1 /* Copyright (C) 2012-2018 Kentoku Shiba
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
13 along with this program; if not, write to the Free Software
14 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
15
16 #define MYSQL_SERVER 1
17 #include <my_global.h>
18 #include "mysql_version.h"
19 #include "spd_environ.h"
20 #if MYSQL_VERSION_ID < 50500
21 #include "mysql_priv.h"
22 #include <mysql/plugin.h>
23 #else
24 #include "sql_priv.h"
25 #include "probes_mysql.h"
26 #include "sql_analyse.h"
27 #endif
28
29 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
30 #include "spd_err.h"
31 #include "spd_param.h"
32 #include "spd_db_include.h"
33 #include "spd_include.h"
34 #include "spd_db_handlersocket.h"
35 #include "ha_spider.h"
36 #include "spd_db_conn.h"
37 #include "spd_trx.h"
38 #include "spd_conn.h"
39 #include "spd_malloc.h"
40
41 extern handlerton *spider_hton_ptr;
42 extern HASH spider_open_connections;
43 extern HASH spider_ipport_conns;
44 extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE];
45 extern const char spider_dig_upper[];
46
47 #define SPIDER_SQL_INTERVAL_STR " + interval "
48 #define SPIDER_SQL_INTERVAL_LEN (sizeof(SPIDER_SQL_INTERVAL_STR) - 1)
49 #define SPIDER_SQL_NEGINTERVAL_STR " - interval "
50 #define SPIDER_SQL_NEGINTERVAL_LEN (sizeof(SPIDER_SQL_NEGINTERVAL_STR) - 1)
51
52 #define SPIDER_SQL_NAME_QUOTE_STR ""
53 #define SPIDER_SQL_NAME_QUOTE_LEN (sizeof(SPIDER_SQL_NAME_QUOTE_STR) - 1)
54 static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR;
55
56 #define SPIDER_SQL_TYPE_FULL_HS (SPIDER_SQL_TYPE_SELECT_HS | \
57 SPIDER_SQL_TYPE_INSERT_HS | SPIDER_SQL_TYPE_UPDATE_HS | \
58 SPIDER_SQL_TYPE_DELETE_HS | SPIDER_SQL_TYPE_OTHER_HS)
59
60 static uchar SPIDER_SQL_LINESTRING_HEAD_STR[] =
61 {0x00,0x00,0x00,0x00,0x01,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00};
62 #define SPIDER_SQL_LINESTRING_HEAD_LEN sizeof(SPIDER_SQL_LINESTRING_HEAD_STR)
63
64 static const char *spider_db_timefunc_interval_str[] =
65 {
66 " year", " quarter", " month", " week", " day",
67 " hour", " minute", " second", " microsecond",
68 " year_month", " day_hour", " day_minute",
69 " day_second", " hour_minute", " hour_second",
70 " minute_second", " day_microsecond", " hour_microsecond",
71 " minute_microsecond", " second_microsecond"
72 };
73
74 static SPIDER_HS_STRING_REF spider_null_string_ref = SPIDER_HS_STRING_REF();
75
spider_handlersocket_init()76 int spider_handlersocket_init()
77 {
78 DBUG_ENTER("spider_handlersocket_init");
79 DBUG_RETURN(0);
80 }
81
spider_handlersocket_deinit()82 int spider_handlersocket_deinit()
83 {
84 DBUG_ENTER("spider_handlersocket_deinit");
85 DBUG_RETURN(0);
86 }
87
spider_handlersocket_create_share(SPIDER_SHARE * share)88 spider_db_share *spider_handlersocket_create_share(
89 SPIDER_SHARE *share
90 ) {
91 DBUG_ENTER("spider_handlersocket_create_share");
92 DBUG_RETURN(new spider_handlersocket_share(share));
93 }
94
spider_handlersocket_create_handler(ha_spider * spider,spider_db_share * db_share)95 spider_db_handler *spider_handlersocket_create_handler(
96 ha_spider *spider,
97 spider_db_share *db_share
98 ) {
99 DBUG_ENTER("spider_handlersocket_create_handler");
100 DBUG_RETURN(new spider_handlersocket_handler(spider,
101 (spider_handlersocket_share *) db_share));
102 }
103
spider_handlersocket_create_conn(SPIDER_CONN * conn)104 SPIDER_DB_CONN *spider_handlersocket_create_conn(
105 SPIDER_CONN *conn
106 ) {
107 DBUG_ENTER("spider_handlersocket_create_conn");
108 DBUG_RETURN(new spider_db_handlersocket(conn));
109 }
110
spider_handlersocket_support_direct_join()111 bool spider_handlersocket_support_direct_join(
112 ) {
113 DBUG_ENTER("spider_handlersocket_support_direct_join");
114 DBUG_RETURN(FALSE);
115 }
116
117 spider_db_handlersocket_util spider_db_handlersocket_utility;
118
119 SPIDER_DBTON spider_dbton_handlersocket = {
120 0,
121 SPIDER_DB_WRAPPER_MYSQL,
122 SPIDER_DB_ACCESS_TYPE_NOSQL,
123 spider_handlersocket_init,
124 spider_handlersocket_deinit,
125 spider_handlersocket_create_share,
126 spider_handlersocket_create_handler,
127 NULL,
128 spider_handlersocket_create_conn,
129 spider_handlersocket_support_direct_join,
130 &spider_db_handlersocket_utility
131 };
132
133 #ifndef HANDLERSOCKET_MYSQL_UTIL
spider_db_hs_string_ref_buffer()134 spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer()
135 {
136 DBUG_ENTER("spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer");
137 DBUG_PRINT("info",("spider this=%p", this));
138 DBUG_VOID_RETURN;
139 }
140
~spider_db_hs_string_ref_buffer()141 spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer()
142 {
143 DBUG_ENTER("spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer");
144 DBUG_PRINT("info",("spider this=%p", this));
145 DBUG_VOID_RETURN;
146 }
147
init()148 int spider_db_hs_string_ref_buffer::init()
149 {
150 DBUG_ENTER("spider_db_hs_string_ref_buffer::init");
151 DBUG_PRINT("info",("spider this=%p", this));
152 DBUG_RETURN(0);
153 }
154
clear()155 void spider_db_hs_string_ref_buffer::clear()
156 {
157 DBUG_ENTER("spider_db_hs_string_ref_buffer::clear");
158 DBUG_PRINT("info",("spider this=%p", this));
159 hs_conds.clear();
160 DBUG_VOID_RETURN;
161 }
162
push_back(SPIDER_HS_STRING_REF & cond)163 int spider_db_hs_string_ref_buffer::push_back(
164 SPIDER_HS_STRING_REF &cond
165 ) {
166 DBUG_ENTER("spider_db_hs_string_ref_buffer::push_back");
167 DBUG_PRINT("info",("spider this=%p", this));
168 hs_conds.push_back(cond);
169 DBUG_RETURN(0);
170 }
171
ptr()172 SPIDER_HS_STRING_REF *spider_db_hs_string_ref_buffer::ptr()
173 {
174 DBUG_ENTER("spider_db_hs_string_ref_buffer::ptr");
175 DBUG_PRINT("info",("spider this=%p", this));
176 DBUG_RETURN(&hs_conds[0]);
177 }
178
size()179 uint spider_db_hs_string_ref_buffer::size()
180 {
181 DBUG_ENTER("spider_db_hs_string_ref_buffer::size");
182 DBUG_PRINT("info",("spider this=%p", this));
183 DBUG_RETURN((uint) hs_conds.size());
184 }
185 #else
spider_db_hs_string_ref_buffer()186 spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer() : hs_da_init(FALSE)
187 {
188 DBUG_ENTER("spider_db_hs_string_ref_buffer::spider_db_hs_string_ref_buffer");
189 DBUG_PRINT("info",("spider this=%p", this));
190 DBUG_VOID_RETURN;
191 }
192
~spider_db_hs_string_ref_buffer()193 spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer()
194 {
195 DBUG_ENTER("spider_db_hs_string_ref_buffer::~spider_db_hs_string_ref_buffer");
196 DBUG_PRINT("info",("spider this=%p", this));
197 if (hs_da_init)
198 {
199 spider_free_mem_calc(spider_current_trx,
200 hs_conds_id, hs_conds.max_element * hs_conds.size_of_element);
201 delete_dynamic(&hs_conds);
202 }
203 DBUG_VOID_RETURN;
204 }
205
init()206 int spider_db_hs_string_ref_buffer::init()
207 {
208 DBUG_ENTER("spider_db_hs_string_ref_buffer::init");
209 DBUG_PRINT("info",("spider this=%p", this));
210 if (!hs_da_init)
211 {
212 SPD_INIT_DYNAMIC_ARRAY2(&hs_conds, sizeof(SPIDER_HS_STRING_REF),
213 NULL, 16, 16, MYF(MY_WME));
214 spider_alloc_calc_mem_init(hs_conds, 159);
215 spider_alloc_calc_mem(spider_current_trx,
216 hs_conds, hs_conds.max_element * hs_conds.size_of_element);
217 hs_da_init = TRUE;
218 }
219 DBUG_RETURN(0);
220 }
221
clear()222 void spider_db_hs_string_ref_buffer::clear()
223 {
224 DBUG_ENTER("spider_db_hs_string_ref_buffer::clear");
225 DBUG_PRINT("info",("spider this=%p", this));
226 hs_conds.elements = 0;
227 DBUG_VOID_RETURN;
228 }
229
push_back(SPIDER_HS_STRING_REF & cond)230 int spider_db_hs_string_ref_buffer::push_back(
231 SPIDER_HS_STRING_REF &cond
232 ) {
233 uint old_elements = hs_conds.max_element;
234 DBUG_ENTER("spider_db_hs_string_ref_buffer::push_back");
235 DBUG_PRINT("info",("spider this=%p", this));
236 if (insert_dynamic(&hs_conds, (uchar *) &cond))
237 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
238 if (hs_conds.max_element > old_elements)
239 {
240 spider_alloc_calc_mem(spider_current_trx,
241 hs_conds,
242 (hs_conds.max_element - old_elements) * hs_conds.size_of_element);
243 }
244 DBUG_RETURN(0);
245 }
246
ptr()247 SPIDER_HS_STRING_REF *spider_db_hs_string_ref_buffer::ptr()
248 {
249 DBUG_ENTER("spider_db_hs_string_ref_buffer::ptr");
250 DBUG_PRINT("info",("spider this=%p", this));
251 DBUG_RETURN((SPIDER_HS_STRING_REF *) hs_conds.buffer);
252 }
253
size()254 uint spider_db_hs_string_ref_buffer::size()
255 {
256 DBUG_ENTER("spider_db_hs_string_ref_buffer::size");
257 DBUG_PRINT("info",("spider this=%p", this));
258 DBUG_RETURN(hs_conds.elements);
259 }
260 #endif
261
spider_db_hs_str_buffer()262 spider_db_hs_str_buffer::spider_db_hs_str_buffer() : hs_da_init(FALSE)
263 {
264 DBUG_ENTER("spider_db_hs_str_buffer::spider_db_hs_str_buffer");
265 DBUG_PRINT("info",("spider this=%p", this));
266 DBUG_VOID_RETURN;
267 }
268
~spider_db_hs_str_buffer()269 spider_db_hs_str_buffer::~spider_db_hs_str_buffer()
270 {
271 DBUG_ENTER("spider_db_hs_str_buffer::~spider_db_hs_str_buffer");
272 DBUG_PRINT("info",("spider this=%p", this));
273 if (hs_da_init)
274 {
275 spider_free_mem_calc(spider_current_trx,
276 hs_conds_id, hs_conds.max_element * hs_conds.size_of_element);
277 delete_dynamic(&hs_conds);
278 }
279 DBUG_VOID_RETURN;
280 }
281
init()282 int spider_db_hs_str_buffer::init()
283 {
284 DBUG_ENTER("spider_db_hs_str_buffer::init");
285 DBUG_PRINT("info",("spider this=%p", this));
286 if (!hs_da_init)
287 {
288 SPD_INIT_DYNAMIC_ARRAY2(&hs_conds, sizeof(spider_string *),
289 NULL, 16, 16, MYF(MY_WME));
290 spider_alloc_calc_mem_init(hs_conds, 160);
291 spider_alloc_calc_mem(spider_current_trx,
292 hs_conds, hs_conds.max_element * hs_conds.size_of_element);
293 hs_da_init = TRUE;
294 }
295 DBUG_RETURN(0);
296 }
297
clear()298 void spider_db_hs_str_buffer::clear()
299 {
300 uint i;
301 spider_string *element;
302 DBUG_ENTER("spider_db_hs_str_buffer::clear");
303 DBUG_PRINT("info",("spider this=%p", this));
304 for (i = 0; i < hs_conds.elements; i++)
305 {
306 get_dynamic(&hs_conds, (uchar *) &element, i);
307 element->free();
308 spider_free(spider_current_trx, element, MYF(0));
309 }
310 hs_conds.elements = 0;
311 DBUG_VOID_RETURN;
312 }
313
add(uint * strs_pos,const char * str,uint str_len)314 spider_string *spider_db_hs_str_buffer::add(
315 uint *strs_pos,
316 const char *str,
317 uint str_len
318 ) {
319 spider_string *element;
320 DBUG_ENTER("spider_db_hs_str_buffer::add");
321 DBUG_PRINT("info",("spider this=%p", this));
322 if (hs_conds.elements <= *strs_pos + 1)
323 {
324 if (!(element = (spider_string *) spider_malloc(spider_current_trx, 8,
325 sizeof(spider_string), MYF(MY_WME | MY_ZEROFILL))))
326 DBUG_RETURN(NULL);
327 element->init_calc_mem(98);
328 element->set_charset(&my_charset_bin);
329 if ((element->reserve(str_len + 1)))
330 {
331 spider_free(spider_current_trx, element, MYF(0));
332 DBUG_RETURN(NULL);
333 }
334 element->q_append(str, str_len);
335 uint old_elements = hs_conds.max_element;
336 if (insert_dynamic(&hs_conds, (uchar *) &element))
337 {
338 element->free();
339 spider_free(spider_current_trx, element, MYF(0));
340 DBUG_RETURN(NULL);
341 }
342 if (hs_conds.max_element > old_elements)
343 {
344 spider_alloc_calc_mem(spider_current_trx,
345 hs_conds,
346 (hs_conds.max_element - old_elements) *
347 hs_conds.size_of_element);
348 }
349 } else {
350 element = ((spider_string **) hs_conds.buffer)[*strs_pos];
351 element->length(0);
352 if ((element->reserve(str_len + 1)))
353 DBUG_RETURN(NULL);
354 element->q_append(str, str_len);
355 }
356 (*strs_pos)++;
357 DBUG_RETURN(element);
358 }
359
spider_db_handlersocket_row()360 spider_db_handlersocket_row::spider_db_handlersocket_row() :
361 spider_db_row(spider_dbton_handlersocket.dbton_id),
362 hs_row(NULL), field_count(0), row_size(0), cloned(FALSE)
363 {
364 DBUG_ENTER("spider_db_handlersocket_row::spider_db_handlersocket_row");
365 DBUG_PRINT("info",("spider this=%p", this));
366 DBUG_VOID_RETURN;
367 }
368
~spider_db_handlersocket_row()369 spider_db_handlersocket_row::~spider_db_handlersocket_row()
370 {
371 DBUG_ENTER("spider_db_handlersocket_row::~spider_db_handlersocket_row");
372 DBUG_PRINT("info",("spider this=%p", this));
373 if (cloned)
374 {
375 spider_free(spider_current_trx, hs_row_first, MYF(0));
376 }
377 DBUG_VOID_RETURN;
378 }
379
store_to_field(Field * field,CHARSET_INFO * access_charset)380 int spider_db_handlersocket_row::store_to_field(
381 Field *field,
382 CHARSET_INFO *access_charset
383 ) {
384 DBUG_ENTER("spider_db_handlersocket_row::store_to_field");
385 DBUG_PRINT("info",("spider this=%p", this));
386 if (!hs_row->begin())
387 {
388 DBUG_PRINT("info", ("spider field is null"));
389 field->set_null();
390 field->reset();
391 } else {
392 #ifndef DBUG_OFF
393 char buf[MAX_FIELD_WIDTH];
394 spider_string tmp_str(buf, MAX_FIELD_WIDTH, field->charset());
395 tmp_str.init_calc_mem(119);
396 tmp_str.length(0);
397 tmp_str.append(hs_row->begin(), hs_row->size(), &my_charset_bin);
398 DBUG_PRINT("info", ("spider val=%s", tmp_str.c_ptr_safe()));
399 #endif
400 field->set_notnull();
401 if (field->flags & BLOB_FLAG)
402 {
403 DBUG_PRINT("info", ("spider blob field"));
404 ((Field_blob *)field)->set_ptr(
405 hs_row->size(), (uchar *) hs_row->begin());
406 } else
407 field->store(hs_row->begin(), hs_row->size(), &my_charset_bin);
408 }
409 DBUG_RETURN(0);
410 }
411
append_to_str(spider_string * str)412 int spider_db_handlersocket_row::append_to_str(
413 spider_string *str
414 ) {
415 DBUG_ENTER("spider_db_handlersocket_row::append_to_str");
416 DBUG_PRINT("info",("spider this=%p", this));
417 if (str->reserve(hs_row->size()))
418 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
419 str->q_append(hs_row->begin(), hs_row->size());
420 DBUG_RETURN(0);
421 }
422
append_escaped_to_str(spider_string * str,uint dbton_id)423 int spider_db_handlersocket_row::append_escaped_to_str(
424 spider_string *str,
425 uint dbton_id
426 ) {
427 DBUG_ENTER("spider_db_handlersocket_row::append_escaped_to_str");
428 DBUG_PRINT("info",("spider this=%p", this));
429 spider_string tmp_str(hs_row->begin(), hs_row->size() + 1, &my_charset_bin);
430 tmp_str.init_calc_mem(172);
431 tmp_str.length(hs_row->size());
432 if (str->reserve(hs_row->size() * 2 + 2))
433 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
434 spider_dbton[dbton_id].db_util->append_escaped_util(str, tmp_str.get_str());
435 str->mem_calc();
436 DBUG_RETURN(0);
437 }
438
first()439 void spider_db_handlersocket_row::first()
440 {
441 DBUG_ENTER("spider_db_handlersocket_row::first");
442 DBUG_PRINT("info",("spider this=%p", this));
443 hs_row = hs_row_first;
444 DBUG_VOID_RETURN;
445 }
446
next()447 void spider_db_handlersocket_row::next()
448 {
449 DBUG_ENTER("spider_db_handlersocket_row::next");
450 DBUG_PRINT("info",("spider this=%p", this));
451 hs_row++;
452 DBUG_VOID_RETURN;
453 }
454
is_null()455 bool spider_db_handlersocket_row::is_null()
456 {
457 DBUG_ENTER("spider_db_handlersocket_row::is_null");
458 DBUG_PRINT("info",("spider this=%p", this));
459 DBUG_RETURN(!hs_row->begin());
460 }
461
val_int()462 int spider_db_handlersocket_row::val_int()
463 {
464 DBUG_ENTER("spider_db_handlersocket_row::val_int");
465 DBUG_PRINT("info",("spider this=%p", this));
466 DBUG_RETURN(atoi(hs_row->begin()));
467 }
468
val_real()469 double spider_db_handlersocket_row::val_real()
470 {
471 DBUG_ENTER("spider_db_handlersocket_row::val_real");
472 DBUG_PRINT("info",("spider this=%p", this));
473 DBUG_RETURN(hs_row->begin() ? my_atof(hs_row->begin()) : 0.0);
474 }
475
val_decimal(my_decimal * decimal_value,CHARSET_INFO * access_charset)476 my_decimal *spider_db_handlersocket_row::val_decimal(
477 my_decimal *decimal_value,
478 CHARSET_INFO *access_charset
479 ) {
480 DBUG_ENTER("spider_db_handlersocket_row::val_decimal");
481 DBUG_PRINT("info",("spider this=%p", this));
482 if (!hs_row->begin())
483 DBUG_RETURN(NULL);
484
485 #ifdef SPIDER_HAS_DECIMAL_OPERATION_RESULTS_VALUE_TYPE
486 decimal_operation_results(str2my_decimal(0, hs_row->begin(), hs_row->size(),
487 access_charset, decimal_value), "", "");
488 #else
489 decimal_operation_results(str2my_decimal(0, hs_row->begin(), hs_row->size(),
490 access_charset, decimal_value));
491 #endif
492
493 DBUG_RETURN(decimal_value);
494 }
495
clone()496 SPIDER_DB_ROW *spider_db_handlersocket_row::clone()
497 {
498 spider_db_handlersocket_row *clone_row;
499 char *tmp_char;
500 uint i;
501 DBUG_ENTER("spider_db_handlersocket_row::clone");
502 DBUG_PRINT("info",("spider this=%p", this));
503 if (!(clone_row = new spider_db_handlersocket_row(dbton_id)))
504 {
505 DBUG_RETURN(NULL);
506 }
507 if (!spider_bulk_malloc(spider_current_trx, 169, MYF(MY_WME),
508 &clone_row->hs_row, sizeof(SPIDER_HS_STRING_REF) * field_count,
509 &tmp_char, row_size,
510 NullS)
511 ) {
512 delete clone_row;
513 DBUG_RETURN(NULL);
514 }
515 for (i = 0; i < field_count; i++)
516 {
517 memcpy(tmp_char, hs_row_first[i].begin(), hs_row_first[i].size());
518 clone_row->hs_row[i].set(tmp_char, hs_row_first[i].size());
519 tmp_char += hs_row_first[i].size();
520 }
521 clone_row->hs_row_first = clone_row->hs_row;
522 clone_row->cloned = TRUE;;
523 clone_row->row_size = row_size;;
524 DBUG_RETURN(NULL);
525 }
526
store_to_tmp_table(TABLE * tmp_table,spider_string * str)527 int spider_db_handlersocket_row::store_to_tmp_table(
528 TABLE *tmp_table,
529 spider_string *str
530 ) {
531 uint i;
532 SPIDER_HS_STRING_REF *tmp_hs_row = hs_row;
533 DBUG_ENTER("spider_db_handlersocket_row::store_to_tmp_table");
534 DBUG_PRINT("info",("spider this=%p", this));
535 str->length(0);
536 for (i = 0; i < field_count; i++)
537 {
538 if (tmp_hs_row->begin())
539 {
540 if (str->reserve(tmp_hs_row->size()))
541 {
542 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
543 }
544 str->q_append(tmp_hs_row->begin(), tmp_hs_row->size());
545 }
546 tmp_hs_row++;
547 }
548 tmp_table->field[0]->set_notnull();
549 tmp_table->field[0]->store(
550 (const char *) hs_row,
551 sizeof(SPIDER_HS_STRING_REF) * field_count, &my_charset_bin);
552 tmp_table->field[1]->set_notnull();
553 tmp_table->field[1]->store(
554 str->ptr(), str->length(), &my_charset_bin);
555 tmp_table->field[2]->set_null();
556 DBUG_RETURN(tmp_table->file->ha_write_row(tmp_table->record[0]));
557 }
558
get_byte_size()559 uint spider_db_handlersocket_row::get_byte_size()
560 {
561 DBUG_ENTER("spider_db_handlersocket_row::get_byte_size");
562 DBUG_PRINT("info",("spider this=%p", this));
563 DBUG_RETURN(row_size);
564 }
565
566
spider_db_handlersocket_result_buffer()567 spider_db_handlersocket_result_buffer::spider_db_handlersocket_result_buffer(
568 ) : spider_db_result_buffer()
569 {
570 DBUG_ENTER("spider_db_handlersocket_result_buffer::spider_db_handlersocket_result_buffer");
571 DBUG_PRINT("info",("spider this=%p", this));
572 DBUG_VOID_RETURN;
573 }
574
~spider_db_handlersocket_result_buffer()575 spider_db_handlersocket_result_buffer::~spider_db_handlersocket_result_buffer()
576 {
577 DBUG_ENTER(
578 "spider_db_handlersocket_result_buffer::~spider_db_handlersocket_result_buffer");
579 DBUG_PRINT("info",("spider this=%p", this));
580 DBUG_VOID_RETURN;
581 }
582
clear()583 void spider_db_handlersocket_result_buffer::clear()
584 {
585 DBUG_ENTER("spider_db_handlersocket_result_buffer::clear");
586 DBUG_PRINT("info",("spider this=%p", this));
587 hs_result.readbuf.clear();
588 DBUG_VOID_RETURN;
589 }
590
check_size(longlong size)591 bool spider_db_handlersocket_result_buffer::check_size(
592 longlong size
593 ) {
594 DBUG_ENTER("spider_db_handlersocket_result_buffer::check_size");
595 DBUG_PRINT("info",("spider this=%p", this));
596 if ((uint) hs_result.readbuf.real_size() > size)
597 {
598 hs_result.readbuf.real_free();
599 DBUG_RETURN(TRUE);
600 }
601 DBUG_RETURN(FALSE);
602 }
603
spider_db_handlersocket_result(SPIDER_DB_CONN * in_db_conn)604 spider_db_handlersocket_result::spider_db_handlersocket_result(
605 SPIDER_DB_CONN *in_db_conn
606 ) : spider_db_result(in_db_conn), row(in_db_conn->dbton_id)
607 {
608 DBUG_ENTER("spider_db_handlersocket_result::spider_db_handlersocket_result");
609 DBUG_PRINT("info",("spider this=%p", this));
610 DBUG_VOID_RETURN;
611 }
612
~spider_db_handlersocket_result()613 spider_db_handlersocket_result::~spider_db_handlersocket_result()
614 {
615 DBUG_ENTER(
616 "spider_db_handlersocket_result::~spider_db_handlersocket_result");
617 DBUG_PRINT("info",("spider this=%p", this));
618 DBUG_VOID_RETURN;
619 }
620
has_result()621 bool spider_db_handlersocket_result::has_result()
622 {
623 DBUG_ENTER("spider_db_handlersocket_result::has_result");
624 DBUG_PRINT("info",("spider this=%p", this));
625 DBUG_RETURN(((*hs_conn_p)->get_response_end_offset() > 0));
626 }
627
free_result()628 void spider_db_handlersocket_result::free_result()
629 {
630 DBUG_ENTER("spider_db_handlersocket_result::free_result");
631 DBUG_PRINT("info",("spider this=%p", this));
632 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
633 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
634 (*hs_conn_p)->get_num_req_bufd()));
635 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
636 (*hs_conn_p)->get_num_req_sent()));
637 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
638 (*hs_conn_p)->get_num_req_rcvd()));
639 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
640 (*hs_conn_p)->get_response_end_offset()));
641 if ((*hs_conn_p)->get_response_end_offset() > 0)
642 {
643 (*hs_conn_p)->response_buf_remove();
644 if ((*hs_conn_p)->get_error_code())
645 {
646 DBUG_PRINT("info",("spider hs %d %s",
647 (*hs_conn_p)->get_error_code(),
648 (*hs_conn_p)->get_error().ptr()));
649 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
650 }
651 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
652 (*hs_conn_p)->get_num_req_bufd()));
653 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
654 (*hs_conn_p)->get_num_req_sent()));
655 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
656 (*hs_conn_p)->get_num_req_rcvd()));
657 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
658 (*hs_conn_p)->get_response_end_offset()));
659 }
660 DBUG_VOID_RETURN;
661 }
662
current_row()663 SPIDER_DB_ROW *spider_db_handlersocket_result::current_row()
664 {
665 DBUG_ENTER("spider_db_handlersocket_result::current_row");
666 DBUG_PRINT("info",("spider this=%p", this));
667 DBUG_RETURN((SPIDER_DB_ROW *) row.clone());
668 }
669
fetch_row()670 SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row()
671 {
672 DBUG_ENTER("spider_db_handlersocket_result::fetch_row");
673 DBUG_PRINT("info",("spider this=%p", this));
674 if (!(row.hs_row = (SPIDER_HS_STRING_REF *)
675 (*hs_conn_p)->get_next_row()))
676 {
677 store_error_num = HA_ERR_END_OF_FILE;
678 DBUG_RETURN(NULL);
679 }
680 row.field_count = field_count;
681 row.hs_row_first = row.hs_row;
682 row.row_size = (*hs_conn_p)->get_row_size();
683 DBUG_RETURN((SPIDER_DB_ROW *) &row);
684 }
685
fetch_row_from_result_buffer(spider_db_result_buffer * spider_res_buf)686 SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row_from_result_buffer(
687 spider_db_result_buffer *spider_res_buf
688 ) {
689 spider_db_handlersocket_result_buffer *hs_res_buf;
690 DBUG_ENTER("spider_db_handlersocket_result::fetch_row_from_result_buffer");
691 DBUG_PRINT("info",("spider this=%p", this));
692 hs_res_buf = (spider_db_handlersocket_result_buffer *) spider_res_buf;
693 if (!(row.hs_row = (SPIDER_HS_STRING_REF *)
694 (*hs_conn_p)->get_next_row_from_result(hs_res_buf->hs_result)))
695 {
696 store_error_num = HA_ERR_END_OF_FILE;
697 DBUG_RETURN(NULL);
698 }
699 row.field_count = field_count;
700 row.hs_row_first = row.hs_row;
701 row.row_size = (*hs_conn_p)->get_row_size_from_result(hs_res_buf->hs_result);
702 DBUG_RETURN((SPIDER_DB_ROW *) &row);
703 }
704
fetch_row_from_tmp_table(TABLE * tmp_table)705 SPIDER_DB_ROW *spider_db_handlersocket_result::fetch_row_from_tmp_table(
706 TABLE *tmp_table
707 ) {
708 uint i;
709 spider_string tmp_str1, tmp_str2;
710 const char *row_ptr;
711 SPIDER_HS_STRING_REF *tmp_hs_row;
712 uint field_count;
713 DBUG_ENTER("spider_db_handlersocket_result::fetch_row_from_tmp_table");
714 DBUG_PRINT("info",("spider this=%p", this));
715 tmp_str1.init_calc_mem(171);
716 tmp_str2.init_calc_mem(173);
717 tmp_table->field[0]->val_str(tmp_str1.get_str());
718 tmp_table->field[1]->val_str(tmp_str2.get_str());
719 tmp_str1.mem_calc();
720 tmp_str2.mem_calc();
721 row_ptr = tmp_str2.ptr();
722 tmp_hs_row = (SPIDER_HS_STRING_REF *) tmp_str1.ptr();
723 field_count = tmp_str1.length() / sizeof(SPIDER_HS_STRING_REF);
724 row.hs_row = tmp_hs_row;
725 row.field_count = field_count;
726 row.hs_row_first = row.hs_row;
727 for (i = 0; i < field_count; i++)
728 {
729 if (tmp_hs_row->begin())
730 {
731 uint length = tmp_hs_row->size();
732 tmp_hs_row->set(row_ptr, length);
733 row_ptr += length;
734 }
735 tmp_hs_row++;
736 }
737 row.row_size = row_ptr - tmp_str2.ptr();
738 DBUG_RETURN((SPIDER_DB_ROW *) &row);
739 }
740
fetch_table_status(int mode,ha_rows & records,ulong & mean_rec_length,ulonglong & data_file_length,ulonglong & max_data_file_length,ulonglong & index_file_length,ulonglong & auto_increment_value,time_t & create_time,time_t & update_time,time_t & check_time)741 int spider_db_handlersocket_result::fetch_table_status(
742 int mode,
743 ha_rows &records,
744 ulong &mean_rec_length,
745 ulonglong &data_file_length,
746 ulonglong &max_data_file_length,
747 ulonglong &index_file_length,
748 ulonglong &auto_increment_value,
749 time_t &create_time,
750 time_t &update_time,
751 time_t &check_time
752 ) {
753 DBUG_ENTER("spider_db_handlersocket_result::fetch_table_status");
754 DBUG_PRINT("info",("spider this=%p", this));
755 DBUG_ASSERT(0);
756 DBUG_RETURN(0);
757 }
758
fetch_table_records(int mode,ha_rows & records)759 int spider_db_handlersocket_result::fetch_table_records(
760 int mode,
761 ha_rows &records
762 ) {
763 DBUG_ENTER("spider_db_handlersocket_result::fetch_table_records");
764 DBUG_PRINT("info",("spider this=%p", this));
765 DBUG_ASSERT(0);
766 DBUG_RETURN(0);
767 }
768
fetch_table_cardinality(int mode,TABLE * table,longlong * cardinality,uchar * cardinality_upd,int bitmap_size)769 int spider_db_handlersocket_result::fetch_table_cardinality(
770 int mode,
771 TABLE *table,
772 longlong *cardinality,
773 uchar *cardinality_upd,
774 int bitmap_size
775 ) {
776 DBUG_ENTER("spider_db_handlersocket_result::fetch_table_cardinality");
777 DBUG_PRINT("info",("spider this=%p", this));
778 DBUG_ASSERT(0);
779 DBUG_RETURN(0);
780 }
781
fetch_table_mon_status(int & status)782 int spider_db_handlersocket_result::fetch_table_mon_status(
783 int &status
784 ) {
785 DBUG_ENTER("spider_db_handlersocket_result::fetch_table_mon_status");
786 DBUG_PRINT("info",("spider this=%p", this));
787 DBUG_ASSERT(0);
788 DBUG_RETURN(0);
789 }
790
num_rows()791 longlong spider_db_handlersocket_result::num_rows()
792 {
793 DBUG_ENTER("spider_db_handlersocket_result::num_rows");
794 DBUG_PRINT("info",("spider this=%p", this));
795 DBUG_RETURN((longlong) 0);
796 }
797
num_fields()798 uint spider_db_handlersocket_result::num_fields()
799 {
800 DBUG_ENTER("spider_db_handlersocket_result::num_fields");
801 DBUG_PRINT("info",("spider this=%p", this));
802 DBUG_RETURN(field_count);
803 }
804
move_to_pos(longlong pos)805 void spider_db_handlersocket_result::move_to_pos(
806 longlong pos
807 ) {
808 DBUG_ENTER("spider_db_handlersocket_result::move_to_pos");
809 DBUG_PRINT("info",("spider this=%p", this));
810 DBUG_ASSERT(0);
811 DBUG_VOID_RETURN;
812 }
813
get_errno()814 int spider_db_handlersocket_result::get_errno()
815 {
816 DBUG_ENTER("spider_db_handlersocket_result::get_errno");
817 DBUG_PRINT("info",("spider this=%p", this));
818 DBUG_PRINT("info",("spider store_error_num=%d", store_error_num));
819 DBUG_RETURN(store_error_num);
820 }
821
822 #ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
fetch_columns_for_discover_table_structure(spider_string * str,CHARSET_INFO * access_charset)823 int spider_db_handlersocket_result::fetch_columns_for_discover_table_structure(
824 spider_string *str,
825 CHARSET_INFO *access_charset
826 ) {
827 DBUG_ENTER("spider_db_handlersocket_result::fetch_columns_for_discover_table_structure");
828 DBUG_PRINT("info",("spider this=%p", this));
829 DBUG_RETURN(HA_ERR_WRONG_COMMAND);
830 }
831
fetch_index_for_discover_table_structure(spider_string * str,CHARSET_INFO * access_charset)832 int spider_db_handlersocket_result::fetch_index_for_discover_table_structure(
833 spider_string *str,
834 CHARSET_INFO *access_charset
835 ) {
836 DBUG_ENTER("spider_db_handlersocket_result::fetch_index_for_discover_table_structure");
837 DBUG_PRINT("info",("spider this=%p", this));
838 DBUG_RETURN(HA_ERR_WRONG_COMMAND);
839 }
840
fetch_table_for_discover_table_structure(spider_string * str,SPIDER_SHARE * spider_share,CHARSET_INFO * access_charset)841 int spider_db_handlersocket_result::fetch_table_for_discover_table_structure(
842 spider_string *str,
843 SPIDER_SHARE *spider_share,
844 CHARSET_INFO *access_charset
845 ) {
846 DBUG_ENTER("spider_db_handlersocket_result::fetch_table_for_discover_table_structure");
847 DBUG_PRINT("info",("spider this=%p", this));
848 DBUG_RETURN(HA_ERR_WRONG_COMMAND);
849 }
850 #endif
851
spider_db_handlersocket(SPIDER_CONN * conn)852 spider_db_handlersocket::spider_db_handlersocket(
853 SPIDER_CONN *conn
854 ) : spider_db_conn(conn),
855 handler_open_array_inited(FALSE),
856 request_key_req_first(NULL),
857 request_key_req_last(NULL),
858 request_key_snd_first(NULL),
859 request_key_snd_last(NULL),
860 request_key_reuse_first(NULL),
861 request_key_reuse_last(NULL)
862 {
863 DBUG_ENTER("spider_db_handlersocket::spider_db_handlersocket");
864 DBUG_PRINT("info",("spider this=%p", this));
865 #ifndef HANDLERSOCKET_MYSQL_UTIL
866 #else
867 hs_conn = NULL;
868 #endif
869 DBUG_VOID_RETURN;
870 }
871
~spider_db_handlersocket()872 spider_db_handlersocket::~spider_db_handlersocket()
873 {
874 st_spider_db_request_key *tmp_request_key;
875 DBUG_ENTER("spider_db_handlersocket::~spider_db_handlersocket");
876 DBUG_PRINT("info",("spider this=%p", this));
877 if (handler_open_array_inited)
878 {
879 reset_opened_handler();
880 spider_free_mem_calc(spider_current_trx,
881 handler_open_array_id,
882 handler_open_array.max_element *
883 handler_open_array.size_of_element);
884 delete_dynamic(&handler_open_array);
885 }
886 while (request_key_req_first)
887 {
888 tmp_request_key = request_key_req_first->next;
889 spider_free(spider_current_trx, request_key_req_first, MYF(0));
890 request_key_req_first = tmp_request_key;
891 }
892 while (request_key_snd_first)
893 {
894 tmp_request_key = request_key_snd_first->next;
895 spider_free(spider_current_trx, request_key_snd_first, MYF(0));
896 request_key_snd_first = tmp_request_key;
897 }
898 while (request_key_reuse_first)
899 {
900 tmp_request_key = request_key_reuse_first->next;
901 spider_free(spider_current_trx, request_key_reuse_first, MYF(0));
902 request_key_reuse_first = tmp_request_key;
903 }
904 DBUG_VOID_RETURN;
905 }
906
init()907 int spider_db_handlersocket::init()
908 {
909 DBUG_ENTER("spider_db_handlersocket::init");
910 DBUG_PRINT("info",("spider this=%p", this));
911 if (
912 SPD_INIT_DYNAMIC_ARRAY2(&handler_open_array,
913 sizeof(SPIDER_LINK_FOR_HASH *), NULL, 16, 16, MYF(MY_WME))
914 ) {
915 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
916 }
917 spider_alloc_calc_mem_init(handler_open_array, 79);
918 spider_alloc_calc_mem(spider_current_trx,
919 handler_open_array,
920 handler_open_array.max_element *
921 handler_open_array.size_of_element);
922 handler_open_array_inited = TRUE;
923 DBUG_RETURN(0);
924 }
925
is_connected()926 bool spider_db_handlersocket::is_connected()
927 {
928 DBUG_ENTER("spider_db_handlersocket::is_connected");
929 DBUG_PRINT("info",("spider this=%p", this));
930 #ifndef HANDLERSOCKET_MYSQL_UTIL
931 DBUG_RETURN(hs_conn.operator->());
932 #else
933 DBUG_RETURN(hs_conn);
934 #endif
935 }
936
bg_connect()937 void spider_db_handlersocket::bg_connect()
938 {
939 DBUG_ENTER("spider_db_handlersocket::bg_connect");
940 DBUG_PRINT("info",("spider this=%p", this));
941 DBUG_VOID_RETURN;
942 }
943
connect(char * tgt_host,char * tgt_username,char * tgt_password,long tgt_port,char * tgt_socket,char * server_name,int connect_retry_count,longlong connect_retry_interval)944 int spider_db_handlersocket::connect(
945 char *tgt_host,
946 char *tgt_username,
947 char *tgt_password,
948 long tgt_port,
949 char *tgt_socket,
950 char *server_name,
951 int connect_retry_count,
952 longlong connect_retry_interval
953 ) {
954 DBUG_ENTER("spider_db_handlersocket::connect");
955 DBUG_PRINT("info",("spider this=%p", this));
956 SPIDER_HS_SOCKARGS sockargs;
957 sockargs.timeout = conn->connect_timeout;
958 sockargs.recv_timeout = conn->net_read_timeout;
959 sockargs.send_timeout = conn->net_write_timeout;
960 if (conn->hs_sock)
961 {
962 sockargs.family = AF_UNIX;
963 sockargs.set_unix_domain(conn->hs_sock);
964 } else {
965 char port_str[6];
966 my_sprintf(port_str, (port_str, "%05ld", conn->hs_port));
967 if (sockargs.resolve(conn->tgt_host, port_str) != 0)
968 {
969 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
970 conn->tgt_host);
971 DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
972 }
973 }
974 #ifndef HANDLERSOCKET_MYSQL_UTIL
975 if (!(hs_conn.operator->()))
976 #else
977 if (!(hs_conn))
978 #endif
979 {
980 hs_conn = SPIDER_HS_CONN_CREATE(sockargs);
981 } else {
982 hs_conn->reconnect();
983 spider_db_hs_request_buf_reset(conn);
984 }
985 #ifndef HANDLERSOCKET_MYSQL_UTIL
986 if (!(hs_conn.operator->()))
987 #else
988 if (!(hs_conn))
989 #endif
990 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
991 while (hs_conn->get_error_code())
992 {
993 THD *thd = current_thd;
994 if (
995 !connect_retry_count ||
996 (thd && thd->killed)
997 ) {
998 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
999 conn->tgt_host);
1000 DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
1001 }
1002 connect_retry_count--;
1003 my_sleep((ulong) connect_retry_interval);
1004 hs_conn->reconnect();
1005 }
1006 reset_request_key_req();
1007 reset_request_key_snd();
1008 DBUG_RETURN(0);
1009 }
1010
ping()1011 int spider_db_handlersocket::ping()
1012 {
1013 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1014 DBUG_ENTER("spider_db_handlersocket::ping");
1015 DBUG_PRINT("info",("spider this=%p", this));
1016 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1017 (*hs_conn_p)->get_num_req_bufd()));
1018 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1019 (*hs_conn_p)->get_num_req_sent()));
1020 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1021 (*hs_conn_p)->get_num_req_rcvd()));
1022 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1023 (*hs_conn_p)->get_response_end_offset()));
1024 if ((*hs_conn_p)->reconnect())
1025 {
1026 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1027 (*hs_conn_p)->get_num_req_bufd()));
1028 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1029 (*hs_conn_p)->get_num_req_sent()));
1030 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1031 (*hs_conn_p)->get_num_req_rcvd()));
1032 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1033 (*hs_conn_p)->get_response_end_offset()));
1034 DBUG_RETURN(ER_SPIDER_HS_NUM);
1035 }
1036 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1037 (*hs_conn_p)->get_num_req_bufd()));
1038 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1039 (*hs_conn_p)->get_num_req_sent()));
1040 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1041 (*hs_conn_p)->get_num_req_rcvd()));
1042 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1043 (*hs_conn_p)->get_response_end_offset()));
1044
1045 reset_request_key_req();
1046 reset_request_key_snd();
1047 conn->opened_handlers = 0;
1048 conn->db_conn->reset_opened_handler();
1049 ++conn->connection_id;
1050 DBUG_RETURN(0);
1051 }
1052
bg_disconnect()1053 void spider_db_handlersocket::bg_disconnect()
1054 {
1055 DBUG_ENTER("spider_db_handlersocket::bg_disconnect");
1056 DBUG_PRINT("info",("spider this=%p", this));
1057 DBUG_VOID_RETURN;
1058 }
1059
disconnect()1060 void spider_db_handlersocket::disconnect()
1061 {
1062 DBUG_ENTER("spider_db_handlersocket::disconnect");
1063 DBUG_PRINT("info",("spider this=%p", this));
1064 #ifndef HANDLERSOCKET_MYSQL_UTIL
1065 if (hs_conn.operator->())
1066 #else
1067 DBUG_PRINT("info",("spider hs_conn=%p", hs_conn));
1068 if (hs_conn)
1069 #endif
1070 {
1071 hs_conn->close();
1072 #ifndef HANDLERSOCKET_MYSQL_UTIL
1073 SPIDER_HS_CONN tmp_hs_conn;
1074 tmp_hs_conn = hs_conn;
1075 #else
1076 delete hs_conn;
1077 hs_conn = NULL;
1078 #endif
1079 }
1080 DBUG_VOID_RETURN;
1081 }
1082
set_net_timeout()1083 int spider_db_handlersocket::set_net_timeout()
1084 {
1085 DBUG_ENTER("spider_db_handlersocket::set_net_timeout");
1086 DBUG_PRINT("info",("spider this=%p", this));
1087 DBUG_RETURN(hs_conn->set_timeout(
1088 conn->net_write_timeout,
1089 conn->net_read_timeout
1090 ));
1091 }
1092
exec_query(const char * query,uint length,int quick_mode)1093 int spider_db_handlersocket::exec_query(
1094 const char *query,
1095 uint length,
1096 int quick_mode
1097 ) {
1098 DBUG_ENTER("spider_db_handlersocket::query");
1099 DBUG_PRINT("info",("spider this=%p", this));
1100 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1101 #ifndef HANDLERSOCKET_MYSQL_UTIL
1102 DBUG_PRINT("info", ("spider hs_conn %p", hs_conn.operator->()));
1103 #else
1104 DBUG_PRINT("info", ("spider hs_conn %p", hs_conn));
1105 #endif
1106 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1107 (*hs_conn_p)->get_num_req_bufd()));
1108 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1109 (*hs_conn_p)->get_num_req_sent()));
1110 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1111 (*hs_conn_p)->get_num_req_rcvd()));
1112 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1113 (*hs_conn_p)->get_response_end_offset()));
1114 if (spider_param_general_log())
1115 {
1116 const char *tgt_str = conn->hs_sock ? conn->hs_sock : conn->tgt_host;
1117 uint32 tgt_len = strlen(tgt_str);
1118 spider_string tmp_query_str((*hs_conn_p)->get_writebuf_size() +
1119 conn->tgt_wrapper_length +
1120 tgt_len + (SPIDER_SQL_SPACE_LEN * 2));
1121 tmp_query_str.init_calc_mem(231);
1122 tmp_query_str.length(0);
1123 tmp_query_str.q_append(conn->tgt_wrapper, conn->tgt_wrapper_length);
1124 tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1125 tmp_query_str.q_append(tgt_str, tgt_len);
1126 tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1127 tmp_query_str.q_append((*hs_conn_p)->get_writebuf_begin(),
1128 (*hs_conn_p)->get_writebuf_size());
1129 general_log_write(current_thd, COM_QUERY, tmp_query_str.ptr(),
1130 tmp_query_str.length());
1131 }
1132 if ((*hs_conn_p)->request_send() < 0)
1133 {
1134 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1135 (*hs_conn_p)->get_num_req_bufd()));
1136 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1137 (*hs_conn_p)->get_num_req_sent()));
1138 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1139 (*hs_conn_p)->get_num_req_rcvd()));
1140 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1141 (*hs_conn_p)->get_response_end_offset()));
1142 DBUG_RETURN(ER_SPIDER_HS_NUM);
1143 }
1144 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1145 (*hs_conn_p)->get_num_req_bufd()));
1146 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1147 (*hs_conn_p)->get_num_req_sent()));
1148 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1149 (*hs_conn_p)->get_num_req_rcvd()));
1150 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1151 (*hs_conn_p)->get_response_end_offset()));
1152 move_request_key_to_snd();
1153 DBUG_RETURN(0);
1154 }
1155
get_errno()1156 int spider_db_handlersocket::get_errno()
1157 {
1158 DBUG_ENTER("spider_db_handlersocket::get_errno");
1159 DBUG_PRINT("info",("spider this=%p", this));
1160 stored_error = hs_conn->get_error_code();
1161 DBUG_PRINT("info",("spider stored_error=%d", stored_error));
1162 DBUG_RETURN(stored_error);
1163 }
1164
get_error()1165 const char *spider_db_handlersocket::get_error()
1166 {
1167 const char *error_ptr;
1168 DBUG_ENTER("spider_db_handlersocket::get_error");
1169 DBUG_PRINT("info",("spider this=%p", this));
1170 #ifndef HANDLERSOCKET_MYSQL_UTIL
1171 error_ptr = hs_conn->get_error().c_str();
1172 #else
1173 error_ptr = hs_conn->get_error().c_ptr();
1174 #endif
1175 DBUG_PRINT("info",("spider error=%s", error_ptr));
1176 DBUG_RETURN(error_ptr);
1177 }
1178
is_server_gone_error(int error_num)1179 bool spider_db_handlersocket::is_server_gone_error(
1180 int error_num
1181 ) {
1182 bool server_gone;
1183 DBUG_ENTER("spider_db_handlersocket::is_server_gone_error");
1184 DBUG_PRINT("info",("spider this=%p", this));
1185 server_gone = (hs_conn->get_error_code() < 0);
1186 DBUG_PRINT("info",("spider server_gone=%s", server_gone ? "TRUE" : "FALSE"));
1187 DBUG_RETURN(server_gone);
1188 }
1189
is_dup_entry_error(int error_num)1190 bool spider_db_handlersocket::is_dup_entry_error(
1191 int error_num
1192 ) {
1193 bool dup_entry;
1194 DBUG_ENTER("spider_db_handlersocket::is_dup_entry_error");
1195 DBUG_PRINT("info",("spider this=%p", this));
1196 #ifndef HANDLERSOCKET_MYSQL_UTIL
1197 const char *c_str = hs_conn->get_error().c_str();
1198 #else
1199 const char *c_str = hs_conn->get_error().c_ptr_safe();
1200 #endif
1201 dup_entry =
1202 (
1203 c_str[0] == '1' &&
1204 c_str[1] == '2' &&
1205 c_str[2] == '1' &&
1206 c_str[3] == '\0'
1207 );
1208 DBUG_PRINT("info",("spider dup_entry=%s", dup_entry ? "TRUE" : "FALSE"));
1209 DBUG_RETURN(dup_entry);
1210 }
1211
is_xa_nota_error(int error_num)1212 bool spider_db_handlersocket::is_xa_nota_error(
1213 int error_num
1214 ) {
1215 bool xa_nota;
1216 DBUG_ENTER("spider_db_handlersocket::is_xa_nota_error");
1217 DBUG_PRINT("info",("spider this=%p", this));
1218 DBUG_ASSERT(0);
1219 xa_nota = (stored_error == ER_XAER_NOTA);
1220 DBUG_PRINT("info",("spider xa_nota=%s", xa_nota ? "TRUE" : "FALSE"));
1221 DBUG_RETURN(xa_nota);
1222 }
1223
store_result(spider_db_result_buffer ** spider_res_buf,st_spider_db_request_key * request_key,int * error_num)1224 spider_db_result *spider_db_handlersocket::store_result(
1225 spider_db_result_buffer **spider_res_buf,
1226 st_spider_db_request_key *request_key,
1227 int *error_num
1228 ) {
1229 int internal_error;
1230 spider_db_handlersocket_result *result;
1231 spider_db_handlersocket_result_buffer *hs_res_buf;
1232 DBUG_ENTER("spider_db_handlersocket::store_result");
1233 DBUG_PRINT("info",("spider this=%p", this));
1234 if (*spider_res_buf)
1235 {
1236 hs_res_buf = (spider_db_handlersocket_result_buffer *) *spider_res_buf;
1237 } else {
1238 if (!(hs_res_buf = new spider_db_handlersocket_result_buffer()))
1239 {
1240 *error_num = HA_ERR_OUT_OF_MEM;
1241 DBUG_RETURN(NULL);
1242 }
1243 *spider_res_buf = (spider_db_result_buffer *) hs_res_buf;
1244 }
1245 hs_res_buf->clear();
1246 if (!(result = new spider_db_handlersocket_result(this)))
1247 {
1248 *error_num = HA_ERR_OUT_OF_MEM;
1249 DBUG_RETURN(NULL);
1250 }
1251 *error_num = 0;
1252 result->hs_conn_p = &hs_conn;
1253 size_t num_fields;
1254 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1255 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1256 if (request_key)
1257 {
1258 int tmp_res, tmp_err = (*hs_conn_p)->get_error_code();
1259 while ((tmp_res = check_request_key(request_key)) == 1)
1260 {
1261 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1262 (*hs_conn_p)->get_num_req_bufd()));
1263 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1264 (*hs_conn_p)->get_num_req_sent()));
1265 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1266 (*hs_conn_p)->get_num_req_rcvd()));
1267 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1268 (*hs_conn_p)->get_response_end_offset()));
1269 if ((internal_error = (*hs_conn_p)->response_recv(num_fields)))
1270 {
1271 if (!tmp_err && internal_error > 0)
1272 {
1273 (*hs_conn_p)->clear_error();
1274 } else {
1275 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1276 #ifndef DBUG_OFF
1277 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1278 (*hs_conn_p)->get_readbuf_begin())
1279 {
1280 char tmp_buf[MAX_FIELD_WIDTH];
1281 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1282 tmp_str.length(0);
1283 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1284 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1285 DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
1286 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1287 }
1288 #endif
1289 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1290 (*hs_conn_p)->get_num_req_bufd()));
1291 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1292 (*hs_conn_p)->get_num_req_sent()));
1293 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1294 (*hs_conn_p)->get_num_req_rcvd()));
1295 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1296 (*hs_conn_p)->get_response_end_offset()));
1297 if (internal_error > 0)
1298 {
1299 (*hs_conn_p)->response_buf_remove();
1300 if ((*hs_conn_p)->get_error_code())
1301 {
1302 DBUG_PRINT("info",("spider hs %d %s",
1303 (*hs_conn_p)->get_error_code(),
1304 (*hs_conn_p)->get_error().ptr()));
1305 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1306 }
1307 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1308 (*hs_conn_p)->get_num_req_bufd()));
1309 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1310 (*hs_conn_p)->get_num_req_sent()));
1311 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1312 (*hs_conn_p)->get_num_req_rcvd()));
1313 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1314 (*hs_conn_p)->get_response_end_offset()));
1315 (*hs_conn_p)->clear_error();
1316 }
1317 delete result;
1318 DBUG_RETURN(NULL);
1319 }
1320 }
1321 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1322 (*hs_conn_p)->get_num_req_bufd()));
1323 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1324 (*hs_conn_p)->get_num_req_sent()));
1325 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1326 (*hs_conn_p)->get_num_req_rcvd()));
1327 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1328 (*hs_conn_p)->get_response_end_offset()));
1329 (*hs_conn_p)->response_buf_remove();
1330 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1331 (*hs_conn_p)->get_num_req_bufd()));
1332 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1333 (*hs_conn_p)->get_num_req_sent()));
1334 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1335 (*hs_conn_p)->get_num_req_rcvd()));
1336 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1337 (*hs_conn_p)->get_response_end_offset()));
1338 }
1339 if (tmp_res == -1)
1340 {
1341 DBUG_PRINT("info",("spider ER_SPIDER_REQUEST_KEY_NUM"));
1342 *error_num = ER_SPIDER_REQUEST_KEY_NUM;
1343 DBUG_RETURN(NULL);
1344 }
1345 }
1346 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1347 (*hs_conn_p)->get_num_req_bufd()));
1348 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1349 (*hs_conn_p)->get_num_req_sent()));
1350 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1351 (*hs_conn_p)->get_num_req_rcvd()));
1352 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1353 (*hs_conn_p)->get_response_end_offset()));
1354 if (
1355 (internal_error = (*hs_conn_p)->response_recv(num_fields)) ||
1356 (*error_num = (*hs_conn_p)->get_result(hs_res_buf->hs_result))
1357 ) {
1358 if (*error_num)
1359 {
1360 *error_num = HA_ERR_OUT_OF_MEM;
1361 }
1362 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1363 #ifndef DBUG_OFF
1364 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1365 (*hs_conn_p)->get_readbuf_begin())
1366 {
1367 char tmp_buf[MAX_FIELD_WIDTH];
1368 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1369 tmp_str.length(0);
1370 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1371 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1372 DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
1373 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1374 }
1375 #endif
1376 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1377 (*hs_conn_p)->get_num_req_bufd()));
1378 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1379 (*hs_conn_p)->get_num_req_sent()));
1380 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1381 (*hs_conn_p)->get_num_req_rcvd()));
1382 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1383 (*hs_conn_p)->get_response_end_offset()));
1384 if (internal_error > 0)
1385 {
1386 (*hs_conn_p)->response_buf_remove();
1387 if ((*hs_conn_p)->get_error_code())
1388 {
1389 DBUG_PRINT("info",("spider hs %d %s",
1390 (*hs_conn_p)->get_error_code(),
1391 (*hs_conn_p)->get_error().ptr()));
1392 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1393 }
1394 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1395 (*hs_conn_p)->get_num_req_bufd()));
1396 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1397 (*hs_conn_p)->get_num_req_sent()));
1398 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1399 (*hs_conn_p)->get_num_req_rcvd()));
1400 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1401 (*hs_conn_p)->get_response_end_offset()));
1402 }
1403 delete result;
1404 DBUG_RETURN(NULL);
1405 }
1406 #ifndef DBUG_OFF
1407 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1408 (*hs_conn_p)->get_readbuf_begin())
1409 {
1410 char tmp_buf[MAX_FIELD_WIDTH];
1411 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1412 tmp_str.length(0);
1413 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1414 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1415 DBUG_PRINT("info",("spider hs readbuf02 size=%zu str=%s",
1416 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1417 }
1418 #endif
1419 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1420 (*hs_conn_p)->get_num_req_bufd()));
1421 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1422 (*hs_conn_p)->get_num_req_sent()));
1423 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1424 (*hs_conn_p)->get_num_req_rcvd()));
1425 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1426 (*hs_conn_p)->get_response_end_offset()));
1427 (*hs_conn_p)->response_buf_remove();
1428 if ((*hs_conn_p)->get_error_code())
1429 {
1430 DBUG_PRINT("info",("spider hs %d %s",
1431 (*hs_conn_p)->get_error_code(),
1432 (*hs_conn_p)->get_error().ptr()));
1433 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1434 }
1435 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1436 (*hs_conn_p)->get_num_req_bufd()));
1437 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1438 (*hs_conn_p)->get_num_req_sent()));
1439 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1440 (*hs_conn_p)->get_num_req_rcvd()));
1441 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1442 (*hs_conn_p)->get_response_end_offset()));
1443 field_count = (uint) num_fields;
1444 result->field_count = field_count;
1445 DBUG_RETURN(result);
1446 }
1447
use_result(st_spider_db_request_key * request_key,int * error_num)1448 spider_db_result *spider_db_handlersocket::use_result(
1449 st_spider_db_request_key *request_key,
1450 int *error_num
1451 ) {
1452 int internal_error;
1453 spider_db_handlersocket_result *result;
1454 DBUG_ENTER("spider_db_handlersocket::use_result");
1455 DBUG_PRINT("info",("spider this=%p", this));
1456 if (!(result = new spider_db_handlersocket_result(this)))
1457 {
1458 *error_num = HA_ERR_OUT_OF_MEM;
1459 DBUG_RETURN(NULL);
1460 }
1461 *error_num = 0;
1462 result->hs_conn_p = &hs_conn;
1463 size_t num_fields;
1464 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1465 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1466 if (request_key)
1467 {
1468 int tmp_res, tmp_err = (*hs_conn_p)->get_error_code();
1469 while ((tmp_res = check_request_key(request_key)) == 1)
1470 {
1471 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1472 (*hs_conn_p)->get_num_req_bufd()));
1473 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1474 (*hs_conn_p)->get_num_req_sent()));
1475 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1476 (*hs_conn_p)->get_num_req_rcvd()));
1477 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1478 (*hs_conn_p)->get_response_end_offset()));
1479 if ((internal_error = (*hs_conn_p)->response_recv(num_fields)))
1480 {
1481 if (!tmp_err && internal_error > 0)
1482 {
1483 (*hs_conn_p)->clear_error();
1484 } else {
1485 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1486 #ifndef DBUG_OFF
1487 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1488 (*hs_conn_p)->get_readbuf_begin())
1489 {
1490 char tmp_buf[MAX_FIELD_WIDTH];
1491 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1492 tmp_str.length(0);
1493 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1494 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1495 DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
1496 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1497 }
1498 #endif
1499 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1500 (*hs_conn_p)->get_num_req_bufd()));
1501 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1502 (*hs_conn_p)->get_num_req_sent()));
1503 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1504 (*hs_conn_p)->get_num_req_rcvd()));
1505 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1506 (*hs_conn_p)->get_response_end_offset()));
1507 if (internal_error > 0)
1508 {
1509 (*hs_conn_p)->response_buf_remove();
1510 if ((*hs_conn_p)->get_error_code())
1511 {
1512 DBUG_PRINT("info",("spider hs %d %s",
1513 (*hs_conn_p)->get_error_code(),
1514 (*hs_conn_p)->get_error().ptr()));
1515 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1516 }
1517 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1518 (*hs_conn_p)->get_num_req_bufd()));
1519 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1520 (*hs_conn_p)->get_num_req_sent()));
1521 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1522 (*hs_conn_p)->get_num_req_rcvd()));
1523 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1524 (*hs_conn_p)->get_response_end_offset()));
1525 (*hs_conn_p)->clear_error();
1526 }
1527 delete result;
1528 DBUG_RETURN(NULL);
1529 }
1530 }
1531 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1532 (*hs_conn_p)->get_num_req_bufd()));
1533 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1534 (*hs_conn_p)->get_num_req_sent()));
1535 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1536 (*hs_conn_p)->get_num_req_rcvd()));
1537 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1538 (*hs_conn_p)->get_response_end_offset()));
1539 (*hs_conn_p)->response_buf_remove();
1540 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1541 (*hs_conn_p)->get_num_req_bufd()));
1542 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1543 (*hs_conn_p)->get_num_req_sent()));
1544 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1545 (*hs_conn_p)->get_num_req_rcvd()));
1546 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1547 (*hs_conn_p)->get_response_end_offset()));
1548 }
1549 if (tmp_res == -1)
1550 {
1551 DBUG_PRINT("info",("spider ER_SPIDER_REQUEST_KEY_NUM"));
1552 *error_num = ER_SPIDER_REQUEST_KEY_NUM;
1553 DBUG_RETURN(NULL);
1554 }
1555 }
1556 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1557 (*hs_conn_p)->get_num_req_bufd()));
1558 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1559 (*hs_conn_p)->get_num_req_sent()));
1560 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1561 (*hs_conn_p)->get_num_req_rcvd()));
1562 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1563 (*hs_conn_p)->get_response_end_offset()));
1564 if (
1565 (internal_error = (*hs_conn_p)->response_recv(num_fields))
1566 ) {
1567 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1568 #ifndef DBUG_OFF
1569 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1570 (*hs_conn_p)->get_readbuf_begin())
1571 {
1572 char tmp_buf[MAX_FIELD_WIDTH];
1573 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1574 tmp_str.length(0);
1575 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1576 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1577 DBUG_PRINT("info",("spider hs readbuf01 size=%zu str=%s",
1578 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1579 }
1580 #endif
1581 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1582 (*hs_conn_p)->get_num_req_bufd()));
1583 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1584 (*hs_conn_p)->get_num_req_sent()));
1585 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1586 (*hs_conn_p)->get_num_req_rcvd()));
1587 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1588 (*hs_conn_p)->get_response_end_offset()));
1589 if (internal_error > 0)
1590 {
1591 (*hs_conn_p)->response_buf_remove();
1592 if ((*hs_conn_p)->get_error_code())
1593 {
1594 DBUG_PRINT("info",("spider hs %d %s",
1595 (*hs_conn_p)->get_error_code(),
1596 (*hs_conn_p)->get_error().ptr()));
1597 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1598 }
1599 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1600 (*hs_conn_p)->get_num_req_bufd()));
1601 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1602 (*hs_conn_p)->get_num_req_sent()));
1603 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1604 (*hs_conn_p)->get_num_req_rcvd()));
1605 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1606 (*hs_conn_p)->get_response_end_offset()));
1607 }
1608 delete result;
1609 DBUG_RETURN(NULL);
1610 }
1611 #ifndef DBUG_OFF
1612 if ((*hs_conn_p)->get_response_end_offset() > 0 &&
1613 (*hs_conn_p)->get_readbuf_begin())
1614 {
1615 char tmp_buf[MAX_FIELD_WIDTH];
1616 String tmp_str(tmp_buf, MAX_FIELD_WIDTH, &my_charset_bin);
1617 tmp_str.length(0);
1618 tmp_str.append((*hs_conn_p)->get_readbuf_begin(),
1619 (*hs_conn_p)->get_response_end_offset(), &my_charset_bin);
1620 DBUG_PRINT("info",("spider hs readbuf02 size=%zu str=%s",
1621 (*hs_conn_p)->get_response_end_offset(), tmp_str.c_ptr_safe()));
1622 }
1623 #endif
1624 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1625 (*hs_conn_p)->get_num_req_bufd()));
1626 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1627 (*hs_conn_p)->get_num_req_sent()));
1628 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1629 (*hs_conn_p)->get_num_req_rcvd()));
1630 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1631 (*hs_conn_p)->get_response_end_offset()));
1632 field_count = (uint) num_fields;
1633 result->field_count = field_count;
1634 DBUG_RETURN(result);
1635 }
1636
next_result()1637 int spider_db_handlersocket::next_result()
1638 {
1639 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1640 DBUG_ENTER("spider_db_handlersocket::next_result");
1641 DBUG_PRINT("info",("spider this=%p", this));
1642 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1643 if ((*hs_conn_p)->stable_point())
1644 DBUG_RETURN(-1);
1645 DBUG_RETURN(0);
1646 }
1647
affected_rows()1648 uint spider_db_handlersocket::affected_rows()
1649 {
1650 int error_num;
1651 const SPIDER_HS_STRING_REF *hs_row;
1652 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1653 DBUG_ENTER("spider_db_handlersocket::affected_rows");
1654 DBUG_PRINT("info",("spider this=%p", this));
1655 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1656 if (
1657 field_count != 1 ||
1658 !(hs_row = (*hs_conn_p)->get_next_row()) ||
1659 !hs_row->begin()
1660 ) {
1661 DBUG_RETURN(0);
1662 }
1663 DBUG_RETURN((uint) my_strtoll10(hs_row->begin(), (char**) NULL, &error_num));
1664 }
1665
last_insert_id()1666 ulonglong spider_db_handlersocket::last_insert_id()
1667 {
1668 DBUG_ENTER("spider_db_handlersocket::last_insert_id");
1669 DBUG_PRINT("info",("spider this=%p", this));
1670 DBUG_RETURN(0);
1671 }
1672
set_character_set(const char * csname)1673 int spider_db_handlersocket::set_character_set(
1674 const char *csname
1675 ) {
1676 DBUG_ENTER("spider_db_handlersocket::set_character_set");
1677 DBUG_PRINT("info",("spider this=%p", this));
1678 /* nothing to do */
1679 DBUG_RETURN(0);
1680 }
1681
select_db(const char * dbname)1682 int spider_db_handlersocket::select_db(
1683 const char *dbname
1684 ) {
1685 DBUG_ENTER("spider_db_handlersocket::select_db");
1686 DBUG_PRINT("info",("spider this=%p", this));
1687 /* nothing to do */
1688 DBUG_RETURN(0);
1689 }
1690
consistent_snapshot(int * need_mon)1691 int spider_db_handlersocket::consistent_snapshot(
1692 int *need_mon
1693 ) {
1694 DBUG_ENTER("spider_db_handlersocket::consistent_snapshot");
1695 DBUG_PRINT("info",("spider this=%p", this));
1696 /* nothing to do */
1697 DBUG_RETURN(0);
1698 }
1699
trx_start_in_bulk_sql()1700 bool spider_db_handlersocket::trx_start_in_bulk_sql()
1701 {
1702 DBUG_ENTER("spider_db_handlersocket::trx_start_in_bulk_sql");
1703 DBUG_PRINT("info",("spider this=%p", this));
1704 DBUG_RETURN(FALSE);
1705 }
1706
start_transaction(int * need_mon)1707 int spider_db_handlersocket::start_transaction(
1708 int *need_mon
1709 ) {
1710 DBUG_ENTER("spider_db_handlersocket::start_transaction");
1711 DBUG_PRINT("info",("spider this=%p", this));
1712 /* nothing to do */
1713 DBUG_RETURN(0);
1714 }
1715
commit(int * need_mon)1716 int spider_db_handlersocket::commit(
1717 int *need_mon
1718 ) {
1719 DBUG_ENTER("spider_db_handlersocket::commit");
1720 DBUG_PRINT("info",("spider this=%p", this));
1721 /* nothing to do */
1722 DBUG_RETURN(0);
1723 }
1724
rollback(int * need_mon)1725 int spider_db_handlersocket::rollback(
1726 int *need_mon
1727 ) {
1728 DBUG_ENTER("spider_db_handlersocket::rollback");
1729 DBUG_PRINT("info",("spider this=%p", this));
1730 /* nothing to do */
1731 DBUG_RETURN(0);
1732 }
1733
xa_start_in_bulk_sql()1734 bool spider_db_handlersocket::xa_start_in_bulk_sql()
1735 {
1736 DBUG_ENTER("spider_db_handlersocket::xa_start_in_bulk_sql");
1737 DBUG_PRINT("info",("spider this=%p", this));
1738 DBUG_RETURN(FALSE);
1739 }
1740
xa_start(XID * xid,int * need_mon)1741 int spider_db_handlersocket::xa_start(
1742 XID *xid,
1743 int *need_mon
1744 ) {
1745 DBUG_ENTER("spider_db_handlersocket::xa_start");
1746 DBUG_PRINT("info",("spider this=%p", this));
1747 /* nothing to do */
1748 DBUG_RETURN(0);
1749 }
1750
xa_end(XID * xid,int * need_mon)1751 int spider_db_handlersocket::xa_end(
1752 XID *xid,
1753 int *need_mon
1754 ) {
1755 DBUG_ENTER("spider_db_handlersocket::xa_end");
1756 DBUG_PRINT("info",("spider this=%p", this));
1757 /* nothing to do */
1758 DBUG_RETURN(0);
1759 }
1760
xa_prepare(XID * xid,int * need_mon)1761 int spider_db_handlersocket::xa_prepare(
1762 XID *xid,
1763 int *need_mon
1764 ) {
1765 DBUG_ENTER("spider_db_handlersocket::xa_prepare");
1766 DBUG_PRINT("info",("spider this=%p", this));
1767 /* nothing to do */
1768 DBUG_RETURN(0);
1769 }
1770
xa_commit(XID * xid,int * need_mon)1771 int spider_db_handlersocket::xa_commit(
1772 XID *xid,
1773 int *need_mon
1774 ) {
1775 DBUG_ENTER("spider_db_handlersocket::xa_commit");
1776 DBUG_PRINT("info",("spider this=%p", this));
1777 /* nothing to do */
1778 DBUG_RETURN(0);
1779 }
1780
xa_rollback(XID * xid,int * need_mon)1781 int spider_db_handlersocket::xa_rollback(
1782 XID *xid,
1783 int *need_mon
1784 ) {
1785 DBUG_ENTER("spider_db_handlersocket::xa_rollback");
1786 DBUG_PRINT("info",("spider this=%p", this));
1787 /* nothing to do */
1788 DBUG_RETURN(0);
1789 }
1790
set_trx_isolation_in_bulk_sql()1791 bool spider_db_handlersocket::set_trx_isolation_in_bulk_sql()
1792 {
1793 DBUG_ENTER("spider_db_handlersocket::set_trx_isolation_in_bulk_sql");
1794 DBUG_PRINT("info",("spider this=%p", this));
1795 DBUG_RETURN(FALSE);
1796 }
1797
set_trx_isolation(int trx_isolation,int * need_mon)1798 int spider_db_handlersocket::set_trx_isolation(
1799 int trx_isolation,
1800 int *need_mon
1801 ) {
1802 DBUG_ENTER("spider_db_handlersocket::set_trx_isolation");
1803 DBUG_PRINT("info",("spider this=%p", this));
1804 /* nothing to do */
1805 DBUG_RETURN(0);
1806 }
1807
set_autocommit_in_bulk_sql()1808 bool spider_db_handlersocket::set_autocommit_in_bulk_sql()
1809 {
1810 DBUG_ENTER("spider_db_handlersocket::set_autocommit_in_bulk_sql");
1811 DBUG_PRINT("info",("spider this=%p", this));
1812 DBUG_RETURN(FALSE);
1813 }
1814
set_autocommit(bool autocommit,int * need_mon)1815 int spider_db_handlersocket::set_autocommit(
1816 bool autocommit,
1817 int *need_mon
1818 ) {
1819 DBUG_ENTER("spider_db_handlersocket::set_autocommit");
1820 DBUG_PRINT("info",("spider this=%p", this));
1821 /* nothing to do */
1822 DBUG_RETURN(0);
1823 }
1824
set_sql_log_off_in_bulk_sql()1825 bool spider_db_handlersocket::set_sql_log_off_in_bulk_sql()
1826 {
1827 DBUG_ENTER("spider_db_handlersocket::set_sql_log_off_in_bulk_sql");
1828 DBUG_PRINT("info",("spider this=%p", this));
1829 DBUG_RETURN(FALSE);
1830 }
1831
set_sql_log_off(bool sql_log_off,int * need_mon)1832 int spider_db_handlersocket::set_sql_log_off(
1833 bool sql_log_off,
1834 int *need_mon
1835 ) {
1836 DBUG_ENTER("spider_db_handlersocket::set_sql_log_off");
1837 DBUG_PRINT("info",("spider this=%p", this));
1838 /* nothing to do */
1839 DBUG_RETURN(0);
1840 }
1841
set_time_zone_in_bulk_sql()1842 bool spider_db_handlersocket::set_time_zone_in_bulk_sql()
1843 {
1844 DBUG_ENTER("spider_db_handlersocket::set_time_zone_in_bulk_sql");
1845 DBUG_PRINT("info",("spider this=%p", this));
1846 DBUG_RETURN(FALSE);
1847 }
1848
set_time_zone(Time_zone * time_zone,int * need_mon)1849 int spider_db_handlersocket::set_time_zone(
1850 Time_zone *time_zone,
1851 int *need_mon
1852 ) {
1853 DBUG_ENTER("spider_db_handlersocket::set_time_zone");
1854 DBUG_PRINT("info",("spider this=%p", this));
1855 /* nothing to do */
1856 DBUG_RETURN(0);
1857 }
1858
show_master_status(SPIDER_TRX * trx,SPIDER_SHARE * share,int all_link_idx,int * need_mon,TABLE * table,spider_string * str,int mode,SPIDER_DB_RESULT ** res1,SPIDER_DB_RESULT ** res2)1859 int spider_db_handlersocket::show_master_status(
1860 SPIDER_TRX *trx,
1861 SPIDER_SHARE *share,
1862 int all_link_idx,
1863 int *need_mon,
1864 TABLE *table,
1865 spider_string *str,
1866 int mode,
1867 SPIDER_DB_RESULT **res1,
1868 SPIDER_DB_RESULT **res2
1869 ) {
1870 DBUG_ENTER("spider_db_handlersocket::show_master_status");
1871 DBUG_PRINT("info",("spider this=%p", this));
1872 DBUG_RETURN(0);
1873 }
1874
append_sql(char * sql,ulong sql_length,st_spider_db_request_key * request_key)1875 int spider_db_handlersocket::append_sql(
1876 char *sql,
1877 ulong sql_length,
1878 st_spider_db_request_key *request_key
1879 ) {
1880 int error_num;
1881 size_t req_num;
1882 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1883 DBUG_ENTER("spider_db_handlersocket::append_sql");
1884 DBUG_PRINT("info",("spider this=%p", this));
1885 if ((error_num = append_request_key(request_key)))
1886 DBUG_RETURN(error_num);
1887 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1888 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1889 (*hs_conn_p)->get_num_req_bufd()));
1890 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1891 (*hs_conn_p)->get_num_req_sent()));
1892 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1893 (*hs_conn_p)->get_num_req_rcvd()));
1894 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1895 (*hs_conn_p)->get_response_end_offset()));
1896 if (!(req_num = (*hs_conn_p)->request_buf_append(sql, sql + sql_length)))
1897 {
1898 DBUG_PRINT("info",("spider hs %d %s",
1899 (*hs_conn_p)->get_error_code(),
1900 (*hs_conn_p)->get_error().ptr()));
1901 (*hs_conn_p)->write_error_to_log(__func__, __FILE__, __LINE__);
1902 DBUG_RETURN((*hs_conn_p)->get_error_code());
1903 }
1904 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1905 (*hs_conn_p)->get_num_req_bufd()));
1906 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1907 (*hs_conn_p)->get_num_req_sent()));
1908 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1909 (*hs_conn_p)->get_num_req_rcvd()));
1910 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1911 (*hs_conn_p)->get_response_end_offset()));
1912 while (req_num > 1)
1913 {
1914 if ((error_num = append_request_key(request_key)))
1915 DBUG_RETURN(error_num);
1916 --req_num;
1917 }
1918 DBUG_RETURN(0);
1919 }
1920
append_open_handler(uint handler_id,const char * db_name,const char * table_name,const char * index_name,const char * sql,st_spider_db_request_key * request_key)1921 int spider_db_handlersocket::append_open_handler(
1922 uint handler_id,
1923 const char *db_name,
1924 const char *table_name,
1925 const char *index_name,
1926 const char *sql,
1927 st_spider_db_request_key *request_key
1928 ) {
1929 int error_num;
1930 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1931 DBUG_ENTER("spider_db_handlersocket::append_open_handler");
1932 DBUG_PRINT("info",("spider this=%p", this));
1933 if ((error_num = append_request_key(request_key)))
1934 DBUG_RETURN(error_num);
1935 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1936 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1937 (*hs_conn_p)->get_num_req_bufd()));
1938 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1939 (*hs_conn_p)->get_num_req_sent()));
1940 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1941 (*hs_conn_p)->get_num_req_rcvd()));
1942 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1943 (*hs_conn_p)->get_response_end_offset()));
1944 (*hs_conn_p)->request_buf_open_index(
1945 handler_id,
1946 db_name,
1947 table_name,
1948 index_name,
1949 sql
1950 );
1951 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1952 (*hs_conn_p)->get_num_req_bufd()));
1953 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1954 (*hs_conn_p)->get_num_req_sent()));
1955 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1956 (*hs_conn_p)->get_num_req_rcvd()));
1957 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1958 (*hs_conn_p)->get_response_end_offset()));
1959 DBUG_RETURN(0);
1960 }
1961
append_select(uint handler_id,spider_string * sql,SPIDER_DB_HS_STRING_REF_BUFFER * keys,int limit,int skip,st_spider_db_request_key * request_key)1962 int spider_db_handlersocket::append_select(
1963 uint handler_id,
1964 spider_string *sql,
1965 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
1966 int limit,
1967 int skip,
1968 st_spider_db_request_key *request_key
1969 ) {
1970 int error_num;
1971 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
1972 DBUG_ENTER("spider_db_handlersocket::append_select");
1973 DBUG_PRINT("info",("spider this=%p", this));
1974 if ((error_num = append_request_key(request_key)))
1975 DBUG_RETURN(error_num);
1976 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
1977 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1978 (*hs_conn_p)->get_num_req_bufd()));
1979 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1980 (*hs_conn_p)->get_num_req_sent()));
1981 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1982 (*hs_conn_p)->get_num_req_rcvd()));
1983 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1984 (*hs_conn_p)->get_response_end_offset()));
1985 (*hs_conn_p)->request_buf_exec_generic(
1986 handler_id,
1987 SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
1988 keys->ptr(), (size_t) keys->size(),
1989 limit, skip,
1990 SPIDER_HS_STRING_REF(),
1991 NULL, 0);
1992 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
1993 (*hs_conn_p)->get_num_req_bufd()));
1994 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
1995 (*hs_conn_p)->get_num_req_sent()));
1996 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
1997 (*hs_conn_p)->get_num_req_rcvd()));
1998 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
1999 (*hs_conn_p)->get_response_end_offset()));
2000 DBUG_RETURN(0);
2001 }
2002
append_insert(uint handler_id,SPIDER_DB_HS_STRING_REF_BUFFER * upds,st_spider_db_request_key * request_key)2003 int spider_db_handlersocket::append_insert(
2004 uint handler_id,
2005 SPIDER_DB_HS_STRING_REF_BUFFER *upds,
2006 st_spider_db_request_key *request_key
2007 ) {
2008 int error_num;
2009 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
2010 DBUG_ENTER("spider_db_handlersocket::append_insert");
2011 DBUG_PRINT("info",("spider this=%p", this));
2012 if ((error_num = append_request_key(request_key)))
2013 DBUG_RETURN(error_num);
2014 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
2015 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2016 (*hs_conn_p)->get_num_req_bufd()));
2017 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2018 (*hs_conn_p)->get_num_req_sent()));
2019 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2020 (*hs_conn_p)->get_num_req_rcvd()));
2021 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2022 (*hs_conn_p)->get_response_end_offset()));
2023 (*hs_conn_p)->request_buf_exec_generic(
2024 handler_id,
2025 SPIDER_HS_STRING_REF(SPIDER_SQL_HS_INSERT_STR, SPIDER_SQL_HS_INSERT_LEN),
2026 upds->ptr(), (size_t) upds->size(),
2027 0, 0,
2028 SPIDER_HS_STRING_REF(), NULL, 0);
2029 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2030 (*hs_conn_p)->get_num_req_bufd()));
2031 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2032 (*hs_conn_p)->get_num_req_sent()));
2033 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2034 (*hs_conn_p)->get_num_req_rcvd()));
2035 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2036 (*hs_conn_p)->get_response_end_offset()));
2037 DBUG_RETURN(0);
2038 }
2039
append_update(uint handler_id,spider_string * sql,SPIDER_DB_HS_STRING_REF_BUFFER * keys,SPIDER_DB_HS_STRING_REF_BUFFER * upds,int limit,int skip,bool increment,bool decrement,st_spider_db_request_key * request_key)2040 int spider_db_handlersocket::append_update(
2041 uint handler_id,
2042 spider_string *sql,
2043 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
2044 SPIDER_DB_HS_STRING_REF_BUFFER *upds,
2045 int limit,
2046 int skip,
2047 bool increment,
2048 bool decrement,
2049 st_spider_db_request_key *request_key
2050 ) {
2051 int error_num;
2052 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
2053 DBUG_ENTER("spider_db_handlersocket::append_update");
2054 DBUG_PRINT("info",("spider this=%p", this));
2055 if ((error_num = append_request_key(request_key)))
2056 DBUG_RETURN(error_num);
2057 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
2058 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2059 (*hs_conn_p)->get_num_req_bufd()));
2060 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2061 (*hs_conn_p)->get_num_req_sent()));
2062 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2063 (*hs_conn_p)->get_num_req_rcvd()));
2064 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2065 (*hs_conn_p)->get_response_end_offset()));
2066 (*hs_conn_p)->request_buf_exec_generic(
2067 handler_id,
2068 SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
2069 keys->ptr(), (size_t) keys->size(),
2070 limit, skip,
2071 increment ?
2072 SPIDER_HS_STRING_REF(SPIDER_SQL_HS_INCREMENT_STR,
2073 SPIDER_SQL_HS_INCREMENT_LEN) :
2074 decrement ?
2075 SPIDER_HS_STRING_REF(SPIDER_SQL_HS_DECREMENT_STR,
2076 SPIDER_SQL_HS_DECREMENT_LEN) :
2077 SPIDER_HS_STRING_REF(SPIDER_SQL_HS_UPDATE_STR,
2078 SPIDER_SQL_HS_UPDATE_LEN),
2079 upds->ptr(), (size_t) upds->size()
2080 );
2081 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2082 (*hs_conn_p)->get_num_req_bufd()));
2083 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2084 (*hs_conn_p)->get_num_req_sent()));
2085 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2086 (*hs_conn_p)->get_num_req_rcvd()));
2087 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2088 (*hs_conn_p)->get_response_end_offset()));
2089 DBUG_RETURN(0);
2090 }
2091
append_delete(uint handler_id,spider_string * sql,SPIDER_DB_HS_STRING_REF_BUFFER * keys,int limit,int skip,st_spider_db_request_key * request_key)2092 int spider_db_handlersocket::append_delete(
2093 uint handler_id,
2094 spider_string *sql,
2095 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
2096 int limit,
2097 int skip,
2098 st_spider_db_request_key *request_key
2099 ) {
2100 int error_num;
2101 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
2102 DBUG_ENTER("spider_db_handlersocket::append_delete");
2103 DBUG_PRINT("info",("spider this=%p", this));
2104 if ((error_num = append_request_key(request_key)))
2105 DBUG_RETURN(error_num);
2106 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
2107 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2108 (*hs_conn_p)->get_num_req_bufd()));
2109 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2110 (*hs_conn_p)->get_num_req_sent()));
2111 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2112 (*hs_conn_p)->get_num_req_rcvd()));
2113 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2114 (*hs_conn_p)->get_response_end_offset()));
2115 (*hs_conn_p)->request_buf_exec_generic(
2116 handler_id,
2117 SPIDER_HS_STRING_REF(sql->ptr(), sql->length()),
2118 keys->ptr(), (size_t) keys->size(),
2119 limit, skip,
2120 SPIDER_HS_STRING_REF(SPIDER_SQL_HS_DELETE_STR, SPIDER_SQL_HS_DELETE_LEN),
2121 NULL, 0);
2122 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2123 (*hs_conn_p)->get_num_req_bufd()));
2124 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2125 (*hs_conn_p)->get_num_req_sent()));
2126 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2127 (*hs_conn_p)->get_num_req_rcvd()));
2128 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2129 (*hs_conn_p)->get_response_end_offset()));
2130 DBUG_RETURN(0);
2131 }
2132
reset_request_queue()2133 void spider_db_handlersocket::reset_request_queue()
2134 {
2135 SPIDER_HS_CONN *hs_conn_p = &hs_conn;
2136 DBUG_ENTER("spider_db_handlersocket::reset_request_queue");
2137 DBUG_PRINT("info",("spider this=%p", this));
2138 DBUG_PRINT("info",("spider hs hs_conn=%p", hs_conn_p));
2139 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2140 (*hs_conn_p)->get_num_req_bufd()));
2141 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2142 (*hs_conn_p)->get_num_req_sent()));
2143 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2144 (*hs_conn_p)->get_num_req_rcvd()));
2145 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2146 (*hs_conn_p)->get_response_end_offset()));
2147 (*hs_conn_p)->request_reset();
2148 DBUG_PRINT("info",("spider hs num_req_bufd=%zu",
2149 (*hs_conn_p)->get_num_req_bufd()));
2150 DBUG_PRINT("info",("spider hs num_req_sent=%zu",
2151 (*hs_conn_p)->get_num_req_sent()));
2152 DBUG_PRINT("info",("spider hs num_req_rcvd=%zu",
2153 (*hs_conn_p)->get_num_req_rcvd()));
2154 DBUG_PRINT("info",("spider hs response_end_offset=%zu",
2155 (*hs_conn_p)->get_response_end_offset()));
2156 reset_request_key_req();
2157 DBUG_VOID_RETURN;
2158 }
2159
escape_string(char * to,const char * from,size_t from_length)2160 size_t spider_db_handlersocket::escape_string(
2161 char *to,
2162 const char *from,
2163 size_t from_length
2164 ) {
2165 DBUG_ENTER("spider_db_handlersocket::escape_string");
2166 DBUG_PRINT("info",("spider this=%p", this));
2167 DBUG_ASSERT(0);
2168 memcpy(to, from, from_length);
2169 DBUG_RETURN(from_length);
2170 }
2171
have_lock_table_list()2172 bool spider_db_handlersocket::have_lock_table_list()
2173 {
2174 DBUG_ENTER("spider_db_handlersocket::have_lock_table_list");
2175 DBUG_PRINT("info",("spider this=%p", this));
2176 DBUG_RETURN(FALSE);
2177 }
2178
append_lock_tables(spider_string * str)2179 int spider_db_handlersocket::append_lock_tables(
2180 spider_string *str
2181 ) {
2182 DBUG_ENTER("spider_db_handlersocket::lock_tables");
2183 DBUG_PRINT("info",("spider this=%p", this));
2184 DBUG_RETURN(0);
2185 }
2186
append_unlock_tables(spider_string * str)2187 int spider_db_handlersocket::append_unlock_tables(
2188 spider_string *str
2189 ) {
2190 DBUG_ENTER("spider_db_handlersocket::append_unlock_tables");
2191 DBUG_PRINT("info",("spider this=%p", this));
2192 DBUG_RETURN(0);
2193 }
2194
get_lock_table_hash_count()2195 uint spider_db_handlersocket::get_lock_table_hash_count()
2196 {
2197 DBUG_ENTER("spider_db_handlersocket::get_lock_table_hash_count");
2198 DBUG_PRINT("info",("spider this=%p", this));
2199 DBUG_ASSERT(0);
2200 DBUG_RETURN(0);
2201 }
2202
reset_lock_table_hash()2203 void spider_db_handlersocket::reset_lock_table_hash()
2204 {
2205 DBUG_ENTER("spider_db_handlersocket::reset_lock_table_hash");
2206 DBUG_PRINT("info",("spider this=%p", this));
2207 DBUG_ASSERT(0);
2208 DBUG_VOID_RETURN;
2209 }
2210
get_opened_handler_count()2211 uint spider_db_handlersocket::get_opened_handler_count()
2212 {
2213 DBUG_ENTER("spider_db_handlersocket::get_opened_handler_count");
2214 DBUG_PRINT("info",("spider this=%p", this));
2215 DBUG_RETURN(handler_open_array.elements);
2216 }
2217
reset_opened_handler()2218 void spider_db_handlersocket::reset_opened_handler()
2219 {
2220 ha_spider *tmp_spider;
2221 int tmp_link_idx;
2222 SPIDER_LINK_FOR_HASH **tmp_link_for_hash;
2223 DBUG_ENTER("spider_db_handlersocket::reset_opened_handler");
2224 DBUG_PRINT("info",("spider this=%p", this));
2225 while ((tmp_link_for_hash =
2226 (SPIDER_LINK_FOR_HASH **) pop_dynamic(&handler_open_array)))
2227 {
2228 tmp_spider = (*tmp_link_for_hash)->spider;
2229 tmp_link_idx = (*tmp_link_for_hash)->link_idx;
2230 tmp_spider->clear_handler_opened(tmp_link_idx, conn->conn_kind);
2231 }
2232 DBUG_VOID_RETURN;
2233 }
2234
set_dup_key_idx(ha_spider * spider,int link_idx)2235 void spider_db_handlersocket::set_dup_key_idx(
2236 ha_spider *spider,
2237 int link_idx
2238 ) {
2239 DBUG_ENTER("spider_db_handlersocket::set_dup_key_idx");
2240 DBUG_PRINT("info",("spider this=%p", this));
2241 DBUG_ASSERT(0);
2242 DBUG_VOID_RETURN;
2243 }
2244
append_request_key(st_spider_db_request_key * request_key)2245 int spider_db_handlersocket::append_request_key(
2246 st_spider_db_request_key *request_key
2247 ) {
2248 st_spider_db_request_key *tmp_request_key;
2249 DBUG_ENTER("spider_db_handlersocket::append_request_key");
2250 DBUG_PRINT("info",("spider this=%p", this));
2251 DBUG_PRINT("info",("spider request_key=%p", request_key));
2252 if (request_key)
2253 {
2254 DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
2255 request_key->spider_thread_id));
2256 DBUG_PRINT("info",("spider request_key->query_id=%llu",
2257 request_key->query_id));
2258 DBUG_PRINT("info",("spider request_key->handler=%p",
2259 request_key->handler));
2260 DBUG_PRINT("info",("spider request_key->request_id=%llu",
2261 request_key->request_id));
2262 if (request_key_reuse_first)
2263 {
2264 tmp_request_key = request_key_reuse_first;
2265 request_key_reuse_first = request_key_reuse_first->next;
2266 if (!request_key_reuse_first)
2267 request_key_reuse_last = NULL;
2268 } else {
2269 if (!(tmp_request_key = (st_spider_db_request_key *)
2270 spider_malloc(spider_current_trx, 1, sizeof(st_spider_db_request_key),
2271 MYF(MY_WME)))
2272 )
2273 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2274 }
2275 *tmp_request_key = *request_key;
2276 tmp_request_key->next = NULL;
2277 if (request_key_req_last)
2278 request_key_req_last->next = tmp_request_key;
2279 else
2280 request_key_req_first = tmp_request_key;
2281 request_key_req_last = tmp_request_key;
2282 }
2283 DBUG_RETURN(0);
2284 }
2285
reset_request_key_req()2286 void spider_db_handlersocket::reset_request_key_req()
2287 {
2288 DBUG_ENTER("spider_db_handlersocket::reset_request_key_req");
2289 DBUG_PRINT("info",("spider this=%p", this));
2290 if (request_key_req_first)
2291 {
2292 if (request_key_reuse_last)
2293 request_key_reuse_last->next = request_key_req_first;
2294 else
2295 request_key_reuse_first = request_key_req_first;
2296 request_key_reuse_last = request_key_req_last;
2297 request_key_req_first = NULL;
2298 request_key_req_last = NULL;
2299 }
2300 DBUG_VOID_RETURN;
2301 }
2302
reset_request_key_snd()2303 void spider_db_handlersocket::reset_request_key_snd()
2304 {
2305 DBUG_ENTER("spider_db_handlersocket::reset_request_key_snd");
2306 DBUG_PRINT("info",("spider this=%p", this));
2307 if (request_key_snd_first)
2308 {
2309 if (request_key_reuse_last)
2310 request_key_reuse_last->next = request_key_snd_first;
2311 else
2312 request_key_reuse_first = request_key_snd_first;
2313 request_key_reuse_last = request_key_snd_last;
2314 request_key_snd_first = NULL;
2315 request_key_snd_last = NULL;
2316 }
2317 DBUG_VOID_RETURN;
2318 }
2319
move_request_key_to_snd()2320 void spider_db_handlersocket::move_request_key_to_snd()
2321 {
2322 DBUG_ENTER("spider_db_handlersocket::move_request_key_to_snd");
2323 DBUG_PRINT("info",("spider this=%p", this));
2324 if (request_key_req_first)
2325 {
2326 if (request_key_snd_last)
2327 request_key_snd_last->next = request_key_req_first;
2328 else
2329 request_key_snd_first = request_key_req_first;
2330 request_key_snd_last = request_key_req_last;
2331 request_key_req_first = NULL;
2332 request_key_req_last = NULL;
2333 }
2334 DBUG_VOID_RETURN;
2335 }
2336
check_request_key(st_spider_db_request_key * request_key)2337 int spider_db_handlersocket::check_request_key(
2338 st_spider_db_request_key *request_key
2339 ) {
2340 st_spider_db_request_key *tmp_request_key;
2341 DBUG_ENTER("spider_db_handlersocket::check_request_key");
2342 DBUG_PRINT("info",("spider this=%p", this));
2343 DBUG_PRINT("info",("spider request_key=%p", request_key));
2344 DBUG_PRINT("info",("spider request_key_snd_first=%p",
2345 request_key_snd_first));
2346 if (!request_key_snd_first)
2347 {
2348 DBUG_PRINT("info",("spider -1"));
2349 DBUG_RETURN(-1);
2350 }
2351 tmp_request_key = request_key_snd_first;
2352 request_key_snd_first = request_key_snd_first->next;
2353 if (!request_key_snd_first)
2354 request_key_snd_last = NULL;
2355 tmp_request_key->next = NULL;
2356 if (request_key_reuse_last)
2357 request_key_reuse_last->next = tmp_request_key;
2358 else
2359 request_key_reuse_first = tmp_request_key;
2360 request_key_reuse_last = tmp_request_key;
2361
2362 DBUG_PRINT("info",("spider tmp_request_key->spider_thread_id=%llu",
2363 tmp_request_key->spider_thread_id));
2364 DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
2365 request_key->spider_thread_id));
2366 DBUG_PRINT("info",("spider tmp_request_key->query_id=%llu",
2367 tmp_request_key->query_id));
2368 DBUG_PRINT("info",("spider request_key->query_id=%llu",
2369 request_key->query_id));
2370 DBUG_PRINT("info",("spider tmp_request_key->handler=%p",
2371 tmp_request_key->handler));
2372 DBUG_PRINT("info",("spider request_key->handler=%p",
2373 request_key->handler));
2374 DBUG_PRINT("info",("spider tmp_request_key->request_id=%llu",
2375 tmp_request_key->request_id));
2376 DBUG_PRINT("info",("spider request_key->request_id=%llu",
2377 request_key->request_id));
2378 if (
2379 tmp_request_key->spider_thread_id != request_key->spider_thread_id ||
2380 tmp_request_key->query_id != request_key->query_id ||
2381 tmp_request_key->handler != request_key->handler ||
2382 tmp_request_key->request_id != request_key->request_id
2383 ) {
2384 DBUG_PRINT("info",("spider 1"));
2385 DBUG_RETURN(1);
2386 }
2387 DBUG_PRINT("info",("spider 0"));
2388 DBUG_RETURN(0);
2389 }
2390
cmp_request_key_to_snd(st_spider_db_request_key * request_key)2391 bool spider_db_handlersocket::cmp_request_key_to_snd(
2392 st_spider_db_request_key *request_key
2393 ) {
2394 DBUG_ENTER("spider_db_handlersocket::cmp_request_key_to_snd");
2395 DBUG_PRINT("info",("spider this=%p", this));
2396 DBUG_PRINT("info",("spider request_key=%p", request_key));
2397 if (
2398 !request_key
2399 ) {
2400 DBUG_PRINT("info",("spider TRUE"));
2401 DBUG_RETURN(TRUE);
2402 }
2403 DBUG_PRINT("info",("spider request_key_snd_first=%p",
2404 request_key_snd_first));
2405 if (
2406 !request_key_snd_first
2407 ) {
2408 DBUG_PRINT("info",("spider FALSE"));
2409 DBUG_RETURN(FALSE);
2410 }
2411 DBUG_PRINT("info",("spider request_key_snd_first->spider_thread_id=%llu",
2412 request_key_snd_first->spider_thread_id));
2413 DBUG_PRINT("info",("spider request_key->spider_thread_id=%llu",
2414 request_key->spider_thread_id));
2415 DBUG_PRINT("info",("spider request_key_snd_first->query_id=%llu",
2416 request_key_snd_first->query_id));
2417 DBUG_PRINT("info",("spider request_key->query_id=%llu",
2418 request_key->query_id));
2419 DBUG_PRINT("info",("spider request_key_snd_first->handler=%p",
2420 request_key_snd_first->handler));
2421 DBUG_PRINT("info",("spider request_key->handler=%p",
2422 request_key->handler));
2423 DBUG_PRINT("info",("spider request_key_snd_first->request_id=%llu",
2424 request_key_snd_first->request_id));
2425 DBUG_PRINT("info",("spider request_key->request_id=%llu",
2426 request_key->request_id));
2427 if (
2428 request_key_snd_first->spider_thread_id != request_key->spider_thread_id ||
2429 request_key_snd_first->query_id != request_key->query_id ||
2430 request_key_snd_first->handler != request_key->handler ||
2431 request_key_snd_first->request_id != request_key->request_id
2432 ) {
2433 DBUG_PRINT("info",("spider FALSE"));
2434 DBUG_RETURN(FALSE);
2435 }
2436 DBUG_PRINT("info",("spider TRUE"));
2437 DBUG_RETURN(TRUE);
2438 }
2439
spider_db_handlersocket_util()2440 spider_db_handlersocket_util::spider_db_handlersocket_util() : spider_db_util()
2441 {
2442 DBUG_ENTER("spider_db_handlersocket_util::spider_db_handlersocket_util");
2443 DBUG_PRINT("info",("spider this=%p", this));
2444 DBUG_VOID_RETURN;
2445 }
2446
~spider_db_handlersocket_util()2447 spider_db_handlersocket_util::~spider_db_handlersocket_util()
2448 {
2449 DBUG_ENTER("spider_db_handlersocket_util::~spider_db_handlersocket_util");
2450 DBUG_PRINT("info",("spider this=%p", this));
2451 DBUG_VOID_RETURN;
2452 }
2453
append_name(spider_string * str,const char * name,uint name_length)2454 int spider_db_handlersocket_util::append_name(
2455 spider_string *str,
2456 const char *name,
2457 uint name_length
2458 ) {
2459 DBUG_ENTER("spider_db_handlersocket_util::append_name");
2460 str->q_append(name, name_length);
2461 DBUG_RETURN(0);
2462 }
2463
append_name_with_charset(spider_string * str,const char * name,uint name_length,CHARSET_INFO * name_charset)2464 int spider_db_handlersocket_util::append_name_with_charset(
2465 spider_string *str,
2466 const char *name,
2467 uint name_length,
2468 CHARSET_INFO *name_charset
2469 ) {
2470 DBUG_ENTER("spider_db_handlersocket_util::append_name_with_charset");
2471 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2))
2472 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2473 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
2474 str->append(name, name_length, name_charset);
2475 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
2476 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2477 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
2478 DBUG_RETURN(0);
2479 }
2480
is_name_quote(const char head_code)2481 bool spider_db_handlersocket_util::is_name_quote(
2482 const char head_code
2483 ) {
2484 DBUG_ENTER("spider_db_handlersocket_util::is_name_quote");
2485 DBUG_RETURN(head_code == *name_quote_str);
2486 }
2487
append_escaped_name_quote(spider_string * str)2488 int spider_db_handlersocket_util::append_escaped_name_quote(
2489 spider_string *str
2490 ) {
2491 DBUG_ENTER("spider_db_handlersocket_util::append_escaped_name_quote");
2492 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2))
2493 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2494 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
2495 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
2496 DBUG_RETURN(0);
2497 }
2498
append_column_value(ha_spider * spider,spider_string * str,Field * field,const uchar * new_ptr,CHARSET_INFO * access_charset)2499 int spider_db_handlersocket_util::append_column_value(
2500 ha_spider *spider,
2501 spider_string *str,
2502 Field *field,
2503 const uchar *new_ptr,
2504 CHARSET_INFO *access_charset
2505 ) {
2506 char buf[MAX_FIELD_WIDTH];
2507 spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin);
2508 String *ptr;
2509 uint length;
2510 DBUG_ENTER("spider_db_handlersocket_util::append_column_value");
2511 tmp_str.init_calc_mem(180);
2512
2513 if (new_ptr)
2514 {
2515 if (
2516 field->type() == MYSQL_TYPE_BLOB ||
2517 field->real_type() == MYSQL_TYPE_VARCHAR
2518 ) {
2519 length = uint2korr(new_ptr);
2520 tmp_str.set_quick((char *) new_ptr + HA_KEY_BLOB_LENGTH, length,
2521 &my_charset_bin);
2522 ptr = tmp_str.get_str();
2523 } else if (field->type() == MYSQL_TYPE_GEOMETRY)
2524 {
2525 /*
2526 uint mlength = SIZEOF_STORED_DOUBLE, lcnt;
2527 uchar *dest = (uchar *) buf;
2528 const uchar *source;
2529 for (lcnt = 0; lcnt < 4; lcnt++)
2530 {
2531 mlength = SIZEOF_STORED_DOUBLE;
2532 source = new_ptr + mlength + SIZEOF_STORED_DOUBLE * lcnt;
2533 while (mlength--)
2534 *dest++ = *--source;
2535 }
2536 tmp_str.length(SIZEOF_STORED_DOUBLE * lcnt);
2537 */
2538 double xmin, xmax, ymin, ymax;
2539 /*
2540 float8store(buf,xmin);
2541 float8store(buf+8,xmax);
2542 float8store(buf+16,ymin);
2543 float8store(buf+24,ymax);
2544 memcpy(&xmin,new_ptr,sizeof(xmin));
2545 memcpy(&xmax,new_ptr + 8,sizeof(xmax));
2546 memcpy(&ymin,new_ptr + 16,sizeof(ymin));
2547 memcpy(&ymax,new_ptr + 24,sizeof(ymax));
2548 float8get(xmin, buf);
2549 float8get(xmax, buf + 8);
2550 float8get(ymin, buf + 16);
2551 float8get(ymax, buf + 24);
2552 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
2553 xmin, xmax, ymin, ymax));
2554 DBUG_PRINT("info", ("spider geo is %.14g %.14g %.14g %.14g",
2555 xmin, xmax, ymin, ymax));
2556 */
2557 float8get(xmin, new_ptr);
2558 float8get(xmax, new_ptr + 8);
2559 float8get(ymin, new_ptr + 16);
2560 float8get(ymax, new_ptr + 24);
2561 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
2562 xmin, xmax, ymin, ymax));
2563 /*
2564 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 4);
2565 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 5);
2566 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 6);
2567 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 7);
2568 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
2569 xmin, xmax, ymin, ymax));
2570 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 8);
2571 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 9);
2572 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 10);
2573 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 11);
2574 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
2575 xmin, xmax, ymin, ymax));
2576 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 12);
2577 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 13);
2578 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 14);
2579 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 15);
2580 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
2581 xmin, xmax, ymin, ymax));
2582 */
2583 /*
2584 tmp_str.set_quick((char *) new_ptr, SIZEOF_STORED_DOUBLE * 4,
2585 &my_charset_bin);
2586 */
2587 tmp_str.length(0);
2588 tmp_str.q_append((char *) SPIDER_SQL_LINESTRING_HEAD_STR,
2589 SPIDER_SQL_LINESTRING_HEAD_LEN);
2590 tmp_str.q_append((char *) new_ptr, SIZEOF_STORED_DOUBLE);
2591 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 2,
2592 SIZEOF_STORED_DOUBLE);
2593 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE,
2594 SIZEOF_STORED_DOUBLE);
2595 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 3,
2596 SIZEOF_STORED_DOUBLE);
2597 ptr = tmp_str.get_str();
2598 } else {
2599 ptr = field->val_str(tmp_str.get_str(), new_ptr);
2600 tmp_str.mem_calc();
2601 }
2602 } else {
2603 ptr = field->val_str(tmp_str.get_str());
2604 tmp_str.mem_calc();
2605 }
2606 DBUG_PRINT("info", ("spider field->type() is %d", field->type()));
2607 DBUG_PRINT("info", ("spider ptr->length() is %d", ptr->length()));
2608 /*
2609 if (
2610 field->type() == MYSQL_TYPE_BIT ||
2611 (field->type() >= MYSQL_TYPE_TINY_BLOB &&
2612 field->type() <= MYSQL_TYPE_BLOB)
2613 ) {
2614 uchar *hex_ptr = (uchar *) ptr->ptr(), *end_ptr;
2615 char *str_ptr;
2616 DBUG_PRINT("info", ("spider HEX"));
2617 if (str->reserve(SPIDER_SQL_HEX_LEN + ptr->length() * 2))
2618 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2619 str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN);
2620 str_ptr = (char *) str->ptr() + str->length();
2621 for (end_ptr = hex_ptr + ptr->length(); hex_ptr < end_ptr; hex_ptr++)
2622 {
2623 *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4];
2624 *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F];
2625 }
2626 str->length(str->length() + ptr->length() * 2);
2627 } else
2628 */
2629 spider_handlersocket_handler *hs_handler = (spider_handlersocket_handler *)
2630 spider->dbton_handler[spider_dbton_handlersocket.dbton_id];
2631 spider_string *hs_str;
2632 if (!(hs_str = hs_handler->hs_strs.add(
2633 &hs_handler->hs_strs_pos, ptr->ptr(), ptr->length())))
2634 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2635 SPIDER_HS_STRING_REF ref =
2636 SPIDER_HS_STRING_REF(hs_str->ptr(), hs_str->length());
2637 if (hs_handler->hs_adding_keys)
2638 {
2639 DBUG_PRINT("info", ("spider add to key:%s", hs_str->c_ptr_safe()));
2640 hs_handler->hs_keys.push_back(ref);
2641 } else {
2642 DBUG_PRINT("info", ("spider add to upd:%s", hs_str->c_ptr_safe()));
2643 hs_handler->hs_upds.push_back(ref);
2644 }
2645 DBUG_RETURN(0);
2646 }
2647
append_trx_isolation(spider_string * str,int trx_isolation)2648 int spider_db_handlersocket_util::append_trx_isolation(
2649 spider_string *str,
2650 int trx_isolation
2651 ) {
2652 DBUG_ENTER("spider_db_handlersocket_util::append_trx_isolation");
2653 DBUG_PRINT("info",("spider this=%p", this));
2654 /* nothing to do */
2655 DBUG_RETURN(0);
2656 }
2657
append_autocommit(spider_string * str,bool autocommit)2658 int spider_db_handlersocket_util::append_autocommit(
2659 spider_string *str,
2660 bool autocommit
2661 ) {
2662 DBUG_ENTER("spider_db_handlersocket_util::append_autocommit");
2663 DBUG_PRINT("info",("spider this=%p", this));
2664 /* nothing to do */
2665 DBUG_RETURN(0);
2666 }
2667
append_sql_log_off(spider_string * str,bool sql_log_off)2668 int spider_db_handlersocket_util::append_sql_log_off(
2669 spider_string *str,
2670 bool sql_log_off
2671 ) {
2672 DBUG_ENTER("spider_db_handlersocket_util::append_sql_log_off");
2673 DBUG_PRINT("info",("spider this=%p", this));
2674 /* nothing to do */
2675 DBUG_RETURN(0);
2676 }
2677
append_time_zone(spider_string * str,Time_zone * time_zone)2678 int spider_db_handlersocket_util::append_time_zone(
2679 spider_string *str,
2680 Time_zone *time_zone
2681 ) {
2682 DBUG_ENTER("spider_db_handlersocket_util::append_time_zone");
2683 DBUG_PRINT("info",("spider this=%p", this));
2684 /* nothing to do */
2685 DBUG_RETURN(0);
2686 }
2687
append_start_transaction(spider_string * str)2688 int spider_db_handlersocket_util::append_start_transaction(
2689 spider_string *str
2690 ) {
2691 DBUG_ENTER("spider_db_handlersocket_util::append_start_transaction");
2692 DBUG_PRINT("info",("spider this=%p", this));
2693 /* nothing to do */
2694 DBUG_RETURN(0);
2695 }
2696
append_xa_start(spider_string * str,XID * xid)2697 int spider_db_handlersocket_util::append_xa_start(
2698 spider_string *str,
2699 XID *xid
2700 ) {
2701 DBUG_ENTER("spider_db_handlersocket_util::append_xa_start");
2702 DBUG_PRINT("info",("spider this=%p", this));
2703 /* nothing to do */
2704 DBUG_RETURN(0);
2705 }
2706
append_lock_table_head(spider_string * str)2707 int spider_db_handlersocket_util::append_lock_table_head(
2708 spider_string *str
2709 ) {
2710 DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_head");
2711 DBUG_PRINT("info",("spider this=%p", this));
2712 /* nothing to do */
2713 DBUG_RETURN(0);
2714 }
2715
append_lock_table_body(spider_string * str,const char * db_name,uint db_name_length,CHARSET_INFO * db_name_charset,const char * table_name,uint table_name_length,CHARSET_INFO * table_name_charset,int lock_type)2716 int spider_db_handlersocket_util::append_lock_table_body(
2717 spider_string *str,
2718 const char *db_name,
2719 uint db_name_length,
2720 CHARSET_INFO *db_name_charset,
2721 const char *table_name,
2722 uint table_name_length,
2723 CHARSET_INFO *table_name_charset,
2724 int lock_type
2725 ) {
2726 DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_body");
2727 DBUG_PRINT("info",("spider this=%p", this));
2728 /* nothing to do */
2729 DBUG_RETURN(0);
2730 }
2731
append_lock_table_tail(spider_string * str)2732 int spider_db_handlersocket_util::append_lock_table_tail(
2733 spider_string *str
2734 ) {
2735 DBUG_ENTER("spider_db_handlersocket_util::append_lock_table_tail");
2736 DBUG_PRINT("info",("spider this=%p", this));
2737 /* nothing to do */
2738 DBUG_RETURN(0);
2739 }
2740
append_unlock_table(spider_string * str)2741 int spider_db_handlersocket_util::append_unlock_table(
2742 spider_string *str
2743 ) {
2744 DBUG_ENTER("spider_db_handlersocket_util::append_unlock_table");
2745 DBUG_PRINT("info",("spider this=%p", this));
2746 /* nothing to do */
2747 DBUG_RETURN(0);
2748 }
2749
open_item_func(Item_func * item_func,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,bool use_fields,spider_fields * fields)2750 int spider_db_handlersocket_util::open_item_func(
2751 Item_func *item_func,
2752 ha_spider *spider,
2753 spider_string *str,
2754 const char *alias,
2755 uint alias_length,
2756 bool use_fields,
2757 spider_fields *fields
2758 ) {
2759 uint dbton_id = spider_dbton_handlersocket.dbton_id;
2760 int error_num;
2761 Item *item, **item_list = item_func->arguments();
2762 uint roop_count, item_count = item_func->argument_count(), start_item = 0;
2763 const char *func_name = SPIDER_SQL_NULL_CHAR_STR,
2764 *separator_str = SPIDER_SQL_NULL_CHAR_STR,
2765 *last_str = SPIDER_SQL_NULL_CHAR_STR;
2766 int func_name_length = SPIDER_SQL_NULL_CHAR_LEN,
2767 separator_str_length = SPIDER_SQL_NULL_CHAR_LEN,
2768 last_str_length = SPIDER_SQL_NULL_CHAR_LEN;
2769 int use_pushdown_udf;
2770 bool merge_func = FALSE;
2771 DBUG_ENTER("spider_db_handlersocket_util::open_item_func");
2772 if (str)
2773 {
2774 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
2775 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2776 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
2777 }
2778 DBUG_PRINT("info",("spider functype = %d", item_func->functype()));
2779 switch (item_func->functype())
2780 {
2781 case Item_func::ISNULL_FUNC:
2782 last_str = SPIDER_SQL_IS_NULL_STR;
2783 last_str_length = SPIDER_SQL_IS_NULL_LEN;
2784 break;
2785 case Item_func::ISNOTNULL_FUNC:
2786 last_str = SPIDER_SQL_IS_NOT_NULL_STR;
2787 last_str_length = SPIDER_SQL_IS_NOT_NULL_LEN;
2788 break;
2789 case Item_func::UNKNOWN_FUNC:
2790 func_name = (char*) item_func->func_name();
2791 func_name_length = strlen(func_name);
2792 DBUG_PRINT("info",("spider func_name = %s", func_name));
2793 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
2794 if (func_name_length == 1 &&
2795 (
2796 !strncasecmp("+", func_name, func_name_length) ||
2797 !strncasecmp("-", func_name, func_name_length) ||
2798 !strncasecmp("*", func_name, func_name_length) ||
2799 !strncasecmp("/", func_name, func_name_length) ||
2800 !strncasecmp("%", func_name, func_name_length) ||
2801 !strncasecmp("&", func_name, func_name_length) ||
2802 !strncasecmp("|", func_name, func_name_length) ||
2803 !strncasecmp("^", func_name, func_name_length)
2804 )
2805 ) {
2806 /* no action */
2807 break;
2808 } else if (func_name_length == 2 &&
2809 (
2810 !strncasecmp("<<", func_name, func_name_length) ||
2811 !strncasecmp(">>", func_name, func_name_length)
2812 )
2813 ) {
2814 /* no action */
2815 break;
2816 } else if (func_name_length == 3 &&
2817 !strncasecmp("div", func_name, func_name_length)
2818 ) {
2819 /* no action */
2820 break;
2821 } else if (func_name_length == 4)
2822 {
2823 if (
2824 !strncasecmp("rand", func_name, func_name_length) &&
2825 #ifdef SPIDER_Item_args_arg_count_IS_PROTECTED
2826 !item_func->argument_count()
2827 #else
2828 !item_func->arg_count
2829 #endif
2830 ) {
2831 if (str)
2832 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
2833 DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
2834 alias, alias_length, dbton_id, use_fields, fields));
2835 } else if (
2836 !strncasecmp("case", func_name, func_name_length)
2837 ) {
2838 #ifdef ITEM_FUNC_CASE_PARAMS_ARE_PUBLIC
2839 Item_func_case *item_func_case = (Item_func_case *) item_func;
2840 if (str)
2841 {
2842 if (str->reserve(SPIDER_SQL_CASE_LEN))
2843 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2844 str->q_append(SPIDER_SQL_CASE_STR, SPIDER_SQL_CASE_LEN);
2845 }
2846 if (item_func_case->first_expr_num != -1)
2847 {
2848 if ((error_num = spider_db_print_item_type(
2849 item_list[item_func_case->first_expr_num], NULL, spider, str,
2850 alias, alias_length, dbton_id, use_fields, fields)))
2851 DBUG_RETURN(error_num);
2852 }
2853 for (roop_count = 0; roop_count < item_func_case->ncases;
2854 roop_count += 2)
2855 {
2856 if (str)
2857 {
2858 if (str->reserve(SPIDER_SQL_WHEN_LEN))
2859 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2860 str->q_append(SPIDER_SQL_WHEN_STR, SPIDER_SQL_WHEN_LEN);
2861 }
2862 if ((error_num = spider_db_print_item_type(
2863 item_list[roop_count], NULL, spider, str,
2864 alias, alias_length, dbton_id, use_fields, fields)))
2865 DBUG_RETURN(error_num);
2866 if (str)
2867 {
2868 if (str->reserve(SPIDER_SQL_THEN_LEN))
2869 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2870 str->q_append(SPIDER_SQL_THEN_STR, SPIDER_SQL_THEN_LEN);
2871 }
2872 if ((error_num = spider_db_print_item_type(
2873 item_list[roop_count + 1], NULL, spider, str,
2874 alias, alias_length, dbton_id, use_fields, fields)))
2875 DBUG_RETURN(error_num);
2876 }
2877 if (item_func_case->else_expr_num != -1)
2878 {
2879 if (str)
2880 {
2881 if (str->reserve(SPIDER_SQL_ELSE_LEN))
2882 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2883 str->q_append(SPIDER_SQL_ELSE_STR, SPIDER_SQL_ELSE_LEN);
2884 }
2885 if ((error_num = spider_db_print_item_type(
2886 item_list[item_func_case->else_expr_num], NULL, spider, str,
2887 alias, alias_length, dbton_id, use_fields, fields)))
2888 DBUG_RETURN(error_num);
2889 }
2890 if (str)
2891 {
2892 if (str->reserve(SPIDER_SQL_END_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
2893 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2894 str->q_append(SPIDER_SQL_END_STR, SPIDER_SQL_END_LEN);
2895 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
2896 SPIDER_SQL_CLOSE_PAREN_LEN);
2897 }
2898 DBUG_RETURN(0);
2899 #else
2900 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
2901 #endif
2902 }
2903 } else if (func_name_length == 6 &&
2904 !strncasecmp("istrue", func_name, func_name_length)
2905 ) {
2906 last_str = SPIDER_SQL_IS_TRUE_STR;
2907 last_str_length = SPIDER_SQL_IS_TRUE_LEN;
2908 break;
2909 } else if (func_name_length == 7)
2910 {
2911 if (!strncasecmp("isfalse", func_name, func_name_length))
2912 {
2913 last_str = SPIDER_SQL_IS_FALSE_STR;
2914 last_str_length = SPIDER_SQL_IS_FALSE_LEN;
2915 break;
2916 } else if (
2917 !strncasecmp("sysdate", func_name, func_name_length) ||
2918 !strncasecmp("curdate", func_name, func_name_length) ||
2919 !strncasecmp("curtime", func_name, func_name_length)
2920 ) {
2921 if (str)
2922 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
2923 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
2924 alias, alias_length, dbton_id, use_fields, fields));
2925 } else if (
2926 !strncasecmp("convert", func_name, func_name_length)
2927 ) {
2928 if (str)
2929 {
2930 if (str->reserve(func_name_length * 2 + SPIDER_SQL_OPEN_PAREN_LEN))
2931 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2932 str->q_append(func_name, func_name_length);
2933 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
2934 SPIDER_SQL_OPEN_PAREN_LEN);
2935 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
2936 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
2937 }
2938 break;
2939 }
2940 } else if (func_name_length == 8 &&
2941 (
2942 !strncasecmp("utc_date", func_name, func_name_length) ||
2943 !strncasecmp("utc_time", func_name, func_name_length)
2944 )
2945 ) {
2946 if (str)
2947 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
2948 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
2949 alias, alias_length, dbton_id, use_fields, fields));
2950 } else if (func_name_length == 9 &&
2951 !strncasecmp("isnottrue", func_name, func_name_length)
2952 ) {
2953 last_str = SPIDER_SQL_IS_NOT_TRUE_STR;
2954 last_str_length = SPIDER_SQL_IS_NOT_TRUE_LEN;
2955 break;
2956 } else if (func_name_length == 10)
2957 {
2958 if (!strncasecmp("isnotfalse", func_name, func_name_length))
2959 {
2960 last_str = SPIDER_SQL_IS_NOT_FALSE_STR;
2961 last_str_length = SPIDER_SQL_IS_NOT_FALSE_LEN;
2962 break;
2963 } else if (!strncasecmp("column_get", func_name, func_name_length))
2964 {
2965 if (str)
2966 {
2967 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
2968 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
2969 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2970 str->q_append(func_name, func_name_length);
2971 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
2972 }
2973 func_name = SPIDER_SQL_COMMA_STR;
2974 func_name_length = SPIDER_SQL_COMMA_LEN;
2975 separator_str = SPIDER_SQL_COMMA_STR;
2976 separator_str_length = SPIDER_SQL_COMMA_LEN;
2977 break;
2978 }
2979 } else if (func_name_length == 12)
2980 {
2981 if (!strncasecmp("cast_as_date", func_name, func_name_length))
2982 {
2983 item = item_list[0];
2984 if (item->type() == Item::FUNC_ITEM)
2985 {
2986 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
2987 Item_func *ifunc = (Item_func *) item;
2988 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
2989 {
2990 const char *child_func_name;
2991 int child_func_name_length;
2992 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
2993 child_func_name = (char*) ifunc->func_name();
2994 child_func_name_length = strlen(child_func_name);
2995 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
2996 if (
2997 child_func_name_length == 10 &&
2998 !strncasecmp("column_get", child_func_name, child_func_name_length)
2999 ) {
3000 DBUG_PRINT("info",("spider this is merge func"));
3001 merge_func = TRUE;
3002 }
3003 }
3004 }
3005
3006 if (str)
3007 {
3008 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3009 if (!merge_func)
3010 {
3011 if (str->reserve(SPIDER_SQL_CAST_LEN))
3012 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3013 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3014 }
3015 }
3016 last_str = SPIDER_SQL_AS_DATE_STR;
3017 last_str_length = SPIDER_SQL_AS_DATE_LEN;
3018 break;
3019 } else if (!strncasecmp("cast_as_time", func_name, func_name_length))
3020 {
3021 item = item_list[0];
3022 if (item->type() == Item::FUNC_ITEM)
3023 {
3024 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3025 Item_func *ifunc = (Item_func *) item;
3026 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3027 {
3028 const char *child_func_name;
3029 int child_func_name_length;
3030 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3031 child_func_name = (char*) ifunc->func_name();
3032 child_func_name_length = strlen(child_func_name);
3033 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3034 if (
3035 child_func_name_length == 10 &&
3036 !strncasecmp("column_get", child_func_name, child_func_name_length)
3037 ) {
3038 DBUG_PRINT("info",("spider this is merge func"));
3039 merge_func = TRUE;
3040 }
3041 }
3042 }
3043
3044 if (str)
3045 {
3046 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3047 if (!merge_func)
3048 {
3049 if (str->reserve(SPIDER_SQL_CAST_LEN))
3050 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3051 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3052 }
3053 }
3054 last_str = SPIDER_SQL_AS_TIME_STR;
3055 last_str_length = SPIDER_SQL_AS_TIME_LEN;
3056 break;
3057 }
3058 } else if (func_name_length == 13)
3059 {
3060 if (!strncasecmp("utc_timestamp", func_name, func_name_length))
3061 {
3062 if (str)
3063 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3064 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
3065 alias, alias_length, dbton_id, use_fields, fields));
3066 } else if (!strncasecmp("timestampdiff", func_name, func_name_length))
3067 {
3068 #ifdef ITEM_FUNC_TIMESTAMPDIFF_ARE_PUBLIC
3069 Item_func_timestamp_diff *item_func_timestamp_diff =
3070 (Item_func_timestamp_diff *) item_func;
3071 if (str)
3072 {
3073 const char *interval_str;
3074 uint interval_len;
3075 switch (item_func_timestamp_diff->int_type)
3076 {
3077 case INTERVAL_YEAR:
3078 interval_str = SPIDER_SQL_YEAR_STR;
3079 interval_len = SPIDER_SQL_YEAR_LEN;
3080 break;
3081 case INTERVAL_QUARTER:
3082 interval_str = SPIDER_SQL_QUARTER_STR;
3083 interval_len = SPIDER_SQL_QUARTER_LEN;
3084 break;
3085 case INTERVAL_MONTH:
3086 interval_str = SPIDER_SQL_MONTH_STR;
3087 interval_len = SPIDER_SQL_MONTH_LEN;
3088 break;
3089 case INTERVAL_WEEK:
3090 interval_str = SPIDER_SQL_WEEK_STR;
3091 interval_len = SPIDER_SQL_WEEK_LEN;
3092 break;
3093 case INTERVAL_DAY:
3094 interval_str = SPIDER_SQL_DAY_STR;
3095 interval_len = SPIDER_SQL_DAY_LEN;
3096 break;
3097 case INTERVAL_HOUR:
3098 interval_str = SPIDER_SQL_HOUR_STR;
3099 interval_len = SPIDER_SQL_HOUR_LEN;
3100 break;
3101 case INTERVAL_MINUTE:
3102 interval_str = SPIDER_SQL_MINUTE_STR;
3103 interval_len = SPIDER_SQL_MINUTE_LEN;
3104 break;
3105 case INTERVAL_SECOND:
3106 interval_str = SPIDER_SQL_SECOND_STR;
3107 interval_len = SPIDER_SQL_SECOND_LEN;
3108 break;
3109 case INTERVAL_MICROSECOND:
3110 interval_str = SPIDER_SQL_MICROSECOND_STR;
3111 interval_len = SPIDER_SQL_MICROSECOND_LEN;
3112 break;
3113 default:
3114 interval_str = "";
3115 interval_len = 0;
3116 break;
3117 }
3118 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3119 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN +
3120 interval_len + SPIDER_SQL_COMMA_LEN))
3121 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3122 str->q_append(func_name, func_name_length);
3123 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
3124 str->q_append(interval_str, interval_len);
3125 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
3126 }
3127 if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
3128 str, alias, alias_length, dbton_id, use_fields, fields)))
3129 DBUG_RETURN(error_num);
3130 if (str)
3131 {
3132 if (str->reserve(SPIDER_SQL_COMMA_LEN))
3133 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3134 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
3135 }
3136 if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
3137 str, alias, alias_length, dbton_id, use_fields, fields)))
3138 DBUG_RETURN(error_num);
3139 if (str)
3140 {
3141 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
3142 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3143 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
3144 SPIDER_SQL_CLOSE_PAREN_LEN);
3145 }
3146 DBUG_RETURN(0);
3147 #else
3148 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3149 #endif
3150 }
3151 } else if (func_name_length == 14)
3152 {
3153 if (!strncasecmp("cast_as_binary", func_name, func_name_length))
3154 {
3155 item = item_list[0];
3156 if (item->type() == Item::FUNC_ITEM)
3157 {
3158 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3159 Item_func *ifunc = (Item_func *) item;
3160 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3161 {
3162 const char *child_func_name;
3163 int child_func_name_length;
3164 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3165 child_func_name = (char*) ifunc->func_name();
3166 child_func_name_length = strlen(child_func_name);
3167 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3168 if (
3169 child_func_name_length == 10 &&
3170 !strncasecmp("column_get", child_func_name, child_func_name_length)
3171 ) {
3172 DBUG_PRINT("info",("spider this is merge func"));
3173 merge_func = TRUE;
3174 }
3175 }
3176 }
3177
3178 if (str)
3179 {
3180 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
3181 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
3182 tmp_str.init_calc_mem(123);
3183 tmp_str.length(0);
3184 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3185 if (!merge_func)
3186 {
3187 if (str->reserve(SPIDER_SQL_CAST_LEN))
3188 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3189 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3190 }
3191 #if MYSQL_VERSION_ID < 50500
3192 item_func->print(tmp_str.get_str(), QT_IS);
3193 #else
3194 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
3195 #endif
3196 tmp_str.mem_calc();
3197 if (tmp_str.reserve(1))
3198 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3199 tmp_ptr = tmp_str.c_ptr_quick();
3200 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
3201 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR)))
3202 tmp_ptr = tmp_ptr2 + 1;
3203 last_str = tmp_ptr - 1;
3204 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
3205 }
3206 break;
3207 } else if (!strncasecmp("cast_as_signed", func_name, func_name_length))
3208 {
3209 item = item_list[0];
3210 if (item->type() == Item::FUNC_ITEM)
3211 {
3212 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3213 Item_func *ifunc = (Item_func *) item;
3214 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3215 {
3216 const char *child_func_name;
3217 int child_func_name_length;
3218 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3219 child_func_name = (char*) ifunc->func_name();
3220 child_func_name_length = strlen(child_func_name);
3221 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3222 if (
3223 child_func_name_length == 10 &&
3224 !strncasecmp("column_get", child_func_name, child_func_name_length)
3225 ) {
3226 DBUG_PRINT("info",("spider this is merge func"));
3227 merge_func = TRUE;
3228 }
3229 }
3230 }
3231
3232 if (str)
3233 {
3234 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3235 if (!merge_func)
3236 {
3237 if (str->reserve(SPIDER_SQL_CAST_LEN))
3238 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3239 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3240 }
3241 }
3242 last_str = SPIDER_SQL_AS_SIGNED_STR;
3243 last_str_length = SPIDER_SQL_AS_SIGNED_LEN;
3244 break;
3245 }
3246 } else if (func_name_length == 16)
3247 {
3248 if (!strncasecmp("cast_as_unsigned", func_name, func_name_length))
3249 {
3250 item = item_list[0];
3251 if (item->type() == Item::FUNC_ITEM)
3252 {
3253 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3254 Item_func *ifunc = (Item_func *) item;
3255 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3256 {
3257 const char *child_func_name;
3258 int child_func_name_length;
3259 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3260 child_func_name = (char*) ifunc->func_name();
3261 child_func_name_length = strlen(child_func_name);
3262 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3263 if (
3264 child_func_name_length == 10 &&
3265 !strncasecmp("column_get", child_func_name, child_func_name_length)
3266 ) {
3267 DBUG_PRINT("info",("spider this is merge func"));
3268 merge_func = TRUE;
3269 }
3270 }
3271 }
3272
3273 if (str)
3274 {
3275 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3276 if (!merge_func)
3277 {
3278 if (str->reserve(SPIDER_SQL_CAST_LEN))
3279 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3280 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3281 }
3282 }
3283 last_str = SPIDER_SQL_AS_UNSIGNED_STR;
3284 last_str_length = SPIDER_SQL_AS_UNSIGNED_LEN;
3285 break;
3286 } else if (!strncasecmp("decimal_typecast", func_name,
3287 func_name_length))
3288 {
3289 item = item_list[0];
3290 if (item->type() == Item::FUNC_ITEM)
3291 {
3292 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3293 Item_func *ifunc = (Item_func *) item;
3294 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3295 {
3296 const char *child_func_name;
3297 int child_func_name_length;
3298 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3299 child_func_name = (char*) ifunc->func_name();
3300 child_func_name_length = strlen(child_func_name);
3301 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3302 if (
3303 child_func_name_length == 10 &&
3304 !strncasecmp("column_get", child_func_name, child_func_name_length)
3305 ) {
3306 DBUG_PRINT("info",("spider this is merge func"));
3307 merge_func = TRUE;
3308 }
3309 }
3310 }
3311
3312 if (str)
3313 {
3314 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
3315 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
3316 tmp_str.init_calc_mem(124);
3317 tmp_str.length(0);
3318 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3319 if (!merge_func)
3320 {
3321 if (str->reserve(SPIDER_SQL_CAST_LEN))
3322 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3323 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3324 }
3325 #if MYSQL_VERSION_ID < 50500
3326 item_func->print(tmp_str.get_str(), QT_IS);
3327 #else
3328 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
3329 #endif
3330 tmp_str.mem_calc();
3331 if (tmp_str.reserve(1))
3332 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3333 tmp_ptr = tmp_str.c_ptr_quick();
3334 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
3335 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR)))
3336 tmp_ptr = tmp_ptr2 + 1;
3337 last_str = tmp_ptr - 1;
3338 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
3339 }
3340 break;
3341 } else if (!strncasecmp("cast_as_datetime", func_name,
3342 func_name_length))
3343 {
3344 item = item_list[0];
3345 if (item->type() == Item::FUNC_ITEM)
3346 {
3347 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3348 Item_func *ifunc = (Item_func *) item;
3349 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3350 {
3351 const char *child_func_name;
3352 int child_func_name_length;
3353 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3354 child_func_name = (char*) ifunc->func_name();
3355 child_func_name_length = strlen(child_func_name);
3356 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3357 if (
3358 child_func_name_length == 10 &&
3359 !strncasecmp("column_get", child_func_name, child_func_name_length)
3360 ) {
3361 DBUG_PRINT("info",("spider this is merge func"));
3362 merge_func = TRUE;
3363 }
3364 }
3365 }
3366
3367 if (str)
3368 {
3369 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3370 if (!merge_func)
3371 {
3372 if (str->reserve(SPIDER_SQL_CAST_LEN))
3373 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3374 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3375 }
3376 }
3377 last_str = SPIDER_SQL_AS_DATETIME_STR;
3378 last_str_length = SPIDER_SQL_AS_DATETIME_LEN;
3379 break;
3380 }
3381 } else if (func_name_length == 17)
3382 {
3383 if (!strncasecmp("date_add_interval", func_name, func_name_length))
3384 {
3385 Item_date_add_interval *item_date_add_interval =
3386 (Item_date_add_interval *) item_func;
3387 func_name = spider_db_timefunc_interval_str[
3388 item_date_add_interval->int_type];
3389 func_name_length = strlen(func_name);
3390 if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
3391 str, alias, alias_length, dbton_id, use_fields, fields)))
3392 DBUG_RETURN(error_num);
3393 if (str)
3394 {
3395 if (item_date_add_interval->date_sub_interval)
3396 {
3397 if (str->reserve(SPIDER_SQL_NEGINTERVAL_LEN))
3398 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3399 str->q_append(SPIDER_SQL_NEGINTERVAL_STR,
3400 SPIDER_SQL_NEGINTERVAL_LEN);
3401 } else {
3402 if (str->reserve(SPIDER_SQL_INTERVAL_LEN))
3403 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3404 str->q_append(SPIDER_SQL_INTERVAL_STR, SPIDER_SQL_INTERVAL_LEN);
3405 }
3406 }
3407 if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
3408 str, alias, alias_length, dbton_id, use_fields, fields)))
3409 DBUG_RETURN(error_num);
3410 if (str)
3411 {
3412 if (str->reserve(func_name_length + SPIDER_SQL_CLOSE_PAREN_LEN))
3413 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3414 str->q_append(func_name, func_name_length);
3415 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
3416 SPIDER_SQL_CLOSE_PAREN_LEN);
3417 }
3418 DBUG_RETURN(0);
3419 }
3420 }
3421 if (str)
3422 {
3423 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
3424 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3425 str->q_append(func_name, func_name_length);
3426 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
3427 }
3428 func_name = SPIDER_SQL_COMMA_STR;
3429 func_name_length = SPIDER_SQL_COMMA_LEN;
3430 separator_str = SPIDER_SQL_COMMA_STR;
3431 separator_str_length = SPIDER_SQL_COMMA_LEN;
3432 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3433 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3434 break;
3435 case Item_func::NOW_FUNC:
3436 if (str)
3437 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3438 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
3439 alias, alias_length, dbton_id, use_fields, fields));
3440 case Item_func::CHAR_TYPECAST_FUNC:
3441 DBUG_PRINT("info",("spider CHAR_TYPECAST_FUNC"));
3442 {
3443 item = item_list[0];
3444 if (item->type() == Item::FUNC_ITEM)
3445 {
3446 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
3447 Item_func *ifunc = (Item_func *) item;
3448 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
3449 {
3450 const char *child_func_name;
3451 int child_func_name_length;
3452 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
3453 child_func_name = (char*) ifunc->func_name();
3454 child_func_name_length = strlen(child_func_name);
3455 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
3456 if (
3457 child_func_name_length == 10 &&
3458 !strncasecmp("column_get", child_func_name, child_func_name_length)
3459 ) {
3460 DBUG_PRINT("info",("spider this is merge func"));
3461 merge_func = TRUE;
3462 }
3463 }
3464 }
3465
3466 if (str)
3467 {
3468 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
3469 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
3470 tmp_str.init_calc_mem(125);
3471 tmp_str.length(0);
3472 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3473 if (!merge_func)
3474 {
3475 if (str->reserve(SPIDER_SQL_CAST_LEN))
3476 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3477 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
3478 }
3479 #if MYSQL_VERSION_ID < 50500
3480 item_func->print(tmp_str.get_str(), QT_IS);
3481 #else
3482 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
3483 #endif
3484 tmp_str.mem_calc();
3485 if (tmp_str.reserve(1))
3486 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3487 tmp_ptr = tmp_str.c_ptr_quick();
3488 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
3489 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR)))
3490 tmp_ptr = tmp_ptr2 + 1;
3491 last_str = tmp_ptr - 1;
3492 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
3493 }
3494 }
3495 break;
3496 case Item_func::NOT_FUNC:
3497 DBUG_PRINT("info",("spider NOT_FUNC"));
3498 if (item_list[0]->type() == Item::COND_ITEM)
3499 {
3500 DBUG_PRINT("info",("spider item_list[0] is COND_ITEM"));
3501 Item_cond *item_cond = (Item_cond *) item_list[0];
3502 if (item_cond->functype() == Item_func::COND_AND_FUNC)
3503 {
3504 DBUG_PRINT("info",("spider item_cond is COND_AND_FUNC"));
3505 List_iterator_fast<Item> lif(*(item_cond->argument_list()));
3506 bool has_expr_cache_item = FALSE;
3507 bool has_isnotnull_func = FALSE;
3508 bool has_other_item = FALSE;
3509 while((item = lif++))
3510 {
3511 #ifdef SPIDER_HAS_EXPR_CACHE_ITEM
3512 if (
3513 item->type() == Item::EXPR_CACHE_ITEM
3514 ) {
3515 DBUG_PRINT("info",("spider EXPR_CACHE_ITEM"));
3516 has_expr_cache_item = TRUE;
3517 } else
3518 #endif
3519 if (
3520 item->type() == Item::FUNC_ITEM &&
3521 ((Item_func *) item)->functype() == Item_func::ISNOTNULL_FUNC
3522 ) {
3523 DBUG_PRINT("info",("spider ISNOTNULL_FUNC"));
3524 has_isnotnull_func = TRUE;
3525 } else {
3526 DBUG_PRINT("info",("spider has other item"));
3527 DBUG_PRINT("info",("spider COND type=%d", item->type()));
3528 has_other_item = TRUE;
3529 }
3530 }
3531 if (has_expr_cache_item && has_isnotnull_func && !has_other_item)
3532 {
3533 DBUG_PRINT("info",("spider NOT EXISTS skip"));
3534 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3535 }
3536 }
3537 }
3538 if (str)
3539 {
3540 func_name = (char*) item_func->func_name();
3541 func_name_length = strlen(func_name);
3542 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
3543 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3544 str->q_append(func_name, func_name_length);
3545 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
3546 }
3547 break;
3548 case Item_func::NEG_FUNC:
3549 if (str)
3550 {
3551 func_name = (char*) item_func->func_name();
3552 func_name_length = strlen(func_name);
3553 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
3554 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3555 str->q_append(func_name, func_name_length);
3556 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
3557 }
3558 break;
3559 case Item_func::IN_FUNC:
3560 if (((Item_func_opt_neg *) item_func)->negated)
3561 {
3562 func_name = SPIDER_SQL_NOT_IN_STR;
3563 func_name_length = SPIDER_SQL_NOT_IN_LEN;
3564 separator_str = SPIDER_SQL_COMMA_STR;
3565 separator_str_length = SPIDER_SQL_COMMA_LEN;
3566 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3567 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3568 } else {
3569 func_name = SPIDER_SQL_IN_STR;
3570 func_name_length = SPIDER_SQL_IN_LEN;
3571 separator_str = SPIDER_SQL_COMMA_STR;
3572 separator_str_length = SPIDER_SQL_COMMA_LEN;
3573 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3574 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3575 }
3576 break;
3577 case Item_func::BETWEEN:
3578 if (((Item_func_opt_neg *) item_func)->negated)
3579 {
3580 func_name = SPIDER_SQL_NOT_BETWEEN_STR;
3581 func_name_length = SPIDER_SQL_NOT_BETWEEN_LEN;
3582 separator_str = SPIDER_SQL_AND_STR;
3583 separator_str_length = SPIDER_SQL_AND_LEN;
3584 } else {
3585 func_name = (char*) item_func->func_name();
3586 func_name_length = strlen(func_name);
3587 separator_str = SPIDER_SQL_AND_STR;
3588 separator_str_length = SPIDER_SQL_AND_LEN;
3589 }
3590 break;
3591 case Item_func::UDF_FUNC:
3592 use_pushdown_udf = spider_param_use_pushdown_udf(spider->trx->thd,
3593 spider->share->use_pushdown_udf);
3594 if (!use_pushdown_udf)
3595 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3596 if (str)
3597 {
3598 func_name = (char*) item_func->func_name();
3599 func_name_length = strlen(func_name);
3600 DBUG_PRINT("info",("spider func_name = %s", func_name));
3601 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
3602 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
3603 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3604 str->q_append(func_name, func_name_length);
3605 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
3606 }
3607 func_name = SPIDER_SQL_COMMA_STR;
3608 func_name_length = SPIDER_SQL_COMMA_LEN;
3609 separator_str = SPIDER_SQL_COMMA_STR;
3610 separator_str_length = SPIDER_SQL_COMMA_LEN;
3611 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3612 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3613 break;
3614 #ifdef MARIADB_BASE_VERSION
3615 case Item_func::XOR_FUNC:
3616 #else
3617 case Item_func::COND_XOR_FUNC:
3618 #endif
3619 if (str)
3620 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3621 DBUG_RETURN(
3622 spider_db_open_item_cond((Item_cond *) item_func, spider, str,
3623 alias, alias_length, dbton_id, use_fields, fields));
3624 case Item_func::TRIG_COND_FUNC:
3625 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3626 case Item_func::GUSERVAR_FUNC:
3627 if (str)
3628 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
3629 if (item_func->result_type() == STRING_RESULT)
3630 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
3631 alias, alias_length, dbton_id, use_fields, fields));
3632 else
3633 DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
3634 alias, alias_length, dbton_id, use_fields, fields));
3635 case Item_func::FT_FUNC:
3636 if (spider_db_check_ft_idx(item_func, spider) == MAX_KEY)
3637 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3638 start_item = 1;
3639 if (str)
3640 {
3641 if (str->reserve(SPIDER_SQL_MATCH_LEN))
3642 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3643 str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);
3644 }
3645 separator_str = SPIDER_SQL_COMMA_STR;
3646 separator_str_length = SPIDER_SQL_COMMA_LEN;
3647 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3648 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3649 break;
3650 case Item_func::SP_EQUALS_FUNC:
3651 if (str)
3652 {
3653 func_name = SPIDER_SQL_MBR_EQUAL_STR;
3654 func_name_length = SPIDER_SQL_MBR_EQUAL_LEN;
3655 DBUG_PRINT("info",("spider func_name = %s", func_name));
3656 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
3657 if (str->reserve(func_name_length))
3658 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3659 str->q_append(func_name, func_name_length);
3660 }
3661 func_name = SPIDER_SQL_COMMA_STR;
3662 func_name_length = SPIDER_SQL_COMMA_LEN;
3663 separator_str = SPIDER_SQL_COMMA_STR;
3664 separator_str_length = SPIDER_SQL_COMMA_LEN;
3665 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3666 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3667 break;
3668 case Item_func::SP_DISJOINT_FUNC:
3669 case Item_func::SP_INTERSECTS_FUNC:
3670 case Item_func::SP_TOUCHES_FUNC:
3671 case Item_func::SP_CROSSES_FUNC:
3672 case Item_func::SP_WITHIN_FUNC:
3673 case Item_func::SP_CONTAINS_FUNC:
3674 case Item_func::SP_OVERLAPS_FUNC:
3675 if (str)
3676 {
3677 func_name = (char*) item_func->func_name();
3678 func_name_length = strlen(func_name);
3679 DBUG_PRINT("info",("spider func_name = %s", func_name));
3680 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
3681 if (str->reserve(
3682 #ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
3683 SPIDER_SQL_MBR_LEN +
3684 #endif
3685 func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
3686 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3687 #ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
3688 str->q_append(SPIDER_SQL_MBR_STR, SPIDER_SQL_MBR_LEN);
3689 #endif
3690 str->q_append(func_name, func_name_length);
3691 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
3692 }
3693 func_name = SPIDER_SQL_COMMA_STR;
3694 func_name_length = SPIDER_SQL_COMMA_LEN;
3695 separator_str = SPIDER_SQL_COMMA_STR;
3696 separator_str_length = SPIDER_SQL_COMMA_LEN;
3697 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
3698 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
3699 break;
3700 case Item_func::EQ_FUNC:
3701 case Item_func::EQUAL_FUNC:
3702 case Item_func::NE_FUNC:
3703 case Item_func::LT_FUNC:
3704 case Item_func::LE_FUNC:
3705 case Item_func::GE_FUNC:
3706 case Item_func::GT_FUNC:
3707 case Item_func::LIKE_FUNC:
3708 if (str)
3709 {
3710 func_name = (char*) item_func->func_name();
3711 func_name_length = strlen(func_name);
3712 }
3713 break;
3714 default:
3715 THD *thd = spider->trx->thd;
3716 SPIDER_SHARE *share = spider->share;
3717 if (spider_param_skip_default_condition(thd,
3718 share->skip_default_condition))
3719 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3720 if (str)
3721 {
3722 func_name = (char*) item_func->func_name();
3723 func_name_length = strlen(func_name);
3724 }
3725 break;
3726 }
3727 DBUG_PRINT("info",("spider func_name = %s", func_name));
3728 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
3729 DBUG_PRINT("info",("spider separator_str = %s", separator_str));
3730 DBUG_PRINT("info",("spider separator_str_length = %d", separator_str_length));
3731 DBUG_PRINT("info",("spider last_str = %s", last_str));
3732 DBUG_PRINT("info",("spider last_str_length = %d", last_str_length));
3733 if (item_count)
3734 {
3735 item_count--;
3736 for (roop_count = start_item; roop_count < item_count; roop_count++)
3737 {
3738 item = item_list[roop_count];
3739 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
3740 alias, alias_length, dbton_id, use_fields, fields)))
3741 DBUG_RETURN(error_num);
3742 if (roop_count == 1)
3743 {
3744 func_name = separator_str;
3745 func_name_length = separator_str_length;
3746 }
3747 if (str)
3748 {
3749 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))
3750 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3751 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
3752 str->q_append(func_name, func_name_length);
3753 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
3754 }
3755 }
3756 item = item_list[roop_count];
3757 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
3758 alias, alias_length, dbton_id, use_fields, fields)))
3759 DBUG_RETURN(error_num);
3760 }
3761 if (item_func->functype() == Item_func::FT_FUNC)
3762 {
3763 Item_func_match *item_func_match = (Item_func_match *)item_func;
3764 if (str)
3765 {
3766 if (str->reserve(SPIDER_SQL_AGAINST_LEN))
3767 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3768 str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);
3769 }
3770 item = item_list[0];
3771 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
3772 alias, alias_length, dbton_id, use_fields, fields)))
3773 DBUG_RETURN(error_num);
3774 if (str)
3775 {
3776 if (str->reserve(
3777 ((item_func_match->flags & FT_BOOL) ?
3778 SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +
3779 ((item_func_match->flags & FT_EXPAND) ?
3780 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)
3781 ))
3782 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3783 if (item_func_match->flags & FT_BOOL)
3784 str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,
3785 SPIDER_SQL_IN_BOOLEAN_MODE_LEN);
3786 if (item_func_match->flags & FT_EXPAND)
3787 str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,
3788 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);
3789 }
3790 } else if (item_func->functype() == Item_func::UNKNOWN_FUNC)
3791 {
3792 if (
3793 func_name_length == 7 &&
3794 !strncasecmp("convert", func_name, func_name_length)
3795 ) {
3796 if (str)
3797 {
3798 Item_func_conv_charset *item_func_conv_charset =
3799 (Item_func_conv_charset *)item_func;
3800 CHARSET_INFO *conv_charset =
3801 item_func_conv_charset->SPIDER_Item_func_conv_charset_conv_charset;
3802 uint cset_length = strlen(conv_charset->csname);
3803 if (str->reserve(SPIDER_SQL_USING_LEN + cset_length))
3804 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3805 str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
3806 str->q_append(conv_charset->csname, cset_length);
3807 }
3808 }
3809 }
3810 if (str)
3811 {
3812 if (merge_func)
3813 str->length(str->length() - SPIDER_SQL_CLOSE_PAREN_LEN);
3814 if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN))
3815 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3816 str->q_append(last_str, last_str_length);
3817 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
3818 }
3819 DBUG_RETURN(0);
3820 }
3821
3822 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
open_item_sum_func(Item_sum * item_sum,ha_spider * spider,spider_string * str,const char * alias,uint alias_length,bool use_fields,spider_fields * fields)3823 int spider_db_handlersocket_util::open_item_sum_func(
3824 Item_sum *item_sum,
3825 ha_spider *spider,
3826 spider_string *str,
3827 const char *alias,
3828 uint alias_length,
3829 bool use_fields,
3830 spider_fields *fields
3831 ) {
3832 uint dbton_id = spider_dbton_handlersocket.dbton_id;
3833 uint roop_count, item_count = item_sum->get_arg_count();
3834 int error_num;
3835 DBUG_ENTER("spider_db_handlersocket_util::open_item_sum_func");
3836 DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func()));
3837 switch (item_sum->sum_func())
3838 {
3839 case Item_sum::COUNT_FUNC:
3840 case Item_sum::SUM_FUNC:
3841 case Item_sum::MIN_FUNC:
3842 case Item_sum::MAX_FUNC:
3843 {
3844 const char *func_name = item_sum->func_name();
3845 uint func_name_length = strlen(func_name);
3846 Item *item, **args = item_sum->get_args();
3847 if (str)
3848 {
3849 if (str->reserve(func_name_length))
3850 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3851 str->q_append(func_name, func_name_length);
3852 }
3853 if (item_count)
3854 {
3855 item_count--;
3856 for (roop_count = 0; roop_count < item_count; roop_count++)
3857 {
3858 item = args[roop_count];
3859 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
3860 alias, alias_length, dbton_id, use_fields, fields)))
3861 DBUG_RETURN(error_num);
3862 if (str)
3863 {
3864 if (str->reserve(SPIDER_SQL_COMMA_LEN))
3865 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3866 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
3867 }
3868 }
3869 item = args[roop_count];
3870 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
3871 alias, alias_length, dbton_id, use_fields, fields)))
3872 DBUG_RETURN(error_num);
3873 }
3874 if (str)
3875 {
3876 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
3877 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3878 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
3879 SPIDER_SQL_CLOSE_PAREN_LEN);
3880 }
3881 }
3882 break;
3883 case Item_sum::COUNT_DISTINCT_FUNC:
3884 case Item_sum::SUM_DISTINCT_FUNC:
3885 case Item_sum::AVG_FUNC:
3886 case Item_sum::AVG_DISTINCT_FUNC:
3887 case Item_sum::STD_FUNC:
3888 case Item_sum::VARIANCE_FUNC:
3889 case Item_sum::SUM_BIT_FUNC:
3890 case Item_sum::UDF_SUM_FUNC:
3891 case Item_sum::GROUP_CONCAT_FUNC:
3892 default:
3893 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
3894 }
3895 DBUG_RETURN(0);
3896 }
3897 #endif
3898
append_escaped_util(spider_string * to,String * from)3899 int spider_db_handlersocket_util::append_escaped_util(
3900 spider_string *to,
3901 String *from
3902 ) {
3903 DBUG_ENTER("spider_db_handlersocket_util::append_escaped_util");
3904 DBUG_PRINT("info",("spider this=%p", this));
3905 to->append_escape_string(from->ptr(), from->length());
3906 DBUG_RETURN(0);
3907 }
3908
3909 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
append_from_and_tables(ha_spider * spider,spider_fields * fields,spider_string * str,TABLE_LIST * table_list,uint table_count)3910 int spider_db_handlersocket_util::append_from_and_tables(
3911 ha_spider *spider,
3912 spider_fields *fields,
3913 spider_string *str,
3914 TABLE_LIST *table_list,
3915 uint table_count
3916 ) {
3917 DBUG_ENTER("spider_db_handlersocket_util::append_from_and_tables");
3918 DBUG_PRINT("info",("spider this=%p", this));
3919 DBUG_ASSERT(0);
3920 DBUG_RETURN(0);
3921 }
3922
reappend_tables(spider_fields * fields,SPIDER_LINK_IDX_CHAIN * link_idx_chain,spider_string * str)3923 int spider_db_handlersocket_util::reappend_tables(
3924 spider_fields *fields,
3925 SPIDER_LINK_IDX_CHAIN *link_idx_chain,
3926 spider_string *str
3927 ) {
3928 DBUG_ENTER("spider_db_handlersocket_util::reappend_tables");
3929 DBUG_PRINT("info",("spider this=%p", this));
3930 DBUG_ASSERT(0);
3931 DBUG_RETURN(0);
3932 }
3933
append_where(spider_string * str)3934 int spider_db_handlersocket_util::append_where(
3935 spider_string *str
3936 ) {
3937 DBUG_ENTER("spider_db_handlersocket_util::append_where");
3938 DBUG_PRINT("info",("spider this=%p", this));
3939 DBUG_ASSERT(0);
3940 DBUG_RETURN(0);
3941 }
3942
append_having(spider_string * str)3943 int spider_db_handlersocket_util::append_having(
3944 spider_string *str
3945 ) {
3946 DBUG_ENTER("spider_db_handlersocket_util::append_having");
3947 DBUG_PRINT("info",("spider this=%p", this));
3948 DBUG_ASSERT(0);
3949 DBUG_RETURN(0);
3950 }
3951 #endif
3952
spider_handlersocket_share(st_spider_share * share)3953 spider_handlersocket_share::spider_handlersocket_share(
3954 st_spider_share *share
3955 ) : spider_db_share(
3956 share,
3957 spider_dbton_handlersocket.dbton_id
3958 ),
3959 table_names_str(NULL),
3960 db_names_str(NULL),
3961 db_table_str(NULL),
3962 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
3963 db_table_str_hash_value(NULL),
3964 #endif
3965 table_nm_max_length(0),
3966 db_nm_max_length(0),
3967 column_name_str(NULL),
3968 same_db_table_name(TRUE),
3969 first_all_link_idx(-1)
3970 {
3971 DBUG_ENTER("spider_handlersocket_share::spider_handlersocket_share");
3972 DBUG_PRINT("info",("spider this=%p", this));
3973 spider_alloc_calc_mem_init(mem_calc, 186);
3974 spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
3975 DBUG_VOID_RETURN;
3976 }
3977
~spider_handlersocket_share()3978 spider_handlersocket_share::~spider_handlersocket_share()
3979 {
3980 DBUG_ENTER("spider_handlersocket_share::~spider_handlersocket_share");
3981 DBUG_PRINT("info",("spider this=%p", this));
3982 free_column_name_str();
3983 free_table_names_str();
3984 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
3985 if (db_table_str_hash_value)
3986 {
3987 spider_free(spider_current_trx, db_table_str_hash_value, MYF(0));
3988 }
3989 #endif
3990 spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
3991 DBUG_VOID_RETURN;
3992 }
3993
init()3994 int spider_handlersocket_share::init()
3995 {
3996 int error_num;
3997 DBUG_ENTER("spider_handlersocket_share::init");
3998 DBUG_PRINT("info",("spider this=%p", this));
3999 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
4000 if (!(db_table_str_hash_value = (my_hash_value_type *)
4001 spider_bulk_alloc_mem(spider_current_trx, 203,
4002 __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
4003 &db_table_str_hash_value,
4004 sizeof(my_hash_value_type) * spider_share->all_link_count,
4005 NullS))
4006 ) {
4007 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4008 }
4009 #endif
4010
4011 if (
4012 (error_num = create_table_names_str()) ||
4013 (
4014 spider_share->table_share &&
4015 (error_num = create_column_name_str())
4016 )
4017 ) {
4018 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4019 }
4020 DBUG_RETURN(0);
4021 }
4022
append_table_name(spider_string * str,int all_link_idx)4023 int spider_handlersocket_share::append_table_name(
4024 spider_string *str,
4025 int all_link_idx
4026 ) {
4027 const char *db_nm = db_names_str[all_link_idx].ptr();
4028 uint db_nm_len = db_names_str[all_link_idx].length();
4029 const char *table_nm = table_names_str[all_link_idx].ptr();
4030 uint table_nm_len = table_names_str[all_link_idx].length();
4031 DBUG_ENTER("spider_handlersocket_share::append_table_name");
4032 DBUG_PRINT("info",("spider this=%p", this));
4033 if (str->reserve(db_nm_len + SPIDER_SQL_DOT_LEN + table_nm_len +
4034 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
4035 {
4036 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4037 }
4038 spider_db_handlersocket_utility.append_name(str, db_nm, db_nm_len);
4039 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
4040 spider_db_handlersocket_utility.append_name(str, table_nm, table_nm_len);
4041 DBUG_RETURN(0);
4042 }
4043
create_table_names_str()4044 int spider_handlersocket_share::create_table_names_str()
4045 {
4046 int error_num, roop_count;
4047 uint table_nm_len, db_nm_len;
4048 spider_string *str, *first_tbl_nm_str, *first_db_nm_str, *first_db_tbl_str;
4049 char *first_tbl_nm, *first_db_nm;
4050 uint dbton_id = spider_dbton_handlersocket.dbton_id;
4051 DBUG_ENTER("spider_handlersocket_share::create_table_names_str");
4052 table_names_str = NULL;
4053 db_names_str = NULL;
4054 db_table_str = NULL;
4055 if (
4056 !(table_names_str = new spider_string[spider_share->all_link_count]) ||
4057 !(db_names_str = new spider_string[spider_share->all_link_count]) ||
4058 !(db_table_str = new spider_string[spider_share->all_link_count])
4059 ) {
4060 error_num = HA_ERR_OUT_OF_MEM;
4061 goto error;
4062 }
4063
4064 same_db_table_name = TRUE;
4065 first_tbl_nm = spider_share->tgt_table_names[0];
4066 first_db_nm = spider_share->tgt_dbs[0];
4067 table_nm_len = spider_share->tgt_table_names_lengths[0];
4068 db_nm_len = spider_share->tgt_dbs_lengths[0];
4069 first_tbl_nm_str = &table_names_str[0];
4070 first_db_nm_str = &db_names_str[0];
4071 first_db_tbl_str = &db_table_str[0];
4072 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
4073 roop_count++)
4074 {
4075 table_names_str[roop_count].init_calc_mem(86);
4076 db_names_str[roop_count].init_calc_mem(87);
4077 db_table_str[roop_count].init_calc_mem(88);
4078 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
4079 continue;
4080 if (first_all_link_idx == -1)
4081 first_all_link_idx = roop_count;
4082
4083 str = &table_names_str[roop_count];
4084 if (
4085 roop_count != 0 &&
4086 same_db_table_name &&
4087 spider_share->tgt_table_names_lengths[roop_count] == table_nm_len &&
4088 !memcmp(first_tbl_nm, spider_share->tgt_table_names[roop_count],
4089 table_nm_len)
4090 ) {
4091 if (str->copy(*first_tbl_nm_str))
4092 {
4093 error_num = HA_ERR_OUT_OF_MEM;
4094 goto error;
4095 }
4096 } else {
4097 str->set_charset(spider_share->access_charset);
4098 if ((error_num = spider_db_append_name_with_quote_str(str,
4099 spider_share->tgt_table_names[roop_count], dbton_id)))
4100 goto error;
4101 if (roop_count)
4102 {
4103 same_db_table_name = FALSE;
4104 DBUG_PRINT("info", ("spider found different table name %s",
4105 spider_share->tgt_table_names[roop_count]));
4106 if (str->length() > table_nm_max_length)
4107 table_nm_max_length = str->length();
4108 } else
4109 table_nm_max_length = str->length();
4110 }
4111
4112 str = &db_names_str[roop_count];
4113 if (
4114 roop_count != 0 &&
4115 same_db_table_name &&
4116 spider_share->tgt_dbs_lengths[roop_count] == db_nm_len &&
4117 !memcmp(first_db_nm, spider_share->tgt_dbs[roop_count],
4118 db_nm_len)
4119 ) {
4120 if (str->copy(*first_db_nm_str))
4121 {
4122 error_num = HA_ERR_OUT_OF_MEM;
4123 goto error;
4124 }
4125 } else {
4126 str->set_charset(spider_share->access_charset);
4127 if ((error_num = spider_db_append_name_with_quote_str(str,
4128 spider_share->tgt_dbs[roop_count], dbton_id)))
4129 goto error;
4130 if (roop_count)
4131 {
4132 same_db_table_name = FALSE;
4133 DBUG_PRINT("info", ("spider found different db name %s",
4134 spider_share->tgt_dbs[roop_count]));
4135 if (str->length() > db_nm_max_length)
4136 db_nm_max_length = str->length();
4137 } else
4138 db_nm_max_length = str->length();
4139 }
4140
4141 str = &db_table_str[roop_count];
4142 if (
4143 roop_count != 0 &&
4144 same_db_table_name
4145 ) {
4146 if (str->copy(*first_db_tbl_str))
4147 {
4148 error_num = HA_ERR_OUT_OF_MEM;
4149 goto error;
4150 }
4151 } else {
4152 str->set_charset(spider_share->access_charset);
4153 if ((error_num = append_table_name(str, roop_count)))
4154 goto error;
4155 }
4156 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
4157 db_table_str_hash_value[roop_count] = my_calc_hash(
4158 &spider_open_connections, (uchar*) str->ptr(), str->length());
4159 #endif
4160 }
4161 DBUG_RETURN(0);
4162
4163 error:
4164 if (db_table_str)
4165 {
4166 delete [] db_table_str;
4167 db_table_str = NULL;
4168 }
4169 if (db_names_str)
4170 {
4171 delete [] db_names_str;
4172 db_names_str = NULL;
4173 }
4174 if (table_names_str)
4175 {
4176 delete [] table_names_str;
4177 table_names_str = NULL;
4178 }
4179 DBUG_RETURN(error_num);
4180 }
4181
free_table_names_str()4182 void spider_handlersocket_share::free_table_names_str()
4183 {
4184 DBUG_ENTER("spider_handlersocket_share::free_table_names_str");
4185 if (db_table_str)
4186 {
4187 delete [] db_table_str;
4188 db_table_str = NULL;
4189 }
4190 if (db_names_str)
4191 {
4192 delete [] db_names_str;
4193 db_names_str = NULL;
4194 }
4195 if (table_names_str)
4196 {
4197 delete [] table_names_str;
4198 table_names_str = NULL;
4199 }
4200 DBUG_VOID_RETURN;
4201 }
4202
create_column_name_str()4203 int spider_handlersocket_share::create_column_name_str()
4204 {
4205 spider_string *str;
4206 int error_num;
4207 Field **field;
4208 TABLE_SHARE *table_share = spider_share->table_share;
4209 uint dbton_id = spider_dbton_handlersocket.dbton_id;
4210 DBUG_ENTER("spider_handlersocket_share::create_column_name_str");
4211 if (
4212 table_share->fields &&
4213 !(column_name_str = new spider_string[table_share->fields])
4214 )
4215 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4216 for (field = table_share->field, str = column_name_str;
4217 *field; field++, str++)
4218 {
4219 str->init_calc_mem(202);
4220 str->set_charset(spider_share->access_charset);
4221 if ((error_num = spider_db_append_name_with_quote_str(str,
4222 (*field)->field_name, dbton_id)))
4223 goto error;
4224 }
4225 DBUG_RETURN(0);
4226
4227 error:
4228 if (column_name_str)
4229 {
4230 delete [] column_name_str;
4231 column_name_str = NULL;
4232 }
4233 DBUG_RETURN(error_num);
4234 }
4235
free_column_name_str()4236 void spider_handlersocket_share::free_column_name_str()
4237 {
4238 DBUG_ENTER("spider_handlersocket_share::free_column_name_str");
4239 if (column_name_str)
4240 {
4241 delete [] column_name_str;
4242 column_name_str = NULL;
4243 }
4244 DBUG_VOID_RETURN;
4245 }
4246
get_column_name_length(uint field_index)4247 uint spider_handlersocket_share::get_column_name_length(
4248 uint field_index
4249 ) {
4250 DBUG_ENTER("spider_handlersocket_share::get_column_name_length");
4251 DBUG_PRINT("info",("spider this=%p", this));
4252 DBUG_RETURN(column_name_str[field_index].length());
4253 }
4254
append_column_name(spider_string * str,uint field_index)4255 int spider_handlersocket_share::append_column_name(
4256 spider_string *str,
4257 uint field_index
4258 ) {
4259 int error_num;
4260 DBUG_ENTER("spider_handlersocket_share::append_column_name");
4261 DBUG_PRINT("info",("spider this=%p", this));
4262 error_num = spider_db_handlersocket_utility.append_name(str,
4263 column_name_str[field_index].ptr(), column_name_str[field_index].length());
4264 DBUG_RETURN(error_num);
4265 }
4266
append_column_name_with_alias(spider_string * str,uint field_index,const char * alias,uint alias_length)4267 int spider_handlersocket_share::append_column_name_with_alias(
4268 spider_string *str,
4269 uint field_index,
4270 const char *alias,
4271 uint alias_length
4272 ) {
4273 DBUG_ENTER("spider_handlersocket_share::append_column_name_with_alias");
4274 DBUG_PRINT("info",("spider this=%p", this));
4275 if (str->reserve(
4276 alias_length +
4277 column_name_str[field_index].length() +
4278 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
4279 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4280 str->q_append(alias, alias_length);
4281 append_column_name(str, field_index);
4282 DBUG_RETURN(0);
4283 }
4284
need_change_db_table_name()4285 bool spider_handlersocket_share::need_change_db_table_name()
4286 {
4287 DBUG_ENTER("spider_handlersocket_share::need_change_db_table_name");
4288 DBUG_RETURN(!same_db_table_name);
4289 }
4290
4291 #ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
discover_table_structure(SPIDER_TRX * trx,SPIDER_SHARE * spider_share,spider_string * str)4292 int spider_handlersocket_share::discover_table_structure(
4293 SPIDER_TRX *trx,
4294 SPIDER_SHARE *spider_share,
4295 spider_string *str
4296 ) {
4297 DBUG_ENTER("spider_handlersocket_share::discover_table_structure");
4298 DBUG_PRINT("info",("spider this=%p", this));
4299 DBUG_RETURN(HA_ERR_WRONG_COMMAND);
4300 }
4301 #endif
4302
spider_handlersocket_handler(ha_spider * spider,spider_handlersocket_share * db_share)4303 spider_handlersocket_handler::spider_handlersocket_handler(
4304 ha_spider *spider,
4305 spider_handlersocket_share *db_share
4306 ) : spider_db_handler(
4307 spider,
4308 db_share
4309 ),
4310 handlersocket_share(db_share),
4311 link_for_hash(NULL)
4312 {
4313 DBUG_ENTER("spider_handlersocket_handler::spider_handlersocket_handler");
4314 DBUG_PRINT("info",("spider this=%p", this));
4315 spider_alloc_calc_mem_init(mem_calc, 187);
4316 spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
4317 DBUG_VOID_RETURN;
4318 }
4319
~spider_handlersocket_handler()4320 spider_handlersocket_handler::~spider_handlersocket_handler()
4321 {
4322 DBUG_ENTER("spider_handlersocket_handler::~spider_handlersocket_handler");
4323 DBUG_PRINT("info",("spider this=%p", this));
4324 if (link_for_hash)
4325 {
4326 spider_free(spider_current_trx, link_for_hash, MYF(0));
4327 }
4328 spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
4329 DBUG_VOID_RETURN;
4330 }
4331
init()4332 int spider_handlersocket_handler::init()
4333 {
4334 st_spider_share *share = spider->share;
4335 TABLE *table = spider->get_table();
4336 DBUG_ENTER("spider_handlersocket_handler::init");
4337 DBUG_PRINT("info",("spider this=%p", this));
4338 if (!(link_for_hash = (SPIDER_LINK_FOR_HASH *)
4339 spider_bulk_alloc_mem(spider_current_trx, 204,
4340 __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
4341 &link_for_hash,
4342 sizeof(SPIDER_LINK_FOR_HASH) * share->link_count,
4343 &minimum_select_bitmap,
4344 table ? sizeof(uchar) * no_bytes_in_map(table->read_set) : 0,
4345 NullS))
4346 ) {
4347 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4348 }
4349 uint roop_count;
4350 for (roop_count = 0; roop_count < share->link_count; roop_count++)
4351 {
4352 link_for_hash[roop_count].spider = spider;
4353 link_for_hash[roop_count].link_idx = roop_count;
4354 link_for_hash[roop_count].db_table_str =
4355 &handlersocket_share->db_table_str[roop_count];
4356 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
4357 link_for_hash[roop_count].db_table_str_hash_value =
4358 handlersocket_share->db_table_str_hash_value[roop_count];
4359 #endif
4360 }
4361 hs_sql.init_calc_mem(63);
4362 hs_sql.set_charset(share->access_charset);
4363 hs_keys.init();
4364 hs_upds.init();
4365 hs_strs.init();
4366 DBUG_RETURN(0);
4367 }
4368
append_index_hint(spider_string * str,int link_idx,ulong sql_type)4369 int spider_handlersocket_handler::append_index_hint(
4370 spider_string *str,
4371 int link_idx,
4372 ulong sql_type
4373 )
4374 {
4375 DBUG_ENTER("spider_handlersocket_handler::append_index_hint");
4376 DBUG_RETURN(0);
4377 }
4378
append_table_name_with_adjusting(spider_string * str,int link_idx,ulong sql_type)4379 int spider_handlersocket_handler::append_table_name_with_adjusting(
4380 spider_string *str,
4381 int link_idx,
4382 ulong sql_type
4383 ) {
4384 DBUG_ENTER("spider_handlersocket_handler::append_table_name_with_adjusting");
4385 DBUG_PRINT("info",("spider this=%p", this));
4386 DBUG_ASSERT(0);
4387 DBUG_RETURN(0);
4388 }
4389
append_tmp_table_and_sql_for_bka(const key_range * start_key)4390 int spider_handlersocket_handler::append_tmp_table_and_sql_for_bka(
4391 const key_range *start_key
4392 ) {
4393 DBUG_ENTER("spider_handlersocket_handler::append_tmp_table_and_sql_for_bka");
4394 DBUG_PRINT("info",("spider this=%p", this));
4395 DBUG_ASSERT(0);
4396 DBUG_RETURN(0);
4397 }
4398
reuse_tmp_table_and_sql_for_bka()4399 int spider_handlersocket_handler::reuse_tmp_table_and_sql_for_bka()
4400 {
4401 DBUG_ENTER("spider_handlersocket_handler::reuse_tmp_table_and_sql_for_bka");
4402 DBUG_PRINT("info",("spider this=%p", this));
4403 DBUG_ASSERT(0);
4404 DBUG_RETURN(0);
4405 }
4406
append_union_table_and_sql_for_bka(const key_range * start_key)4407 int spider_handlersocket_handler::append_union_table_and_sql_for_bka(
4408 const key_range *start_key
4409 ) {
4410 DBUG_ENTER("spider_handlersocket_handler::append_union_table_and_sql_for_bka");
4411 DBUG_PRINT("info",("spider this=%p", this));
4412 DBUG_ASSERT(0);
4413 DBUG_RETURN(0);
4414 }
4415
reuse_union_table_and_sql_for_bka()4416 int spider_handlersocket_handler::reuse_union_table_and_sql_for_bka()
4417 {
4418 DBUG_ENTER("spider_handlersocket_handler::reuse_union_table_and_sql_for_bka");
4419 DBUG_PRINT("info",("spider this=%p", this));
4420 DBUG_ASSERT(0);
4421 DBUG_RETURN(0);
4422 }
4423
append_insert_for_recovery(ulong sql_type,int link_idx)4424 int spider_handlersocket_handler::append_insert_for_recovery(
4425 ulong sql_type,
4426 int link_idx
4427 ) {
4428 DBUG_ENTER("spider_handlersocket_handler::append_insert_for_recovery");
4429 DBUG_PRINT("info",("spider this=%p", this));
4430 DBUG_ASSERT(0);
4431 DBUG_RETURN(0);
4432 }
4433
append_update(const TABLE * table,my_ptrdiff_t ptr_diff)4434 int spider_handlersocket_handler::append_update(
4435 const TABLE *table,
4436 my_ptrdiff_t ptr_diff
4437 ) {
4438 DBUG_ENTER("spider_handlersocket_handler::append_update");
4439 DBUG_PRINT("info",("spider this=%p", this));
4440 DBUG_ASSERT(0);
4441 DBUG_RETURN(0);
4442 }
4443
append_update(const TABLE * table,my_ptrdiff_t ptr_diff,int link_idx)4444 int spider_handlersocket_handler::append_update(
4445 const TABLE *table,
4446 my_ptrdiff_t ptr_diff,
4447 int link_idx
4448 ) {
4449 DBUG_ENTER("spider_handlersocket_handler::append_update");
4450 DBUG_PRINT("info",("spider this=%p", this));
4451 DBUG_ASSERT(0);
4452 DBUG_RETURN(0);
4453 }
4454
append_delete(const TABLE * table,my_ptrdiff_t ptr_diff)4455 int spider_handlersocket_handler::append_delete(
4456 const TABLE *table,
4457 my_ptrdiff_t ptr_diff
4458 ) {
4459 DBUG_ENTER("spider_handlersocket_handler::append_delete");
4460 DBUG_PRINT("info",("spider this=%p", this));
4461 DBUG_ASSERT(0);
4462 DBUG_RETURN(0);
4463 }
4464
append_delete(const TABLE * table,my_ptrdiff_t ptr_diff,int link_idx)4465 int spider_handlersocket_handler::append_delete(
4466 const TABLE *table,
4467 my_ptrdiff_t ptr_diff,
4468 int link_idx
4469 ) {
4470 DBUG_ENTER("spider_handlersocket_handler::append_delete");
4471 DBUG_PRINT("info",("spider this=%p", this));
4472 DBUG_ASSERT(0);
4473 DBUG_RETURN(0);
4474 }
4475
append_insert_part()4476 int spider_handlersocket_handler::append_insert_part()
4477 {
4478 DBUG_ENTER("spider_handlersocket_handler::append_insert_part");
4479 DBUG_PRINT("info",("spider this=%p", this));
4480 DBUG_ASSERT(0);
4481 DBUG_RETURN(0);
4482 }
4483
append_update_part()4484 int spider_handlersocket_handler::append_update_part()
4485 {
4486 DBUG_ENTER("spider_handlersocket_handler::append_update_part");
4487 DBUG_PRINT("info",("spider this=%p", this));
4488 DBUG_ASSERT(0);
4489 DBUG_RETURN(0);
4490 }
4491
append_delete_part()4492 int spider_handlersocket_handler::append_delete_part()
4493 {
4494 DBUG_ENTER("spider_handlersocket_handler::append_delete_part");
4495 DBUG_PRINT("info",("spider this=%p", this));
4496 DBUG_ASSERT(0);
4497 DBUG_RETURN(0);
4498 }
4499
4500 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
append_increment_update_set_part()4501 int spider_handlersocket_handler::append_increment_update_set_part()
4502 {
4503 DBUG_ENTER("spider_handlersocket_handler::append_increment_update_set_part");
4504 DBUG_PRINT("info",("spider this=%p", this));
4505 DBUG_ASSERT(0);
4506 DBUG_RETURN(0);
4507 }
4508 #endif
4509
append_update_set_part()4510 int spider_handlersocket_handler::append_update_set_part()
4511 {
4512 DBUG_ENTER("spider_handlersocket_handler::append_update_set_part");
4513 DBUG_PRINT("info",("spider this=%p", this));
4514 DBUG_ASSERT(0);
4515 DBUG_RETURN(0);
4516 }
4517
4518 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
append_direct_update_set_part()4519 int spider_handlersocket_handler::append_direct_update_set_part()
4520 {
4521 SPIDER_SHARE *share = spider->share;
4522 DBUG_ENTER("spider_handlersocket_handler::append_direct_update_set_part");
4523 if (
4524 spider->do_direct_update &&
4525 (spider->direct_update_kinds & SPIDER_SQL_KIND_HS)
4526 ) {
4527 DBUG_PRINT("info",("spider add set for DU SPIDER_SQL_KIND_HS"));
4528 size_t roop_count;
4529 Field *field;
4530 hs_adding_keys = FALSE;
4531 for (roop_count = 0; roop_count < spider->hs_pushed_ret_fields_num;
4532 roop_count++)
4533 {
4534 Field *top_table_field =
4535 spider->get_top_table_field(spider->hs_pushed_ret_fields[roop_count]);
4536 if (!(field = spider->field_exchange(top_table_field)))
4537 continue;
4538 if (top_table_field->is_null())
4539 {
4540 hs_upds.push_back(spider_null_string_ref);
4541 } else {
4542 if (spider_db_handlersocket_utility.
4543 append_column_value(spider, NULL, top_table_field, NULL,
4544 share->access_charset))
4545 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4546 }
4547 }
4548 }
4549 DBUG_RETURN(0);
4550 }
4551 #endif
4552
append_minimum_select_without_quote(spider_string * str)4553 int spider_handlersocket_handler::append_minimum_select_without_quote(
4554 spider_string *str
4555 ) {
4556 TABLE *table = spider->get_table();
4557 Field **field;
4558 int field_length;
4559 bool appended = FALSE;
4560 DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_without_quote");
4561 minimum_select_bitmap_create();
4562 for (field = table->field; *field; field++)
4563 {
4564 if (minimum_select_bit_is_set((*field)->field_index))
4565 {
4566 /*
4567 spider_set_bit(minimum_select_bitmap, (*field)->field_index);
4568 */
4569 field_length =
4570 handlersocket_share->column_name_str[(*field)->field_index].length();
4571 if (str->reserve(field_length + SPIDER_SQL_COMMA_LEN))
4572 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4573 str->q_append(
4574 handlersocket_share->column_name_str[(*field)->field_index].ptr(),
4575 handlersocket_share->column_name_str[(*field)->field_index].length());
4576 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
4577 appended = TRUE;
4578 }
4579 }
4580 if (appended)
4581 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
4582 DBUG_RETURN(0);
4583 }
4584
4585 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
append_minimum_select_by_field_idx_list(spider_string * str,uint32 * field_idxs,size_t field_idxs_num)4586 int spider_handlersocket_handler::append_minimum_select_by_field_idx_list(
4587 spider_string *str,
4588 uint32 *field_idxs,
4589 size_t field_idxs_num
4590 ) {
4591 Field *field;
4592 int roop_count, field_length;
4593 bool appended = FALSE;
4594 DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_by_field_idx_list");
4595 for (roop_count = 0; roop_count < (int) field_idxs_num; roop_count++)
4596 {
4597 field = spider->get_top_table_field(field_idxs[roop_count]);
4598 if ((field = spider->field_exchange(field)))
4599 {
4600 field_length =
4601 handlersocket_share->column_name_str[field->field_index].length();
4602 if (str->reserve(field_length + SPIDER_SQL_COMMA_LEN))
4603 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4604 str->q_append(
4605 handlersocket_share->column_name_str[field->field_index].ptr(),
4606 handlersocket_share->column_name_str[field->field_index].length());
4607 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
4608 appended = TRUE;
4609 }
4610 }
4611 if (appended)
4612 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
4613 DBUG_RETURN(0);
4614 }
4615
append_dup_update_pushdown_part(const char * alias,uint alias_length)4616 int spider_handlersocket_handler::append_dup_update_pushdown_part(
4617 const char *alias,
4618 uint alias_length
4619 ) {
4620 DBUG_ENTER("spider_handlersocket_handler::append_dup_update_pushdown_part");
4621 DBUG_PRINT("info",("spider this=%p", this));
4622 DBUG_ASSERT(0);
4623 DBUG_RETURN(0);
4624 }
4625
append_update_columns_part(const char * alias,uint alias_length)4626 int spider_handlersocket_handler::append_update_columns_part(
4627 const char *alias,
4628 uint alias_length
4629 ) {
4630 DBUG_ENTER("spider_handlersocket_handler::append_update_columns_part");
4631 DBUG_PRINT("info",("spider this=%p", this));
4632 DBUG_ASSERT(0);
4633 DBUG_RETURN(0);
4634 }
4635
check_update_columns_part()4636 int spider_handlersocket_handler::check_update_columns_part()
4637 {
4638 DBUG_ENTER("spider_handlersocket_handler::check_update_columns_part");
4639 DBUG_PRINT("info",("spider this=%p", this));
4640 DBUG_ASSERT(0);
4641 DBUG_RETURN(0);
4642 }
4643 #endif
4644
append_select_part(ulong sql_type)4645 int spider_handlersocket_handler::append_select_part(
4646 ulong sql_type
4647 ) {
4648 DBUG_ENTER("spider_handlersocket_handler::append_select_part");
4649 DBUG_PRINT("info",("spider this=%p", this));
4650 DBUG_ASSERT(0);
4651 DBUG_RETURN(0);
4652 }
4653
append_table_select_part(ulong sql_type)4654 int spider_handlersocket_handler::append_table_select_part(
4655 ulong sql_type
4656 ) {
4657 DBUG_ENTER("spider_handlersocket_handler::append_table_select_part");
4658 DBUG_PRINT("info",("spider this=%p", this));
4659 DBUG_ASSERT(0);
4660 DBUG_RETURN(0);
4661 }
4662
append_key_select_part(ulong sql_type,uint idx)4663 int spider_handlersocket_handler::append_key_select_part(
4664 ulong sql_type,
4665 uint idx
4666 ) {
4667 DBUG_ENTER("spider_handlersocket_handler::append_key_select_part");
4668 DBUG_PRINT("info",("spider this=%p", this));
4669 DBUG_ASSERT(0);
4670 DBUG_RETURN(0);
4671 }
4672
append_minimum_select_part(ulong sql_type)4673 int spider_handlersocket_handler::append_minimum_select_part(
4674 ulong sql_type
4675 ) {
4676 DBUG_ENTER("spider_handlersocket_handler::append_minimum_select_part");
4677 DBUG_PRINT("info",("spider this=%p", this));
4678 DBUG_ASSERT(0);
4679 DBUG_RETURN(0);
4680 }
4681
append_hint_after_table_part(ulong sql_type)4682 int spider_handlersocket_handler::append_hint_after_table_part(
4683 ulong sql_type
4684 ) {
4685 DBUG_ENTER("spider_handlersocket_handler::append_hint_after_table_part");
4686 DBUG_PRINT("info",("spider this=%p", this));
4687 DBUG_ASSERT(0);
4688 DBUG_RETURN(0);
4689 }
4690
set_where_pos(ulong sql_type)4691 void spider_handlersocket_handler::set_where_pos(
4692 ulong sql_type
4693 ) {
4694 DBUG_ENTER("spider_handlersocket_handler::set_where_pos");
4695 DBUG_PRINT("info",("spider this=%p", this));
4696 DBUG_ASSERT(0);
4697 DBUG_VOID_RETURN;
4698 }
4699
set_where_to_pos(ulong sql_type)4700 void spider_handlersocket_handler::set_where_to_pos(
4701 ulong sql_type
4702 ) {
4703 DBUG_ENTER("spider_handlersocket_handler::set_where_to_pos");
4704 DBUG_PRINT("info",("spider this=%p", this));
4705 DBUG_ASSERT(0);
4706 DBUG_VOID_RETURN;
4707 }
4708
check_item_type(Item * item)4709 int spider_handlersocket_handler::check_item_type(
4710 Item *item
4711 ) {
4712 DBUG_ENTER("spider_handlersocket_handler::check_item_type");
4713 DBUG_PRINT("info",("spider this=%p", this));
4714 DBUG_ASSERT(0);
4715 DBUG_RETURN(0);
4716 }
4717
append_values_connector_part(ulong sql_type)4718 int spider_handlersocket_handler::append_values_connector_part(
4719 ulong sql_type
4720 ) {
4721 DBUG_ENTER("spider_handlersocket_handler::append_values_connector_part");
4722 DBUG_PRINT("info",("spider this=%p", this));
4723 DBUG_ASSERT(0);
4724 DBUG_RETURN(0);
4725 }
4726
append_values_terminator_part(ulong sql_type)4727 int spider_handlersocket_handler::append_values_terminator_part(
4728 ulong sql_type
4729 ) {
4730 DBUG_ENTER("spider_handlersocket_handler::append_values_terminator_part");
4731 DBUG_PRINT("info",("spider this=%p", this));
4732 DBUG_ASSERT(0);
4733 DBUG_RETURN(0);
4734 }
4735
append_union_table_connector_part(ulong sql_type)4736 int spider_handlersocket_handler::append_union_table_connector_part(
4737 ulong sql_type
4738 ) {
4739 DBUG_ENTER("spider_handlersocket_handler::append_union_table_connector_part");
4740 DBUG_PRINT("info",("spider this=%p", this));
4741 DBUG_ASSERT(0);
4742 DBUG_RETURN(0);
4743 }
4744
append_union_table_terminator_part(ulong sql_type)4745 int spider_handlersocket_handler::append_union_table_terminator_part(
4746 ulong sql_type
4747 ) {
4748 DBUG_ENTER("spider_handlersocket_handler::append_union_table_terminator_part");
4749 DBUG_PRINT("info",("spider this=%p", this));
4750 DBUG_ASSERT(0);
4751 DBUG_RETURN(0);
4752 }
4753
append_key_column_values_part(const key_range * start_key,ulong sql_type)4754 int spider_handlersocket_handler::append_key_column_values_part(
4755 const key_range *start_key,
4756 ulong sql_type
4757 ) {
4758 DBUG_ENTER("spider_handlersocket_handler::append_key_column_values_part");
4759 DBUG_PRINT("info",("spider this=%p", this));
4760 DBUG_ASSERT(0);
4761 DBUG_RETURN(0);
4762 }
4763
append_key_column_values_with_name_part(const key_range * start_key,ulong sql_type)4764 int spider_handlersocket_handler::append_key_column_values_with_name_part(
4765 const key_range *start_key,
4766 ulong sql_type
4767 ) {
4768 DBUG_ENTER("spider_handlersocket_handler::append_key_column_values_with_name_part");
4769 DBUG_PRINT("info",("spider this=%p", this));
4770 DBUG_ASSERT(0);
4771 DBUG_RETURN(0);
4772 }
4773
append_key_where_part(const key_range * start_key,const key_range * end_key,ulong sql_type)4774 int spider_handlersocket_handler::append_key_where_part(
4775 const key_range *start_key,
4776 const key_range *end_key,
4777 ulong sql_type
4778 ) {
4779 int error_num;
4780 spider_string *str;
4781 bool set_order;
4782 DBUG_ENTER("spider_handlersocket_handler::append_key_where_part");
4783 switch (sql_type)
4784 {
4785 case SPIDER_SQL_TYPE_SELECT_HS:
4786 case SPIDER_SQL_TYPE_INSERT_HS:
4787 case SPIDER_SQL_TYPE_UPDATE_HS:
4788 case SPIDER_SQL_TYPE_DELETE_HS:
4789 str = &hs_sql;
4790 str->length(0);
4791 hs_adding_keys = TRUE;
4792 set_order = FALSE;
4793 break;
4794 default:
4795 DBUG_RETURN(0);
4796 }
4797 error_num = append_key_where(str, NULL, NULL, start_key, end_key,
4798 sql_type, set_order);
4799 DBUG_RETURN(error_num);
4800 }
4801
append_key_where(spider_string * str,spider_string * str_part,spider_string * str_part2,const key_range * start_key,const key_range * end_key,ulong sql_type,bool set_order)4802 int spider_handlersocket_handler::append_key_where(
4803 spider_string *str,
4804 spider_string *str_part,
4805 spider_string *str_part2,
4806 const key_range *start_key,
4807 const key_range *end_key,
4808 ulong sql_type,
4809 bool set_order
4810 ) {
4811 int error_num;
4812 DBUG_ENTER("spider_handlersocket_handler::append_key_where");
4813 error_num = spider_db_append_key_where_internal(str, str_part, str_part2,
4814 start_key, end_key, spider, set_order, sql_type,
4815 spider_dbton_handlersocket.dbton_id);
4816 DBUG_RETURN(error_num);
4817 }
4818
append_is_null_part(ulong sql_type,KEY_PART_INFO * key_part,const key_range * key,const uchar ** ptr,bool key_eq,bool tgt_final)4819 int spider_handlersocket_handler::append_is_null_part(
4820 ulong sql_type,
4821 KEY_PART_INFO *key_part,
4822 const key_range *key,
4823 const uchar **ptr,
4824 bool key_eq,
4825 bool tgt_final
4826 ) {
4827 int error_num;
4828 spider_string *str;
4829 DBUG_ENTER("spider_handlersocket_handler::append_is_null_part");
4830 DBUG_PRINT("info",("spider this=%p", this));
4831 switch (sql_type)
4832 {
4833 case SPIDER_SQL_TYPE_SELECT_HS:
4834 case SPIDER_SQL_TYPE_INSERT_HS:
4835 case SPIDER_SQL_TYPE_UPDATE_HS:
4836 case SPIDER_SQL_TYPE_DELETE_HS:
4837 str = &hs_sql;
4838 break;
4839 default:
4840 DBUG_RETURN(0);
4841 }
4842 error_num = append_is_null(sql_type, str, NULL, NULL, key_part, key, ptr,
4843 key_eq, tgt_final);
4844 DBUG_RETURN(error_num);
4845 }
4846
append_is_null(ulong sql_type,spider_string * str,spider_string * str_part,spider_string * str_part2,KEY_PART_INFO * key_part,const key_range * key,const uchar ** ptr,bool key_eq,bool tgt_final)4847 int spider_handlersocket_handler::append_is_null(
4848 ulong sql_type,
4849 spider_string *str,
4850 spider_string *str_part,
4851 spider_string *str_part2,
4852 KEY_PART_INFO *key_part,
4853 const key_range *key,
4854 const uchar **ptr,
4855 bool key_eq,
4856 bool tgt_final
4857 ) {
4858 DBUG_ENTER("spider_handlersocket_handler::append_is_null");
4859 DBUG_PRINT("info",("spider this=%p", this));
4860 if (key_part->null_bit)
4861 {
4862 if (*(*ptr)++)
4863 {
4864 hs_keys.push_back(spider_null_string_ref);
4865 DBUG_RETURN(-1);
4866 }
4867 }
4868 DBUG_RETURN(0);
4869 }
4870
append_where_terminator_part(ulong sql_type,bool set_order,int key_count)4871 int spider_handlersocket_handler::append_where_terminator_part(
4872 ulong sql_type,
4873 bool set_order,
4874 int key_count
4875 ) {
4876 DBUG_ENTER("spider_handlersocket_handler::append_where_terminator_part");
4877 DBUG_PRINT("info",("spider this=%p", this));
4878 DBUG_RETURN(0);
4879 }
4880
append_match_where_part(ulong sql_type)4881 int spider_handlersocket_handler::append_match_where_part(
4882 ulong sql_type
4883 ) {
4884 DBUG_ENTER("spider_handlersocket_handler::append_match_where_part");
4885 DBUG_PRINT("info",("spider this=%p", this));
4886 DBUG_ASSERT(0);
4887 DBUG_RETURN(0);
4888 }
4889
append_condition_part(const char * alias,uint alias_length,ulong sql_type,bool test_flg)4890 int spider_handlersocket_handler::append_condition_part(
4891 const char *alias,
4892 uint alias_length,
4893 ulong sql_type,
4894 bool test_flg
4895 ) {
4896 DBUG_ENTER("spider_handlersocket_handler::append_condition_part");
4897 DBUG_PRINT("info",("spider this=%p", this));
4898 DBUG_RETURN(0);
4899 }
4900
append_match_select_part(ulong sql_type,const char * alias,uint alias_length)4901 int spider_handlersocket_handler::append_match_select_part(
4902 ulong sql_type,
4903 const char *alias,
4904 uint alias_length
4905 ) {
4906 DBUG_ENTER("spider_handlersocket_handler::append_match_select_part");
4907 DBUG_PRINT("info",("spider this=%p", this));
4908 DBUG_ASSERT(0);
4909 DBUG_RETURN(0);
4910 }
4911
4912 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
append_sum_select_part(ulong sql_type,const char * alias,uint alias_length)4913 int spider_handlersocket_handler::append_sum_select_part(
4914 ulong sql_type,
4915 const char *alias,
4916 uint alias_length
4917 ) {
4918 DBUG_ENTER("spider_handlersocket_handler::append_sum_select_part");
4919 DBUG_PRINT("info",("spider this=%p", this));
4920 DBUG_ASSERT(0);
4921 DBUG_RETURN(0);
4922 }
4923 #endif
4924
set_order_pos(ulong sql_type)4925 void spider_handlersocket_handler::set_order_pos(
4926 ulong sql_type
4927 ) {
4928 DBUG_ENTER("spider_handlersocket_handler::set_order_pos");
4929 DBUG_PRINT("info",("spider this=%p", this));
4930 DBUG_ASSERT(0);
4931 DBUG_VOID_RETURN;
4932 }
4933
set_order_to_pos(ulong sql_type)4934 void spider_handlersocket_handler::set_order_to_pos(
4935 ulong sql_type
4936 ) {
4937 DBUG_ENTER("spider_handlersocket_handler::set_order_to_pos");
4938 DBUG_PRINT("info",("spider this=%p", this));
4939 DBUG_ASSERT(0);
4940 DBUG_VOID_RETURN;
4941 }
4942
4943 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
append_group_by_part(const char * alias,uint alias_length,ulong sql_type)4944 int spider_handlersocket_handler::append_group_by_part(
4945 const char *alias,
4946 uint alias_length,
4947 ulong sql_type
4948 ) {
4949 DBUG_ENTER("spider_handlersocket_handler::append_group_by_part");
4950 DBUG_PRINT("info",("spider this=%p", this));
4951 DBUG_ASSERT(0);
4952 DBUG_RETURN(0);
4953 }
4954 #endif
4955
append_key_order_for_merge_with_alias_part(const char * alias,uint alias_length,ulong sql_type)4956 int spider_handlersocket_handler::append_key_order_for_merge_with_alias_part(
4957 const char *alias,
4958 uint alias_length,
4959 ulong sql_type
4960 ) {
4961 DBUG_ENTER("spider_handlersocket_handler::append_key_order_for_merge_with_alias_part");
4962 DBUG_PRINT("info",("spider this=%p", this));
4963 DBUG_ASSERT(0);
4964 DBUG_RETURN(0);
4965 }
4966
append_key_order_for_direct_order_limit_with_alias_part(const char * alias,uint alias_length,ulong sql_type)4967 int spider_handlersocket_handler::append_key_order_for_direct_order_limit_with_alias_part(
4968 const char *alias,
4969 uint alias_length,
4970 ulong sql_type
4971 ) {
4972 DBUG_ENTER("spider_handlersocket_handler::append_key_order_for_direct_order_limit_with_alias_part");
4973 DBUG_PRINT("info",("spider this=%p", this));
4974 DBUG_ASSERT(0);
4975 DBUG_RETURN(0);
4976 }
4977
append_key_order_with_alias_part(const char * alias,uint alias_length,ulong sql_type)4978 int spider_handlersocket_handler::append_key_order_with_alias_part(
4979 const char *alias,
4980 uint alias_length,
4981 ulong sql_type
4982 ) {
4983 DBUG_ENTER("spider_handlersocket_handler::append_key_order_with_alias_part");
4984 DBUG_PRINT("info",("spider this=%p", this));
4985 DBUG_ASSERT(0);
4986 DBUG_RETURN(0);
4987 }
4988
append_limit_part(longlong offset,longlong limit,ulong sql_type)4989 int spider_handlersocket_handler::append_limit_part(
4990 longlong offset,
4991 longlong limit,
4992 ulong sql_type
4993 ) {
4994 DBUG_ENTER("spider_handlersocket_handler::append_limit_part");
4995 DBUG_PRINT("info",("spider this=%p", this));
4996 DBUG_PRINT("info", ("spider offset=%lld", offset));
4997 DBUG_PRINT("info", ("spider limit=%lld", limit));
4998 hs_skip = (int) offset;
4999 hs_limit = (int) limit;
5000 DBUG_RETURN(0);
5001 }
5002
reappend_limit_part(longlong offset,longlong limit,ulong sql_type)5003 int spider_handlersocket_handler::reappend_limit_part(
5004 longlong offset,
5005 longlong limit,
5006 ulong sql_type
5007 ) {
5008 DBUG_ENTER("spider_handlersocket_handler::reappend_limit_part");
5009 DBUG_PRINT("info",("spider this=%p", this));
5010 DBUG_ASSERT(0);
5011 DBUG_RETURN(0);
5012 }
5013
append_select_lock_part(ulong sql_type)5014 int spider_handlersocket_handler::append_select_lock_part(
5015 ulong sql_type
5016 ) {
5017 DBUG_ENTER("spider_handlersocket_handler::append_select_lock_part");
5018 DBUG_PRINT("info",("spider this=%p", this));
5019 DBUG_ASSERT(0);
5020 DBUG_RETURN(0);
5021 }
5022
append_union_all_start_part(ulong sql_type)5023 int spider_handlersocket_handler::append_union_all_start_part(
5024 ulong sql_type
5025 ) {
5026 DBUG_ENTER("spider_handlersocket_handler::append_union_all_start_part");
5027 DBUG_PRINT("info",("spider this=%p", this));
5028 DBUG_ASSERT(0);
5029 DBUG_RETURN(0);
5030 }
5031
append_union_all_part(ulong sql_type)5032 int spider_handlersocket_handler::append_union_all_part(
5033 ulong sql_type
5034 ) {
5035 DBUG_ENTER("spider_handlersocket_handler::append_union_all_part");
5036 DBUG_PRINT("info",("spider this=%p", this));
5037 DBUG_ASSERT(0);
5038 DBUG_RETURN(0);
5039 }
5040
append_union_all_end_part(ulong sql_type)5041 int spider_handlersocket_handler::append_union_all_end_part(
5042 ulong sql_type
5043 ) {
5044 DBUG_ENTER("spider_handlersocket_handler::append_union_all_end_part");
5045 DBUG_PRINT("info",("spider this=%p", this));
5046 DBUG_ASSERT(0);
5047 DBUG_RETURN(0);
5048 }
5049
append_multi_range_cnt_part(ulong sql_type,uint multi_range_cnt,bool with_comma)5050 int spider_handlersocket_handler::append_multi_range_cnt_part(
5051 ulong sql_type,
5052 uint multi_range_cnt,
5053 bool with_comma
5054 ) {
5055 DBUG_ENTER("spider_handlersocket_handler::append_multi_range_cnt_part");
5056 DBUG_PRINT("info",("spider this=%p", this));
5057 DBUG_ASSERT(0);
5058 DBUG_RETURN(0);
5059 }
5060
append_multi_range_cnt_with_name_part(ulong sql_type,uint multi_range_cnt)5061 int spider_handlersocket_handler::append_multi_range_cnt_with_name_part(
5062 ulong sql_type,
5063 uint multi_range_cnt
5064 ) {
5065 DBUG_ENTER("spider_handlersocket_handler::append_multi_range_cnt_with_name_part");
5066 DBUG_PRINT("info",("spider this=%p", this));
5067 DBUG_ASSERT(0);
5068 DBUG_RETURN(0);
5069 }
5070
append_open_handler_part(ulong sql_type,uint handler_id,SPIDER_CONN * conn,int link_idx)5071 int spider_handlersocket_handler::append_open_handler_part(
5072 ulong sql_type,
5073 uint handler_id,
5074 SPIDER_CONN *conn,
5075 int link_idx
5076 ) {
5077 int error_num;
5078 spider_string *str;
5079 DBUG_ENTER("spider_handlersocket_handler::append_open_handler_part");
5080 DBUG_PRINT("info",("spider this=%p", this));
5081 switch (sql_type)
5082 {
5083 case SPIDER_SQL_TYPE_OTHER_HS:
5084 str = &hs_sql;
5085 break;
5086 default:
5087 DBUG_RETURN(0);
5088 }
5089 error_num = append_open_handler(str, handler_id, conn, link_idx);
5090 DBUG_RETURN(error_num);
5091 }
5092
append_open_handler(spider_string * str,uint handler_id,SPIDER_CONN * conn,int link_idx)5093 int spider_handlersocket_handler::append_open_handler(
5094 spider_string *str,
5095 uint handler_id,
5096 SPIDER_CONN *conn,
5097 int link_idx
5098 ) {
5099 int error_num;
5100 DBUG_ENTER("spider_handlersocket_handler::append_open_handler");
5101 DBUG_PRINT("info",("spider this=%p", this));
5102 if (
5103 str->length() == 0 &&
5104 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
5105 (
5106 (
5107 (
5108 spider->sql_command == SQLCOM_HS_INSERT ||
5109 spider->hs_pushed_ret_fields_num == MAX_FIELDS
5110 ) &&
5111 #endif
5112 (error_num = append_minimum_select_without_quote(str))
5113 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
5114 ) ||
5115 (
5116 (
5117 spider->sql_command != SQLCOM_HS_INSERT &&
5118 spider->hs_pushed_ret_fields_num < MAX_FIELDS
5119 ) &&
5120 (error_num = append_minimum_select_by_field_idx_list(str,
5121 spider->hs_pushed_ret_fields, spider->hs_pushed_ret_fields_num))
5122 )
5123 )
5124 #endif
5125 ) {
5126 DBUG_RETURN(error_num);
5127 }
5128
5129 TABLE *table = spider->get_table();
5130 SPIDER_SHARE *share = spider->share;
5131 DBUG_PRINT("info",("spider field list=%s", str->c_ptr_safe()));
5132 if (!spider_bit_is_set(spider->db_request_phase, link_idx))
5133 {
5134 spider_set_bit(spider->db_request_phase, link_idx);
5135 ++spider->db_request_id[link_idx];
5136 }
5137 st_spider_db_request_key request_key;
5138 request_key.spider_thread_id = spider->trx->spider_thread_id;
5139 request_key.query_id = spider->trx->thd->query_id;
5140 request_key.handler = spider;
5141 request_key.request_id = spider->db_request_id[link_idx];
5142 request_key.next = NULL;
5143 conn->db_conn->append_open_handler(
5144 handler_id,
5145 share->tgt_dbs[spider->conn_link_idx[link_idx]],
5146 share->tgt_table_names[spider->conn_link_idx[link_idx]],
5147 spider->active_index < MAX_KEY ?
5148 table->s->key_info[spider->active_index].name :
5149 "0",
5150 str->c_ptr_safe(),
5151 &request_key
5152 );
5153 DBUG_RETURN(0);
5154 }
5155
append_close_handler_part(ulong sql_type,int link_idx)5156 int spider_handlersocket_handler::append_close_handler_part(
5157 ulong sql_type,
5158 int link_idx
5159 ) {
5160 DBUG_ENTER("spider_handlersocket_handler::append_close_handler_part");
5161 DBUG_PRINT("info",("spider this=%p", this));
5162 DBUG_ASSERT(0);
5163 DBUG_RETURN(0);
5164 }
5165
append_insert_terminator_part(ulong sql_type)5166 int spider_handlersocket_handler::append_insert_terminator_part(
5167 ulong sql_type
5168 ) {
5169 DBUG_ENTER("spider_handlersocket_handler::append_insert_terminator_part");
5170 DBUG_PRINT("info",("spider this=%p", this));
5171 DBUG_ASSERT(0);
5172 DBUG_RETURN(0);
5173 }
5174
append_insert_values_part(ulong sql_type)5175 int spider_handlersocket_handler::append_insert_values_part(
5176 ulong sql_type
5177 ) {
5178 int error_num;
5179 spider_string *str;
5180 DBUG_ENTER("spider_mysql_handler::append_insert_values_part");
5181 DBUG_PRINT("info",("spider this=%p", this));
5182 switch (sql_type)
5183 {
5184 case SPIDER_SQL_TYPE_INSERT_HS:
5185 str = &hs_sql;
5186 break;
5187 default:
5188 DBUG_RETURN(0);
5189 }
5190 error_num = append_insert_values(str);
5191 DBUG_RETURN(error_num);
5192 }
5193
append_insert_values(spider_string * str)5194 int spider_handlersocket_handler::append_insert_values(
5195 spider_string *str
5196 ) {
5197 SPIDER_SHARE *share = spider->share;
5198 TABLE *table = spider->get_table();
5199 Field **field;
5200 DBUG_ENTER("spider_mysql_handler::append_insert_values");
5201 DBUG_PRINT("info",("spider this=%p", this));
5202 hs_adding_keys = FALSE;
5203 for (field = table->field; *field; field++)
5204 {
5205 DBUG_PRINT("info",("spider field_index=%u", (*field)->field_index));
5206 if (
5207 bitmap_is_set(table->write_set, (*field)->field_index) ||
5208 bitmap_is_set(table->read_set, (*field)->field_index)
5209 ) {
5210 #ifndef DBUG_OFF
5211 my_bitmap_map *tmp_map =
5212 dbug_tmp_use_all_columns(table, table->read_set);
5213 #endif
5214 DBUG_PRINT("info",("spider is_null()=%s",
5215 (*field)->is_null() ? "TRUE" : "FALSE"));
5216 DBUG_PRINT("info",("spider table->next_number_field=%p",
5217 table->next_number_field));
5218 DBUG_PRINT("info",("spider *field=%p", *field));
5219 DBUG_PRINT("info",("spider force_auto_increment=%s",
5220 (table->next_number_field && spider->force_auto_increment) ?
5221 "TRUE" : "FALSE"));
5222 if (
5223 (*field)->is_null() ||
5224 (
5225 table->next_number_field == *field &&
5226 !table->auto_increment_field_not_null &&
5227 !spider->force_auto_increment
5228 )
5229 ) {
5230 hs_upds.push_back(spider_null_string_ref);
5231 } else {
5232 spider_db_handlersocket_utility.
5233 append_column_value(spider, NULL, *field, NULL,
5234 share->access_charset);
5235 }
5236 #ifndef DBUG_OFF
5237 dbug_tmp_restore_column_map(table->read_set, tmp_map);
5238 #endif
5239 }
5240 }
5241 int error_num;
5242 int roop_count2;
5243 for (
5244 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
5245 spider->conn_link_idx, -1, share->link_count,
5246 SPIDER_LINK_STATUS_RECOVERY);
5247 roop_count2 < (int) share->link_count;
5248 roop_count2 = spider_conn_link_idx_next(share->link_statuses,
5249 spider->conn_link_idx, roop_count2, share->link_count,
5250 SPIDER_LINK_STATUS_RECOVERY)
5251 ) {
5252 if (spider->sql_kind[roop_count2] == SPIDER_SQL_KIND_HS)
5253 {
5254 SPIDER_CONN *conn = spider->hs_w_conns[roop_count2];
5255 if (conn->dbton_id == spider_dbton_handlersocket.dbton_id)
5256 {
5257 if ((error_num = request_buf_insert(roop_count2)))
5258 DBUG_RETURN(error_num);
5259 #ifdef HA_CAN_BULK_ACCESS
5260 if (spider->is_bulk_access_clone)
5261 {
5262 spider->connection_ids[roop_count2] = conn->connection_id;
5263 spider_trx_add_bulk_access_conn(spider->trx, conn);
5264 }
5265 #endif
5266 }
5267 }
5268 }
5269 hs_upds.clear();
5270 DBUG_RETURN(0);
5271 }
5272
append_into_part(ulong sql_type)5273 int spider_handlersocket_handler::append_into_part(
5274 ulong sql_type
5275 ) {
5276 DBUG_ENTER("spider_handlersocket_handler::append_into_part");
5277 DBUG_PRINT("info",("spider this=%p", this));
5278 DBUG_ASSERT(0);
5279 DBUG_RETURN(0);
5280 }
5281
set_insert_to_pos(ulong sql_type)5282 void spider_handlersocket_handler::set_insert_to_pos(
5283 ulong sql_type
5284 ) {
5285 DBUG_ENTER("spider_handlersocket_handler::set_insert_to_pos");
5286 DBUG_PRINT("info",("spider this=%p", this));
5287 DBUG_ASSERT(0);
5288 DBUG_VOID_RETURN;
5289 }
5290
append_from_part(ulong sql_type,int link_idx)5291 int spider_handlersocket_handler::append_from_part(
5292 ulong sql_type,
5293 int link_idx
5294 ) {
5295 DBUG_ENTER("spider_handlersocket_handler::append_from_part");
5296 DBUG_PRINT("info",("spider this=%p", this));
5297 DBUG_ASSERT(0);
5298 DBUG_RETURN(0);
5299 }
5300
append_delete_all_rows_part(ulong sql_type)5301 int spider_handlersocket_handler::append_delete_all_rows_part(
5302 ulong sql_type
5303 ) {
5304 DBUG_ENTER("spider_handlersocket_handler::append_delete_all_rows_part");
5305 DBUG_PRINT("info",("spider this=%p", this));
5306 DBUG_ASSERT(0);
5307 DBUG_RETURN(0);
5308 }
5309
append_explain_select_part(key_range * start_key,key_range * end_key,ulong sql_type,int link_idx)5310 int spider_handlersocket_handler::append_explain_select_part(
5311 key_range *start_key,
5312 key_range *end_key,
5313 ulong sql_type,
5314 int link_idx
5315 ) {
5316 DBUG_ENTER("spider_handlersocket_handler::append_explain_select_part");
5317 DBUG_PRINT("info",("spider this=%p", this));
5318 DBUG_ASSERT(0);
5319 DBUG_RETURN(0);
5320 }
5321
is_sole_projection_field(uint16 field_index)5322 int spider_handlersocket_handler::is_sole_projection_field(
5323 uint16 field_index
5324 ) {
5325 DBUG_ENTER("spider_handlersocket_handler::is_sole_projection_field");
5326 DBUG_PRINT("info",("spider this=%p", this));
5327 DBUG_ASSERT(0);
5328 DBUG_RETURN(0);
5329 }
5330
is_bulk_insert_exec_period(bool bulk_end)5331 bool spider_handlersocket_handler::is_bulk_insert_exec_period(
5332 bool bulk_end
5333 ) {
5334 DBUG_ENTER("spider_handlersocket_handler::is_bulk_insert_exec_period");
5335 DBUG_PRINT("info",("spider this=%p", this));
5336 if (!spider->bulk_insert || bulk_end)
5337 DBUG_RETURN(TRUE);
5338 DBUG_RETURN(FALSE);
5339 }
5340
sql_is_filled_up(ulong sql_type)5341 bool spider_handlersocket_handler::sql_is_filled_up(
5342 ulong sql_type
5343 ) {
5344 DBUG_ENTER("spider_handlersocket_handler::sql_is_filled_up");
5345 DBUG_PRINT("info",("spider this=%p", this));
5346 DBUG_ASSERT(0);
5347 DBUG_RETURN(FALSE);
5348 }
5349
sql_is_empty(ulong sql_type)5350 bool spider_handlersocket_handler::sql_is_empty(
5351 ulong sql_type
5352 ) {
5353 DBUG_ENTER("spider_handlersocket_handler::sql_is_empty");
5354 DBUG_PRINT("info",("spider this=%p", this));
5355 DBUG_ASSERT(0);
5356 DBUG_RETURN(FALSE);
5357 }
5358
support_multi_split_read()5359 bool spider_handlersocket_handler::support_multi_split_read()
5360 {
5361 DBUG_ENTER("spider_handlersocket_handler::support_multi_split_read");
5362 DBUG_PRINT("info",("spider this=%p", this));
5363 DBUG_ASSERT(0);
5364 DBUG_RETURN(FALSE);
5365 }
5366
support_bulk_update()5367 bool spider_handlersocket_handler::support_bulk_update()
5368 {
5369 DBUG_ENTER("spider_handlersocket_handler::support_bulk_update");
5370 DBUG_PRINT("info",("spider this=%p", this));
5371 DBUG_ASSERT(0);
5372 DBUG_RETURN(FALSE);
5373 }
5374
bulk_tmp_table_insert()5375 int spider_handlersocket_handler::bulk_tmp_table_insert()
5376 {
5377 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_insert");
5378 DBUG_PRINT("info",("spider this=%p", this));
5379 DBUG_ASSERT(0);
5380 DBUG_RETURN(0);
5381 }
5382
bulk_tmp_table_insert(int link_idx)5383 int spider_handlersocket_handler::bulk_tmp_table_insert(
5384 int link_idx
5385 ) {
5386 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_insert");
5387 DBUG_PRINT("info",("spider this=%p", this));
5388 DBUG_ASSERT(0);
5389 DBUG_RETURN(0);
5390 }
5391
bulk_tmp_table_end_bulk_insert()5392 int spider_handlersocket_handler::bulk_tmp_table_end_bulk_insert()
5393 {
5394 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_end_bulk_insert");
5395 DBUG_PRINT("info",("spider this=%p", this));
5396 DBUG_ASSERT(0);
5397 DBUG_RETURN(0);
5398 }
5399
bulk_tmp_table_rnd_init()5400 int spider_handlersocket_handler::bulk_tmp_table_rnd_init()
5401 {
5402 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_init");
5403 DBUG_PRINT("info",("spider this=%p", this));
5404 DBUG_ASSERT(0);
5405 DBUG_RETURN(0);
5406 }
5407
bulk_tmp_table_rnd_next()5408 int spider_handlersocket_handler::bulk_tmp_table_rnd_next()
5409 {
5410 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_next");
5411 DBUG_PRINT("info",("spider this=%p", this));
5412 DBUG_ASSERT(0);
5413 DBUG_RETURN(0);
5414 }
5415
bulk_tmp_table_rnd_end()5416 int spider_handlersocket_handler::bulk_tmp_table_rnd_end()
5417 {
5418 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_rnd_end");
5419 DBUG_PRINT("info",("spider this=%p", this));
5420 DBUG_ASSERT(0);
5421 DBUG_RETURN(0);
5422 }
5423
need_copy_for_update(int link_idx)5424 bool spider_handlersocket_handler::need_copy_for_update(
5425 int link_idx
5426 ) {
5427 DBUG_ENTER("spider_handlersocket_handler::need_copy_for_update");
5428 DBUG_PRINT("info",("spider this=%p", this));
5429 DBUG_ASSERT(0);
5430 DBUG_RETURN(TRUE);
5431 }
5432
bulk_tmp_table_created()5433 bool spider_handlersocket_handler::bulk_tmp_table_created()
5434 {
5435 DBUG_ENTER("spider_handlersocket_handler::bulk_tmp_table_created");
5436 DBUG_PRINT("info",("spider this=%p", this));
5437 DBUG_ASSERT(0);
5438 DBUG_RETURN(FALSE);
5439 }
5440
mk_bulk_tmp_table_and_bulk_start()5441 int spider_handlersocket_handler::mk_bulk_tmp_table_and_bulk_start()
5442 {
5443 DBUG_ENTER("spider_handlersocket_handler::mk_bulk_tmp_table_and_bulk_start");
5444 DBUG_PRINT("info",("spider this=%p", this));
5445 DBUG_ASSERT(0);
5446 DBUG_RETURN(0);
5447 }
5448
rm_bulk_tmp_table()5449 void spider_handlersocket_handler::rm_bulk_tmp_table()
5450 {
5451 DBUG_ENTER("spider_handlersocket_handler::rm_bulk_tmp_table");
5452 DBUG_PRINT("info",("spider this=%p", this));
5453 DBUG_ASSERT(0);
5454 DBUG_VOID_RETURN;
5455 }
5456
insert_lock_tables_list(SPIDER_CONN * conn,int link_idx)5457 int spider_handlersocket_handler::insert_lock_tables_list(
5458 SPIDER_CONN *conn,
5459 int link_idx
5460 ) {
5461 DBUG_ENTER("spider_handlersocket_handler::insert_lock_tables_list");
5462 DBUG_PRINT("info",("spider this=%p", this));
5463 DBUG_RETURN(0);
5464 }
5465
append_lock_tables_list(SPIDER_CONN * conn,int link_idx,int * appended)5466 int spider_handlersocket_handler::append_lock_tables_list(
5467 SPIDER_CONN *conn,
5468 int link_idx,
5469 int *appended
5470 ) {
5471 DBUG_ENTER("spider_handlersocket_handler::append_lock_tables_list");
5472 DBUG_PRINT("info",("spider this=%p", this));
5473 DBUG_RETURN(0);
5474 }
5475
realloc_sql(ulong * realloced)5476 int spider_handlersocket_handler::realloc_sql(
5477 ulong *realloced
5478 ) {
5479 THD *thd = spider->trx->thd;
5480 st_spider_share *share = spider->share;
5481 int init_sql_alloc_size =
5482 spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
5483 DBUG_ENTER("spider_handlersocket_handler::realloc_sql");
5484 DBUG_PRINT("info",("spider this=%p", this));
5485 if ((int) hs_sql.alloced_length() > init_sql_alloc_size * 2)
5486 {
5487 hs_sql.free();
5488 if (hs_sql.real_alloc(init_sql_alloc_size))
5489 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5490 *realloced |= SPIDER_SQL_TYPE_FULL_HS;
5491 }
5492 DBUG_RETURN(0);
5493 }
5494
reset_sql(ulong sql_type)5495 int spider_handlersocket_handler::reset_sql(
5496 ulong sql_type
5497 ) {
5498 DBUG_ENTER("spider_handlersocket_handler::reset_sql");
5499 DBUG_PRINT("info",("spider this=%p", this));
5500 if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
5501 {
5502 hs_sql.length(0);
5503 }
5504 DBUG_RETURN(0);
5505 }
5506
reset_keys(ulong sql_type)5507 int spider_handlersocket_handler::reset_keys(
5508 ulong sql_type
5509 ) {
5510 DBUG_ENTER("spider_handlersocket_handler::reset_keys");
5511 DBUG_PRINT("info",("spider this=%p", this));
5512 if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
5513 {
5514 hs_keys.clear();
5515 }
5516 DBUG_RETURN(0);
5517 }
5518
reset_upds(ulong sql_type)5519 int spider_handlersocket_handler::reset_upds(
5520 ulong sql_type
5521 ) {
5522 DBUG_ENTER("spider_handlersocket_handler::reset_upds");
5523 DBUG_PRINT("info",("spider this=%p", this));
5524 if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
5525 {
5526 hs_upds.clear();
5527 }
5528 DBUG_RETURN(0);
5529 }
5530
reset_strs(ulong sql_type)5531 int spider_handlersocket_handler::reset_strs(
5532 ulong sql_type
5533 ) {
5534 DBUG_ENTER("spider_handlersocket_handler::reset_strs");
5535 DBUG_PRINT("info",("spider this=%p", this));
5536 if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
5537 {
5538 hs_strs.clear();
5539 }
5540 DBUG_RETURN(0);
5541 }
5542
reset_strs_pos(ulong sql_type)5543 int spider_handlersocket_handler::reset_strs_pos(
5544 ulong sql_type
5545 ) {
5546 DBUG_ENTER("spider_handlersocket_handler::reset_strs_pos");
5547 DBUG_PRINT("info",("spider this=%p", this));
5548 if (sql_type & SPIDER_SQL_TYPE_FULL_HS)
5549 {
5550 hs_strs_pos = 0;
5551 }
5552 DBUG_RETURN(0);
5553 }
5554
push_back_upds(SPIDER_HS_STRING_REF & info)5555 int spider_handlersocket_handler::push_back_upds(
5556 SPIDER_HS_STRING_REF &info
5557 ) {
5558 int error_num;
5559 DBUG_ENTER("spider_handlersocket_handler::push_back_upds");
5560 DBUG_PRINT("info",("spider this=%p", this));
5561 error_num = hs_upds.push_back(info);
5562 DBUG_RETURN(error_num);
5563 }
5564
request_buf_find(int link_idx)5565 int spider_handlersocket_handler::request_buf_find(
5566 int link_idx
5567 ) {
5568 int error_num;
5569 spider_string *hs_str;
5570 SPIDER_CONN *conn;
5571 uint handler_id;
5572 DBUG_ENTER("spider_handlersocket_handler::request_buf_find");
5573 DBUG_PRINT("info",("spider this=%p", this));
5574 if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
5575 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5576 if (spider->conn_kind[link_idx] == SPIDER_CONN_KIND_HS_READ)
5577 {
5578 conn = spider->hs_r_conns[link_idx];
5579 handler_id = spider->r_handler_id[link_idx];
5580 } else {
5581 conn = spider->hs_w_conns[link_idx];
5582 handler_id = spider->w_handler_id[link_idx];
5583 }
5584 if ((error_num = spider_db_conn_queue_action(conn)))
5585 DBUG_RETURN(error_num);
5586 if (!spider_bit_is_set(spider->db_request_phase, link_idx))
5587 {
5588 spider_set_bit(spider->db_request_phase, link_idx);
5589 ++spider->db_request_id[link_idx];
5590 }
5591 st_spider_db_request_key request_key;
5592 request_key.spider_thread_id = spider->trx->spider_thread_id;
5593 request_key.query_id = spider->trx->thd->query_id;
5594 request_key.handler = spider;
5595 request_key.request_id = spider->db_request_id[link_idx];
5596 request_key.next = NULL;
5597 conn->db_conn->append_select(
5598 handler_id, hs_str, &hs_keys,
5599 hs_limit, hs_skip, &request_key);
5600 DBUG_RETURN(0);
5601 }
5602
request_buf_insert(int link_idx)5603 int spider_handlersocket_handler::request_buf_insert(
5604 int link_idx
5605 ) {
5606 int error_num;
5607 DBUG_ENTER("spider_handlersocket_handler::request_buf_insert");
5608 DBUG_PRINT("info",("spider this=%p", this));
5609 if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
5610 DBUG_RETURN(error_num);
5611 if (!spider_bit_is_set(spider->db_request_phase, link_idx))
5612 {
5613 spider_set_bit(spider->db_request_phase, link_idx);
5614 ++spider->db_request_id[link_idx];
5615 }
5616 st_spider_db_request_key request_key;
5617 request_key.spider_thread_id = spider->trx->spider_thread_id;
5618 request_key.query_id = spider->trx->thd->query_id;
5619 request_key.handler = spider;
5620 request_key.request_id = spider->db_request_id[link_idx];
5621 request_key.next = NULL;
5622 spider->hs_w_conns[link_idx]->db_conn->append_insert(
5623 spider->w_handler_id[link_idx], &hs_upds, &request_key);
5624 DBUG_RETURN(0);
5625 }
5626
request_buf_update(int link_idx)5627 int spider_handlersocket_handler::request_buf_update(
5628 int link_idx
5629 ) {
5630 int error_num;
5631 spider_string *hs_str;
5632 DBUG_ENTER("spider_handlersocket_handler::request_buf_update");
5633 DBUG_PRINT("info",("spider this=%p", this));
5634 if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
5635 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5636 if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
5637 DBUG_RETURN(error_num);
5638 if (!spider_bit_is_set(spider->db_request_phase, link_idx))
5639 {
5640 spider_set_bit(spider->db_request_phase, link_idx);
5641 ++spider->db_request_id[link_idx];
5642 }
5643 st_spider_db_request_key request_key;
5644 request_key.spider_thread_id = spider->trx->spider_thread_id;
5645 request_key.query_id = spider->trx->thd->query_id;
5646 request_key.handler = spider;
5647 request_key.request_id = spider->db_request_id[link_idx];
5648 request_key.next = NULL;
5649 spider->hs_w_conns[link_idx]->db_conn->append_update(
5650 spider->w_handler_id[link_idx], hs_str, &hs_keys, &hs_upds,
5651 hs_limit, hs_skip,
5652 spider->hs_increment, spider->hs_decrement, &request_key
5653 );
5654 DBUG_RETURN(0);
5655 }
5656
request_buf_delete(int link_idx)5657 int spider_handlersocket_handler::request_buf_delete(
5658 int link_idx
5659 ) {
5660 int error_num;
5661 spider_string *hs_str;
5662 DBUG_ENTER("spider_handlersocket_handler::request_buf_delete");
5663 DBUG_PRINT("info",("spider this=%p", this));
5664 if (!(hs_str = hs_strs.add(&hs_strs_pos, hs_sql.ptr(), hs_sql.length())))
5665 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5666 if ((error_num = spider_db_conn_queue_action(spider->hs_w_conns[link_idx])))
5667 DBUG_RETURN(error_num);
5668 if (!spider_bit_is_set(spider->db_request_phase, link_idx))
5669 {
5670 spider_set_bit(spider->db_request_phase, link_idx);
5671 ++spider->db_request_id[link_idx];
5672 }
5673 st_spider_db_request_key request_key;
5674 request_key.spider_thread_id = spider->trx->spider_thread_id;
5675 request_key.query_id = spider->trx->thd->query_id;
5676 request_key.handler = spider;
5677 request_key.request_id = spider->db_request_id[link_idx];
5678 request_key.next = NULL;
5679 spider->hs_w_conns[link_idx]->db_conn->append_delete(
5680 spider->w_handler_id[link_idx], hs_str, &hs_keys,
5681 hs_limit, hs_skip, &request_key);
5682 DBUG_RETURN(0);
5683 }
5684
need_lock_before_set_sql_for_exec(ulong sql_type)5685 bool spider_handlersocket_handler::need_lock_before_set_sql_for_exec(
5686 ulong sql_type
5687 ) {
5688 DBUG_ENTER("spider_handlersocket_handler::need_lock_before_set_sql_for_exec");
5689 DBUG_PRINT("info",("spider this=%p", this));
5690 DBUG_RETURN(TRUE);
5691 }
5692
5693 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
set_sql_for_exec(ulong sql_type,int link_idx,SPIDER_LINK_IDX_CHAIN * link_idx_chain)5694 int spider_handlersocket_handler::set_sql_for_exec(
5695 ulong sql_type,
5696 int link_idx,
5697 SPIDER_LINK_IDX_CHAIN *link_idx_chain
5698 ) {
5699 DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
5700 DBUG_PRINT("info",("spider this=%p", this));
5701 DBUG_ASSERT(0);
5702 DBUG_RETURN(0);
5703 }
5704 #endif
5705
set_sql_for_exec(ulong sql_type,int link_idx)5706 int spider_handlersocket_handler::set_sql_for_exec(
5707 ulong sql_type,
5708 int link_idx
5709 ) {
5710 DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
5711 DBUG_PRINT("info",("spider this=%p", this));
5712 if (sql_type & SPIDER_SQL_TYPE_SELECT_HS)
5713 {
5714 DBUG_RETURN(request_buf_find(link_idx));
5715 }
5716 if (sql_type & SPIDER_SQL_TYPE_INSERT_HS)
5717 {
5718 DBUG_RETURN(request_buf_insert(link_idx));
5719 }
5720 if (sql_type & SPIDER_SQL_TYPE_UPDATE_HS)
5721 {
5722 DBUG_RETURN(request_buf_update(link_idx));
5723 }
5724 if (sql_type & SPIDER_SQL_TYPE_DELETE_HS)
5725 {
5726 DBUG_RETURN(request_buf_delete(link_idx));
5727 }
5728 DBUG_RETURN(0);
5729 }
5730
set_sql_for_exec(spider_db_copy_table * tgt_ct,ulong sql_type)5731 int spider_handlersocket_handler::set_sql_for_exec(
5732 spider_db_copy_table *tgt_ct,
5733 ulong sql_type
5734 ) {
5735 DBUG_ENTER("spider_handlersocket_handler::set_sql_for_exec");
5736 DBUG_PRINT("info",("spider this=%p", this));
5737 DBUG_ASSERT(0);
5738 DBUG_RETURN(0);
5739 }
5740
execute_sql(ulong sql_type,SPIDER_CONN * conn,int quick_mode,int * need_mon)5741 int spider_handlersocket_handler::execute_sql(
5742 ulong sql_type,
5743 SPIDER_CONN *conn,
5744 int quick_mode,
5745 int *need_mon
5746 ) {
5747 DBUG_ENTER("spider_handlersocket_handler::execute_sql");
5748 DBUG_PRINT("info",("spider this=%p", this));
5749 if (!(sql_type & SPIDER_SQL_TYPE_FULL_HS))
5750 {
5751 /* nothing to do */
5752 DBUG_RETURN(0);
5753 }
5754 DBUG_RETURN(spider_db_query(
5755 conn,
5756 NULL,
5757 0,
5758 quick_mode,
5759 need_mon
5760 ));
5761 }
5762
reset()5763 int spider_handlersocket_handler::reset()
5764 {
5765 DBUG_ENTER("spider_handlersocket_handler::reset");
5766 DBUG_PRINT("info",("spider this=%p", this));
5767 DBUG_RETURN(0);
5768 }
5769
sts_mode_exchange(int sts_mode)5770 int spider_handlersocket_handler::sts_mode_exchange(
5771 int sts_mode
5772 ) {
5773 DBUG_ENTER("spider_handlersocket_handler::sts_mode_exchange");
5774 DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
5775 DBUG_RETURN(sts_mode);
5776 }
5777
show_table_status(int link_idx,int sts_mode,uint flag)5778 int spider_handlersocket_handler::show_table_status(
5779 int link_idx,
5780 int sts_mode,
5781 uint flag
5782 ) {
5783 spider_db_handlersocket_result res(NULL);
5784 SPIDER_SHARE *share = spider->share;
5785 ulonglong auto_increment_value = 0;
5786 DBUG_ENTER("spider_handlersocket_show_table_status");
5787 res.fetch_table_status(
5788 sts_mode,
5789 share->records,
5790 share->mean_rec_length,
5791 share->data_file_length,
5792 share->max_data_file_length,
5793 share->index_file_length,
5794 auto_increment_value,
5795 share->create_time,
5796 share->update_time,
5797 share->check_time
5798 );
5799 if (auto_increment_value > share->lgtm_tblhnd_share->auto_increment_value)
5800 {
5801 share->lgtm_tblhnd_share->auto_increment_value = auto_increment_value;
5802 DBUG_PRINT("info",("spider auto_increment_value=%llu",
5803 share->lgtm_tblhnd_share->auto_increment_value));
5804 }
5805 DBUG_RETURN(0);
5806 }
5807
crd_mode_exchange(int crd_mode)5808 int spider_handlersocket_handler::crd_mode_exchange(
5809 int crd_mode
5810 ) {
5811 DBUG_ENTER("spider_handlersocket_handler::crd_mode_exchange");
5812 DBUG_PRINT("info",("spider crd_mode=%d", crd_mode));
5813 DBUG_RETURN(crd_mode);
5814 }
5815
show_index(int link_idx,int crd_mode)5816 int spider_handlersocket_handler::show_index(
5817 int link_idx,
5818 int crd_mode
5819 ) {
5820 DBUG_ENTER("spider_handlersocket_handler::show_index");
5821 DBUG_PRINT("info",("spider this=%p", this));
5822 DBUG_ASSERT(0);
5823 DBUG_RETURN(0);
5824 }
5825
show_records(int link_idx)5826 int spider_handlersocket_handler::show_records(
5827 int link_idx
5828 ) {
5829 DBUG_ENTER("spider_handlersocket_handler::show_records");
5830 DBUG_PRINT("info",("spider this=%p", this));
5831 DBUG_ASSERT(0);
5832 DBUG_RETURN(0);
5833 }
5834
show_last_insert_id(int link_idx,ulonglong & last_insert_id)5835 int spider_handlersocket_handler::show_last_insert_id(
5836 int link_idx,
5837 ulonglong &last_insert_id
5838 ) {
5839 DBUG_ENTER("spider_handlersocket_handler::show_last_insert_id");
5840 last_insert_id = 0;
5841 DBUG_RETURN(0);
5842 }
5843
explain_select(key_range * start_key,key_range * end_key,int link_idx)5844 ha_rows spider_handlersocket_handler::explain_select(
5845 key_range *start_key,
5846 key_range *end_key,
5847 int link_idx
5848 ) {
5849 DBUG_ENTER("spider_handlersocket_handler::explain_select");
5850 DBUG_PRINT("info",("spider this=%p", this));
5851 DBUG_ASSERT(0);
5852 DBUG_RETURN(0);
5853 }
5854
lock_tables(int link_idx)5855 int spider_handlersocket_handler::lock_tables(
5856 int link_idx
5857 ) {
5858 DBUG_ENTER("spider_handlersocket_handler::lock_tables");
5859 DBUG_ASSERT(0);
5860 DBUG_RETURN(0);
5861 }
5862
unlock_tables(int link_idx)5863 int spider_handlersocket_handler::unlock_tables(
5864 int link_idx
5865 ) {
5866 DBUG_ENTER("spider_handlersocket_handler::unlock_tables");
5867 DBUG_ASSERT(0);
5868 DBUG_RETURN(0);
5869 }
5870
disable_keys(SPIDER_CONN * conn,int link_idx)5871 int spider_handlersocket_handler::disable_keys(
5872 SPIDER_CONN *conn,
5873 int link_idx
5874 ) {
5875 DBUG_ENTER("spider_handlersocket_handler::disable_keys");
5876 DBUG_PRINT("info",("spider this=%p", this));
5877 DBUG_ASSERT(0);
5878 DBUG_RETURN(0);
5879 }
5880
enable_keys(SPIDER_CONN * conn,int link_idx)5881 int spider_handlersocket_handler::enable_keys(
5882 SPIDER_CONN *conn,
5883 int link_idx
5884 ) {
5885 DBUG_ENTER("spider_handlersocket_handler::enable_keys");
5886 DBUG_PRINT("info",("spider this=%p", this));
5887 DBUG_ASSERT(0);
5888 DBUG_RETURN(0);
5889 }
5890
check_table(SPIDER_CONN * conn,int link_idx,HA_CHECK_OPT * check_opt)5891 int spider_handlersocket_handler::check_table(
5892 SPIDER_CONN *conn,
5893 int link_idx,
5894 HA_CHECK_OPT* check_opt
5895 ) {
5896 DBUG_ENTER("spider_handlersocket_handler::check_table");
5897 DBUG_PRINT("info",("spider this=%p", this));
5898 DBUG_ASSERT(0);
5899 DBUG_RETURN(0);
5900 }
5901
repair_table(SPIDER_CONN * conn,int link_idx,HA_CHECK_OPT * check_opt)5902 int spider_handlersocket_handler::repair_table(
5903 SPIDER_CONN *conn,
5904 int link_idx,
5905 HA_CHECK_OPT* check_opt
5906 ) {
5907 DBUG_ENTER("spider_handlersocket_handler::repair_table");
5908 DBUG_PRINT("info",("spider this=%p", this));
5909 DBUG_ASSERT(0);
5910 DBUG_RETURN(0);
5911 }
5912
analyze_table(SPIDER_CONN * conn,int link_idx)5913 int spider_handlersocket_handler::analyze_table(
5914 SPIDER_CONN *conn,
5915 int link_idx
5916 ) {
5917 DBUG_ENTER("spider_handlersocket_handler::analyze_table");
5918 DBUG_PRINT("info",("spider this=%p", this));
5919 DBUG_ASSERT(0);
5920 DBUG_RETURN(0);
5921 }
5922
optimize_table(SPIDER_CONN * conn,int link_idx)5923 int spider_handlersocket_handler::optimize_table(
5924 SPIDER_CONN *conn,
5925 int link_idx
5926 ) {
5927 DBUG_ENTER("spider_handlersocket_handler::optimize_table");
5928 DBUG_PRINT("info",("spider this=%p", this));
5929 DBUG_ASSERT(0);
5930 DBUG_RETURN(0);
5931 }
5932
flush_tables(SPIDER_CONN * conn,int link_idx,bool lock)5933 int spider_handlersocket_handler::flush_tables(
5934 SPIDER_CONN *conn,
5935 int link_idx,
5936 bool lock
5937 ) {
5938 DBUG_ENTER("spider_handlersocket_handler::flush_tables");
5939 DBUG_PRINT("info",("spider this=%p", this));
5940 DBUG_ASSERT(0);
5941 DBUG_RETURN(0);
5942 }
5943
flush_logs(SPIDER_CONN * conn,int link_idx)5944 int spider_handlersocket_handler::flush_logs(
5945 SPIDER_CONN *conn,
5946 int link_idx
5947 ) {
5948 DBUG_ENTER("spider_handlersocket_handler::flush_logs");
5949 DBUG_PRINT("info",("spider this=%p", this));
5950 DBUG_ASSERT(0);
5951 DBUG_RETURN(0);
5952 }
5953
insert_opened_handler(SPIDER_CONN * conn,int link_idx)5954 int spider_handlersocket_handler::insert_opened_handler(
5955 SPIDER_CONN *conn,
5956 int link_idx
5957 ) {
5958 spider_db_handlersocket *db_conn = (spider_db_handlersocket *) conn->db_conn;
5959 SPIDER_LINK_FOR_HASH *tmp_link_for_hash = &link_for_hash[link_idx];
5960 DBUG_ASSERT(tmp_link_for_hash->spider == spider);
5961 DBUG_ASSERT(tmp_link_for_hash->link_idx == link_idx);
5962 uint old_elements = db_conn->handler_open_array.max_element;
5963 DBUG_ENTER("spider_handlersocket_handler::insert_opened_handler");
5964 DBUG_PRINT("info",("spider this=%p", this));
5965 if (insert_dynamic(&db_conn->handler_open_array,
5966 (uchar*) &tmp_link_for_hash))
5967 {
5968 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5969 }
5970 if (db_conn->handler_open_array.max_element > old_elements)
5971 {
5972 spider_alloc_calc_mem(spider_current_trx,
5973 db_conn->handler_open_array,
5974 (db_conn->handler_open_array.max_element - old_elements) *
5975 db_conn->handler_open_array.size_of_element);
5976 }
5977 DBUG_RETURN(0);
5978 }
5979
delete_opened_handler(SPIDER_CONN * conn,int link_idx)5980 int spider_handlersocket_handler::delete_opened_handler(
5981 SPIDER_CONN *conn,
5982 int link_idx
5983 ) {
5984 spider_db_handlersocket *db_conn = (spider_db_handlersocket *) conn->db_conn;
5985 uint roop_count, elements = db_conn->handler_open_array.elements;
5986 SPIDER_LINK_FOR_HASH *tmp_link_for_hash;
5987 DBUG_ENTER("spider_handlersocket_handler::delete_opened_handler");
5988 DBUG_PRINT("info",("spider this=%p", this));
5989 for (roop_count = 0; roop_count < elements; roop_count++)
5990 {
5991 get_dynamic(&db_conn->handler_open_array, (uchar *) &tmp_link_for_hash,
5992 roop_count);
5993 if (tmp_link_for_hash == &link_for_hash[link_idx])
5994 {
5995 delete_dynamic_element(&db_conn->handler_open_array, roop_count);
5996 break;
5997 }
5998 }
5999 DBUG_ASSERT(roop_count < elements);
6000 DBUG_RETURN(0);
6001 }
6002
sync_from_clone_source(spider_db_handler * dbton_hdl)6003 int spider_handlersocket_handler::sync_from_clone_source(
6004 spider_db_handler *dbton_hdl
6005 ) {
6006 spider_handlersocket_handler *hs_hdl =
6007 (spider_handlersocket_handler *) dbton_hdl;
6008 DBUG_ENTER("spider_handlersocket_handler::sync_from_clone_source");
6009 DBUG_PRINT("info",("spider this=%p", this));
6010 hs_strs_pos = hs_hdl->hs_strs_pos;
6011 DBUG_RETURN(0);
6012 }
6013
support_use_handler(int use_handler)6014 bool spider_handlersocket_handler::support_use_handler(
6015 int use_handler
6016 ) {
6017 DBUG_ENTER("spider_handlersocket_handler::support_use_handler");
6018 DBUG_PRINT("info",("spider this=%p", this));
6019 DBUG_RETURN(TRUE);
6020 }
6021
minimum_select_bitmap_create()6022 void spider_handlersocket_handler::minimum_select_bitmap_create()
6023 {
6024 TABLE *table = spider->get_table();
6025 Field **field_p;
6026 DBUG_ENTER("spider_handlersocket_handler::minimum_select_bitmap_create");
6027 memset(minimum_select_bitmap, 0, no_bytes_in_map(table->read_set));
6028 if (
6029 spider->use_index_merge ||
6030 #ifdef HA_CAN_BULK_ACCESS
6031 (spider->is_clone && !spider->is_bulk_access_clone)
6032 #else
6033 spider->is_clone
6034 #endif
6035 ) {
6036 /* need preparing for cmp_ref */
6037 TABLE_SHARE *table_share = table->s;
6038 if (
6039 table_share->primary_key == MAX_KEY
6040 ) {
6041 /* need all columns */
6042 memset(minimum_select_bitmap, 0xFF, no_bytes_in_map(table->read_set));
6043 DBUG_VOID_RETURN;
6044 } else {
6045 /* need primary key columns */
6046 uint roop_count;
6047 KEY *key_info;
6048 KEY_PART_INFO *key_part;
6049 Field *field;
6050 key_info = &table_share->key_info[table_share->primary_key];
6051 key_part = key_info->key_part;
6052 for (roop_count = 0;
6053 roop_count < spider_user_defined_key_parts(key_info);
6054 roop_count++)
6055 {
6056 field = key_part[roop_count].field;
6057 spider_set_bit(minimum_select_bitmap, field->field_index);
6058 }
6059 }
6060 }
6061 for (field_p = table->field; *field_p; field_p++)
6062 {
6063 uint field_index = (*field_p)->field_index;
6064 if (
6065 spider_bit_is_set(spider->searched_bitmap, field_index) |
6066 bitmap_is_set(table->read_set, field_index) |
6067 bitmap_is_set(table->write_set, field_index)
6068 ) {
6069 spider_set_bit(minimum_select_bitmap, field_index);
6070 }
6071 }
6072 DBUG_VOID_RETURN;
6073 }
6074
minimum_select_bit_is_set(uint field_index)6075 bool spider_handlersocket_handler::minimum_select_bit_is_set(
6076 uint field_index
6077 ) {
6078 DBUG_ENTER("spider_handlersocket_handler::minimum_select_bit_is_set");
6079 DBUG_PRINT("info",("spider field_index=%u", field_index));
6080 DBUG_PRINT("info",("spider minimum_select_bitmap=%s",
6081 spider_bit_is_set(minimum_select_bitmap, field_index) ?
6082 "TRUE" : "FALSE"));
6083 DBUG_RETURN(spider_bit_is_set(minimum_select_bitmap, field_index));
6084 }
6085
copy_minimum_select_bitmap(uchar * bitmap)6086 void spider_handlersocket_handler::copy_minimum_select_bitmap(
6087 uchar *bitmap
6088 ) {
6089 int roop_count;
6090 TABLE *table = spider->get_table();
6091 DBUG_ENTER("spider_handlersocket_handler::copy_minimum_select_bitmap");
6092 for (roop_count = 0;
6093 roop_count < (int) ((table->s->fields + 7) / 8);
6094 roop_count++)
6095 {
6096 bitmap[roop_count] =
6097 minimum_select_bitmap[roop_count];
6098 DBUG_PRINT("info",("spider roop_count=%d", roop_count));
6099 DBUG_PRINT("info",("spider bitmap=%d",
6100 bitmap[roop_count]));
6101 }
6102 DBUG_VOID_RETURN;
6103 }
6104
init_union_table_name_pos()6105 int spider_handlersocket_handler::init_union_table_name_pos()
6106 {
6107 DBUG_ENTER("spider_handlersocket_handler::init_union_table_name_pos");
6108 DBUG_PRINT("info",("spider this=%p", this));
6109 DBUG_ASSERT(0);
6110 DBUG_RETURN(0);
6111 }
6112
set_union_table_name_pos()6113 int spider_handlersocket_handler::set_union_table_name_pos()
6114 {
6115 DBUG_ENTER("spider_handlersocket_handler::set_union_table_name_pos");
6116 DBUG_PRINT("info",("spider this=%p", this));
6117 DBUG_ASSERT(0);
6118 DBUG_RETURN(0);
6119 }
6120
reset_union_table_name(spider_string * str,int link_idx,ulong sql_type)6121 int spider_handlersocket_handler::reset_union_table_name(
6122 spider_string *str,
6123 int link_idx,
6124 ulong sql_type
6125 ) {
6126 DBUG_ENTER("spider_handlersocket_handler::reset_union_table_name");
6127 DBUG_PRINT("info",("spider this=%p", this));
6128 DBUG_ASSERT(0);
6129 DBUG_RETURN(0);
6130 }
6131
6132 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
append_list_item_select_part(List<Item> * select,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)6133 int spider_handlersocket_handler::append_list_item_select_part(
6134 List<Item> *select,
6135 const char *alias,
6136 uint alias_length,
6137 bool use_fields,
6138 spider_fields *fields,
6139 ulong sql_type
6140 ) {
6141 DBUG_ENTER("spider_handlersocket_handler::append_list_item_select_part");
6142 DBUG_PRINT("info",("spider this=%p", this));
6143 DBUG_ASSERT(0);
6144 DBUG_RETURN(0);
6145 }
6146
append_from_and_tables_part(spider_fields * fields,ulong sql_type)6147 int spider_handlersocket_handler::append_from_and_tables_part(
6148 spider_fields *fields,
6149 ulong sql_type
6150 ) {
6151 DBUG_ENTER("spider_handlersocket_handler::append_from_and_tables_part");
6152 DBUG_PRINT("info",("spider this=%p", this));
6153 DBUG_ASSERT(0);
6154 DBUG_RETURN(0);
6155 }
6156
reappend_tables_part(spider_fields * fields,ulong sql_type)6157 int spider_handlersocket_handler::reappend_tables_part(
6158 spider_fields *fields,
6159 ulong sql_type
6160 ) {
6161 DBUG_ENTER("spider_handlersocket_handler::reappend_tables_part");
6162 DBUG_PRINT("info",("spider this=%p", this));
6163 DBUG_ASSERT(0);
6164 DBUG_RETURN(0);
6165 }
6166
append_where_part(ulong sql_type)6167 int spider_handlersocket_handler::append_where_part(
6168 ulong sql_type
6169 ) {
6170 DBUG_ENTER("spider_handlersocket_handler::append_where_part");
6171 DBUG_PRINT("info",("spider this=%p", this));
6172 DBUG_ASSERT(0);
6173 DBUG_RETURN(0);
6174 }
6175
append_having_part(ulong sql_type)6176 int spider_handlersocket_handler::append_having_part(
6177 ulong sql_type
6178 ) {
6179 DBUG_ENTER("spider_handlersocket_handler::append_having_part");
6180 DBUG_PRINT("info",("spider this=%p", this));
6181 DBUG_ASSERT(0);
6182 DBUG_RETURN(0);
6183 }
6184
append_item_type_part(Item * item,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)6185 int spider_handlersocket_handler::append_item_type_part(
6186 Item *item,
6187 const char *alias,
6188 uint alias_length,
6189 bool use_fields,
6190 spider_fields *fields,
6191 ulong sql_type
6192 ) {
6193 DBUG_ENTER("spider_handlersocket_handler::append_item_type_part");
6194 DBUG_PRINT("info",("spider this=%p", this));
6195 DBUG_ASSERT(0);
6196 DBUG_RETURN(0);
6197 }
6198
append_group_by_part(ORDER * order,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)6199 int spider_handlersocket_handler::append_group_by_part(
6200 ORDER *order,
6201 const char *alias,
6202 uint alias_length,
6203 bool use_fields,
6204 spider_fields *fields,
6205 ulong sql_type
6206 ) {
6207 DBUG_ENTER("spider_handlersocket_handler::append_group_by_part");
6208 DBUG_PRINT("info",("spider this=%p", this));
6209 DBUG_ASSERT(0);
6210 DBUG_RETURN(0);
6211 }
6212
append_order_by_part(ORDER * order,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)6213 int spider_handlersocket_handler::append_order_by_part(
6214 ORDER *order,
6215 const char *alias,
6216 uint alias_length,
6217 bool use_fields,
6218 spider_fields *fields,
6219 ulong sql_type
6220 ) {
6221 DBUG_ENTER("spider_handlersocket_handler::append_order_by_part");
6222 DBUG_PRINT("info",("spider this=%p", this));
6223 DBUG_ASSERT(0);
6224 DBUG_RETURN(0);
6225 }
6226 #endif
6227 #endif
6228