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