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_class.h"
27 #include "sql_partition.h"
28 #include "sql_analyse.h"
29 #include "sql_base.h"
30 #include "tztime.h"
31 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
32 #include "sql_select.h"
33 #endif
34 #endif
35 #include "sql_common.h"
36 #include <mysql.h>
37 #include <errmsg.h>
38 #include "spd_err.h"
39 #include "spd_param.h"
40 #include "spd_db_include.h"
41 #include "spd_include.h"
42 #include "spd_db_mysql.h"
43 #include "ha_spider.h"
44 #include "spd_conn.h"
45 #include "spd_db_conn.h"
46 #include "spd_malloc.h"
47 #include "spd_sys_table.h"
48 #include "spd_table.h"
49
50 extern struct charset_info_st *spd_charset_utf8_bin;
51 extern bool volatile *spd_abort_loop;
52
53 extern handlerton *spider_hton_ptr;
54 extern pthread_mutex_t spider_open_conn_mutex;
55 extern HASH spider_open_connections;
56 extern HASH spider_ipport_conns;
57 extern SPIDER_DBTON spider_dbton[SPIDER_DBTON_SIZE];
58 extern const char spider_dig_upper[];
59
60 spider_db_mysql_util spider_db_mysql_utility;
61 spider_db_mariadb_util spider_db_mariadb_utility;
62
63 #define SPIDER_SQL_NAME_QUOTE_STR "`"
64 #define SPIDER_SQL_NAME_QUOTE_LEN (sizeof(SPIDER_SQL_NAME_QUOTE_STR) - 1)
65 static const char *name_quote_str = SPIDER_SQL_NAME_QUOTE_STR;
66
67 #define SPIDER_SQL_ISO_READ_UNCOMMITTED_STR "set session transaction isolation level read uncommitted"
68 #define SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN sizeof(SPIDER_SQL_ISO_READ_UNCOMMITTED_STR) - 1
69 #define SPIDER_SQL_ISO_READ_COMMITTED_STR "set session transaction isolation level read committed"
70 #define SPIDER_SQL_ISO_READ_COMMITTED_LEN sizeof(SPIDER_SQL_ISO_READ_COMMITTED_STR) - 1
71 #define SPIDER_SQL_ISO_REPEATABLE_READ_STR "set session transaction isolation level repeatable read"
72 #define SPIDER_SQL_ISO_REPEATABLE_READ_LEN sizeof(SPIDER_SQL_ISO_REPEATABLE_READ_STR) - 1
73 #define SPIDER_SQL_ISO_SERIALIZABLE_STR "set session transaction isolation level serializable"
74 #define SPIDER_SQL_ISO_SERIALIZABLE_LEN sizeof(SPIDER_SQL_ISO_SERIALIZABLE_STR) - 1
75
76 #define SPIDER_SQL_START_CONSISTENT_SNAPSHOT_STR "start transaction with consistent snapshot"
77 #define SPIDER_SQL_START_CONSISTENT_SNAPSHOT_LEN sizeof(SPIDER_SQL_START_CONSISTENT_SNAPSHOT_STR) - 1
78 #define SPIDER_SQL_START_TRANSACTION_STR "start transaction"
79 #define SPIDER_SQL_START_TRANSACTION_LEN sizeof(SPIDER_SQL_START_TRANSACTION_STR) - 1
80
81 #define SPIDER_SQL_AUTOCOMMIT_OFF_STR "set session autocommit = 0"
82 #define SPIDER_SQL_AUTOCOMMIT_OFF_LEN sizeof(SPIDER_SQL_AUTOCOMMIT_OFF_STR) - 1
83 #define SPIDER_SQL_AUTOCOMMIT_ON_STR "set session autocommit = 1"
84 #define SPIDER_SQL_AUTOCOMMIT_ON_LEN sizeof(SPIDER_SQL_AUTOCOMMIT_ON_STR) - 1
85
86 #define SPIDER_SQL_SQL_LOG_OFF_STR "set session sql_log_off = 0"
87 #define SPIDER_SQL_SQL_LOG_OFF_LEN sizeof(SPIDER_SQL_SQL_LOG_OFF_STR) - 1
88 #define SPIDER_SQL_SQL_LOG_ON_STR "set session sql_log_off = 1"
89 #define SPIDER_SQL_SQL_LOG_ON_LEN sizeof(SPIDER_SQL_SQL_LOG_ON_STR) - 1
90
91 #define SPIDER_SQL_TIME_ZONE_STR "set session time_zone = '"
92 #define SPIDER_SQL_TIME_ZONE_LEN sizeof(SPIDER_SQL_TIME_ZONE_STR) - 1
93
94 #define SPIDER_SQL_COMMIT_STR "commit"
95 #define SPIDER_SQL_COMMIT_LEN sizeof(SPIDER_SQL_COMMIT_STR) - 1
96 #define SPIDER_SQL_ROLLBACK_STR "rollback"
97 #define SPIDER_SQL_ROLLBACK_LEN sizeof(SPIDER_SQL_ROLLBACK_STR) - 1
98
99 #define SPIDER_SQL_XA_START_STR "xa start "
100 #define SPIDER_SQL_XA_START_LEN sizeof(SPIDER_SQL_XA_START_STR) - 1
101 #define SPIDER_SQL_XA_END_STR "xa end "
102 #define SPIDER_SQL_XA_END_LEN sizeof(SPIDER_SQL_XA_END_STR) - 1
103 #define SPIDER_SQL_XA_PREPARE_STR "xa prepare "
104 #define SPIDER_SQL_XA_PREPARE_LEN sizeof(SPIDER_SQL_XA_PREPARE_STR) - 1
105 #define SPIDER_SQL_XA_COMMIT_STR "xa commit "
106 #define SPIDER_SQL_XA_COMMIT_LEN sizeof(SPIDER_SQL_XA_COMMIT_STR) - 1
107 #define SPIDER_SQL_XA_ROLLBACK_STR "xa rollback "
108 #define SPIDER_SQL_XA_ROLLBACK_LEN sizeof(SPIDER_SQL_XA_ROLLBACK_STR) - 1
109
110 #define SPIDER_SQL_LOCK_TABLE_STR "lock tables "
111 #define SPIDER_SQL_LOCK_TABLE_LEN (sizeof(SPIDER_SQL_LOCK_TABLE_STR) - 1)
112 #define SPIDER_SQL_UNLOCK_TABLE_STR "unlock tables"
113 #define SPIDER_SQL_UNLOCK_TABLE_LEN (sizeof(SPIDER_SQL_UNLOCK_TABLE_STR) - 1)
114
115 #define SPIDER_SQL_LEFT_JOIN_STR " left join "
116 #define SPIDER_SQL_LEFT_JOIN_LEN (sizeof(SPIDER_SQL_LEFT_JOIN_STR) - 1)
117 #define SPIDER_SQL_RIGHT_JOIN_STR " right join "
118 #define SPIDER_SQL_RIGHT_JOIN_LEN (sizeof(SPIDER_SQL_RIGHT_JOIN_STR) - 1)
119 #define SPIDER_SQL_JOIN_STR " join "
120 #define SPIDER_SQL_JOIN_LEN (sizeof(SPIDER_SQL_JOIN_STR) - 1)
121 #define SPIDER_SQL_ON_STR " on "
122 #define SPIDER_SQL_ON_LEN (sizeof(SPIDER_SQL_ON_STR) - 1)
123
124 #define SPIDER_SQL_SHOW_TABLE_STATUS_STR "show table status from "
125 #define SPIDER_SQL_SHOW_TABLE_STATUS_LEN sizeof(SPIDER_SQL_SHOW_TABLE_STATUS_STR) - 1
126 #define SPIDER_SQL_SELECT_TABLES_STATUS_STR "select `table_rows`,`avg_row_length`,`data_length`,`max_data_length`,`index_length`,`auto_increment`,`create_time`,`update_time`,`check_time` from `information_schema`.`tables` where `table_schema` = "
127 #define SPIDER_SQL_SELECT_TABLES_STATUS_LEN sizeof(SPIDER_SQL_SELECT_TABLES_STATUS_STR) - 1
128 #define SPIDER_SQL_SHOW_WARNINGS_STR "show warnings"
129 #define SPIDER_SQL_SHOW_WARNINGS_LEN sizeof(SPIDER_SQL_SHOW_WARNINGS_STR) - 1
130
131 #define SPIDER_SQL_SHOW_MASTER_STATUS_STR "show master status"
132 #define SPIDER_SQL_SHOW_MASTER_STATUS_LEN sizeof(SPIDER_SQL_SHOW_MASTER_STATUS_STR) - 1
133 #define SPIDER_SQL_BINLOG_GTID_POS_STR "select binlog_gtid_pos"
134 #define SPIDER_SQL_BINLOG_GTID_POS_LEN sizeof(SPIDER_SQL_BINLOG_GTID_POS_STR) - 1
135
136 #ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
137 #define SPIDER_SQL_SHOW_COLUMNS_STR "show columns from "
138 #define SPIDER_SQL_SHOW_COLUMNS_LEN sizeof(SPIDER_SQL_SHOW_COLUMNS_STR) - 1
139 #define SPIDER_SQL_SELECT_COLUMNS_STR "select `column_name`,`column_default`,`is_nullable`,`character_set_name`,`collation_name`,`column_type`,`extra` from `information_schema`.`columns` where `table_schema` = "
140 #define SPIDER_SQL_SELECT_COLUMNS_LEN sizeof(SPIDER_SQL_SELECT_COLUMNS_STR) - 1
141
142 #define SPIDER_SQL_AUTO_INCREMENT_STR " auto_increment"
143 #define SPIDER_SQL_AUTO_INCREMENT_LEN sizeof(SPIDER_SQL_AUTO_INCREMENT_STR) - 1
144 #define SPIDER_SQL_ORDINAL_POSITION_STR "ordinal_position"
145 #define SPIDER_SQL_ORDINAL_POSITION_LEN sizeof(SPIDER_SQL_ORDINAL_POSITION_STR) - 1
146 #define SPIDER_SQL_FULLTEXT_STR "fulltext"
147 #define SPIDER_SQL_FULLTEXT_LEN sizeof(SPIDER_SQL_FULLTEXT_STR) - 1
148 #define SPIDER_SQL_SPATIAL_STR "spatial"
149 #define SPIDER_SQL_SPATIAL_LEN sizeof(SPIDER_SQL_SPATIAL_STR) - 1
150 #define SPIDER_SQL_USING_HASH_STR " using hash"
151 #define SPIDER_SQL_USING_HASH_LEN sizeof(SPIDER_SQL_USING_HASH_STR) - 1
152 #endif
153
154 #define SPIDER_SQL_LIKE_STR " like "
155 #define SPIDER_SQL_LIKE_LEN (sizeof(SPIDER_SQL_LIKE_STR) - 1)
156 #define SPIDER_SQL_LIMIT1_STR " limit 1"
157 #define SPIDER_SQL_LIMIT1_LEN (sizeof(SPIDER_SQL_LIMIT1_STR) - 1)
158 #define SPIDER_SQL_COLLATE_STR " collate "
159 #define SPIDER_SQL_COLLATE_LEN (sizeof(SPIDER_SQL_COLLATE_STR) - 1)
160
161 #define SPIDER_SQL_INTERVAL_STR " + interval "
162 #define SPIDER_SQL_INTERVAL_LEN (sizeof(SPIDER_SQL_INTERVAL_STR) - 1)
163 #define SPIDER_SQL_NEGINTERVAL_STR " - interval "
164 #define SPIDER_SQL_NEGINTERVAL_LEN (sizeof(SPIDER_SQL_NEGINTERVAL_STR) - 1)
165
166 static uchar SPIDER_SQL_LINESTRING_HEAD_STR[] =
167 {0x00,0x00,0x00,0x00,0x01,0x02,0x00,0x00,0x00,0x02,0x00,0x00,0x00};
168 #define SPIDER_SQL_LINESTRING_HEAD_LEN sizeof(SPIDER_SQL_LINESTRING_HEAD_STR)
169
170 static const char *spider_db_table_lock_str[] =
171 {
172 " read local,",
173 " read,",
174 " low_priority write,",
175 " write,"
176 };
177 static const int spider_db_table_lock_len[] =
178 {
179 sizeof(" read local,") - 1,
180 sizeof(" read,") - 1,
181 sizeof(" low_priority write,") - 1,
182 sizeof(" write,") - 1
183 };
184 static const char *spider_db_timefunc_interval_str[] =
185 {
186 " year", " quarter", " month", " week", " day",
187 " hour", " minute", " second", " microsecond",
188 " year_month", " day_hour", " day_minute",
189 " day_second", " hour_minute", " hour_second",
190 " minute_second", " day_microsecond", " hour_microsecond",
191 " minute_microsecond", " second_microsecond"
192 };
193
194 /* UTC time zone for timestamp columns */
195 extern Time_zone *UTC;
196
spider_mysql_init()197 int spider_mysql_init()
198 {
199 DBUG_ENTER("spider_mysql_init");
200 DBUG_RETURN(0);
201 }
202
spider_mariadb_init()203 int spider_mariadb_init()
204 {
205 DBUG_ENTER("spider_mariadb_init");
206 DBUG_RETURN(0);
207 }
208
spider_mysql_deinit()209 int spider_mysql_deinit()
210 {
211 DBUG_ENTER("spider_mysql_deinit");
212 DBUG_RETURN(0);
213 }
214
spider_mariadb_deinit()215 int spider_mariadb_deinit()
216 {
217 DBUG_ENTER("spider_mariadb_deinit");
218 DBUG_RETURN(0);
219 }
220
spider_mysql_create_share(SPIDER_SHARE * share)221 spider_db_share *spider_mysql_create_share(
222 SPIDER_SHARE *share
223 ) {
224 DBUG_ENTER("spider_mysql_create_share");
225 DBUG_RETURN(new spider_mysql_share(share));
226 }
227
spider_mariadb_create_share(SPIDER_SHARE * share)228 spider_db_share *spider_mariadb_create_share(
229 SPIDER_SHARE *share
230 ) {
231 DBUG_ENTER("spider_mariadb_create_share");
232 DBUG_RETURN(new spider_mariadb_share(share));
233 }
234
spider_mysql_create_handler(ha_spider * spider,spider_db_share * db_share)235 spider_db_handler *spider_mysql_create_handler(
236 ha_spider *spider,
237 spider_db_share *db_share
238 ) {
239 DBUG_ENTER("spider_mysql_create_handler");
240 DBUG_RETURN(new spider_mysql_handler(spider,
241 (spider_mbase_share *) db_share));
242 }
243
spider_mariadb_create_handler(ha_spider * spider,spider_db_share * db_share)244 spider_db_handler *spider_mariadb_create_handler(
245 ha_spider *spider,
246 spider_db_share *db_share
247 ) {
248 DBUG_ENTER("spider_mariadb_create_handler");
249 DBUG_RETURN(new spider_mariadb_handler(spider,
250 (spider_mbase_share *) db_share));
251 }
252
spider_mysql_create_copy_table(spider_db_share * db_share)253 spider_db_copy_table *spider_mysql_create_copy_table(
254 spider_db_share *db_share
255 ) {
256 DBUG_ENTER("spider_mysql_create_copy_table");
257 DBUG_RETURN(new spider_mysql_copy_table(
258 (spider_mbase_share *) db_share));
259 }
260
spider_mariadb_create_copy_table(spider_db_share * db_share)261 spider_db_copy_table *spider_mariadb_create_copy_table(
262 spider_db_share *db_share
263 ) {
264 DBUG_ENTER("spider_mariadb_create_copy_table");
265 DBUG_RETURN(new spider_mariadb_copy_table(
266 (spider_mbase_share *) db_share));
267 }
268
spider_mysql_create_conn(SPIDER_CONN * conn)269 SPIDER_DB_CONN *spider_mysql_create_conn(
270 SPIDER_CONN *conn
271 ) {
272 DBUG_ENTER("spider_mysql_create_conn");
273 DBUG_RETURN(new spider_db_mysql(conn));
274 }
275
spider_mariadb_create_conn(SPIDER_CONN * conn)276 SPIDER_DB_CONN *spider_mariadb_create_conn(
277 SPIDER_CONN *conn
278 ) {
279 DBUG_ENTER("spider_mariadb_create_conn");
280 DBUG_RETURN(new spider_db_mariadb(conn));
281 }
282
spider_mysql_support_direct_join()283 bool spider_mysql_support_direct_join(
284 ) {
285 DBUG_ENTER("spider_mysql_support_direct_join");
286 DBUG_RETURN(TRUE);
287 }
288
spider_mariadb_support_direct_join()289 bool spider_mariadb_support_direct_join(
290 ) {
291 DBUG_ENTER("spider_mariadb_support_direct_join");
292 DBUG_RETURN(TRUE);
293 }
294
295 SPIDER_DBTON spider_dbton_mysql = {
296 0,
297 SPIDER_DB_WRAPPER_MYSQL,
298 SPIDER_DB_ACCESS_TYPE_SQL,
299 spider_mysql_init,
300 spider_mysql_deinit,
301 spider_mysql_create_share,
302 spider_mysql_create_handler,
303 spider_mysql_create_copy_table,
304 spider_mysql_create_conn,
305 spider_mysql_support_direct_join,
306 &spider_db_mysql_utility
307 };
308
309 SPIDER_DBTON spider_dbton_mariadb = {
310 0,
311 SPIDER_DB_WRAPPER_MARIADB,
312 SPIDER_DB_ACCESS_TYPE_SQL,
313 spider_mariadb_init,
314 spider_mariadb_deinit,
315 spider_mariadb_create_share,
316 spider_mariadb_create_handler,
317 spider_mariadb_create_copy_table,
318 spider_mariadb_create_conn,
319 spider_mariadb_support_direct_join,
320 &spider_db_mariadb_utility
321 };
322
spider_db_mbase_row(uint dbton_id)323 spider_db_mbase_row::spider_db_mbase_row(
324 uint dbton_id
325 ) : spider_db_row(dbton_id),
326 row(NULL), lengths(NULL), cloned(FALSE)
327 {
328 DBUG_ENTER("spider_db_mbase_row::spider_db_mbase_row");
329 DBUG_PRINT("info",("spider this=%p", this));
330 DBUG_VOID_RETURN;
331 }
332
spider_db_mysql_row()333 spider_db_mysql_row::spider_db_mysql_row() :
334 spider_db_mbase_row(spider_db_mysql_utility.dbton_id)
335 {
336 DBUG_ENTER("spider_db_mysql_row::spider_db_mysql_row");
337 DBUG_PRINT("info",("spider this=%p", this));
338 DBUG_VOID_RETURN;
339 }
340
spider_db_mariadb_row()341 spider_db_mariadb_row::spider_db_mariadb_row() :
342 spider_db_mbase_row(spider_db_mariadb_utility.dbton_id)
343 {
344 DBUG_ENTER("spider_db_mariadb_row::spider_db_mariadb_row");
345 DBUG_PRINT("info",("spider this=%p", this));
346 DBUG_VOID_RETURN;
347 }
348
~spider_db_mbase_row()349 spider_db_mbase_row::~spider_db_mbase_row()
350 {
351 DBUG_ENTER("spider_db_mbase_row::~spider_db_mbase_row");
352 DBUG_PRINT("info",("spider this=%p", this));
353 if (cloned)
354 {
355 spider_free(spider_current_trx, row_first, MYF(0));
356 }
357 DBUG_VOID_RETURN;
358 }
359
~spider_db_mysql_row()360 spider_db_mysql_row::~spider_db_mysql_row()
361 {
362 DBUG_ENTER("spider_db_mysql_row::~spider_db_mysql_row");
363 DBUG_PRINT("info",("spider this=%p", this));
364 DBUG_VOID_RETURN;
365 }
366
~spider_db_mariadb_row()367 spider_db_mariadb_row::~spider_db_mariadb_row()
368 {
369 DBUG_ENTER("spider_db_mariadb_row::~spider_db_mariadb_row");
370 DBUG_PRINT("info",("spider this=%p", this));
371 DBUG_VOID_RETURN;
372 }
373
store_to_field(Field * field,CHARSET_INFO * access_charset)374 int spider_db_mbase_row::store_to_field(
375 Field *field,
376 CHARSET_INFO *access_charset
377 ) {
378 DBUG_ENTER("spider_db_mbase_row::store_to_field");
379 DBUG_PRINT("info",("spider this=%p", this));
380 if (!*row)
381 {
382 DBUG_PRINT("info", ("spider field is null"));
383 field->set_null();
384 field->reset();
385 } else {
386 field->set_notnull();
387 if (field->flags & BLOB_FLAG)
388 {
389 DBUG_PRINT("info", ("spider blob field"));
390 if (
391 field->charset() == &my_charset_bin ||
392 field->charset()->cset == access_charset->cset
393 )
394 ((Field_blob *)field)->set_ptr(*lengths, (uchar *) *row);
395 else {
396 DBUG_PRINT("info", ("spider blob convert"));
397 if (field->table->file->ht == spider_hton_ptr)
398 {
399 ha_spider *spider = (ha_spider *) field->table->file;
400 spider_string *str = &spider->blob_buff[field->field_index];
401 str->length(0);
402 if (str->append(*row, *lengths, access_charset))
403 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
404 ((Field_blob *)field)->set_ptr(str->length(), (uchar *) str->ptr());
405 } else {
406 field->store(*row, *lengths, access_charset);
407 }
408 }
409 } else
410 field->store(*row, *lengths, access_charset);
411 }
412 DBUG_RETURN(0);
413 }
414
append_to_str(spider_string * str)415 int spider_db_mbase_row::append_to_str(
416 spider_string *str
417 ) {
418 DBUG_ENTER("spider_db_mbase_row::append_to_str");
419 DBUG_PRINT("info",("spider this=%p", this));
420 if (str->reserve(*lengths))
421 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
422 str->q_append(*row, *lengths);
423 DBUG_RETURN(0);
424 }
425
append_escaped_to_str(spider_string * str,uint dbton_id)426 int spider_db_mbase_row::append_escaped_to_str(
427 spider_string *str,
428 uint dbton_id
429 ) {
430 DBUG_ENTER("spider_db_mbase_row::append_escaped_to_str");
431 DBUG_PRINT("info",("spider this=%p", this));
432 spider_string tmp_str(*row, *lengths + 1, str->charset());
433 tmp_str.init_calc_mem(133);
434 tmp_str.length(*lengths);
435 if (str->reserve(*lengths * 2 + 2))
436 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
437 spider_dbton[dbton_id].db_util->append_escaped_util(str, tmp_str.get_str());
438 DBUG_RETURN(0);
439 }
440
first()441 void spider_db_mbase_row::first()
442 {
443 DBUG_ENTER("spider_db_mbase_row::first");
444 DBUG_PRINT("info",("spider this=%p", this));
445 row = row_first;
446 lengths = lengths_first;
447 DBUG_VOID_RETURN;
448 }
449
next()450 void spider_db_mbase_row::next()
451 {
452 DBUG_ENTER("spider_db_mbase_row::next");
453 DBUG_PRINT("info",("spider this=%p", this));
454 row++;
455 lengths++;
456 DBUG_VOID_RETURN;
457 }
458
is_null()459 bool spider_db_mbase_row::is_null()
460 {
461 DBUG_ENTER("spider_db_mbase_row::is_null");
462 DBUG_PRINT("info",("spider this=%p", this));
463 DBUG_RETURN(!(*row));
464 }
465
val_int()466 int spider_db_mbase_row::val_int()
467 {
468 DBUG_ENTER("spider_db_mbase_row::val_int");
469 DBUG_PRINT("info",("spider this=%p", this));
470 DBUG_RETURN(*row ? atoi(*row) : 0);
471 }
472
val_real()473 double spider_db_mbase_row::val_real()
474 {
475 DBUG_ENTER("spider_db_mbase_row::val_real");
476 DBUG_PRINT("info",("spider this=%p", this));
477 DBUG_RETURN(*row ? my_atof(*row) : 0.0);
478 }
479
val_decimal(my_decimal * decimal_value,CHARSET_INFO * access_charset)480 my_decimal *spider_db_mbase_row::val_decimal(
481 my_decimal *decimal_value,
482 CHARSET_INFO *access_charset
483 ) {
484 DBUG_ENTER("spider_db_mbase_row::val_decimal");
485 DBUG_PRINT("info",("spider this=%p", this));
486 if (!*row)
487 DBUG_RETURN(NULL);
488
489 #ifdef SPIDER_HAS_DECIMAL_OPERATION_RESULTS_VALUE_TYPE
490 decimal_operation_results(str2my_decimal(0, *row, *lengths, access_charset,
491 decimal_value), "", "");
492 #else
493 decimal_operation_results(str2my_decimal(0, *row, *lengths, access_charset,
494 decimal_value));
495 #endif
496
497 DBUG_RETURN(decimal_value);
498 }
499
clone()500 SPIDER_DB_ROW *spider_db_mbase_row::clone()
501 {
502 spider_db_mbase_row *clone_row;
503 char *tmp_char;
504 MYSQL_ROW tmp_row = row_first, ctmp_row;
505 ulong *tmp_lengths = lengths_first;
506 uint row_size, i;
507 DBUG_ENTER("spider_db_mbase_row::clone");
508 DBUG_PRINT("info",("spider this=%p", this));
509 if (!(clone_row = new spider_db_mbase_row(dbton_id)))
510 {
511 DBUG_RETURN(NULL);
512 }
513 if (!record_size)
514 {
515 row_size = field_count;
516 for (i = 0; i < field_count; i++)
517 {
518 row_size += *tmp_lengths;
519 tmp_lengths++;
520 }
521 record_size = row_size - field_count;
522 } else {
523 row_size = record_size + field_count;
524 }
525 if (!spider_bulk_malloc(spider_current_trx, 29, MYF(MY_WME),
526 &clone_row->row, sizeof(char*) * field_count,
527 &tmp_char, row_size,
528 &clone_row->lengths, sizeof(ulong) * field_count,
529 NullS)
530 ) {
531 delete clone_row;
532 DBUG_RETURN(NULL);
533 }
534 memcpy(clone_row->lengths, lengths_first, sizeof(ulong) * field_count);
535 tmp_lengths = lengths_first;
536 ctmp_row = clone_row->row;
537 for (i = 0; i < field_count; i++)
538 {
539 DBUG_PRINT("info",("spider *lengths=%lu", *tmp_lengths));
540 if (*tmp_row == NULL)
541 {
542 *ctmp_row = NULL;
543 *tmp_char = 0;
544 tmp_char++;
545 } else {
546 *ctmp_row = tmp_char;
547 memcpy(tmp_char, *tmp_row, *tmp_lengths + 1);
548 tmp_char += *tmp_lengths + 1;
549 }
550 ctmp_row++;
551 tmp_lengths++;
552 tmp_row++;
553 }
554 clone_row->field_count = field_count;
555 clone_row->record_size = record_size;
556 clone_row->row_first = clone_row->row;
557 clone_row->lengths_first = clone_row->lengths;
558 clone_row->cloned = TRUE;
559 DBUG_RETURN((SPIDER_DB_ROW *) clone_row);
560 }
561
store_to_tmp_table(TABLE * tmp_table,spider_string * str)562 int spider_db_mbase_row::store_to_tmp_table(
563 TABLE *tmp_table,
564 spider_string *str
565 ) {
566 uint i;
567 MYSQL_ROW tmp_row = row;
568 ulong *tmp_lengths = lengths;
569 DBUG_ENTER("spider_db_mbase_row::store_to_tmp_table");
570 DBUG_PRINT("info",("spider this=%p", this));
571 str->length(0);
572 for (i = 0; i < field_count; i++)
573 {
574 if (*tmp_row)
575 {
576 if (str->reserve(*tmp_lengths + 1))
577 {
578 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
579 }
580 str->q_append(*tmp_row, *tmp_lengths + 1);
581 }
582 tmp_lengths++;
583 tmp_row++;
584 }
585 tmp_table->field[0]->set_notnull();
586 tmp_table->field[0]->store(
587 (const char *) lengths,
588 sizeof(ulong) * field_count, &my_charset_bin);
589 tmp_table->field[1]->set_notnull();
590 tmp_table->field[1]->store(
591 str->ptr(), str->length(), &my_charset_bin);
592 tmp_table->field[2]->set_notnull();
593 tmp_table->field[2]->store(
594 (char *) row, (uint) (sizeof(char *) * field_count), &my_charset_bin);
595 DBUG_RETURN(tmp_table->file->ha_write_row(tmp_table->record[0]));
596 }
597
get_byte_size()598 uint spider_db_mbase_row::get_byte_size()
599 {
600 ulong *tmp_lengths = lengths_first;
601 uint i;
602 DBUG_ENTER("spider_db_mbase_row::get_byte_size");
603 DBUG_PRINT("info",("spider this=%p", this));
604 if (!record_size)
605 {
606 for (i = 0; i < field_count; i++)
607 {
608 record_size += *tmp_lengths;
609 tmp_lengths++;
610 }
611 }
612 DBUG_RETURN(record_size);
613 }
614
spider_db_mbase_result(SPIDER_DB_CONN * in_db_conn)615 spider_db_mbase_result::spider_db_mbase_result(
616 SPIDER_DB_CONN *in_db_conn
617 ) : spider_db_result(in_db_conn),
618 db_result(NULL), row(in_db_conn->dbton_id)
619 {
620 DBUG_ENTER("spider_db_mbase_result::spider_db_mbase_result");
621 DBUG_PRINT("info",("spider this=%p", this));
622 DBUG_VOID_RETURN;
623 }
624
spider_db_mysql_result(SPIDER_DB_CONN * in_db_conn)625 spider_db_mysql_result::spider_db_mysql_result(
626 SPIDER_DB_CONN *in_db_conn
627 ) : spider_db_mbase_result(in_db_conn)
628 {
629 DBUG_ENTER("spider_db_mysql_result::spider_db_mysql_result");
630 DBUG_PRINT("info",("spider this=%p", this));
631 DBUG_VOID_RETURN;
632 }
633
spider_db_mariadb_result(SPIDER_DB_CONN * in_db_conn)634 spider_db_mariadb_result::spider_db_mariadb_result(
635 SPIDER_DB_CONN *in_db_conn
636 ) : spider_db_mbase_result(in_db_conn)
637 {
638 DBUG_ENTER("spider_db_mariadb_result::spider_db_mariadb_result");
639 DBUG_PRINT("info",("spider this=%p", this));
640 DBUG_VOID_RETURN;
641 }
642
~spider_db_mbase_result()643 spider_db_mbase_result::~spider_db_mbase_result()
644 {
645 DBUG_ENTER("spider_db_mbase_result::~spider_db_mbase_result");
646 DBUG_PRINT("info",("spider this=%p", this));
647 if (db_result)
648 {
649 free_result();
650 }
651 DBUG_VOID_RETURN;
652 }
653
~spider_db_mysql_result()654 spider_db_mysql_result::~spider_db_mysql_result()
655 {
656 DBUG_ENTER("spider_db_mysql_result::~spider_db_mysql_result");
657 DBUG_PRINT("info",("spider this=%p", this));
658 DBUG_VOID_RETURN;
659 }
660
~spider_db_mariadb_result()661 spider_db_mariadb_result::~spider_db_mariadb_result()
662 {
663 DBUG_ENTER("spider_db_mariadb_result::~spider_db_mariadb_result");
664 DBUG_PRINT("info",("spider this=%p", this));
665 DBUG_VOID_RETURN;
666 }
667
has_result()668 bool spider_db_mbase_result::has_result()
669 {
670 DBUG_ENTER("spider_db_mbase_result::has_result");
671 DBUG_PRINT("info",("spider this=%p", this));
672 DBUG_RETURN(db_result);
673 }
674
free_result()675 void spider_db_mbase_result::free_result()
676 {
677 DBUG_ENTER("spider_db_mbase_result::free_result");
678 DBUG_PRINT("info",("spider this=%p", this));
679 /* need 2 times execution design */
680 if (db_result)
681 {
682 mysql_free_result(db_result);
683 db_result = NULL;
684 }
685 DBUG_VOID_RETURN;
686 }
687
current_row()688 SPIDER_DB_ROW *spider_db_mbase_result::current_row()
689 {
690 DBUG_ENTER("spider_db_mbase_result::current_row");
691 DBUG_PRINT("info",("spider this=%p", this));
692 DBUG_RETURN((SPIDER_DB_ROW *) row.clone());
693 }
694
fetch_row()695 SPIDER_DB_ROW *spider_db_mbase_result::fetch_row()
696 {
697 DBUG_ENTER("spider_db_mbase_result::fetch_row");
698 DBUG_PRINT("info",("spider this=%p", this));
699 if (!(row.row = mysql_fetch_row(db_result)))
700 {
701 if (mysql_errno(((spider_db_mbase *) db_conn)->db_conn))
702 {
703 store_error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn);
704 my_message(store_error_num,
705 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
706 } else
707 store_error_num = HA_ERR_END_OF_FILE;
708 DBUG_RETURN(NULL);
709 }
710 row.lengths = mysql_fetch_lengths(db_result);
711 row.field_count = mysql_num_fields(db_result);
712 row.row_first = row.row;
713 row.lengths_first = row.lengths;
714 row.record_size = 0;
715 DBUG_RETURN((SPIDER_DB_ROW *) &row);
716 }
717
fetch_row_from_result_buffer(spider_db_result_buffer * spider_res_buf)718 SPIDER_DB_ROW *spider_db_mbase_result::fetch_row_from_result_buffer(
719 spider_db_result_buffer *spider_res_buf
720 ) {
721 DBUG_ENTER("spider_db_mbase_result::fetch_row_from_result_buffer");
722 DBUG_PRINT("info",("spider this=%p", this));
723 if (!(row.row = mysql_fetch_row(db_result)))
724 {
725 if (mysql_errno(((spider_db_mbase *) db_conn)->db_conn))
726 {
727 store_error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn);
728 my_message(store_error_num,
729 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
730 } else
731 store_error_num = HA_ERR_END_OF_FILE;
732 DBUG_RETURN(NULL);
733 }
734 row.lengths = mysql_fetch_lengths(db_result);
735 row.field_count = mysql_num_fields(db_result);
736 row.row_first = row.row;
737 row.lengths_first = row.lengths;
738 row.record_size = 0;
739 DBUG_RETURN((SPIDER_DB_ROW *) &row);
740 }
741
fetch_row_from_tmp_table(TABLE * tmp_table)742 SPIDER_DB_ROW *spider_db_mbase_result::fetch_row_from_tmp_table(
743 TABLE *tmp_table
744 ) {
745 uint i;
746 spider_string tmp_str1, tmp_str2, tmp_str3;
747 const char *row_ptr;
748 MYSQL_ROW tmp_row;
749 ulong *tmp_lengths;
750 uint field_count;
751 DBUG_ENTER("spider_db_mbase_result::fetch_row_from_tmp_table");
752 DBUG_PRINT("info",("spider this=%p", this));
753 tmp_str1.init_calc_mem(117);
754 tmp_str2.init_calc_mem(118);
755 tmp_str3.init_calc_mem(170);
756 tmp_table->field[0]->val_str(tmp_str1.get_str());
757 tmp_table->field[1]->val_str(tmp_str2.get_str());
758 tmp_table->field[2]->val_str(tmp_str3.get_str());
759 tmp_str1.mem_calc();
760 tmp_str2.mem_calc();
761 tmp_str3.mem_calc();
762 row_ptr = tmp_str2.ptr();
763 tmp_lengths = (ulong *) tmp_str1.ptr();
764 tmp_row = (MYSQL_ROW) tmp_str3.ptr();
765 field_count = tmp_str1.length() / sizeof(ulong);
766 row.row = tmp_row;
767 row.lengths = tmp_lengths;
768 row.field_count = field_count;
769 row.row_first = row.row;
770 row.lengths_first = row.lengths;
771 row.record_size = tmp_str2.length();
772 for (i = 0; i < field_count; i++)
773 {
774 if (*tmp_row)
775 {
776 *tmp_row = (char *) row_ptr;
777 row_ptr += *tmp_lengths + 1;
778 }
779 tmp_row++;
780 tmp_lengths++;
781 }
782 DBUG_RETURN((SPIDER_DB_ROW *) &row);
783 }
784
fetch_table_status(int mode,ha_rows & records,ulong & mean_rec_length,ulonglong & data_file_length,ulonglong & max_data_file_length,ulonglong & index_file_length,ulonglong & auto_increment_value,time_t & create_time,time_t & update_time,time_t & check_time)785 int spider_db_mbase_result::fetch_table_status(
786 int mode,
787 ha_rows &records,
788 ulong &mean_rec_length,
789 ulonglong &data_file_length,
790 ulonglong &max_data_file_length,
791 ulonglong &index_file_length,
792 ulonglong &auto_increment_value,
793 time_t &create_time,
794 time_t &update_time,
795 time_t &check_time
796 ) {
797 int error_num;
798 MYSQL_ROW mysql_row;
799 MYSQL_TIME mysql_time;
800 #ifdef MARIADB_BASE_VERSION
801 uint not_used_uint;
802 #else
803 my_bool not_used_my_bool;
804 #endif
805 #ifdef SPIDER_HAS_TIME_STATUS
806 MYSQL_TIME_STATUS time_status;
807 #else
808 int time_status;
809 #endif
810 long not_used_long;
811 DBUG_ENTER("spider_db_mbase_result::fetch_table_status");
812 DBUG_PRINT("info",("spider this=%p", this));
813 if (!(mysql_row = mysql_fetch_row(db_result)))
814 {
815 DBUG_PRINT("info",("spider fetch row is null"));
816 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
817 {
818 my_message(error_num,
819 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
820 DBUG_RETURN(error_num);
821 }
822 DBUG_RETURN(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM);
823 }
824 if (mode == 1)
825 {
826 /* Ok to test for 18 fields as all new fields are added last */
827 if (num_fields() < 18)
828 {
829 DBUG_PRINT("info",("spider field_count < 18"));
830 DBUG_RETURN(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM);
831 }
832
833 if (mysql_row[4])
834 records =
835 (ha_rows) my_strtoll10(mysql_row[4], (char**) NULL, &error_num);
836 else
837 records = (ha_rows) 0;
838 DBUG_PRINT("info",
839 ("spider records=%lld", records));
840 if (mysql_row[5])
841 mean_rec_length =
842 (ulong) my_strtoll10(mysql_row[5], (char**) NULL, &error_num);
843 else
844 mean_rec_length = 0;
845 DBUG_PRINT("info",
846 ("spider mean_rec_length=%lu", mean_rec_length));
847 if (mysql_row[6])
848 data_file_length =
849 (ulonglong) my_strtoll10(mysql_row[6], (char**) NULL, &error_num);
850 else
851 data_file_length = 0;
852 DBUG_PRINT("info",
853 ("spider data_file_length=%lld", data_file_length));
854 if (mysql_row[7])
855 max_data_file_length =
856 (ulonglong) my_strtoll10(mysql_row[7], (char**) NULL, &error_num);
857 else
858 max_data_file_length = 0;
859 DBUG_PRINT("info",
860 ("spider max_data_file_length=%lld", max_data_file_length));
861 if (mysql_row[8])
862 index_file_length =
863 (ulonglong) my_strtoll10(mysql_row[8], (char**) NULL, &error_num);
864 else
865 index_file_length = 0;
866 DBUG_PRINT("info",
867 ("spider index_file_length=%lld", index_file_length));
868 if (mysql_row[10])
869 auto_increment_value =
870 (ulonglong) my_strtoll10(mysql_row[10], (char**) NULL, &error_num);
871 else
872 auto_increment_value = 1;
873 DBUG_PRINT("info",
874 ("spider auto_increment_value=%lld", auto_increment_value));
875 if (mysql_row[11])
876 {
877 #ifdef SPIDER_HAS_TIME_STATUS
878 my_time_status_init(&time_status);
879 #endif
880 SPIDER_str_to_datetime(mysql_row[11], strlen(mysql_row[11]),
881 &mysql_time, 0, &time_status);
882 #ifdef MARIADB_BASE_VERSION
883 create_time = (time_t) my_system_gmt_sec(&mysql_time,
884 ¬_used_long, ¬_used_uint);
885 #else
886 create_time = (time_t) my_system_gmt_sec(&mysql_time,
887 ¬_used_long, ¬_used_my_bool);
888 #endif
889 } else
890 create_time = (time_t) 0;
891 #ifndef DBUG_OFF
892 {
893 struct tm *ts, tmp_ts;
894 char buf[80];
895 ts = localtime_r(&create_time, &tmp_ts);
896 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
897 DBUG_PRINT("info",("spider create_time=%s", buf));
898 }
899 #endif
900 if (mysql_row[12])
901 {
902 #ifdef SPIDER_HAS_TIME_STATUS
903 my_time_status_init(&time_status);
904 #endif
905 SPIDER_str_to_datetime(mysql_row[12], strlen(mysql_row[12]),
906 &mysql_time, 0, &time_status);
907 #ifdef MARIADB_BASE_VERSION
908 update_time = (time_t) my_system_gmt_sec(&mysql_time,
909 ¬_used_long, ¬_used_uint);
910 #else
911 update_time = (time_t) my_system_gmt_sec(&mysql_time,
912 ¬_used_long, ¬_used_my_bool);
913 #endif
914 } else
915 update_time = (time_t) 0;
916 #ifndef DBUG_OFF
917 {
918 struct tm *ts, tmp_ts;
919 char buf[80];
920 ts = localtime_r(&update_time, &tmp_ts);
921 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
922 DBUG_PRINT("info",("spider update_time=%s", buf));
923 }
924 #endif
925 if (mysql_row[13])
926 {
927 #ifdef SPIDER_HAS_TIME_STATUS
928 my_time_status_init(&time_status);
929 #endif
930 SPIDER_str_to_datetime(mysql_row[13], strlen(mysql_row[13]),
931 &mysql_time, 0, &time_status);
932 #ifdef MARIADB_BASE_VERSION
933 check_time = (time_t) my_system_gmt_sec(&mysql_time,
934 ¬_used_long, ¬_used_uint);
935 #else
936 check_time = (time_t) my_system_gmt_sec(&mysql_time,
937 ¬_used_long, ¬_used_my_bool);
938 #endif
939 } else
940 check_time = (time_t) 0;
941 #ifndef DBUG_OFF
942 {
943 struct tm *ts, tmp_ts;
944 char buf[80];
945 ts = localtime_r(&check_time, &tmp_ts);
946 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
947 DBUG_PRINT("info",("spider check_time=%s", buf));
948 }
949 #endif
950 } else {
951 if (mysql_row[0])
952 records =
953 (ha_rows) my_strtoll10(mysql_row[0], (char**) NULL, &error_num);
954 else
955 records = (ha_rows) 0;
956 DBUG_PRINT("info",
957 ("spider records=%lld", records));
958 if (mysql_row[1])
959 mean_rec_length =
960 (ulong) my_strtoll10(mysql_row[1], (char**) NULL, &error_num);
961 else
962 mean_rec_length = 0;
963 DBUG_PRINT("info",
964 ("spider mean_rec_length=%lu", mean_rec_length));
965 if (mysql_row[2])
966 data_file_length =
967 (ulonglong) my_strtoll10(mysql_row[2], (char**) NULL, &error_num);
968 else
969 data_file_length = 0;
970 DBUG_PRINT("info",
971 ("spider data_file_length=%lld", data_file_length));
972 if (mysql_row[3])
973 max_data_file_length =
974 (ulonglong) my_strtoll10(mysql_row[3], (char**) NULL, &error_num);
975 else
976 max_data_file_length = 0;
977 DBUG_PRINT("info",
978 ("spider max_data_file_length=%lld", max_data_file_length));
979 if (mysql_row[4])
980 index_file_length =
981 (ulonglong) my_strtoll10(mysql_row[4], (char**) NULL, &error_num);
982 else
983 index_file_length = 0;
984 DBUG_PRINT("info",
985 ("spider index_file_length=%lld", index_file_length));
986 if (mysql_row[5])
987 auto_increment_value =
988 (ulonglong) my_strtoll10(mysql_row[5], (char**) NULL, &error_num);
989 else
990 auto_increment_value = 1;
991 DBUG_PRINT("info",
992 ("spider auto_increment_value=%lld", auto_increment_value));
993 if (mysql_row[6])
994 {
995 #ifdef SPIDER_HAS_TIME_STATUS
996 my_time_status_init(&time_status);
997 #endif
998 SPIDER_str_to_datetime(mysql_row[6], strlen(mysql_row[6]),
999 &mysql_time, 0, &time_status);
1000 #ifdef MARIADB_BASE_VERSION
1001 create_time = (time_t) my_system_gmt_sec(&mysql_time,
1002 ¬_used_long, ¬_used_uint);
1003 #else
1004 create_time = (time_t) my_system_gmt_sec(&mysql_time,
1005 ¬_used_long, ¬_used_my_bool);
1006 #endif
1007 } else
1008 create_time = (time_t) 0;
1009 #ifndef DBUG_OFF
1010 {
1011 struct tm *ts, tmp_ts;
1012 char buf[80];
1013 ts = localtime_r(&create_time, &tmp_ts);
1014 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
1015 DBUG_PRINT("info",("spider create_time=%s", buf));
1016 }
1017 #endif
1018 if (mysql_row[7])
1019 {
1020 #ifdef SPIDER_HAS_TIME_STATUS
1021 my_time_status_init(&time_status);
1022 #endif
1023 SPIDER_str_to_datetime(mysql_row[7], strlen(mysql_row[7]),
1024 &mysql_time, 0, &time_status);
1025 #ifdef MARIADB_BASE_VERSION
1026 update_time = (time_t) my_system_gmt_sec(&mysql_time,
1027 ¬_used_long, ¬_used_uint);
1028 #else
1029 update_time = (time_t) my_system_gmt_sec(&mysql_time,
1030 ¬_used_long, ¬_used_my_bool);
1031 #endif
1032 } else
1033 update_time = (time_t) 0;
1034 #ifndef DBUG_OFF
1035 {
1036 struct tm *ts, tmp_ts;
1037 char buf[80];
1038 ts = localtime_r(&update_time, &tmp_ts);
1039 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
1040 DBUG_PRINT("info",("spider update_time=%s", buf));
1041 }
1042 #endif
1043 if (mysql_row[8])
1044 {
1045 #ifdef SPIDER_HAS_TIME_STATUS
1046 my_time_status_init(&time_status);
1047 #endif
1048 SPIDER_str_to_datetime(mysql_row[8], strlen(mysql_row[8]),
1049 &mysql_time, 0, &time_status);
1050 #ifdef MARIADB_BASE_VERSION
1051 check_time = (time_t) my_system_gmt_sec(&mysql_time,
1052 ¬_used_long, ¬_used_uint);
1053 #else
1054 check_time = (time_t) my_system_gmt_sec(&mysql_time,
1055 ¬_used_long, ¬_used_my_bool);
1056 #endif
1057 } else
1058 check_time = (time_t) 0;
1059 #ifndef DBUG_OFF
1060 {
1061 struct tm *ts, tmp_ts;
1062 char buf[80];
1063 ts = localtime_r(&check_time, &tmp_ts);
1064 strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", ts);
1065 DBUG_PRINT("info",("spider check_time=%s", buf));
1066 }
1067 #endif
1068 }
1069 DBUG_RETURN(0);
1070 }
1071
fetch_table_records(int mode,ha_rows & records)1072 int spider_db_mbase_result::fetch_table_records(
1073 int mode,
1074 ha_rows &records
1075 ) {
1076 int error_num;
1077 MYSQL_ROW mysql_row;
1078 DBUG_ENTER("spider_db_mbase_result::fetch_table_records");
1079 DBUG_PRINT("info",("spider this=%p", this));
1080 if (!(mysql_row = mysql_fetch_row(db_result)))
1081 {
1082 DBUG_PRINT("info",("spider fetch row is null"));
1083 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1084 {
1085 my_message(error_num,
1086 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1087 DBUG_RETURN(error_num);
1088 }
1089 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1090 }
1091 if (mode == 1)
1092 {
1093 if (mysql_row[0])
1094 {
1095 records =
1096 (ha_rows) my_strtoll10(mysql_row[0], (char**) NULL, &error_num);
1097 } else
1098 records = (ha_rows) 0;
1099 DBUG_PRINT("info",
1100 ("spider records=%lld", records));
1101 } else {
1102 if (num_fields() != 10)
1103 {
1104 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1105 }
1106
1107 if (mysql_row[8])
1108 {
1109 records =
1110 (ha_rows) my_strtoll10(mysql_row[8], (char**) NULL, &error_num);
1111 } else
1112 records = 0;
1113 }
1114 DBUG_RETURN(0);
1115 }
1116
fetch_table_cardinality(int mode,TABLE * table,longlong * cardinality,uchar * cardinality_upd,int bitmap_size)1117 int spider_db_mbase_result::fetch_table_cardinality(
1118 int mode,
1119 TABLE *table,
1120 longlong *cardinality,
1121 uchar *cardinality_upd,
1122 int bitmap_size
1123 ) {
1124 int error_num;
1125 MYSQL_ROW mysql_row;
1126 Field *field;
1127 DBUG_ENTER("spider_db_mbase_result::fetch_table_cardinality");
1128 DBUG_PRINT("info",("spider this=%p", this));
1129 memset((uchar *) cardinality_upd, 0, sizeof(uchar) * bitmap_size);
1130 if (!(mysql_row = mysql_fetch_row(db_result)))
1131 {
1132 DBUG_PRINT("info",("spider fetch row is null"));
1133 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1134 {
1135 my_message(error_num,
1136 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1137 DBUG_RETURN(error_num);
1138 }
1139 /* no index */
1140 DBUG_RETURN(0);
1141 }
1142 if (mode == 1)
1143 {
1144 uint num_fields = this->num_fields();
1145 if (num_fields < 12 || num_fields > 13)
1146 {
1147 DBUG_PRINT("info",("spider num_fields < 12 || num_fields > 13"));
1148 DBUG_RETURN(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM);
1149 }
1150
1151 while (mysql_row)
1152 {
1153 if (
1154 mysql_row[4] &&
1155 mysql_row[6] &&
1156 (field = find_field_in_table_sef(table, mysql_row[4]))
1157 ) {
1158 if ((cardinality[field->field_index] =
1159 (longlong) my_strtoll10(mysql_row[6], (char**) NULL, &error_num))
1160 <= 0)
1161 cardinality[field->field_index] = 1;
1162 spider_set_bit(cardinality_upd, field->field_index);
1163 DBUG_PRINT("info",
1164 ("spider col_name=%s", mysql_row[4]));
1165 DBUG_PRINT("info",
1166 ("spider cardinality=%lld",
1167 cardinality[field->field_index]));
1168 } else if (mysql_row[4])
1169 {
1170 DBUG_PRINT("info",
1171 ("spider skip col_name=%s", mysql_row[4]));
1172 } else {
1173 DBUG_RETURN(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM);
1174 }
1175 mysql_row = mysql_fetch_row(db_result);
1176 }
1177 } else {
1178 while (mysql_row)
1179 {
1180 if (
1181 mysql_row[0] &&
1182 mysql_row[1] &&
1183 (field = find_field_in_table_sef(table, mysql_row[0]))
1184 ) {
1185 if ((cardinality[field->field_index] =
1186 (longlong) my_strtoll10(mysql_row[1], (char**) NULL, &error_num))
1187 <= 0)
1188 cardinality[field->field_index] = 1;
1189 spider_set_bit(cardinality_upd, field->field_index);
1190 DBUG_PRINT("info",
1191 ("spider col_name=%s", mysql_row[0]));
1192 DBUG_PRINT("info",
1193 ("spider cardinality=%lld",
1194 cardinality[field->field_index]));
1195 } else if (mysql_row[0])
1196 {
1197 DBUG_PRINT("info",
1198 ("spider skip col_name=%s", mysql_row[0]));
1199 } else {
1200 DBUG_RETURN(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM);
1201 }
1202 mysql_row = mysql_fetch_row(db_result);
1203 }
1204 }
1205 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1206 {
1207 my_message(error_num,
1208 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1209 DBUG_RETURN(error_num);
1210 }
1211 DBUG_RETURN(0);
1212 }
1213
fetch_table_mon_status(int & status)1214 int spider_db_mbase_result::fetch_table_mon_status(
1215 int &status
1216 ) {
1217 int error_num;
1218 MYSQL_ROW mysql_row;
1219 DBUG_ENTER("spider_db_mbase_result::fetch_table_mon_status");
1220 DBUG_PRINT("info",("spider this=%p", this));
1221 if (!(mysql_row = mysql_fetch_row(db_result)))
1222 {
1223 DBUG_PRINT("info",("spider fetch row is null"));
1224 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1225 {
1226 my_message(error_num,
1227 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1228 DBUG_RETURN(error_num);
1229 }
1230 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1231 }
1232 if (num_fields() != 1)
1233 {
1234 DBUG_PRINT("info",("spider num_fields != 1"));
1235 my_printf_error(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
1236 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
1237 }
1238 if (mysql_row[0])
1239 status = atoi(mysql_row[0]);
1240 else
1241 status = SPIDER_LINK_MON_OK;
1242 DBUG_PRINT("info", ("spider status=%d", status));
1243 DBUG_RETURN(0);
1244 }
1245
fetch_show_master_status(const char ** binlog_file_name,const char ** binlog_pos)1246 int spider_db_mbase_result::fetch_show_master_status(
1247 const char **binlog_file_name,
1248 const char **binlog_pos
1249 ) {
1250 int error_num;
1251 MYSQL_ROW mysql_row;
1252 DBUG_ENTER("spider_db_mbase_result::fetch_show_master_status");
1253 DBUG_PRINT("info",("spider this=%p", this));
1254 if (!(mysql_row = mysql_fetch_row(db_result)))
1255 {
1256 DBUG_PRINT("info",("spider fetch row is null"));
1257 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1258 {
1259 my_message(error_num,
1260 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1261 DBUG_RETURN(error_num);
1262 }
1263 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1264 }
1265 if (num_fields() != 4)
1266 {
1267 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1268 }
1269
1270 *binlog_file_name = mysql_row[0];
1271 DBUG_PRINT("info",("spider binlog_file_name=%s", *binlog_file_name));
1272 *binlog_pos = mysql_row[1];
1273 DBUG_PRINT("info",("spider binlog_pos=%s", *binlog_pos));
1274 DBUG_RETURN(0);
1275 }
1276
fetch_select_binlog_gtid_pos(const char ** gtid_pos)1277 int spider_db_mbase_result::fetch_select_binlog_gtid_pos(
1278 const char **gtid_pos
1279 ) {
1280 int error_num;
1281 MYSQL_ROW mysql_row;
1282 DBUG_ENTER("spider_db_mbase_result::fetch_select_binlog_gtid_pos");
1283 DBUG_PRINT("info",("spider this=%p", this));
1284 if (!(mysql_row = mysql_fetch_row(db_result)))
1285 {
1286 DBUG_PRINT("info",("spider fetch row is null"));
1287 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1288 {
1289 my_message(error_num,
1290 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1291 DBUG_RETURN(error_num);
1292 }
1293 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1294 }
1295 if (num_fields() != 1)
1296 {
1297 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
1298 }
1299
1300 *gtid_pos = mysql_row[0];
1301 DBUG_PRINT("info",("spider gtid_pos=%s", *gtid_pos));
1302 DBUG_RETURN(0);
1303 }
1304
num_rows()1305 longlong spider_db_mbase_result::num_rows()
1306 {
1307 DBUG_ENTER("spider_db_mbase_result::num_rows");
1308 DBUG_PRINT("info",("spider this=%p", this));
1309 DBUG_RETURN((longlong) mysql_num_rows(db_result));
1310 }
1311
num_fields()1312 uint spider_db_mbase_result::num_fields()
1313 {
1314 DBUG_ENTER("spider_db_mbase_result::num_fields");
1315 DBUG_PRINT("info",("spider this=%p", this));
1316 DBUG_RETURN(mysql_num_fields(db_result));
1317 }
1318
move_to_pos(longlong pos)1319 void spider_db_mbase_result::move_to_pos(
1320 longlong pos
1321 ) {
1322 DBUG_ENTER("spider_db_mbase_result::move_to_pos");
1323 DBUG_PRINT("info",("spider this=%p", this));
1324 DBUG_PRINT("info",("spider pos=%lld", pos));
1325 /*
1326 DBUG_ASSERT(first_row);
1327 */
1328 db_result->data_cursor = first_row + pos;
1329 DBUG_VOID_RETURN;
1330 }
1331
get_errno()1332 int spider_db_mbase_result::get_errno()
1333 {
1334 DBUG_ENTER("spider_db_mbase_result::get_errno");
1335 DBUG_PRINT("info",("spider this=%p", this));
1336 DBUG_PRINT("info",("spider store_error_num=%d", store_error_num));
1337 DBUG_RETURN(store_error_num);
1338 }
1339
1340 #ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
fetch_columns_for_discover_table_structure(spider_string * str,CHARSET_INFO * access_charset)1341 int spider_db_mbase_result::fetch_columns_for_discover_table_structure(
1342 spider_string *str,
1343 CHARSET_INFO *access_charset
1344 ) {
1345 int error_num;
1346 uint length;
1347 MYSQL_ROW mysql_row;
1348 DBUG_ENTER("spider_db_mbase_result::fetch_columns_for_discover_table_structure");
1349 DBUG_PRINT("info",("spider this=%p", this));
1350 if (!(mysql_row = mysql_fetch_row(db_result)))
1351 {
1352 DBUG_PRINT("info",("spider fetch row is null"));
1353 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1354 {
1355 my_message(error_num,
1356 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1357 DBUG_RETURN(error_num);
1358 }
1359 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1360 }
1361 if (num_fields() != 7)
1362 {
1363 DBUG_PRINT("info",("spider num_fields != 7"));
1364 my_printf_error(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
1365 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
1366 }
1367 do {
1368 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1369 {
1370 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1371 }
1372 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1373 if (str->append(mysql_row[0], strlen(mysql_row[0]), access_charset))
1374 {
1375 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1376 }
1377 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_SPACE_LEN))
1378 {
1379 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1380 }
1381 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1382 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1383 if (str->append(mysql_row[5], strlen(mysql_row[5]), access_charset))
1384 {
1385 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1386 }
1387 if (mysql_row[3])
1388 {
1389 length = strlen(mysql_row[3]);
1390 if (str->reserve(SPIDER_SQL_CHARACTER_SET_LEN + length))
1391 {
1392 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1393 }
1394 str->q_append(SPIDER_SQL_CHARACTER_SET_STR, SPIDER_SQL_CHARACTER_SET_LEN);
1395 str->q_append(mysql_row[3], length);
1396 }
1397 if (mysql_row[4])
1398 {
1399 length = strlen(mysql_row[4]);
1400 if (str->reserve(SPIDER_SQL_COLLATE_LEN + length))
1401 {
1402 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1403 }
1404 str->q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
1405 str->q_append(mysql_row[4], length);
1406 }
1407 if (!strcmp(mysql_row[2], "NO"))
1408 {
1409 if (str->reserve(SPIDER_SQL_NOT_NULL_LEN))
1410 {
1411 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1412 }
1413 str->q_append(SPIDER_SQL_NOT_NULL_STR, SPIDER_SQL_NOT_NULL_LEN);
1414 if (mysql_row[1])
1415 {
1416 if (str->reserve(SPIDER_SQL_DEFAULT_LEN))
1417 {
1418 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1419 }
1420 str->q_append(SPIDER_SQL_DEFAULT_STR, SPIDER_SQL_DEFAULT_LEN);
1421 if (str->append(mysql_row[1], strlen(mysql_row[1]), access_charset))
1422 {
1423 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1424 }
1425 }
1426 } else {
1427 if (str->reserve(SPIDER_SQL_DEFAULT_LEN))
1428 {
1429 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1430 }
1431 str->q_append(SPIDER_SQL_DEFAULT_STR, SPIDER_SQL_DEFAULT_LEN);
1432 if (mysql_row[1])
1433 {
1434 if (str->append(mysql_row[1], strlen(mysql_row[1]), access_charset))
1435 {
1436 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1437 }
1438 } else {
1439 if (str->reserve(SPIDER_SQL_NULL_LEN))
1440 {
1441 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1442 }
1443 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
1444 }
1445 }
1446 if (mysql_row[6] && !strcmp(mysql_row[6], "auto_increment"))
1447 {
1448 if (str->reserve(SPIDER_SQL_AUTO_INCREMENT_LEN))
1449 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1450 str->q_append(SPIDER_SQL_AUTO_INCREMENT_STR, SPIDER_SQL_AUTO_INCREMENT_LEN);
1451 }
1452 if (str->reserve(SPIDER_SQL_COMMA_LEN))
1453 {
1454 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1455 }
1456 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1457 } while ((mysql_row = mysql_fetch_row(db_result)));
1458 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1459 {
1460 my_message(error_num,
1461 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1462 DBUG_RETURN(error_num);
1463 }
1464 DBUG_RETURN(0);
1465 }
1466
fetch_index_for_discover_table_structure(spider_string * str,CHARSET_INFO * access_charset)1467 int spider_db_mbase_result::fetch_index_for_discover_table_structure(
1468 spider_string *str,
1469 CHARSET_INFO *access_charset
1470 ) {
1471 int error_num;
1472 MYSQL_ROW mysql_row;
1473 DBUG_ENTER("spider_db_mbase_result::fetch_index_for_discover_table_structure");
1474 DBUG_PRINT("info",("spider this=%p", this));
1475 if (!(mysql_row = mysql_fetch_row(db_result)))
1476 {
1477 DBUG_PRINT("info",("spider fetch row is null"));
1478 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1479 {
1480 my_message(error_num,
1481 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1482 DBUG_RETURN(error_num);
1483 }
1484 DBUG_RETURN(0);
1485 }
1486 if (num_fields() != 13)
1487 {
1488 DBUG_PRINT("info",("spider num_fields != 13"));
1489 my_printf_error(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
1490 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
1491 }
1492 bool first = TRUE;
1493 bool without_size = FALSE;
1494 bool using_hash = FALSE;
1495 do {
1496 if (!strcmp(mysql_row[3], "1"))
1497 {
1498 without_size = FALSE;
1499 if (first)
1500 {
1501 first = FALSE;
1502 } else {
1503 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_COMMA_LEN +
1504 (using_hash ? SPIDER_SQL_USING_HASH_LEN : 0)))
1505 {
1506 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1507 }
1508 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1509 if (using_hash)
1510 str->q_append(SPIDER_SQL_USING_HASH_STR, SPIDER_SQL_USING_HASH_LEN);
1511 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1512 }
1513 /* new index */
1514 if (!strcmp(mysql_row[2], SPIDER_DB_PK_NAME_STR))
1515 {
1516 /* primary key */
1517 if (str->reserve(SPIDER_DB_PK_NAME_LEN + SPIDER_SQL_SPACE_LEN))
1518 {
1519 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1520 }
1521 str->q_append(SPIDER_DB_PK_NAME_STR, SPIDER_DB_PK_NAME_LEN);
1522 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1523 } else if (!strcmp(mysql_row[1], "0"))
1524 {
1525 /* unique key */
1526 if (str->reserve(SPIDER_DB_UNIQUE_NAME_LEN + SPIDER_SQL_SPACE_LEN))
1527 {
1528 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1529 }
1530 str->q_append(SPIDER_DB_UNIQUE_NAME_STR, SPIDER_DB_UNIQUE_NAME_LEN);
1531 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1532 } else if (mysql_row[10] && !strcmp(mysql_row[10], "FULLTEXT"))
1533 {
1534 /* fulltext key */
1535 if (str->reserve(SPIDER_SQL_FULLTEXT_LEN + SPIDER_SQL_SPACE_LEN))
1536 {
1537 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1538 }
1539 str->q_append(SPIDER_SQL_FULLTEXT_STR, SPIDER_SQL_FULLTEXT_LEN);
1540 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1541 } else if (mysql_row[10] && !strcmp(mysql_row[10], "SPATIAL"))
1542 {
1543 /* spatial key */
1544 without_size = TRUE;
1545 if (str->reserve(SPIDER_SQL_SPATIAL_LEN + SPIDER_SQL_SPACE_LEN))
1546 {
1547 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1548 }
1549 str->q_append(SPIDER_SQL_SPATIAL_STR, SPIDER_SQL_SPATIAL_LEN);
1550 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1551 }
1552 if (str->reserve(SPIDER_DB_KEY_NAME_LEN + SPIDER_SQL_SPACE_LEN))
1553 {
1554 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1555 }
1556 str->q_append(SPIDER_DB_KEY_NAME_STR, SPIDER_DB_KEY_NAME_LEN);
1557 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
1558 if (strcmp(mysql_row[2], SPIDER_DB_PK_NAME_STR))
1559 {
1560 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1561 {
1562 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1563 }
1564 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1565 if (str->append(mysql_row[2], strlen(mysql_row[2]), access_charset))
1566 {
1567 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1568 }
1569 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1570 {
1571 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1572 }
1573 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1574 }
1575 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
1576 {
1577 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1578 }
1579 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
1580 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1581 {
1582 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1583 }
1584 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1585 if (str->append(mysql_row[4], strlen(mysql_row[4]), access_charset))
1586 {
1587 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1588 }
1589 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1590 {
1591 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1592 }
1593 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1594 if (mysql_row[7] && !without_size)
1595 {
1596 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
1597 {
1598 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1599 }
1600 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
1601 if (str->append(mysql_row[7], strlen(mysql_row[7]), access_charset))
1602 {
1603 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1604 }
1605 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
1606 {
1607 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1608 }
1609 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1610 }
1611 } else {
1612 if (str->reserve(SPIDER_SQL_COMMA_LEN + SPIDER_SQL_NAME_QUOTE_LEN))
1613 {
1614 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1615 }
1616 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1617 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1618 if (str->append(mysql_row[4], strlen(mysql_row[4]), access_charset))
1619 {
1620 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1621 }
1622 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
1623 {
1624 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1625 }
1626 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
1627 if (mysql_row[7] && !without_size)
1628 {
1629 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
1630 {
1631 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1632 }
1633 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
1634 if (str->append(mysql_row[7], strlen(mysql_row[7]), access_charset))
1635 {
1636 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1637 }
1638 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
1639 {
1640 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1641 }
1642 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1643 }
1644 }
1645 if (mysql_row[10] && !strcmp(mysql_row[10], "HASH"))
1646 using_hash = TRUE;
1647 else
1648 using_hash = FALSE;
1649 } while ((mysql_row = mysql_fetch_row(db_result)));
1650 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1651 {
1652 my_message(error_num,
1653 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1654 DBUG_RETURN(error_num);
1655 }
1656 if (!first)
1657 {
1658 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_COMMA_LEN +
1659 (using_hash ? SPIDER_SQL_USING_HASH_LEN : 0)))
1660 {
1661 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1662 }
1663 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
1664 if (using_hash)
1665 str->q_append(SPIDER_SQL_USING_HASH_STR, SPIDER_SQL_USING_HASH_LEN);
1666 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
1667 }
1668 DBUG_RETURN(0);
1669 }
1670
fetch_table_for_discover_table_structure(spider_string * str,SPIDER_SHARE * spider_share,CHARSET_INFO * access_charset)1671 int spider_db_mbase_result::fetch_table_for_discover_table_structure(
1672 spider_string *str,
1673 SPIDER_SHARE *spider_share,
1674 CHARSET_INFO *access_charset
1675 ) {
1676 int error_num;
1677 MYSQL_ROW mysql_row;
1678 DBUG_ENTER("spider_db_mbase_result::fetch_table_for_discover_table_structure");
1679 DBUG_PRINT("info",("spider this=%p", this));
1680 if (!(mysql_row = mysql_fetch_row(db_result)))
1681 {
1682 DBUG_PRINT("info",("spider fetch row is null"));
1683 if ((error_num = mysql_errno(((spider_db_mbase *) db_conn)->db_conn)))
1684 {
1685 my_message(error_num,
1686 mysql_error(((spider_db_mbase *) db_conn)->db_conn), MYF(0));
1687 DBUG_RETURN(error_num);
1688 }
1689 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1690 }
1691 if (num_fields() < 18)
1692 {
1693 DBUG_PRINT("info",("spider num_fields != 18"));
1694 my_printf_error(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
1695 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
1696 }
1697 if (!mysql_row[14])
1698 {
1699 DBUG_PRINT("info",("spider mysql_row[14] is null"));
1700 my_printf_error(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
1701 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
1702 }
1703 DBUG_PRINT("info",("spider mysql_row[14]=%s", mysql_row[14]));
1704 if (!spider_share->table_share->table_charset)
1705 {
1706 spider_share->table_share->table_charset = get_charset_by_name(mysql_row[14], MYF(MY_WME));
1707 }
1708 DBUG_RETURN(0);
1709 }
1710 #endif
1711
spider_db_mbase(SPIDER_CONN * conn,spider_db_mbase_util * spider_db_mbase_utility)1712 spider_db_mbase::spider_db_mbase(
1713 SPIDER_CONN *conn,
1714 spider_db_mbase_util *spider_db_mbase_utility
1715 ) : spider_db_conn(conn), spider_db_mbase_utility(spider_db_mbase_utility),
1716 lock_table_hash_inited(FALSE), handler_open_array_inited(FALSE)
1717 {
1718 DBUG_ENTER("spider_db_mbase::spider_db_mbase");
1719 DBUG_PRINT("info",("spider this=%p", this));
1720 db_conn = NULL;
1721 DBUG_VOID_RETURN;
1722 }
1723
spider_db_mysql(SPIDER_CONN * conn)1724 spider_db_mysql::spider_db_mysql(
1725 SPIDER_CONN *conn
1726 ) : spider_db_mbase(conn, &spider_db_mysql_utility)
1727 {
1728 DBUG_ENTER("spider_db_mysql::spider_db_mysql");
1729 DBUG_PRINT("info",("spider this=%p", this));
1730 DBUG_VOID_RETURN;
1731 }
1732
spider_db_mariadb(SPIDER_CONN * conn)1733 spider_db_mariadb::spider_db_mariadb(
1734 SPIDER_CONN *conn
1735 ) : spider_db_mbase(conn, &spider_db_mariadb_utility)
1736 {
1737 DBUG_ENTER("spider_db_mariadb::spider_db_mariadb");
1738 DBUG_PRINT("info",("spider this=%p", this));
1739 DBUG_VOID_RETURN;
1740 }
1741
~spider_db_mbase()1742 spider_db_mbase::~spider_db_mbase()
1743 {
1744 DBUG_ENTER("spider_db_mbase::~spider_db_mbase");
1745 DBUG_PRINT("info",("spider this=%p", this));
1746 if (handler_open_array_inited)
1747 {
1748 reset_opened_handler();
1749 spider_free_mem_calc(spider_current_trx,
1750 handler_open_array_id,
1751 handler_open_array.max_element *
1752 handler_open_array.size_of_element);
1753 delete_dynamic(&handler_open_array);
1754 }
1755 if (lock_table_hash_inited)
1756 {
1757 spider_free_mem_calc(spider_current_trx,
1758 lock_table_hash_id,
1759 lock_table_hash.array.max_element *
1760 lock_table_hash.array.size_of_element);
1761 my_hash_free(&lock_table_hash);
1762 }
1763 DBUG_VOID_RETURN;
1764 }
1765
~spider_db_mysql()1766 spider_db_mysql::~spider_db_mysql()
1767 {
1768 DBUG_ENTER("spider_db_mysql::~spider_db_mysql");
1769 DBUG_PRINT("info",("spider this=%p", this));
1770 DBUG_VOID_RETURN;
1771 }
1772
~spider_db_mariadb()1773 spider_db_mariadb::~spider_db_mariadb()
1774 {
1775 DBUG_ENTER("spider_db_mariadb::~spider_db_mariadb");
1776 DBUG_PRINT("info",("spider this=%p", this));
1777 DBUG_VOID_RETURN;
1778 }
1779
init()1780 int spider_db_mbase::init()
1781 {
1782 DBUG_ENTER("spider_db_mbase::init");
1783 DBUG_PRINT("info",("spider this=%p", this));
1784 if (
1785 my_hash_init(&lock_table_hash, spd_charset_utf8_bin, 32, 0, 0,
1786 (my_hash_get_key) spider_link_get_key, 0, 0)
1787 ) {
1788 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1789 }
1790 spider_alloc_calc_mem_init(lock_table_hash, 140);
1791 spider_alloc_calc_mem(spider_current_trx,
1792 lock_table_hash,
1793 lock_table_hash.array.max_element *
1794 lock_table_hash.array.size_of_element);
1795 lock_table_hash_inited = TRUE;
1796
1797 if (
1798 SPD_INIT_DYNAMIC_ARRAY2(&handler_open_array,
1799 sizeof(SPIDER_LINK_FOR_HASH *), NULL, 16, 16, MYF(MY_WME))
1800 ) {
1801 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1802 }
1803 spider_alloc_calc_mem_init(handler_open_array, 162);
1804 spider_alloc_calc_mem(spider_current_trx,
1805 handler_open_array,
1806 handler_open_array.max_element *
1807 handler_open_array.size_of_element);
1808 handler_open_array_inited = TRUE;
1809 DBUG_RETURN(0);
1810 }
1811
is_connected()1812 bool spider_db_mbase::is_connected()
1813 {
1814 DBUG_ENTER("spider_db_mbase::is_connected");
1815 DBUG_PRINT("info",("spider this=%p", this));
1816 DBUG_RETURN(db_conn);
1817 }
1818
bg_connect()1819 void spider_db_mbase::bg_connect()
1820 {
1821 DBUG_ENTER("spider_db_mbase::bg_connect");
1822 DBUG_PRINT("info",("spider this=%p", this));
1823 DBUG_VOID_RETURN;
1824 }
1825
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)1826 int spider_db_mbase::connect(
1827 char *tgt_host,
1828 char *tgt_username,
1829 char *tgt_password,
1830 long tgt_port,
1831 char *tgt_socket,
1832 char *server_name,
1833 int connect_retry_count,
1834 longlong connect_retry_interval
1835 ) {
1836 int error_num;
1837 my_bool connect_mutex = spider_param_connect_mutex();
1838 DBUG_ENTER("spider_db_mbase::connect");
1839 DBUG_PRINT("info",("spider this=%p", this));
1840 while (TRUE)
1841 {
1842 THD *thd = current_thd;
1843 DBUG_PRINT("info",("spider thd->killed=%s",
1844 thd ? (thd->killed ? "TRUE" : "FALSE") : "NULL"));
1845 DBUG_PRINT("info",("spider abort_loop=%s",
1846 *spd_abort_loop ? "TRUE" : "FALSE"));
1847 if (
1848 (thd && thd->killed) ||
1849 *spd_abort_loop
1850 ) {
1851 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
1852 }
1853
1854 if (!db_conn)
1855 {
1856 if (!(db_conn = mysql_init(NULL)))
1857 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
1858 }
1859
1860 mysql_options(db_conn, MYSQL_OPT_READ_TIMEOUT,
1861 &conn->net_read_timeout);
1862 mysql_options(db_conn, MYSQL_OPT_WRITE_TIMEOUT,
1863 &conn->net_write_timeout);
1864 mysql_options(db_conn, MYSQL_OPT_CONNECT_TIMEOUT,
1865 &conn->connect_timeout);
1866 mysql_options(db_conn, MYSQL_OPT_USE_REMOTE_CONNECTION,
1867 NULL);
1868
1869 if (
1870 conn->tgt_ssl_ca_length |
1871 conn->tgt_ssl_capath_length |
1872 conn->tgt_ssl_cert_length |
1873 conn->tgt_ssl_key_length
1874 ) {
1875 mysql_ssl_set(db_conn, conn->tgt_ssl_key, conn->tgt_ssl_cert,
1876 conn->tgt_ssl_ca, conn->tgt_ssl_capath, conn->tgt_ssl_cipher);
1877 if (conn->tgt_ssl_vsc)
1878 {
1879 my_bool verify_flg = TRUE;
1880 mysql_options(db_conn, MYSQL_OPT_SSL_VERIFY_SERVER_CERT,
1881 &verify_flg);
1882 }
1883 }
1884
1885 if (conn->tgt_default_file)
1886 {
1887 DBUG_PRINT("info",("spider tgt_default_file=%s",
1888 conn->tgt_default_file));
1889 mysql_options(db_conn, MYSQL_READ_DEFAULT_FILE,
1890 conn->tgt_default_file);
1891 }
1892 if (conn->tgt_default_group)
1893 {
1894 DBUG_PRINT("info",("spider tgt_default_group=%s",
1895 conn->tgt_default_group));
1896 mysql_options(db_conn, MYSQL_READ_DEFAULT_GROUP,
1897 conn->tgt_default_group);
1898 }
1899
1900 if (connect_mutex)
1901 pthread_mutex_lock(&spider_open_conn_mutex);
1902 /* tgt_db not use */
1903 if (
1904 !spider_param_dry_access() &&
1905 !mysql_real_connect(
1906 db_conn,
1907 tgt_host,
1908 tgt_username,
1909 tgt_password,
1910 NULL,
1911 tgt_port,
1912 tgt_socket,
1913 CLIENT_MULTI_STATEMENTS
1914 )
1915 ) {
1916 if (connect_mutex)
1917 pthread_mutex_unlock(&spider_open_conn_mutex);
1918 error_num = mysql_errno(db_conn);
1919 disconnect();
1920 DBUG_PRINT("info",("spider thd->killed=%s",
1921 thd ? (thd->killed ? "TRUE" : "FALSE") : "NULL"));
1922 DBUG_PRINT("info",("spider abort_loop=%s",
1923 *spd_abort_loop ? "TRUE" : "FALSE"));
1924 if (
1925 (thd && thd->killed) ||
1926 *spd_abort_loop
1927 ) {
1928 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
1929 }
1930 if (
1931 (
1932 error_num != CR_CONN_HOST_ERROR &&
1933 error_num != CR_CONNECTION_ERROR
1934 ) ||
1935 !connect_retry_count
1936 ) {
1937 if (error_num == ER_CON_COUNT_ERROR)
1938 {
1939 *conn->need_mon = 0;
1940 my_error(ER_CON_COUNT_ERROR, MYF(0));
1941 DBUG_RETURN(ER_CON_COUNT_ERROR);
1942 }
1943 *conn->need_mon = ER_CONNECT_TO_FOREIGN_DATA_SOURCE;
1944 my_error(ER_CONNECT_TO_FOREIGN_DATA_SOURCE, MYF(0),
1945 server_name ? server_name : tgt_host);
1946 DBUG_RETURN(ER_CONNECT_TO_FOREIGN_DATA_SOURCE);
1947 }
1948 connect_retry_count--;
1949 my_sleep((ulong) connect_retry_interval);
1950 } else {
1951 #ifdef SPIDER_NET_HAS_THD
1952 db_conn->net.thd = NULL;
1953 #endif
1954 if (connect_mutex)
1955 pthread_mutex_unlock(&spider_open_conn_mutex);
1956 break;
1957 }
1958 }
1959 DBUG_RETURN(0);
1960 }
1961
ping()1962 int spider_db_mbase::ping(
1963 ) {
1964 DBUG_ENTER("spider_db_mbase::ping");
1965 DBUG_PRINT("info",("spider this=%p", this));
1966 if (spider_param_dry_access())
1967 DBUG_RETURN(0);
1968 DBUG_RETURN(simple_command(db_conn, COM_PING, 0, 0, 0));
1969 }
1970
bg_disconnect()1971 void spider_db_mbase::bg_disconnect()
1972 {
1973 DBUG_ENTER("spider_db_mbase::bg_disconnect");
1974 DBUG_PRINT("info",("spider this=%p", this));
1975 DBUG_VOID_RETURN;
1976 }
1977
disconnect()1978 void spider_db_mbase::disconnect()
1979 {
1980 DBUG_ENTER("spider_db_mbase::disconnect");
1981 DBUG_PRINT("info",("spider this=%p", this));
1982 DBUG_PRINT("info",("spider db_conn=%p", db_conn));
1983 if (db_conn)
1984 {
1985 mysql_close(db_conn);
1986 db_conn = NULL;
1987 }
1988 DBUG_VOID_RETURN;
1989 }
1990
set_net_timeout()1991 int spider_db_mbase::set_net_timeout()
1992 {
1993 DBUG_ENTER("spider_db_mbase::set_net_timeout");
1994 DBUG_PRINT("info",("spider this=%p", this));
1995 DBUG_PRINT("info",("spider conn=%p", conn));
1996 my_net_set_read_timeout(&db_conn->net, conn->net_read_timeout);
1997 my_net_set_write_timeout(&db_conn->net, conn->net_write_timeout);
1998 DBUG_RETURN(0);
1999 }
2000
exec_query(const char * query,uint length,int quick_mode)2001 int spider_db_mbase::exec_query(
2002 const char *query,
2003 uint length,
2004 int quick_mode
2005 ) {
2006 int error_num = 0;
2007 uint log_result_errors = spider_param_log_result_errors();
2008 DBUG_ENTER("spider_db_mbase::exec_query");
2009 DBUG_PRINT("info",("spider this=%p", this));
2010 if (spider_param_general_log())
2011 {
2012 const char *tgt_str = conn->tgt_host;
2013 uint32 tgt_len = conn->tgt_host_length;
2014 spider_string tmp_query_str;
2015 tmp_query_str.init_calc_mem(230);
2016 if (tmp_query_str.reserve(
2017 length + conn->tgt_wrapper_length +
2018 tgt_len + (SPIDER_SQL_SPACE_LEN * 2)))
2019 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2020 tmp_query_str.q_append(conn->tgt_wrapper, conn->tgt_wrapper_length);
2021 tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
2022 tmp_query_str.q_append(tgt_str, tgt_len);
2023 tmp_query_str.q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
2024 tmp_query_str.q_append(query, length);
2025 general_log_write(current_thd, COM_QUERY, tmp_query_str.ptr(),
2026 tmp_query_str.length());
2027 }
2028 if (!spider_param_dry_access())
2029 {
2030 error_num = mysql_real_query(db_conn, query, length);
2031 }
2032 if (
2033 (error_num && log_result_errors >= 1) ||
2034 (log_result_errors >= 2 && db_conn->warning_count > 0) ||
2035 (log_result_errors >= 4)
2036 ) {
2037 THD *thd = current_thd;
2038 uint log_result_error_with_sql = spider_param_log_result_error_with_sql();
2039 if (log_result_error_with_sql)
2040 {
2041 time_t cur_time = (time_t) time((time_t*) 0);
2042 struct tm lt;
2043 struct tm *l_time = localtime_r(&cur_time, <);
2044 spider_string tmp_query_str;
2045 tmp_query_str.init_calc_mem(243);
2046 uint query_length = thd->query_length();
2047 if ((log_result_error_with_sql & 2) && query_length)
2048 {
2049 Security_context *security_ctx = thd->security_ctx;
2050 tmp_query_str.length(0);
2051 if (tmp_query_str.reserve(query_length + 1))
2052 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2053 tmp_query_str.q_append(thd->query(), query_length);
2054 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [RECV SPIDER SQL] "
2055 "from [%s][%s] to %ld: "
2056 "sql: %s\n",
2057 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
2058 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
2059 security_ctx->user ? security_ctx->user : "system user",
2060 security_ctx->host_or_ip,
2061 (ulong) thd->thread_id,
2062 tmp_query_str.c_ptr_safe());
2063 }
2064 if (log_result_error_with_sql & 1)
2065 {
2066 tmp_query_str.length(0);
2067 if (tmp_query_str.reserve(length + 1))
2068 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
2069 tmp_query_str.q_append(query, length);
2070 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [SEND SPIDER SQL] "
2071 "from %ld to [%s] %ld: "
2072 "sql: %s\n",
2073 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
2074 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
2075 (ulong) thd->thread_id, conn->tgt_host, (ulong) db_conn->thread_id,
2076 tmp_query_str.c_ptr_safe());
2077 }
2078 }
2079 if (log_result_errors >= 2 && db_conn->warning_count > 0)
2080 {
2081 time_t cur_time = (time_t) time((time_t*) 0);
2082 struct tm lt;
2083 struct tm *l_time = localtime_r(&cur_time, <);
2084 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [WARN SPIDER RESULT] "
2085 "from [%s] %ld to %ld: "
2086 "affected_rows: %llu id: %llu status: %u warning_count: %u\n",
2087 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
2088 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
2089 conn->tgt_host, (ulong) db_conn->thread_id, (ulong) thd->thread_id,
2090 db_conn->affected_rows, db_conn->insert_id,
2091 db_conn->server_status, db_conn->warning_count);
2092 if (spider_param_log_result_errors() >= 3)
2093 print_warnings(l_time);
2094 } else if (log_result_errors >= 4)
2095 {
2096 time_t cur_time = (time_t) time((time_t*) 0);
2097 struct tm lt;
2098 struct tm *l_time = localtime_r(&cur_time, <);
2099 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [INFO SPIDER RESULT] "
2100 "from [%s] %ld to %ld: "
2101 "affected_rows: %llu id: %llu status: %u warning_count: %u\n",
2102 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
2103 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
2104 conn->tgt_host, (ulong) db_conn->thread_id, (ulong) thd->thread_id,
2105 db_conn->affected_rows, db_conn->insert_id,
2106 db_conn->server_status, db_conn->warning_count);
2107 }
2108 }
2109 DBUG_RETURN(error_num);
2110 }
2111
get_errno()2112 int spider_db_mbase::get_errno()
2113 {
2114 DBUG_ENTER("spider_db_mbase::get_errno");
2115 DBUG_PRINT("info",("spider this=%p", this));
2116 stored_error = mysql_errno(db_conn);
2117 DBUG_PRINT("info",("spider stored_error=%d", stored_error));
2118 DBUG_RETURN(stored_error);
2119 }
2120
get_error()2121 const char *spider_db_mbase::get_error()
2122 {
2123 const char *error_ptr;
2124 DBUG_ENTER("spider_db_mbase::get_error");
2125 DBUG_PRINT("info",("spider this=%p", this));
2126 error_ptr = mysql_error(db_conn);
2127 DBUG_PRINT("info",("spider error=%s", error_ptr));
2128 DBUG_RETURN(error_ptr);
2129 }
2130
is_server_gone_error(int error_num)2131 bool spider_db_mbase::is_server_gone_error(
2132 int error_num
2133 ) {
2134 bool server_gone;
2135 DBUG_ENTER("spider_db_mbase::is_server_gone_error");
2136 DBUG_PRINT("info",("spider this=%p", this));
2137 server_gone =
2138 (error_num == CR_SERVER_GONE_ERROR || error_num == CR_SERVER_LOST);
2139 DBUG_PRINT("info",("spider server_gone=%s", server_gone ? "TRUE" : "FALSE"));
2140 DBUG_RETURN(server_gone);
2141 }
2142
is_dup_entry_error(int error_num)2143 bool spider_db_mbase::is_dup_entry_error(
2144 int error_num
2145 ) {
2146 bool dup_entry;
2147 DBUG_ENTER("spider_db_mbase::is_dup_entry_error");
2148 DBUG_PRINT("info",("spider this=%p", this));
2149 dup_entry =
2150 (
2151 error_num == ER_DUP_ENTRY ||
2152 error_num == ER_DUP_KEY ||
2153 error_num == HA_ERR_FOUND_DUPP_KEY
2154 );
2155 DBUG_PRINT("info",("spider dup_entry=%s", dup_entry ? "TRUE" : "FALSE"));
2156 DBUG_RETURN(dup_entry);
2157 }
2158
is_xa_nota_error(int error_num)2159 bool spider_db_mbase::is_xa_nota_error(
2160 int error_num
2161 ) {
2162 bool xa_nota;
2163 DBUG_ENTER("spider_db_mbase::is_xa_nota_error");
2164 DBUG_PRINT("info",("spider this=%p", this));
2165 xa_nota =
2166 (
2167 error_num == ER_XAER_NOTA ||
2168 error_num == ER_XA_RBTIMEOUT ||
2169 error_num == ER_XA_RBDEADLOCK
2170 );
2171 DBUG_PRINT("info",("spider xa_nota=%s", xa_nota ? "TRUE" : "FALSE"));
2172 DBUG_RETURN(xa_nota);
2173 }
2174
print_warnings(struct tm * l_time)2175 void spider_db_mbase::print_warnings(
2176 struct tm *l_time
2177 ) {
2178 DBUG_ENTER("spider_db_mbase::print_warnings");
2179 DBUG_PRINT("info",("spider this=%p", this));
2180 if (db_conn->status == MYSQL_STATUS_READY)
2181 {
2182 #if MYSQL_VERSION_ID < 50500
2183 if (!(db_conn->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS))
2184 #else
2185 if (!(db_conn->server_status & SERVER_MORE_RESULTS_EXISTS))
2186 #endif
2187 {
2188 if (
2189 spider_param_dry_access() ||
2190 !mysql_real_query(db_conn, SPIDER_SQL_SHOW_WARNINGS_STR,
2191 SPIDER_SQL_SHOW_WARNINGS_LEN)
2192 ) {
2193 MYSQL_RES *res = NULL;
2194 MYSQL_ROW row = NULL;
2195 uint num_fields;
2196 if (
2197 spider_param_dry_access() ||
2198 !(res = mysql_store_result(db_conn)) ||
2199 !(row = mysql_fetch_row(res))
2200 ) {
2201 if (mysql_errno(db_conn))
2202 {
2203 if (res)
2204 mysql_free_result(res);
2205 DBUG_VOID_RETURN;
2206 }
2207 /* no record is ok */
2208 }
2209 num_fields = mysql_num_fields(res);
2210 if (num_fields != 3)
2211 {
2212 mysql_free_result(res);
2213 DBUG_VOID_RETURN;
2214 }
2215 while (row)
2216 {
2217 fprintf(stderr, "%04d%02d%02d %02d:%02d:%02d [WARN SPIDER RESULT] "
2218 "from [%s] %ld to %ld: %s %s %s\n",
2219 l_time->tm_year + 1900, l_time->tm_mon + 1, l_time->tm_mday,
2220 l_time->tm_hour, l_time->tm_min, l_time->tm_sec,
2221 conn->tgt_host, (ulong) db_conn->thread_id,
2222 (ulong) current_thd->thread_id, row[0], row[1], row[2]);
2223 row = mysql_fetch_row(res);
2224 }
2225 if (res)
2226 mysql_free_result(res);
2227 }
2228 }
2229 }
2230 DBUG_VOID_RETURN;
2231 }
2232
store_result(spider_db_result_buffer ** spider_res_buf,st_spider_db_request_key * request_key,int * error_num)2233 spider_db_result *spider_db_mbase::store_result(
2234 spider_db_result_buffer **spider_res_buf,
2235 st_spider_db_request_key *request_key,
2236 int *error_num
2237 ) {
2238 spider_db_mbase_result *result;
2239 DBUG_ENTER("spider_db_mbase::store_result");
2240 DBUG_PRINT("info",("spider this=%p", this));
2241 DBUG_ASSERT(!spider_res_buf);
2242 if ((result = new spider_db_mbase_result(this)))
2243 {
2244 *error_num = 0;
2245 if (
2246 spider_param_dry_access() ||
2247 !(result->db_result = mysql_store_result(db_conn))
2248 ) {
2249 delete result;
2250 result = NULL;
2251 } else {
2252 result->first_row = result->db_result->data_cursor;
2253 DBUG_PRINT("info",("spider result->first_row=%p", result->first_row));
2254 }
2255 } else {
2256 *error_num = HA_ERR_OUT_OF_MEM;
2257 }
2258 DBUG_RETURN(result);
2259 }
2260
use_result(st_spider_db_request_key * request_key,int * error_num)2261 spider_db_result *spider_db_mbase::use_result(
2262 st_spider_db_request_key *request_key,
2263 int *error_num
2264 ) {
2265 spider_db_mbase_result *result;
2266 DBUG_ENTER("spider_db_mbase::use_result");
2267 DBUG_PRINT("info",("spider this=%p", this));
2268 if ((result = new spider_db_mbase_result(this)))
2269 {
2270 *error_num = 0;
2271 if (
2272 spider_param_dry_access() ||
2273 !(result->db_result = db_conn->methods->use_result(db_conn))
2274 ) {
2275 delete result;
2276 result = NULL;
2277 } else {
2278 result->first_row = NULL;
2279 }
2280 } else {
2281 *error_num = HA_ERR_OUT_OF_MEM;
2282 }
2283 DBUG_RETURN(result);
2284 }
2285
next_result()2286 int spider_db_mbase::next_result()
2287 {
2288 int status;
2289 DBUG_ENTER("spider_db_mbase::next_result");
2290 DBUG_PRINT("info",("spider this=%p", this));
2291 if (db_conn->status != MYSQL_STATUS_READY)
2292 {
2293 my_message(ER_SPIDER_UNKNOWN_NUM, ER_SPIDER_UNKNOWN_STR, MYF(0));
2294 DBUG_RETURN(ER_SPIDER_UNKNOWN_NUM);
2295 }
2296
2297 db_conn->net.last_errno = 0;
2298 db_conn->net.last_error[0] = '\0';
2299 strmov(db_conn->net.sqlstate, "00000");
2300 db_conn->affected_rows = ~(my_ulonglong) 0;
2301
2302 #if MYSQL_VERSION_ID < 50500
2303 if (db_conn->last_used_con->server_status & SERVER_MORE_RESULTS_EXISTS)
2304 #else
2305 if (db_conn->server_status & SERVER_MORE_RESULTS_EXISTS)
2306 #endif
2307 {
2308 if ((status = db_conn->methods->read_query_result(db_conn)) > 0)
2309 DBUG_RETURN(spider_db_errorno(conn));
2310 DBUG_RETURN(status);
2311 }
2312 DBUG_RETURN(-1);
2313 }
2314
affected_rows()2315 uint spider_db_mbase::affected_rows()
2316 {
2317 MYSQL *last_used_con;
2318 DBUG_ENTER("spider_db_mbase::affected_rows");
2319 DBUG_PRINT("info",("spider this=%p", this));
2320 #if MYSQL_VERSION_ID < 50500
2321 last_used_con = db_conn->last_used_con;
2322 #else
2323 last_used_con = db_conn;
2324 #endif
2325 DBUG_RETURN((uint) last_used_con->affected_rows);
2326 }
2327
last_insert_id()2328 ulonglong spider_db_mbase::last_insert_id()
2329 {
2330 MYSQL *last_used_con;
2331 DBUG_ENTER("spider_db_mbase::last_insert_id");
2332 DBUG_PRINT("info",("spider this=%p", this));
2333 #if MYSQL_VERSION_ID < 50500
2334 last_used_con = db_conn->last_used_con;
2335 #else
2336 last_used_con = db_conn;
2337 #endif
2338 DBUG_RETURN((uint) last_used_con->insert_id);
2339 }
2340
set_character_set(const char * csname)2341 int spider_db_mbase::set_character_set(
2342 const char *csname
2343 ) {
2344 DBUG_ENTER("spider_db_mbase::set_character_set");
2345 DBUG_PRINT("info",("spider this=%p", this));
2346 if (spider_param_dry_access())
2347 DBUG_RETURN(0);
2348 DBUG_RETURN(mysql_set_character_set(db_conn, csname));
2349 }
2350
select_db(const char * dbname)2351 int spider_db_mbase::select_db(
2352 const char *dbname
2353 ) {
2354 DBUG_ENTER("spider_db_mbase::select_db");
2355 DBUG_PRINT("info",("spider this=%p", this));
2356 if (spider_param_dry_access())
2357 DBUG_RETURN(0);
2358 DBUG_RETURN(mysql_select_db(db_conn, dbname));
2359 }
2360
consistent_snapshot(int * need_mon)2361 int spider_db_mbase::consistent_snapshot(
2362 int *need_mon
2363 ) {
2364 DBUG_ENTER("spider_db_mbase::consistent_snapshot");
2365 DBUG_PRINT("info",("spider this=%p", this));
2366 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2367 pthread_mutex_lock(&conn->mta_conn_mutex);
2368 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2369 conn->need_mon = need_mon;
2370 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2371 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2372 conn->mta_conn_mutex_lock_already = TRUE;
2373 conn->mta_conn_mutex_unlock_later = TRUE;
2374 if (spider_db_query(
2375 conn,
2376 SPIDER_SQL_START_CONSISTENT_SNAPSHOT_STR,
2377 SPIDER_SQL_START_CONSISTENT_SNAPSHOT_LEN,
2378 -1,
2379 need_mon)
2380 ) {
2381 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2382 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2383 conn->mta_conn_mutex_lock_already = FALSE;
2384 conn->mta_conn_mutex_unlock_later = FALSE;
2385 DBUG_RETURN(spider_db_errorno(conn));
2386 }
2387 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2388 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2389 conn->mta_conn_mutex_lock_already = FALSE;
2390 conn->mta_conn_mutex_unlock_later = FALSE;
2391 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2392 pthread_mutex_unlock(&conn->mta_conn_mutex);
2393 DBUG_RETURN(0);
2394 }
2395
trx_start_in_bulk_sql()2396 bool spider_db_mbase::trx_start_in_bulk_sql()
2397 {
2398 DBUG_ENTER("spider_db_mbase::trx_start_in_bulk_sql");
2399 DBUG_PRINT("info",("spider this=%p", this));
2400 DBUG_RETURN(TRUE);
2401 }
2402
start_transaction(int * need_mon)2403 int spider_db_mbase::start_transaction(
2404 int *need_mon
2405 ) {
2406 DBUG_ENTER("spider_db_mbase::start_transaction");
2407 DBUG_PRINT("info",("spider this=%p", this));
2408 pthread_mutex_assert_owner(&conn->mta_conn_mutex);
2409 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2410 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2411 if (spider_db_query(
2412 conn,
2413 SPIDER_SQL_START_TRANSACTION_STR,
2414 SPIDER_SQL_START_TRANSACTION_LEN,
2415 -1,
2416 need_mon)
2417 ) {
2418 DBUG_RETURN(spider_db_errorno(conn));
2419 }
2420 DBUG_RETURN(0);
2421 }
2422
commit(int * need_mon)2423 int spider_db_mbase::commit(
2424 int *need_mon
2425 ) {
2426 DBUG_ENTER("spider_db_mbase::commit");
2427 DBUG_PRINT("info",("spider this=%p", this));
2428 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2429 pthread_mutex_lock(&conn->mta_conn_mutex);
2430 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2431 conn->need_mon = need_mon;
2432 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2433 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2434 conn->mta_conn_mutex_lock_already = TRUE;
2435 conn->mta_conn_mutex_unlock_later = TRUE;
2436 if (spider_db_query(
2437 conn,
2438 SPIDER_SQL_COMMIT_STR,
2439 SPIDER_SQL_COMMIT_LEN,
2440 -1,
2441 need_mon)
2442 ) {
2443 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2444 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2445 conn->mta_conn_mutex_lock_already = FALSE;
2446 conn->mta_conn_mutex_unlock_later = FALSE;
2447 DBUG_RETURN(spider_db_errorno(conn));
2448 }
2449 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2450 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2451 conn->mta_conn_mutex_lock_already = FALSE;
2452 conn->mta_conn_mutex_unlock_later = FALSE;
2453 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2454 pthread_mutex_unlock(&conn->mta_conn_mutex);
2455 DBUG_RETURN(0);
2456 }
2457
rollback(int * need_mon)2458 int spider_db_mbase::rollback(
2459 int *need_mon
2460 ) {
2461 bool is_error;
2462 int error_num;
2463 DBUG_ENTER("spider_db_mbase::rollback");
2464 DBUG_PRINT("info",("spider this=%p", this));
2465 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2466 pthread_mutex_lock(&conn->mta_conn_mutex);
2467 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2468 conn->need_mon = need_mon;
2469 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2470 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2471 conn->mta_conn_mutex_lock_already = TRUE;
2472 conn->mta_conn_mutex_unlock_later = TRUE;
2473 if (spider_db_query(
2474 conn,
2475 SPIDER_SQL_ROLLBACK_STR,
2476 SPIDER_SQL_ROLLBACK_LEN,
2477 -1,
2478 need_mon)
2479 ) {
2480 is_error = conn->thd->is_error();
2481 error_num = spider_db_errorno(conn);
2482 if (
2483 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
2484 !is_error
2485 )
2486 conn->thd->clear_error();
2487 else {
2488 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2489 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2490 conn->mta_conn_mutex_lock_already = FALSE;
2491 conn->mta_conn_mutex_unlock_later = FALSE;
2492 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2493 pthread_mutex_unlock(&conn->mta_conn_mutex);
2494 DBUG_RETURN(error_num);
2495 }
2496 }
2497 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2498 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2499 conn->mta_conn_mutex_lock_already = FALSE;
2500 conn->mta_conn_mutex_unlock_later = FALSE;
2501 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2502 pthread_mutex_unlock(&conn->mta_conn_mutex);
2503 DBUG_RETURN(0);
2504 }
2505
xa_start(XID * xid,int * need_mon)2506 int spider_db_mbase::xa_start(
2507 XID *xid,
2508 int *need_mon
2509 ) {
2510 DBUG_ENTER("spider_db_mbase::xa_start");
2511 DBUG_PRINT("info",("spider this=%p", this));
2512 DBUG_ASSERT(0);
2513 DBUG_RETURN(0);
2514 }
2515
xa_start_in_bulk_sql()2516 bool spider_db_mbase::xa_start_in_bulk_sql()
2517 {
2518 DBUG_ENTER("spider_db_mbase::xa_start_in_bulk_sql");
2519 DBUG_PRINT("info",("spider this=%p", this));
2520 DBUG_RETURN(TRUE);
2521 }
2522
xa_end(XID * xid,int * need_mon)2523 int spider_db_mbase::xa_end(
2524 XID *xid,
2525 int *need_mon
2526 ) {
2527 char sql_buf[SPIDER_SQL_XA_END_LEN + XIDDATASIZE + sizeof(long) + 9];
2528 spider_string sql_str(sql_buf, sizeof(sql_buf), &my_charset_bin);
2529 DBUG_ENTER("spider_db_mbase::xa_end");
2530 DBUG_PRINT("info",("spider this=%p", this));
2531 sql_str.init_calc_mem(108);
2532
2533 sql_str.length(0);
2534 sql_str.q_append(SPIDER_SQL_XA_END_STR, SPIDER_SQL_XA_END_LEN);
2535 spider_db_append_xid_str(&sql_str, xid);
2536 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2537 pthread_mutex_lock(&conn->mta_conn_mutex);
2538 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2539 conn->need_mon = need_mon;
2540 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2541 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2542 conn->mta_conn_mutex_lock_already = TRUE;
2543 conn->mta_conn_mutex_unlock_later = TRUE;
2544 if (spider_db_query(
2545 conn,
2546 sql_str.ptr(),
2547 sql_str.length(),
2548 -1,
2549 need_mon)
2550 ) {
2551 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2552 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2553 conn->mta_conn_mutex_lock_already = FALSE;
2554 conn->mta_conn_mutex_unlock_later = FALSE;
2555 DBUG_RETURN(spider_db_errorno(conn));
2556 }
2557 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2558 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2559 conn->mta_conn_mutex_lock_already = FALSE;
2560 conn->mta_conn_mutex_unlock_later = FALSE;
2561 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2562 pthread_mutex_unlock(&conn->mta_conn_mutex);
2563 DBUG_RETURN(0);
2564 }
2565
xa_prepare(XID * xid,int * need_mon)2566 int spider_db_mbase::xa_prepare(
2567 XID *xid,
2568 int *need_mon
2569 ) {
2570 char sql_buf[SPIDER_SQL_XA_PREPARE_LEN + XIDDATASIZE + sizeof(long) + 9];
2571 spider_string sql_str(sql_buf, sizeof(sql_buf), &my_charset_bin);
2572 DBUG_ENTER("spider_db_mbase::xa_prepare");
2573 DBUG_PRINT("info",("spider this=%p", this));
2574 sql_str.init_calc_mem(109);
2575
2576 sql_str.length(0);
2577 sql_str.q_append(SPIDER_SQL_XA_PREPARE_STR, SPIDER_SQL_XA_PREPARE_LEN);
2578 spider_db_append_xid_str(&sql_str, xid);
2579 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2580 pthread_mutex_lock(&conn->mta_conn_mutex);
2581 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2582 conn->need_mon = need_mon;
2583 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2584 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2585 conn->mta_conn_mutex_lock_already = TRUE;
2586 conn->mta_conn_mutex_unlock_later = TRUE;
2587 if (spider_db_query(
2588 conn,
2589 sql_str.ptr(),
2590 sql_str.length(),
2591 -1,
2592 need_mon)
2593 ) {
2594 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2595 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2596 conn->mta_conn_mutex_lock_already = FALSE;
2597 conn->mta_conn_mutex_unlock_later = FALSE;
2598 DBUG_RETURN(spider_db_errorno(conn));
2599 }
2600 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2601 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2602 conn->mta_conn_mutex_lock_already = FALSE;
2603 conn->mta_conn_mutex_unlock_later = FALSE;
2604 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2605 pthread_mutex_unlock(&conn->mta_conn_mutex);
2606 DBUG_RETURN(0);
2607 }
2608
xa_commit(XID * xid,int * need_mon)2609 int spider_db_mbase::xa_commit(
2610 XID *xid,
2611 int *need_mon
2612 ) {
2613 char sql_buf[SPIDER_SQL_XA_COMMIT_LEN + XIDDATASIZE + sizeof(long) + 9];
2614 spider_string sql_str(sql_buf, sizeof(sql_buf), &my_charset_bin);
2615 DBUG_ENTER("spider_db_mbase::xa_commit");
2616 DBUG_PRINT("info",("spider this=%p", this));
2617 sql_str.init_calc_mem(110);
2618
2619 sql_str.length(0);
2620 sql_str.q_append(SPIDER_SQL_XA_COMMIT_STR, SPIDER_SQL_XA_COMMIT_LEN);
2621 spider_db_append_xid_str(&sql_str, xid);
2622 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2623 pthread_mutex_lock(&conn->mta_conn_mutex);
2624 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2625 conn->need_mon = need_mon;
2626 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2627 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2628 conn->mta_conn_mutex_lock_already = TRUE;
2629 conn->mta_conn_mutex_unlock_later = TRUE;
2630 if (spider_db_query(
2631 conn,
2632 sql_str.ptr(),
2633 sql_str.length(),
2634 -1,
2635 need_mon)
2636 ) {
2637 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2638 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2639 conn->mta_conn_mutex_lock_already = FALSE;
2640 conn->mta_conn_mutex_unlock_later = FALSE;
2641 DBUG_RETURN(spider_db_errorno(conn));
2642 }
2643 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2644 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2645 conn->mta_conn_mutex_lock_already = FALSE;
2646 conn->mta_conn_mutex_unlock_later = FALSE;
2647 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2648 pthread_mutex_unlock(&conn->mta_conn_mutex);
2649 DBUG_RETURN(0);
2650 }
2651
xa_rollback(XID * xid,int * need_mon)2652 int spider_db_mbase::xa_rollback(
2653 XID *xid,
2654 int *need_mon
2655 ) {
2656 char sql_buf[SPIDER_SQL_XA_ROLLBACK_LEN + XIDDATASIZE + sizeof(long) + 9];
2657 spider_string sql_str(sql_buf, sizeof(sql_buf), &my_charset_bin);
2658 DBUG_ENTER("spider_db_mbase::xa_rollback");
2659 DBUG_PRINT("info",("spider this=%p", this));
2660 sql_str.init_calc_mem(111);
2661
2662 sql_str.length(0);
2663 sql_str.q_append(SPIDER_SQL_XA_ROLLBACK_STR, SPIDER_SQL_XA_ROLLBACK_LEN);
2664 spider_db_append_xid_str(&sql_str, xid);
2665 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2666 pthread_mutex_lock(&conn->mta_conn_mutex);
2667 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2668 conn->need_mon = need_mon;
2669 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2670 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2671 conn->mta_conn_mutex_lock_already = TRUE;
2672 conn->mta_conn_mutex_unlock_later = TRUE;
2673 if (spider_db_query(
2674 conn,
2675 sql_str.ptr(),
2676 sql_str.length(),
2677 -1,
2678 need_mon)
2679 ) {
2680 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2681 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2682 conn->mta_conn_mutex_lock_already = FALSE;
2683 conn->mta_conn_mutex_unlock_later = FALSE;
2684 DBUG_RETURN(spider_db_errorno(conn));
2685 }
2686 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2687 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2688 conn->mta_conn_mutex_lock_already = FALSE;
2689 conn->mta_conn_mutex_unlock_later = FALSE;
2690 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2691 pthread_mutex_unlock(&conn->mta_conn_mutex);
2692 DBUG_RETURN(0);
2693 }
2694
set_trx_isolation_in_bulk_sql()2695 bool spider_db_mbase::set_trx_isolation_in_bulk_sql()
2696 {
2697 DBUG_ENTER("spider_db_mbase::set_trx_isolation_in_bulk_sql");
2698 DBUG_PRINT("info",("spider this=%p", this));
2699 DBUG_RETURN(TRUE);
2700 }
2701
set_trx_isolation(int trx_isolation,int * need_mon)2702 int spider_db_mbase::set_trx_isolation(
2703 int trx_isolation,
2704 int *need_mon
2705 ) {
2706 DBUG_ENTER("spider_db_mbase::set_trx_isolation");
2707 DBUG_PRINT("info",("spider this=%p", this));
2708 switch (trx_isolation)
2709 {
2710 case ISO_READ_UNCOMMITTED:
2711 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2712 pthread_mutex_lock(&conn->mta_conn_mutex);
2713 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2714 conn->need_mon = need_mon;
2715 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2716 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2717 conn->mta_conn_mutex_lock_already = TRUE;
2718 conn->mta_conn_mutex_unlock_later = TRUE;
2719 if (spider_db_query(
2720 conn,
2721 SPIDER_SQL_ISO_READ_UNCOMMITTED_STR,
2722 SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN,
2723 -1,
2724 need_mon)
2725 ) {
2726 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2727 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2728 conn->mta_conn_mutex_lock_already = FALSE;
2729 conn->mta_conn_mutex_unlock_later = FALSE;
2730 DBUG_RETURN(spider_db_errorno(conn));
2731 }
2732 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2733 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2734 conn->mta_conn_mutex_lock_already = FALSE;
2735 conn->mta_conn_mutex_unlock_later = FALSE;
2736 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2737 pthread_mutex_unlock(&conn->mta_conn_mutex);
2738 break;
2739 case ISO_READ_COMMITTED:
2740 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2741 pthread_mutex_lock(&conn->mta_conn_mutex);
2742 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2743 conn->need_mon = need_mon;
2744 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2745 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2746 conn->mta_conn_mutex_lock_already = TRUE;
2747 conn->mta_conn_mutex_unlock_later = TRUE;
2748 if (spider_db_query(
2749 conn,
2750 SPIDER_SQL_ISO_READ_COMMITTED_STR,
2751 SPIDER_SQL_ISO_READ_COMMITTED_LEN,
2752 -1,
2753 need_mon)
2754 ) {
2755 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2756 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2757 conn->mta_conn_mutex_lock_already = FALSE;
2758 conn->mta_conn_mutex_unlock_later = FALSE;
2759 DBUG_RETURN(spider_db_errorno(conn));
2760 }
2761 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2762 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2763 conn->mta_conn_mutex_lock_already = FALSE;
2764 conn->mta_conn_mutex_unlock_later = FALSE;
2765 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2766 pthread_mutex_unlock(&conn->mta_conn_mutex);
2767 break;
2768 case ISO_REPEATABLE_READ:
2769 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2770 pthread_mutex_lock(&conn->mta_conn_mutex);
2771 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2772 conn->need_mon = need_mon;
2773 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2774 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2775 conn->mta_conn_mutex_lock_already = TRUE;
2776 conn->mta_conn_mutex_unlock_later = TRUE;
2777 if (spider_db_query(
2778 conn,
2779 SPIDER_SQL_ISO_REPEATABLE_READ_STR,
2780 SPIDER_SQL_ISO_REPEATABLE_READ_LEN,
2781 -1,
2782 need_mon)
2783 ) {
2784 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2785 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2786 conn->mta_conn_mutex_lock_already = FALSE;
2787 conn->mta_conn_mutex_unlock_later = FALSE;
2788 DBUG_RETURN(spider_db_errorno(conn));
2789 }
2790 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2791 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2792 conn->mta_conn_mutex_lock_already = FALSE;
2793 conn->mta_conn_mutex_unlock_later = FALSE;
2794 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2795 pthread_mutex_unlock(&conn->mta_conn_mutex);
2796 break;
2797 case ISO_SERIALIZABLE:
2798 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2799 pthread_mutex_lock(&conn->mta_conn_mutex);
2800 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2801 conn->need_mon = need_mon;
2802 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2803 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2804 conn->mta_conn_mutex_lock_already = TRUE;
2805 conn->mta_conn_mutex_unlock_later = TRUE;
2806 if (spider_db_query(
2807 conn,
2808 SPIDER_SQL_ISO_SERIALIZABLE_STR,
2809 SPIDER_SQL_ISO_SERIALIZABLE_LEN,
2810 -1,
2811 need_mon)
2812 ) {
2813 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2814 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2815 conn->mta_conn_mutex_lock_already = FALSE;
2816 conn->mta_conn_mutex_unlock_later = FALSE;
2817 DBUG_RETURN(spider_db_errorno(conn));
2818 }
2819 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2820 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2821 conn->mta_conn_mutex_lock_already = FALSE;
2822 conn->mta_conn_mutex_unlock_later = FALSE;
2823 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2824 pthread_mutex_unlock(&conn->mta_conn_mutex);
2825 break;
2826 default:
2827 DBUG_RETURN(HA_ERR_UNSUPPORTED);
2828 }
2829 DBUG_RETURN(0);
2830 }
2831
set_autocommit_in_bulk_sql()2832 bool spider_db_mbase::set_autocommit_in_bulk_sql()
2833 {
2834 DBUG_ENTER("spider_db_mbase::set_autocommit_in_bulk_sql");
2835 DBUG_PRINT("info",("spider this=%p", this));
2836 DBUG_RETURN(TRUE);
2837 }
2838
set_autocommit(bool autocommit,int * need_mon)2839 int spider_db_mbase::set_autocommit(
2840 bool autocommit,
2841 int *need_mon
2842 ) {
2843 DBUG_ENTER("spider_db_mbase::set_autocommit");
2844 DBUG_PRINT("info",("spider this=%p", this));
2845 if (autocommit)
2846 {
2847 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2848 pthread_mutex_lock(&conn->mta_conn_mutex);
2849 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2850 conn->need_mon = need_mon;
2851 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2852 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2853 conn->mta_conn_mutex_lock_already = TRUE;
2854 conn->mta_conn_mutex_unlock_later = TRUE;
2855 if (spider_db_query(
2856 conn,
2857 SPIDER_SQL_AUTOCOMMIT_ON_STR,
2858 SPIDER_SQL_AUTOCOMMIT_ON_LEN,
2859 -1,
2860 need_mon)
2861 ) {
2862 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2863 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2864 conn->mta_conn_mutex_lock_already = FALSE;
2865 conn->mta_conn_mutex_unlock_later = FALSE;
2866 DBUG_RETURN(spider_db_errorno(conn));
2867 }
2868 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2869 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2870 conn->mta_conn_mutex_lock_already = FALSE;
2871 conn->mta_conn_mutex_unlock_later = FALSE;
2872 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2873 pthread_mutex_unlock(&conn->mta_conn_mutex);
2874 } else {
2875 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2876 pthread_mutex_lock(&conn->mta_conn_mutex);
2877 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2878 conn->need_mon = need_mon;
2879 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2880 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2881 conn->mta_conn_mutex_lock_already = TRUE;
2882 conn->mta_conn_mutex_unlock_later = TRUE;
2883 if (spider_db_query(
2884 conn,
2885 SPIDER_SQL_AUTOCOMMIT_OFF_STR,
2886 SPIDER_SQL_AUTOCOMMIT_OFF_LEN,
2887 -1,
2888 need_mon)
2889 ) {
2890 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2891 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2892 conn->mta_conn_mutex_lock_already = FALSE;
2893 conn->mta_conn_mutex_unlock_later = FALSE;
2894 DBUG_RETURN(spider_db_errorno(conn));
2895 }
2896 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2897 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2898 conn->mta_conn_mutex_lock_already = FALSE;
2899 conn->mta_conn_mutex_unlock_later = FALSE;
2900 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2901 pthread_mutex_unlock(&conn->mta_conn_mutex);
2902 }
2903 DBUG_RETURN(0);
2904 }
2905
set_sql_log_off_in_bulk_sql()2906 bool spider_db_mbase::set_sql_log_off_in_bulk_sql()
2907 {
2908 DBUG_ENTER("spider_db_mbase::set_sql_log_off_in_bulk_sql");
2909 DBUG_PRINT("info",("spider this=%p", this));
2910 DBUG_RETURN(TRUE);
2911 }
2912
set_sql_log_off(bool sql_log_off,int * need_mon)2913 int spider_db_mbase::set_sql_log_off(
2914 bool sql_log_off,
2915 int *need_mon
2916 ) {
2917 DBUG_ENTER("spider_db_mbase::set_sql_log_off");
2918 DBUG_PRINT("info",("spider this=%p", this));
2919 if (sql_log_off)
2920 {
2921 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2922 pthread_mutex_lock(&conn->mta_conn_mutex);
2923 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2924 conn->need_mon = need_mon;
2925 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2926 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2927 conn->mta_conn_mutex_lock_already = TRUE;
2928 conn->mta_conn_mutex_unlock_later = TRUE;
2929 if (spider_db_query(
2930 conn,
2931 SPIDER_SQL_SQL_LOG_ON_STR,
2932 SPIDER_SQL_SQL_LOG_ON_LEN,
2933 -1,
2934 need_mon)
2935 ) {
2936 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2937 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2938 conn->mta_conn_mutex_lock_already = FALSE;
2939 conn->mta_conn_mutex_unlock_later = FALSE;
2940 DBUG_RETURN(spider_db_errorno(conn));
2941 }
2942 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2943 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2944 conn->mta_conn_mutex_lock_already = FALSE;
2945 conn->mta_conn_mutex_unlock_later = FALSE;
2946 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2947 pthread_mutex_unlock(&conn->mta_conn_mutex);
2948 } else {
2949 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
2950 pthread_mutex_lock(&conn->mta_conn_mutex);
2951 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
2952 conn->need_mon = need_mon;
2953 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
2954 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
2955 conn->mta_conn_mutex_lock_already = TRUE;
2956 conn->mta_conn_mutex_unlock_later = TRUE;
2957 if (spider_db_query(
2958 conn,
2959 SPIDER_SQL_SQL_LOG_OFF_STR,
2960 SPIDER_SQL_SQL_LOG_OFF_LEN,
2961 -1,
2962 need_mon)
2963 ) {
2964 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2965 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2966 conn->mta_conn_mutex_lock_already = FALSE;
2967 conn->mta_conn_mutex_unlock_later = FALSE;
2968 DBUG_RETURN(spider_db_errorno(conn));
2969 }
2970 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
2971 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
2972 conn->mta_conn_mutex_lock_already = FALSE;
2973 conn->mta_conn_mutex_unlock_later = FALSE;
2974 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
2975 pthread_mutex_unlock(&conn->mta_conn_mutex);
2976 }
2977 DBUG_RETURN(0);
2978 }
2979
set_time_zone_in_bulk_sql()2980 bool spider_db_mbase::set_time_zone_in_bulk_sql()
2981 {
2982 DBUG_ENTER("spider_db_mbase::set_time_zone_in_bulk_sql");
2983 DBUG_PRINT("info",("spider this=%p", this));
2984 DBUG_RETURN(TRUE);
2985 }
2986
set_time_zone(Time_zone * time_zone,int * need_mon)2987 int spider_db_mbase::set_time_zone(
2988 Time_zone *time_zone,
2989 int *need_mon
2990 ) {
2991 const String *tz_str = time_zone->get_name();
2992 char sql_buf[MAX_FIELD_WIDTH];
2993 spider_string sql_str(sql_buf, sizeof(sql_buf), &my_charset_bin);
2994 DBUG_ENTER("spider_db_mbase::set_time_zone");
2995 DBUG_PRINT("info",("spider this=%p", this));
2996 sql_str.init_calc_mem(214);
2997 sql_str.length(0);
2998 if (sql_str.reserve(SPIDER_SQL_TIME_ZONE_LEN +
2999 tz_str->length() + SPIDER_SQL_VALUE_QUOTE_LEN))
3000 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3001 sql_str.q_append(SPIDER_SQL_TIME_ZONE_STR, SPIDER_SQL_TIME_ZONE_LEN);
3002 sql_str.q_append(tz_str->ptr(), tz_str->length());
3003 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3004 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
3005 pthread_mutex_lock(&conn->mta_conn_mutex);
3006 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
3007 conn->need_mon = need_mon;
3008 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3009 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
3010 conn->mta_conn_mutex_lock_already = TRUE;
3011 conn->mta_conn_mutex_unlock_later = TRUE;
3012 if (spider_db_query(
3013 conn,
3014 sql_str.ptr(),
3015 sql_str.length(),
3016 -1,
3017 need_mon)
3018 ) {
3019 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3020 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3021 conn->mta_conn_mutex_lock_already = FALSE;
3022 conn->mta_conn_mutex_unlock_later = FALSE;
3023 DBUG_RETURN(spider_db_errorno(conn));
3024 }
3025 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3026 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3027 conn->mta_conn_mutex_lock_already = FALSE;
3028 conn->mta_conn_mutex_unlock_later = FALSE;
3029 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3030 pthread_mutex_unlock(&conn->mta_conn_mutex);
3031 DBUG_RETURN(0);
3032 }
3033
exec_simple_sql_with_result(SPIDER_TRX * trx,SPIDER_SHARE * share,const char * sql,uint sql_length,int all_link_idx,int * need_mon,SPIDER_DB_RESULT ** res)3034 int spider_db_mbase::exec_simple_sql_with_result(
3035 SPIDER_TRX *trx,
3036 SPIDER_SHARE *share,
3037 const char *sql,
3038 uint sql_length,
3039 int all_link_idx,
3040 int *need_mon,
3041 SPIDER_DB_RESULT **res
3042 ) {
3043 int error_num;
3044 DBUG_ENTER("spider_db_mbase::exec_simple_sql_with_result");
3045 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
3046 pthread_mutex_lock(&conn->mta_conn_mutex);
3047 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
3048 conn->need_mon = need_mon;
3049 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
3050 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
3051 conn->mta_conn_mutex_lock_already = TRUE;
3052 conn->mta_conn_mutex_unlock_later = TRUE;
3053 spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd,
3054 share);
3055 if (
3056 (error_num = spider_db_set_names_internal(trx, share, conn,
3057 all_link_idx, need_mon)) ||
3058 (
3059 spider_db_query(
3060 conn,
3061 sql,
3062 sql_length,
3063 -1,
3064 need_mon) &&
3065 (error_num = spider_db_errorno(conn))
3066 )
3067 ) {
3068 if (
3069 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
3070 !conn->disable_reconnect
3071 ) {
3072 /* retry */
3073 if ((error_num = spider_db_ping_internal(share, conn,
3074 all_link_idx, need_mon)))
3075 {
3076 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3077 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3078 conn->mta_conn_mutex_lock_already = FALSE;
3079 conn->mta_conn_mutex_unlock_later = FALSE;
3080 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3081 pthread_mutex_unlock(&conn->mta_conn_mutex);
3082 DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
3083 DBUG_RETURN(error_num);
3084 }
3085 if ((error_num = spider_db_set_names_internal(trx, share, conn,
3086 all_link_idx, need_mon)))
3087 {
3088 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3089 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3090 conn->mta_conn_mutex_lock_already = FALSE;
3091 conn->mta_conn_mutex_unlock_later = FALSE;
3092 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3093 pthread_mutex_unlock(&conn->mta_conn_mutex);
3094 DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
3095 DBUG_RETURN(error_num);
3096 }
3097 spider_conn_set_timeout_from_share(conn, all_link_idx, trx->thd,
3098 share);
3099 if (spider_db_query(
3100 conn,
3101 sql,
3102 sql_length,
3103 -1,
3104 need_mon)
3105 ) {
3106 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3107 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3108 conn->mta_conn_mutex_lock_already = FALSE;
3109 conn->mta_conn_mutex_unlock_later = FALSE;
3110 DBUG_PRINT("info", ("spider error_num=%d 3", error_num));
3111 DBUG_RETURN(spider_db_errorno(conn));
3112 }
3113 } else {
3114 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3115 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3116 conn->mta_conn_mutex_lock_already = FALSE;
3117 conn->mta_conn_mutex_unlock_later = FALSE;
3118 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3119 pthread_mutex_unlock(&conn->mta_conn_mutex);
3120 DBUG_PRINT("info", ("spider error_num=%d 4", error_num));
3121 DBUG_RETURN(error_num);
3122 }
3123 }
3124 if (!(*res = store_result(NULL, NULL, &error_num)))
3125 {
3126 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3127 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3128 conn->mta_conn_mutex_lock_already = FALSE;
3129 conn->mta_conn_mutex_unlock_later = FALSE;
3130 if (error_num)
3131 {
3132 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3133 pthread_mutex_unlock(&conn->mta_conn_mutex);
3134 DBUG_PRINT("info", ("spider error_num=%d 5", error_num));
3135 DBUG_RETURN(error_num);
3136 }
3137 else if ((error_num = spider_db_errorno(conn)))
3138 {
3139 DBUG_PRINT("info", ("spider error_num=%d 6", error_num));
3140 DBUG_RETURN(error_num);
3141 } else {
3142 DBUG_PRINT("info", ("spider error_num=%d 7",
3143 ER_QUERY_ON_FOREIGN_DATA_SOURCE));
3144 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
3145 }
3146 }
3147 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
3148 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
3149 conn->mta_conn_mutex_lock_already = FALSE;
3150 conn->mta_conn_mutex_unlock_later = FALSE;
3151 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
3152 pthread_mutex_unlock(&conn->mta_conn_mutex);
3153 DBUG_RETURN(0);
3154 }
3155
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)3156 int spider_db_mbase::show_master_status(
3157 SPIDER_TRX *trx,
3158 SPIDER_SHARE *share,
3159 int all_link_idx,
3160 int *need_mon,
3161 TABLE *table,
3162 spider_string *str,
3163 int mode,
3164 SPIDER_DB_RESULT **res1,
3165 SPIDER_DB_RESULT **res2
3166 ) {
3167 int error_num;
3168 const char *binlog_file_name, *binlog_pos;
3169 uint binlog_file_name_length, binlog_pos_length;
3170 DBUG_ENTER("spider_db_mbase::show_master_status");
3171 if ((error_num = exec_simple_sql_with_result(trx, share,
3172 SPIDER_SQL_SHOW_MASTER_STATUS_STR, SPIDER_SQL_SHOW_MASTER_STATUS_LEN,
3173 all_link_idx, need_mon, res1))
3174 ) {
3175 DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
3176 DBUG_RETURN(error_num);
3177 }
3178
3179 if (!(error_num = ((spider_db_mbase_result *)*res1)->fetch_show_master_status(
3180 &binlog_file_name, &binlog_pos))
3181 ) {
3182 binlog_file_name_length = strlen(binlog_file_name);
3183 binlog_pos_length = strlen(binlog_pos);
3184 spider_store_binlog_pos_binlog_file(table,
3185 binlog_file_name, binlog_file_name_length,
3186 binlog_pos, binlog_pos_length, conn->access_charset);
3187 if (mode > 0)
3188 {
3189 error_num = select_binlog_gtid_pos(
3190 trx,
3191 share,
3192 all_link_idx,
3193 need_mon,
3194 table,
3195 str,
3196 binlog_file_name,
3197 binlog_file_name_length,
3198 binlog_pos,
3199 binlog_pos_length,
3200 res2
3201 );
3202 } else {
3203 spider_store_binlog_pos_gtid(table, NULL, 0, conn->access_charset);
3204 }
3205 }
3206 /*
3207 res->free_result();
3208 delete res;
3209 */
3210 if (error_num)
3211 {
3212 DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
3213 DBUG_RETURN(error_num);
3214 }
3215 DBUG_RETURN(0);
3216 }
3217
select_binlog_gtid_pos(SPIDER_TRX * trx,SPIDER_SHARE * share,int all_link_idx,int * need_mon,TABLE * table,spider_string * str,const char * binlog_file_name,uint binlog_file_name_length,const char * binlog_pos,uint binlog_pos_length,SPIDER_DB_RESULT ** res)3218 int spider_db_mbase::select_binlog_gtid_pos(
3219 SPIDER_TRX *trx,
3220 SPIDER_SHARE *share,
3221 int all_link_idx,
3222 int *need_mon,
3223 TABLE *table,
3224 spider_string *str,
3225 const char *binlog_file_name,
3226 uint binlog_file_name_length,
3227 const char *binlog_pos,
3228 uint binlog_pos_length,
3229 SPIDER_DB_RESULT **res
3230 ) {
3231 int error_num;
3232 size_t length;
3233 const char *gtid_pos;
3234 DBUG_ENTER("spider_db_mbase::select_binlog_gtid_pos");
3235 str->length(0);
3236 if (str->reserve(
3237 SPIDER_SQL_BINLOG_GTID_POS_LEN +
3238 SPIDER_SQL_OPEN_PAREN_LEN +
3239 SPIDER_SQL_VALUE_QUOTE_LEN +
3240 binlog_file_name_length * 2 +
3241 SPIDER_SQL_VALUE_QUOTE_LEN +
3242 SPIDER_SQL_COMMA_LEN +
3243 SPIDER_SQL_VALUE_QUOTE_LEN +
3244 binlog_pos_length * 2 +
3245 SPIDER_SQL_VALUE_QUOTE_LEN +
3246 SPIDER_SQL_CLOSE_PAREN_LEN
3247 ))
3248 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3249 str->q_append(SPIDER_SQL_BINLOG_GTID_POS_STR,
3250 SPIDER_SQL_BINLOG_GTID_POS_LEN);
3251 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
3252 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3253 length = conn->db_conn->escape_string((char *)str->ptr() + str->length(),
3254 binlog_file_name, binlog_file_name_length);
3255 str->length(str->length() + length);
3256 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3257 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
3258 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3259 length = conn->db_conn->escape_string((char *)str->ptr() + str->length(),
3260 binlog_pos, binlog_pos_length);
3261 str->length(str->length() + length);
3262 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3263 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
3264
3265 if ((error_num = exec_simple_sql_with_result(trx, share,
3266 str->ptr(), str->length(), all_link_idx, need_mon, res)))
3267 {
3268 DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
3269 DBUG_RETURN(error_num);
3270 }
3271 if (!(error_num = ((spider_db_mbase_result *)*res)->fetch_select_binlog_gtid_pos(>id_pos)))
3272 {
3273 spider_store_binlog_pos_gtid(table, gtid_pos, strlen(gtid_pos), conn->access_charset);
3274 }
3275 /*
3276 res->free_result();
3277 delete res;
3278 */
3279 if (error_num)
3280 {
3281 DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
3282 DBUG_RETURN(error_num);
3283 }
3284 DBUG_RETURN(0);
3285 }
3286
3287 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
append_sql(char * sql,ulong sql_length,st_spider_db_request_key * request_key)3288 int spider_db_mbase::append_sql(
3289 char *sql,
3290 ulong sql_length,
3291 st_spider_db_request_key *request_key
3292 ) {
3293 DBUG_ENTER("spider_db_mbase::append_sql");
3294 DBUG_PRINT("info",("spider this=%p", this));
3295 DBUG_ASSERT(0);
3296 DBUG_RETURN(0);
3297 }
3298
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)3299 int spider_db_mbase::append_open_handler(
3300 uint handler_id,
3301 const char *db_name,
3302 const char *table_name,
3303 const char *index_name,
3304 const char *sql,
3305 st_spider_db_request_key *request_key
3306 ) {
3307 DBUG_ENTER("spider_db_mbase::append_open_handler");
3308 DBUG_PRINT("info",("spider this=%p", this));
3309 DBUG_ASSERT(0);
3310 DBUG_RETURN(0);
3311 }
3312
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)3313 int spider_db_mbase::append_select(
3314 uint handler_id,
3315 spider_string *sql,
3316 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
3317 int limit,
3318 int skip,
3319 st_spider_db_request_key *request_key
3320 ) {
3321 DBUG_ENTER("spider_db_mbase::append_select");
3322 DBUG_PRINT("info",("spider this=%p", this));
3323 DBUG_ASSERT(0);
3324 DBUG_RETURN(0);
3325 }
3326
append_insert(uint handler_id,SPIDER_DB_HS_STRING_REF_BUFFER * upds,st_spider_db_request_key * request_key)3327 int spider_db_mbase::append_insert(
3328 uint handler_id,
3329 SPIDER_DB_HS_STRING_REF_BUFFER *upds,
3330 st_spider_db_request_key *request_key
3331 ) {
3332 DBUG_ENTER("spider_db_mbase::append_insert");
3333 DBUG_PRINT("info",("spider this=%p", this));
3334 DBUG_ASSERT(0);
3335 DBUG_RETURN(0);
3336 }
3337
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)3338 int spider_db_mbase::append_update(
3339 uint handler_id,
3340 spider_string *sql,
3341 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
3342 SPIDER_DB_HS_STRING_REF_BUFFER *upds,
3343 int limit,
3344 int skip,
3345 bool increment,
3346 bool decrement,
3347 st_spider_db_request_key *request_key
3348 ) {
3349 DBUG_ENTER("spider_db_mbase::append_update");
3350 DBUG_PRINT("info",("spider this=%p", this));
3351 DBUG_ASSERT(0);
3352 DBUG_RETURN(0);
3353 }
3354
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)3355 int spider_db_mbase::append_delete(
3356 uint handler_id,
3357 spider_string *sql,
3358 SPIDER_DB_HS_STRING_REF_BUFFER *keys,
3359 int limit,
3360 int skip,
3361 st_spider_db_request_key *request_key
3362 ) {
3363 DBUG_ENTER("spider_db_mbase::append_delete");
3364 DBUG_PRINT("info",("spider this=%p", this));
3365 DBUG_ASSERT(0);
3366 DBUG_RETURN(0);
3367 }
3368
reset_request_queue()3369 void spider_db_mbase::reset_request_queue()
3370 {
3371 DBUG_ENTER("spider_db_mbase::reset_request_queue");
3372 DBUG_PRINT("info",("spider this=%p", this));
3373 DBUG_ASSERT(0);
3374 DBUG_VOID_RETURN;
3375 }
3376 #endif
3377
escape_string(char * to,const char * from,size_t from_length)3378 size_t spider_db_mbase::escape_string(
3379 char *to,
3380 const char *from,
3381 size_t from_length
3382 ) {
3383 DBUG_ENTER("spider_db_mbase::escape_string");
3384 DBUG_PRINT("info",("spider this=%p", this));
3385 if (db_conn->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES)
3386 DBUG_RETURN(escape_quotes_for_mysql(db_conn->charset, to, 0,
3387 from, from_length));
3388 DBUG_RETURN(escape_string_for_mysql(db_conn->charset, to, 0,
3389 from, from_length));
3390 }
3391
have_lock_table_list()3392 bool spider_db_mbase::have_lock_table_list()
3393 {
3394 DBUG_ENTER("spider_db_mbase::have_lock_table_list");
3395 DBUG_PRINT("info",("spider this=%p", this));
3396 DBUG_RETURN(lock_table_hash.records);
3397 }
3398
append_lock_tables(spider_string * str)3399 int spider_db_mbase::append_lock_tables(
3400 spider_string *str
3401 ) {
3402 int error_num;
3403 ha_spider *tmp_spider;
3404 int lock_type;
3405 uint conn_link_idx;
3406 int tmp_link_idx;
3407 SPIDER_LINK_FOR_HASH *tmp_link_for_hash;
3408 const char *db_name;
3409 uint db_name_length;
3410 CHARSET_INFO *db_name_charset;
3411 const char *table_name;
3412 uint table_name_length;
3413 CHARSET_INFO *table_name_charset;
3414 DBUG_ENTER("spider_db_mbase::lock_tables");
3415 DBUG_PRINT("info",("spider this=%p", this));
3416 if ((error_num = spider_db_mbase_utility->append_lock_table_head(str)))
3417 {
3418 DBUG_RETURN(error_num);
3419 }
3420 while ((tmp_link_for_hash =
3421 (SPIDER_LINK_FOR_HASH *) my_hash_element(&lock_table_hash, 0)))
3422 {
3423 tmp_spider = tmp_link_for_hash->spider;
3424 tmp_link_idx = tmp_link_for_hash->link_idx;
3425 switch (tmp_spider->lock_type)
3426 {
3427 case TL_READ:
3428 lock_type = SPIDER_DB_TABLE_LOCK_READ_LOCAL;
3429 break;
3430 case TL_READ_NO_INSERT:
3431 lock_type = SPIDER_DB_TABLE_LOCK_READ;
3432 break;
3433 case TL_WRITE_LOW_PRIORITY:
3434 lock_type = SPIDER_DB_TABLE_LOCK_LOW_PRIORITY_WRITE;
3435 break;
3436 case TL_WRITE:
3437 lock_type = SPIDER_DB_TABLE_LOCK_WRITE;
3438 break;
3439 default:
3440 // no lock
3441 DBUG_PRINT("info",("spider lock_type=%d", tmp_spider->lock_type));
3442 DBUG_RETURN(0);
3443 }
3444 conn_link_idx = tmp_spider->conn_link_idx[tmp_link_idx];
3445 spider_mbase_share *db_share = (spider_mbase_share *)
3446 tmp_spider->share->dbton_share[conn->dbton_id];
3447 if (&db_share->db_names_str[conn_link_idx])
3448 {
3449 db_name = db_share->db_names_str[conn_link_idx].ptr();
3450 db_name_length = db_share->db_names_str[conn_link_idx].length();
3451 db_name_charset = tmp_spider->share->access_charset;
3452 } else {
3453 db_name = tmp_spider->share->tgt_dbs[conn_link_idx];
3454 db_name_length = tmp_spider->share->tgt_dbs_lengths[conn_link_idx];
3455 db_name_charset = system_charset_info;
3456 }
3457 if (&db_share->table_names_str[conn_link_idx])
3458 {
3459 table_name = db_share->table_names_str[conn_link_idx].ptr();
3460 table_name_length = db_share->table_names_str[conn_link_idx].length();
3461 table_name_charset = tmp_spider->share->access_charset;
3462 } else {
3463 table_name = tmp_spider->share->tgt_table_names[conn_link_idx];
3464 table_name_length =
3465 tmp_spider->share->tgt_table_names_lengths[conn_link_idx];
3466 table_name_charset = system_charset_info;
3467 }
3468 if ((error_num = spider_db_mbase_utility->
3469 append_lock_table_body(
3470 str,
3471 db_name,
3472 db_name_length,
3473 db_name_charset,
3474 table_name,
3475 table_name_length,
3476 table_name_charset,
3477 lock_type
3478 )
3479 )) {
3480 my_hash_reset(&lock_table_hash);
3481 DBUG_RETURN(error_num);
3482 }
3483 #ifdef HASH_UPDATE_WITH_HASH_VALUE
3484 my_hash_delete_with_hash_value(&lock_table_hash,
3485 tmp_link_for_hash->db_table_str_hash_value, (uchar*) tmp_link_for_hash);
3486 #else
3487 my_hash_delete(&lock_table_hash, (uchar*) tmp_link_for_hash);
3488 #endif
3489 }
3490 if ((error_num = spider_db_mbase_utility->append_lock_table_tail(str)))
3491 {
3492 DBUG_RETURN(error_num);
3493 }
3494 DBUG_RETURN(0);
3495 }
3496
append_unlock_tables(spider_string * str)3497 int spider_db_mbase::append_unlock_tables(
3498 spider_string *str
3499 ) {
3500 int error_num;
3501 DBUG_ENTER("spider_db_mbase::append_unlock_tables");
3502 DBUG_PRINT("info",("spider this=%p", this));
3503 if ((error_num = spider_db_mbase_utility->append_unlock_table(str)))
3504 {
3505 DBUG_RETURN(error_num);
3506 }
3507 DBUG_RETURN(0);
3508 }
3509
get_lock_table_hash_count()3510 uint spider_db_mbase::get_lock_table_hash_count()
3511 {
3512 DBUG_ENTER("spider_db_mbase::get_lock_table_hash_count");
3513 DBUG_PRINT("info",("spider this=%p", this));
3514 DBUG_RETURN(lock_table_hash.records);
3515 }
3516
reset_lock_table_hash()3517 void spider_db_mbase::reset_lock_table_hash()
3518 {
3519 DBUG_ENTER("spider_db_mbase::reset_lock_table_hash");
3520 DBUG_PRINT("info",("spider this=%p", this));
3521 my_hash_reset(&lock_table_hash);
3522 DBUG_VOID_RETURN;
3523 }
3524
get_opened_handler_count()3525 uint spider_db_mbase::get_opened_handler_count()
3526 {
3527 DBUG_ENTER("spider_db_mbase::get_opened_handler_count");
3528 DBUG_PRINT("info",("spider this=%p", this));
3529 DBUG_RETURN(handler_open_array.elements);
3530 }
3531
reset_opened_handler()3532 void spider_db_mbase::reset_opened_handler()
3533 {
3534 ha_spider *tmp_spider;
3535 int tmp_link_idx;
3536 SPIDER_LINK_FOR_HASH **tmp_link_for_hash;
3537 DBUG_ENTER("spider_db_mbase::reset_opened_handler");
3538 DBUG_PRINT("info",("spider this=%p", this));
3539 while ((tmp_link_for_hash =
3540 (SPIDER_LINK_FOR_HASH **) pop_dynamic(&handler_open_array)))
3541 {
3542 tmp_spider = (*tmp_link_for_hash)->spider;
3543 tmp_link_idx = (*tmp_link_for_hash)->link_idx;
3544 tmp_spider->clear_handler_opened(tmp_link_idx, conn->conn_kind);
3545 }
3546 DBUG_VOID_RETURN;
3547 }
3548
set_dup_key_idx(ha_spider * spider,int link_idx)3549 void spider_db_mbase::set_dup_key_idx(
3550 ha_spider *spider,
3551 int link_idx
3552 ) {
3553 TABLE *table = spider->get_table();
3554 uint roop_count, pk_idx = table->s->primary_key;
3555 int key_name_length;
3556 int max_length = 0;
3557 const char *key_name;
3558 DBUG_ENTER("spider_db_mbase::set_dup_key_idx");
3559 DBUG_PRINT("info",("spider this=%p", this));
3560 DBUG_PRINT("info",("spider error_str=%s", conn->error_str));
3561 for (roop_count = 0; roop_count < table->s->keys; roop_count++)
3562 {
3563 if (roop_count == pk_idx)
3564 {
3565 DBUG_PRINT("info",("spider pk_idx=%u", roop_count));
3566 int all_link_idx = spider->conn_link_idx[link_idx];
3567 key_name = spider->share->tgt_pk_names[all_link_idx];
3568 key_name_length = spider->share->tgt_pk_names_lengths[all_link_idx];
3569 } else {
3570 #ifdef SPIDER_use_LEX_CSTRING_for_KEY_Field_name
3571 key_name = table->s->key_info[roop_count].name.str;
3572 key_name_length = table->s->key_info[roop_count].name.length;
3573 #else
3574 key_name = table->s->key_info[roop_count].name;
3575 key_name_length = strlen(key_name);
3576 #endif
3577 }
3578 DBUG_PRINT("info",("spider key_name=%s", key_name));
3579 if (
3580 max_length < key_name_length &&
3581 conn->error_length - 1 >= key_name_length &&
3582 *(conn->error_str + conn->error_length - 2 -
3583 key_name_length) == '\'' &&
3584 !strncasecmp(conn->error_str +
3585 conn->error_length - 1 - key_name_length,
3586 key_name, key_name_length)
3587 ) {
3588 max_length = key_name_length;
3589 spider->dup_key_idx = roop_count;
3590 }
3591 }
3592 if (max_length == 0)
3593 spider->dup_key_idx = (uint) -1;
3594 DBUG_PRINT("info",("spider dup_key_idx=%d", spider->dup_key_idx));
3595 DBUG_VOID_RETURN;
3596 }
3597
cmp_request_key_to_snd(st_spider_db_request_key * request_key)3598 bool spider_db_mbase::cmp_request_key_to_snd(
3599 st_spider_db_request_key *request_key
3600 ) {
3601 DBUG_ENTER("spider_db_mbase::cmp_request_key_to_snd");
3602 DBUG_PRINT("info",("spider this=%p", this));
3603 DBUG_RETURN(TRUE);
3604 }
3605
spider_db_mbase_util()3606 spider_db_mbase_util::spider_db_mbase_util() : spider_db_util()
3607 {
3608 DBUG_ENTER("spider_db_mbase_util::spider_db_mbase_util");
3609 DBUG_PRINT("info",("spider this=%p", this));
3610 DBUG_VOID_RETURN;
3611 }
3612
spider_db_mysql_util()3613 spider_db_mysql_util::spider_db_mysql_util() : spider_db_mbase_util()
3614 {
3615 DBUG_ENTER("spider_db_mysql_util::spider_db_mysql_util");
3616 DBUG_PRINT("info",("spider this=%p", this));
3617 DBUG_VOID_RETURN;
3618 }
3619
spider_db_mariadb_util()3620 spider_db_mariadb_util::spider_db_mariadb_util() : spider_db_mbase_util()
3621 {
3622 DBUG_ENTER("spider_db_mariadb_util::spider_db_mariadb_util");
3623 DBUG_PRINT("info",("spider this=%p", this));
3624 DBUG_VOID_RETURN;
3625 }
3626
~spider_db_mbase_util()3627 spider_db_mbase_util::~spider_db_mbase_util()
3628 {
3629 DBUG_ENTER("spider_db_mbase_util::~spider_db_mbase_util");
3630 DBUG_PRINT("info",("spider this=%p", this));
3631 DBUG_VOID_RETURN;
3632 }
3633
~spider_db_mysql_util()3634 spider_db_mysql_util::~spider_db_mysql_util()
3635 {
3636 DBUG_ENTER("spider_db_mysql_util::~spider_db_mysql_util");
3637 DBUG_PRINT("info",("spider this=%p", this));
3638 DBUG_VOID_RETURN;
3639 }
3640
~spider_db_mariadb_util()3641 spider_db_mariadb_util::~spider_db_mariadb_util()
3642 {
3643 DBUG_ENTER("spider_db_mariadb_util::~spider_db_mariadb_util");
3644 DBUG_PRINT("info",("spider this=%p", this));
3645 DBUG_VOID_RETURN;
3646 }
3647
append_name(spider_string * str,const char * name,uint name_length)3648 int spider_db_mbase_util::append_name(
3649 spider_string *str,
3650 const char *name,
3651 uint name_length
3652 ) {
3653 DBUG_ENTER("spider_db_mbase_util::append_name");
3654 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3655 str->q_append(name, name_length);
3656 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3657 DBUG_RETURN(0);
3658 }
3659
append_name_with_charset(spider_string * str,const char * name,uint name_length,CHARSET_INFO * name_charset)3660 int spider_db_mbase_util::append_name_with_charset(
3661 spider_string *str,
3662 const char *name,
3663 uint name_length,
3664 CHARSET_INFO *name_charset
3665 ) {
3666 DBUG_ENTER("spider_db_mbase_util::append_name_with_charset");
3667 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2 + name_length * 2))
3668 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3669 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3670 str->append(name, name_length, name_charset);
3671 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
3672 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3673 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3674 DBUG_RETURN(0);
3675 }
3676
is_name_quote(const char head_code)3677 bool spider_db_mbase_util::is_name_quote(
3678 const char head_code
3679 ) {
3680 DBUG_ENTER("spider_db_mbase_util::is_name_quote");
3681 DBUG_RETURN(head_code == *name_quote_str);
3682 }
3683
append_escaped_name_quote(spider_string * str)3684 int spider_db_mbase_util::append_escaped_name_quote(
3685 spider_string *str
3686 ) {
3687 DBUG_ENTER("spider_db_mbase_util::append_escaped_name_quote");
3688 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN * 2))
3689 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3690 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3691 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
3692 DBUG_RETURN(0);
3693 }
3694
append_column_value(ha_spider * spider,spider_string * str,Field * field,const uchar * new_ptr,CHARSET_INFO * access_charset)3695 int spider_db_mbase_util::append_column_value(
3696 ha_spider *spider,
3697 spider_string *str,
3698 Field *field,
3699 const uchar *new_ptr,
3700 CHARSET_INFO *access_charset
3701 ) {
3702 char buf[MAX_FIELD_WIDTH];
3703 spider_string tmp_str(buf, MAX_FIELD_WIDTH, &my_charset_bin);
3704 String *ptr;
3705 uint length;
3706 THD *thd = field->table->in_use;
3707 Time_zone *saved_time_zone = thd->variables.time_zone;
3708 DBUG_ENTER("spider_db_mbase_util::append_column_value");
3709 tmp_str.init_calc_mem(113);
3710
3711 thd->variables.time_zone = UTC;
3712
3713 if (new_ptr)
3714 {
3715 if (
3716 field->type() == MYSQL_TYPE_BLOB ||
3717 field->real_type() == MYSQL_TYPE_VARCHAR
3718 ) {
3719 length = uint2korr(new_ptr);
3720 tmp_str.set_quick((char *) new_ptr + HA_KEY_BLOB_LENGTH, length,
3721 &my_charset_bin);
3722 ptr = tmp_str.get_str();
3723 } else if (field->type() == MYSQL_TYPE_GEOMETRY)
3724 {
3725 /*
3726 uint mlength = SIZEOF_STORED_DOUBLE, lcnt;
3727 uchar *dest = (uchar *) buf;
3728 const uchar *source;
3729 for (lcnt = 0; lcnt < 4; lcnt++)
3730 {
3731 mlength = SIZEOF_STORED_DOUBLE;
3732 source = new_ptr + mlength + SIZEOF_STORED_DOUBLE * lcnt;
3733 while (mlength--)
3734 *dest++ = *--source;
3735 }
3736 tmp_str.length(SIZEOF_STORED_DOUBLE * lcnt);
3737 */
3738 #ifndef DBUG_OFF
3739 double xmin, xmax, ymin, ymax;
3740 /*
3741 float8store(buf,xmin);
3742 float8store(buf+8,xmax);
3743 float8store(buf+16,ymin);
3744 float8store(buf+24,ymax);
3745 memcpy(&xmin,new_ptr,sizeof(xmin));
3746 memcpy(&xmax,new_ptr + 8,sizeof(xmax));
3747 memcpy(&ymin,new_ptr + 16,sizeof(ymin));
3748 memcpy(&ymax,new_ptr + 24,sizeof(ymax));
3749 float8get(xmin, buf);
3750 float8get(xmax, buf + 8);
3751 float8get(ymin, buf + 16);
3752 float8get(ymax, buf + 24);
3753 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
3754 xmin, xmax, ymin, ymax));
3755 DBUG_PRINT("info", ("spider geo is %.14g %.14g %.14g %.14g",
3756 xmin, xmax, ymin, ymax));
3757 */
3758 float8get(xmin, new_ptr);
3759 float8get(xmax, new_ptr + 8);
3760 float8get(ymin, new_ptr + 16);
3761 float8get(ymax, new_ptr + 24);
3762 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
3763 xmin, xmax, ymin, ymax));
3764 /*
3765 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 4);
3766 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 5);
3767 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 6);
3768 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 7);
3769 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
3770 xmin, xmax, ymin, ymax));
3771 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 8);
3772 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 9);
3773 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 10);
3774 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 11);
3775 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
3776 xmin, xmax, ymin, ymax));
3777 float8get(xmin, new_ptr + SIZEOF_STORED_DOUBLE * 12);
3778 float8get(xmax, new_ptr + SIZEOF_STORED_DOUBLE * 13);
3779 float8get(ymin, new_ptr + SIZEOF_STORED_DOUBLE * 14);
3780 float8get(ymax, new_ptr + SIZEOF_STORED_DOUBLE * 15);
3781 DBUG_PRINT("info", ("spider geo is %f %f %f %f",
3782 xmin, xmax, ymin, ymax));
3783 */
3784 #endif
3785 /*
3786 tmp_str.set_quick((char *) new_ptr, SIZEOF_STORED_DOUBLE * 4,
3787 &my_charset_bin);
3788 */
3789 tmp_str.length(0);
3790 tmp_str.q_append((char *) SPIDER_SQL_LINESTRING_HEAD_STR,
3791 SPIDER_SQL_LINESTRING_HEAD_LEN);
3792 tmp_str.q_append((char *) new_ptr, SIZEOF_STORED_DOUBLE);
3793 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 2,
3794 SIZEOF_STORED_DOUBLE);
3795 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE,
3796 SIZEOF_STORED_DOUBLE);
3797 tmp_str.q_append((char *) new_ptr + SIZEOF_STORED_DOUBLE * 3,
3798 SIZEOF_STORED_DOUBLE);
3799 ptr = tmp_str.get_str();
3800 } else {
3801 ptr = field->val_str(tmp_str.get_str(), new_ptr);
3802 tmp_str.mem_calc();
3803 }
3804 } else {
3805 ptr = field->val_str(tmp_str.get_str());
3806 tmp_str.mem_calc();
3807 }
3808
3809 thd->variables.time_zone = saved_time_zone;
3810
3811 DBUG_PRINT("info", ("spider field->type() is %d", field->type()));
3812 DBUG_PRINT("info", ("spider ptr->length() is %d", ptr->length()));
3813 /*
3814 if (
3815 field->type() == MYSQL_TYPE_BIT ||
3816 (field->type() >= MYSQL_TYPE_TINY_BLOB &&
3817 field->type() <= MYSQL_TYPE_BLOB)
3818 ) {
3819 uchar *hex_ptr = (uchar *) ptr->ptr(), *end_ptr;
3820 char *str_ptr;
3821 DBUG_PRINT("info", ("spider HEX"));
3822 if (str->reserve(SPIDER_SQL_HEX_LEN + ptr->length() * 2))
3823 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3824 str->q_append(SPIDER_SQL_HEX_STR, SPIDER_SQL_HEX_LEN);
3825 str_ptr = (char *) str->ptr() + str->length();
3826 for (end_ptr = hex_ptr + ptr->length(); hex_ptr < end_ptr; hex_ptr++)
3827 {
3828 *str_ptr++ = spider_dig_upper[(*hex_ptr) >> 4];
3829 *str_ptr++ = spider_dig_upper[(*hex_ptr) & 0x0F];
3830 }
3831 str->length(str->length() + ptr->length() * 2);
3832 } else
3833 */
3834 if (field->result_type() == STRING_RESULT)
3835 {
3836 DBUG_PRINT("info", ("spider STRING_RESULT"));
3837 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN))
3838 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3839 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3840 if (
3841 field->type() == MYSQL_TYPE_VARCHAR ||
3842 (field->type() >= MYSQL_TYPE_ENUM &&
3843 field->type() <= MYSQL_TYPE_GEOMETRY)
3844 ) {
3845 DBUG_PRINT("info", ("spider append_escaped"));
3846 char buf2[MAX_FIELD_WIDTH];
3847 spider_string tmp_str2(buf2, MAX_FIELD_WIDTH, access_charset);
3848 tmp_str2.init_calc_mem(114);
3849 tmp_str2.length(0);
3850 if (
3851 tmp_str2.append(ptr->ptr(), ptr->length(), field->charset()) ||
3852 str->reserve(tmp_str2.length() * 2) ||
3853 append_escaped_util(str, tmp_str2.get_str())
3854 )
3855 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3856 } else if (str->append(*ptr))
3857 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3858 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN))
3859 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3860 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3861 } else if (field->str_needs_quotes())
3862 {
3863 if (str->reserve(SPIDER_SQL_VALUE_QUOTE_LEN * 2 + ptr->length() * 2 + 2))
3864 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3865 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3866 append_escaped_util(str, ptr);
3867 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
3868 } else if (str->append(*ptr))
3869 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3870 DBUG_RETURN(0);
3871 }
3872
append_from_with_alias(spider_string * str,const char ** table_names,uint * table_name_lengths,const char ** table_aliases,uint * table_alias_lengths,uint table_count,int * table_name_pos,bool over_write)3873 int spider_db_mbase_util::append_from_with_alias(
3874 spider_string *str,
3875 const char **table_names,
3876 uint *table_name_lengths,
3877 const char **table_aliases,
3878 uint *table_alias_lengths,
3879 uint table_count,
3880 int *table_name_pos,
3881 bool over_write
3882 ) {
3883 uint roop_count, length = 0;
3884 DBUG_ENTER("spider_db_mbase_util::append_from_with_alias");
3885 DBUG_PRINT("info",("spider this=%p", this));
3886 if (!over_write)
3887 {
3888 for (roop_count = 0; roop_count < table_count; roop_count++)
3889 length += table_name_lengths[roop_count] + SPIDER_SQL_SPACE_LEN +
3890 table_alias_lengths[roop_count] + SPIDER_SQL_COMMA_LEN;
3891 if (str->reserve(SPIDER_SQL_FROM_LEN + length))
3892 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3893 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
3894 *table_name_pos = str->length();
3895 }
3896 for (roop_count = 0; roop_count < table_count; roop_count++)
3897 {
3898 str->q_append(table_names[roop_count], table_name_lengths[roop_count]);
3899 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
3900 str->q_append(table_aliases[roop_count], table_alias_lengths[roop_count]);
3901 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
3902 }
3903 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
3904 DBUG_RETURN(0);
3905 }
3906
append_trx_isolation(spider_string * str,int trx_isolation)3907 int spider_db_mbase_util::append_trx_isolation(
3908 spider_string *str,
3909 int trx_isolation
3910 ) {
3911 DBUG_ENTER("spider_db_mbase_util::append_trx_isolation");
3912 DBUG_PRINT("info",("spider this=%p", this));
3913 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN +
3914 SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN))
3915 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3916 if (str->length())
3917 {
3918 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
3919 }
3920 switch (trx_isolation)
3921 {
3922 case ISO_READ_UNCOMMITTED:
3923 str->q_append(SPIDER_SQL_ISO_READ_UNCOMMITTED_STR,
3924 SPIDER_SQL_ISO_READ_UNCOMMITTED_LEN);
3925 break;
3926 case ISO_READ_COMMITTED:
3927 str->q_append(SPIDER_SQL_ISO_READ_COMMITTED_STR,
3928 SPIDER_SQL_ISO_READ_COMMITTED_LEN);
3929 break;
3930 case ISO_REPEATABLE_READ:
3931 str->q_append(SPIDER_SQL_ISO_REPEATABLE_READ_STR,
3932 SPIDER_SQL_ISO_REPEATABLE_READ_LEN);
3933 break;
3934 case ISO_SERIALIZABLE:
3935 str->q_append(SPIDER_SQL_ISO_SERIALIZABLE_STR,
3936 SPIDER_SQL_ISO_SERIALIZABLE_LEN);
3937 break;
3938 default:
3939 DBUG_RETURN(HA_ERR_UNSUPPORTED);
3940 }
3941 DBUG_RETURN(0);
3942 }
3943
append_autocommit(spider_string * str,bool autocommit)3944 int spider_db_mbase_util::append_autocommit(
3945 spider_string *str,
3946 bool autocommit
3947 ) {
3948 DBUG_ENTER("spider_db_mbase_util::append_autocommit");
3949 DBUG_PRINT("info",("spider this=%p", this));
3950 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + SPIDER_SQL_AUTOCOMMIT_OFF_LEN))
3951 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3952 if (str->length())
3953 {
3954 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
3955 }
3956 if (autocommit)
3957 {
3958 str->q_append(SPIDER_SQL_AUTOCOMMIT_ON_STR,
3959 SPIDER_SQL_AUTOCOMMIT_ON_LEN);
3960 } else {
3961 str->q_append(SPIDER_SQL_AUTOCOMMIT_OFF_STR,
3962 SPIDER_SQL_AUTOCOMMIT_OFF_LEN);
3963 }
3964 DBUG_RETURN(0);
3965 }
3966
append_sql_log_off(spider_string * str,bool sql_log_off)3967 int spider_db_mbase_util::append_sql_log_off(
3968 spider_string *str,
3969 bool sql_log_off
3970 ) {
3971 DBUG_ENTER("spider_db_mbase_util::append_sql_log_off");
3972 DBUG_PRINT("info",("spider this=%p", this));
3973 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + SPIDER_SQL_SQL_LOG_OFF_LEN))
3974 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3975 if (str->length())
3976 {
3977 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
3978 }
3979 if (sql_log_off)
3980 {
3981 str->q_append(SPIDER_SQL_SQL_LOG_ON_STR, SPIDER_SQL_SQL_LOG_ON_LEN);
3982 } else {
3983 str->q_append(SPIDER_SQL_SQL_LOG_OFF_STR, SPIDER_SQL_SQL_LOG_OFF_LEN);
3984 }
3985 DBUG_RETURN(0);
3986 }
3987
append_time_zone(spider_string * str,Time_zone * time_zone)3988 int spider_db_mbase_util::append_time_zone(
3989 spider_string *str,
3990 Time_zone *time_zone
3991 ) {
3992 const String *tz_str = time_zone->get_name();
3993 DBUG_ENTER("spider_db_mbase_util::append_time_zone");
3994 DBUG_PRINT("info",("spider this=%p", this));
3995 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN + SPIDER_SQL_TIME_ZONE_LEN +
3996 tz_str->length() + SPIDER_SQL_VALUE_QUOTE_LEN))
3997 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
3998 if (str->length())
3999 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
4000 str->q_append(SPIDER_SQL_TIME_ZONE_STR, SPIDER_SQL_TIME_ZONE_LEN);
4001 str->q_append(tz_str->ptr(), tz_str->length());
4002 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
4003 DBUG_RETURN(0);
4004 }
4005
append_start_transaction(spider_string * str)4006 int spider_db_mbase_util::append_start_transaction(
4007 spider_string *str
4008 ) {
4009 DBUG_ENTER("spider_db_mbase_util::append_start_transaction");
4010 DBUG_PRINT("info",("spider this=%p", this));
4011 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN +
4012 SPIDER_SQL_START_TRANSACTION_LEN))
4013 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4014 if (str->length())
4015 {
4016 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
4017 }
4018 str->q_append(SPIDER_SQL_START_TRANSACTION_STR,
4019 SPIDER_SQL_START_TRANSACTION_LEN);
4020 DBUG_RETURN(0);
4021 }
4022
append_xa_start(spider_string * str,XID * xid)4023 int spider_db_mbase_util::append_xa_start(
4024 spider_string *str,
4025 XID *xid
4026 ) {
4027 DBUG_ENTER("spider_db_mbase_util::append_xa_start");
4028 DBUG_PRINT("info",("spider this=%p", this));
4029 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN +
4030 SPIDER_SQL_XA_START_LEN + XIDDATASIZE + sizeof(long) + 9))
4031 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4032 if (str->length())
4033 {
4034 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
4035 }
4036 str->q_append(SPIDER_SQL_XA_START_STR, SPIDER_SQL_XA_START_LEN);
4037 spider_db_append_xid_str(str, xid);
4038 DBUG_RETURN(0);
4039 }
4040
append_lock_table_head(spider_string * str)4041 int spider_db_mbase_util::append_lock_table_head(
4042 spider_string *str
4043 ) {
4044 DBUG_ENTER("spider_db_mbase_util::append_lock_table_head");
4045 DBUG_PRINT("info",("spider this=%p", this));
4046 if (str->reserve(SPIDER_SQL_LOCK_TABLE_LEN))
4047 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4048 str->q_append(SPIDER_SQL_LOCK_TABLE_STR, SPIDER_SQL_LOCK_TABLE_LEN);
4049 DBUG_RETURN(0);
4050 }
4051
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)4052 int spider_db_mbase_util::append_lock_table_body(
4053 spider_string *str,
4054 const char *db_name,
4055 uint db_name_length,
4056 CHARSET_INFO *db_name_charset,
4057 const char *table_name,
4058 uint table_name_length,
4059 CHARSET_INFO *table_name_charset,
4060 int lock_type
4061 ) {
4062 DBUG_ENTER("spider_db_mbase_util::append_lock_table_body");
4063 DBUG_PRINT("info",("spider this=%p", this));
4064 if (str->reserve(SPIDER_SQL_NAME_QUOTE_LEN))
4065 {
4066 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4067 }
4068 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
4069 if (
4070 str->append(db_name, db_name_length, db_name_charset) ||
4071 str->reserve((SPIDER_SQL_NAME_QUOTE_LEN) * 2 + SPIDER_SQL_DOT_LEN)
4072 ) {
4073 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4074 }
4075 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
4076 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
4077 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
4078 if (
4079 str->append(table_name, table_name_length, table_name_charset) ||
4080 str->reserve(SPIDER_SQL_NAME_QUOTE_LEN +
4081 spider_db_table_lock_len[lock_type])
4082 ) {
4083 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4084 }
4085 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
4086 str->q_append(spider_db_table_lock_str[lock_type],
4087 spider_db_table_lock_len[lock_type]);
4088 DBUG_RETURN(0);
4089 }
4090
append_lock_table_tail(spider_string * str)4091 int spider_db_mbase_util::append_lock_table_tail(
4092 spider_string *str
4093 ) {
4094 DBUG_ENTER("spider_db_mbase_util::append_lock_table_tail");
4095 DBUG_PRINT("info",("spider this=%p", this));
4096 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
4097 DBUG_RETURN(0);
4098 }
4099
append_unlock_table(spider_string * str)4100 int spider_db_mbase_util::append_unlock_table(
4101 spider_string *str
4102 ) {
4103 DBUG_ENTER("spider_db_mbase_util::append_unlock_table");
4104 DBUG_PRINT("info",("spider this=%p", this));
4105 if (str->reserve(SPIDER_SQL_UNLOCK_TABLE_LEN))
4106 {
4107 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4108 }
4109 str->q_append(SPIDER_SQL_UNLOCK_TABLE_STR, SPIDER_SQL_UNLOCK_TABLE_LEN);
4110 DBUG_RETURN(0);
4111 }
4112
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)4113 int spider_db_mbase_util::open_item_func(
4114 Item_func *item_func,
4115 ha_spider *spider,
4116 spider_string *str,
4117 const char *alias,
4118 uint alias_length,
4119 bool use_fields,
4120 spider_fields *fields
4121 ) {
4122 int error_num;
4123 Item *item, **item_list = item_func->arguments();
4124 Field *field;
4125 uint roop_count, item_count = item_func->argument_count(), start_item = 0;
4126 const char *func_name = SPIDER_SQL_NULL_CHAR_STR,
4127 *separator_str = SPIDER_SQL_NULL_CHAR_STR,
4128 *last_str = SPIDER_SQL_NULL_CHAR_STR;
4129 int func_name_length = SPIDER_SQL_NULL_CHAR_LEN,
4130 separator_str_length = SPIDER_SQL_NULL_CHAR_LEN,
4131 last_str_length = SPIDER_SQL_NULL_CHAR_LEN;
4132 int use_pushdown_udf;
4133 bool merge_func = FALSE;
4134 DBUG_ENTER("spider_db_mbase_util::open_item_func");
4135 if (str)
4136 {
4137 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
4138 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4139 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
4140 }
4141 DBUG_PRINT("info",("spider functype = %d", item_func->functype()));
4142 switch (item_func->functype())
4143 {
4144 case Item_func::ISNULL_FUNC:
4145 last_str = SPIDER_SQL_IS_NULL_STR;
4146 last_str_length = SPIDER_SQL_IS_NULL_LEN;
4147 break;
4148 case Item_func::ISNOTNULL_FUNC:
4149 last_str = SPIDER_SQL_IS_NOT_NULL_STR;
4150 last_str_length = SPIDER_SQL_IS_NOT_NULL_LEN;
4151 break;
4152 case Item_func::UNKNOWN_FUNC:
4153 func_name = (char*) item_func->func_name();
4154 func_name_length = strlen(func_name);
4155 DBUG_PRINT("info",("spider func_name = %s", func_name));
4156 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
4157 if (func_name_length == 1 &&
4158 (
4159 !strncasecmp("+", func_name, func_name_length) ||
4160 !strncasecmp("-", func_name, func_name_length) ||
4161 !strncasecmp("*", func_name, func_name_length) ||
4162 !strncasecmp("/", func_name, func_name_length) ||
4163 !strncasecmp("%", func_name, func_name_length) ||
4164 !strncasecmp("&", func_name, func_name_length) ||
4165 !strncasecmp("|", func_name, func_name_length) ||
4166 !strncasecmp("^", func_name, func_name_length)
4167 )
4168 ) {
4169 /* no action */
4170 break;
4171 } else if (func_name_length == 2 &&
4172 (
4173 !strncasecmp("<<", func_name, func_name_length) ||
4174 !strncasecmp(">>", func_name, func_name_length)
4175 )
4176 ) {
4177 /* no action */
4178 break;
4179 } else if (func_name_length == 3 &&
4180 !strncasecmp("div", func_name, func_name_length)
4181 ) {
4182 /* no action */
4183 break;
4184 } else if (func_name_length == 4)
4185 {
4186 if (
4187 !strncasecmp("rand", func_name, func_name_length) &&
4188 #ifdef SPIDER_Item_args_arg_count_IS_PROTECTED
4189 !item_func->argument_count()
4190 #else
4191 !item_func->arg_count
4192 #endif
4193 ) {
4194 if (str)
4195 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4196 DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
4197 alias, alias_length, dbton_id, use_fields, fields));
4198 } else if (
4199 !strncasecmp("trim", func_name, func_name_length) &&
4200 item_count == 2
4201 ) {
4202 /* item_count == 1 means this TRIM() is without a remove_str */
4203 item = item_list[0];
4204 Item *item_tmp = item_list[1];
4205 if (str)
4206 {
4207 if (item_tmp->type() == Item::STRING_ITEM)
4208 {
4209 /* 1. append 'TRIM(BOTH ' */
4210 if (str->reserve(SPIDER_SQL_TRIM_LEN + SPIDER_SQL_OPEN_PAREN_LEN +
4211 SPIDER_SQL_TRIM_BOTH_LEN))
4212 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4213 str->q_append(SPIDER_SQL_TRIM_STR, SPIDER_SQL_TRIM_LEN);
4214 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
4215 SPIDER_SQL_OPEN_PAREN_LEN);
4216 str->q_append(SPIDER_SQL_TRIM_BOTH_STR, SPIDER_SQL_TRIM_BOTH_LEN);
4217 /* 2. append "remove_str"*/
4218 if ((error_num = spider_db_print_item_type(
4219 item_tmp, NULL, spider, str, alias, alias_length, dbton_id,
4220 use_fields, fields)))
4221 DBUG_RETURN(error_num);
4222 /* 3. append ' FROM ' */
4223 if (str->reserve(SPIDER_SQL_FROM_LEN))
4224 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4225 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
4226 /* 4. append `field` */
4227 if ((error_num = spider_db_print_item_type(
4228 item, NULL, spider, str, alias, alias_length, dbton_id,
4229 use_fields, fields)))
4230 DBUG_RETURN(error_num);
4231 /* 5. append ')' */
4232 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
4233 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4234 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
4235 SPIDER_SQL_CLOSE_PAREN_LEN);
4236 }
4237 }
4238 item_count -= 2;
4239 break;
4240 }
4241 } else if (func_name_length == 5)
4242 {
4243 if (
4244 (!strncasecmp("ltrim", func_name, func_name_length) ||
4245 !strncasecmp("rtrim", func_name, func_name_length)) &&
4246 (item_count == 2)
4247 ) {
4248 /* the func_name for TRIM(LEADING ...) is LTRIM, for TRIM(TRAILING) is RTRIM */
4249 /* item_count == 2 means this TRIM(LEADING/TRAILING ...) is with a remove_str */
4250 item = item_list[0];
4251 Item *item_tmp = item_list[1];
4252 if (str)
4253 {
4254 if (item_tmp->type() == Item::STRING_ITEM)
4255 {
4256 /* 1. append 'TRIM(LEADING ' or 'TRIM(TRAILING ' */
4257 if (func_name[0] == 'l' || func_name[0] == 'L')
4258 { /* ltrim */
4259 if (str->reserve(SPIDER_SQL_TRIM_LEN + SPIDER_SQL_OPEN_PAREN_LEN +
4260 SPIDER_SQL_TRIM_LEADING_LEN))
4261 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4262 str->q_append(SPIDER_SQL_TRIM_STR, SPIDER_SQL_TRIM_LEN);
4263 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
4264 SPIDER_SQL_OPEN_PAREN_LEN);
4265 str->q_append(SPIDER_SQL_TRIM_LEADING_STR, SPIDER_SQL_TRIM_LEADING_LEN);
4266 } else
4267 { /* rtrim */
4268 if (str->reserve(SPIDER_SQL_TRIM_LEN + SPIDER_SQL_OPEN_PAREN_LEN +
4269 SPIDER_SQL_TRIM_TRAILING_LEN))
4270 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4271 str->q_append(SPIDER_SQL_TRIM_STR, SPIDER_SQL_TRIM_LEN);
4272 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
4273 SPIDER_SQL_OPEN_PAREN_LEN);
4274 str->q_append(SPIDER_SQL_TRIM_TRAILING_STR, SPIDER_SQL_TRIM_TRAILING_LEN);
4275 }
4276 /* 2. append "remove_str"*/
4277 if ((error_num = spider_db_print_item_type(
4278 item_tmp, NULL, spider, str, alias, alias_length, dbton_id,
4279 use_fields, fields)))
4280 DBUG_RETURN(error_num);
4281 /* 3. append ' FROM ' */
4282 if (str->reserve(SPIDER_SQL_FROM_LEN))
4283 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4284 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
4285 /* 4. append `field` */
4286 if ((error_num = spider_db_print_item_type(
4287 item, NULL, spider, str, alias, alias_length, dbton_id,
4288 use_fields, fields)))
4289 DBUG_RETURN(error_num);
4290 /* 5. append ')' */
4291 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
4292 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4293 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
4294 SPIDER_SQL_CLOSE_PAREN_LEN);
4295 }
4296 }
4297 item_count -= 2;
4298 break;
4299 }
4300 } else if (func_name_length == 6 &&
4301 !strncasecmp("istrue", func_name, func_name_length)
4302 ) {
4303 last_str = SPIDER_SQL_IS_TRUE_STR;
4304 last_str_length = SPIDER_SQL_IS_TRUE_LEN;
4305 break;
4306 } else if (func_name_length == 7)
4307 {
4308 if (!strncasecmp("isfalse", func_name, func_name_length))
4309 {
4310 last_str = SPIDER_SQL_IS_FALSE_STR;
4311 last_str_length = SPIDER_SQL_IS_FALSE_LEN;
4312 break;
4313 } else if (
4314 !strncasecmp("sysdate", func_name, func_name_length) ||
4315 !strncasecmp("curdate", func_name, func_name_length) ||
4316 !strncasecmp("curtime", func_name, func_name_length)
4317 ) {
4318 if (str)
4319 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4320 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
4321 alias, alias_length, dbton_id, use_fields, fields));
4322 } else if (
4323 !strncasecmp("convert", func_name, func_name_length)
4324 ) {
4325 if (str)
4326 {
4327 if (str->reserve(func_name_length * 2 + SPIDER_SQL_OPEN_PAREN_LEN))
4328 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4329 str->q_append(func_name, func_name_length);
4330 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
4331 SPIDER_SQL_OPEN_PAREN_LEN);
4332 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
4333 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
4334 }
4335 break;
4336 }
4337 } else if (func_name_length == 8 &&
4338 (
4339 !strncasecmp("utc_date", func_name, func_name_length) ||
4340 !strncasecmp("utc_time", func_name, func_name_length)
4341 )
4342 ) {
4343 if (str)
4344 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4345 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
4346 alias, alias_length, dbton_id, use_fields, fields));
4347 } else if (func_name_length == 9 &&
4348 !strncasecmp("isnottrue", func_name, func_name_length)
4349 ) {
4350 last_str = SPIDER_SQL_IS_NOT_TRUE_STR;
4351 last_str_length = SPIDER_SQL_IS_NOT_TRUE_LEN;
4352 break;
4353 } else if (func_name_length == 10)
4354 {
4355 if (!strncasecmp("isnotfalse", func_name, func_name_length))
4356 {
4357 last_str = SPIDER_SQL_IS_NOT_FALSE_STR;
4358 last_str_length = SPIDER_SQL_IS_NOT_FALSE_LEN;
4359 break;
4360 } else if (!strncasecmp("column_get", func_name, func_name_length))
4361 {
4362 if (str)
4363 {
4364 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4365 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
4366 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4367 str->q_append(func_name, func_name_length);
4368 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
4369 }
4370 func_name = SPIDER_SQL_COMMA_STR;
4371 func_name_length = SPIDER_SQL_COMMA_LEN;
4372 separator_str = SPIDER_SQL_COMMA_STR;
4373 separator_str_length = SPIDER_SQL_COMMA_LEN;
4374 break;
4375 }
4376 } else if (func_name_length == 12)
4377 {
4378 if (!strncasecmp("cast_as_date", func_name, func_name_length))
4379 {
4380 item = item_list[0];
4381 if (item->type() == Item::FUNC_ITEM)
4382 {
4383 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4384 Item_func *ifunc = (Item_func *) item;
4385 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4386 {
4387 const char *child_func_name;
4388 int child_func_name_length;
4389 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4390 child_func_name = (char*) ifunc->func_name();
4391 child_func_name_length = strlen(child_func_name);
4392 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4393 if (
4394 child_func_name_length == 10 &&
4395 !strncasecmp("column_get", child_func_name, child_func_name_length)
4396 ) {
4397 DBUG_PRINT("info",("spider this is merge func"));
4398 merge_func = TRUE;
4399 }
4400 }
4401 }
4402
4403 if (str)
4404 {
4405 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4406 if (!merge_func)
4407 {
4408 if (str->reserve(SPIDER_SQL_CAST_LEN))
4409 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4410 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4411 }
4412 }
4413 last_str = SPIDER_SQL_AS_DATE_STR;
4414 last_str_length = SPIDER_SQL_AS_DATE_LEN;
4415 break;
4416 } else if (!strncasecmp("cast_as_time", func_name, func_name_length))
4417 {
4418 item = item_list[0];
4419 if (item->type() == Item::FUNC_ITEM)
4420 {
4421 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4422 Item_func *ifunc = (Item_func *) item;
4423 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4424 {
4425 const char *child_func_name;
4426 int child_func_name_length;
4427 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4428 child_func_name = (char*) ifunc->func_name();
4429 child_func_name_length = strlen(child_func_name);
4430 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4431 if (
4432 child_func_name_length == 10 &&
4433 !strncasecmp("column_get", child_func_name, child_func_name_length)
4434 ) {
4435 DBUG_PRINT("info",("spider this is merge func"));
4436 merge_func = TRUE;
4437 }
4438 }
4439 }
4440
4441 if (str)
4442 {
4443 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4444 if (!merge_func)
4445 {
4446 if (str->reserve(SPIDER_SQL_CAST_LEN))
4447 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4448 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4449 }
4450 }
4451 last_str = SPIDER_SQL_AS_TIME_STR;
4452 last_str_length = SPIDER_SQL_AS_TIME_LEN;
4453 break;
4454 }
4455 } else if (func_name_length == 13)
4456 {
4457 if (!strncasecmp("utc_timestamp", func_name, func_name_length))
4458 {
4459 if (str)
4460 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4461 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
4462 alias, alias_length, dbton_id, use_fields, fields));
4463 } else if (!strncasecmp("timestampdiff", func_name, func_name_length))
4464 {
4465 #ifdef ITEM_FUNC_TIMESTAMPDIFF_ARE_PUBLIC
4466 Item_func_timestamp_diff *item_func_timestamp_diff =
4467 (Item_func_timestamp_diff *) item_func;
4468 if (str)
4469 {
4470 const char *interval_str;
4471 uint interval_len;
4472 switch (item_func_timestamp_diff->int_type)
4473 {
4474 case INTERVAL_YEAR:
4475 interval_str = SPIDER_SQL_YEAR_STR;
4476 interval_len = SPIDER_SQL_YEAR_LEN;
4477 break;
4478 case INTERVAL_QUARTER:
4479 interval_str = SPIDER_SQL_QUARTER_STR;
4480 interval_len = SPIDER_SQL_QUARTER_LEN;
4481 break;
4482 case INTERVAL_MONTH:
4483 interval_str = SPIDER_SQL_MONTH_STR;
4484 interval_len = SPIDER_SQL_MONTH_LEN;
4485 break;
4486 case INTERVAL_WEEK:
4487 interval_str = SPIDER_SQL_WEEK_STR;
4488 interval_len = SPIDER_SQL_WEEK_LEN;
4489 break;
4490 case INTERVAL_DAY:
4491 interval_str = SPIDER_SQL_DAY_STR;
4492 interval_len = SPIDER_SQL_DAY_LEN;
4493 break;
4494 case INTERVAL_HOUR:
4495 interval_str = SPIDER_SQL_HOUR_STR;
4496 interval_len = SPIDER_SQL_HOUR_LEN;
4497 break;
4498 case INTERVAL_MINUTE:
4499 interval_str = SPIDER_SQL_MINUTE_STR;
4500 interval_len = SPIDER_SQL_MINUTE_LEN;
4501 break;
4502 case INTERVAL_SECOND:
4503 interval_str = SPIDER_SQL_SECOND_STR;
4504 interval_len = SPIDER_SQL_SECOND_LEN;
4505 break;
4506 case INTERVAL_MICROSECOND:
4507 interval_str = SPIDER_SQL_MICROSECOND_STR;
4508 interval_len = SPIDER_SQL_MICROSECOND_LEN;
4509 break;
4510 default:
4511 interval_str = "";
4512 interval_len = 0;
4513 break;
4514 }
4515 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4516 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN +
4517 interval_len + SPIDER_SQL_COMMA_LEN))
4518 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4519 str->q_append(func_name, func_name_length);
4520 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
4521 str->q_append(interval_str, interval_len);
4522 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
4523 }
4524 if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
4525 str, alias, alias_length, dbton_id, use_fields, fields)))
4526 DBUG_RETURN(error_num);
4527 if (str)
4528 {
4529 if (str->reserve(SPIDER_SQL_COMMA_LEN))
4530 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4531 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
4532 }
4533 if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
4534 str, alias, alias_length, dbton_id, use_fields, fields)))
4535 DBUG_RETURN(error_num);
4536 if (str)
4537 {
4538 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
4539 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4540 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
4541 SPIDER_SQL_CLOSE_PAREN_LEN);
4542 }
4543 DBUG_RETURN(0);
4544 #else
4545 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
4546 #endif
4547 }
4548 } else if (func_name_length == 14)
4549 {
4550 if (!strncasecmp("cast_as_binary", func_name, func_name_length))
4551 {
4552 item = item_list[0];
4553 if (item->type() == Item::FUNC_ITEM)
4554 {
4555 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4556 Item_func *ifunc = (Item_func *) item;
4557 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4558 {
4559 const char *child_func_name;
4560 int child_func_name_length;
4561 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4562 child_func_name = (char*) ifunc->func_name();
4563 child_func_name_length = strlen(child_func_name);
4564 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4565 if (
4566 child_func_name_length == 10 &&
4567 !strncasecmp("column_get", child_func_name, child_func_name_length)
4568 ) {
4569 DBUG_PRINT("info",("spider this is merge func"));
4570 merge_func = TRUE;
4571 }
4572 }
4573 }
4574
4575 if (str)
4576 {
4577 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
4578 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
4579 tmp_str.init_calc_mem(123);
4580 tmp_str.length(0);
4581 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4582 if (!merge_func)
4583 {
4584 if (str->reserve(SPIDER_SQL_CAST_LEN))
4585 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4586 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4587 }
4588 #if MYSQL_VERSION_ID < 50500
4589 item_func->print(tmp_str.get_str(), QT_IS);
4590 #else
4591 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
4592 #endif
4593 tmp_str.mem_calc();
4594 if (tmp_str.reserve(1))
4595 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4596 tmp_ptr = tmp_str.c_ptr_quick();
4597 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
4598 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_BINARY_STR)))
4599 tmp_ptr = tmp_ptr2 + 1;
4600 last_str = tmp_ptr - 1;
4601 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
4602 }
4603 break;
4604 } else if (!strncasecmp("cast_as_signed", func_name, func_name_length))
4605 {
4606 item = item_list[0];
4607 if (item->type() == Item::FUNC_ITEM)
4608 {
4609 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4610 Item_func *ifunc = (Item_func *) item;
4611 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4612 {
4613 const char *child_func_name;
4614 int child_func_name_length;
4615 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4616 child_func_name = (char*) ifunc->func_name();
4617 child_func_name_length = strlen(child_func_name);
4618 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4619 if (
4620 child_func_name_length == 10 &&
4621 !strncasecmp("column_get", child_func_name, child_func_name_length)
4622 ) {
4623 DBUG_PRINT("info",("spider this is merge func"));
4624 merge_func = TRUE;
4625 }
4626 }
4627 }
4628
4629 if (str)
4630 {
4631 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4632 if (!merge_func)
4633 {
4634 if (str->reserve(SPIDER_SQL_CAST_LEN))
4635 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4636 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4637 }
4638 }
4639 last_str = SPIDER_SQL_AS_SIGNED_STR;
4640 last_str_length = SPIDER_SQL_AS_SIGNED_LEN;
4641 break;
4642 }
4643 } else if (func_name_length == 16)
4644 {
4645 if (!strncasecmp("cast_as_unsigned", func_name, func_name_length))
4646 {
4647 item = item_list[0];
4648 if (item->type() == Item::FUNC_ITEM)
4649 {
4650 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4651 Item_func *ifunc = (Item_func *) item;
4652 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4653 {
4654 const char *child_func_name;
4655 int child_func_name_length;
4656 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4657 child_func_name = (char*) ifunc->func_name();
4658 child_func_name_length = strlen(child_func_name);
4659 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4660 if (
4661 child_func_name_length == 10 &&
4662 !strncasecmp("column_get", child_func_name, child_func_name_length)
4663 ) {
4664 DBUG_PRINT("info",("spider this is merge func"));
4665 merge_func = TRUE;
4666 }
4667 }
4668 }
4669
4670 if (str)
4671 {
4672 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4673 if (!merge_func)
4674 {
4675 if (str->reserve(SPIDER_SQL_CAST_LEN))
4676 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4677 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4678 }
4679 }
4680 last_str = SPIDER_SQL_AS_UNSIGNED_STR;
4681 last_str_length = SPIDER_SQL_AS_UNSIGNED_LEN;
4682 break;
4683 } else if (!strncasecmp("decimal_typecast", func_name,
4684 func_name_length))
4685 {
4686 item = item_list[0];
4687 if (item->type() == Item::FUNC_ITEM)
4688 {
4689 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4690 Item_func *ifunc = (Item_func *) item;
4691 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4692 {
4693 const char *child_func_name;
4694 int child_func_name_length;
4695 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4696 child_func_name = (char*) ifunc->func_name();
4697 child_func_name_length = strlen(child_func_name);
4698 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4699 if (
4700 child_func_name_length == 10 &&
4701 !strncasecmp("column_get", child_func_name, child_func_name_length)
4702 ) {
4703 DBUG_PRINT("info",("spider this is merge func"));
4704 merge_func = TRUE;
4705 }
4706 }
4707 }
4708
4709 if (str)
4710 {
4711 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
4712 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
4713 tmp_str.init_calc_mem(124);
4714 tmp_str.length(0);
4715 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4716 if (!merge_func)
4717 {
4718 if (str->reserve(SPIDER_SQL_CAST_LEN))
4719 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4720 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4721 }
4722 #if MYSQL_VERSION_ID < 50500
4723 item_func->print(tmp_str.get_str(), QT_IS);
4724 #else
4725 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
4726 #endif
4727 tmp_str.mem_calc();
4728 if (tmp_str.reserve(1))
4729 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4730 tmp_ptr = tmp_str.c_ptr_quick();
4731 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
4732 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_DECIMAL_STR)))
4733 tmp_ptr = tmp_ptr2 + 1;
4734 last_str = tmp_ptr - 1;
4735 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
4736 }
4737 break;
4738 } else if (!strncasecmp("cast_as_datetime", func_name,
4739 func_name_length))
4740 {
4741 item = item_list[0];
4742 if (item->type() == Item::FUNC_ITEM)
4743 {
4744 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4745 Item_func *ifunc = (Item_func *) item;
4746 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4747 {
4748 const char *child_func_name;
4749 int child_func_name_length;
4750 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4751 child_func_name = (char*) ifunc->func_name();
4752 child_func_name_length = strlen(child_func_name);
4753 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4754 if (
4755 child_func_name_length == 10 &&
4756 !strncasecmp("column_get", child_func_name, child_func_name_length)
4757 ) {
4758 DBUG_PRINT("info",("spider this is merge func"));
4759 merge_func = TRUE;
4760 }
4761 }
4762 }
4763
4764 if (str)
4765 {
4766 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4767 if (!merge_func)
4768 {
4769 if (str->reserve(SPIDER_SQL_CAST_LEN))
4770 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4771 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4772 }
4773 }
4774 last_str = SPIDER_SQL_AS_DATETIME_STR;
4775 last_str_length = SPIDER_SQL_AS_DATETIME_LEN;
4776 break;
4777 }
4778 } else if (func_name_length == 17)
4779 {
4780 if (!strncasecmp("date_add_interval", func_name, func_name_length))
4781 {
4782 Item_date_add_interval *item_date_add_interval =
4783 (Item_date_add_interval *) item_func;
4784 func_name = spider_db_timefunc_interval_str[
4785 item_date_add_interval->int_type];
4786 func_name_length = strlen(func_name);
4787 if ((error_num = spider_db_print_item_type(item_list[0], NULL, spider,
4788 str, alias, alias_length, dbton_id, use_fields, fields)))
4789 DBUG_RETURN(error_num);
4790 if (str)
4791 {
4792 if (item_date_add_interval->date_sub_interval)
4793 {
4794 if (str->reserve(SPIDER_SQL_NEGINTERVAL_LEN))
4795 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4796 str->q_append(SPIDER_SQL_NEGINTERVAL_STR,
4797 SPIDER_SQL_NEGINTERVAL_LEN);
4798 } else {
4799 if (str->reserve(SPIDER_SQL_INTERVAL_LEN))
4800 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4801 str->q_append(SPIDER_SQL_INTERVAL_STR, SPIDER_SQL_INTERVAL_LEN);
4802 }
4803 }
4804 if ((error_num = spider_db_print_item_type(item_list[1], NULL, spider,
4805 str, alias, alias_length, dbton_id, use_fields, fields)))
4806 DBUG_RETURN(error_num);
4807 if (str)
4808 {
4809 if (str->reserve(func_name_length + SPIDER_SQL_CLOSE_PAREN_LEN))
4810 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4811 str->q_append(func_name, func_name_length);
4812 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
4813 SPIDER_SQL_CLOSE_PAREN_LEN);
4814 }
4815 DBUG_RETURN(0);
4816 }
4817 }
4818 if (str)
4819 {
4820 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
4821 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4822 str->q_append(func_name, func_name_length);
4823 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
4824 }
4825 func_name = SPIDER_SQL_COMMA_STR;
4826 func_name_length = SPIDER_SQL_COMMA_LEN;
4827 separator_str = SPIDER_SQL_COMMA_STR;
4828 separator_str_length = SPIDER_SQL_COMMA_LEN;
4829 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
4830 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
4831 break;
4832 case Item_func::NOW_FUNC:
4833 if (str)
4834 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4835 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider,
4836 str, alias, alias_length, dbton_id, use_fields, fields));
4837 case Item_func::CHAR_TYPECAST_FUNC:
4838 DBUG_PRINT("info",("spider CHAR_TYPECAST_FUNC"));
4839 {
4840 item = item_list[0];
4841 if (item->type() == Item::FUNC_ITEM)
4842 {
4843 DBUG_PRINT("info",("spider child is FUNC_ITEM"));
4844 Item_func *ifunc = (Item_func *) item;
4845 if (ifunc->functype() == Item_func::UNKNOWN_FUNC)
4846 {
4847 const char *child_func_name;
4848 int child_func_name_length;
4849 DBUG_PRINT("info",("spider child is UNKNOWN_FUNC"));
4850 child_func_name = (char*) ifunc->func_name();
4851 child_func_name_length = strlen(child_func_name);
4852 DBUG_PRINT("info",("spider child func_name is %s", child_func_name));
4853 if (
4854 child_func_name_length == 10 &&
4855 !strncasecmp("column_get", child_func_name, child_func_name_length)
4856 ) {
4857 DBUG_PRINT("info",("spider this is merge func"));
4858 merge_func = TRUE;
4859 }
4860 }
4861 }
4862
4863 if (str)
4864 {
4865 char tmp_buf[MAX_FIELD_WIDTH], *tmp_ptr, *tmp_ptr2;
4866 spider_string tmp_str(tmp_buf, MAX_FIELD_WIDTH, str->charset());
4867 tmp_str.init_calc_mem(125);
4868 tmp_str.length(0);
4869 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
4870 if (!merge_func)
4871 {
4872 if (str->reserve(SPIDER_SQL_CAST_LEN))
4873 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4874 str->q_append(SPIDER_SQL_CAST_STR, SPIDER_SQL_CAST_LEN);
4875 }
4876 #if MYSQL_VERSION_ID < 50500
4877 item_func->print(tmp_str.get_str(), QT_IS);
4878 #else
4879 item_func->print(tmp_str.get_str(), QT_TO_SYSTEM_CHARSET);
4880 #endif
4881 tmp_str.mem_calc();
4882 if (tmp_str.reserve(1))
4883 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4884 tmp_ptr = tmp_str.c_ptr_quick();
4885 DBUG_PRINT("info",("spider tmp_ptr = %s", tmp_ptr));
4886 while ((tmp_ptr2 = strstr(tmp_ptr, SPIDER_SQL_AS_CHAR_STR)))
4887 tmp_ptr = tmp_ptr2 + 1;
4888 last_str = tmp_ptr - 1;
4889 last_str_length = strlen(last_str) - SPIDER_SQL_CLOSE_PAREN_LEN;
4890 }
4891 }
4892 break;
4893 case Item_func::NOT_FUNC:
4894 DBUG_PRINT("info",("spider NOT_FUNC"));
4895 if (item_list[0]->type() == Item::COND_ITEM)
4896 {
4897 DBUG_PRINT("info",("spider item_list[0] is COND_ITEM"));
4898 Item_cond *item_cond = (Item_cond *) item_list[0];
4899 if (item_cond->functype() == Item_func::COND_AND_FUNC)
4900 {
4901 DBUG_PRINT("info",("spider item_cond is COND_AND_FUNC"));
4902 List_iterator_fast<Item> lif(*(item_cond->argument_list()));
4903 bool has_expr_cache_item = FALSE;
4904 bool has_isnotnull_func = FALSE;
4905 bool has_other_item = FALSE;
4906 while((item = lif++))
4907 {
4908 #ifdef SPIDER_HAS_EXPR_CACHE_ITEM
4909 if (
4910 item->type() == Item::EXPR_CACHE_ITEM
4911 ) {
4912 DBUG_PRINT("info",("spider EXPR_CACHE_ITEM"));
4913 has_expr_cache_item = TRUE;
4914 } else
4915 #endif
4916 if (
4917 item->type() == Item::FUNC_ITEM &&
4918 ((Item_func *) item)->functype() == Item_func::ISNOTNULL_FUNC
4919 ) {
4920 DBUG_PRINT("info",("spider ISNOTNULL_FUNC"));
4921 has_isnotnull_func = TRUE;
4922 } else {
4923 DBUG_PRINT("info",("spider has other item"));
4924 DBUG_PRINT("info",("spider COND type=%d", item->type()));
4925 has_other_item = TRUE;
4926 }
4927 }
4928 if (has_expr_cache_item && has_isnotnull_func && !has_other_item)
4929 {
4930 DBUG_PRINT("info",("spider NOT EXISTS skip"));
4931 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
4932 }
4933 }
4934 }
4935 if (str)
4936 {
4937 func_name = (char*) item_func->func_name();
4938 func_name_length = strlen(func_name);
4939 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
4940 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4941 str->q_append(func_name, func_name_length);
4942 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
4943 }
4944 break;
4945 case Item_func::NEG_FUNC:
4946 if (str)
4947 {
4948 func_name = (char*) item_func->func_name();
4949 func_name_length = strlen(func_name);
4950 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN))
4951 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
4952 str->q_append(func_name, func_name_length);
4953 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
4954 }
4955 break;
4956 case Item_func::IN_FUNC:
4957 if (((Item_func_opt_neg *) item_func)->negated)
4958 {
4959 func_name = SPIDER_SQL_NOT_IN_STR;
4960 func_name_length = SPIDER_SQL_NOT_IN_LEN;
4961 separator_str = SPIDER_SQL_COMMA_STR;
4962 separator_str_length = SPIDER_SQL_COMMA_LEN;
4963 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
4964 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
4965 } else {
4966 func_name = SPIDER_SQL_IN_STR;
4967 func_name_length = SPIDER_SQL_IN_LEN;
4968 separator_str = SPIDER_SQL_COMMA_STR;
4969 separator_str_length = SPIDER_SQL_COMMA_LEN;
4970 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
4971 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
4972 }
4973 break;
4974 case Item_func::BETWEEN:
4975 if (((Item_func_opt_neg *) item_func)->negated)
4976 {
4977 func_name = SPIDER_SQL_NOT_BETWEEN_STR;
4978 func_name_length = SPIDER_SQL_NOT_BETWEEN_LEN;
4979 separator_str = SPIDER_SQL_AND_STR;
4980 separator_str_length = SPIDER_SQL_AND_LEN;
4981 } else {
4982 func_name = (char*) item_func->func_name();
4983 func_name_length = strlen(func_name);
4984 separator_str = SPIDER_SQL_AND_STR;
4985 separator_str_length = SPIDER_SQL_AND_LEN;
4986 }
4987 break;
4988 case Item_func::FUNC_SP:
4989 case Item_func::UDF_FUNC:
4990 use_pushdown_udf = spider_param_use_pushdown_udf(spider->trx->thd,
4991 spider->share->use_pushdown_udf);
4992 if (!use_pushdown_udf)
4993 /*
4994 This is the default behavior because the remote nodes may deal with
4995 the function in an unexpected way (e.g. not having the same
4996 definition). Users can turn it on if they know what they are doing.
4997 */
4998 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
4999 if (str)
5000 {
5001 func_name = (char*) item_func->func_name();
5002 func_name_length = strlen(func_name);
5003 DBUG_PRINT("info",("spider func_name = %s", func_name));
5004 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
5005 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
5006 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5007 str->q_append(func_name, func_name_length);
5008 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
5009 }
5010 func_name = SPIDER_SQL_COMMA_STR;
5011 func_name_length = SPIDER_SQL_COMMA_LEN;
5012 separator_str = SPIDER_SQL_COMMA_STR;
5013 separator_str_length = SPIDER_SQL_COMMA_LEN;
5014 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
5015 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
5016 break;
5017 #ifdef MARIADB_BASE_VERSION
5018 case Item_func::XOR_FUNC:
5019 #else
5020 case Item_func::COND_XOR_FUNC:
5021 #endif
5022 if (str)
5023 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
5024 DBUG_RETURN(
5025 spider_db_open_item_cond((Item_cond *) item_func, spider, str,
5026 alias, alias_length, dbton_id, use_fields, fields));
5027 case Item_func::TRIG_COND_FUNC:
5028 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5029 case Item_func::GUSERVAR_FUNC:
5030 if (str)
5031 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
5032 if (item_func->result_type() == STRING_RESULT)
5033 DBUG_RETURN(spider_db_open_item_string(item_func, NULL, spider, str,
5034 alias, alias_length, dbton_id, use_fields, fields));
5035 else
5036 DBUG_RETURN(spider_db_open_item_int(item_func, NULL, spider, str,
5037 alias, alias_length, dbton_id, use_fields, fields));
5038 case Item_func::FT_FUNC:
5039 if (spider_db_check_ft_idx(item_func, spider) == MAX_KEY)
5040 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5041 start_item = 1;
5042 if (str)
5043 {
5044 if (str->reserve(SPIDER_SQL_MATCH_LEN))
5045 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5046 str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);
5047 }
5048 separator_str = SPIDER_SQL_COMMA_STR;
5049 separator_str_length = SPIDER_SQL_COMMA_LEN;
5050 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
5051 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
5052 break;
5053 case Item_func::SP_EQUALS_FUNC:
5054 if (str)
5055 {
5056 func_name = SPIDER_SQL_MBR_EQUAL_STR;
5057 func_name_length = SPIDER_SQL_MBR_EQUAL_LEN;
5058 DBUG_PRINT("info",("spider func_name = %s", func_name));
5059 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
5060 if (str->reserve(func_name_length))
5061 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5062 str->q_append(func_name, func_name_length);
5063 }
5064 func_name = SPIDER_SQL_COMMA_STR;
5065 func_name_length = SPIDER_SQL_COMMA_LEN;
5066 separator_str = SPIDER_SQL_COMMA_STR;
5067 separator_str_length = SPIDER_SQL_COMMA_LEN;
5068 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
5069 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
5070 break;
5071 case Item_func::SP_DISJOINT_FUNC:
5072 case Item_func::SP_INTERSECTS_FUNC:
5073 case Item_func::SP_TOUCHES_FUNC:
5074 case Item_func::SP_CROSSES_FUNC:
5075 case Item_func::SP_WITHIN_FUNC:
5076 case Item_func::SP_CONTAINS_FUNC:
5077 case Item_func::SP_OVERLAPS_FUNC:
5078 if (str)
5079 {
5080 func_name = (char*) item_func->func_name();
5081 func_name_length = strlen(func_name);
5082 DBUG_PRINT("info",("spider func_name = %s", func_name));
5083 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
5084 if (str->reserve(
5085 #ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
5086 SPIDER_SQL_MBR_LEN +
5087 #endif
5088 func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
5089 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5090 #ifndef SPIDER_ITEM_GEOFUNC_NAME_HAS_MBR
5091 str->q_append(SPIDER_SQL_MBR_STR, SPIDER_SQL_MBR_LEN);
5092 #endif
5093 str->q_append(func_name, func_name_length);
5094 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
5095 }
5096 func_name = SPIDER_SQL_COMMA_STR;
5097 func_name_length = SPIDER_SQL_COMMA_LEN;
5098 separator_str = SPIDER_SQL_COMMA_STR;
5099 separator_str_length = SPIDER_SQL_COMMA_LEN;
5100 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
5101 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
5102 break;
5103 case Item_func::EQ_FUNC:
5104 case Item_func::EQUAL_FUNC:
5105 case Item_func::NE_FUNC:
5106 case Item_func::LT_FUNC:
5107 case Item_func::LE_FUNC:
5108 case Item_func::GE_FUNC:
5109 case Item_func::GT_FUNC:
5110 if (str)
5111 {
5112 func_name = (char*) item_func->func_name();
5113 func_name_length = strlen(func_name);
5114 }
5115 break;
5116 case Item_func::LIKE_FUNC:
5117 if (str)
5118 {
5119 if (((Item_func_like *)item_func)->negated)
5120 {
5121 func_name = SPIDER_SQL_NOT_LIKE_STR;
5122 func_name_length = SPIDER_SQL_NOT_LIKE_LEN;
5123 }
5124 else
5125 {
5126 func_name = (char*)item_func->func_name();
5127 func_name_length = strlen(func_name);
5128 }
5129 }
5130 break;
5131 case Item_func::CASE_SEARCHED_FUNC:
5132 case Item_func::CASE_SIMPLE_FUNC:
5133 #ifdef ITEM_FUNC_CASE_PARAMS_ARE_PUBLIC
5134 Item_func_case *item_func_case = (Item_func_case *) item_func;
5135 if (str)
5136 {
5137 if (str->reserve(SPIDER_SQL_CASE_LEN))
5138 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5139 str->q_append(SPIDER_SQL_CASE_STR, SPIDER_SQL_CASE_LEN);
5140 }
5141 if (item_func_case->first_expr_num != -1)
5142 {
5143 if ((error_num = spider_db_print_item_type(
5144 item_list[item_func_case->first_expr_num], NULL, spider, str,
5145 alias, alias_length, dbton_id, use_fields, fields)))
5146 DBUG_RETURN(error_num);
5147 }
5148 for (roop_count = 0; roop_count < item_func_case->ncases;
5149 roop_count += 2)
5150 {
5151 if (str)
5152 {
5153 if (str->reserve(SPIDER_SQL_WHEN_LEN))
5154 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5155 str->q_append(SPIDER_SQL_WHEN_STR, SPIDER_SQL_WHEN_LEN);
5156 }
5157 if ((error_num = spider_db_print_item_type(
5158 item_list[roop_count], NULL, spider, str,
5159 alias, alias_length, dbton_id, use_fields, fields)))
5160 DBUG_RETURN(error_num);
5161 if (str)
5162 {
5163 if (str->reserve(SPIDER_SQL_THEN_LEN))
5164 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5165 str->q_append(SPIDER_SQL_THEN_STR, SPIDER_SQL_THEN_LEN);
5166 }
5167 if ((error_num = spider_db_print_item_type(
5168 item_list[roop_count + 1], NULL, spider, str,
5169 alias, alias_length, dbton_id, use_fields, fields)))
5170 DBUG_RETURN(error_num);
5171 }
5172 if (item_func_case->else_expr_num != -1)
5173 {
5174 if (str)
5175 {
5176 if (str->reserve(SPIDER_SQL_ELSE_LEN))
5177 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5178 str->q_append(SPIDER_SQL_ELSE_STR, SPIDER_SQL_ELSE_LEN);
5179 }
5180 if ((error_num = spider_db_print_item_type(
5181 item_list[item_func_case->else_expr_num], NULL, spider, str,
5182 alias, alias_length, dbton_id, use_fields, fields)))
5183 DBUG_RETURN(error_num);
5184 }
5185 if (str)
5186 {
5187 if (str->reserve(SPIDER_SQL_END_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
5188 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5189 str->q_append(SPIDER_SQL_END_STR, SPIDER_SQL_END_LEN);
5190 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5191 SPIDER_SQL_CLOSE_PAREN_LEN);
5192 }
5193 DBUG_RETURN(0);
5194 #else
5195 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5196 #endif
5197 case Item_func::JSON_EXTRACT_FUNC:
5198 func_name = (char*) item_func->func_name();
5199 func_name_length = strlen(func_name);
5200 if (str)
5201 {
5202 if (str->reserve(func_name_length + SPIDER_SQL_OPEN_PAREN_LEN))
5203 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5204 str->q_append(func_name, func_name_length);
5205 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
5206 }
5207 func_name = SPIDER_SQL_COMMA_STR;
5208 func_name_length = SPIDER_SQL_COMMA_LEN;
5209 separator_str = SPIDER_SQL_COMMA_STR;
5210 separator_str_length = SPIDER_SQL_COMMA_LEN;
5211 last_str = SPIDER_SQL_CLOSE_PAREN_STR;
5212 last_str_length = SPIDER_SQL_CLOSE_PAREN_LEN;
5213 break;
5214 default:
5215 THD *thd = spider->trx->thd;
5216 SPIDER_SHARE *share = spider->share;
5217 if (spider_param_skip_default_condition(thd,
5218 share->skip_default_condition))
5219 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5220 if (str)
5221 {
5222 func_name = (char*) item_func->func_name();
5223 func_name_length = strlen(func_name);
5224 }
5225 break;
5226 }
5227 DBUG_PRINT("info",("spider func_name = %s", func_name));
5228 DBUG_PRINT("info",("spider func_name_length = %d", func_name_length));
5229 DBUG_PRINT("info",("spider separator_str = %s", separator_str));
5230 DBUG_PRINT("info",("spider separator_str_length = %d", separator_str_length));
5231 DBUG_PRINT("info",("spider last_str = %s", last_str));
5232 DBUG_PRINT("info",("spider last_str_length = %d", last_str_length));
5233 if (item_count)
5234 {
5235 /* Find the field in the list of items of the expression tree */
5236 field = spider_db_find_field_in_item_list(item_list,
5237 item_count, start_item,
5238 str,
5239 func_name, func_name_length);
5240 item_count--;
5241 /*
5242 Loop through the items of the current function expression to
5243 print its portion of the statement
5244 */
5245 for (roop_count = start_item; roop_count < item_count; roop_count++)
5246 {
5247 item = item_list[roop_count];
5248 if ((error_num = spider_db_print_item_type(item, field, spider, str,
5249 alias, alias_length, dbton_id, use_fields, fields)))
5250 DBUG_RETURN(error_num);
5251 if (roop_count == 1)
5252 {
5253 /* Remaining operands need to be preceded by the separator */
5254 func_name = separator_str;
5255 func_name_length = separator_str_length;
5256 }
5257 if (str)
5258 {
5259 if (str->reserve(func_name_length + SPIDER_SQL_SPACE_LEN * 2))
5260 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5261 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
5262 str->q_append(func_name, func_name_length);
5263 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
5264 }
5265 }
5266
5267 /* Print the last operand value */
5268 item = item_list[roop_count];
5269 if ((error_num = spider_db_print_item_type(item, field, spider, str,
5270 alias, alias_length, dbton_id, use_fields, fields)))
5271 DBUG_RETURN(error_num);
5272 }
5273
5274 if (item_func->functype() == Item_func::FT_FUNC)
5275 {
5276 Item_func_match *item_func_match = (Item_func_match *)item_func;
5277 if (str)
5278 {
5279 if (str->reserve(SPIDER_SQL_AGAINST_LEN))
5280 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5281 str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);
5282 }
5283 item = item_list[0];
5284 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
5285 alias, alias_length, dbton_id, use_fields, fields)))
5286 DBUG_RETURN(error_num);
5287 if (str)
5288 {
5289 if (str->reserve(
5290 ((item_func_match->flags & FT_BOOL) ?
5291 SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +
5292 ((item_func_match->flags & FT_EXPAND) ?
5293 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)
5294 ))
5295 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5296 if (item_func_match->flags & FT_BOOL)
5297 str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,
5298 SPIDER_SQL_IN_BOOLEAN_MODE_LEN);
5299 if (item_func_match->flags & FT_EXPAND)
5300 str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,
5301 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);
5302 }
5303 } else if (item_func->functype() == Item_func::UNKNOWN_FUNC)
5304 {
5305 if (
5306 func_name_length == 7 &&
5307 !strncasecmp("convert", func_name, func_name_length)
5308 ) {
5309 if (str)
5310 {
5311 Item_func_conv_charset *item_func_conv_charset =
5312 (Item_func_conv_charset *)item_func;
5313 CHARSET_INFO *conv_charset =
5314 item_func_conv_charset->SPIDER_Item_func_conv_charset_conv_charset;
5315 uint cset_length = strlen(conv_charset->csname);
5316 if (str->reserve(SPIDER_SQL_USING_LEN + cset_length))
5317 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5318 str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
5319 str->q_append(conv_charset->csname, cset_length);
5320 }
5321 }
5322 }
5323 if (str)
5324 {
5325 if (merge_func)
5326 str->length(str->length() - SPIDER_SQL_CLOSE_PAREN_LEN);
5327 if (str->reserve(last_str_length + SPIDER_SQL_CLOSE_PAREN_LEN))
5328 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5329 str->q_append(last_str, last_str_length);
5330 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
5331 }
5332 DBUG_RETURN(0);
5333 }
5334
5335 #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)5336 int spider_db_mbase_util::open_item_sum_func(
5337 Item_sum *item_sum,
5338 ha_spider *spider,
5339 spider_string *str,
5340 const char *alias,
5341 uint alias_length,
5342 bool use_fields,
5343 spider_fields *fields
5344 ) {
5345 uint roop_count, item_count = item_sum->get_arg_count();
5346 int error_num;
5347 DBUG_ENTER("spider_db_mbase_util::open_item_sum_func");
5348 DBUG_PRINT("info",("spider Sumfunctype = %d", item_sum->sum_func()));
5349 switch (item_sum->sum_func())
5350 {
5351 case Item_sum::COUNT_FUNC:
5352 case Item_sum::SUM_FUNC:
5353 case Item_sum::MIN_FUNC:
5354 case Item_sum::MAX_FUNC:
5355 {
5356 const char *func_name = item_sum->func_name();
5357 uint func_name_length = strlen(func_name);
5358 Item *item, **args = item_sum->get_args();
5359 if (str)
5360 {
5361 if (str->reserve(func_name_length))
5362 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5363 str->q_append(func_name, func_name_length);
5364 }
5365 if (item_count)
5366 {
5367 item_count--;
5368 for (roop_count = 0; roop_count < item_count; roop_count++)
5369 {
5370 item = args[roop_count];
5371 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
5372 alias, alias_length, dbton_id, use_fields, fields)))
5373 DBUG_RETURN(error_num);
5374 if (str)
5375 {
5376 if (str->reserve(SPIDER_SQL_COMMA_LEN))
5377 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5378 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
5379 }
5380 }
5381 item = args[roop_count];
5382 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
5383 alias, alias_length, dbton_id, use_fields, fields)))
5384 DBUG_RETURN(error_num);
5385 }
5386 if (str)
5387 {
5388 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
5389 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5390 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5391 SPIDER_SQL_CLOSE_PAREN_LEN);
5392 }
5393 }
5394 break;
5395 case Item_sum::COUNT_DISTINCT_FUNC:
5396 case Item_sum::SUM_DISTINCT_FUNC:
5397 case Item_sum::AVG_FUNC:
5398 case Item_sum::AVG_DISTINCT_FUNC:
5399 {
5400 if (!use_fields)
5401 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5402 const char *func_name = item_sum->func_name();
5403 uint func_name_length = strlen(func_name);
5404 Item *item, **args = item_sum->get_args();
5405 if (str)
5406 {
5407 if (str->reserve(func_name_length))
5408 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5409 str->q_append(func_name, func_name_length);
5410 }
5411 if (item_count)
5412 {
5413 item_count--;
5414 for (roop_count = 0; roop_count < item_count; roop_count++)
5415 {
5416 item = args[roop_count];
5417 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
5418 alias, alias_length, dbton_id, use_fields, fields)))
5419 DBUG_RETURN(error_num);
5420 if (str)
5421 {
5422 if (str->reserve(SPIDER_SQL_COMMA_LEN))
5423 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5424 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
5425 }
5426 }
5427 item = args[roop_count];
5428 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
5429 alias, alias_length, dbton_id, use_fields, fields)))
5430 DBUG_RETURN(error_num);
5431 }
5432 if (str)
5433 {
5434 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
5435 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5436 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5437 SPIDER_SQL_CLOSE_PAREN_LEN);
5438 }
5439 }
5440 break;
5441 case Item_sum::STD_FUNC:
5442 case Item_sum::VARIANCE_FUNC:
5443 case Item_sum::SUM_BIT_FUNC:
5444 case Item_sum::UDF_SUM_FUNC:
5445 case Item_sum::GROUP_CONCAT_FUNC:
5446 default:
5447 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
5448 }
5449 DBUG_RETURN(0);
5450 }
5451 #endif
5452
append_escaped_util(spider_string * to,String * from)5453 int spider_db_mbase_util::append_escaped_util(
5454 spider_string *to,
5455 String *from
5456 ) {
5457 DBUG_ENTER("spider_db_mbase_util::append_escaped_util");
5458 DBUG_PRINT("info",("spider this=%p", this));
5459 DBUG_PRINT("info",("spider from=%s", from->charset()->csname));
5460 DBUG_PRINT("info",("spider to=%s", to->charset()->csname));
5461 to->append_escape_string(from->ptr(), from->length());
5462 DBUG_RETURN(0);
5463 }
5464
5465 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
append_table(ha_spider * spider,spider_fields * fields,spider_string * str,TABLE_LIST * table_list,TABLE_LIST ** used_table_list,uint * current_pos,TABLE_LIST ** cond_table_list_ptr,bool top_down,bool first)5466 int spider_db_mbase_util::append_table(
5467 ha_spider *spider,
5468 spider_fields *fields,
5469 spider_string *str,
5470 TABLE_LIST *table_list,
5471 TABLE_LIST **used_table_list,
5472 uint *current_pos,
5473 TABLE_LIST **cond_table_list_ptr,
5474 bool top_down,
5475 bool first
5476 ) {
5477 int error_num;
5478 bool use_cond_table_list = FALSE;
5479 spider_mbase_share *db_share;
5480 spider_mbase_handler *dbton_hdl;
5481 SPIDER_TABLE_HOLDER *table_holder;
5482 TABLE_LIST *cond_table_list = *cond_table_list_ptr;
5483 ha_spider *spd;
5484 DBUG_ENTER("spider_db_mbase_util::append_table");
5485 DBUG_PRINT("info",("spider table_list=%p", table_list));
5486 DBUG_PRINT("info",("spider table_list->outer_join=%u",
5487 table_list->outer_join));
5488 DBUG_PRINT("info",("spider table_list->on_expr=%p",
5489 table_list->on_expr));
5490 DBUG_PRINT("info",("spider table_list->join_using_fields=%p",
5491 table_list->join_using_fields));
5492 DBUG_PRINT("info",("spider table_list->table=%p",
5493 table_list->table));
5494 if (!top_down && table_list->embedding)
5495 {
5496 if ((error_num = append_embedding_tables(spider, fields, str,
5497 table_list->embedding, used_table_list, current_pos,
5498 cond_table_list_ptr)))
5499 DBUG_RETURN(error_num);
5500 } else if (!table_list->table)
5501 {
5502 if ((error_num = append_tables_top_down(spider, fields, str, table_list,
5503 used_table_list, current_pos, cond_table_list_ptr)))
5504 DBUG_RETURN(error_num);
5505 } else {
5506 if (
5507 table_list->outer_join ||
5508 table_list->on_expr ||
5509 table_list->join_using_fields
5510 ) {
5511 DBUG_PRINT("info",("spider use table_list"));
5512 if (table_list->outer_join & JOIN_TYPE_LEFT)
5513 {
5514 if (str)
5515 {
5516 if (str->reserve(SPIDER_SQL_LEFT_JOIN_LEN))
5517 {
5518 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5519 }
5520 str->q_append(SPIDER_SQL_LEFT_JOIN_STR, SPIDER_SQL_LEFT_JOIN_LEN);
5521 }
5522 } else {
5523 if (str)
5524 {
5525 if (str->reserve(SPIDER_SQL_JOIN_LEN))
5526 {
5527 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5528 }
5529 str->q_append(SPIDER_SQL_JOIN_STR, SPIDER_SQL_JOIN_LEN);
5530 }
5531 }
5532 } else if (
5533 cond_table_list &&
5534 (
5535 cond_table_list->outer_join ||
5536 cond_table_list->on_expr ||
5537 cond_table_list->join_using_fields
5538 )
5539 ) {
5540 DBUG_PRINT("info",("spider use cond_table_list"));
5541 if (cond_table_list->outer_join & (JOIN_TYPE_LEFT | JOIN_TYPE_RIGHT))
5542 {
5543 if (str)
5544 {
5545 if (str->reserve(SPIDER_SQL_LEFT_JOIN_LEN))
5546 {
5547 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5548 }
5549 str->q_append(SPIDER_SQL_LEFT_JOIN_STR, SPIDER_SQL_LEFT_JOIN_LEN);
5550 }
5551 } else {
5552 if (str)
5553 {
5554 if (str->reserve(SPIDER_SQL_JOIN_LEN))
5555 {
5556 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5557 }
5558 str->q_append(SPIDER_SQL_JOIN_STR, SPIDER_SQL_JOIN_LEN);
5559 }
5560 }
5561 use_cond_table_list = TRUE;
5562 } else if (*current_pos > 0 && !first)
5563 {
5564 DBUG_PRINT("info",("spider no condition"));
5565 if (top_down)
5566 {
5567 if (str)
5568 {
5569 if (str->reserve(SPIDER_SQL_JOIN_LEN))
5570 {
5571 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5572 }
5573 str->q_append(SPIDER_SQL_JOIN_STR, SPIDER_SQL_JOIN_LEN);
5574 }
5575 } else {
5576 if (str)
5577 {
5578 if (str->reserve(SPIDER_SQL_COMMA_LEN))
5579 {
5580 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5581 }
5582 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
5583 }
5584 }
5585 }
5586
5587 if (str)
5588 {
5589 table_holder = fields->get_table_holder(table_list->table);
5590 spd = table_holder->spider;
5591 db_share = (spider_mbase_share *)
5592 spd->share->dbton_share[dbton_id];
5593 dbton_hdl = (spider_mbase_handler *)
5594 spd->dbton_handler[dbton_id];
5595
5596 dbton_hdl->table_name_pos = str->length();
5597
5598 if (str->reserve(
5599 db_share->db_nm_max_length +
5600 SPIDER_SQL_DOT_LEN + /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 +
5601 db_share->table_nm_max_length + SPIDER_SQL_SPACE_LEN +
5602 table_holder->alias->length() - SPIDER_SQL_DOT_LEN
5603 )) {
5604 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5605 }
5606
5607 if ((error_num = db_share->append_table_name_with_adjusting(str,
5608 spd->conn_link_idx[dbton_hdl->first_link_idx])))
5609 {
5610 DBUG_RETURN(error_num);
5611 }
5612 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
5613 str->q_append(table_holder->alias->ptr(),
5614 table_holder->alias->length() - SPIDER_SQL_DOT_LEN);
5615 }
5616 used_table_list[(*current_pos)++] = table_list;
5617
5618 if (str)
5619 {
5620 List<String> *join_using_fields = table_list->join_using_fields;
5621 if (!join_using_fields && cond_table_list)
5622 {
5623 join_using_fields = cond_table_list->join_using_fields;
5624 }
5625
5626 if (join_using_fields)
5627 {
5628 if (str->reserve(SPIDER_SQL_USING_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
5629 {
5630 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5631 }
5632 str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
5633 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
5634 SPIDER_SQL_OPEN_PAREN_LEN);
5635 List_iterator_fast<String> it2(*join_using_fields);
5636 String *ptr;
5637 while ((ptr = it2++))
5638 {
5639 if (str->reserve(ptr->length() + SPIDER_SQL_COMMA_LEN))
5640 {
5641 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5642 }
5643 str->q_append(ptr->ptr(), ptr->length());
5644 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
5645 }
5646 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
5647 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
5648 {
5649 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5650 }
5651 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5652 SPIDER_SQL_CLOSE_PAREN_LEN);
5653 }
5654 }
5655
5656 Item *on_expr = table_list->on_expr;
5657 if (!on_expr && cond_table_list)
5658 {
5659 on_expr = cond_table_list->on_expr;
5660 }
5661
5662 if (on_expr)
5663 {
5664 if (str)
5665 {
5666 if (str->reserve(SPIDER_SQL_ON_LEN))
5667 {
5668 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5669 }
5670 str->q_append(SPIDER_SQL_ON_STR, SPIDER_SQL_ON_LEN);
5671 }
5672 if ((error_num = spider_db_print_item_type(on_expr, NULL,
5673 spider, str, NULL, 0, dbton_id, TRUE, fields)))
5674 {
5675 DBUG_RETURN(error_num);
5676 }
5677 }
5678
5679 if (use_cond_table_list)
5680 {
5681 (*cond_table_list_ptr) = NULL;
5682 DBUG_PRINT("info",("spider cond_table_list=%p", (*cond_table_list_ptr)));
5683 }
5684 }
5685 DBUG_RETURN(0);
5686 }
5687
append_tables_top_down(ha_spider * spider,spider_fields * fields,spider_string * str,TABLE_LIST * table_list,TABLE_LIST ** used_table_list,uint * current_pos,TABLE_LIST ** cond_table_list_ptr)5688 int spider_db_mbase_util::append_tables_top_down(
5689 ha_spider *spider,
5690 spider_fields *fields,
5691 spider_string *str,
5692 TABLE_LIST *table_list,
5693 TABLE_LIST **used_table_list,
5694 uint *current_pos,
5695 TABLE_LIST **cond_table_list_ptr
5696 ) {
5697 int error_num;
5698 uint outer_join_backup;
5699 TABLE_LIST *cur_table_list, *prev_table_list = NULL, *cond_table_list = NULL;
5700 bool first = TRUE;
5701 DBUG_ENTER("spider_db_mbase_util::append_tables_top_down");
5702 DBUG_PRINT("info",("spider this=%p", this));
5703 if (
5704 table_list->outer_join ||
5705 table_list->on_expr ||
5706 table_list->join_using_fields
5707 ) {
5708 DBUG_ASSERT(!(*cond_table_list_ptr));
5709 (*cond_table_list_ptr) = table_list;
5710 DBUG_PRINT("info",("spider cond_table_list=%p", table_list));
5711 }
5712 List_iterator_fast<TABLE_LIST> it1(table_list->nested_join->join_list);
5713 cur_table_list = it1++;
5714 if (cur_table_list->outer_join & JOIN_TYPE_RIGHT)
5715 {
5716 first = FALSE;
5717 prev_table_list = cur_table_list;
5718 cur_table_list = it1++;
5719 } else if (*cond_table_list_ptr)
5720 {
5721 first = TRUE;
5722 cond_table_list = (*cond_table_list_ptr);
5723 (*cond_table_list_ptr) = NULL;
5724 if (cond_table_list->outer_join & JOIN_TYPE_LEFT)
5725 {
5726 if (str)
5727 {
5728 if (str->reserve(SPIDER_SQL_LEFT_JOIN_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
5729 {
5730 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5731 }
5732 str->q_append(SPIDER_SQL_LEFT_JOIN_STR, SPIDER_SQL_LEFT_JOIN_LEN);
5733 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
5734 }
5735 } else {
5736 if (str)
5737 {
5738 if (str->reserve(SPIDER_SQL_JOIN_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
5739 {
5740 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5741 }
5742 str->q_append(SPIDER_SQL_JOIN_STR, SPIDER_SQL_JOIN_LEN);
5743 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
5744 }
5745 }
5746 }
5747
5748 do {
5749 if (cur_table_list->outer_join & JOIN_TYPE_RIGHT)
5750 {
5751 prev_table_list = cur_table_list;
5752 } else {
5753 if ((error_num = append_table(spider, fields, str, cur_table_list,
5754 used_table_list, current_pos, cond_table_list_ptr, TRUE, first)))
5755 DBUG_RETURN(error_num);
5756 first = FALSE;
5757 if (prev_table_list)
5758 {
5759 outer_join_backup = prev_table_list->outer_join;
5760 prev_table_list->outer_join = JOIN_TYPE_LEFT;
5761 if ((error_num = append_table(spider, fields, str, prev_table_list,
5762 used_table_list, current_pos, cond_table_list_ptr, TRUE, FALSE)))
5763 {
5764 prev_table_list->outer_join = outer_join_backup;
5765 DBUG_RETURN(error_num);
5766 }
5767 prev_table_list->outer_join = outer_join_backup;
5768 prev_table_list = NULL;
5769 }
5770 }
5771 } while ((cur_table_list = it1++));
5772
5773 if (cond_table_list)
5774 {
5775 if (str)
5776 {
5777 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
5778 {
5779 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5780 }
5781 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5782 SPIDER_SQL_CLOSE_PAREN_LEN);
5783
5784 List<String> *join_using_fields = cond_table_list->join_using_fields;
5785 if (join_using_fields)
5786 {
5787 if (str->reserve(SPIDER_SQL_USING_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
5788 {
5789 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5790 }
5791 str->q_append(SPIDER_SQL_USING_STR, SPIDER_SQL_USING_LEN);
5792 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,
5793 SPIDER_SQL_OPEN_PAREN_LEN);
5794 List_iterator_fast<String> it2(*join_using_fields);
5795 String *ptr;
5796 while ((ptr = it2++))
5797 {
5798 if (str->reserve(ptr->length() + SPIDER_SQL_COMMA_LEN))
5799 {
5800 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5801 }
5802 str->q_append(ptr->ptr(), ptr->length());
5803 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
5804 }
5805 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
5806 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN))
5807 {
5808 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5809 }
5810 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
5811 SPIDER_SQL_CLOSE_PAREN_LEN);
5812 }
5813 }
5814
5815 Item *on_expr = cond_table_list->on_expr;
5816 if (on_expr)
5817 {
5818 if (str)
5819 {
5820 if (str->reserve(SPIDER_SQL_ON_LEN))
5821 {
5822 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5823 }
5824 str->q_append(SPIDER_SQL_ON_STR, SPIDER_SQL_ON_LEN);
5825 }
5826 if ((error_num = spider_db_print_item_type(on_expr, NULL,
5827 spider, str, NULL, 0, dbton_id, TRUE, fields)))
5828 {
5829 DBUG_RETURN(error_num);
5830 }
5831 }
5832 }
5833 DBUG_RETURN(0);
5834 }
5835
append_tables_top_down_check(TABLE_LIST * table_list,TABLE_LIST ** used_table_list,uint * current_pos)5836 int spider_db_mbase_util::append_tables_top_down_check(
5837 TABLE_LIST *table_list,
5838 TABLE_LIST **used_table_list,
5839 uint *current_pos
5840 ) {
5841 int error_num;
5842 TABLE_LIST *cur_table_list;
5843 DBUG_ENTER("spider_db_mbase_util::append_tables_top_down_check");
5844 DBUG_PRINT("info",("spider this=%p", this));
5845 List_iterator_fast<TABLE_LIST> it1(table_list->nested_join->join_list);
5846 while ((cur_table_list = it1++))
5847 {
5848 if (!cur_table_list->table)
5849 {
5850 if ((error_num = append_tables_top_down_check(
5851 cur_table_list, used_table_list, current_pos)))
5852 DBUG_RETURN(error_num);
5853 } else {
5854 used_table_list[(*current_pos)++] = cur_table_list;
5855 }
5856 }
5857 DBUG_RETURN(0);
5858 }
5859
append_embedding_tables(ha_spider * spider,spider_fields * fields,spider_string * str,TABLE_LIST * table_list,TABLE_LIST ** used_table_list,uint * current_pos,TABLE_LIST ** cond_table_list_ptr)5860 int spider_db_mbase_util::append_embedding_tables(
5861 ha_spider *spider,
5862 spider_fields *fields,
5863 spider_string *str,
5864 TABLE_LIST *table_list,
5865 TABLE_LIST **used_table_list,
5866 uint *current_pos,
5867 TABLE_LIST **cond_table_list_ptr
5868 ) {
5869 int error_num;
5870 TABLE_LIST *embedding = table_list->embedding;
5871 DBUG_ENTER("spider_db_mbase_util::append_embedding_tables");
5872 DBUG_PRINT("info",("spider this=%p", this));
5873 if (embedding)
5874 {
5875 DBUG_PRINT("info",("spider embedding=%p", embedding));
5876 DBUG_PRINT("info",("spider embedding->outer_join=%u",
5877 embedding->outer_join));
5878 DBUG_PRINT("info",("spider embedding->on_expr=%p",
5879 embedding->on_expr));
5880 DBUG_PRINT("info",("spider embedding->join_using_fields=%p",
5881 embedding->join_using_fields));
5882 DBUG_PRINT("info",("spider embedding->table=%p",
5883 embedding->table));
5884 if ((error_num = append_embedding_tables(spider, fields, str, embedding,
5885 used_table_list, current_pos, cond_table_list_ptr)))
5886 DBUG_RETURN(error_num);
5887 } else {
5888 DBUG_PRINT("info",("spider table_list=%p", table_list));
5889 DBUG_PRINT("info",("spider table_list->outer_join=%u",
5890 table_list->outer_join));
5891 DBUG_PRINT("info",("spider table_list->on_expr=%p",
5892 table_list->on_expr));
5893 DBUG_PRINT("info",("spider table_list->join_using_fields=%p",
5894 table_list->join_using_fields));
5895 DBUG_PRINT("info",("spider table_list->table=%p",
5896 table_list->table));
5897 if (table_list->outer_join & JOIN_TYPE_RIGHT)
5898 {
5899 if ((error_num = append_tables_top_down_check(table_list,
5900 used_table_list, current_pos)))
5901 DBUG_RETURN(error_num);
5902 DBUG_ASSERT(!(*cond_table_list_ptr));
5903 (*cond_table_list_ptr) = table_list;
5904 DBUG_PRINT("info",("spider cond_table_list=%p", table_list));
5905 } else {
5906 if ((error_num = append_tables_top_down(spider, fields, str, table_list,
5907 used_table_list, current_pos, cond_table_list_ptr)))
5908 DBUG_RETURN(error_num);
5909 }
5910 }
5911 DBUG_RETURN(0);
5912 }
5913
append_from_and_tables(ha_spider * spider,spider_fields * fields,spider_string * str,TABLE_LIST * table_list,uint table_count)5914 int spider_db_mbase_util::append_from_and_tables(
5915 ha_spider *spider,
5916 spider_fields *fields,
5917 spider_string *str,
5918 TABLE_LIST *table_list,
5919 uint table_count
5920 ) {
5921 int error_num;
5922 uint current_pos = 0, roop_count, backup_pos, outer_join_backup;
5923 TABLE *table;
5924 TABLE_LIST **used_table_list, *prev_table_list = NULL,
5925 *cond_table_list = NULL;
5926 DBUG_ENTER("spider_db_mbase_util::append_from_and_tables");
5927 DBUG_PRINT("info",("spider this=%p", this));
5928 used_table_list = (TABLE_LIST **)
5929 my_alloca(sizeof(TABLE_LIST *) * table_count);
5930 if (!used_table_list)
5931 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5932
5933 if (str)
5934 {
5935 if (str->reserve(SPIDER_SQL_FROM_LEN))
5936 {
5937 my_afree(used_table_list);
5938 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
5939 }
5940 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
5941 }
5942
5943 do {
5944 table = table_list->table;
5945 if (table->const_table)
5946 continue;
5947
5948 for (roop_count = 0; roop_count < current_pos; ++roop_count)
5949 {
5950 if (used_table_list[roop_count] == table_list)
5951 break;
5952 }
5953 if (roop_count < current_pos)
5954 continue;
5955
5956 if (prev_table_list)
5957 current_pos = backup_pos;
5958 else
5959 backup_pos = current_pos;
5960 if ((error_num = append_table(spider, fields, str, table_list, used_table_list,
5961 ¤t_pos, &cond_table_list, FALSE, FALSE)))
5962 {
5963 my_afree(used_table_list);
5964 DBUG_RETURN(error_num);
5965 }
5966 if (prev_table_list)
5967 {
5968 outer_join_backup = prev_table_list->outer_join;
5969 prev_table_list->outer_join = JOIN_TYPE_LEFT;
5970 if ((error_num = append_table(spider, fields, str, prev_table_list,
5971 used_table_list, ¤t_pos, &cond_table_list, FALSE, FALSE)))
5972 {
5973 prev_table_list->outer_join = outer_join_backup;
5974 my_afree(used_table_list);
5975 DBUG_RETURN(error_num);
5976 }
5977 prev_table_list->outer_join = outer_join_backup;
5978 prev_table_list = NULL;
5979 }
5980 if (cond_table_list && (cond_table_list->outer_join & JOIN_TYPE_RIGHT))
5981 {
5982 prev_table_list = cond_table_list;
5983 cond_table_list = NULL;
5984 DBUG_PRINT("info",("spider cond_table_list=%p", cond_table_list));
5985 }
5986 } while ((table_list = table_list->next_local));
5987 my_afree(used_table_list);
5988 DBUG_RETURN(0);
5989 }
5990
reappend_tables(spider_fields * fields,SPIDER_LINK_IDX_CHAIN * link_idx_chain,spider_string * str)5991 int spider_db_mbase_util::reappend_tables(
5992 spider_fields *fields,
5993 SPIDER_LINK_IDX_CHAIN *link_idx_chain,
5994 spider_string *str
5995 ) {
5996 int error_num;
5997 uint32 length;
5998 ha_spider *spider;
5999 spider_mbase_share *db_share;
6000 spider_mbase_handler *dbton_hdl;
6001 SPIDER_TABLE_HOLDER *table_holder;
6002 SPIDER_LINK_IDX_HOLDER *link_idx_holder;
6003 DBUG_ENTER("spider_db_mbase_util::reappend_tables");
6004 DBUG_PRINT("info",("spider this=%p", this));
6005 length = str->length();
6006 fields->set_pos_to_first_table_on_link_idx_chain(link_idx_chain);
6007 fields->set_pos_to_first_table_holder();
6008 while ((table_holder = fields->get_next_table_holder()))
6009 {
6010 link_idx_holder =
6011 fields->get_next_table_on_link_idx_chain(link_idx_chain);
6012 spider = table_holder->spider;
6013 db_share = (spider_mbase_share *)
6014 spider->share->dbton_share[dbton_id];
6015 if (!db_share->same_db_table_name)
6016 {
6017 dbton_hdl = (spider_mbase_handler *) spider->dbton_handler[dbton_id];
6018 str->length(dbton_hdl->table_name_pos);
6019 if ((error_num = db_share->append_table_name_with_adjusting(str,
6020 spider->conn_link_idx[link_idx_holder->link_idx])))
6021 {
6022 DBUG_RETURN(error_num);
6023 }
6024 }
6025 }
6026 str->length(length);
6027 DBUG_RETURN(0);
6028 }
6029
append_where(spider_string * str)6030 int spider_db_mbase_util::append_where(
6031 spider_string *str
6032 ) {
6033 DBUG_ENTER("spider_db_mbase_util::append_where");
6034 DBUG_PRINT("info",("spider this=%p", this));
6035 if (str->reserve(SPIDER_SQL_WHERE_LEN))
6036 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6037 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
6038 DBUG_RETURN(0);
6039 }
6040
append_having(spider_string * str)6041 int spider_db_mbase_util::append_having(
6042 spider_string *str
6043 ) {
6044 DBUG_ENTER("spider_db_mbase_util::append_having");
6045 DBUG_PRINT("info",("spider this=%p", this));
6046 if (str->reserve(SPIDER_SQL_HAVING_LEN))
6047 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6048 str->q_append(SPIDER_SQL_HAVING_STR, SPIDER_SQL_HAVING_LEN);
6049 DBUG_RETURN(0);
6050 }
6051 #endif
6052
spider_mbase_share(st_spider_share * share,uint dbton_id,spider_db_mbase_util * spider_db_mbase_utility)6053 spider_mbase_share::spider_mbase_share(
6054 st_spider_share *share,
6055 uint dbton_id,
6056 spider_db_mbase_util *spider_db_mbase_utility
6057 ) : spider_db_share(
6058 share,
6059 dbton_id
6060 ),
6061 spider_db_mbase_utility(spider_db_mbase_utility),
6062 table_select(NULL),
6063 table_select_pos(0),
6064 key_select(NULL),
6065 key_select_pos(NULL),
6066 key_hint(NULL),
6067 show_table_status(NULL),
6068 show_records(NULL),
6069 show_index(NULL),
6070 table_names_str(NULL),
6071 db_names_str(NULL),
6072 db_table_str(NULL),
6073 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
6074 db_table_str_hash_value(NULL),
6075 #endif
6076 table_nm_max_length(0),
6077 db_nm_max_length(0),
6078 column_name_str(NULL),
6079 same_db_table_name(TRUE),
6080 first_all_link_idx(-1)
6081 {
6082 DBUG_ENTER("spider_mbase_share::spider_mbase_share");
6083 DBUG_PRINT("info",("spider this=%p", this));
6084 spider_alloc_calc_mem_init(mem_calc, 71);
6085 spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
6086 DBUG_VOID_RETURN;
6087 }
6088
spider_mysql_share(st_spider_share * share)6089 spider_mysql_share::spider_mysql_share(
6090 st_spider_share *share
6091 ) : spider_mbase_share(
6092 share,
6093 spider_db_mysql_utility.dbton_id,
6094 &spider_db_mysql_utility
6095 ) {
6096 DBUG_ENTER("spider_mysql_share::spider_mysql_share");
6097 DBUG_PRINT("info",("spider this=%p", this));
6098 DBUG_VOID_RETURN;
6099 }
spider_mariadb_share(st_spider_share * share)6100 spider_mariadb_share::spider_mariadb_share(
6101 st_spider_share *share
6102 ) : spider_mbase_share(
6103 share,
6104 spider_db_mariadb_utility.dbton_id,
6105 &spider_db_mariadb_utility
6106 ) {
6107 DBUG_ENTER("spider_mariadb_share::spider_mariadb_share");
6108 DBUG_PRINT("info",("spider this=%p", this));
6109 DBUG_VOID_RETURN;
6110 }
6111
~spider_mbase_share()6112 spider_mbase_share::~spider_mbase_share()
6113 {
6114 DBUG_ENTER("spider_mbase_share::~spider_mbase_share");
6115 DBUG_PRINT("info",("spider this=%p", this));
6116 if (table_select)
6117 delete [] table_select;
6118 if (key_select)
6119 delete [] key_select;
6120 if (key_hint)
6121 delete [] key_hint;
6122 free_show_table_status();
6123 free_show_records();
6124 free_show_index();
6125 free_column_name_str();
6126 free_table_names_str();
6127 if (key_select_pos)
6128 {
6129 spider_free(spider_current_trx, key_select_pos, MYF(0));
6130 }
6131 spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
6132 DBUG_VOID_RETURN;
6133 }
6134
~spider_mysql_share()6135 spider_mysql_share::~spider_mysql_share()
6136 {
6137 DBUG_ENTER("spider_mysql_share::~spider_mysql_share");
6138 DBUG_PRINT("info",("spider this=%p", this));
6139 DBUG_VOID_RETURN;
6140 }
6141
~spider_mariadb_share()6142 spider_mariadb_share::~spider_mariadb_share()
6143 {
6144 DBUG_ENTER("spider_mariadb_share::~spider_mariadb_share");
6145 DBUG_PRINT("info",("spider this=%p", this));
6146 DBUG_VOID_RETURN;
6147 }
6148
init()6149 int spider_mbase_share::init()
6150 {
6151 int error_num;
6152 uint roop_count;
6153 TABLE_SHARE *table_share = spider_share->table_share;
6154 uint keys = table_share ? table_share->keys : 0;
6155 DBUG_ENTER("spider_mbase_share::init");
6156 DBUG_PRINT("info",("spider this=%p", this));
6157 if (!(key_select_pos = (int *)
6158 spider_bulk_alloc_mem(spider_current_trx, 112,
6159 __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
6160 &key_select_pos,
6161 sizeof(int) * keys,
6162 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
6163 &db_table_str_hash_value,
6164 sizeof(my_hash_value_type) * spider_share->all_link_count,
6165 #endif
6166 NullS))
6167 ) {
6168 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6169 }
6170
6171 if (keys > 0 &&
6172 !(key_hint = new spider_string[keys])
6173 ) {
6174 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6175 }
6176 for (roop_count = 0; roop_count < keys; roop_count++)
6177 {
6178 key_hint[roop_count].init_calc_mem(189);
6179 key_hint[roop_count].set_charset(spider_share->access_charset);
6180 }
6181 DBUG_PRINT("info",("spider key_hint=%p", key_hint));
6182
6183 if (
6184 !(table_select = new spider_string[1]) ||
6185 (keys > 0 &&
6186 !(key_select = new spider_string[keys])
6187 ) ||
6188 (error_num = create_table_names_str()) ||
6189 (table_share &&
6190 (
6191 (error_num = create_column_name_str()) ||
6192 (error_num = convert_key_hint_str()) ||
6193 (error_num = append_show_table_status()) ||
6194 (error_num = append_show_records()) ||
6195 (error_num = append_show_index())
6196 )
6197 )
6198 ) {
6199 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6200 }
6201
6202 table_select->init_calc_mem(96);
6203 if (table_share && (error_num = append_table_select()))
6204 DBUG_RETURN(error_num);
6205
6206 for (roop_count = 0; roop_count < keys; roop_count++)
6207 {
6208 key_select[roop_count].init_calc_mem(97);
6209 if ((error_num = append_key_select(roop_count)))
6210 DBUG_RETURN(error_num);
6211 }
6212
6213 DBUG_RETURN(error_num);
6214 }
6215
get_column_name_length(uint field_index)6216 uint spider_mbase_share::get_column_name_length(
6217 uint field_index
6218 ) {
6219 DBUG_ENTER("spider_mbase_share::get_column_name_length");
6220 DBUG_PRINT("info",("spider this=%p", this));
6221 DBUG_RETURN(column_name_str[field_index].length());
6222 }
6223
append_column_name(spider_string * str,uint field_index)6224 int spider_mbase_share::append_column_name(
6225 spider_string *str,
6226 uint field_index
6227 ) {
6228 int error_num;
6229 DBUG_ENTER("spider_mbase_share::append_column_name");
6230 DBUG_PRINT("info",("spider this=%p", this));
6231 error_num = spider_db_mbase_utility->append_name(str,
6232 column_name_str[field_index].ptr(), column_name_str[field_index].length());
6233 DBUG_RETURN(error_num);
6234 }
6235
append_column_name_with_alias(spider_string * str,uint field_index,const char * alias,uint alias_length)6236 int spider_mbase_share::append_column_name_with_alias(
6237 spider_string *str,
6238 uint field_index,
6239 const char *alias,
6240 uint alias_length
6241 ) {
6242 DBUG_ENTER("spider_mbase_share::append_column_name_with_alias");
6243 DBUG_PRINT("info",("spider this=%p", this));
6244 if (str->reserve(
6245 alias_length +
6246 column_name_str[field_index].length() +
6247 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
6248 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6249 str->q_append(alias, alias_length);
6250 append_column_name(str, field_index);
6251 DBUG_RETURN(0);
6252 }
6253
append_table_name(spider_string * str,int all_link_idx)6254 int spider_mbase_share::append_table_name(
6255 spider_string *str,
6256 int all_link_idx
6257 ) {
6258 const char *db_nm = db_names_str[all_link_idx].ptr();
6259 uint db_nm_len = db_names_str[all_link_idx].length();
6260 const char *table_nm = table_names_str[all_link_idx].ptr();
6261 uint table_nm_len = table_names_str[all_link_idx].length();
6262 DBUG_ENTER("spider_mbase_share::append_table_name");
6263 DBUG_PRINT("info",("spider this=%p", this));
6264 if (str->reserve(db_nm_len + SPIDER_SQL_DOT_LEN + table_nm_len +
6265 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
6266 {
6267 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6268 }
6269 spider_db_mbase_utility->append_name(str, db_nm, db_nm_len);
6270 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
6271 spider_db_mbase_utility->append_name(str, table_nm, table_nm_len);
6272 DBUG_RETURN(0);
6273 }
6274
append_table_name_with_adjusting(spider_string * str,int all_link_idx)6275 int spider_mbase_share::append_table_name_with_adjusting(
6276 spider_string *str,
6277 int all_link_idx
6278 ) {
6279 const char *db_nm = db_names_str[all_link_idx].ptr();
6280 uint db_nm_len = db_names_str[all_link_idx].length();
6281 uint db_nm_max_len = db_nm_max_length;
6282 const char *table_nm = table_names_str[all_link_idx].ptr();
6283 uint table_nm_len = table_names_str[all_link_idx].length();
6284 uint table_nm_max_len = table_nm_max_length;
6285 DBUG_ENTER("spider_mbase_share::append_table_name_with_adjusting");
6286 DBUG_PRINT("info",("spider this=%p", this));
6287 spider_db_mbase_utility->append_name(str, db_nm, db_nm_len);
6288 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
6289 spider_db_mbase_utility->append_name(str, table_nm, table_nm_len);
6290 uint length =
6291 db_nm_max_len - db_nm_len +
6292 table_nm_max_len - table_nm_len;
6293 memset((char *) str->ptr() + str->length(), ' ', length);
6294 str->length(str->length() + length);
6295 DBUG_RETURN(0);
6296 }
6297
append_from_with_adjusted_table_name(spider_string * str,int * table_name_pos)6298 int spider_mbase_share::append_from_with_adjusted_table_name(
6299 spider_string *str,
6300 int *table_name_pos
6301 ) {
6302 const char *db_nm = db_names_str[0].ptr();
6303 uint db_nm_len = db_names_str[0].length();
6304 uint db_nm_max_len = db_nm_max_length;
6305 const char *table_nm = table_names_str[0].ptr();
6306 uint table_nm_len = table_names_str[0].length();
6307 uint table_nm_max_len = table_nm_max_length;
6308 DBUG_ENTER("spider_mbase_share::append_from_with_adjusted_table_name");
6309 DBUG_PRINT("info",("spider this=%p", this));
6310 if (str->reserve(SPIDER_SQL_FROM_LEN + db_nm_max_length +
6311 SPIDER_SQL_DOT_LEN + table_nm_max_length +
6312 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
6313 {
6314 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6315 }
6316 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
6317 *table_name_pos = str->length();
6318 spider_db_mbase_utility->append_name(str, db_nm, db_nm_len);
6319 str->q_append(SPIDER_SQL_DOT_STR, SPIDER_SQL_DOT_LEN);
6320 spider_db_mbase_utility->append_name(str, table_nm, table_nm_len);
6321 uint length =
6322 db_nm_max_len - db_nm_len +
6323 table_nm_max_len - table_nm_len;
6324 memset((char *) str->ptr() + str->length(), ' ', length);
6325 str->length(str->length() + length);
6326 DBUG_RETURN(0);
6327 }
6328
create_table_names_str()6329 int spider_mbase_share::create_table_names_str()
6330 {
6331 int error_num, roop_count;
6332 uint table_nm_len, db_nm_len;
6333 spider_string *str, *first_tbl_nm_str, *first_db_nm_str, *first_db_tbl_str;
6334 char *first_tbl_nm, *first_db_nm;
6335 DBUG_ENTER("spider_mbase_share::create_table_names_str");
6336 table_names_str = NULL;
6337 db_names_str = NULL;
6338 db_table_str = NULL;
6339 if (
6340 !(table_names_str = new spider_string[spider_share->all_link_count]) ||
6341 !(db_names_str = new spider_string[spider_share->all_link_count]) ||
6342 !(db_table_str = new spider_string[spider_share->all_link_count])
6343 ) {
6344 error_num = HA_ERR_OUT_OF_MEM;
6345 goto error;
6346 }
6347
6348 same_db_table_name = TRUE;
6349 first_tbl_nm = spider_share->tgt_table_names[0];
6350 first_db_nm = spider_share->tgt_dbs[0];
6351 table_nm_len = spider_share->tgt_table_names_lengths[0];
6352 db_nm_len = spider_share->tgt_dbs_lengths[0];
6353 first_tbl_nm_str = &table_names_str[0];
6354 first_db_nm_str = &db_names_str[0];
6355 first_db_tbl_str = &db_table_str[0];
6356 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
6357 roop_count++)
6358 {
6359 table_names_str[roop_count].init_calc_mem(86);
6360 db_names_str[roop_count].init_calc_mem(87);
6361 db_table_str[roop_count].init_calc_mem(88);
6362 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
6363 continue;
6364 if (first_all_link_idx == -1)
6365 first_all_link_idx = roop_count;
6366
6367 str = &table_names_str[roop_count];
6368 if (
6369 roop_count != 0 &&
6370 same_db_table_name &&
6371 spider_share->tgt_table_names_lengths[roop_count] == table_nm_len &&
6372 !memcmp(first_tbl_nm, spider_share->tgt_table_names[roop_count],
6373 table_nm_len)
6374 ) {
6375 if (str->copy(*first_tbl_nm_str))
6376 {
6377 error_num = HA_ERR_OUT_OF_MEM;
6378 goto error;
6379 }
6380 } else {
6381 str->set_charset(spider_share->access_charset);
6382 if ((error_num = spider_db_append_name_with_quote_str(str,
6383 spider_share->tgt_table_names[roop_count], dbton_id)))
6384 goto error;
6385 if (roop_count)
6386 {
6387 same_db_table_name = FALSE;
6388 DBUG_PRINT("info", ("spider found different table name %s",
6389 spider_share->tgt_table_names[roop_count]));
6390 if (str->length() > table_nm_max_length)
6391 table_nm_max_length = str->length();
6392 } else
6393 table_nm_max_length = str->length();
6394 }
6395
6396 str = &db_names_str[roop_count];
6397 if (
6398 roop_count != 0 &&
6399 same_db_table_name &&
6400 spider_share->tgt_dbs_lengths[roop_count] == db_nm_len &&
6401 !memcmp(first_db_nm, spider_share->tgt_dbs[roop_count],
6402 db_nm_len)
6403 ) {
6404 if (str->copy(*first_db_nm_str))
6405 {
6406 error_num = HA_ERR_OUT_OF_MEM;
6407 goto error;
6408 }
6409 } else {
6410 str->set_charset(spider_share->access_charset);
6411 if ((error_num = spider_db_append_name_with_quote_str(str,
6412 spider_share->tgt_dbs[roop_count], dbton_id)))
6413 goto error;
6414 if (roop_count)
6415 {
6416 same_db_table_name = FALSE;
6417 DBUG_PRINT("info", ("spider found different db name %s",
6418 spider_share->tgt_dbs[roop_count]));
6419 if (str->length() > db_nm_max_length)
6420 db_nm_max_length = str->length();
6421 } else
6422 db_nm_max_length = str->length();
6423 }
6424
6425 str = &db_table_str[roop_count];
6426 if (
6427 roop_count != 0 &&
6428 same_db_table_name
6429 ) {
6430 if (str->copy(*first_db_tbl_str))
6431 {
6432 error_num = HA_ERR_OUT_OF_MEM;
6433 goto error;
6434 }
6435 } else {
6436 str->set_charset(spider_share->access_charset);
6437 if ((error_num = append_table_name(str, roop_count)))
6438 goto error;
6439 }
6440 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
6441 db_table_str_hash_value[roop_count] = my_calc_hash(
6442 &spider_open_connections, (uchar*) str->ptr(), str->length());
6443 #endif
6444 }
6445 DBUG_RETURN(0);
6446
6447 error:
6448 if (db_table_str)
6449 {
6450 delete [] db_table_str;
6451 db_table_str = NULL;
6452 }
6453 if (db_names_str)
6454 {
6455 delete [] db_names_str;
6456 db_names_str = NULL;
6457 }
6458 if (table_names_str)
6459 {
6460 delete [] table_names_str;
6461 table_names_str = NULL;
6462 }
6463 DBUG_RETURN(error_num);
6464 }
6465
free_table_names_str()6466 void spider_mbase_share::free_table_names_str()
6467 {
6468 DBUG_ENTER("spider_mbase_share::free_table_names_str");
6469 if (db_table_str)
6470 {
6471 delete [] db_table_str;
6472 db_table_str = NULL;
6473 }
6474 if (db_names_str)
6475 {
6476 delete [] db_names_str;
6477 db_names_str = NULL;
6478 }
6479 if (table_names_str)
6480 {
6481 delete [] table_names_str;
6482 table_names_str = NULL;
6483 }
6484 DBUG_VOID_RETURN;
6485 }
6486
create_column_name_str()6487 int spider_mbase_share::create_column_name_str()
6488 {
6489 spider_string *str;
6490 int error_num;
6491 Field **field;
6492 TABLE_SHARE *table_share = spider_share->table_share;
6493 DBUG_ENTER("spider_mbase_share::create_column_name_str");
6494 if (
6495 table_share->fields &&
6496 !(column_name_str = new spider_string[table_share->fields])
6497 )
6498 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6499 for (field = table_share->field, str = column_name_str;
6500 *field; field++, str++)
6501 {
6502 str->init_calc_mem(89);
6503 str->set_charset(spider_share->access_charset);
6504 if ((error_num = spider_db_append_name_with_quote_str(str,
6505 (*field)->field_name, dbton_id)))
6506 goto error;
6507 }
6508 DBUG_RETURN(0);
6509
6510 error:
6511 if (column_name_str)
6512 {
6513 delete [] column_name_str;
6514 column_name_str = NULL;
6515 }
6516 DBUG_RETURN(error_num);
6517 }
6518
free_column_name_str()6519 void spider_mbase_share::free_column_name_str()
6520 {
6521 DBUG_ENTER("spider_mbase_share::free_column_name_str");
6522 if (column_name_str)
6523 {
6524 delete [] column_name_str;
6525 column_name_str = NULL;
6526 }
6527 DBUG_VOID_RETURN;
6528 }
6529
convert_key_hint_str()6530 int spider_mbase_share::convert_key_hint_str()
6531 {
6532 spider_string *tmp_key_hint;
6533 int roop_count;
6534 TABLE_SHARE *table_share = spider_share->table_share;
6535 DBUG_ENTER("spider_mbase_share::convert_key_hint_str");
6536 if (spider_share->access_charset->cset != system_charset_info->cset)
6537 {
6538 /* need conversion */
6539 for (roop_count = 0, tmp_key_hint = key_hint;
6540 roop_count < (int) table_share->keys; roop_count++, tmp_key_hint++)
6541 {
6542 tmp_key_hint->length(0);
6543 if (tmp_key_hint->append(spider_share->key_hint->ptr(),
6544 spider_share->key_hint->length(), system_charset_info))
6545 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6546 }
6547 } else {
6548 for (roop_count = 0, tmp_key_hint = key_hint;
6549 roop_count < (int) table_share->keys; roop_count++, tmp_key_hint++)
6550 {
6551 if (tmp_key_hint->copy(spider_share->key_hint[roop_count]))
6552 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6553 }
6554 }
6555 DBUG_RETURN(0);
6556 }
6557
append_show_table_status()6558 int spider_mbase_share::append_show_table_status()
6559 {
6560 int roop_count;
6561 spider_string *str;
6562 DBUG_ENTER("spider_mysql_append_show_table_status");
6563 if (!(show_table_status =
6564 new spider_string[2 * spider_share->all_link_count]))
6565 goto error;
6566
6567 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
6568 roop_count++)
6569 {
6570 show_table_status[0 + (2 * roop_count)].init_calc_mem(90);
6571 show_table_status[1 + (2 * roop_count)].init_calc_mem(91);
6572 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
6573 continue;
6574
6575 if (
6576 show_table_status[0 + (2 * roop_count)].reserve(
6577 SPIDER_SQL_SHOW_TABLE_STATUS_LEN +
6578 db_names_str[roop_count].length() +
6579 SPIDER_SQL_LIKE_LEN + table_names_str[roop_count].length() +
6580 ((SPIDER_SQL_NAME_QUOTE_LEN) * 2) +
6581 ((SPIDER_SQL_VALUE_QUOTE_LEN) * 2)) ||
6582 show_table_status[1 + (2 * roop_count)].reserve(
6583 SPIDER_SQL_SELECT_TABLES_STATUS_LEN +
6584 db_names_str[roop_count].length() +
6585 SPIDER_SQL_AND_LEN + SPIDER_SQL_TABLE_NAME_LEN + SPIDER_SQL_EQUAL_LEN +
6586 table_names_str[roop_count].length() +
6587 ((SPIDER_SQL_VALUE_QUOTE_LEN) * 4))
6588 )
6589 goto error;
6590 str = &show_table_status[0 + (2 * roop_count)];
6591 str->q_append(
6592 SPIDER_SQL_SHOW_TABLE_STATUS_STR, SPIDER_SQL_SHOW_TABLE_STATUS_LEN);
6593 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
6594 str->q_append(db_names_str[roop_count].ptr(),
6595 db_names_str[roop_count].length());
6596 str->q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
6597 str->q_append(SPIDER_SQL_LIKE_STR, SPIDER_SQL_LIKE_LEN);
6598 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6599 str->q_append(table_names_str[roop_count].ptr(),
6600 table_names_str[roop_count].length());
6601 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6602 str = &show_table_status[1 + (2 * roop_count)];
6603 str->q_append(
6604 SPIDER_SQL_SELECT_TABLES_STATUS_STR,
6605 SPIDER_SQL_SELECT_TABLES_STATUS_LEN);
6606 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6607 str->q_append(db_names_str[roop_count].ptr(),
6608 db_names_str[roop_count].length());
6609 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6610 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
6611 str->q_append(SPIDER_SQL_TABLE_NAME_STR, SPIDER_SQL_TABLE_NAME_LEN);
6612 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
6613 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6614 str->q_append(table_names_str[roop_count].ptr(),
6615 table_names_str[roop_count].length());
6616 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6617 }
6618 DBUG_RETURN(0);
6619
6620 error:
6621 if (show_table_status)
6622 {
6623 delete [] show_table_status;
6624 show_table_status = NULL;
6625 }
6626 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6627 }
6628
free_show_table_status()6629 void spider_mbase_share::free_show_table_status()
6630 {
6631 DBUG_ENTER("spider_mysql_free_show_table_status");
6632 if (show_table_status)
6633 {
6634 delete [] show_table_status;
6635 show_table_status = NULL;
6636 }
6637 DBUG_VOID_RETURN;
6638 }
6639
append_show_records()6640 int spider_mbase_share::append_show_records()
6641 {
6642 int roop_count;
6643 spider_string *str;
6644 DBUG_ENTER("spider_mbase_share::append_show_records");
6645 if (!(show_records = new spider_string[spider_share->all_link_count]))
6646 goto error;
6647
6648 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
6649 roop_count++)
6650 {
6651 show_records[roop_count].init_calc_mem(92);
6652 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
6653 continue;
6654
6655 if (
6656 show_records[roop_count].reserve(
6657 SPIDER_SQL_SHOW_RECORDS_LEN +
6658 db_names_str[roop_count].length() +
6659 SPIDER_SQL_DOT_LEN +
6660 table_names_str[roop_count].length() +
6661 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4)
6662 )
6663 goto error;
6664 str = &show_records[roop_count];
6665 str->q_append(SPIDER_SQL_SHOW_RECORDS_STR, SPIDER_SQL_SHOW_RECORDS_LEN);
6666 append_table_name(str, roop_count);
6667 }
6668 DBUG_RETURN(0);
6669
6670 error:
6671 if (show_records)
6672 {
6673 delete [] show_records;
6674 show_records = NULL;
6675 }
6676 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6677 }
6678
free_show_records()6679 void spider_mbase_share::free_show_records()
6680 {
6681 DBUG_ENTER("spider_mbase_share::free_show_records");
6682 if (show_records)
6683 {
6684 delete [] show_records;
6685 show_records = NULL;
6686 }
6687 DBUG_VOID_RETURN;
6688 }
6689
append_show_index()6690 int spider_mbase_share::append_show_index()
6691 {
6692 int roop_count;
6693 spider_string *str;
6694 DBUG_ENTER("spider_mbase_share::append_show_index");
6695 if (!(show_index = new spider_string[2 * spider_share->all_link_count]))
6696 goto error;
6697
6698 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
6699 roop_count++)
6700 {
6701 show_index[0 + (2 * roop_count)].init_calc_mem(93);
6702 show_index[1 + (2 * roop_count)].init_calc_mem(94);
6703 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
6704 continue;
6705
6706 if (
6707 show_index[0 + (2 * roop_count)].reserve(
6708 SPIDER_SQL_SHOW_INDEX_LEN + db_names_str[roop_count].length() +
6709 SPIDER_SQL_DOT_LEN +
6710 table_names_str[roop_count].length() +
6711 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4) ||
6712 show_index[1 + (2 * roop_count)].reserve(
6713 SPIDER_SQL_SELECT_STATISTICS_LEN +
6714 db_names_str[roop_count].length() +
6715 SPIDER_SQL_AND_LEN + SPIDER_SQL_TABLE_NAME_LEN + SPIDER_SQL_EQUAL_LEN +
6716 table_names_str[roop_count].length() +
6717 ((SPIDER_SQL_VALUE_QUOTE_LEN) * 4) +
6718 SPIDER_SQL_GROUP_LEN + SPIDER_SQL_COLUMN_NAME_LEN)
6719 )
6720 goto error;
6721 str = &show_index[0 + (2 * roop_count)];
6722 str->q_append(
6723 SPIDER_SQL_SHOW_INDEX_STR, SPIDER_SQL_SHOW_INDEX_LEN);
6724 append_table_name(str, roop_count);
6725 str = &show_index[1 + (2 * roop_count)];
6726 str->q_append(
6727 SPIDER_SQL_SELECT_STATISTICS_STR, SPIDER_SQL_SELECT_STATISTICS_LEN);
6728 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6729 str->q_append(db_names_str[roop_count].ptr(),
6730 db_names_str[roop_count].length());
6731 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6732 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
6733 str->q_append(SPIDER_SQL_TABLE_NAME_STR, SPIDER_SQL_TABLE_NAME_LEN);
6734 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
6735 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6736 str->q_append(table_names_str[roop_count].ptr(),
6737 table_names_str[roop_count].length());
6738 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6739 str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN);
6740 str->q_append(SPIDER_SQL_COLUMN_NAME_STR, SPIDER_SQL_COLUMN_NAME_LEN);
6741 }
6742 DBUG_RETURN(0);
6743
6744 error:
6745 if (show_index)
6746 {
6747 delete [] show_index;
6748 show_index = NULL;
6749 }
6750 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6751 }
6752
free_show_index()6753 void spider_mbase_share::free_show_index()
6754 {
6755 DBUG_ENTER("spider_mbase_share::free_show_index");
6756 if (show_index)
6757 {
6758 delete [] show_index;
6759 show_index = NULL;
6760 }
6761 DBUG_VOID_RETURN;
6762 }
6763
append_table_select()6764 int spider_mbase_share::append_table_select()
6765 {
6766 Field **field;
6767 uint field_length;
6768 spider_string *str = table_select;
6769 TABLE_SHARE *table_share = spider_share->table_share;
6770 DBUG_ENTER("spider_mbase_share::append_table_select");
6771
6772 if (!*table_share->field)
6773 DBUG_RETURN(0);
6774
6775 for (field = table_share->field; *field; field++)
6776 {
6777 field_length = column_name_str[(*field)->field_index].length();
6778 if (str->reserve(field_length +
6779 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
6780 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6781 append_column_name(str, (*field)->field_index);
6782 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
6783 }
6784 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
6785 DBUG_RETURN(append_from_with_adjusted_table_name(str, &table_select_pos));
6786 }
6787
append_key_select(uint idx)6788 int spider_mbase_share::append_key_select(
6789 uint idx
6790 ) {
6791 KEY_PART_INFO *key_part;
6792 Field *field;
6793 uint part_num;
6794 uint field_length;
6795 spider_string *str = &key_select[idx];
6796 TABLE_SHARE *table_share = spider_share->table_share;
6797 const KEY *key_info = &table_share->key_info[idx];
6798 DBUG_ENTER("spider_mbase_share::append_key_select");
6799
6800 if (!spider_user_defined_key_parts(key_info))
6801 DBUG_RETURN(0);
6802
6803 for (key_part = key_info->key_part, part_num = 0;
6804 part_num < spider_user_defined_key_parts(key_info); key_part++, part_num++)
6805 {
6806 field = key_part->field;
6807 field_length = column_name_str[field->field_index].length();
6808 if (str->reserve(field_length +
6809 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
6810 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6811 append_column_name(str, field->field_index);
6812 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
6813 }
6814 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
6815 DBUG_RETURN(append_from_with_adjusted_table_name(str, &key_select_pos[idx]));
6816 }
6817
need_change_db_table_name()6818 bool spider_mbase_share::need_change_db_table_name()
6819 {
6820 DBUG_ENTER("spider_mbase_share::need_change_db_table_name");
6821 DBUG_RETURN(!same_db_table_name);
6822 }
6823
6824 #ifdef SPIDER_HAS_DISCOVER_TABLE_STRUCTURE
discover_table_structure(SPIDER_TRX * trx,SPIDER_SHARE * spider_share,spider_string * str)6825 int spider_mbase_share::discover_table_structure(
6826 SPIDER_TRX *trx,
6827 SPIDER_SHARE *spider_share,
6828 spider_string *str
6829 ) {
6830 int roop_count, error_num = HA_ERR_WRONG_COMMAND;
6831 char sql_buf[MAX_FIELD_WIDTH];
6832 spider_string sql_str(sql_buf, sizeof(sql_buf), system_charset_info);
6833 uint strlen = str->length();
6834 DBUG_ENTER("spider_mbase_share::discover_table_structure");
6835 DBUG_PRINT("info",("spider this=%p", this));
6836 sql_str.init_calc_mem(228);
6837 for (roop_count = 0; roop_count < (int) spider_share->all_link_count;
6838 roop_count++)
6839 {
6840 if (spider_share->sql_dbton_ids[roop_count] != dbton_id)
6841 {
6842 DBUG_PRINT("info",("spider spider_share->sql_dbton_ids[%d]=%u",
6843 roop_count, spider_share->sql_dbton_ids[roop_count]));
6844 DBUG_PRINT("info",("spider dbton_id=%u", dbton_id));
6845 continue;
6846 }
6847
6848 str->length(strlen);
6849 sql_str.length(0);
6850 if (sql_str.reserve(
6851 SPIDER_SQL_SELECT_COLUMNS_LEN + db_names_str[roop_count].length() +
6852 SPIDER_SQL_AND_LEN + SPIDER_SQL_TABLE_NAME_LEN + SPIDER_SQL_EQUAL_LEN +
6853 table_names_str[roop_count].length() + SPIDER_SQL_ORDER_LEN +
6854 SPIDER_SQL_ORDINAL_POSITION_LEN +
6855 /* SPIDER_SQL_VALUE_QUOTE_LEN */ 8 +
6856 SPIDER_SQL_SEMICOLON_LEN +
6857 SPIDER_SQL_SHOW_INDEX_LEN + db_names_str[roop_count].length() +
6858 SPIDER_SQL_DOT_LEN + table_names_str[roop_count].length() +
6859 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 +
6860 SPIDER_SQL_SEMICOLON_LEN +
6861 SPIDER_SQL_SHOW_TABLE_STATUS_LEN + db_names_str[roop_count].length() +
6862 SPIDER_SQL_LIKE_LEN + table_names_str[roop_count].length() +
6863 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4
6864 )) {
6865 DBUG_PRINT("info",("spider alloc sql_str error"));
6866 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
6867 }
6868 sql_str.q_append(SPIDER_SQL_SELECT_COLUMNS_STR,
6869 SPIDER_SQL_SELECT_COLUMNS_LEN);
6870 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6871 sql_str.q_append(db_names_str[roop_count].ptr(),
6872 db_names_str[roop_count].length());
6873 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6874 sql_str.q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
6875 sql_str.q_append(SPIDER_SQL_TABLE_NAME_STR, SPIDER_SQL_TABLE_NAME_LEN);
6876 sql_str.q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
6877 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6878 sql_str.q_append(table_names_str[roop_count].ptr(),
6879 table_names_str[roop_count].length());
6880 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6881 sql_str.q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
6882 sql_str.q_append(SPIDER_SQL_ORDINAL_POSITION_STR,
6883 SPIDER_SQL_ORDINAL_POSITION_LEN);
6884 sql_str.q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
6885 sql_str.q_append(SPIDER_SQL_SHOW_INDEX_STR, SPIDER_SQL_SHOW_INDEX_LEN);
6886 append_table_name(&sql_str, roop_count);
6887 sql_str.q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
6888 sql_str.q_append(
6889 SPIDER_SQL_SHOW_TABLE_STATUS_STR, SPIDER_SQL_SHOW_TABLE_STATUS_LEN);
6890 sql_str.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
6891 sql_str.q_append(db_names_str[roop_count].ptr(),
6892 db_names_str[roop_count].length());
6893 sql_str.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
6894 sql_str.q_append(SPIDER_SQL_LIKE_STR, SPIDER_SQL_LIKE_LEN);
6895 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6896 sql_str.q_append(table_names_str[roop_count].ptr(),
6897 table_names_str[roop_count].length());
6898 sql_str.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
6899
6900 SPIDER_CONN *conn;
6901 int need_mon;
6902 if (!(conn = spider_get_conn(
6903 spider_share, 0, spider_share->conn_keys[roop_count], trx, NULL, FALSE,
6904 FALSE, SPIDER_CONN_KIND_MYSQL, &error_num))
6905 ) {
6906 DBUG_RETURN(error_num);
6907 }
6908 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
6909 pthread_mutex_lock(&conn->mta_conn_mutex);
6910 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
6911 conn->need_mon = &need_mon;
6912 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
6913 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
6914 conn->mta_conn_mutex_lock_already = TRUE;
6915 conn->mta_conn_mutex_unlock_later = TRUE;
6916 if (!conn->disable_reconnect)
6917 {
6918 ha_spider tmp_spider;
6919 int need_mon = 0;
6920 uint tmp_conn_link_idx = 0;
6921 tmp_spider.trx = trx;
6922 tmp_spider.share = spider_share;
6923 tmp_spider.need_mons = &need_mon;
6924 tmp_spider.conn_link_idx = &tmp_conn_link_idx;
6925 if ((error_num = spider_db_ping(&tmp_spider, conn, 0)))
6926 {
6927 DBUG_PRINT("info",("spider spider_db_ping error"));
6928 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6929 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6930 conn->mta_conn_mutex_lock_already = FALSE;
6931 conn->mta_conn_mutex_unlock_later = FALSE;
6932 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6933 pthread_mutex_unlock(&conn->mta_conn_mutex);
6934 continue;
6935 }
6936 }
6937 spider_conn_set_timeout_from_share(conn, roop_count, trx->thd,
6938 spider_share);
6939 if (
6940 (error_num = spider_db_set_names_internal(trx, spider_share, conn,
6941 roop_count, &need_mon)) ||
6942 (
6943 spider_db_query(
6944 conn,
6945 sql_str.ptr(),
6946 sql_str.length(),
6947 -1,
6948 &need_mon) &&
6949 (error_num = spider_db_errorno(conn))
6950 )
6951 ) {
6952 DBUG_PRINT("info",("spider spider_get_trx error"));
6953 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6954 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6955 conn->mta_conn_mutex_lock_already = FALSE;
6956 conn->mta_conn_mutex_unlock_later = FALSE;
6957 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6958 pthread_mutex_unlock(&conn->mta_conn_mutex);
6959 continue;
6960 }
6961 st_spider_db_request_key request_key;
6962 request_key.spider_thread_id = trx->spider_thread_id;
6963 request_key.query_id = trx->thd->query_id;
6964 request_key.handler = NULL;
6965 request_key.request_id = 1;
6966 request_key.next = NULL;
6967 spider_db_result *res;
6968 /* get column list */
6969 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
6970 {
6971 if (error_num || (error_num = spider_db_errorno(conn)))
6972 {
6973 DBUG_PRINT("info",("spider column store error"));
6974 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6975 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6976 conn->mta_conn_mutex_lock_already = FALSE;
6977 conn->mta_conn_mutex_unlock_later = FALSE;
6978 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6979 pthread_mutex_unlock(&conn->mta_conn_mutex);
6980 continue;
6981 }
6982 /* no record */
6983 DBUG_PRINT("info",("spider column no record error"));
6984 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6985 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
6986 conn->mta_conn_mutex_lock_already = FALSE;
6987 conn->mta_conn_mutex_unlock_later = FALSE;
6988 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
6989 pthread_mutex_unlock(&conn->mta_conn_mutex);
6990 continue;
6991 }
6992 if ((error_num = res->fetch_columns_for_discover_table_structure(str,
6993 spider_share->access_charset)))
6994 {
6995 DBUG_PRINT("info",("spider column fetch error"));
6996 res->free_result();
6997 delete res;
6998 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
6999 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7000 conn->mta_conn_mutex_lock_already = FALSE;
7001 conn->mta_conn_mutex_unlock_later = FALSE;
7002 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7003 pthread_mutex_unlock(&conn->mta_conn_mutex);
7004 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
7005 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
7006 db_names_str[roop_count].ptr(),
7007 table_names_str[roop_count].ptr());
7008 error_num = ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM;
7009 continue;
7010 }
7011 res->free_result();
7012 delete res;
7013 if (conn->db_conn->next_result())
7014 {
7015 DBUG_PRINT("info",("spider single result error"));
7016 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7017 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7018 conn->mta_conn_mutex_lock_already = FALSE;
7019 conn->mta_conn_mutex_unlock_later = FALSE;
7020 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7021 pthread_mutex_unlock(&conn->mta_conn_mutex);
7022 continue;
7023 }
7024 /* get index list */
7025 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
7026 {
7027 if (error_num || (error_num = spider_db_errorno(conn)))
7028 {
7029 DBUG_PRINT("info",("spider index store error"));
7030 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7031 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7032 conn->mta_conn_mutex_lock_already = FALSE;
7033 conn->mta_conn_mutex_unlock_later = FALSE;
7034 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7035 pthread_mutex_unlock(&conn->mta_conn_mutex);
7036 continue;
7037 }
7038 /* no record */
7039 DBUG_PRINT("info",("spider index no record error"));
7040 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7041 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7042 conn->mta_conn_mutex_lock_already = FALSE;
7043 conn->mta_conn_mutex_unlock_later = FALSE;
7044 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7045 pthread_mutex_unlock(&conn->mta_conn_mutex);
7046 continue;
7047 }
7048 if ((error_num = res->fetch_index_for_discover_table_structure(str,
7049 spider_share->access_charset)))
7050 {
7051 DBUG_PRINT("info",("spider index fetch error"));
7052 res->free_result();
7053 delete res;
7054 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7055 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7056 conn->mta_conn_mutex_lock_already = FALSE;
7057 conn->mta_conn_mutex_unlock_later = FALSE;
7058 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7059 pthread_mutex_unlock(&conn->mta_conn_mutex);
7060 continue;
7061 }
7062 res->free_result();
7063 delete res;
7064 if (conn->db_conn->next_result())
7065 {
7066 DBUG_PRINT("info",("spider dual result error"));
7067 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7068 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7069 conn->mta_conn_mutex_lock_already = FALSE;
7070 conn->mta_conn_mutex_unlock_later = FALSE;
7071 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7072 pthread_mutex_unlock(&conn->mta_conn_mutex);
7073 continue;
7074 }
7075 /* get table info */
7076 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
7077 {
7078 if (error_num || (error_num = spider_db_errorno(conn)))
7079 {
7080 DBUG_PRINT("info",("spider table store error"));
7081 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7082 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7083 conn->mta_conn_mutex_lock_already = FALSE;
7084 conn->mta_conn_mutex_unlock_later = FALSE;
7085 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7086 pthread_mutex_unlock(&conn->mta_conn_mutex);
7087 continue;
7088 }
7089 /* no record */
7090 DBUG_PRINT("info",("spider table no record error"));
7091 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7092 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7093 conn->mta_conn_mutex_lock_already = FALSE;
7094 conn->mta_conn_mutex_unlock_later = FALSE;
7095 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7096 pthread_mutex_unlock(&conn->mta_conn_mutex);
7097 continue;
7098 }
7099 if ((error_num = res->fetch_table_for_discover_table_structure(str,
7100 spider_share, spider_share->access_charset)))
7101 {
7102 DBUG_PRINT("info",("spider table fetch error"));
7103 res->free_result();
7104 delete res;
7105 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7106 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7107 conn->mta_conn_mutex_lock_already = FALSE;
7108 conn->mta_conn_mutex_unlock_later = FALSE;
7109 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7110 pthread_mutex_unlock(&conn->mta_conn_mutex);
7111 continue;
7112 }
7113 res->free_result();
7114 delete res;
7115 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
7116 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
7117 conn->mta_conn_mutex_lock_already = FALSE;
7118 conn->mta_conn_mutex_unlock_later = FALSE;
7119 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
7120 pthread_mutex_unlock(&conn->mta_conn_mutex);
7121 if (!error_num)
7122 break;
7123 }
7124 DBUG_RETURN(error_num);
7125 }
7126 #endif
7127
spider_mbase_handler(ha_spider * spider,spider_mbase_share * db_share,spider_db_mbase_util * spider_db_mbase_utility)7128 spider_mbase_handler::spider_mbase_handler(
7129 ha_spider *spider,
7130 spider_mbase_share *db_share,
7131 spider_db_mbase_util *spider_db_mbase_utility
7132 ) : spider_db_handler(
7133 spider,
7134 db_share
7135 ),
7136 spider_db_mbase_utility(spider_db_mbase_utility),
7137 where_pos(0),
7138 order_pos(0),
7139 limit_pos(0),
7140 table_name_pos(0),
7141 ha_read_pos(0),
7142 ha_next_pos(0),
7143 ha_where_pos(0),
7144 ha_limit_pos(0),
7145 ha_table_name_pos(0),
7146 insert_pos(0),
7147 insert_table_name_pos(0),
7148 upd_tmp_tbl(NULL),
7149 tmp_sql_pos1(0),
7150 tmp_sql_pos2(0),
7151 tmp_sql_pos3(0),
7152 tmp_sql_pos4(0),
7153 tmp_sql_pos5(0),
7154 reading_from_bulk_tmp_table(FALSE),
7155 union_table_name_pos_first(NULL),
7156 union_table_name_pos_current(NULL),
7157 mysql_share(db_share),
7158 link_for_hash(NULL)
7159 {
7160 DBUG_ENTER("spider_mbase_handler::spider_mbase_handler");
7161 DBUG_PRINT("info",("spider this=%p", this));
7162 spider_alloc_calc_mem_init(mem_calc, 183);
7163 spider_alloc_calc_mem(spider_current_trx, mem_calc, sizeof(*this));
7164 DBUG_VOID_RETURN;
7165 }
7166
spider_mysql_handler(ha_spider * spider,spider_mbase_share * db_share)7167 spider_mysql_handler::spider_mysql_handler(
7168 ha_spider *spider,
7169 spider_mbase_share *db_share
7170 ) : spider_mbase_handler(
7171 spider,
7172 db_share,
7173 &spider_db_mysql_utility
7174 ) {
7175 DBUG_ENTER("spider_mysql_handler::spider_mysql_handler");
7176 DBUG_PRINT("info",("spider this=%p", this));
7177 DBUG_VOID_RETURN;
7178 }
7179
spider_mariadb_handler(ha_spider * spider,spider_mbase_share * db_share)7180 spider_mariadb_handler::spider_mariadb_handler(
7181 ha_spider *spider,
7182 spider_mbase_share *db_share
7183 ) : spider_mbase_handler(
7184 spider,
7185 db_share,
7186 &spider_db_mariadb_utility
7187 ) {
7188 DBUG_ENTER("spider_mariadb_handler::spider_mariadb_handler");
7189 DBUG_PRINT("info",("spider this=%p", this));
7190 DBUG_VOID_RETURN;
7191 }
7192
~spider_mbase_handler()7193 spider_mbase_handler::~spider_mbase_handler()
7194 {
7195 DBUG_ENTER("spider_mbase_handler::~spider_mbase_handler");
7196 DBUG_PRINT("info",("spider this=%p", this));
7197 while (union_table_name_pos_first)
7198 {
7199 SPIDER_INT_HLD *tmp_pos = union_table_name_pos_first;
7200 union_table_name_pos_first = tmp_pos->next;
7201 spider_free(spider_current_trx, tmp_pos, MYF(0));
7202 }
7203 if (link_for_hash)
7204 {
7205 spider_free(spider_current_trx, link_for_hash, MYF(0));
7206 }
7207 spider_free_mem_calc(spider_current_trx, mem_calc_id, sizeof(*this));
7208 DBUG_VOID_RETURN;
7209 }
7210
~spider_mysql_handler()7211 spider_mysql_handler::~spider_mysql_handler()
7212 {
7213 DBUG_ENTER("spider_mysql_handler::~spider_mysql_handler");
7214 DBUG_PRINT("info",("spider this=%p", this));
7215 DBUG_VOID_RETURN;
7216 }
7217
~spider_mariadb_handler()7218 spider_mariadb_handler::~spider_mariadb_handler()
7219 {
7220 DBUG_ENTER("spider_mariadb_handler::~spider_mariadb_handler");
7221 DBUG_PRINT("info",("spider this=%p", this));
7222 DBUG_VOID_RETURN;
7223 }
7224
init()7225 int spider_mbase_handler::init()
7226 {
7227 uint roop_count;
7228 THD *thd = spider->trx->thd;
7229 st_spider_share *share = spider->share;
7230 int init_sql_alloc_size =
7231 spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
7232 TABLE *table = spider->get_table();
7233 DBUG_ENTER("spider_mbase_handler::init");
7234 DBUG_PRINT("info",("spider this=%p", this));
7235 sql.init_calc_mem(59);
7236 sql_part.init_calc_mem(60);
7237 sql_part2.init_calc_mem(61);
7238 ha_sql.init_calc_mem(62);
7239 insert_sql.init_calc_mem(64);
7240 update_sql.init_calc_mem(65);
7241 tmp_sql.init_calc_mem(66);
7242 dup_update_sql.init_calc_mem(166);
7243 if (
7244 (sql.real_alloc(init_sql_alloc_size)) ||
7245 (insert_sql.real_alloc(init_sql_alloc_size)) ||
7246 (update_sql.real_alloc(init_sql_alloc_size)) ||
7247 (tmp_sql.real_alloc(init_sql_alloc_size))
7248 ) {
7249 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7250 }
7251 sql.set_charset(share->access_charset);
7252 sql_part.set_charset(share->access_charset);
7253 ha_sql.set_charset(share->access_charset);
7254 insert_sql.set_charset(share->access_charset);
7255 update_sql.set_charset(share->access_charset);
7256 tmp_sql.set_charset(share->access_charset);
7257 upd_tmp_tbl_prm.init();
7258 upd_tmp_tbl_prm.field_count = 1;
7259 if (!(link_for_hash = (SPIDER_LINK_FOR_HASH *)
7260 spider_bulk_alloc_mem(spider_current_trx, 141,
7261 __func__, __FILE__, __LINE__, MYF(MY_WME | MY_ZEROFILL),
7262 &link_for_hash,
7263 sizeof(SPIDER_LINK_FOR_HASH) * share->link_count,
7264 &minimum_select_bitmap,
7265 table ? sizeof(uchar) * no_bytes_in_map(table->read_set) : 0,
7266 NullS))
7267 ) {
7268 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7269 }
7270 for (roop_count = 0; roop_count < share->link_count; roop_count++)
7271 {
7272 link_for_hash[roop_count].spider = spider;
7273 link_for_hash[roop_count].link_idx = roop_count;
7274 link_for_hash[roop_count].db_table_str =
7275 &mysql_share->db_table_str[roop_count];
7276 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
7277 link_for_hash[roop_count].db_table_str_hash_value =
7278 mysql_share->db_table_str_hash_value[roop_count];
7279 #endif
7280 }
7281 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
7282 hs_upds.init();
7283 #endif
7284 DBUG_RETURN(0);
7285 }
7286
7287
append_index_hint(spider_string * str,int link_idx,ulong sql_type)7288 int spider_mbase_handler::append_index_hint(
7289 spider_string *str,
7290 int link_idx,
7291 ulong sql_type
7292 )
7293 {
7294 List<Index_hint> *index_hints = spider_get_index_hints(spider);
7295 List_iterator <Index_hint> iter(*index_hints);
7296 Index_hint *hint;
7297 // THD *thd = current_thd;
7298 int error_num = 0;
7299 DBUG_ENTER("spider_mbase_handler::append_index_hint");
7300 DBUG_PRINT("info",("spider this=%p", this));
7301
7302 while(index_hints && (hint = iter++))
7303 {
7304 // hint->print(thd, str);
7305 if (sql_type != SPIDER_SQL_TYPE_HANDLER)
7306 {
7307 switch(hint->type)
7308 {
7309 case INDEX_HINT_IGNORE:
7310 if (str->reserve(hint->key_name.length+ SPIDER_SQL_INDEX_IGNORE_LEN + SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
7311 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7312 str->q_append(SPIDER_SQL_INDEX_IGNORE_STR,SPIDER_SQL_INDEX_IGNORE_LEN);
7313 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,SPIDER_SQL_OPEN_PAREN_LEN);
7314 str->q_append(hint->key_name.str, hint->key_name.length);
7315 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,SPIDER_SQL_CLOSE_PAREN_LEN);
7316 break;
7317 case INDEX_HINT_USE:
7318 if (str->reserve(hint->key_name.length+ SPIDER_SQL_INDEX_USE_LEN + SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
7319 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7320 str->q_append(SPIDER_SQL_INDEX_USE_STR,SPIDER_SQL_INDEX_USE_LEN);
7321 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,SPIDER_SQL_OPEN_PAREN_LEN);
7322 str->q_append(hint->key_name.str, hint->key_name.length);
7323 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,SPIDER_SQL_CLOSE_PAREN_LEN);
7324 break;
7325 case INDEX_HINT_FORCE:
7326 if (str->reserve(hint->key_name.length+ SPIDER_SQL_INDEX_FORCE_LEN + SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_CLOSE_PAREN_LEN))
7327 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7328 str->q_append(SPIDER_SQL_INDEX_FORCE_STR,SPIDER_SQL_INDEX_FORCE_LEN);
7329 str->q_append(SPIDER_SQL_OPEN_PAREN_STR,SPIDER_SQL_OPEN_PAREN_LEN);
7330 str->q_append(hint->key_name.str, hint->key_name.length);
7331 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR,SPIDER_SQL_CLOSE_PAREN_LEN);
7332 break;
7333 default:
7334 // SPIDER_SQL_COMMA_STR
7335 break;
7336 }
7337 }
7338 }
7339 DBUG_RETURN(error_num);
7340 }
7341
append_table_name_with_adjusting(spider_string * str,int link_idx,ulong sql_type)7342 int spider_mbase_handler::append_table_name_with_adjusting(
7343 spider_string *str,
7344 int link_idx,
7345 ulong sql_type
7346 ) {
7347 int error_num = 0;
7348 DBUG_ENTER("spider_mbase_handler::append_table_name_with_adjusting");
7349 DBUG_PRINT("info",("spider this=%p", this));
7350 if (sql_type == SPIDER_SQL_TYPE_HANDLER)
7351 {
7352 str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN);
7353 } else {
7354 error_num = mysql_share->append_table_name_with_adjusting(str,
7355 spider->conn_link_idx[link_idx]);
7356 }
7357 DBUG_RETURN(error_num);
7358 }
7359
append_key_column_types(const key_range * start_key,spider_string * str)7360 int spider_mbase_handler::append_key_column_types(
7361 const key_range *start_key,
7362 spider_string *str
7363 ) {
7364 SPIDER_RESULT_LIST *result_list = &spider->result_list;
7365 KEY *key_info = result_list->key_info;
7366 uint key_name_length, key_count;
7367 key_part_map full_key_part_map =
7368 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
7369 key_part_map start_key_part_map;
7370 KEY_PART_INFO *key_part;
7371 Field *field;
7372 char tmp_buf[MAX_FIELD_WIDTH];
7373 spider_string tmp_str(tmp_buf, sizeof(tmp_buf), system_charset_info);
7374 DBUG_ENTER("spider_mbase_handler::append_key_column_types");
7375 DBUG_PRINT("info",("spider this=%p", this));
7376 tmp_str.init_calc_mem(115);
7377
7378 start_key_part_map = start_key->keypart_map & full_key_part_map;
7379 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
7380 spider_user_defined_key_parts(key_info)));
7381 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
7382 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
7383
7384 if (!start_key_part_map)
7385 DBUG_RETURN(0);
7386
7387 for (
7388 key_part = key_info->key_part,
7389 key_count = 0;
7390 start_key_part_map;
7391 start_key_part_map >>= 1,
7392 key_part++,
7393 key_count++
7394 ) {
7395 field = key_part->field;
7396 key_name_length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count));
7397 if (str->reserve(key_name_length + SPIDER_SQL_SPACE_LEN))
7398 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7399 str->q_append(tmp_buf, key_name_length);
7400 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
7401
7402 if (tmp_str.ptr() != tmp_buf)
7403 tmp_str.set(tmp_buf, sizeof(tmp_buf), system_charset_info);
7404 else
7405 tmp_str.set_charset(system_charset_info);
7406 field->sql_type(*tmp_str.get_str());
7407 tmp_str.mem_calc();
7408 str->append(tmp_str);
7409 if (field->has_charset())
7410 {
7411 CHARSET_INFO *cs = field->charset();
7412 uint coll_length = strlen(cs->name);
7413 if (str->reserve(SPIDER_SQL_COLLATE_LEN + coll_length))
7414 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7415 str->q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
7416 str->q_append(cs->name, coll_length);
7417 }
7418
7419 if (str->reserve(SPIDER_SQL_COMMA_LEN))
7420 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7421 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7422 }
7423 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
7424
7425 DBUG_RETURN(0);
7426 }
7427
append_key_join_columns_for_bka(const key_range * start_key,spider_string * str,const char ** table_aliases,uint * table_alias_lengths)7428 int spider_mbase_handler::append_key_join_columns_for_bka(
7429 const key_range *start_key,
7430 spider_string *str,
7431 const char **table_aliases,
7432 uint *table_alias_lengths
7433 ) {
7434 KEY *key_info = spider->result_list.key_info;
7435 uint length, key_name_length, key_count;
7436 key_part_map full_key_part_map =
7437 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
7438 key_part_map start_key_part_map;
7439 KEY_PART_INFO *key_part;
7440 Field *field;
7441 char tmp_buf[MAX_FIELD_WIDTH];
7442 bool start_where = ((int) str->length() == where_pos);
7443 DBUG_ENTER("spider_mbase_handler::append_key_join_columns_for_bka");
7444 DBUG_PRINT("info",("spider this=%p", this));
7445 start_key_part_map = start_key->keypart_map & full_key_part_map;
7446 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
7447 spider_user_defined_key_parts(key_info)));
7448 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
7449 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
7450
7451 if (!start_key_part_map)
7452 DBUG_RETURN(0);
7453
7454 if (start_where)
7455 {
7456 if (str->reserve(SPIDER_SQL_WHERE_LEN))
7457 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7458 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
7459 } else {
7460 if (str->reserve(SPIDER_SQL_AND_LEN))
7461 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7462 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
7463 }
7464
7465 for (
7466 key_part = key_info->key_part,
7467 key_count = 0;
7468 start_key_part_map;
7469 start_key_part_map >>= 1,
7470 key_part++,
7471 key_count++
7472 ) {
7473 field = key_part->field;
7474 key_name_length =
7475 mysql_share->column_name_str[field->field_index].length();
7476 length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count));
7477 if (str->reserve(length + table_alias_lengths[0] + key_name_length +
7478 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
7479 table_alias_lengths[1] + SPIDER_SQL_PF_EQUAL_LEN + SPIDER_SQL_AND_LEN))
7480 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7481 str->q_append(table_aliases[0], table_alias_lengths[0]);
7482 str->q_append(tmp_buf, length);
7483 str->q_append(SPIDER_SQL_PF_EQUAL_STR, SPIDER_SQL_PF_EQUAL_LEN);
7484 str->q_append(table_aliases[1], table_alias_lengths[1]);
7485 mysql_share->append_column_name(str, field->field_index);
7486 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
7487 }
7488 str->length(str->length() - SPIDER_SQL_AND_LEN);
7489 DBUG_RETURN(0);
7490 }
7491
append_tmp_table_and_sql_for_bka(const key_range * start_key)7492 int spider_mbase_handler::append_tmp_table_and_sql_for_bka(
7493 const key_range *start_key
7494 ) {
7495 int error_num;
7496 DBUG_ENTER("spider_mbase_handler::append_tmp_table_and_sql_for_bka");
7497 DBUG_PRINT("info",("spider this=%p", this));
7498 char tmp_table_name[MAX_FIELD_WIDTH * 2],
7499 tgt_table_name[MAX_FIELD_WIDTH * 2];
7500 int tmp_table_name_length;
7501 spider_string tgt_table_name_str(tgt_table_name, MAX_FIELD_WIDTH * 2,
7502 mysql_share->db_names_str[0].charset());
7503 const char *table_names[2], *table_aliases[2], *table_dot_aliases[2];
7504 uint table_name_lengths[2], table_alias_lengths[2],
7505 table_dot_alias_lengths[2];
7506 tgt_table_name_str.init_calc_mem(99);
7507 tgt_table_name_str.length(0);
7508 create_tmp_bka_table_name(tmp_table_name, &tmp_table_name_length,
7509 first_link_idx);
7510 if ((error_num = append_table_name_with_adjusting(&tgt_table_name_str,
7511 first_link_idx, SPIDER_SQL_TYPE_SELECT_SQL)))
7512 {
7513 DBUG_RETURN(error_num);
7514 }
7515 table_names[0] = tmp_table_name;
7516 table_names[1] = tgt_table_name_str.c_ptr_safe();
7517 table_name_lengths[0] = tmp_table_name_length;
7518 table_name_lengths[1] = tgt_table_name_str.length();
7519 table_aliases[0] = SPIDER_SQL_A_STR;
7520 table_aliases[1] = SPIDER_SQL_B_STR;
7521 table_alias_lengths[0] = SPIDER_SQL_A_LEN;
7522 table_alias_lengths[1] = SPIDER_SQL_B_LEN;
7523 table_dot_aliases[0] = SPIDER_SQL_A_DOT_STR;
7524 table_dot_aliases[1] = SPIDER_SQL_B_DOT_STR;
7525 table_dot_alias_lengths[0] = SPIDER_SQL_A_DOT_LEN;
7526 table_dot_alias_lengths[1] = SPIDER_SQL_B_DOT_LEN;
7527 if (
7528 (error_num = append_drop_tmp_bka_table(
7529 &tmp_sql, tmp_table_name, tmp_table_name_length,
7530 &tmp_sql_pos1, &tmp_sql_pos5, TRUE)) ||
7531 (error_num = append_create_tmp_bka_table(
7532 start_key,
7533 &tmp_sql, tmp_table_name,
7534 tmp_table_name_length,
7535 &tmp_sql_pos2, spider->share->table_share->table_charset)) ||
7536 (error_num = append_insert_tmp_bka_table(
7537 start_key,
7538 &tmp_sql, tmp_table_name,
7539 tmp_table_name_length, &tmp_sql_pos3))
7540 )
7541 DBUG_RETURN(error_num);
7542 tmp_sql_pos4 = tmp_sql.length();
7543 if ((error_num = spider_db_append_select(spider)))
7544 DBUG_RETURN(error_num);
7545 if (sql.reserve(SPIDER_SQL_A_DOT_LEN + SPIDER_SQL_ID_LEN +
7546 SPIDER_SQL_COMMA_LEN))
7547 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7548 sql.q_append(SPIDER_SQL_A_DOT_STR, SPIDER_SQL_A_DOT_LEN);
7549 sql.q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN);
7550 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7551 if (
7552 (error_num = append_select_columns_with_alias(&sql,
7553 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)) ||
7554 (error_num = spider_db_mbase_utility->append_from_with_alias(&sql,
7555 table_names, table_name_lengths,
7556 table_aliases, table_alias_lengths, 2,
7557 &table_name_pos, FALSE))
7558 )
7559 DBUG_RETURN(error_num);
7560 if (
7561 mysql_share->key_hint &&
7562 (error_num = spider_db_append_hint_after_table(spider,
7563 &sql, &mysql_share->key_hint[spider->active_index]))
7564 )
7565 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7566 where_pos = sql.length();
7567 if (
7568 (error_num = append_key_join_columns_for_bka(
7569 start_key, &sql,
7570 table_dot_aliases, table_dot_alias_lengths)) ||
7571 (error_num = append_condition_part(
7572 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN,
7573 SPIDER_SQL_TYPE_SELECT_SQL, FALSE))
7574 )
7575 DBUG_RETURN(error_num);
7576 if (spider->result_list.direct_order_limit)
7577 {
7578 if ((error_num = append_key_order_for_direct_order_limit_with_alias(&sql,
7579 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)))
7580 DBUG_RETURN(error_num);
7581 }
7582 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
7583 else if (spider->result_list.direct_aggregate)
7584 {
7585 if ((error_num =
7586 append_group_by(&sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)))
7587 DBUG_RETURN(error_num);
7588 }
7589 #endif
7590
7591 DBUG_RETURN(0);
7592 }
7593
reuse_tmp_table_and_sql_for_bka()7594 int spider_mbase_handler::reuse_tmp_table_and_sql_for_bka()
7595 {
7596 DBUG_ENTER("spider_mbase_handler::reuse_tmp_table_and_sql_for_bka");
7597 DBUG_PRINT("info",("spider this=%p", this));
7598 tmp_sql.length(tmp_sql_pos4);
7599 sql.length(limit_pos);
7600 ha_sql.length(ha_limit_pos);
7601 DBUG_RETURN(0);
7602 }
7603
create_tmp_bka_table_name(char * tmp_table_name,int * tmp_table_name_length,int link_idx)7604 void spider_mbase_handler::create_tmp_bka_table_name(
7605 char *tmp_table_name,
7606 int *tmp_table_name_length,
7607 int link_idx
7608 ) {
7609 uint adjust_length, length;
7610 DBUG_ENTER("spider_mbase_handler::create_tmp_bka_table_name");
7611 if (spider_param_bka_table_name_type(current_thd,
7612 mysql_share->spider_share->
7613 bka_table_name_types[spider->conn_link_idx[link_idx]]) == 1)
7614 {
7615 adjust_length =
7616 mysql_share->db_nm_max_length -
7617 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].length() +
7618 mysql_share->table_nm_max_length -
7619 mysql_share->table_names_str[spider->conn_link_idx[link_idx]].length();
7620 *tmp_table_name_length = mysql_share->db_nm_max_length +
7621 mysql_share->table_nm_max_length;
7622 memset(tmp_table_name, ' ', adjust_length);
7623 tmp_table_name += adjust_length;
7624 memcpy(tmp_table_name, mysql_share->db_names_str[link_idx].c_ptr(),
7625 mysql_share->db_names_str[link_idx].length());
7626 tmp_table_name += mysql_share->db_names_str[link_idx].length();
7627 length = my_sprintf(tmp_table_name, (tmp_table_name,
7628 "%s%s%p%s", SPIDER_SQL_DOT_STR, SPIDER_SQL_TMP_BKA_STR, spider,
7629 SPIDER_SQL_UNDERSCORE_STR));
7630 *tmp_table_name_length += length;
7631 tmp_table_name += length;
7632 memcpy(tmp_table_name,
7633 mysql_share->table_names_str[spider->conn_link_idx[link_idx]].c_ptr(),
7634 mysql_share->table_names_str[spider->conn_link_idx[link_idx]].length());
7635 } else {
7636 adjust_length =
7637 mysql_share->db_nm_max_length -
7638 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].length();
7639 *tmp_table_name_length = mysql_share->db_nm_max_length;
7640 memset(tmp_table_name, ' ', adjust_length);
7641 tmp_table_name += adjust_length;
7642 memcpy(tmp_table_name, mysql_share->db_names_str[link_idx].c_ptr(),
7643 mysql_share->db_names_str[link_idx].length());
7644 tmp_table_name += mysql_share->db_names_str[link_idx].length();
7645 length = my_sprintf(tmp_table_name, (tmp_table_name,
7646 "%s%s%p", SPIDER_SQL_DOT_STR, SPIDER_SQL_TMP_BKA_STR, spider));
7647 *tmp_table_name_length += length;
7648 }
7649 DBUG_VOID_RETURN;
7650 }
7651
append_create_tmp_bka_table(const key_range * start_key,spider_string * str,char * tmp_table_name,int tmp_table_name_length,int * db_name_pos,CHARSET_INFO * table_charset)7652 int spider_mbase_handler::append_create_tmp_bka_table(
7653 const key_range *start_key,
7654 spider_string *str,
7655 char *tmp_table_name,
7656 int tmp_table_name_length,
7657 int *db_name_pos,
7658 CHARSET_INFO *table_charset
7659 ) {
7660 int error_num;
7661 SPIDER_SHARE *share = spider->share;
7662 THD *thd = spider->trx->thd;
7663 char *bka_engine = spider_param_bka_engine(thd, share->bka_engine);
7664 uint bka_engine_length = strlen(bka_engine),
7665 cset_length = strlen(table_charset->csname),
7666 coll_length = strlen(table_charset->name);
7667 DBUG_ENTER("spider_mbase_handler::append_create_tmp_bka_table");
7668 if (str->reserve(SPIDER_SQL_CREATE_TMP_LEN + tmp_table_name_length +
7669 SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_ID_LEN + SPIDER_SQL_ID_TYPE_LEN +
7670 SPIDER_SQL_COMMA_LEN))
7671 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7672 str->q_append(SPIDER_SQL_CREATE_TMP_STR, SPIDER_SQL_CREATE_TMP_LEN);
7673 *db_name_pos = str->length();
7674 str->q_append(tmp_table_name, tmp_table_name_length);
7675 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7676 str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN);
7677 str->q_append(SPIDER_SQL_ID_TYPE_STR, SPIDER_SQL_ID_TYPE_LEN);
7678 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7679 if ((error_num = append_key_column_types(start_key, str)))
7680 DBUG_RETURN(error_num);
7681 if (str->reserve(SPIDER_SQL_ENGINE_LEN + bka_engine_length +
7682 SPIDER_SQL_DEF_CHARSET_LEN + cset_length + SPIDER_SQL_COLLATE_LEN +
7683 coll_length + SPIDER_SQL_SEMICOLON_LEN))
7684 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7685 str->q_append(SPIDER_SQL_ENGINE_STR, SPIDER_SQL_ENGINE_LEN);
7686 str->q_append(bka_engine, bka_engine_length);
7687 str->q_append(SPIDER_SQL_DEF_CHARSET_STR, SPIDER_SQL_DEF_CHARSET_LEN);
7688 str->q_append(table_charset->csname, cset_length);
7689 str->q_append(SPIDER_SQL_COLLATE_STR, SPIDER_SQL_COLLATE_LEN);
7690 str->q_append(table_charset->name, coll_length);
7691 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
7692 DBUG_RETURN(0);
7693 }
7694
append_drop_tmp_bka_table(spider_string * str,char * tmp_table_name,int tmp_table_name_length,int * db_name_pos,int * drop_table_end_pos,bool with_semicolon)7695 int spider_mbase_handler::append_drop_tmp_bka_table(
7696 spider_string *str,
7697 char *tmp_table_name,
7698 int tmp_table_name_length,
7699 int *db_name_pos,
7700 int *drop_table_end_pos,
7701 bool with_semicolon
7702 ) {
7703 DBUG_ENTER("spider_mbase_handler::append_drop_tmp_bka_table");
7704 if (str->reserve(SPIDER_SQL_DROP_TMP_LEN + tmp_table_name_length +
7705 (with_semicolon ? SPIDER_SQL_SEMICOLON_LEN : 0)))
7706 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7707 str->q_append(SPIDER_SQL_DROP_TMP_STR, SPIDER_SQL_DROP_TMP_LEN);
7708 *db_name_pos = str->length();
7709 str->q_append(tmp_table_name, tmp_table_name_length);
7710 *drop_table_end_pos = str->length();
7711 if (with_semicolon)
7712 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
7713 DBUG_RETURN(0);
7714 }
7715
append_insert_tmp_bka_table(const key_range * start_key,spider_string * str,char * tmp_table_name,int tmp_table_name_length,int * db_name_pos)7716 int spider_mbase_handler::append_insert_tmp_bka_table(
7717 const key_range *start_key,
7718 spider_string *str,
7719 char *tmp_table_name,
7720 int tmp_table_name_length,
7721 int *db_name_pos
7722 ) {
7723 int error_num;
7724 DBUG_ENTER("spider_mbase_handler::append_insert_tmp_bka_table");
7725 if (str->reserve(SPIDER_SQL_INSERT_LEN + SPIDER_SQL_INTO_LEN +
7726 tmp_table_name_length + SPIDER_SQL_OPEN_PAREN_LEN + SPIDER_SQL_ID_LEN +
7727 SPIDER_SQL_COMMA_LEN))
7728 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7729 str->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN);
7730 str->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN);
7731 *db_name_pos = str->length();
7732 str->q_append(tmp_table_name, tmp_table_name_length);
7733 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7734 str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN);
7735 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7736 if ((error_num = spider_db_append_key_columns(start_key, spider, str)))
7737 DBUG_RETURN(error_num);
7738 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN +
7739 SPIDER_SQL_OPEN_PAREN_LEN))
7740 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7741 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
7742 str->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN);
7743 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7744 DBUG_RETURN(0);
7745 }
7746
append_union_table_and_sql_for_bka(const key_range * start_key)7747 int spider_mbase_handler::append_union_table_and_sql_for_bka(
7748 const key_range *start_key
7749 ) {
7750 int error_num;
7751 DBUG_ENTER("spider_mbase_handler::append_union_table_and_sql_for_bka");
7752 DBUG_PRINT("info",("spider this=%p", this));
7753 char tgt_table_name[MAX_FIELD_WIDTH * 2];
7754 spider_string tgt_table_name_str(tgt_table_name, MAX_FIELD_WIDTH * 2,
7755 mysql_share->db_names_str[0].charset());
7756 const char *table_names[2], *table_aliases[2], *table_dot_aliases[2];
7757 uint table_name_lengths[2], table_alias_lengths[2],
7758 table_dot_alias_lengths[2];
7759 tgt_table_name_str.init_calc_mem(233);
7760 tgt_table_name_str.length(0);
7761 if ((error_num = append_table_name_with_adjusting(&tgt_table_name_str,
7762 first_link_idx, SPIDER_SQL_TYPE_SELECT_SQL)))
7763 {
7764 DBUG_RETURN(error_num);
7765 }
7766 table_names[0] = "";
7767 table_names[1] = tgt_table_name_str.c_ptr_safe();
7768 table_name_lengths[0] = 0;
7769 table_name_lengths[1] = tgt_table_name_str.length();
7770 table_aliases[0] = SPIDER_SQL_A_STR;
7771 table_aliases[1] = SPIDER_SQL_B_STR;
7772 table_alias_lengths[0] = SPIDER_SQL_A_LEN;
7773 table_alias_lengths[1] = SPIDER_SQL_B_LEN;
7774 table_dot_aliases[0] = SPIDER_SQL_A_DOT_STR;
7775 table_dot_aliases[1] = SPIDER_SQL_B_DOT_STR;
7776 table_dot_alias_lengths[0] = SPIDER_SQL_A_DOT_LEN;
7777 table_dot_alias_lengths[1] = SPIDER_SQL_B_DOT_LEN;
7778
7779 if ((error_num = spider_db_append_select(spider)))
7780 DBUG_RETURN(error_num);
7781 if (sql.reserve(SPIDER_SQL_A_DOT_LEN + SPIDER_SQL_ID_LEN +
7782 SPIDER_SQL_COMMA_LEN))
7783 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7784 sql.q_append(SPIDER_SQL_A_DOT_STR, SPIDER_SQL_A_DOT_LEN);
7785 sql.q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN);
7786 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7787 if ((error_num = append_select_columns_with_alias(&sql,
7788 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)))
7789 DBUG_RETURN(error_num);
7790 if (sql.reserve(SPIDER_SQL_FROM_LEN + (SPIDER_SQL_OPEN_PAREN_LEN * 2)))
7791 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7792 sql.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
7793 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7794 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7795 tmp_sql_pos1 = sql.length();
7796
7797 if (
7798 (error_num = spider_db_mbase_utility->append_from_with_alias(&tmp_sql,
7799 table_names, table_name_lengths,
7800 table_aliases, table_alias_lengths, 2,
7801 &table_name_pos, FALSE))
7802 )
7803 DBUG_RETURN(error_num);
7804 if (
7805 mysql_share->key_hint &&
7806 (error_num = spider_db_append_hint_after_table(spider,
7807 &tmp_sql, &mysql_share->key_hint[spider->active_index]))
7808 )
7809 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7810 where_pos = tmp_sql.length();
7811 if (
7812 (error_num = append_key_join_columns_for_bka(
7813 start_key, &tmp_sql,
7814 table_dot_aliases, table_dot_alias_lengths)) ||
7815 (error_num = append_condition_part(
7816 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN,
7817 SPIDER_SQL_TYPE_TMP_SQL, FALSE))
7818 )
7819 DBUG_RETURN(error_num);
7820 if (spider->result_list.direct_order_limit)
7821 {
7822 if ((error_num =
7823 append_key_order_for_direct_order_limit_with_alias(&tmp_sql,
7824 SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN))
7825 )
7826 DBUG_RETURN(error_num);
7827 }
7828 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
7829 else if (spider->result_list.direct_aggregate)
7830 {
7831 if ((error_num =
7832 append_group_by(&tmp_sql, SPIDER_SQL_B_DOT_STR, SPIDER_SQL_B_DOT_LEN)))
7833 DBUG_RETURN(error_num);
7834 }
7835 #endif
7836
7837 DBUG_RETURN(0);
7838 }
7839
reuse_union_table_and_sql_for_bka()7840 int spider_mbase_handler::reuse_union_table_and_sql_for_bka()
7841 {
7842 DBUG_ENTER("spider_mbase_handler::reuse_union_table_and_sql_for_bka");
7843 DBUG_PRINT("info",("spider this=%p", this));
7844 sql.length(tmp_sql_pos1);
7845 DBUG_RETURN(0);
7846 }
7847
append_insert_for_recovery(ulong sql_type,int link_idx)7848 int spider_mbase_handler::append_insert_for_recovery(
7849 ulong sql_type,
7850 int link_idx
7851 ) {
7852 const TABLE *table = spider->get_table();
7853 SPIDER_SHARE *share = spider->share;
7854 Field **field;
7855 uint field_name_length = 0;
7856 bool add_value = FALSE;
7857 spider_string *insert_sql;
7858 DBUG_ENTER("spider_mbase_handler::append_insert_for_recovery");
7859 DBUG_PRINT("info",("spider this=%p", this));
7860 if (sql_type == SPIDER_SQL_TYPE_INSERT_SQL)
7861 {
7862 insert_sql = &spider->result_list.insert_sqls[link_idx];
7863 insert_sql->length(0);
7864 } else {
7865 insert_sql = &spider->result_list.update_sqls[link_idx];
7866 }
7867 if (insert_sql->reserve(
7868 SPIDER_SQL_INSERT_LEN + SPIDER_SQL_SQL_IGNORE_LEN +
7869 SPIDER_SQL_INTO_LEN + mysql_share->db_nm_max_length +
7870 SPIDER_SQL_DOT_LEN + mysql_share->table_nm_max_length +
7871 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN))
7872 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7873 insert_sql->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN);
7874 insert_sql->q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN);
7875 insert_sql->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN);
7876 mysql_share->append_table_name(insert_sql, spider->conn_link_idx[link_idx]);
7877 insert_sql->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7878 for (field = table->field; *field; field++)
7879 {
7880 field_name_length =
7881 mysql_share->column_name_str[(*field)->field_index].length();
7882 if (insert_sql->reserve(field_name_length +
7883 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
7884 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7885 mysql_share->append_column_name(insert_sql, (*field)->field_index);
7886 insert_sql->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7887 }
7888 if (field_name_length)
7889 insert_sql->length(insert_sql->length() - SPIDER_SQL_COMMA_LEN);
7890 if (insert_sql->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN +
7891 SPIDER_SQL_OPEN_PAREN_LEN))
7892 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7893 insert_sql->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
7894 insert_sql->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN);
7895 insert_sql->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
7896 for (field = table->field; *field; field++)
7897 {
7898 add_value = TRUE;
7899 if ((*field)->is_null())
7900 {
7901 if (insert_sql->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN))
7902 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7903 insert_sql->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
7904 } else {
7905 if (
7906 spider_db_mbase_utility->
7907 append_column_value(spider, insert_sql, *field, NULL,
7908 share->access_charset) ||
7909 insert_sql->reserve(SPIDER_SQL_COMMA_LEN)
7910 )
7911 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7912 }
7913 insert_sql->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
7914 }
7915 if (add_value)
7916 insert_sql->length(insert_sql->length() - SPIDER_SQL_COMMA_LEN);
7917 if (insert_sql->reserve(SPIDER_SQL_CLOSE_PAREN_LEN, SPIDER_SQL_COMMA_LEN))
7918 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7919 insert_sql->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
7920 if (sql_type == SPIDER_SQL_TYPE_INSERT_SQL)
7921 {
7922 exec_insert_sql = insert_sql;
7923 }
7924 DBUG_RETURN(0);
7925 }
7926
append_update(const TABLE * table,my_ptrdiff_t ptr_diff)7927 int spider_mbase_handler::append_update(
7928 const TABLE *table,
7929 my_ptrdiff_t ptr_diff
7930 ) {
7931 int error_num;
7932 spider_string *str = &update_sql;
7933 DBUG_ENTER("spider_mbase_handler::append_update");
7934 DBUG_PRINT("info",("spider this=%p", this));
7935 if (str->length() > 0)
7936 {
7937 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN))
7938 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7939 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
7940 }
7941
7942 if (
7943 (error_num = append_update(str, 0)) ||
7944 (error_num = append_update_set(str)) ||
7945 (error_num = append_update_where(str, table, ptr_diff))
7946 )
7947 DBUG_RETURN(error_num);
7948 filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size);
7949 DBUG_RETURN(0);
7950 }
7951
append_update(const TABLE * table,my_ptrdiff_t ptr_diff,int link_idx)7952 int spider_mbase_handler::append_update(
7953 const TABLE *table,
7954 my_ptrdiff_t ptr_diff,
7955 int link_idx
7956 ) {
7957 int error_num;
7958 SPIDER_SHARE *share = spider->share;
7959 spider_string *str = &spider->result_list.update_sqls[link_idx];
7960 DBUG_ENTER("spider_mbase_handler::append_update");
7961 DBUG_PRINT("info",("spider this=%p", this));
7962 if (str->length() > 0)
7963 {
7964 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN))
7965 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7966 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
7967 }
7968
7969 if (
7970 (error_num = append_update(str, link_idx)) ||
7971 (error_num = append_update_set(str)) ||
7972 (error_num = append_update_where(str, table, ptr_diff))
7973 )
7974 DBUG_RETURN(error_num);
7975
7976 if (
7977 spider->pk_update &&
7978 share->link_statuses[link_idx] == SPIDER_LINK_STATUS_RECOVERY
7979 ) {
7980 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN))
7981 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
7982 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
7983 if ((error_num = append_insert_for_recovery(
7984 SPIDER_SQL_TYPE_UPDATE_SQL, link_idx)))
7985 DBUG_RETURN(error_num);
7986 }
7987
7988 if (!filled_up)
7989 filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size);
7990 DBUG_RETURN(0);
7991 }
7992
append_delete(const TABLE * table,my_ptrdiff_t ptr_diff)7993 int spider_mbase_handler::append_delete(
7994 const TABLE *table,
7995 my_ptrdiff_t ptr_diff
7996 ) {
7997 int error_num;
7998 spider_string *str = &update_sql;
7999 DBUG_ENTER("spider_mbase_handler::append_delete");
8000 DBUG_PRINT("info",("spider this=%p", this));
8001 if (str->length() > 0)
8002 {
8003 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN))
8004 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8005 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
8006 }
8007
8008 if (
8009 (error_num = append_delete(str)) ||
8010 (error_num = append_from(str, SPIDER_SQL_TYPE_DELETE_SQL,
8011 first_link_idx)) ||
8012 (error_num = append_update_where(str, table, ptr_diff))
8013 )
8014 DBUG_RETURN(error_num);
8015 filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size);
8016 DBUG_RETURN(0);
8017 }
8018
append_delete(const TABLE * table,my_ptrdiff_t ptr_diff,int link_idx)8019 int spider_mbase_handler::append_delete(
8020 const TABLE *table,
8021 my_ptrdiff_t ptr_diff,
8022 int link_idx
8023 ) {
8024 int error_num;
8025 spider_string *str = &spider->result_list.update_sqls[link_idx];
8026 DBUG_ENTER("spider_mbase_handler::append_delete");
8027 DBUG_PRINT("info",("spider this=%p", this));
8028 if (str->length() > 0)
8029 {
8030 if (str->reserve(SPIDER_SQL_SEMICOLON_LEN))
8031 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8032 str->q_append(SPIDER_SQL_SEMICOLON_STR, SPIDER_SQL_SEMICOLON_LEN);
8033 }
8034
8035 if (
8036 (error_num = append_delete(str)) ||
8037 (error_num = append_from(str, SPIDER_SQL_TYPE_DELETE_SQL, link_idx)) ||
8038 (error_num = append_update_where(str, table, ptr_diff))
8039 )
8040 DBUG_RETURN(error_num);
8041 if (!filled_up)
8042 filled_up = (str->length() >= (uint) spider->result_list.bulk_update_size);
8043 DBUG_RETURN(0);
8044 }
8045
append_insert_part()8046 int spider_mbase_handler::append_insert_part()
8047 {
8048 int error_num;
8049 DBUG_ENTER("spider_mbase_handler::append_insert_part");
8050 DBUG_PRINT("info",("spider this=%p", this));
8051 error_num = append_insert(&insert_sql, 0);
8052 DBUG_RETURN(error_num);
8053 }
8054
append_insert(spider_string * str,int link_idx)8055 int spider_mbase_handler::append_insert(
8056 spider_string *str,
8057 int link_idx
8058 ) {
8059 SPIDER_SHARE *share = spider->share;
8060 DBUG_ENTER("spider_mbase_handler::append_insert");
8061 if (
8062 (
8063 spider->write_can_replace ||
8064 /* for direct_dup_insert without patch for partition */
8065 spider->sql_command == SQLCOM_REPLACE ||
8066 spider->sql_command == SQLCOM_REPLACE_SELECT
8067 ) &&
8068 spider->direct_dup_insert
8069 ) {
8070 if (str->reserve(SPIDER_SQL_REPLACE_LEN))
8071 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8072 str->q_append(SPIDER_SQL_REPLACE_STR, SPIDER_SQL_REPLACE_LEN);
8073 } else {
8074 if (str->reserve(SPIDER_SQL_INSERT_LEN))
8075 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8076 str->q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN);
8077 }
8078 if (spider->low_priority)
8079 {
8080 if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
8081 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8082 str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
8083 }
8084 else if (spider->insert_delayed)
8085 {
8086 if (share->internal_delayed)
8087 {
8088 if (str->reserve(SPIDER_SQL_SQL_DELAYED_LEN))
8089 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8090 str->q_append(SPIDER_SQL_SQL_DELAYED_STR, SPIDER_SQL_SQL_DELAYED_LEN);
8091 }
8092 }
8093 else if (
8094 spider->lock_type >= TL_WRITE &&
8095 !spider->write_can_replace &&
8096 /* for direct_dup_insert without patch for partition */
8097 spider->sql_command != SQLCOM_REPLACE &&
8098 spider->sql_command != SQLCOM_REPLACE_SELECT
8099 ) {
8100 if (str->reserve(SPIDER_SQL_HIGH_PRIORITY_LEN))
8101 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8102 str->q_append(SPIDER_SQL_HIGH_PRIORITY_STR, SPIDER_SQL_HIGH_PRIORITY_LEN);
8103 }
8104 if (
8105 spider->ignore_dup_key &&
8106 spider->direct_dup_insert &&
8107 !spider->write_can_replace &&
8108 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
8109 (!spider->insert_with_update || !dup_update_sql.length()) &&
8110 #else
8111 !spider->insert_with_update &&
8112 #endif
8113 /* for direct_dup_insert without patch for partition */
8114 spider->sql_command != SQLCOM_REPLACE &&
8115 spider->sql_command != SQLCOM_REPLACE_SELECT
8116 ) {
8117 if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
8118 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8119 str->q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN);
8120 }
8121 DBUG_RETURN(0);
8122 }
8123
append_update_part()8124 int spider_mbase_handler::append_update_part()
8125 {
8126 int error_num;
8127 DBUG_ENTER("spider_mbase_handler::append_update_part");
8128 DBUG_PRINT("info",("spider this=%p", this));
8129 error_num = append_update(&update_sql, 0);
8130 DBUG_RETURN(error_num);
8131 }
8132
append_update(spider_string * str,int link_idx)8133 int spider_mbase_handler::append_update(
8134 spider_string *str,
8135 int link_idx
8136 ) {
8137 DBUG_ENTER("spider_mbase_handler::append_update");
8138 if (str->reserve(SPIDER_SQL_UPDATE_LEN))
8139 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8140 str->q_append(SPIDER_SQL_UPDATE_STR, SPIDER_SQL_UPDATE_LEN);
8141 if (spider->low_priority)
8142 {
8143 if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
8144 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8145 str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
8146 }
8147 if (
8148 spider->ignore_dup_key &&
8149 !spider->insert_with_update
8150 ) {
8151 if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
8152 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8153 str->q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN);
8154 }
8155 if (str->reserve(mysql_share->db_nm_max_length +
8156 SPIDER_SQL_DOT_LEN + mysql_share->table_nm_max_length +
8157 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
8158 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8159 table_name_pos = str->length();
8160 append_table_name_with_adjusting(str, link_idx, SPIDER_SQL_TYPE_UPDATE_SQL);
8161 DBUG_RETURN(0);
8162 }
8163
append_delete_part()8164 int spider_mbase_handler::append_delete_part()
8165 {
8166 int error_num;
8167 DBUG_ENTER("spider_mbase_handler::append_delete_part");
8168 DBUG_PRINT("info",("spider this=%p", this));
8169 error_num = append_delete(&update_sql);
8170 DBUG_RETURN(error_num);
8171 }
8172
append_delete(spider_string * str)8173 int spider_mbase_handler::append_delete(
8174 spider_string *str
8175 ) {
8176 DBUG_ENTER("spider_mbase_handler::append_delete");
8177 if (str->reserve(SPIDER_SQL_DELETE_LEN))
8178 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8179 str->q_append(SPIDER_SQL_DELETE_STR, SPIDER_SQL_DELETE_LEN);
8180 if (spider->low_priority)
8181 {
8182 if (str->reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
8183 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8184 str->q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
8185 }
8186 if (spider->quick_mode)
8187 {
8188 if (str->reserve(SPIDER_SQL_SQL_QUICK_MODE_LEN))
8189 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8190 str->q_append(SPIDER_SQL_SQL_QUICK_MODE_STR,
8191 SPIDER_SQL_SQL_QUICK_MODE_LEN);
8192 }
8193 if (spider->ignore_dup_key)
8194 {
8195 if (str->reserve(SPIDER_SQL_SQL_IGNORE_LEN))
8196 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8197 str->q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN);
8198 }
8199 str->length(str->length() - 1);
8200 DBUG_RETURN(0);
8201 }
8202
8203 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
8204 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
append_increment_update_set_part()8205 int spider_mbase_handler::append_increment_update_set_part()
8206 {
8207 int error_num;
8208 DBUG_ENTER("spider_mbase_handler::append_increment_update_set_part");
8209 DBUG_PRINT("info",("spider this=%p", this));
8210 error_num = append_increment_update_set(&update_sql);
8211 DBUG_RETURN(error_num);
8212 }
8213
append_increment_update_set(spider_string * str)8214 int spider_mbase_handler::append_increment_update_set(
8215 spider_string *str
8216 ) {
8217 uint field_name_length;
8218 uint roop_count;
8219 Field *field;
8220 DBUG_ENTER("spider_mbase_handler::append_increment_update_set");
8221 if (str->reserve(SPIDER_SQL_SET_LEN))
8222 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8223 str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN);
8224 const SPIDER_HS_STRING_REF *value = hs_upds.ptr();
8225 for (roop_count = 0; roop_count < hs_upds.size();
8226 roop_count++)
8227 {
8228 if (
8229 value[roop_count].size() == 1 &&
8230 *(value[roop_count].begin()) == '0'
8231 )
8232 continue;
8233
8234 Field *top_table_field =
8235 spider->get_top_table_field(spider->hs_pushed_ret_fields[roop_count]);
8236 if (!(field = spider->field_exchange(top_table_field)))
8237 continue;
8238 field_name_length =
8239 mysql_share->column_name_str[field->field_index].length();
8240
8241 if (str->reserve(field_name_length * 2 + /* SPIDER_SQL_NAME_QUOTE_LEN */
8242 4 + SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_HS_INCREMENT_LEN +
8243 SPIDER_SQL_COMMA_LEN + value[roop_count].size()))
8244 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8245
8246 mysql_share->append_column_name(str, field->field_index);
8247 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
8248 mysql_share->append_column_name(str, field->field_index);
8249 if (spider->hs_increment)
8250 str->q_append(SPIDER_SQL_HS_INCREMENT_STR,
8251 SPIDER_SQL_HS_INCREMENT_LEN);
8252 else
8253 str->q_append(SPIDER_SQL_HS_DECREMENT_STR,
8254 SPIDER_SQL_HS_DECREMENT_LEN);
8255 str->q_append(value[roop_count].begin(), value[roop_count].size());
8256 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8257 }
8258 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8259 DBUG_RETURN(0);
8260 }
8261 #endif
8262 #endif
8263
append_update_set_part()8264 int spider_mbase_handler::append_update_set_part()
8265 {
8266 int error_num;
8267 DBUG_ENTER("spider_mbase_handler::append_update_set_part");
8268 DBUG_PRINT("info",("spider this=%p", this));
8269 error_num = append_update_set(&update_sql);
8270 where_pos = update_sql.length();
8271 DBUG_RETURN(error_num);
8272 }
8273
append_update_set(spider_string * str)8274 int spider_mbase_handler::append_update_set(
8275 spider_string *str
8276 ) {
8277 uint field_name_length;
8278 SPIDER_SHARE *share = spider->share;
8279 TABLE *table = spider->get_table();
8280 Field **fields;
8281 DBUG_ENTER("spider_mbase_handler::append_update_set");
8282 if (str->reserve(SPIDER_SQL_SET_LEN))
8283 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8284 str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN);
8285 for (fields = table->field; *fields; fields++)
8286 {
8287 if (bitmap_is_set(table->write_set, (*fields)->field_index))
8288 {
8289 field_name_length =
8290 mysql_share->column_name_str[(*fields)->field_index].length();
8291 if ((*fields)->is_null())
8292 {
8293 if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */
8294 2 + SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_NULL_LEN +
8295 SPIDER_SQL_COMMA_LEN))
8296 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8297 mysql_share->append_column_name(str, (*fields)->field_index);
8298 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
8299 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
8300 } else {
8301 if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */
8302 2 + SPIDER_SQL_EQUAL_LEN))
8303 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8304 mysql_share->append_column_name(str, (*fields)->field_index);
8305 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
8306 #ifndef DBUG_OFF
8307 MY_BITMAP *tmp_map = dbug_tmp_use_all_columns(table, &table->read_set);
8308 #endif
8309 if (
8310 spider_db_mbase_utility->
8311 append_column_value(spider, str, *fields, NULL,
8312 share->access_charset) ||
8313 str->reserve(SPIDER_SQL_COMMA_LEN)
8314 ) {
8315 #ifndef DBUG_OFF
8316 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
8317 #endif
8318 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8319 }
8320 #ifndef DBUG_OFF
8321 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
8322 #endif
8323 }
8324 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8325 }
8326 }
8327 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8328 DBUG_RETURN(0);
8329 }
8330
8331 #ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS
append_direct_update_set_part()8332 int spider_mbase_handler::append_direct_update_set_part()
8333 {
8334 int error_num;
8335 DBUG_ENTER("spider_mbase_handler::append_direct_update_set_part");
8336 DBUG_PRINT("info",("spider this=%p", this));
8337 error_num = append_direct_update_set(&update_sql);
8338 where_pos = update_sql.length();
8339 DBUG_RETURN(error_num);
8340 }
8341
append_direct_update_set(spider_string * str)8342 int spider_mbase_handler::append_direct_update_set(
8343 spider_string *str
8344 ) {
8345 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
8346 uint field_name_length;
8347 SPIDER_SHARE *share = spider->share;
8348 #ifndef DBUG_OFF
8349 TABLE *table = spider->get_table();
8350 #endif
8351 #endif
8352 DBUG_ENTER("spider_mbase_handler::append_direct_update_set");
8353 if (
8354 spider->direct_update_kinds == SPIDER_SQL_KIND_SQL &&
8355 spider->direct_update_fields
8356 ) {
8357 if (str->reserve(SPIDER_SQL_SET_LEN))
8358 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8359 str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN);
8360 DBUG_RETURN(spider_db_append_update_columns(spider, str, NULL, 0,
8361 dbton_id, FALSE, NULL));
8362 }
8363
8364 if (
8365 (spider->direct_update_kinds & SPIDER_SQL_KIND_SQL)
8366 ) {
8367 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
8368 size_t roop_count;
8369 Field *field;
8370 if (str->reserve(SPIDER_SQL_SET_LEN))
8371 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8372 str->q_append(SPIDER_SQL_SET_STR, SPIDER_SQL_SET_LEN);
8373 for (roop_count = 0; roop_count < spider->hs_pushed_ret_fields_num;
8374 roop_count++)
8375 {
8376 Field *top_table_field =
8377 spider->get_top_table_field(spider->hs_pushed_ret_fields[roop_count]);
8378 if (!(field = spider->field_exchange(top_table_field)))
8379 continue;
8380 field_name_length =
8381 mysql_share->column_name_str[field->field_index].length();
8382 if (top_table_field->is_null())
8383 {
8384 if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */
8385 2 + SPIDER_SQL_EQUAL_LEN + SPIDER_SQL_NULL_LEN +
8386 SPIDER_SQL_COMMA_LEN))
8387 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8388 mysql_share->append_column_name(str, field->field_index);
8389 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
8390 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
8391 } else {
8392 if (str->reserve(field_name_length + /* SPIDER_SQL_NAME_QUOTE_LEN */
8393 2 + SPIDER_SQL_EQUAL_LEN))
8394 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8395 mysql_share->append_column_name(str, field->field_index);
8396 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
8397 #ifndef DBUG_OFF
8398 my_bitmap_map *tmp_map = dbug_tmp_use_all_columns(table,
8399 table->read_set);
8400 #endif
8401 if (
8402 spider_db_mbase_utility->
8403 append_column_value(spider, str, top_table_field, NULL,
8404 share->access_charset) ||
8405 str->reserve(SPIDER_SQL_COMMA_LEN)
8406 ) {
8407 #ifndef DBUG_OFF
8408 dbug_tmp_restore_column_map(table->read_set, tmp_map);
8409 #endif
8410 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8411 }
8412 #ifndef DBUG_OFF
8413 dbug_tmp_restore_column_map(table->read_set, tmp_map);
8414 #endif
8415 }
8416 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8417 }
8418 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8419 #else
8420 DBUG_ASSERT(0);
8421 #endif
8422 }
8423 DBUG_RETURN(0);
8424 }
8425
append_dup_update_pushdown_part(const char * alias,uint alias_length)8426 int spider_mbase_handler::append_dup_update_pushdown_part(
8427 const char *alias,
8428 uint alias_length
8429 ) {
8430 int error_num;
8431 DBUG_ENTER("spider_mbase_handler::append_dup_update_pushdown_part");
8432 DBUG_PRINT("info",("spider this=%p", this));
8433 dup_update_sql.length(0);
8434 error_num = append_update_columns(&dup_update_sql, alias, alias_length);
8435 DBUG_RETURN(error_num);
8436 }
8437
append_update_columns_part(const char * alias,uint alias_length)8438 int spider_mbase_handler::append_update_columns_part(
8439 const char *alias,
8440 uint alias_length
8441 ) {
8442 int error_num;
8443 DBUG_ENTER("spider_mbase_handler::append_update_columns_part");
8444 DBUG_PRINT("info",("spider this=%p", this));
8445 error_num = append_update_columns(&update_sql, alias, alias_length);
8446 DBUG_RETURN(error_num);
8447 }
8448
check_update_columns_part()8449 int spider_mbase_handler::check_update_columns_part()
8450 {
8451 int error_num;
8452 DBUG_ENTER("spider_mbase_handler::check_update_columns_part");
8453 DBUG_PRINT("info",("spider this=%p", this));
8454 error_num = append_update_columns(NULL, NULL, 0);
8455 DBUG_RETURN(error_num);
8456 }
8457
append_update_columns(spider_string * str,const char * alias,uint alias_length)8458 int spider_mbase_handler::append_update_columns(
8459 spider_string *str,
8460 const char *alias,
8461 uint alias_length
8462 ) {
8463 int error_num;
8464 DBUG_ENTER("spider_mbase_handler::append_update_columns");
8465 error_num = spider_db_append_update_columns(spider, str,
8466 alias, alias_length, dbton_id, FALSE, NULL);
8467 DBUG_RETURN(error_num);
8468 }
8469 #endif
8470
append_select_part(ulong sql_type)8471 int spider_mbase_handler::append_select_part(
8472 ulong sql_type
8473 ) {
8474 int error_num;
8475 spider_string *str;
8476 DBUG_ENTER("spider_mbase_handler::append_select_part");
8477 DBUG_PRINT("info",("spider this=%p", this));
8478 switch (sql_type)
8479 {
8480 case SPIDER_SQL_TYPE_SELECT_SQL:
8481 str = &sql;
8482 break;
8483 case SPIDER_SQL_TYPE_HANDLER:
8484 str = &ha_sql;
8485 break;
8486 default:
8487 DBUG_RETURN(0);
8488 }
8489 error_num = append_select(str, sql_type);
8490 DBUG_RETURN(error_num);
8491 }
8492
append_select(spider_string * str,ulong sql_type)8493 int spider_mbase_handler::append_select(
8494 spider_string *str,
8495 ulong sql_type
8496 ) {
8497 SPIDER_RESULT_LIST *result_list = &spider->result_list;
8498 DBUG_ENTER("spider_mbase_handler::append_select");
8499 if (sql_type == SPIDER_SQL_TYPE_HANDLER)
8500 {
8501 if (str->reserve(SPIDER_SQL_HANDLER_LEN))
8502 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8503 str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN);
8504 } else {
8505 if (str->reserve(SPIDER_SQL_SELECT_LEN))
8506 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8507 str->q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN);
8508 if (result_list->direct_distinct)
8509 {
8510 if (str->reserve(SPIDER_SQL_DISTINCT_LEN))
8511 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8512 str->q_append(SPIDER_SQL_DISTINCT_STR, SPIDER_SQL_DISTINCT_LEN);
8513 }
8514 if (result_list->lock_type != F_WRLCK && spider->lock_mode < 1)
8515 {
8516 /* no lock */
8517 #ifdef SPIDER_SQL_CACHE_IS_IN_LEX
8518 LEX *lex = spider->trx->thd->lex;
8519 #else
8520 st_select_lex *select_lex = &spider->trx->thd->lex->select_lex;
8521 #endif
8522 if (
8523 #ifdef SPIDER_SQL_CACHE_IS_IN_LEX
8524 lex->sql_cache == LEX::SQL_CACHE &&
8525 #else
8526 select_lex->sql_cache == SELECT_LEX::SQL_CACHE &&
8527 #endif
8528 (spider->share->query_cache_sync & 1)
8529 ) {
8530 if (str->reserve(SPIDER_SQL_SQL_CACHE_LEN))
8531 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8532 str->q_append(SPIDER_SQL_SQL_CACHE_STR, SPIDER_SQL_SQL_CACHE_LEN);
8533 } else if (
8534 #ifdef SPIDER_SQL_CACHE_IS_IN_LEX
8535 lex->sql_cache == LEX::SQL_NO_CACHE &&
8536 #else
8537 select_lex->sql_cache == SELECT_LEX::SQL_NO_CACHE &&
8538 #endif
8539 (spider->share->query_cache_sync & 2)
8540 ) {
8541 if (str->reserve(SPIDER_SQL_SQL_NO_CACHE_LEN))
8542 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8543 str->q_append(SPIDER_SQL_SQL_NO_CACHE_STR,
8544 SPIDER_SQL_SQL_NO_CACHE_LEN);
8545 } else if (spider->share->query_cache == 1)
8546 {
8547 if (str->reserve(SPIDER_SQL_SQL_CACHE_LEN))
8548 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8549 str->q_append(SPIDER_SQL_SQL_CACHE_STR, SPIDER_SQL_SQL_CACHE_LEN);
8550 } else if (spider->share->query_cache == 2)
8551 {
8552 if (str->reserve(SPIDER_SQL_SQL_NO_CACHE_LEN))
8553 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8554 str->q_append(SPIDER_SQL_SQL_NO_CACHE_STR,
8555 SPIDER_SQL_SQL_NO_CACHE_LEN);
8556 }
8557 }
8558 if (spider->high_priority)
8559 {
8560 if (str->reserve(SPIDER_SQL_HIGH_PRIORITY_LEN))
8561 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8562 str->q_append(SPIDER_SQL_HIGH_PRIORITY_STR,
8563 SPIDER_SQL_HIGH_PRIORITY_LEN);
8564 }
8565 }
8566 DBUG_RETURN(0);
8567 }
8568
append_table_select_part(ulong sql_type)8569 int spider_mbase_handler::append_table_select_part(
8570 ulong sql_type
8571 ) {
8572 int error_num;
8573 spider_string *str;
8574 DBUG_ENTER("spider_mbase_handler::append_table_select_part");
8575 DBUG_PRINT("info",("spider this=%p", this));
8576 switch (sql_type)
8577 {
8578 case SPIDER_SQL_TYPE_SELECT_SQL:
8579 str = &sql;
8580 break;
8581 default:
8582 DBUG_RETURN(0);
8583 }
8584 error_num = append_table_select(str);
8585 DBUG_RETURN(error_num);
8586 }
8587
append_table_select(spider_string * str)8588 int spider_mbase_handler::append_table_select(
8589 spider_string *str
8590 ) {
8591 DBUG_ENTER("spider_mbase_handler::append_table_select");
8592 table_name_pos = str->length() + mysql_share->table_select_pos;
8593 if (str->append(*(mysql_share->table_select)))
8594 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8595 DBUG_RETURN(0);
8596 }
8597
append_key_select_part(ulong sql_type,uint idx)8598 int spider_mbase_handler::append_key_select_part(
8599 ulong sql_type,
8600 uint idx
8601 ) {
8602 int error_num;
8603 spider_string *str;
8604 DBUG_ENTER("spider_mbase_handler::append_key_select_part");
8605 DBUG_PRINT("info",("spider this=%p", this));
8606 switch (sql_type)
8607 {
8608 case SPIDER_SQL_TYPE_SELECT_SQL:
8609 str = &sql;
8610 break;
8611 default:
8612 DBUG_RETURN(0);
8613 }
8614 error_num = append_key_select(str, idx);
8615 DBUG_RETURN(error_num);
8616 }
8617
append_key_select(spider_string * str,uint idx)8618 int spider_mbase_handler::append_key_select(
8619 spider_string *str,
8620 uint idx
8621 ) {
8622 DBUG_ENTER("spider_mbase_handler::append_key_select");
8623 table_name_pos = str->length() + mysql_share->key_select_pos[idx];
8624 if (str->append(mysql_share->key_select[idx]))
8625 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8626 DBUG_RETURN(0);
8627 }
8628
append_minimum_select_part(ulong sql_type)8629 int spider_mbase_handler::append_minimum_select_part(
8630 ulong sql_type
8631 ) {
8632 int error_num;
8633 spider_string *str;
8634 DBUG_ENTER("spider_mbase_handler::append_minimum_select_part");
8635 DBUG_PRINT("info",("spider this=%p", this));
8636 switch (sql_type)
8637 {
8638 case SPIDER_SQL_TYPE_SELECT_SQL:
8639 str = &sql;
8640 break;
8641 default:
8642 DBUG_RETURN(0);
8643 }
8644 error_num = append_minimum_select(str, sql_type);
8645 DBUG_RETURN(error_num);
8646 }
8647
append_minimum_select(spider_string * str,ulong sql_type)8648 int spider_mbase_handler::append_minimum_select(
8649 spider_string *str,
8650 ulong sql_type
8651 ) {
8652 TABLE *table = spider->get_table();
8653 Field **field;
8654 int field_length;
8655 bool appended = FALSE;
8656 DBUG_ENTER("spider_mbase_handler::append_minimum_select");
8657 minimum_select_bitmap_create();
8658 for (field = table->field; *field; field++)
8659 {
8660 if (minimum_select_bit_is_set((*field)->field_index))
8661 {
8662 /*
8663 spider_set_bit(minimum_select_bitmap, (*field)->field_index);
8664 */
8665 field_length =
8666 mysql_share->column_name_str[(*field)->field_index].length();
8667 if (str->reserve(field_length +
8668 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
8669 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8670 mysql_share->append_column_name(str, (*field)->field_index);
8671 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8672 appended = TRUE;
8673 }
8674 }
8675 if (appended)
8676 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8677 else {
8678 if (str->reserve(SPIDER_SQL_ONE_LEN))
8679 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8680 str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN);
8681 }
8682 DBUG_RETURN(append_from(str, sql_type, first_link_idx));
8683 }
8684
append_table_select_with_alias(spider_string * str,const char * alias,uint alias_length)8685 int spider_mbase_handler::append_table_select_with_alias(
8686 spider_string *str,
8687 const char *alias,
8688 uint alias_length
8689 ) {
8690 TABLE *table = spider->get_table();
8691 Field **field;
8692 int field_length;
8693 DBUG_ENTER("spider_mbase_handler::append_table_select_with_alias");
8694 for (field = table->field; *field; field++)
8695 {
8696 field_length =
8697 mysql_share->column_name_str[(*field)->field_index].length();
8698 if (str->reserve(alias_length + field_length +
8699 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
8700 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8701 str->q_append(alias, alias_length);
8702 mysql_share->append_column_name(str, (*field)->field_index);
8703 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8704 }
8705 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8706 DBUG_RETURN(0);
8707 }
8708
append_key_select_with_alias(spider_string * str,const KEY * key_info,const char * alias,uint alias_length)8709 int spider_mbase_handler::append_key_select_with_alias(
8710 spider_string *str,
8711 const KEY *key_info,
8712 const char *alias,
8713 uint alias_length
8714 ) {
8715 KEY_PART_INFO *key_part;
8716 Field *field;
8717 uint part_num;
8718 int field_length;
8719 DBUG_ENTER("spider_mbase_handler::append_key_select_with_alias");
8720 for (key_part = key_info->key_part, part_num = 0;
8721 part_num < spider_user_defined_key_parts(key_info); key_part++, part_num++)
8722 {
8723 field = key_part->field;
8724 field_length = mysql_share->column_name_str[field->field_index].length();
8725 if (str->reserve(alias_length + field_length +
8726 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
8727 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8728 str->q_append(alias, alias_length);
8729 mysql_share->append_column_name(str, field->field_index);
8730 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8731 }
8732 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8733 DBUG_RETURN(0);
8734 }
8735
append_minimum_select_with_alias(spider_string * str,const char * alias,uint alias_length)8736 int spider_mbase_handler::append_minimum_select_with_alias(
8737 spider_string *str,
8738 const char *alias,
8739 uint alias_length
8740 ) {
8741 TABLE *table = spider->get_table();
8742 Field **field;
8743 int field_length;
8744 bool appended = FALSE;
8745 DBUG_ENTER("spider_mbase_handler::append_minimum_select_with_alias");
8746 minimum_select_bitmap_create();
8747 for (field = table->field; *field; field++)
8748 {
8749 if (minimum_select_bit_is_set((*field)->field_index))
8750 {
8751 /*
8752 spider_set_bit(minimum_select_bitmap, (*field)->field_index);
8753 */
8754 field_length =
8755 mysql_share->column_name_str[(*field)->field_index].length();
8756 if (str->reserve(alias_length + field_length +
8757 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
8758 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8759 str->q_append(alias, alias_length);
8760 mysql_share->append_column_name(str, (*field)->field_index);
8761 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8762 appended = TRUE;
8763 }
8764 }
8765 if (appended)
8766 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
8767 else {
8768 if (str->reserve(SPIDER_SQL_ONE_LEN))
8769 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8770 str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN);
8771 }
8772 DBUG_RETURN(0);
8773 }
8774
append_select_columns_with_alias(spider_string * str,const char * alias,uint alias_length)8775 int spider_mbase_handler::append_select_columns_with_alias(
8776 spider_string *str,
8777 const char *alias,
8778 uint alias_length
8779 ) {
8780 int error_num;
8781 SPIDER_RESULT_LIST *result_list = &spider->result_list;
8782 DBUG_ENTER("spider_mbase_handler::append_select_columns_with_alias");
8783 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
8784 if (
8785 result_list->direct_aggregate &&
8786 (error_num = append_sum_select(str, alias, alias_length))
8787 )
8788 DBUG_RETURN(error_num);
8789 #endif
8790 if ((error_num = append_match_select(str, alias, alias_length)))
8791 DBUG_RETURN(error_num);
8792 if (!spider->select_column_mode)
8793 {
8794 if (result_list->keyread)
8795 DBUG_RETURN(append_key_select_with_alias(
8796 str, result_list->key_info, alias, alias_length));
8797 else
8798 DBUG_RETURN(append_table_select_with_alias(
8799 str, alias, alias_length));
8800 }
8801 DBUG_RETURN(append_minimum_select_with_alias(str, alias, alias_length));
8802 }
8803
append_hint_after_table_part(ulong sql_type)8804 int spider_mbase_handler::append_hint_after_table_part(
8805 ulong sql_type
8806 ) {
8807 int error_num;
8808 spider_string *str;
8809 DBUG_ENTER("spider_mbase_handler::append_hint_after_table_part");
8810 DBUG_PRINT("info",("spider this=%p", this));
8811 switch (sql_type)
8812 {
8813 case SPIDER_SQL_TYPE_SELECT_SQL:
8814 case SPIDER_SQL_TYPE_TMP_SQL:
8815 str = &sql;
8816 break;
8817 case SPIDER_SQL_TYPE_INSERT_SQL:
8818 case SPIDER_SQL_TYPE_UPDATE_SQL:
8819 case SPIDER_SQL_TYPE_DELETE_SQL:
8820 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
8821 str = &update_sql;
8822 break;
8823 case SPIDER_SQL_TYPE_HANDLER:
8824 str = &ha_sql;
8825 break;
8826 default:
8827 DBUG_RETURN(0);
8828 }
8829 error_num = append_hint_after_table(str);
8830 DBUG_RETURN(error_num);
8831 }
8832
append_hint_after_table(spider_string * str)8833 int spider_mbase_handler::append_hint_after_table(
8834 spider_string *str
8835 ) {
8836 int error_num;
8837 DBUG_ENTER("spider_mbase_handler::append_hint_after_table");
8838 DBUG_PRINT("info",("spider this=%p", this));
8839 if (
8840 mysql_share->key_hint &&
8841 (error_num = spider_db_append_hint_after_table(spider,
8842 str, &mysql_share->key_hint[spider->active_index]))
8843 )
8844 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8845 DBUG_RETURN(0);
8846 }
8847
set_where_pos(ulong sql_type)8848 void spider_mbase_handler::set_where_pos(
8849 ulong sql_type
8850 ) {
8851 DBUG_ENTER("spider_mbase_handler::set_where_pos");
8852 switch (sql_type)
8853 {
8854 case SPIDER_SQL_TYPE_SELECT_SQL:
8855 case SPIDER_SQL_TYPE_TMP_SQL:
8856 where_pos = sql.length();
8857 break;
8858 case SPIDER_SQL_TYPE_INSERT_SQL:
8859 case SPIDER_SQL_TYPE_UPDATE_SQL:
8860 case SPIDER_SQL_TYPE_DELETE_SQL:
8861 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
8862 where_pos = update_sql.length();
8863 break;
8864 case SPIDER_SQL_TYPE_HANDLER:
8865 ha_read_pos = ha_sql.length();
8866 break;
8867 default:
8868 break;
8869 }
8870 DBUG_VOID_RETURN;
8871 }
8872
set_where_to_pos(ulong sql_type)8873 void spider_mbase_handler::set_where_to_pos(
8874 ulong sql_type
8875 ) {
8876 DBUG_ENTER("spider_mbase_handler::set_where_to_pos");
8877 switch (sql_type)
8878 {
8879 case SPIDER_SQL_TYPE_SELECT_SQL:
8880 case SPIDER_SQL_TYPE_TMP_SQL:
8881 sql.length(where_pos);
8882 break;
8883 case SPIDER_SQL_TYPE_INSERT_SQL:
8884 case SPIDER_SQL_TYPE_UPDATE_SQL:
8885 case SPIDER_SQL_TYPE_DELETE_SQL:
8886 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
8887 update_sql.length(where_pos);
8888 break;
8889 case SPIDER_SQL_TYPE_HANDLER:
8890 ha_sql.length(ha_read_pos);
8891 break;
8892 default:
8893 break;
8894 }
8895 DBUG_VOID_RETURN;
8896 }
8897
check_item_type(Item * item)8898 int spider_mbase_handler::check_item_type(
8899 Item *item
8900 ) {
8901 int error_num;
8902 DBUG_ENTER("spider_mbase_handler::check_item_type");
8903 DBUG_PRINT("info",("spider this=%p", this));
8904 error_num = spider_db_print_item_type(item, NULL, spider, NULL, NULL, 0,
8905 dbton_id, FALSE, NULL);
8906 DBUG_RETURN(error_num);
8907 }
8908
append_values_connector_part(ulong sql_type)8909 int spider_mbase_handler::append_values_connector_part(
8910 ulong sql_type
8911 ) {
8912 int error_num;
8913 spider_string *str;
8914 DBUG_ENTER("spider_mbase_handler::append_values_connector_part");
8915 DBUG_PRINT("info",("spider this=%p", this));
8916 switch (sql_type)
8917 {
8918 case SPIDER_SQL_TYPE_SELECT_SQL:
8919 str = &sql;
8920 break;
8921 case SPIDER_SQL_TYPE_TMP_SQL:
8922 str = &tmp_sql;
8923 break;
8924 default:
8925 DBUG_RETURN(0);
8926 }
8927 error_num = append_values_connector(str);
8928 DBUG_RETURN(error_num);
8929 }
8930
append_values_connector(spider_string * str)8931 int spider_mbase_handler::append_values_connector(
8932 spider_string *str
8933 ) {
8934 DBUG_ENTER("spider_mbase_handler::append_values_connector");
8935 DBUG_PRINT("info",("spider this=%p", this));
8936 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN +
8937 SPIDER_SQL_COMMA_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
8938 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
8939 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
8940 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
8941 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
8942 DBUG_RETURN(0);
8943 }
8944
append_values_terminator_part(ulong sql_type)8945 int spider_mbase_handler::append_values_terminator_part(
8946 ulong sql_type
8947 ) {
8948 int error_num;
8949 spider_string *str;
8950 DBUG_ENTER("spider_mbase_handler::append_values_terminator_part");
8951 DBUG_PRINT("info",("spider this=%p", this));
8952 switch (sql_type)
8953 {
8954 case SPIDER_SQL_TYPE_SELECT_SQL:
8955 str = &sql;
8956 break;
8957 case SPIDER_SQL_TYPE_TMP_SQL:
8958 str = &tmp_sql;
8959 break;
8960 default:
8961 DBUG_RETURN(0);
8962 }
8963 error_num = append_values_terminator(str);
8964 DBUG_RETURN(error_num);
8965 }
8966
append_values_terminator(spider_string * str)8967 int spider_mbase_handler::append_values_terminator(
8968 spider_string *str
8969 ) {
8970 DBUG_ENTER("spider_mbase_handler::append_values_terminator");
8971 DBUG_PRINT("info",("spider this=%p", this));
8972 str->length(str->length() -
8973 SPIDER_SQL_COMMA_LEN - SPIDER_SQL_OPEN_PAREN_LEN);
8974 DBUG_RETURN(0);
8975 }
8976
append_union_table_connector_part(ulong sql_type)8977 int spider_mbase_handler::append_union_table_connector_part(
8978 ulong sql_type
8979 ) {
8980 int error_num;
8981 spider_string *str;
8982 DBUG_ENTER("spider_mbase_handler::append_union_table_connector_part");
8983 DBUG_PRINT("info",("spider this=%p", this));
8984 switch (sql_type)
8985 {
8986 case SPIDER_SQL_TYPE_SELECT_SQL:
8987 str = &sql;
8988 break;
8989 case SPIDER_SQL_TYPE_TMP_SQL:
8990 str = &tmp_sql;
8991 break;
8992 default:
8993 DBUG_RETURN(0);
8994 }
8995 error_num = append_union_table_connector(str);
8996 DBUG_RETURN(error_num);
8997 }
8998
append_union_table_connector(spider_string * str)8999 int spider_mbase_handler::append_union_table_connector(
9000 spider_string *str
9001 ) {
9002 DBUG_ENTER("spider_mbase_handler::append_union_table_connector");
9003 DBUG_PRINT("info",("spider this=%p", this));
9004 if (str->reserve((SPIDER_SQL_SPACE_LEN * 2) + SPIDER_SQL_UNION_ALL_LEN))
9005 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9006 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9007 str->q_append(SPIDER_SQL_UNION_ALL_STR, SPIDER_SQL_UNION_ALL_LEN);
9008 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9009 DBUG_RETURN(0);
9010 }
9011
append_union_table_terminator_part(ulong sql_type)9012 int spider_mbase_handler::append_union_table_terminator_part(
9013 ulong sql_type
9014 ) {
9015 int error_num;
9016 spider_string *str;
9017 DBUG_ENTER("spider_mbase_handler::append_union_table_terminator_part");
9018 DBUG_PRINT("info",("spider this=%p", this));
9019 switch (sql_type)
9020 {
9021 case SPIDER_SQL_TYPE_SELECT_SQL:
9022 str = &sql;
9023 break;
9024 default:
9025 DBUG_RETURN(0);
9026 }
9027 error_num = append_union_table_terminator(str);
9028 DBUG_RETURN(error_num);
9029 }
9030
append_union_table_terminator(spider_string * str)9031 int spider_mbase_handler::append_union_table_terminator(
9032 spider_string *str
9033 ) {
9034 DBUG_ENTER("spider_mbase_handler::append_union_table_terminator");
9035 DBUG_PRINT("info",("spider this=%p", this));
9036 str->length(str->length() -
9037 ((SPIDER_SQL_SPACE_LEN * 2) + SPIDER_SQL_UNION_ALL_LEN));
9038 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
9039 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
9040 table_name_pos = str->length() + SPIDER_SQL_SPACE_LEN + SPIDER_SQL_A_LEN +
9041 SPIDER_SQL_COMMA_LEN;
9042 if (str->reserve(tmp_sql.length() - SPIDER_SQL_FROM_LEN))
9043 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9044 str->q_append(tmp_sql.ptr() + SPIDER_SQL_FROM_LEN,
9045 tmp_sql.length() - SPIDER_SQL_FROM_LEN);
9046 DBUG_RETURN(0);
9047 }
9048
append_key_column_values_part(const key_range * start_key,ulong sql_type)9049 int spider_mbase_handler::append_key_column_values_part(
9050 const key_range *start_key,
9051 ulong sql_type
9052 ) {
9053 int error_num;
9054 spider_string *str;
9055 DBUG_ENTER("spider_mbase_handler::append_key_column_values_part");
9056 switch (sql_type)
9057 {
9058 case SPIDER_SQL_TYPE_SELECT_SQL:
9059 str = &sql;
9060 break;
9061 case SPIDER_SQL_TYPE_TMP_SQL:
9062 str = &tmp_sql;
9063 break;
9064 default:
9065 DBUG_RETURN(0);
9066 }
9067 error_num = append_key_column_values(str, start_key);
9068 DBUG_RETURN(error_num);
9069 }
9070
append_key_column_values(spider_string * str,const key_range * start_key)9071 int spider_mbase_handler::append_key_column_values(
9072 spider_string *str,
9073 const key_range *start_key
9074 ) {
9075 int error_num;
9076 const uchar *ptr;
9077 SPIDER_RESULT_LIST *result_list = &spider->result_list;
9078 SPIDER_SHARE *share = spider->share;
9079 KEY *key_info = result_list->key_info;
9080 uint length;
9081 uint store_length;
9082 key_part_map full_key_part_map =
9083 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
9084 key_part_map start_key_part_map;
9085 KEY_PART_INFO *key_part;
9086 Field *field;
9087 DBUG_ENTER("spider_mbase_handler::append_key_column_values");
9088 start_key_part_map = start_key->keypart_map & full_key_part_map;
9089 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
9090 spider_user_defined_key_parts(key_info)));
9091 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
9092 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
9093
9094 if (!start_key_part_map)
9095 DBUG_RETURN(0);
9096
9097 for (
9098 key_part = key_info->key_part,
9099 length = 0;
9100 start_key_part_map;
9101 start_key_part_map >>= 1,
9102 key_part++,
9103 length += store_length
9104 ) {
9105 store_length = key_part->store_length;
9106 ptr = start_key->key + length;
9107 field = key_part->field;
9108 if ((error_num = spider_db_append_null_value(str, key_part, &ptr)))
9109 {
9110 if (error_num > 0)
9111 DBUG_RETURN(error_num);
9112 } else {
9113 if (spider_db_mbase_utility->append_column_value(spider, str, field, ptr,
9114 share->access_charset))
9115 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9116 }
9117
9118 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9119 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9120 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9121 }
9122 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
9123 DBUG_RETURN(0);
9124 }
9125
append_key_column_values_with_name_part(const key_range * start_key,ulong sql_type)9126 int spider_mbase_handler::append_key_column_values_with_name_part(
9127 const key_range *start_key,
9128 ulong sql_type
9129 ) {
9130 int error_num;
9131 spider_string *str;
9132 DBUG_ENTER("spider_mbase_handler::append_key_column_values_with_name_part");
9133 switch (sql_type)
9134 {
9135 case SPIDER_SQL_TYPE_SELECT_SQL:
9136 str = &sql;
9137 break;
9138 case SPIDER_SQL_TYPE_TMP_SQL:
9139 str = &tmp_sql;
9140 break;
9141 default:
9142 DBUG_RETURN(0);
9143 }
9144 error_num = append_key_column_values_with_name(str, start_key);
9145 DBUG_RETURN(error_num);
9146 }
9147
append_key_column_values_with_name(spider_string * str,const key_range * start_key)9148 int spider_mbase_handler::append_key_column_values_with_name(
9149 spider_string *str,
9150 const key_range *start_key
9151 ) {
9152 int error_num;
9153 const uchar *ptr;
9154 SPIDER_RESULT_LIST *result_list = &spider->result_list;
9155 SPIDER_SHARE *share = spider->share;
9156 KEY *key_info = result_list->key_info;
9157 uint length;
9158 uint key_name_length, key_count;
9159 uint store_length;
9160 key_part_map full_key_part_map =
9161 make_prev_keypart_map(spider_user_defined_key_parts(key_info));
9162 key_part_map start_key_part_map;
9163 KEY_PART_INFO *key_part;
9164 Field *field;
9165 char tmp_buf[MAX_FIELD_WIDTH];
9166 DBUG_ENTER("spider_mbase_handler::append_key_column_values_with_name");
9167 start_key_part_map = start_key->keypart_map & full_key_part_map;
9168 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
9169 spider_user_defined_key_parts(key_info)));
9170 DBUG_PRINT("info", ("spider full_key_part_map=%lu", full_key_part_map));
9171 DBUG_PRINT("info", ("spider start_key_part_map=%lu", start_key_part_map));
9172
9173 if (!start_key_part_map)
9174 DBUG_RETURN(0);
9175
9176 for (
9177 key_part = key_info->key_part,
9178 length = 0,
9179 key_count = 0;
9180 start_key_part_map;
9181 start_key_part_map >>= 1,
9182 key_part++,
9183 length += store_length,
9184 key_count++
9185 ) {
9186 store_length = key_part->store_length;
9187 ptr = start_key->key + length;
9188 field = key_part->field;
9189 if ((error_num = spider_db_append_null_value(str, key_part, &ptr)))
9190 {
9191 if (error_num > 0)
9192 DBUG_RETURN(error_num);
9193 } else {
9194 if (spider_db_mbase_utility->append_column_value(spider, str, field, ptr,
9195 share->access_charset))
9196 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9197 }
9198
9199 key_name_length = my_sprintf(tmp_buf, (tmp_buf, "c%u", key_count));
9200 if (str->reserve(SPIDER_SQL_SPACE_LEN + key_name_length +
9201 SPIDER_SQL_COMMA_LEN))
9202 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9203 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9204 str->q_append(tmp_buf, key_name_length);
9205 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9206 }
9207 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
9208 DBUG_RETURN(0);
9209 }
9210
append_key_where_part(const key_range * start_key,const key_range * end_key,ulong sql_type)9211 int spider_mbase_handler::append_key_where_part(
9212 const key_range *start_key,
9213 const key_range *end_key,
9214 ulong sql_type
9215 ) {
9216 int error_num;
9217 spider_string *str, *str_part = NULL, *str_part2 = NULL;
9218 bool set_order;
9219 DBUG_ENTER("spider_mbase_handler::append_key_where_part");
9220 switch (sql_type)
9221 {
9222 case SPIDER_SQL_TYPE_SELECT_SQL:
9223 str = &sql;
9224 set_order = FALSE;
9225 break;
9226 case SPIDER_SQL_TYPE_TMP_SQL:
9227 str = &tmp_sql;
9228 set_order = FALSE;
9229 break;
9230 case SPIDER_SQL_TYPE_INSERT_SQL:
9231 case SPIDER_SQL_TYPE_UPDATE_SQL:
9232 case SPIDER_SQL_TYPE_DELETE_SQL:
9233 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
9234 str = &update_sql;
9235 set_order = FALSE;
9236 break;
9237 case SPIDER_SQL_TYPE_HANDLER:
9238 str = &ha_sql;
9239 ha_read_pos = str->length();
9240 str_part = &sql_part;
9241 str_part2 = &sql_part2;
9242 str_part->length(0);
9243 str_part2->length(0);
9244 set_order = TRUE;
9245 break;
9246 default:
9247 DBUG_RETURN(0);
9248 }
9249 error_num = append_key_where(str, str_part, str_part2, start_key, end_key,
9250 sql_type, set_order);
9251 DBUG_RETURN(error_num);
9252 }
9253
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)9254 int spider_mbase_handler::append_key_where(
9255 spider_string *str,
9256 spider_string *str_part,
9257 spider_string *str_part2,
9258 const key_range *start_key,
9259 const key_range *end_key,
9260 ulong sql_type,
9261 bool set_order
9262 ) {
9263 int error_num;
9264 DBUG_ENTER("spider_mbase_handler::append_key_where");
9265 error_num = spider_db_append_key_where_internal(str, str_part, str_part2,
9266 start_key, end_key, spider, set_order, sql_type,
9267 dbton_id);
9268 DBUG_RETURN(error_num);
9269 }
9270
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)9271 int spider_mbase_handler::append_is_null_part(
9272 ulong sql_type,
9273 KEY_PART_INFO *key_part,
9274 const key_range *key,
9275 const uchar **ptr,
9276 bool key_eq,
9277 bool tgt_final
9278 ) {
9279 int error_num;
9280 spider_string *str, *str_part = NULL, *str_part2 = NULL;
9281 DBUG_ENTER("spider_mbase_handler::append_is_null_part");
9282 DBUG_PRINT("info",("spider this=%p", this));
9283 switch (sql_type)
9284 {
9285 case SPIDER_SQL_TYPE_SELECT_SQL:
9286 case SPIDER_SQL_TYPE_TMP_SQL:
9287 str = &sql;
9288 break;
9289 case SPIDER_SQL_TYPE_INSERT_SQL:
9290 case SPIDER_SQL_TYPE_UPDATE_SQL:
9291 case SPIDER_SQL_TYPE_DELETE_SQL:
9292 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
9293 str = &update_sql;
9294 break;
9295 case SPIDER_SQL_TYPE_HANDLER:
9296 str = &ha_sql;
9297 str_part = &sql_part;
9298 str_part2 = &sql_part2;
9299 break;
9300 default:
9301 DBUG_RETURN(0);
9302 }
9303 error_num = append_is_null(sql_type, str, str_part, str_part2,
9304 key_part, key, ptr, key_eq, tgt_final);
9305 DBUG_RETURN(error_num);
9306 }
9307
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)9308 int spider_mbase_handler::append_is_null(
9309 ulong sql_type,
9310 spider_string *str,
9311 spider_string *str_part,
9312 spider_string *str_part2,
9313 KEY_PART_INFO *key_part,
9314 const key_range *key,
9315 const uchar **ptr,
9316 bool key_eq,
9317 bool tgt_final
9318 ) {
9319 DBUG_ENTER("spider_mbase_handler::append_is_null");
9320 DBUG_PRINT("info",("spider this=%p", this));
9321 DBUG_PRINT("info",("spider key_eq=%s", key_eq ? "TRUE" : "FALSE"));
9322 if (key_part->null_bit)
9323 {
9324 if (*(*ptr)++)
9325 {
9326 if (sql_type == SPIDER_SQL_TYPE_HANDLER)
9327 {
9328 if (
9329 key_eq ||
9330 key->flag == HA_READ_KEY_EXACT ||
9331 key->flag == HA_READ_KEY_OR_NEXT
9332 ) {
9333 if (tgt_final)
9334 {
9335 if (str->reserve(SPIDER_SQL_EQUAL_LEN))
9336 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9337 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
9338 }
9339 str = str_part;
9340 if (str->reserve(SPIDER_SQL_NULL_LEN))
9341 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9342 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
9343 } else {
9344 if (str_part->length() == SPIDER_SQL_OPEN_PAREN_LEN)
9345 {
9346 str = str_part;
9347 /* first index column */
9348 str->length(str->length() - SPIDER_SQL_OPEN_PAREN_LEN);
9349 ha_next_pos = str->length();
9350 if (str->reserve(SPIDER_SQL_FIRST_LEN))
9351 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9352 str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN);
9353 spider->result_list.ha_read_kind = 1;
9354 } else if (tgt_final)
9355 {
9356 if (str->reserve(SPIDER_SQL_GT_LEN))
9357 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9358 str->q_append(SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN);
9359 str = str_part;
9360 if (str->reserve(SPIDER_SQL_NULL_LEN))
9361 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9362 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
9363 }
9364 }
9365 str = str_part2;
9366 }
9367 if (
9368 key_eq ||
9369 key->flag == HA_READ_KEY_EXACT ||
9370 key->flag == HA_READ_KEY_OR_NEXT
9371 ) {
9372 if (str->reserve(SPIDER_SQL_IS_NULL_LEN +
9373 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9374 mysql_share->column_name_str[key_part->field->field_index].length()))
9375 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9376 mysql_share->append_column_name(str, key_part->field->field_index);
9377 str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN);
9378 } else {
9379 if (str->reserve(SPIDER_SQL_IS_NOT_NULL_LEN +
9380 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9381 mysql_share->column_name_str[key_part->field->field_index].length()))
9382 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9383 mysql_share->append_column_name(str, key_part->field->field_index);
9384 str->q_append(SPIDER_SQL_IS_NOT_NULL_STR, SPIDER_SQL_IS_NOT_NULL_LEN);
9385 }
9386 DBUG_RETURN(-1);
9387 }
9388 }
9389 DBUG_RETURN(0);
9390 }
9391
append_where_terminator_part(ulong sql_type,bool set_order,int key_count)9392 int spider_mbase_handler::append_where_terminator_part(
9393 ulong sql_type,
9394 bool set_order,
9395 int key_count
9396 ) {
9397 int error_num;
9398 spider_string *str, *str_part = NULL, *str_part2 = NULL;
9399 DBUG_ENTER("spider_mbase_handler::append_where_terminator_part");
9400 DBUG_PRINT("info",("spider this=%p", this));
9401 switch (sql_type)
9402 {
9403 case SPIDER_SQL_TYPE_SELECT_SQL:
9404 case SPIDER_SQL_TYPE_TMP_SQL:
9405 str = &sql;
9406 break;
9407 case SPIDER_SQL_TYPE_INSERT_SQL:
9408 case SPIDER_SQL_TYPE_UPDATE_SQL:
9409 case SPIDER_SQL_TYPE_DELETE_SQL:
9410 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
9411 str = &update_sql;
9412 break;
9413 case SPIDER_SQL_TYPE_HANDLER:
9414 str = &ha_sql;
9415 str_part = &sql_part;
9416 str_part2 = &sql_part2;
9417 break;
9418 default:
9419 DBUG_RETURN(0);
9420 }
9421 error_num = append_where_terminator(sql_type, str, str_part, str_part2,
9422 set_order, key_count);
9423 DBUG_RETURN(error_num);
9424 }
9425
append_where_terminator(ulong sql_type,spider_string * str,spider_string * str_part,spider_string * str_part2,bool set_order,int key_count)9426 int spider_mbase_handler::append_where_terminator(
9427 ulong sql_type,
9428 spider_string *str,
9429 spider_string *str_part,
9430 spider_string *str_part2,
9431 bool set_order,
9432 int key_count
9433 ) {
9434 SPIDER_RESULT_LIST *result_list = &spider->result_list;
9435 DBUG_ENTER("spider_mbase_handler::append_where_terminator");
9436 DBUG_PRINT("info",("spider this=%p", this));
9437 if (sql_type != SPIDER_SQL_TYPE_HANDLER)
9438 {
9439 str->length(str->length() - SPIDER_SQL_AND_LEN);
9440 if (!set_order)
9441 result_list->key_order = key_count;
9442 } else {
9443 str_part2->length(str_part2->length() - SPIDER_SQL_AND_LEN);
9444
9445 str_part->length(str_part->length() - SPIDER_SQL_COMMA_LEN);
9446 if (!result_list->ha_read_kind)
9447 str_part->q_append(SPIDER_SQL_CLOSE_PAREN_STR,
9448 SPIDER_SQL_CLOSE_PAREN_LEN);
9449 if (str->append(*str_part))
9450 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9451 uint clause_length = str->length() - ha_next_pos;
9452 if (clause_length < SPIDER_SQL_NEXT_LEN)
9453 {
9454 int roop_count;
9455 clause_length = SPIDER_SQL_NEXT_LEN - clause_length;
9456 if (str->reserve(clause_length))
9457 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9458 for (roop_count = 0; roop_count < (int) clause_length; roop_count++)
9459 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
9460 }
9461 }
9462 DBUG_RETURN(0);
9463 }
9464
append_match_where_part(ulong sql_type)9465 int spider_mbase_handler::append_match_where_part(
9466 ulong sql_type
9467 ) {
9468 int error_num;
9469 spider_string *str;
9470 DBUG_ENTER("spider_mbase_handler::append_match_where_part");
9471 switch (sql_type)
9472 {
9473 case SPIDER_SQL_TYPE_SELECT_SQL:
9474 str = &sql;
9475 break;
9476 default:
9477 DBUG_ASSERT(0);
9478 DBUG_RETURN(0);
9479 }
9480 error_num = append_match_where(str);
9481 DBUG_RETURN(error_num);
9482 }
9483
append_match_where(spider_string * str)9484 int spider_mbase_handler::append_match_where(
9485 spider_string *str
9486 ) {
9487 int error_num;
9488 bool first = TRUE;
9489 st_spider_ft_info *ft_info = spider->ft_first;
9490 DBUG_ENTER("spider_mbase_handler::append_match_where");
9491 if (spider->ft_current)
9492 {
9493 while (TRUE)
9494 {
9495 if (ft_info->used_in_where)
9496 {
9497 if (first)
9498 {
9499 if (str->reserve(SPIDER_SQL_WHERE_LEN))
9500 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9501 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
9502 first = FALSE;
9503 }
9504 if ((error_num = append_match_against(str, ft_info, NULL, 0)))
9505 DBUG_RETURN(error_num);
9506 if (str->reserve(SPIDER_SQL_AND_LEN))
9507 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9508 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
9509 }
9510
9511 if (ft_info == spider->ft_current)
9512 break;
9513 ft_info = ft_info->next;
9514 }
9515 if (!first)
9516 str->length(str->length() - SPIDER_SQL_AND_LEN);
9517 }
9518 DBUG_RETURN(0);
9519 }
9520
append_update_where(spider_string * str,const TABLE * table,my_ptrdiff_t ptr_diff)9521 int spider_mbase_handler::append_update_where(
9522 spider_string *str,
9523 const TABLE *table,
9524 my_ptrdiff_t ptr_diff
9525 ) {
9526 uint field_name_length;
9527 Field **field;
9528 THD *thd = spider->trx->thd;
9529 SPIDER_SHARE *share = spider->share;
9530 bool no_pk = (table->s->primary_key == MAX_KEY);
9531 DBUG_ENTER("spider_mbase_handler::append_update_where");
9532 DBUG_PRINT("info", ("spider table->s->primary_key=%s",
9533 table->s->primary_key != MAX_KEY ? "TRUE" : "FALSE"));
9534 uint str_len_bakup = str->length();
9535 if (str->reserve(SPIDER_SQL_WHERE_LEN))
9536 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9537 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
9538
9539 if (
9540 no_pk ||
9541 spider_param_use_cond_other_than_pk_for_update(thd)
9542 ) {
9543 for (field = table->field; *field; field++)
9544 {
9545 if (
9546 no_pk ||
9547 bitmap_is_set(table->read_set, (*field)->field_index)
9548 ) {
9549 field_name_length =
9550 mysql_share->column_name_str[(*field)->field_index].length();
9551 if ((*field)->is_null(ptr_diff))
9552 {
9553 if (str->reserve(field_name_length +
9554 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9555 SPIDER_SQL_IS_NULL_LEN + SPIDER_SQL_AND_LEN))
9556 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9557 mysql_share->append_column_name(str, (*field)->field_index);
9558 str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN);
9559 } else {
9560 if (str->reserve(field_name_length +
9561 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9562 SPIDER_SQL_EQUAL_LEN))
9563 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9564 mysql_share->append_column_name(str, (*field)->field_index);
9565 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
9566 (*field)->move_field_offset(ptr_diff);
9567 if (
9568 spider_db_mbase_utility->
9569 append_column_value(spider, str, *field, NULL,
9570 share->access_charset) ||
9571 str->reserve(SPIDER_SQL_AND_LEN)
9572 )
9573 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9574 (*field)->move_field_offset(-ptr_diff);
9575 }
9576 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
9577 }
9578 }
9579 } else {
9580 KEY *key_info = &table->key_info[table->s->primary_key];
9581 KEY_PART_INFO *key_part;
9582 uint part_num;
9583 for (
9584 key_part = key_info->key_part, part_num = 0;
9585 part_num < spider_user_defined_key_parts(key_info);
9586 key_part++, part_num++
9587 ) {
9588 field = &key_part->field;
9589 field_name_length =
9590 mysql_share->column_name_str[(*field)->field_index].length();
9591 if ((*field)->is_null(ptr_diff))
9592 {
9593 if (str->reserve(field_name_length +
9594 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9595 SPIDER_SQL_IS_NULL_LEN + SPIDER_SQL_AND_LEN))
9596 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9597 mysql_share->append_column_name(str, (*field)->field_index);
9598 str->q_append(SPIDER_SQL_IS_NULL_STR, SPIDER_SQL_IS_NULL_LEN);
9599 } else {
9600 if (str->reserve(field_name_length +
9601 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
9602 SPIDER_SQL_EQUAL_LEN))
9603 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9604 mysql_share->append_column_name(str, (*field)->field_index);
9605 str->q_append(SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN);
9606 (*field)->move_field_offset(ptr_diff);
9607 if (
9608 spider_db_mbase_utility->
9609 append_column_value(spider, str, *field, NULL,
9610 share->access_charset) ||
9611 str->reserve(SPIDER_SQL_AND_LEN)
9612 )
9613 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9614 (*field)->move_field_offset(-ptr_diff);
9615 }
9616 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
9617 }
9618 }
9619 if (str->length() == str_len_bakup + SPIDER_SQL_WHERE_LEN)
9620 {
9621 /* no condition */
9622 str->length(str_len_bakup);
9623 } else {
9624 str->length(str->length() - SPIDER_SQL_AND_LEN);
9625 }
9626 if (str->reserve(SPIDER_SQL_LIMIT1_LEN))
9627 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9628 str->q_append(SPIDER_SQL_LIMIT1_STR, SPIDER_SQL_LIMIT1_LEN);
9629 DBUG_RETURN(0);
9630 }
9631
append_condition_part(const char * alias,uint alias_length,ulong sql_type,bool test_flg)9632 int spider_mbase_handler::append_condition_part(
9633 const char *alias,
9634 uint alias_length,
9635 ulong sql_type,
9636 bool test_flg
9637 ) {
9638 int error_num;
9639 spider_string *str;
9640 bool start_where = FALSE;
9641 DBUG_ENTER("spider_mbase_handler::append_condition_part");
9642 switch (sql_type)
9643 {
9644 case SPIDER_SQL_TYPE_SELECT_SQL:
9645 if (test_flg)
9646 {
9647 str = NULL;
9648 } else {
9649 str = &sql;
9650 start_where = ((int) str->length() == where_pos);
9651 }
9652 break;
9653 case SPIDER_SQL_TYPE_TMP_SQL:
9654 if (test_flg)
9655 {
9656 str = NULL;
9657 } else {
9658 str = &tmp_sql;
9659 start_where = ((int) str->length() == where_pos);
9660 }
9661 break;
9662 case SPIDER_SQL_TYPE_INSERT_SQL:
9663 case SPIDER_SQL_TYPE_UPDATE_SQL:
9664 case SPIDER_SQL_TYPE_DELETE_SQL:
9665 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
9666 if (test_flg)
9667 {
9668 str = NULL;
9669 } else {
9670 str = &update_sql;
9671 start_where = ((int) str->length() == where_pos);
9672 }
9673 break;
9674 case SPIDER_SQL_TYPE_HANDLER:
9675 if (test_flg)
9676 {
9677 str = NULL;
9678 } else {
9679 str = &ha_sql;
9680 start_where = TRUE;
9681 if (spider->active_index == MAX_KEY)
9682 {
9683 set_where_pos(SPIDER_SQL_TYPE_HANDLER);
9684 if (str->reserve(SPIDER_SQL_READ_LEN + SPIDER_SQL_FIRST_LEN))
9685 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9686 str->q_append(SPIDER_SQL_READ_STR, SPIDER_SQL_READ_LEN);
9687 ha_next_pos = str->length();
9688 str->q_append(SPIDER_SQL_FIRST_STR, SPIDER_SQL_FIRST_LEN);
9689 sql_part2.length(0);
9690 }
9691 ha_where_pos = str->length();
9692
9693 if (
9694 spider->sql_command == SQLCOM_HA_READ ||
9695 !spider->result_list.use_both_key
9696 ) {
9697 if (sql_part2.length())
9698 {
9699 str->append(sql_part2);
9700 start_where = FALSE;
9701 }
9702 } else {
9703 DBUG_RETURN(0);
9704 }
9705 }
9706 break;
9707 default:
9708 DBUG_RETURN(0);
9709 }
9710 error_num = append_condition(str, alias, alias_length, start_where,
9711 sql_type);
9712 DBUG_RETURN(error_num);
9713 }
9714
append_condition(spider_string * str,const char * alias,uint alias_length,bool start_where,ulong sql_type)9715 int spider_mbase_handler::append_condition(
9716 spider_string *str,
9717 const char *alias,
9718 uint alias_length,
9719 bool start_where,
9720 ulong sql_type
9721 ) {
9722 int error_num, restart_pos = 0, start_where_pos;
9723 SPIDER_CONDITION *tmp_cond = spider->condition;
9724 DBUG_ENTER("spider_mbase_handler::append_condition");
9725 if (str && start_where)
9726 {
9727 start_where_pos = str->length();
9728 } else {
9729 start_where_pos = 0;
9730 }
9731
9732 if (spider->is_clone && !tmp_cond)
9733 {
9734 tmp_cond = spider->pt_clone_source_handler->condition;
9735 }
9736
9737 while (tmp_cond)
9738 {
9739 if (str)
9740 {
9741 restart_pos = str->length();
9742 if (start_where)
9743 {
9744 if (str->reserve(SPIDER_SQL_WHERE_LEN))
9745 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9746 str->q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
9747 start_where = FALSE;
9748 } else {
9749 if (str->reserve(SPIDER_SQL_AND_LEN))
9750 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9751 str->q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
9752 }
9753 }
9754 if ((error_num = spider_db_print_item_type(
9755 (Item *) tmp_cond->cond, NULL, spider, str, alias, alias_length,
9756 dbton_id, FALSE, NULL)))
9757 {
9758 if (str && error_num == ER_SPIDER_COND_SKIP_NUM)
9759 {
9760 DBUG_PRINT("info",("spider COND skip"));
9761 str->length(restart_pos);
9762 start_where = (restart_pos == start_where_pos);
9763 } else
9764 DBUG_RETURN(error_num);
9765 }
9766 tmp_cond = tmp_cond->next;
9767 }
9768 DBUG_RETURN(0);
9769 }
9770
append_match_against_part(ulong sql_type,st_spider_ft_info * ft_info,const char * alias,uint alias_length)9771 int spider_mbase_handler::append_match_against_part(
9772 ulong sql_type,
9773 st_spider_ft_info *ft_info,
9774 const char *alias,
9775 uint alias_length
9776 ) {
9777 int error_num;
9778 spider_string *str;
9779 DBUG_ENTER("spider_mbase_handler::append_match_against_part");
9780 DBUG_PRINT("info",("spider this=%p", this));
9781 switch (sql_type)
9782 {
9783 case SPIDER_SQL_TYPE_SELECT_SQL:
9784 str = &sql;
9785 break;
9786 default:
9787 DBUG_RETURN(0);
9788 }
9789 error_num = append_match_against(str, ft_info, alias, alias_length);
9790 DBUG_RETURN(error_num);
9791 }
9792
append_match_against(spider_string * str,st_spider_ft_info * ft_info,const char * alias,uint alias_length)9793 int spider_mbase_handler::append_match_against(
9794 spider_string *str,
9795 st_spider_ft_info *ft_info,
9796 const char *alias,
9797 uint alias_length
9798 ) {
9799 SPIDER_SHARE *share = spider->share;
9800 TABLE *table = spider->get_table();
9801 String *ft_init_key;
9802 KEY *key_info;
9803 uint key_name_length;
9804 int key_count;
9805 KEY_PART_INFO *key_part;
9806 Field *field;
9807 DBUG_ENTER("spider_mbase_handler::append_match_against");
9808 DBUG_PRINT("info",("spider this=%p", this));
9809 if (str->reserve(SPIDER_SQL_MATCH_LEN))
9810 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9811 str->q_append(SPIDER_SQL_MATCH_STR, SPIDER_SQL_MATCH_LEN);
9812
9813 ft_init_key = ft_info->key;
9814 key_info = &table->key_info[ft_info->inx];
9815 DBUG_PRINT("info", ("spider spider_user_defined_key_parts=%u",
9816 spider_user_defined_key_parts(key_info)));
9817
9818 for (
9819 key_part = key_info->key_part,
9820 key_count = 0;
9821 key_count < (int) spider_user_defined_key_parts(key_info);
9822 key_part++,
9823 key_count++
9824 ) {
9825 field = key_part->field;
9826 key_name_length =
9827 mysql_share->column_name_str[field->field_index].length();
9828 if (alias_length)
9829 {
9830 if (str->reserve(alias_length + key_name_length +
9831 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
9832 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9833 str->q_append(alias, alias_length);
9834 } else {
9835 if (str->reserve(key_name_length +
9836 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
9837 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9838 }
9839 mysql_share->append_column_name(str, field->field_index);
9840 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9841 }
9842 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
9843 if (str->reserve(SPIDER_SQL_AGAINST_LEN + SPIDER_SQL_VALUE_QUOTE_LEN))
9844 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9845 str->q_append(SPIDER_SQL_AGAINST_STR, SPIDER_SQL_AGAINST_LEN);
9846 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9847
9848 char buf[MAX_FIELD_WIDTH];
9849 spider_string tmp_str(buf, MAX_FIELD_WIDTH, share->access_charset);
9850 tmp_str.init_calc_mem(116);
9851 tmp_str.length(0);
9852 if (
9853 tmp_str.append(ft_init_key->ptr(), ft_init_key->length(),
9854 ft_init_key->charset()) ||
9855 str->reserve(tmp_str.length() * 2) ||
9856 spider_db_mbase_utility->append_escaped_util(str, tmp_str.get_str())
9857 )
9858 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9859 str->mem_calc();
9860
9861 if (str->reserve(
9862 SPIDER_SQL_VALUE_QUOTE_LEN + SPIDER_SQL_CLOSE_PAREN_LEN +
9863 ((ft_info->flags & FT_BOOL) ? SPIDER_SQL_IN_BOOLEAN_MODE_LEN : 0) +
9864 ((ft_info->flags & FT_EXPAND) ?
9865 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN : 0)
9866 ))
9867 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9868 str->q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
9869 if (ft_info->flags & FT_BOOL)
9870 str->q_append(SPIDER_SQL_IN_BOOLEAN_MODE_STR,
9871 SPIDER_SQL_IN_BOOLEAN_MODE_LEN);
9872 if (ft_info->flags & FT_EXPAND)
9873 str->q_append(SPIDER_SQL_WITH_QUERY_EXPANSION_STR,
9874 SPIDER_SQL_WITH_QUERY_EXPANSION_LEN);
9875 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
9876 DBUG_RETURN(0);
9877 }
9878
append_match_select_part(ulong sql_type,const char * alias,uint alias_length)9879 int spider_mbase_handler::append_match_select_part(
9880 ulong sql_type,
9881 const char *alias,
9882 uint alias_length
9883 ) {
9884 int error_num;
9885 spider_string *str;
9886 DBUG_ENTER("spider_mbase_handler::append_match_select_part");
9887 DBUG_PRINT("info",("spider this=%p", this));
9888 switch (sql_type)
9889 {
9890 case SPIDER_SQL_TYPE_SELECT_SQL:
9891 str = &sql;
9892 break;
9893 default:
9894 DBUG_RETURN(0);
9895 }
9896 error_num = append_match_select(str, alias, alias_length);
9897 DBUG_RETURN(error_num);
9898 }
9899
append_match_select(spider_string * str,const char * alias,uint alias_length)9900 int spider_mbase_handler::append_match_select(
9901 spider_string *str,
9902 const char *alias,
9903 uint alias_length
9904 ) {
9905 int error_num;
9906 DBUG_ENTER("spider_mbase_handler::append_match_select");
9907 DBUG_PRINT("info",("spider this=%p", this));
9908 if (spider->ft_current)
9909 {
9910 st_spider_ft_info *ft_info = spider->ft_first;
9911 while (TRUE)
9912 {
9913 if ((error_num = append_match_against(str, ft_info,
9914 alias, alias_length)))
9915 DBUG_RETURN(error_num);
9916 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9917 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9918 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9919 if (ft_info == spider->ft_current)
9920 break;
9921 ft_info = ft_info->next;
9922 }
9923 }
9924 DBUG_RETURN(0);
9925 }
9926
9927 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
append_sum_select_part(ulong sql_type,const char * alias,uint alias_length)9928 int spider_mbase_handler::append_sum_select_part(
9929 ulong sql_type,
9930 const char *alias,
9931 uint alias_length
9932 ) {
9933 int error_num;
9934 spider_string *str;
9935 DBUG_ENTER("spider_mbase_handler::append_sum_select_part");
9936 DBUG_PRINT("info",("spider this=%p", this));
9937 switch (sql_type)
9938 {
9939 case SPIDER_SQL_TYPE_SELECT_SQL:
9940 str = &sql;
9941 break;
9942 default:
9943 DBUG_RETURN(0);
9944 }
9945 error_num = append_sum_select(str, alias, alias_length);
9946 DBUG_RETURN(error_num);
9947 }
9948
append_sum_select(spider_string * str,const char * alias,uint alias_length)9949 int spider_mbase_handler::append_sum_select(
9950 spider_string *str,
9951 const char *alias,
9952 uint alias_length
9953 ) {
9954 int error_num;
9955 st_select_lex *select_lex;
9956 DBUG_ENTER("spider_mbase_handler::append_sum_select");
9957 DBUG_PRINT("info",("spider this=%p", this));
9958 select_lex = spider_get_select_lex(spider);
9959 JOIN *join = select_lex->join;
9960 Item_sum **item_sum_ptr;
9961 for (item_sum_ptr = join->sum_funcs; *item_sum_ptr; ++item_sum_ptr)
9962 {
9963 if ((error_num = spider_db_mbase_utility->open_item_sum_func(*item_sum_ptr,
9964 spider, str, alias, alias_length, FALSE, NULL)))
9965 {
9966 DBUG_RETURN(error_num);
9967 }
9968 if (str->reserve(SPIDER_SQL_COMMA_LEN))
9969 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
9970 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
9971 }
9972 DBUG_RETURN(0);
9973 }
9974 #endif
9975
set_order_pos(ulong sql_type)9976 void spider_mbase_handler::set_order_pos(
9977 ulong sql_type
9978 ) {
9979 DBUG_ENTER("spider_mbase_handler::set_order_pos");
9980 switch (sql_type)
9981 {
9982 case SPIDER_SQL_TYPE_SELECT_SQL:
9983 case SPIDER_SQL_TYPE_TMP_SQL:
9984 order_pos = sql.length();
9985 break;
9986 case SPIDER_SQL_TYPE_INSERT_SQL:
9987 case SPIDER_SQL_TYPE_UPDATE_SQL:
9988 case SPIDER_SQL_TYPE_DELETE_SQL:
9989 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
9990 order_pos = update_sql.length();
9991 break;
9992 case SPIDER_SQL_TYPE_HANDLER:
9993 ha_next_pos = ha_sql.length();
9994 break;
9995 default:
9996 DBUG_ASSERT(0);
9997 break;
9998 }
9999 DBUG_VOID_RETURN;
10000 }
10001
set_order_to_pos(ulong sql_type)10002 void spider_mbase_handler::set_order_to_pos(
10003 ulong sql_type
10004 ) {
10005 DBUG_ENTER("spider_mbase_handler::set_order_to_pos");
10006 switch (sql_type)
10007 {
10008 case SPIDER_SQL_TYPE_SELECT_SQL:
10009 case SPIDER_SQL_TYPE_TMP_SQL:
10010 sql.length(order_pos);
10011 break;
10012 case SPIDER_SQL_TYPE_INSERT_SQL:
10013 case SPIDER_SQL_TYPE_UPDATE_SQL:
10014 case SPIDER_SQL_TYPE_DELETE_SQL:
10015 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10016 update_sql.length(order_pos);
10017 break;
10018 case SPIDER_SQL_TYPE_HANDLER:
10019 ha_sql.length(ha_next_pos);
10020 break;
10021 default:
10022 DBUG_ASSERT(0);
10023 break;
10024 }
10025 DBUG_VOID_RETURN;
10026 }
10027
10028 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
append_group_by_part(const char * alias,uint alias_length,ulong sql_type)10029 int spider_mbase_handler::append_group_by_part(
10030 const char *alias,
10031 uint alias_length,
10032 ulong sql_type
10033 ) {
10034 int error_num;
10035 spider_string *str;
10036 DBUG_ENTER("spider_mbase_handler::append_group_by_part");
10037 DBUG_PRINT("info",("spider this=%p", this));
10038 switch (sql_type)
10039 {
10040 case SPIDER_SQL_TYPE_SELECT_SQL:
10041 case SPIDER_SQL_TYPE_TMP_SQL:
10042 str = &sql;
10043 break;
10044 case SPIDER_SQL_TYPE_INSERT_SQL:
10045 case SPIDER_SQL_TYPE_UPDATE_SQL:
10046 case SPIDER_SQL_TYPE_DELETE_SQL:
10047 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10048 str = &update_sql;
10049 break;
10050 case SPIDER_SQL_TYPE_HANDLER:
10051 str = &ha_sql;
10052 break;
10053 default:
10054 DBUG_RETURN(0);
10055 }
10056 error_num = append_group_by(str, alias, alias_length);
10057 DBUG_RETURN(error_num);
10058 }
10059
append_group_by(spider_string * str,const char * alias,uint alias_length)10060 int spider_mbase_handler::append_group_by(
10061 spider_string *str,
10062 const char *alias,
10063 uint alias_length
10064 ) {
10065 int error_num;
10066 st_select_lex *select_lex;
10067 DBUG_ENTER("spider_mbase_handler::append_group_by");
10068 DBUG_PRINT("info",("spider this=%p", this));
10069 select_lex = spider_get_select_lex(spider);
10070 ORDER *group = (ORDER *) select_lex->group_list.first;
10071 if (group)
10072 {
10073 if (str->reserve(SPIDER_SQL_GROUP_LEN))
10074 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10075 str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN);
10076 for (; group; group = group->next)
10077 {
10078 if ((error_num = spider_db_print_item_type((*group->item), NULL, spider,
10079 str, alias, alias_length, dbton_id, FALSE, NULL)))
10080 {
10081 DBUG_RETURN(error_num);
10082 }
10083 if (str->reserve(SPIDER_SQL_COMMA_LEN))
10084 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10085 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10086 }
10087 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10088 }
10089 DBUG_RETURN(0);
10090 }
10091 #endif
10092
append_key_order_for_merge_with_alias_part(const char * alias,uint alias_length,ulong sql_type)10093 int spider_mbase_handler::append_key_order_for_merge_with_alias_part(
10094 const char *alias,
10095 uint alias_length,
10096 ulong sql_type
10097 ) {
10098 int error_num;
10099 spider_string *str;
10100 DBUG_ENTER("spider_mbase_handler::append_key_order_for_merge_with_alias_part");
10101 DBUG_PRINT("info",("spider this=%p", this));
10102 switch (sql_type)
10103 {
10104 case SPIDER_SQL_TYPE_SELECT_SQL:
10105 case SPIDER_SQL_TYPE_TMP_SQL:
10106 str = &sql;
10107 break;
10108 case SPIDER_SQL_TYPE_INSERT_SQL:
10109 case SPIDER_SQL_TYPE_UPDATE_SQL:
10110 case SPIDER_SQL_TYPE_DELETE_SQL:
10111 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10112 str = &update_sql;
10113 break;
10114 case SPIDER_SQL_TYPE_HANDLER:
10115 str = &ha_sql;
10116 ha_limit_pos = ha_sql.length();
10117 break;
10118 default:
10119 DBUG_RETURN(0);
10120 }
10121 error_num = append_key_order_for_merge_with_alias(str, alias, alias_length);
10122 DBUG_RETURN(error_num);
10123 }
10124
append_key_order_for_merge_with_alias(spider_string * str,const char * alias,uint alias_length)10125 int spider_mbase_handler::append_key_order_for_merge_with_alias(
10126 spider_string *str,
10127 const char *alias,
10128 uint alias_length
10129 ) {
10130 /* sort for index merge */
10131 TABLE *table = spider->get_table();
10132 int length;
10133 Field *field;
10134 uint key_name_length;
10135 DBUG_ENTER("spider_mbase_handler::append_key_order_for_merge_with_alias");
10136 DBUG_PRINT("info",("spider this=%p", this));
10137 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
10138 if (spider->result_list.direct_aggregate)
10139 {
10140 int error_num;
10141 if ((error_num = append_group_by(str, alias, alias_length)))
10142 DBUG_RETURN(error_num);
10143 }
10144 #endif
10145 if (table->s->primary_key < MAX_KEY)
10146 {
10147 /* sort by primary key */
10148 KEY *key_info = &table->key_info[table->s->primary_key];
10149 KEY_PART_INFO *key_part;
10150 for (
10151 key_part = key_info->key_part,
10152 length = 1;
10153 length <= (int) spider_user_defined_key_parts(key_info);
10154 key_part++,
10155 length++
10156 ) {
10157 field = key_part->field;
10158 key_name_length =
10159 mysql_share->column_name_str[field->field_index].length();
10160 if (length == 1)
10161 {
10162 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10163 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10164 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10165 }
10166 if (str->reserve(alias_length + key_name_length +
10167 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
10168 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10169 str->q_append(alias, alias_length);
10170 mysql_share->append_column_name(str, field->field_index);
10171 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10172 }
10173 if (length > 1)
10174 {
10175 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10176 }
10177 } else {
10178 /* sort by all columns */
10179 Field **fieldp;
10180 for (
10181 fieldp = table->field, length = 1;
10182 *fieldp;
10183 fieldp++, length++
10184 ) {
10185 key_name_length =
10186 mysql_share->column_name_str[(*fieldp)->field_index].length();
10187 if (length == 1)
10188 {
10189 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10190 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10191 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10192 }
10193 if (str->reserve(alias_length + key_name_length +
10194 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
10195 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10196 str->q_append(alias, alias_length);
10197 mysql_share->append_column_name(str, (*fieldp)->field_index);
10198 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10199 }
10200 if (length > 1)
10201 {
10202 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10203 }
10204 }
10205 limit_pos = str->length();
10206 DBUG_RETURN(0);
10207 }
10208
append_key_order_for_direct_order_limit_with_alias_part(const char * alias,uint alias_length,ulong sql_type)10209 int spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias_part(
10210 const char *alias,
10211 uint alias_length,
10212 ulong sql_type
10213 ) {
10214 int error_num;
10215 spider_string *str;
10216 DBUG_ENTER("spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias_part");
10217 DBUG_PRINT("info",("spider this=%p", this));
10218 switch (sql_type)
10219 {
10220 case SPIDER_SQL_TYPE_SELECT_SQL:
10221 case SPIDER_SQL_TYPE_TMP_SQL:
10222 str = &sql;
10223 break;
10224 case SPIDER_SQL_TYPE_INSERT_SQL:
10225 case SPIDER_SQL_TYPE_UPDATE_SQL:
10226 case SPIDER_SQL_TYPE_DELETE_SQL:
10227 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10228 str = &update_sql;
10229 break;
10230 case SPIDER_SQL_TYPE_HANDLER:
10231 str = &ha_sql;
10232 break;
10233 default:
10234 DBUG_RETURN(0);
10235 }
10236 error_num = append_key_order_for_direct_order_limit_with_alias(
10237 str, alias, alias_length);
10238 DBUG_RETURN(error_num);
10239 }
10240
append_key_order_for_direct_order_limit_with_alias(spider_string * str,const char * alias,uint alias_length)10241 int spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias(
10242 spider_string *str,
10243 const char *alias,
10244 uint alias_length
10245 ) {
10246 int error_num;
10247 ORDER *order;
10248 st_select_lex *select_lex;
10249 longlong select_limit;
10250 longlong offset_limit;
10251 DBUG_ENTER("spider_mbase_handler::append_key_order_for_direct_order_limit_with_alias");
10252 DBUG_PRINT("info",("spider this=%p", this));
10253 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
10254 if (spider->result_list.direct_aggregate)
10255 {
10256 if ((error_num = append_group_by(str, alias, alias_length)))
10257 DBUG_RETURN(error_num);
10258 }
10259 #endif
10260 spider_get_select_limit(spider, &select_lex, &select_limit,
10261 &offset_limit);
10262 if (select_lex->order_list.first)
10263 {
10264 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10265 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10266 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10267 for (order = (ORDER *) select_lex->order_list.first; order;
10268 order = order->next)
10269 {
10270 if ((error_num =
10271 spider_db_print_item_type((*order->item), NULL, spider, str, alias,
10272 alias_length, dbton_id, FALSE, NULL)))
10273 {
10274 DBUG_PRINT("info",("spider error=%d", error_num));
10275 DBUG_RETURN(error_num);
10276 }
10277 if (SPIDER_order_direction_is_asc(order))
10278 {
10279 if (str->reserve(SPIDER_SQL_COMMA_LEN))
10280 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10281 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10282 } else {
10283 if (str->reserve(SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))
10284 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10285 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
10286 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10287 }
10288 }
10289 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10290 }
10291 limit_pos = str->length();
10292 DBUG_RETURN(0);
10293 }
10294
append_key_order_with_alias_part(const char * alias,uint alias_length,ulong sql_type)10295 int spider_mbase_handler::append_key_order_with_alias_part(
10296 const char *alias,
10297 uint alias_length,
10298 ulong sql_type
10299 ) {
10300 int error_num;
10301 spider_string *str;
10302 DBUG_ENTER("spider_mbase_handler::append_key_order_with_alias_part");
10303 DBUG_PRINT("info",("spider this=%p", this));
10304 switch (sql_type)
10305 {
10306 case SPIDER_SQL_TYPE_SELECT_SQL:
10307 case SPIDER_SQL_TYPE_TMP_SQL:
10308 str = &sql;
10309 break;
10310 case SPIDER_SQL_TYPE_INSERT_SQL:
10311 case SPIDER_SQL_TYPE_UPDATE_SQL:
10312 case SPIDER_SQL_TYPE_DELETE_SQL:
10313 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10314 str = &update_sql;
10315 break;
10316 case SPIDER_SQL_TYPE_HANDLER:
10317 str = &ha_sql;
10318 error_num = append_key_order_for_handler(str, alias, alias_length);
10319 DBUG_RETURN(error_num);
10320 default:
10321 DBUG_RETURN(0);
10322 }
10323 error_num = append_key_order_with_alias(str, alias, alias_length);
10324 DBUG_RETURN(error_num);
10325 }
10326
append_key_order_for_handler(spider_string * str,const char * alias,uint alias_length)10327 int spider_mbase_handler::append_key_order_for_handler(
10328 spider_string *str,
10329 const char *alias,
10330 uint alias_length
10331 ) {
10332 DBUG_ENTER("spider_mbase_handler::append_key_order_for_handler");
10333 DBUG_PRINT("info",("spider this=%p", this));
10334 DBUG_PRINT("info",("spider ha_next_pos=%d", ha_next_pos));
10335 DBUG_PRINT("info",("spider ha_where_pos=%d", ha_where_pos));
10336 str->q_append(alias, alias_length);
10337 memset((char *) str->ptr() + str->length(), ' ',
10338 ha_where_pos - ha_next_pos - alias_length);
10339 DBUG_RETURN(0);
10340 }
10341
append_key_order_with_alias(spider_string * str,const char * alias,uint alias_length)10342 int spider_mbase_handler::append_key_order_with_alias(
10343 spider_string *str,
10344 const char *alias,
10345 uint alias_length
10346 ) {
10347 SPIDER_RESULT_LIST *result_list = &spider->result_list;
10348 KEY *key_info = result_list->key_info;
10349 int length;
10350 KEY_PART_INFO *key_part;
10351 Field *field;
10352 uint key_name_length;
10353 DBUG_ENTER("spider_mbase_handler::append_key_order_with_alias");
10354 DBUG_PRINT("info",("spider this=%p", this));
10355 #ifdef HANDLER_HAS_DIRECT_AGGREGATE
10356 if (spider->result_list.direct_aggregate)
10357 {
10358 int error_num;
10359 if ((error_num = append_group_by(str, alias, alias_length)))
10360 DBUG_RETURN(error_num);
10361 }
10362 #endif
10363 if (result_list->sorted == TRUE)
10364 {
10365 if (result_list->desc_flg == TRUE)
10366 {
10367 for (
10368 key_part = key_info->key_part + result_list->key_order,
10369 length = 1;
10370 length + result_list->key_order <
10371 (int) spider_user_defined_key_parts(key_info) &&
10372 length < result_list->max_order;
10373 key_part++,
10374 length++
10375 ) {
10376 field = key_part->field;
10377 key_name_length =
10378 mysql_share->column_name_str[field->field_index].length();
10379 if (length == 1)
10380 {
10381 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10382 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10383 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10384 }
10385 if (key_part->key_part_flag & HA_REVERSE_SORT)
10386 {
10387 if (str->reserve(alias_length + key_name_length +
10388 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
10389 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10390 str->q_append(alias, alias_length);
10391 mysql_share->append_column_name(str, field->field_index);
10392 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10393 } else {
10394 if (str->reserve(alias_length + key_name_length +
10395 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
10396 SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))
10397 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10398 str->q_append(alias, alias_length);
10399 mysql_share->append_column_name(str, field->field_index);
10400 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
10401 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10402 }
10403 }
10404 if (
10405 length + result_list->key_order <=
10406 (int) spider_user_defined_key_parts(key_info) &&
10407 length <= result_list->max_order
10408 ) {
10409 field = key_part->field;
10410 key_name_length =
10411 mysql_share->column_name_str[field->field_index].length();
10412 if (length == 1)
10413 {
10414 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10415 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10416 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10417 }
10418 if (key_part->key_part_flag & HA_REVERSE_SORT)
10419 {
10420 if (str->reserve(alias_length + key_name_length +
10421 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
10422 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10423 str->q_append(alias, alias_length);
10424 mysql_share->append_column_name(str, field->field_index);
10425 } else {
10426 if (str->reserve(alias_length + key_name_length +
10427 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_DESC_LEN))
10428 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10429 str->q_append(alias, alias_length);
10430 mysql_share->append_column_name(str, field->field_index);
10431 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
10432 }
10433 }
10434 } else {
10435 for (
10436 key_part = key_info->key_part + result_list->key_order,
10437 length = 1;
10438 length + result_list->key_order <
10439 (int) spider_user_defined_key_parts(key_info) &&
10440 length < result_list->max_order;
10441 key_part++,
10442 length++
10443 ) {
10444 field = key_part->field;
10445 key_name_length =
10446 mysql_share->column_name_str[field->field_index].length();
10447 if (length == 1)
10448 {
10449 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10450 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10451 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10452 }
10453 if (key_part->key_part_flag & HA_REVERSE_SORT)
10454 {
10455 if (str->reserve(alias_length + key_name_length +
10456 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
10457 SPIDER_SQL_DESC_LEN + SPIDER_SQL_COMMA_LEN))
10458 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10459 str->q_append(alias, alias_length);
10460 mysql_share->append_column_name(str, field->field_index);
10461 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
10462 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10463 } else {
10464 if (str->reserve(alias_length + key_name_length +
10465 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
10466 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10467 str->q_append(alias, alias_length);
10468 mysql_share->append_column_name(str, field->field_index);
10469 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10470 }
10471 }
10472 if (
10473 length + result_list->key_order <=
10474 (int) spider_user_defined_key_parts(key_info) &&
10475 length <= result_list->max_order
10476 ) {
10477 field = key_part->field;
10478 key_name_length =
10479 mysql_share->column_name_str[field->field_index].length();
10480 if (length == 1)
10481 {
10482 if (str->reserve(SPIDER_SQL_ORDER_LEN))
10483 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10484 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
10485 }
10486 if (key_part->key_part_flag & HA_REVERSE_SORT)
10487 {
10488 if (str->reserve(alias_length + key_name_length +
10489 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_DESC_LEN))
10490 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10491 str->q_append(alias, alias_length);
10492 mysql_share->append_column_name(str, field->field_index);
10493 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
10494 } else {
10495 if (str->reserve(alias_length + key_name_length +
10496 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2))
10497 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10498 str->q_append(alias, alias_length);
10499 mysql_share->append_column_name(str, field->field_index);
10500 }
10501 }
10502 }
10503 }
10504 limit_pos = str->length();
10505 DBUG_RETURN(0);
10506 }
10507
append_limit_part(longlong offset,longlong limit,ulong sql_type)10508 int spider_mbase_handler::append_limit_part(
10509 longlong offset,
10510 longlong limit,
10511 ulong sql_type
10512 ) {
10513 int error_num;
10514 spider_string *str;
10515 DBUG_ENTER("spider_mbase_handler::append_limit_part");
10516 DBUG_PRINT("info",("spider this=%p", this));
10517 switch (sql_type)
10518 {
10519 case SPIDER_SQL_TYPE_SELECT_SQL:
10520 str = &sql;
10521 limit_pos = str->length();
10522 break;
10523 case SPIDER_SQL_TYPE_TMP_SQL:
10524 str = &tmp_sql;
10525 limit_pos = str->length();
10526 break;
10527 case SPIDER_SQL_TYPE_INSERT_SQL:
10528 case SPIDER_SQL_TYPE_UPDATE_SQL:
10529 case SPIDER_SQL_TYPE_DELETE_SQL:
10530 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10531 str = &update_sql;
10532 limit_pos = str->length();
10533 break;
10534 case SPIDER_SQL_TYPE_HANDLER:
10535 str = &ha_sql;
10536 ha_limit_pos = str->length();
10537 break;
10538 default:
10539 DBUG_RETURN(0);
10540 }
10541 error_num = append_limit(str, offset, limit);
10542 DBUG_RETURN(error_num);
10543 }
10544
reappend_limit_part(longlong offset,longlong limit,ulong sql_type)10545 int spider_mbase_handler::reappend_limit_part(
10546 longlong offset,
10547 longlong limit,
10548 ulong sql_type
10549 ) {
10550 int error_num;
10551 spider_string *str;
10552 DBUG_ENTER("spider_mbase_handler::reappend_limit_part");
10553 DBUG_PRINT("info",("spider this=%p", this));
10554 switch (sql_type)
10555 {
10556 case SPIDER_SQL_TYPE_SELECT_SQL:
10557 str = &sql;
10558 str->length(limit_pos);
10559 break;
10560 case SPIDER_SQL_TYPE_TMP_SQL:
10561 str = &tmp_sql;
10562 str->length(limit_pos);
10563 break;
10564 case SPIDER_SQL_TYPE_INSERT_SQL:
10565 case SPIDER_SQL_TYPE_UPDATE_SQL:
10566 case SPIDER_SQL_TYPE_DELETE_SQL:
10567 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
10568 str = &update_sql;
10569 str->length(limit_pos);
10570 break;
10571 case SPIDER_SQL_TYPE_HANDLER:
10572 str = &ha_sql;
10573 str->length(ha_limit_pos);
10574 break;
10575 default:
10576 DBUG_RETURN(0);
10577 }
10578 error_num = append_limit(str, offset, limit);
10579 DBUG_RETURN(error_num);
10580 }
10581
append_limit(spider_string * str,longlong offset,longlong limit)10582 int spider_mbase_handler::append_limit(
10583 spider_string *str,
10584 longlong offset,
10585 longlong limit
10586 ) {
10587 char buf[SPIDER_LONGLONG_LEN + 1];
10588 uint32 length;
10589 DBUG_ENTER("spider_mbase_handler::append_limit");
10590 DBUG_PRINT("info",("spider this=%p", this));
10591 DBUG_PRINT("info", ("spider offset=%lld", offset));
10592 DBUG_PRINT("info", ("spider limit=%lld", limit));
10593 if (offset || limit < 9223372036854775807LL)
10594 {
10595 if (str->reserve(SPIDER_SQL_LIMIT_LEN + SPIDER_SQL_COMMA_LEN +
10596 ((SPIDER_LONGLONG_LEN) * 2)))
10597 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10598 str->q_append(SPIDER_SQL_LIMIT_STR, SPIDER_SQL_LIMIT_LEN);
10599 if (offset)
10600 {
10601 length = (uint32) (my_charset_bin.cset->longlong10_to_str)(
10602 &my_charset_bin, buf, SPIDER_LONGLONG_LEN + 1, -10, offset);
10603 str->q_append(buf, length);
10604 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10605 }
10606 length = (uint32) (my_charset_bin.cset->longlong10_to_str)(
10607 &my_charset_bin, buf, SPIDER_LONGLONG_LEN + 1, -10, limit);
10608 str->q_append(buf, length);
10609 }
10610 DBUG_RETURN(0);
10611 }
10612
append_select_lock_part(ulong sql_type)10613 int spider_mbase_handler::append_select_lock_part(
10614 ulong sql_type
10615 ) {
10616 int error_num;
10617 spider_string *str;
10618 DBUG_ENTER("spider_mbase_handler::append_select_lock_part");
10619 DBUG_PRINT("info",("spider this=%p", this));
10620 switch (sql_type)
10621 {
10622 case SPIDER_SQL_TYPE_SELECT_SQL:
10623 str = &sql;
10624 break;
10625 default:
10626 DBUG_RETURN(0);
10627 }
10628 error_num = append_select_lock(str);
10629 DBUG_RETURN(error_num);
10630 }
10631
append_select_lock(spider_string * str)10632 int spider_mbase_handler::append_select_lock(
10633 spider_string *str
10634 ) {
10635 int lock_mode = spider_conn_lock_mode(spider);
10636 DBUG_ENTER("spider_mbase_handler::append_select_lock");
10637 DBUG_PRINT("info",("spider this=%p", this));
10638 if (lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE)
10639 {
10640 if (str->reserve(SPIDER_SQL_FOR_UPDATE_LEN))
10641 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10642 str->q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN);
10643 } else if (lock_mode == SPIDER_LOCK_MODE_SHARED)
10644 {
10645 if (str->reserve(SPIDER_SQL_SHARED_LOCK_LEN))
10646 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10647 str->q_append(SPIDER_SQL_SHARED_LOCK_STR, SPIDER_SQL_SHARED_LOCK_LEN);
10648 }
10649 DBUG_RETURN(0);
10650 }
10651
append_union_all_start_part(ulong sql_type)10652 int spider_mbase_handler::append_union_all_start_part(
10653 ulong sql_type
10654 ) {
10655 int error_num;
10656 spider_string *str;
10657 DBUG_ENTER("spider_mbase_handler::append_union_all_start_part");
10658 DBUG_PRINT("info",("spider this=%p", this));
10659 switch (sql_type)
10660 {
10661 case SPIDER_SQL_TYPE_SELECT_SQL:
10662 str = &sql;
10663 break;
10664 default:
10665 DBUG_RETURN(0);
10666 }
10667 error_num = append_union_all_start(str);
10668 DBUG_RETURN(error_num);
10669 }
10670
append_union_all_start(spider_string * str)10671 int spider_mbase_handler::append_union_all_start(
10672 spider_string *str
10673 ) {
10674 DBUG_ENTER("spider_mbase_handler::append_union_all_start");
10675 DBUG_PRINT("info",("spider this=%p", this));
10676 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
10677 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10678 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
10679 DBUG_RETURN(0);
10680 }
10681
append_union_all_part(ulong sql_type)10682 int spider_mbase_handler::append_union_all_part(
10683 ulong sql_type
10684 ) {
10685 int error_num;
10686 spider_string *str;
10687 DBUG_ENTER("spider_mbase_handler::append_union_all_part");
10688 DBUG_PRINT("info",("spider this=%p", this));
10689 switch (sql_type)
10690 {
10691 case SPIDER_SQL_TYPE_SELECT_SQL:
10692 str = &sql;
10693 break;
10694 default:
10695 DBUG_RETURN(0);
10696 }
10697 error_num = append_union_all(str);
10698 DBUG_RETURN(error_num);
10699 }
10700
append_union_all(spider_string * str)10701 int spider_mbase_handler::append_union_all(
10702 spider_string *str
10703 ) {
10704 DBUG_ENTER("spider_mbase_handler::append_union_all");
10705 DBUG_PRINT("info",("spider this=%p", this));
10706 if (str->reserve(SPIDER_SQL_UNION_ALL_LEN))
10707 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10708 str->q_append(SPIDER_SQL_UNION_ALL_STR, SPIDER_SQL_UNION_ALL_LEN);
10709 DBUG_RETURN(0);
10710 }
10711
append_union_all_end_part(ulong sql_type)10712 int spider_mbase_handler::append_union_all_end_part(
10713 ulong sql_type
10714 ) {
10715 int error_num;
10716 spider_string *str;
10717 DBUG_ENTER("spider_mbase_handler::append_union_all_end_part");
10718 DBUG_PRINT("info",("spider this=%p", this));
10719 switch (sql_type)
10720 {
10721 case SPIDER_SQL_TYPE_SELECT_SQL:
10722 str = &sql;
10723 break;
10724 default:
10725 DBUG_RETURN(0);
10726 }
10727 error_num = append_union_all_end(str);
10728 DBUG_RETURN(error_num);
10729 }
10730
append_union_all_end(spider_string * str)10731 int spider_mbase_handler::append_union_all_end(
10732 spider_string *str
10733 ) {
10734 DBUG_ENTER("spider_mbase_handler::append_union_all_end");
10735 DBUG_PRINT("info",("spider this=%p", this));
10736 str->length(str->length() -
10737 SPIDER_SQL_UNION_ALL_LEN + SPIDER_SQL_CLOSE_PAREN_LEN);
10738 DBUG_RETURN(0);
10739 }
10740
append_multi_range_cnt_part(ulong sql_type,uint multi_range_cnt,bool with_comma)10741 int spider_mbase_handler::append_multi_range_cnt_part(
10742 ulong sql_type,
10743 uint multi_range_cnt,
10744 bool with_comma
10745 ) {
10746 int error_num;
10747 spider_string *str;
10748 DBUG_ENTER("spider_mbase_handler::append_multi_range_cnt_part");
10749 DBUG_PRINT("info",("spider this=%p", this));
10750 switch (sql_type)
10751 {
10752 case SPIDER_SQL_TYPE_SELECT_SQL:
10753 str = &sql;
10754 break;
10755 case SPIDER_SQL_TYPE_TMP_SQL:
10756 str = &tmp_sql;
10757 break;
10758 default:
10759 DBUG_RETURN(0);
10760 }
10761 error_num = append_multi_range_cnt(str, multi_range_cnt, with_comma);
10762 DBUG_RETURN(error_num);
10763 }
10764
append_multi_range_cnt(spider_string * str,uint multi_range_cnt,bool with_comma)10765 int spider_mbase_handler::append_multi_range_cnt(
10766 spider_string *str,
10767 uint multi_range_cnt,
10768 bool with_comma
10769 ) {
10770 int range_cnt_length;
10771 char range_cnt_str[SPIDER_SQL_INT_LEN];
10772 DBUG_ENTER("spider_mbase_handler::append_multi_range_cnt");
10773 DBUG_PRINT("info",("spider this=%p", this));
10774 range_cnt_length = my_sprintf(range_cnt_str, (range_cnt_str, "%u",
10775 multi_range_cnt));
10776 if (with_comma)
10777 {
10778 if (str->reserve(range_cnt_length + SPIDER_SQL_COMMA_LEN))
10779 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10780 str->q_append(range_cnt_str, range_cnt_length);
10781 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10782 } else {
10783 if (str->reserve(range_cnt_length))
10784 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10785 str->q_append(range_cnt_str, range_cnt_length);
10786 }
10787 DBUG_RETURN(0);
10788 }
10789
append_multi_range_cnt_with_name_part(ulong sql_type,uint multi_range_cnt)10790 int spider_mbase_handler::append_multi_range_cnt_with_name_part(
10791 ulong sql_type,
10792 uint multi_range_cnt
10793 ) {
10794 int error_num;
10795 spider_string *str;
10796 DBUG_ENTER("spider_mbase_handler::append_multi_range_cnt_with_name_part");
10797 DBUG_PRINT("info",("spider this=%p", this));
10798 switch (sql_type)
10799 {
10800 case SPIDER_SQL_TYPE_SELECT_SQL:
10801 str = &sql;
10802 break;
10803 case SPIDER_SQL_TYPE_TMP_SQL:
10804 str = &tmp_sql;
10805 break;
10806 default:
10807 DBUG_RETURN(0);
10808 }
10809 error_num = append_multi_range_cnt_with_name(str, multi_range_cnt);
10810 DBUG_RETURN(error_num);
10811 }
10812
append_multi_range_cnt_with_name(spider_string * str,uint multi_range_cnt)10813 int spider_mbase_handler::append_multi_range_cnt_with_name(
10814 spider_string *str,
10815 uint multi_range_cnt
10816 ) {
10817 int range_cnt_length;
10818 char range_cnt_str[SPIDER_SQL_INT_LEN];
10819 DBUG_ENTER("spider_mbase_handler::append_multi_range_cnt_with_name");
10820 DBUG_PRINT("info",("spider this=%p", this));
10821 range_cnt_length = my_sprintf(range_cnt_str, (range_cnt_str, "%u",
10822 multi_range_cnt));
10823 if (str->reserve(range_cnt_length + SPIDER_SQL_SPACE_LEN +
10824 SPIDER_SQL_ID_LEN + SPIDER_SQL_COMMA_LEN))
10825 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10826 str->q_append(range_cnt_str, range_cnt_length);
10827 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
10828 str->q_append(SPIDER_SQL_ID_STR, SPIDER_SQL_ID_LEN);
10829 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
10830 DBUG_RETURN(0);
10831 }
10832
append_open_handler_part(ulong sql_type,uint handler_id,SPIDER_CONN * conn,int link_idx)10833 int spider_mbase_handler::append_open_handler_part(
10834 ulong sql_type,
10835 uint handler_id,
10836 SPIDER_CONN *conn,
10837 int link_idx
10838 ) {
10839 int error_num;
10840 spider_string *str;
10841 DBUG_ENTER("spider_mbase_handler::append_open_handler_part");
10842 DBUG_PRINT("info",("spider this=%p", this));
10843 switch (sql_type)
10844 {
10845 case SPIDER_SQL_TYPE_HANDLER:
10846 str = &ha_sql;
10847 break;
10848 default:
10849 DBUG_RETURN(0);
10850 }
10851 error_num = append_open_handler(str, handler_id, conn, link_idx);
10852 exec_ha_sql = str;
10853 DBUG_RETURN(error_num);
10854 }
10855
append_open_handler(spider_string * str,uint handler_id,SPIDER_CONN * conn,int link_idx)10856 int spider_mbase_handler::append_open_handler(
10857 spider_string *str,
10858 uint handler_id,
10859 SPIDER_CONN *conn,
10860 int link_idx
10861 ) {
10862 int error_num;
10863 DBUG_ENTER("spider_mbase_handler::append_open_handler");
10864 DBUG_PRINT("info",("spider this=%p", this));
10865 DBUG_PRINT("info",("spider link_idx=%d", link_idx));
10866 DBUG_PRINT("info",("spider m_handler_cid=%s",
10867 spider->m_handler_cid[link_idx]));
10868 if (str->reserve(SPIDER_SQL_HANDLER_LEN))
10869 {
10870 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10871 }
10872 str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN);
10873 if ((error_num = mysql_share->append_table_name(str,
10874 spider->conn_link_idx[link_idx])))
10875 DBUG_RETURN(error_num);
10876 if (str->reserve(SPIDER_SQL_OPEN_LEN + SPIDER_SQL_AS_LEN +
10877 SPIDER_SQL_HANDLER_CID_LEN))
10878 {
10879 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10880 }
10881 str->q_append(SPIDER_SQL_OPEN_STR, SPIDER_SQL_OPEN_LEN);
10882 str->q_append(SPIDER_SQL_AS_STR, SPIDER_SQL_AS_LEN);
10883 str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN);
10884 DBUG_RETURN(0);
10885 }
10886
append_close_handler_part(ulong sql_type,int link_idx)10887 int spider_mbase_handler::append_close_handler_part(
10888 ulong sql_type,
10889 int link_idx
10890 ) {
10891 int error_num;
10892 spider_string *str;
10893 DBUG_ENTER("spider_mbase_handler::append_close_handler_part");
10894 DBUG_PRINT("info",("spider this=%p", this));
10895 switch (sql_type)
10896 {
10897 case SPIDER_SQL_TYPE_HANDLER:
10898 str = &ha_sql;
10899 break;
10900 default:
10901 DBUG_RETURN(0);
10902 }
10903 error_num = append_close_handler(str, link_idx);
10904 exec_ha_sql = str;
10905 DBUG_RETURN(error_num);
10906 }
10907
append_close_handler(spider_string * str,int link_idx)10908 int spider_mbase_handler::append_close_handler(
10909 spider_string *str,
10910 int link_idx
10911 ) {
10912 DBUG_ENTER("spider_mbase_handler::append_close_handler");
10913 DBUG_PRINT("info",("spider this=%p", this));
10914 if (str->reserve(SPIDER_SQL_HANDLER_LEN + SPIDER_SQL_CLOSE_LEN +
10915 SPIDER_SQL_HANDLER_CID_LEN))
10916 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10917 str->q_append(SPIDER_SQL_HANDLER_STR, SPIDER_SQL_HANDLER_LEN);
10918 str->q_append(spider->m_handler_cid[link_idx],
10919 SPIDER_SQL_HANDLER_CID_LEN);
10920 str->q_append(SPIDER_SQL_CLOSE_STR, SPIDER_SQL_CLOSE_LEN);
10921 DBUG_RETURN(0);
10922 }
10923
append_insert_terminator_part(ulong sql_type)10924 int spider_mbase_handler::append_insert_terminator_part(
10925 ulong sql_type
10926 ) {
10927 int error_num;
10928 spider_string *str;
10929 DBUG_ENTER("spider_mbase_handler::append_insert_terminator_part");
10930 DBUG_PRINT("info",("spider this=%p", this));
10931 switch (sql_type)
10932 {
10933 case SPIDER_SQL_TYPE_INSERT_SQL:
10934 str = &insert_sql;
10935 break;
10936 default:
10937 DBUG_RETURN(0);
10938 }
10939 error_num = append_insert_terminator(str);
10940 DBUG_RETURN(error_num);
10941 }
10942
append_insert_terminator(spider_string * str)10943 int spider_mbase_handler::append_insert_terminator(
10944 spider_string *str
10945 ) {
10946 DBUG_ENTER("spider_mbase_handler::append_insert_terminator");
10947 DBUG_PRINT("info",("spider this=%p", this));
10948 DBUG_PRINT("info",("spider dup_update_sql.length=%u", dup_update_sql.length()));
10949 if (
10950 spider->result_list.insert_dup_update_pushdown &&
10951 dup_update_sql.length()
10952 ) {
10953 DBUG_PRINT("info",("spider add duplicate key update"));
10954 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10955 if (str->reserve(SPIDER_SQL_DUPLICATE_KEY_UPDATE_LEN +
10956 dup_update_sql.length()))
10957 {
10958 str->length(0);
10959 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10960 }
10961 str->q_append(SPIDER_SQL_DUPLICATE_KEY_UPDATE_STR,
10962 SPIDER_SQL_DUPLICATE_KEY_UPDATE_LEN);
10963 if (str->append(dup_update_sql))
10964 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
10965 } else {
10966 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
10967 }
10968 DBUG_RETURN(0);
10969 }
10970
append_insert_values_part(ulong sql_type)10971 int spider_mbase_handler::append_insert_values_part(
10972 ulong sql_type
10973 ) {
10974 int error_num;
10975 spider_string *str;
10976 DBUG_ENTER("spider_mbase_handler::append_insert_values_part");
10977 DBUG_PRINT("info",("spider this=%p", this));
10978 switch (sql_type)
10979 {
10980 case SPIDER_SQL_TYPE_INSERT_SQL:
10981 str = &insert_sql;
10982 break;
10983 default:
10984 DBUG_RETURN(0);
10985 }
10986 error_num = append_insert_values(str);
10987 DBUG_RETURN(error_num);
10988 }
10989
append_insert_values(spider_string * str)10990 int spider_mbase_handler::append_insert_values(
10991 spider_string *str
10992 ) {
10993 SPIDER_SHARE *share = spider->share;
10994 TABLE *table = spider->get_table();
10995 Field **field;
10996 bool add_value = FALSE;
10997 DBUG_ENTER("spider_mbase_handler::append_insert_values");
10998 DBUG_PRINT("info",("spider this=%p", this));
10999 if (str->reserve(SPIDER_SQL_OPEN_PAREN_LEN))
11000 {
11001 str->length(0);
11002 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11003 }
11004 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
11005 for (field = table->field; *field; field++)
11006 {
11007 DBUG_PRINT("info",("spider field_index=%u", (*field)->field_index));
11008 if (
11009 bitmap_is_set(table->write_set, (*field)->field_index) ||
11010 bitmap_is_set(table->read_set, (*field)->field_index)
11011 ) {
11012 #ifndef DBUG_OFF
11013 MY_BITMAP *tmp_map =
11014 dbug_tmp_use_all_columns(table, &table->read_set);
11015 #endif
11016 add_value = TRUE;
11017 DBUG_PRINT("info",("spider is_null()=%s",
11018 (*field)->is_null() ? "TRUE" : "FALSE"));
11019 DBUG_PRINT("info",("spider table->next_number_field=%p",
11020 table->next_number_field));
11021 DBUG_PRINT("info",("spider *field=%p", *field));
11022 DBUG_PRINT("info",("spider force_auto_increment=%s",
11023 (table->next_number_field && spider->force_auto_increment) ?
11024 "TRUE" : "FALSE"));
11025 if (
11026 (*field)->is_null() ||
11027 (
11028 table->next_number_field == *field &&
11029 !table->auto_increment_field_not_null &&
11030 !spider->force_auto_increment
11031 )
11032 ) {
11033 if (str->reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN))
11034 {
11035 #ifndef DBUG_OFF
11036 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
11037 #endif
11038 str->length(0);
11039 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11040 }
11041 str->q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
11042 } else {
11043 if (
11044 spider_db_mbase_utility->
11045 append_column_value(spider, str, *field, NULL,
11046 share->access_charset) ||
11047 str->reserve(SPIDER_SQL_COMMA_LEN)
11048 ) {
11049 #ifndef DBUG_OFF
11050 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
11051 #endif
11052 str->length(0);
11053 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11054 }
11055 }
11056 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
11057 #ifndef DBUG_OFF
11058 dbug_tmp_restore_column_map(&table->read_set, tmp_map);
11059 #endif
11060 }
11061 }
11062 if (add_value)
11063 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
11064 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_COMMA_LEN))
11065 {
11066 str->length(0);
11067 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11068 }
11069 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
11070 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
11071 DBUG_RETURN(0);
11072 }
11073
append_into_part(ulong sql_type)11074 int spider_mbase_handler::append_into_part(
11075 ulong sql_type
11076 ) {
11077 int error_num;
11078 spider_string *str;
11079 DBUG_ENTER("spider_mbase_handler::append_into_part");
11080 DBUG_PRINT("info",("spider this=%p", this));
11081 switch (sql_type)
11082 {
11083 case SPIDER_SQL_TYPE_INSERT_SQL:
11084 str = &insert_sql;
11085 break;
11086 default:
11087 DBUG_RETURN(0);
11088 }
11089 error_num = append_into(str);
11090 DBUG_RETURN(error_num);
11091 }
11092
append_into(spider_string * str)11093 int spider_mbase_handler::append_into(
11094 spider_string *str
11095 ) {
11096 const TABLE *table = spider->get_table();
11097 Field **field;
11098 uint field_name_length = 0;
11099 DBUG_ENTER("spider_mbase_handler::append_into");
11100 DBUG_PRINT("info",("spider this=%p", this));
11101 if (str->reserve(SPIDER_SQL_INTO_LEN + mysql_share->db_nm_max_length +
11102 SPIDER_SQL_DOT_LEN + mysql_share->table_nm_max_length +
11103 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN))
11104 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11105 str->q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN);
11106 insert_table_name_pos = str->length();
11107 append_table_name_with_adjusting(str, first_link_idx,
11108 SPIDER_SQL_TYPE_INSERT_SQL);
11109 str->q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
11110 for (field = table->field; *field; field++)
11111 {
11112 if (
11113 bitmap_is_set(table->write_set, (*field)->field_index) ||
11114 bitmap_is_set(table->read_set, (*field)->field_index)
11115 ) {
11116 field_name_length =
11117 mysql_share->column_name_str[(*field)->field_index].length();
11118 if (str->reserve(field_name_length +
11119 /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 + SPIDER_SQL_COMMA_LEN))
11120 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11121 mysql_share->append_column_name(str, (*field)->field_index);
11122 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
11123 }
11124 }
11125 if (field_name_length)
11126 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
11127 if (str->reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN))
11128 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11129 str->q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
11130 str->q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN);
11131 insert_pos = str->length();
11132 DBUG_RETURN(0);
11133 }
11134
set_insert_to_pos(ulong sql_type)11135 void spider_mbase_handler::set_insert_to_pos(
11136 ulong sql_type
11137 ) {
11138 DBUG_ENTER("spider_mbase_handler::set_insert_to_pos");
11139 switch (sql_type)
11140 {
11141 case SPIDER_SQL_TYPE_INSERT_SQL:
11142 insert_sql.length(insert_pos);
11143 break;
11144 default:
11145 DBUG_ASSERT(0);
11146 break;
11147 }
11148 DBUG_VOID_RETURN;
11149 }
11150
append_from_part(ulong sql_type,int link_idx)11151 int spider_mbase_handler::append_from_part(
11152 ulong sql_type,
11153 int link_idx
11154 ) {
11155 int error_num;
11156 spider_string *str;
11157 DBUG_ENTER("spider_mbase_handler::append_from_part");
11158 DBUG_PRINT("info",("spider this=%p", this));
11159 switch (sql_type)
11160 {
11161 case SPIDER_SQL_TYPE_HANDLER:
11162 str = &ha_sql;
11163 break;
11164 case SPIDER_SQL_TYPE_UPDATE_SQL:
11165 case SPIDER_SQL_TYPE_DELETE_SQL:
11166 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
11167 str = &update_sql;
11168 break;
11169 default:
11170 str = &sql;
11171 break;
11172 }
11173 error_num = append_from(str, sql_type, link_idx);
11174 DBUG_RETURN(error_num);
11175 }
11176
append_from(spider_string * str,ulong sql_type,int link_idx)11177 int spider_mbase_handler::append_from(
11178 spider_string *str,
11179 ulong sql_type,
11180 int link_idx
11181 ) {
11182 DBUG_ENTER("spider_mbase_handler::append_from");
11183 DBUG_PRINT("info",("spider this=%p", this));
11184 DBUG_PRINT("info",("spider link_idx=%d", link_idx));
11185 int error_num = 0;
11186 if (sql_type == SPIDER_SQL_TYPE_HANDLER)
11187 {
11188 ha_table_name_pos = str->length();
11189 DBUG_PRINT("info",("spider ha_table_name_pos=%u", ha_table_name_pos));
11190 ha_sql_handler_id = spider->m_handler_id[link_idx];
11191 DBUG_PRINT("info",("spider ha_sql_handler_id=%u", ha_sql_handler_id));
11192 if (str->reserve(SPIDER_SQL_HANDLER_CID_LEN))
11193 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11194 str->q_append(spider->m_handler_cid[link_idx], SPIDER_SQL_HANDLER_CID_LEN);
11195 DBUG_PRINT("info",("spider m_handler_cid=%s",
11196 spider->m_handler_cid[link_idx]));
11197 } else {
11198 if (str->reserve(SPIDER_SQL_FROM_LEN + mysql_share->db_nm_max_length +
11199 SPIDER_SQL_DOT_LEN + mysql_share->table_nm_max_length +
11200 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN))
11201 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11202 str->q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
11203 table_name_pos = str->length();
11204 append_table_name_with_adjusting(str, link_idx, sql_type);
11205 if(spider_param_index_hint_pushdown(spider->trx->thd))
11206 {
11207 if((error_num = append_index_hint(str, link_idx, sql_type)))
11208 {
11209 DBUG_RETURN(error_num);
11210 }
11211 }
11212 }
11213 DBUG_RETURN(0);
11214 }
11215
append_flush_tables_part(ulong sql_type,int link_idx,bool lock)11216 int spider_mbase_handler::append_flush_tables_part(
11217 ulong sql_type,
11218 int link_idx,
11219 bool lock
11220 ) {
11221 int error_num;
11222 spider_string *str;
11223 DBUG_ENTER("spider_mbase_handler::append_flush_tables_part");
11224 DBUG_PRINT("info",("spider this=%p", this));
11225 switch (sql_type)
11226 {
11227 case SPIDER_SQL_TYPE_OTHER_SQL:
11228 str = &spider->result_list.sqls[link_idx];
11229 break;
11230 default:
11231 DBUG_RETURN(0);
11232 }
11233 error_num = append_flush_tables(str, link_idx, lock);
11234 DBUG_RETURN(error_num);
11235 }
11236
append_flush_tables(spider_string * str,int link_idx,bool lock)11237 int spider_mbase_handler::append_flush_tables(
11238 spider_string *str,
11239 int link_idx,
11240 bool lock
11241 ) {
11242 DBUG_ENTER("spider_mbase_handler::append_flush_tables");
11243 DBUG_PRINT("info",("spider this=%p", this));
11244 if (lock)
11245 {
11246 if (str->reserve(SPIDER_SQL_FLUSH_TABLES_LEN +
11247 SPIDER_SQL_WITH_READ_LOCK_LEN))
11248 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11249 str->q_append(SPIDER_SQL_FLUSH_TABLES_STR, SPIDER_SQL_FLUSH_TABLES_LEN);
11250 str->q_append(SPIDER_SQL_WITH_READ_LOCK_STR,
11251 SPIDER_SQL_WITH_READ_LOCK_LEN);
11252 } else {
11253 if (str->reserve(SPIDER_SQL_FLUSH_TABLES_LEN))
11254 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11255 str->q_append(SPIDER_SQL_FLUSH_TABLES_STR, SPIDER_SQL_FLUSH_TABLES_LEN);
11256 }
11257 DBUG_RETURN(0);
11258 }
11259
append_optimize_table_part(ulong sql_type,int link_idx)11260 int spider_mbase_handler::append_optimize_table_part(
11261 ulong sql_type,
11262 int link_idx
11263 ) {
11264 int error_num;
11265 spider_string *str;
11266 DBUG_ENTER("spider_mbase_handler::append_optimize_table_part");
11267 DBUG_PRINT("info",("spider this=%p", this));
11268 switch (sql_type)
11269 {
11270 case SPIDER_SQL_TYPE_OTHER_SQL:
11271 str = &spider->result_list.sqls[link_idx];
11272 break;
11273 default:
11274 DBUG_RETURN(0);
11275 }
11276 error_num = append_optimize_table(str, link_idx);
11277 DBUG_RETURN(error_num);
11278 }
11279
append_optimize_table(spider_string * str,int link_idx)11280 int spider_mbase_handler::append_optimize_table(
11281 spider_string *str,
11282 int link_idx
11283 ) {
11284 SPIDER_SHARE *share = spider->share;
11285 int conn_link_idx = spider->conn_link_idx[link_idx];
11286 int local_length = spider_param_internal_optimize_local(spider->trx->thd,
11287 share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
11288 DBUG_ENTER("spider_mbase_handler::append_optimize_table");
11289 DBUG_PRINT("info",("spider this=%p", this));
11290 if (str->reserve(SPIDER_SQL_SQL_OPTIMIZE_LEN + SPIDER_SQL_SQL_TABLE_LEN +
11291 local_length +
11292 mysql_share->db_names_str[conn_link_idx].length() +
11293 SPIDER_SQL_DOT_LEN +
11294 mysql_share->table_names_str[conn_link_idx].length() +
11295 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
11296 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11297 str->q_append(SPIDER_SQL_SQL_OPTIMIZE_STR, SPIDER_SQL_SQL_OPTIMIZE_LEN);
11298 if (local_length)
11299 str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN);
11300 str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN);
11301 mysql_share->append_table_name(str, conn_link_idx);
11302 DBUG_RETURN(0);
11303 }
11304
append_analyze_table_part(ulong sql_type,int link_idx)11305 int spider_mbase_handler::append_analyze_table_part(
11306 ulong sql_type,
11307 int link_idx
11308 ) {
11309 int error_num;
11310 spider_string *str;
11311 DBUG_ENTER("spider_mbase_handler::append_analyze_table_part");
11312 DBUG_PRINT("info",("spider this=%p", this));
11313 switch (sql_type)
11314 {
11315 case SPIDER_SQL_TYPE_OTHER_SQL:
11316 str = &spider->result_list.sqls[link_idx];
11317 break;
11318 default:
11319 DBUG_RETURN(0);
11320 }
11321 error_num = append_analyze_table(str, link_idx);
11322 DBUG_RETURN(error_num);
11323 }
11324
append_analyze_table(spider_string * str,int link_idx)11325 int spider_mbase_handler::append_analyze_table(
11326 spider_string *str,
11327 int link_idx
11328 ) {
11329 SPIDER_SHARE *share = spider->share;
11330 int conn_link_idx = spider->conn_link_idx[link_idx];
11331 int local_length = spider_param_internal_optimize_local(spider->trx->thd,
11332 share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
11333 DBUG_ENTER("spider_mbase_handler::append_analyze_table");
11334 DBUG_PRINT("info",("spider this=%p", this));
11335 if (str->reserve(SPIDER_SQL_SQL_ANALYZE_LEN + SPIDER_SQL_SQL_TABLE_LEN +
11336 local_length +
11337 mysql_share->db_names_str[conn_link_idx].length() +
11338 SPIDER_SQL_DOT_LEN +
11339 mysql_share->table_names_str[conn_link_idx].length() +
11340 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
11341 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11342 str->q_append(SPIDER_SQL_SQL_ANALYZE_STR, SPIDER_SQL_SQL_ANALYZE_LEN);
11343 if (local_length)
11344 str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN);
11345 str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN);
11346 mysql_share->append_table_name(str, conn_link_idx);
11347 DBUG_RETURN(0);
11348 }
11349
append_repair_table_part(ulong sql_type,int link_idx,HA_CHECK_OPT * check_opt)11350 int spider_mbase_handler::append_repair_table_part(
11351 ulong sql_type,
11352 int link_idx,
11353 HA_CHECK_OPT* check_opt
11354 ) {
11355 int error_num;
11356 spider_string *str;
11357 DBUG_ENTER("spider_mbase_handler::append_repair_table_part");
11358 DBUG_PRINT("info",("spider this=%p", this));
11359 switch (sql_type)
11360 {
11361 case SPIDER_SQL_TYPE_OTHER_SQL:
11362 str = &spider->result_list.sqls[link_idx];
11363 break;
11364 default:
11365 DBUG_RETURN(0);
11366 }
11367 error_num = append_repair_table(str, link_idx, check_opt);
11368 DBUG_RETURN(error_num);
11369 }
11370
append_repair_table(spider_string * str,int link_idx,HA_CHECK_OPT * check_opt)11371 int spider_mbase_handler::append_repair_table(
11372 spider_string *str,
11373 int link_idx,
11374 HA_CHECK_OPT* check_opt
11375 ) {
11376 SPIDER_SHARE *share = spider->share;
11377 int conn_link_idx = spider->conn_link_idx[link_idx];
11378 int local_length = spider_param_internal_optimize_local(spider->trx->thd,
11379 share->internal_optimize_local) * SPIDER_SQL_SQL_LOCAL_LEN;
11380 DBUG_ENTER("spider_mbase_handler::append_repair_table");
11381 DBUG_PRINT("info",("spider this=%p", this));
11382 if (str->reserve(SPIDER_SQL_SQL_REPAIR_LEN + SPIDER_SQL_SQL_TABLE_LEN +
11383 local_length +
11384 mysql_share->db_names_str[conn_link_idx].length() +
11385 SPIDER_SQL_DOT_LEN +
11386 mysql_share->table_names_str[conn_link_idx].length() +
11387 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
11388 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11389 str->q_append(SPIDER_SQL_SQL_REPAIR_STR, SPIDER_SQL_SQL_REPAIR_LEN);
11390 if (local_length)
11391 str->q_append(SPIDER_SQL_SQL_LOCAL_STR, SPIDER_SQL_SQL_LOCAL_LEN);
11392 str->q_append(SPIDER_SQL_SQL_TABLE_STR, SPIDER_SQL_SQL_TABLE_LEN);
11393 mysql_share->append_table_name(str, conn_link_idx);
11394 if (check_opt->flags & T_QUICK)
11395 {
11396 if (str->reserve(SPIDER_SQL_SQL_QUICK_LEN))
11397 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11398 str->q_append(SPIDER_SQL_SQL_QUICK_STR, SPIDER_SQL_SQL_QUICK_LEN);
11399 }
11400 if (check_opt->flags & T_EXTEND)
11401 {
11402 if (str->reserve(SPIDER_SQL_SQL_EXTENDED_LEN))
11403 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11404 str->q_append(SPIDER_SQL_SQL_EXTENDED_STR, SPIDER_SQL_SQL_EXTENDED_LEN);
11405 }
11406 if (check_opt->sql_flags & TT_USEFRM)
11407 {
11408 if (str->reserve(SPIDER_SQL_SQL_USE_FRM_LEN))
11409 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11410 str->q_append(SPIDER_SQL_SQL_USE_FRM_STR, SPIDER_SQL_SQL_USE_FRM_LEN);
11411 }
11412 DBUG_RETURN(0);
11413 }
11414
append_check_table_part(ulong sql_type,int link_idx,HA_CHECK_OPT * check_opt)11415 int spider_mbase_handler::append_check_table_part(
11416 ulong sql_type,
11417 int link_idx,
11418 HA_CHECK_OPT* check_opt
11419 ) {
11420 int error_num;
11421 spider_string *str;
11422 DBUG_ENTER("spider_mbase_handler::append_check_table_part");
11423 DBUG_PRINT("info",("spider this=%p", this));
11424 switch (sql_type)
11425 {
11426 case SPIDER_SQL_TYPE_OTHER_SQL:
11427 str = &spider->result_list.sqls[link_idx];
11428 break;
11429 default:
11430 DBUG_RETURN(0);
11431 }
11432 error_num = append_check_table(str, link_idx, check_opt);
11433 DBUG_RETURN(error_num);
11434 }
11435
append_check_table(spider_string * str,int link_idx,HA_CHECK_OPT * check_opt)11436 int spider_mbase_handler::append_check_table(
11437 spider_string *str,
11438 int link_idx,
11439 HA_CHECK_OPT* check_opt
11440 ) {
11441 int conn_link_idx = spider->conn_link_idx[link_idx];
11442 DBUG_ENTER("spider_mbase_handler::append_check_table");
11443 DBUG_PRINT("info",("spider this=%p", this));
11444 if (str->reserve(SPIDER_SQL_SQL_CHECK_TABLE_LEN +
11445 mysql_share->db_names_str[conn_link_idx].length() +
11446 SPIDER_SQL_DOT_LEN +
11447 mysql_share->table_names_str[conn_link_idx].length() +
11448 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4))
11449 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11450 str->q_append(SPIDER_SQL_SQL_CHECK_TABLE_STR,
11451 SPIDER_SQL_SQL_CHECK_TABLE_LEN);
11452 mysql_share->append_table_name(str, conn_link_idx);
11453 if (check_opt->flags & T_QUICK)
11454 {
11455 if (str->reserve(SPIDER_SQL_SQL_QUICK_LEN))
11456 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11457 str->q_append(SPIDER_SQL_SQL_QUICK_STR, SPIDER_SQL_SQL_QUICK_LEN);
11458 }
11459 if (check_opt->flags & T_FAST)
11460 {
11461 if (str->reserve(SPIDER_SQL_SQL_FAST_LEN))
11462 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11463 str->q_append(SPIDER_SQL_SQL_FAST_STR, SPIDER_SQL_SQL_FAST_LEN);
11464 }
11465 if (check_opt->flags & T_MEDIUM)
11466 {
11467 if (str->reserve(SPIDER_SQL_SQL_MEDIUM_LEN))
11468 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11469 str->q_append(SPIDER_SQL_SQL_MEDIUM_STR, SPIDER_SQL_SQL_MEDIUM_LEN);
11470 }
11471 if (check_opt->flags & T_EXTEND)
11472 {
11473 if (str->reserve(SPIDER_SQL_SQL_EXTENDED_LEN))
11474 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11475 str->q_append(SPIDER_SQL_SQL_EXTENDED_STR, SPIDER_SQL_SQL_EXTENDED_LEN);
11476 }
11477 DBUG_RETURN(0);
11478 }
11479
append_enable_keys_part(ulong sql_type,int link_idx)11480 int spider_mbase_handler::append_enable_keys_part(
11481 ulong sql_type,
11482 int link_idx
11483 ) {
11484 int error_num;
11485 spider_string *str;
11486 DBUG_ENTER("spider_mbase_handler::append_enable_keys_part");
11487 DBUG_PRINT("info",("spider this=%p", this));
11488 switch (sql_type)
11489 {
11490 case SPIDER_SQL_TYPE_OTHER_SQL:
11491 str = &spider->result_list.sqls[link_idx];
11492 break;
11493 default:
11494 DBUG_RETURN(0);
11495 }
11496 error_num = append_enable_keys(str, link_idx);
11497 DBUG_RETURN(error_num);
11498 }
11499
append_enable_keys(spider_string * str,int link_idx)11500 int spider_mbase_handler::append_enable_keys(
11501 spider_string *str,
11502 int link_idx
11503 ) {
11504 int conn_link_idx = spider->conn_link_idx[link_idx];
11505 DBUG_ENTER("spider_mbase_handler::append_enable_keys");
11506 DBUG_PRINT("info",("spider this=%p", this));
11507 if (str->reserve(SPIDER_SQL_SQL_ALTER_TABLE_LEN +
11508 mysql_share->db_names_str[conn_link_idx].length() +
11509 SPIDER_SQL_DOT_LEN +
11510 mysql_share->table_names_str[conn_link_idx].length() +
11511 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_SQL_ENABLE_KEYS_LEN))
11512 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11513 str->q_append(SPIDER_SQL_SQL_ALTER_TABLE_STR,
11514 SPIDER_SQL_SQL_ALTER_TABLE_LEN);
11515 mysql_share->append_table_name(str, conn_link_idx);
11516 str->q_append(SPIDER_SQL_SQL_ENABLE_KEYS_STR,
11517 SPIDER_SQL_SQL_ENABLE_KEYS_LEN);
11518 DBUG_RETURN(0);
11519 }
11520
append_disable_keys_part(ulong sql_type,int link_idx)11521 int spider_mbase_handler::append_disable_keys_part(
11522 ulong sql_type,
11523 int link_idx
11524 ) {
11525 int error_num;
11526 spider_string *str;
11527 DBUG_ENTER("spider_mbase_handler::append_disable_keys_part");
11528 DBUG_PRINT("info",("spider this=%p", this));
11529 switch (sql_type)
11530 {
11531 case SPIDER_SQL_TYPE_OTHER_SQL:
11532 str = &spider->result_list.sqls[link_idx];
11533 break;
11534 default:
11535 DBUG_RETURN(0);
11536 }
11537 error_num = append_disable_keys(str, link_idx);
11538 DBUG_RETURN(error_num);
11539 }
11540
append_disable_keys(spider_string * str,int link_idx)11541 int spider_mbase_handler::append_disable_keys(
11542 spider_string *str,
11543 int link_idx
11544 ) {
11545 int conn_link_idx = spider->conn_link_idx[link_idx];
11546 DBUG_ENTER("spider_mbase_handler::append_disable_keys");
11547 DBUG_PRINT("info",("spider this=%p", this));
11548 if (str->reserve(SPIDER_SQL_SQL_ALTER_TABLE_LEN +
11549 mysql_share->db_names_str[conn_link_idx].length() +
11550 SPIDER_SQL_DOT_LEN +
11551 mysql_share->table_names_str[conn_link_idx].length() +
11552 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_SQL_DISABLE_KEYS_LEN))
11553 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11554 str->q_append(SPIDER_SQL_SQL_ALTER_TABLE_STR,
11555 SPIDER_SQL_SQL_ALTER_TABLE_LEN);
11556 mysql_share->append_table_name(str, conn_link_idx);
11557 str->q_append(SPIDER_SQL_SQL_DISABLE_KEYS_STR,
11558 SPIDER_SQL_SQL_DISABLE_KEYS_LEN);
11559 DBUG_RETURN(0);
11560 }
11561
append_delete_all_rows_part(ulong sql_type)11562 int spider_mbase_handler::append_delete_all_rows_part(
11563 ulong sql_type
11564 ) {
11565 int error_num;
11566 spider_string *str;
11567 DBUG_ENTER("spider_mbase_handler::append_delete_all_rows_part");
11568 DBUG_PRINT("info",("spider this=%p", this));
11569 switch (sql_type)
11570 {
11571 case SPIDER_SQL_TYPE_DELETE_SQL:
11572 str = &update_sql;
11573 break;
11574 default:
11575 DBUG_RETURN(0);
11576 }
11577 error_num = append_delete_all_rows(str, sql_type);
11578 DBUG_RETURN(error_num);
11579 }
11580
append_delete_all_rows(spider_string * str,ulong sql_type)11581 int spider_mbase_handler::append_delete_all_rows(
11582 spider_string *str,
11583 ulong sql_type
11584 ) {
11585 int error_num;
11586 DBUG_ENTER("spider_mbase_handler::append_delete_all_rows");
11587 DBUG_PRINT("info",("spider this=%p", this));
11588 if (spider->sql_command == SQLCOM_TRUNCATE)
11589 {
11590 if ((error_num = append_truncate(str, sql_type, first_link_idx)))
11591 DBUG_RETURN(error_num);
11592 } else {
11593 if (
11594 (error_num = append_delete(str)) ||
11595 (error_num = append_from(str, sql_type, first_link_idx))
11596 )
11597 DBUG_RETURN(error_num);
11598 }
11599 DBUG_RETURN(0);
11600 }
11601
append_truncate(spider_string * str,ulong sql_type,int link_idx)11602 int spider_mbase_handler::append_truncate(
11603 spider_string *str,
11604 ulong sql_type,
11605 int link_idx
11606 ) {
11607 DBUG_ENTER("spider_mbase_handler::append_truncate");
11608 if (str->reserve(SPIDER_SQL_TRUNCATE_TABLE_LEN +
11609 mysql_share->db_nm_max_length +
11610 SPIDER_SQL_DOT_LEN + mysql_share->table_nm_max_length +
11611 /* SPIDER_SQL_NAME_QUOTE_LEN */ 4 + SPIDER_SQL_OPEN_PAREN_LEN))
11612 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11613 str->q_append(SPIDER_SQL_TRUNCATE_TABLE_STR, SPIDER_SQL_TRUNCATE_TABLE_LEN);
11614 table_name_pos = str->length();
11615 append_table_name_with_adjusting(str, link_idx, sql_type);
11616 DBUG_RETURN(0);
11617 }
11618
append_explain_select_part(key_range * start_key,key_range * end_key,ulong sql_type,int link_idx)11619 int spider_mbase_handler::append_explain_select_part(
11620 key_range *start_key,
11621 key_range *end_key,
11622 ulong sql_type,
11623 int link_idx
11624 ) {
11625 int error_num;
11626 spider_string *str;
11627 DBUG_ENTER("spider_mbase_handler::append_explain_select_part");
11628 DBUG_PRINT("info",("spider this=%p", this));
11629 switch (sql_type)
11630 {
11631 case SPIDER_SQL_TYPE_OTHER_SQL:
11632 str = &spider->result_list.sqls[link_idx];
11633 break;
11634 default:
11635 DBUG_RETURN(0);
11636 }
11637 error_num =
11638 append_explain_select(str, start_key, end_key, sql_type, link_idx);
11639 DBUG_RETURN(error_num);
11640 }
11641
append_explain_select(spider_string * str,key_range * start_key,key_range * end_key,ulong sql_type,int link_idx)11642 int spider_mbase_handler::append_explain_select(
11643 spider_string *str,
11644 key_range *start_key,
11645 key_range *end_key,
11646 ulong sql_type,
11647 int link_idx
11648 ) {
11649 int error_num;
11650 DBUG_ENTER("spider_mbase_handler::append_explain_select");
11651 DBUG_PRINT("info",("spider this=%p", this));
11652 if (str->reserve(SPIDER_SQL_EXPLAIN_SELECT_LEN))
11653 {
11654 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11655 }
11656 str->q_append(SPIDER_SQL_EXPLAIN_SELECT_STR, SPIDER_SQL_EXPLAIN_SELECT_LEN);
11657 if (
11658 (error_num = append_from(str, sql_type, link_idx)) ||
11659 (error_num = append_key_where(str, NULL, NULL, start_key, end_key,
11660 sql_type, FALSE))
11661 ) {
11662 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11663 }
11664 DBUG_RETURN(0);
11665 }
11666
11667 /********************************************************************
11668 * Determine whether the current query's projection list
11669 * consists solely of the specified column.
11670 *
11671 * Params IN - field_index:
11672 * Field index of the column of interest within
11673 * its table.
11674 *
11675 * Returns TRUE - if the query's projection list consists
11676 * solely of the specified column.
11677 * FALSE - otherwise.
11678 ********************************************************************/
is_sole_projection_field(uint16 field_index)11679 bool spider_mbase_handler::is_sole_projection_field(
11680 uint16 field_index
11681 ) {
11682 // Determine whether the projection list consists solely of the field of interest
11683 bool is_field_in_projection_list = FALSE;
11684 TABLE* table = spider->get_table();
11685 uint16 projection_field_count = 0;
11686 uint16 projection_field_index;
11687 Field** field;
11688 DBUG_ENTER( "spider_mbase_handler::is_sole_projection_field" );
11689
11690 for ( field = table->field; *field ; field++ )
11691 {
11692 projection_field_index = ( *field )->field_index;
11693
11694 if ( !( minimum_select_bit_is_set( projection_field_index ) ) )
11695 {
11696 // Current field is not in the projection list
11697 continue;
11698 }
11699
11700 projection_field_count++;
11701
11702 if ( !is_field_in_projection_list )
11703 {
11704 if ( field_index == projection_field_index )
11705 {
11706 // Field of interest is in the projection list
11707 is_field_in_projection_list = TRUE;
11708 }
11709 }
11710
11711 if ( is_field_in_projection_list && ( projection_field_count != 1 ) )
11712 {
11713 // Field of interest is not the sole column in the projection list
11714 DBUG_RETURN( FALSE );
11715 }
11716 }
11717
11718 if ( is_field_in_projection_list && ( projection_field_count == 1 ) )
11719 {
11720 // Field of interest is the only column in the projection list
11721 DBUG_RETURN( TRUE );
11722 }
11723
11724 DBUG_RETURN( FALSE );
11725 }
11726
is_bulk_insert_exec_period(bool bulk_end)11727 bool spider_mbase_handler::is_bulk_insert_exec_period(
11728 bool bulk_end
11729 ) {
11730 DBUG_ENTER("spider_mbase_handler::is_bulk_insert_exec_period");
11731 DBUG_PRINT("info",("spider this=%p", this));
11732 DBUG_PRINT("info",("spider insert_sql.length=%u", insert_sql.length()));
11733 DBUG_PRINT("info",("spider insert_pos=%d", insert_pos));
11734 DBUG_PRINT("info",("spider insert_sql=%s", insert_sql.c_ptr_safe()));
11735 if (
11736 (bulk_end || (int) insert_sql.length() >= spider->bulk_size) &&
11737 (int) insert_sql.length() > insert_pos
11738 ) {
11739 DBUG_RETURN(TRUE);
11740 }
11741 DBUG_RETURN(FALSE);
11742 }
11743
sql_is_filled_up(ulong sql_type)11744 bool spider_mbase_handler::sql_is_filled_up(
11745 ulong sql_type
11746 ) {
11747 DBUG_ENTER("spider_mbase_handler::sql_is_filled_up");
11748 DBUG_PRINT("info",("spider this=%p", this));
11749 DBUG_RETURN(filled_up);
11750 }
11751
sql_is_empty(ulong sql_type)11752 bool spider_mbase_handler::sql_is_empty(
11753 ulong sql_type
11754 ) {
11755 bool is_empty;
11756 DBUG_ENTER("spider_mbase_handler::sql_is_empty");
11757 DBUG_PRINT("info",("spider this=%p", this));
11758 switch (sql_type)
11759 {
11760 case SPIDER_SQL_TYPE_SELECT_SQL:
11761 is_empty = (sql.length() == 0);
11762 break;
11763 case SPIDER_SQL_TYPE_INSERT_SQL:
11764 is_empty = (insert_sql.length() == 0);
11765 break;
11766 case SPIDER_SQL_TYPE_UPDATE_SQL:
11767 case SPIDER_SQL_TYPE_DELETE_SQL:
11768 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
11769 is_empty = (update_sql.length() == 0);
11770 break;
11771 case SPIDER_SQL_TYPE_TMP_SQL:
11772 is_empty = (tmp_sql.length() == 0);
11773 break;
11774 case SPIDER_SQL_TYPE_HANDLER:
11775 is_empty = (ha_sql.length() == 0);
11776 break;
11777 default:
11778 is_empty = TRUE;
11779 break;
11780 }
11781 DBUG_RETURN(is_empty);
11782 }
11783
support_multi_split_read()11784 bool spider_mbase_handler::support_multi_split_read()
11785 {
11786 DBUG_ENTER("spider_mbase_handler::support_multi_split_read");
11787 DBUG_PRINT("info",("spider this=%p", this));
11788 DBUG_RETURN(TRUE);
11789 }
11790
support_bulk_update()11791 bool spider_mbase_handler::support_bulk_update()
11792 {
11793 DBUG_ENTER("spider_mbase_handler::support_bulk_update");
11794 DBUG_PRINT("info",("spider this=%p", this));
11795 DBUG_RETURN(TRUE);
11796 }
11797
bulk_tmp_table_insert()11798 int spider_mbase_handler::bulk_tmp_table_insert()
11799 {
11800 int error_num;
11801 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_insert");
11802 DBUG_PRINT("info",("spider this=%p", this));
11803 error_num = store_sql_to_bulk_tmp_table(&update_sql, upd_tmp_tbl);
11804 DBUG_RETURN(error_num);
11805 }
11806
bulk_tmp_table_insert(int link_idx)11807 int spider_mbase_handler::bulk_tmp_table_insert(
11808 int link_idx
11809 ) {
11810 int error_num;
11811 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_insert");
11812 DBUG_PRINT("info",("spider this=%p", this));
11813 error_num = store_sql_to_bulk_tmp_table(
11814 &spider->result_list.update_sqls[link_idx],
11815 spider->result_list.upd_tmp_tbls[link_idx]);
11816 DBUG_RETURN(error_num);
11817 }
11818
bulk_tmp_table_end_bulk_insert()11819 int spider_mbase_handler::bulk_tmp_table_end_bulk_insert()
11820 {
11821 int error_num;
11822 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_end_bulk_insert");
11823 DBUG_PRINT("info",("spider this=%p", this));
11824 if ((error_num = upd_tmp_tbl->file->ha_end_bulk_insert()))
11825 {
11826 DBUG_RETURN(error_num);
11827 }
11828 DBUG_RETURN(0);
11829 }
11830
bulk_tmp_table_rnd_init()11831 int spider_mbase_handler::bulk_tmp_table_rnd_init()
11832 {
11833 int error_num;
11834 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_rnd_init");
11835 DBUG_PRINT("info",("spider this=%p", this));
11836 upd_tmp_tbl->file->extra(HA_EXTRA_CACHE);
11837 if ((error_num = upd_tmp_tbl->file->ha_rnd_init(TRUE)))
11838 {
11839 DBUG_RETURN(error_num);
11840 }
11841 reading_from_bulk_tmp_table = TRUE;
11842 DBUG_RETURN(0);
11843 }
11844
bulk_tmp_table_rnd_next()11845 int spider_mbase_handler::bulk_tmp_table_rnd_next()
11846 {
11847 int error_num;
11848 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_rnd_next");
11849 DBUG_PRINT("info",("spider this=%p", this));
11850 #if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 50200
11851 error_num = upd_tmp_tbl->file->ha_rnd_next(upd_tmp_tbl->record[0]);
11852 #else
11853 error_num = upd_tmp_tbl->file->rnd_next(upd_tmp_tbl->record[0]);
11854 #endif
11855 if (!error_num)
11856 {
11857 error_num = restore_sql_from_bulk_tmp_table(&insert_sql, upd_tmp_tbl);
11858 }
11859 DBUG_RETURN(error_num);
11860 }
11861
bulk_tmp_table_rnd_end()11862 int spider_mbase_handler::bulk_tmp_table_rnd_end()
11863 {
11864 int error_num;
11865 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_rnd_end");
11866 DBUG_PRINT("info",("spider this=%p", this));
11867 reading_from_bulk_tmp_table = FALSE;
11868 if ((error_num = upd_tmp_tbl->file->ha_rnd_end()))
11869 {
11870 DBUG_RETURN(error_num);
11871 }
11872 DBUG_RETURN(0);
11873 }
11874
need_copy_for_update(int link_idx)11875 bool spider_mbase_handler::need_copy_for_update(
11876 int link_idx
11877 ) {
11878 int all_link_idx = spider->conn_link_idx[link_idx];
11879 DBUG_ENTER("spider_mbase_handler::need_copy_for_update");
11880 DBUG_PRINT("info",("spider this=%p", this));
11881 DBUG_RETURN(!mysql_share->same_db_table_name ||
11882 spider->share->link_statuses[all_link_idx] == SPIDER_LINK_STATUS_RECOVERY);
11883 }
11884
bulk_tmp_table_created()11885 bool spider_mbase_handler::bulk_tmp_table_created()
11886 {
11887 DBUG_ENTER("spider_mbase_handler::bulk_tmp_table_created");
11888 DBUG_PRINT("info",("spider this=%p", this));
11889 DBUG_RETURN(upd_tmp_tbl);
11890 }
11891
mk_bulk_tmp_table_and_bulk_start()11892 int spider_mbase_handler::mk_bulk_tmp_table_and_bulk_start()
11893 {
11894 THD *thd = spider->trx->thd;
11895 TABLE *table = spider->get_table();
11896 DBUG_ENTER("spider_mbase_handler::mk_bulk_tmp_table_and_bulk_start");
11897 DBUG_PRINT("info",("spider this=%p", this));
11898 if (!upd_tmp_tbl)
11899 {
11900 #ifdef SPIDER_use_LEX_CSTRING_for_Field_blob_constructor
11901 LEX_CSTRING field_name = {STRING_WITH_LEN("a")};
11902 if (!(upd_tmp_tbl = spider_mk_sys_tmp_table(
11903 thd, table, &upd_tmp_tbl_prm, &field_name, update_sql.charset())))
11904 #else
11905 if (!(upd_tmp_tbl = spider_mk_sys_tmp_table(
11906 thd, table, &upd_tmp_tbl_prm, "a", update_sql.charset())))
11907 #endif
11908 {
11909 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11910 }
11911 upd_tmp_tbl->file->extra(HA_EXTRA_WRITE_CACHE);
11912 upd_tmp_tbl->file->ha_start_bulk_insert((ha_rows) 0);
11913 }
11914 DBUG_RETURN(0);
11915 }
11916
rm_bulk_tmp_table()11917 void spider_mbase_handler::rm_bulk_tmp_table()
11918 {
11919 DBUG_ENTER("spider_mbase_handler::rm_bulk_tmp_table");
11920 DBUG_PRINT("info",("spider this=%p", this));
11921 if (upd_tmp_tbl)
11922 {
11923 spider_rm_sys_tmp_table(spider->trx->thd, upd_tmp_tbl, &upd_tmp_tbl_prm);
11924 upd_tmp_tbl = NULL;
11925 }
11926 DBUG_VOID_RETURN;
11927 }
11928
store_sql_to_bulk_tmp_table(spider_string * str,TABLE * tmp_table)11929 int spider_mbase_handler::store_sql_to_bulk_tmp_table(
11930 spider_string *str,
11931 TABLE *tmp_table
11932 ) {
11933 int error_num;
11934 DBUG_ENTER("spider_mbase_handler::store_sql_to_bulk_tmp_table");
11935 DBUG_PRINT("info",("spider this=%p", this));
11936 tmp_table->field[0]->set_notnull();
11937 tmp_table->field[0]->store(str->ptr(), str->length(), str->charset());
11938 if ((error_num = tmp_table->file->ha_write_row(tmp_table->record[0])))
11939 DBUG_RETURN(error_num);
11940 DBUG_RETURN(0);
11941 }
11942
restore_sql_from_bulk_tmp_table(spider_string * str,TABLE * tmp_table)11943 int spider_mbase_handler::restore_sql_from_bulk_tmp_table(
11944 spider_string *str,
11945 TABLE *tmp_table
11946 ) {
11947 DBUG_ENTER("spider_mbase_handler::restore_sql_from_bulk_tmp_table");
11948 DBUG_PRINT("info",("spider this=%p", this));
11949 tmp_table->field[0]->val_str(str->get_str());
11950 str->mem_calc();
11951 DBUG_RETURN(0);
11952 }
11953
insert_lock_tables_list(SPIDER_CONN * conn,int link_idx)11954 int spider_mbase_handler::insert_lock_tables_list(
11955 SPIDER_CONN *conn,
11956 int link_idx
11957 ) {
11958 spider_db_mbase *db_conn = (spider_db_mbase *) conn->db_conn;
11959 SPIDER_LINK_FOR_HASH *tmp_link_for_hash2 = &link_for_hash[link_idx];
11960 DBUG_ENTER("spider_mbase_handler::insert_lock_tables_list");
11961 DBUG_PRINT("info",("spider this=%p", this));
11962 uint old_elements =
11963 db_conn->lock_table_hash.array.max_element;
11964 #ifdef HASH_UPDATE_WITH_HASH_VALUE
11965 if (my_hash_insert_with_hash_value(
11966 &db_conn->lock_table_hash,
11967 tmp_link_for_hash2->db_table_str_hash_value,
11968 (uchar*) tmp_link_for_hash2))
11969 #else
11970 if (my_hash_insert(&db_conn->lock_table_hash,
11971 (uchar*) tmp_link_for_hash2))
11972 #endif
11973 {
11974 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
11975 }
11976 if (db_conn->lock_table_hash.array.max_element > old_elements)
11977 {
11978 spider_alloc_calc_mem(spider_current_trx,
11979 db_conn->lock_table_hash,
11980 (db_conn->lock_table_hash.array.max_element - old_elements) *
11981 db_conn->lock_table_hash.array.size_of_element);
11982 }
11983 DBUG_RETURN(0);
11984 }
11985
append_lock_tables_list(SPIDER_CONN * conn,int link_idx,int * appended)11986 int spider_mbase_handler::append_lock_tables_list(
11987 SPIDER_CONN *conn,
11988 int link_idx,
11989 int *appended
11990 ) {
11991 int error_num;
11992 SPIDER_LINK_FOR_HASH *tmp_link_for_hash, *tmp_link_for_hash2;
11993 int conn_link_idx = spider->conn_link_idx[link_idx];
11994 spider_db_mbase *db_conn = (spider_db_mbase *) conn->db_conn;
11995 DBUG_ENTER("spider_mbase_handler::append_lock_tables_list");
11996 DBUG_PRINT("info",("spider this=%p", this));
11997 tmp_link_for_hash2 = &link_for_hash[link_idx];
11998 tmp_link_for_hash2->db_table_str =
11999 &mysql_share->db_table_str[conn_link_idx];
12000 #ifdef SPIDER_HAS_HASH_VALUE_TYPE
12001 tmp_link_for_hash2->db_table_str_hash_value =
12002 mysql_share->db_table_str_hash_value[conn_link_idx];
12003 if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *)
12004 my_hash_search_using_hash_value(
12005 &db_conn->lock_table_hash,
12006 tmp_link_for_hash2->db_table_str_hash_value,
12007 (uchar*) tmp_link_for_hash2->db_table_str->ptr(),
12008 tmp_link_for_hash2->db_table_str->length())))
12009 #else
12010 if (!(tmp_link_for_hash = (SPIDER_LINK_FOR_HASH *) my_hash_search(
12011 &db_conn->lock_table_hash,
12012 (uchar*) tmp_link_for_hash2->db_table_str->ptr(),
12013 tmp_link_for_hash2->db_table_str->length())))
12014 #endif
12015 {
12016 if ((error_num = insert_lock_tables_list(conn, link_idx)))
12017 DBUG_RETURN(error_num);
12018 *appended = 1;
12019 } else {
12020 if (tmp_link_for_hash->spider->lock_type < spider->lock_type)
12021 {
12022 #ifdef HASH_UPDATE_WITH_HASH_VALUE
12023 my_hash_delete_with_hash_value(
12024 &db_conn->lock_table_hash,
12025 tmp_link_for_hash->db_table_str_hash_value,
12026 (uchar*) tmp_link_for_hash);
12027 #else
12028 my_hash_delete(&db_conn->lock_table_hash,
12029 (uchar*) tmp_link_for_hash);
12030 #endif
12031 uint old_elements =
12032 db_conn->lock_table_hash.array.max_element;
12033 #ifdef HASH_UPDATE_WITH_HASH_VALUE
12034 if (my_hash_insert_with_hash_value(
12035 &db_conn->lock_table_hash,
12036 tmp_link_for_hash2->db_table_str_hash_value,
12037 (uchar*) tmp_link_for_hash2))
12038 #else
12039 if (my_hash_insert(&db_conn->lock_table_hash,
12040 (uchar*) tmp_link_for_hash2))
12041 #endif
12042 {
12043 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12044 }
12045 if (db_conn->lock_table_hash.array.max_element > old_elements)
12046 {
12047 spider_alloc_calc_mem(spider_current_trx,
12048 db_conn->lock_table_hash,
12049 (db_conn->lock_table_hash.array.max_element - old_elements) *
12050 db_conn->lock_table_hash.array.size_of_element);
12051 }
12052 }
12053 }
12054 DBUG_RETURN(0);
12055 }
12056
realloc_sql(ulong * realloced)12057 int spider_mbase_handler::realloc_sql(
12058 ulong *realloced
12059 ) {
12060 THD *thd = spider->trx->thd;
12061 st_spider_share *share = spider->share;
12062 int init_sql_alloc_size =
12063 spider_param_init_sql_alloc_size(thd, share->init_sql_alloc_size);
12064 DBUG_ENTER("spider_mbase_handler::realloc_sql");
12065 DBUG_PRINT("info",("spider this=%p", this));
12066 if ((int) sql.alloced_length() > init_sql_alloc_size * 2)
12067 {
12068 sql.free();
12069 if (sql.real_alloc(init_sql_alloc_size))
12070 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12071 *realloced |= SPIDER_SQL_TYPE_SELECT_SQL;
12072 }
12073 if ((int) ha_sql.alloced_length() > init_sql_alloc_size * 2)
12074 {
12075 ha_sql.free();
12076 if (ha_sql.real_alloc(init_sql_alloc_size))
12077 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12078 *realloced |= SPIDER_SQL_TYPE_SELECT_SQL;
12079 }
12080 if ((int) dup_update_sql.alloced_length() > init_sql_alloc_size * 2)
12081 {
12082 dup_update_sql.free();
12083 if (dup_update_sql.real_alloc(init_sql_alloc_size))
12084 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12085 }
12086 if ((int) insert_sql.alloced_length() > init_sql_alloc_size * 2)
12087 {
12088 insert_sql.free();
12089 if (insert_sql.real_alloc(init_sql_alloc_size))
12090 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12091 *realloced |= SPIDER_SQL_TYPE_INSERT_SQL;
12092 }
12093 if ((int) update_sql.alloced_length() > init_sql_alloc_size * 2)
12094 {
12095 update_sql.free();
12096 if (update_sql.real_alloc(init_sql_alloc_size))
12097 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12098 *realloced |= (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL);
12099 }
12100 update_sql.length(0);
12101 if ((int) tmp_sql.alloced_length() > init_sql_alloc_size * 2)
12102 {
12103 tmp_sql.free();
12104 if (tmp_sql.real_alloc(init_sql_alloc_size))
12105 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12106 *realloced |= SPIDER_SQL_TYPE_TMP_SQL;
12107 }
12108 DBUG_RETURN(0);
12109 }
12110
reset_sql(ulong sql_type)12111 int spider_mbase_handler::reset_sql(
12112 ulong sql_type
12113 ) {
12114 DBUG_ENTER("spider_mbase_handler::reset_sql");
12115 DBUG_PRINT("info",("spider this=%p", this));
12116 if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL)
12117 {
12118 sql.length(0);
12119 }
12120 if (sql_type & SPIDER_SQL_TYPE_INSERT_SQL)
12121 {
12122 insert_sql.length(0);
12123 }
12124 if (sql_type & (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL |
12125 SPIDER_SQL_TYPE_BULK_UPDATE_SQL))
12126 {
12127 update_sql.length(0);
12128 }
12129 if (sql_type & SPIDER_SQL_TYPE_TMP_SQL)
12130 {
12131 tmp_sql.length(0);
12132 }
12133 if (sql_type & SPIDER_SQL_TYPE_HANDLER)
12134 {
12135 ha_sql.length(0);
12136 }
12137 DBUG_RETURN(0);
12138 }
12139
12140 #if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET)
reset_keys(ulong sql_type)12141 int spider_mbase_handler::reset_keys(
12142 ulong sql_type
12143 ) {
12144 DBUG_ENTER("spider_mbase_handler::reset_keys");
12145 DBUG_PRINT("info",("spider this=%p", this));
12146 DBUG_ASSERT(0);
12147 DBUG_RETURN(0);
12148 }
12149
reset_upds(ulong sql_type)12150 int spider_mbase_handler::reset_upds(
12151 ulong sql_type
12152 ) {
12153 DBUG_ENTER("spider_mbase_handler::reset_upds");
12154 DBUG_PRINT("info",("spider this=%p", this));
12155 hs_upds.clear();
12156 DBUG_RETURN(0);
12157 }
12158
reset_strs(ulong sql_type)12159 int spider_mbase_handler::reset_strs(
12160 ulong sql_type
12161 ) {
12162 DBUG_ENTER("spider_mbase_handler::reset_strs");
12163 DBUG_PRINT("info",("spider this=%p", this));
12164 DBUG_ASSERT(0);
12165 DBUG_RETURN(0);
12166 }
12167
reset_strs_pos(ulong sql_type)12168 int spider_mbase_handler::reset_strs_pos(
12169 ulong sql_type
12170 ) {
12171 DBUG_ENTER("spider_mbase_handler::reset_strs_pos");
12172 DBUG_PRINT("info",("spider this=%p", this));
12173 DBUG_ASSERT(0);
12174 DBUG_RETURN(0);
12175 }
12176
push_back_upds(SPIDER_HS_STRING_REF & info)12177 int spider_mbase_handler::push_back_upds(
12178 SPIDER_HS_STRING_REF &info
12179 ) {
12180 int error_num;
12181 DBUG_ENTER("spider_mbase_handler::push_back_upds");
12182 DBUG_PRINT("info",("spider this=%p", this));
12183 error_num = hs_upds.push_back(info);
12184 DBUG_RETURN(error_num);
12185 }
12186 #endif
12187
need_lock_before_set_sql_for_exec(ulong sql_type)12188 bool spider_mbase_handler::need_lock_before_set_sql_for_exec(
12189 ulong sql_type
12190 ) {
12191 DBUG_ENTER("spider_mbase_handler::need_lock_before_set_sql_for_exec");
12192 DBUG_PRINT("info",("spider this=%p", this));
12193 DBUG_RETURN(FALSE);
12194 }
12195
12196 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
set_sql_for_exec(ulong sql_type,int link_idx,SPIDER_LINK_IDX_CHAIN * link_idx_chain)12197 int spider_mbase_handler::set_sql_for_exec(
12198 ulong sql_type,
12199 int link_idx,
12200 SPIDER_LINK_IDX_CHAIN *link_idx_chain
12201 ) {
12202 int error_num;
12203 DBUG_ENTER("spider_mbase_handler::set_sql_for_exec");
12204 DBUG_PRINT("info",("spider this=%p", this));
12205 if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL)
12206 {
12207 if ((error_num = spider_db_mbase_utility->reappend_tables(
12208 spider->fields, link_idx_chain, &sql)))
12209 DBUG_RETURN(error_num);
12210 exec_sql = &sql;
12211 }
12212 DBUG_RETURN(0);
12213 }
12214 #endif
12215
set_sql_for_exec(ulong sql_type,int link_idx)12216 int spider_mbase_handler::set_sql_for_exec(
12217 ulong sql_type,
12218 int link_idx
12219 ) {
12220 int error_num;
12221 uint tmp_pos;
12222 SPIDER_SHARE *share = spider->share;
12223 SPIDER_RESULT_LIST *result_list = &spider->result_list;
12224 int all_link_idx = spider->conn_link_idx[link_idx];
12225 DBUG_ENTER("spider_mbase_handler::set_sql_for_exec");
12226 DBUG_PRINT("info",("spider this=%p", this));
12227 if (sql_type & (SPIDER_SQL_TYPE_SELECT_SQL | SPIDER_SQL_TYPE_TMP_SQL))
12228 {
12229 if (mysql_share->same_db_table_name || link_idx == first_link_idx)
12230 {
12231 if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL)
12232 exec_sql = &sql;
12233 if (sql_type & SPIDER_SQL_TYPE_TMP_SQL)
12234 exec_tmp_sql = &tmp_sql;
12235 } else {
12236 char tmp_table_name[MAX_FIELD_WIDTH * 2],
12237 tgt_table_name[MAX_FIELD_WIDTH * 2];
12238 int tmp_table_name_length;
12239 spider_string tgt_table_name_str(tgt_table_name,
12240 MAX_FIELD_WIDTH * 2,
12241 mysql_share->db_names_str[link_idx].charset());
12242 const char *table_names[2], *table_aliases[2];
12243 uint table_name_lengths[2], table_alias_lengths[2];
12244 tgt_table_name_str.init_calc_mem(104);
12245 tgt_table_name_str.length(0);
12246 if (result_list->tmp_table_join && spider->bka_mode != 2)
12247 {
12248 create_tmp_bka_table_name(tmp_table_name, &tmp_table_name_length,
12249 link_idx);
12250 append_table_name_with_adjusting(&tgt_table_name_str, link_idx,
12251 SPIDER_SQL_TYPE_TMP_SQL);
12252 table_names[0] = tmp_table_name;
12253 table_names[1] = tgt_table_name_str.ptr();
12254 table_name_lengths[0] = tmp_table_name_length;
12255 table_name_lengths[1] = tgt_table_name_str.length();
12256 table_aliases[0] = SPIDER_SQL_A_STR;
12257 table_aliases[1] = SPIDER_SQL_B_STR;
12258 table_alias_lengths[0] = SPIDER_SQL_A_LEN;
12259 table_alias_lengths[1] = SPIDER_SQL_B_LEN;
12260 }
12261 if (sql_type & SPIDER_SQL_TYPE_SELECT_SQL)
12262 {
12263 exec_sql = &result_list->sqls[link_idx];
12264 if (exec_sql->copy(sql))
12265 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12266 else if (result_list->use_union)
12267 {
12268 if ((error_num = reset_union_table_name(exec_sql, link_idx,
12269 SPIDER_SQL_TYPE_SELECT_SQL)))
12270 DBUG_RETURN(error_num);
12271 } else {
12272 tmp_pos = exec_sql->length();
12273 exec_sql->length(table_name_pos);
12274 if (result_list->tmp_table_join && spider->bka_mode != 2)
12275 {
12276 if ((error_num = spider_db_mbase_utility->append_from_with_alias(
12277 exec_sql, table_names, table_name_lengths,
12278 table_aliases, table_alias_lengths, 2,
12279 &table_name_pos, TRUE))
12280 )
12281 DBUG_RETURN(error_num);
12282 exec_sql->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
12283 } else {
12284 append_table_name_with_adjusting(exec_sql, link_idx,
12285 SPIDER_SQL_TYPE_SELECT_SQL);
12286 }
12287 exec_sql->length(tmp_pos);
12288 }
12289 }
12290 if (sql_type & SPIDER_SQL_TYPE_TMP_SQL)
12291 {
12292 exec_tmp_sql = &result_list->tmp_sqls[link_idx];
12293 if (result_list->tmp_table_join && spider->bka_mode != 2)
12294 {
12295 if (exec_tmp_sql->copy(tmp_sql))
12296 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12297 else {
12298 tmp_pos = exec_tmp_sql->length();
12299 exec_tmp_sql->length(tmp_sql_pos1);
12300 exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length);
12301 exec_tmp_sql->length(tmp_sql_pos2);
12302 exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length);
12303 exec_tmp_sql->length(tmp_sql_pos3);
12304 exec_tmp_sql->q_append(tmp_table_name, tmp_table_name_length);
12305 exec_tmp_sql->length(tmp_pos);
12306 }
12307 }
12308 }
12309 }
12310 }
12311 if (sql_type & SPIDER_SQL_TYPE_INSERT_SQL)
12312 {
12313 if (mysql_share->same_db_table_name || link_idx == first_link_idx)
12314 exec_insert_sql = &insert_sql;
12315 else {
12316 exec_insert_sql = &result_list->insert_sqls[link_idx];
12317 if (exec_insert_sql->copy(insert_sql))
12318 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12319 DBUG_PRINT("info",("spider exec_insert_sql=%s",
12320 exec_insert_sql->c_ptr_safe()));
12321 tmp_pos = exec_insert_sql->length();
12322 exec_insert_sql->length(insert_table_name_pos);
12323 append_table_name_with_adjusting(exec_insert_sql, link_idx,
12324 sql_type);
12325 exec_insert_sql->length(tmp_pos);
12326 DBUG_PRINT("info",("spider exec_insert_sql->length=%u",
12327 exec_insert_sql->length()));
12328 DBUG_PRINT("info",("spider exec_insert_sql=%s",
12329 exec_insert_sql->c_ptr_safe()));
12330 }
12331 }
12332 if (sql_type & SPIDER_SQL_TYPE_BULK_UPDATE_SQL)
12333 {
12334 if (reading_from_bulk_tmp_table)
12335 {
12336 if (
12337 mysql_share->same_db_table_name &&
12338 share->link_statuses[all_link_idx] != SPIDER_LINK_STATUS_RECOVERY
12339 ) {
12340 exec_update_sql = &insert_sql;
12341 } else if (!spider->result_list.upd_tmp_tbls[link_idx])
12342 {
12343 DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
12344 } else {
12345 exec_update_sql = &spider->result_list.insert_sqls[link_idx];
12346 if ((error_num = restore_sql_from_bulk_tmp_table(exec_update_sql,
12347 spider->result_list.upd_tmp_tbls[link_idx])))
12348 {
12349 DBUG_RETURN(error_num);
12350 }
12351 }
12352 } else {
12353 if (
12354 mysql_share->same_db_table_name &&
12355 share->link_statuses[all_link_idx] != SPIDER_LINK_STATUS_RECOVERY
12356 ) {
12357 exec_update_sql = &update_sql;
12358 } else {
12359 exec_update_sql = &spider->result_list.update_sqls[link_idx];
12360 }
12361 }
12362 } else if (sql_type &
12363 (SPIDER_SQL_TYPE_UPDATE_SQL | SPIDER_SQL_TYPE_DELETE_SQL))
12364 {
12365 if (mysql_share->same_db_table_name || link_idx == first_link_idx)
12366 exec_update_sql = &update_sql;
12367 else {
12368 exec_update_sql = &spider->result_list.update_sqls[link_idx];
12369 if (exec_update_sql->copy(update_sql))
12370 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12371 tmp_pos = exec_update_sql->length();
12372 exec_update_sql->length(table_name_pos);
12373 append_table_name_with_adjusting(exec_update_sql, link_idx,
12374 sql_type);
12375 exec_update_sql->length(tmp_pos);
12376 }
12377 }
12378 if (sql_type & SPIDER_SQL_TYPE_HANDLER)
12379 {
12380 if (spider->m_handler_id[link_idx] == ha_sql_handler_id)
12381 exec_ha_sql = &ha_sql;
12382 else {
12383 exec_ha_sql = &result_list->sqls[link_idx];
12384 if (exec_ha_sql->copy(ha_sql))
12385 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
12386 else {
12387 tmp_pos = exec_ha_sql->length();
12388 exec_ha_sql->length(ha_table_name_pos);
12389 append_table_name_with_adjusting(exec_ha_sql, link_idx,
12390 SPIDER_SQL_TYPE_HANDLER);
12391 exec_ha_sql->length(tmp_pos);
12392 }
12393 }
12394 }
12395 DBUG_RETURN(0);
12396 }
12397
set_sql_for_exec(spider_db_copy_table * tgt_ct,ulong sql_type)12398 int spider_mbase_handler::set_sql_for_exec(
12399 spider_db_copy_table *tgt_ct,
12400 ulong sql_type
12401 ) {
12402 spider_mbase_copy_table *mysql_ct = (spider_mbase_copy_table *) tgt_ct;
12403 DBUG_ENTER("spider_mbase_handler::set_sql_for_exec");
12404 DBUG_PRINT("info",("spider this=%p", this));
12405 switch (sql_type)
12406 {
12407 case SPIDER_SQL_TYPE_INSERT_SQL:
12408 exec_insert_sql = &mysql_ct->sql;
12409 break;
12410 default:
12411 DBUG_ASSERT(0);
12412 break;
12413 }
12414 DBUG_RETURN(0);
12415 }
12416
execute_sql(ulong sql_type,SPIDER_CONN * conn,int quick_mode,int * need_mon)12417 int spider_mbase_handler::execute_sql(
12418 ulong sql_type,
12419 SPIDER_CONN *conn,
12420 int quick_mode,
12421 int *need_mon
12422 ) {
12423 spider_string *tgt_sql;
12424 uint tgt_length;
12425 DBUG_ENTER("spider_mbase_handler::execute_sql");
12426 DBUG_PRINT("info",("spider this=%p", this));
12427 switch (sql_type)
12428 {
12429 case SPIDER_SQL_TYPE_SELECT_SQL:
12430 DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_SELECT_SQL"));
12431 tgt_sql = exec_sql;
12432 tgt_length = tgt_sql->length();
12433 break;
12434 case SPIDER_SQL_TYPE_INSERT_SQL:
12435 DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_SELECT_SQL"));
12436 tgt_sql = exec_insert_sql;
12437 tgt_length = tgt_sql->length();
12438 break;
12439 case SPIDER_SQL_TYPE_UPDATE_SQL:
12440 case SPIDER_SQL_TYPE_DELETE_SQL:
12441 case SPIDER_SQL_TYPE_BULK_UPDATE_SQL:
12442 DBUG_PRINT("info",("spider %s",
12443 sql_type == SPIDER_SQL_TYPE_UPDATE_SQL ? "SPIDER_SQL_TYPE_UPDATE_SQL" :
12444 sql_type == SPIDER_SQL_TYPE_DELETE_SQL ? "SPIDER_SQL_TYPE_DELETE_SQL" :
12445 "SPIDER_SQL_TYPE_BULK_UPDATE_SQL"
12446 ));
12447 tgt_sql = exec_update_sql;
12448 tgt_length = tgt_sql->length();
12449 break;
12450 case SPIDER_SQL_TYPE_TMP_SQL:
12451 DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_TMP_SQL"));
12452 tgt_sql = exec_tmp_sql;
12453 tgt_length = tgt_sql->length();
12454 break;
12455 case SPIDER_SQL_TYPE_DROP_TMP_TABLE_SQL:
12456 DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_DROP_TMP_TABLE_SQL"));
12457 tgt_sql = exec_tmp_sql;
12458 tgt_length = tmp_sql_pos5;
12459 break;
12460 case SPIDER_SQL_TYPE_HANDLER:
12461 DBUG_PRINT("info",("spider SPIDER_SQL_TYPE_HANDLER"));
12462 tgt_sql = exec_ha_sql;
12463 tgt_length = tgt_sql->length();
12464 break;
12465 default:
12466 /* nothing to do */
12467 DBUG_PRINT("info",("spider default"));
12468 DBUG_RETURN(0);
12469 }
12470 DBUG_RETURN(spider_db_query(
12471 conn,
12472 tgt_sql->ptr(),
12473 tgt_length,
12474 quick_mode,
12475 need_mon
12476 ));
12477 }
12478
reset()12479 int spider_mbase_handler::reset()
12480 {
12481 DBUG_ENTER("spider_mbase_handler::reset");
12482 DBUG_PRINT("info",("spider this=%p", this));
12483 update_sql.length(0);
12484 DBUG_RETURN(0);
12485 }
12486
sts_mode_exchange(int sts_mode)12487 int spider_mbase_handler::sts_mode_exchange(
12488 int sts_mode
12489 ) {
12490 DBUG_ENTER("spider_mbase_handler::sts_mode_exchange");
12491 DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
12492 DBUG_RETURN(sts_mode);
12493 }
12494
show_table_status(int link_idx,int sts_mode,uint flag)12495 int spider_mbase_handler::show_table_status(
12496 int link_idx,
12497 int sts_mode,
12498 uint flag
12499 ) {
12500 int error_num;
12501 SPIDER_CONN *conn = spider->conns[link_idx];
12502 SPIDER_DB_RESULT *res;
12503 SPIDER_SHARE *share = spider->share;
12504 uint pos = (2 * spider->conn_link_idx[link_idx]);
12505 ulonglong auto_increment_value = 0;
12506 DBUG_ENTER("spider_mbase_handler::show_table_status");
12507 DBUG_PRINT("info",("spider sts_mode=%d", sts_mode));
12508
12509 if (sts_mode == 1)
12510 {
12511 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
12512 pthread_mutex_lock(&conn->mta_conn_mutex);
12513 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
12514 conn->need_mon = &spider->need_mons[link_idx];
12515 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
12516 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
12517 conn->mta_conn_mutex_lock_already = TRUE;
12518 conn->mta_conn_mutex_unlock_later = TRUE;
12519 conn->disable_connect_retry = TRUE;
12520 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12521 share);
12522 if (
12523 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
12524 (
12525 spider_db_query(
12526 conn,
12527 mysql_share->show_table_status[0 + pos].ptr(),
12528 mysql_share->show_table_status[0 + pos].length(),
12529 -1,
12530 &spider->need_mons[link_idx]) &&
12531 (error_num = spider_db_errorno(conn))
12532 )
12533 ) {
12534 if (
12535 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
12536 !conn->disable_reconnect
12537 ) {
12538 /* retry */
12539 if ((error_num = spider_db_ping(spider, conn, link_idx)))
12540 {
12541 conn->disable_connect_retry = FALSE;
12542 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12543 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12544 conn->mta_conn_mutex_lock_already = FALSE;
12545 conn->mta_conn_mutex_unlock_later = FALSE;
12546 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12547 pthread_mutex_unlock(&conn->mta_conn_mutex);
12548 DBUG_RETURN(error_num);
12549 }
12550 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
12551 {
12552 conn->disable_connect_retry = FALSE;
12553 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12554 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12555 conn->mta_conn_mutex_lock_already = FALSE;
12556 conn->mta_conn_mutex_unlock_later = FALSE;
12557 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12558 pthread_mutex_unlock(&conn->mta_conn_mutex);
12559 DBUG_RETURN(error_num);
12560 }
12561 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12562 share);
12563 if (spider_db_query(
12564 conn,
12565 mysql_share->show_table_status[0 + pos].ptr(),
12566 mysql_share->show_table_status[0 + pos].length(),
12567 -1,
12568 &spider->need_mons[link_idx])
12569 ) {
12570 conn->disable_connect_retry = FALSE;
12571 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12572 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12573 conn->mta_conn_mutex_lock_already = FALSE;
12574 conn->mta_conn_mutex_unlock_later = FALSE;
12575 DBUG_RETURN(spider_db_errorno(conn));
12576 }
12577 } else {
12578 conn->disable_connect_retry = FALSE;
12579 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12580 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12581 conn->mta_conn_mutex_lock_already = FALSE;
12582 conn->mta_conn_mutex_unlock_later = FALSE;
12583 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12584 pthread_mutex_unlock(&conn->mta_conn_mutex);
12585 DBUG_RETURN(error_num);
12586 }
12587 }
12588 st_spider_db_request_key request_key;
12589 request_key.spider_thread_id = spider->trx->spider_thread_id;
12590 request_key.query_id = spider->trx->thd->query_id;
12591 request_key.handler = spider;
12592 request_key.request_id = 1;
12593 request_key.next = NULL;
12594 if (spider_param_dry_access())
12595 {
12596 conn->disable_connect_retry = FALSE;
12597 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12598 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12599 conn->mta_conn_mutex_lock_already = FALSE;
12600 conn->mta_conn_mutex_unlock_later = FALSE;
12601 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12602 pthread_mutex_unlock(&conn->mta_conn_mutex);
12603 DBUG_RETURN(0);
12604 }
12605 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
12606 {
12607 conn->disable_connect_retry = FALSE;
12608 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12609 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12610 conn->mta_conn_mutex_lock_already = FALSE;
12611 conn->mta_conn_mutex_unlock_later = FALSE;
12612 if (error_num)
12613 {
12614 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12615 pthread_mutex_unlock(&conn->mta_conn_mutex);
12616 DBUG_RETURN(error_num);
12617 }
12618 else if ((error_num = spider_db_errorno(conn)))
12619 DBUG_RETURN(error_num);
12620 else {
12621 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
12622 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
12623 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12624 mysql_share->table_names_str[spider->conn_link_idx[
12625 link_idx]].ptr());
12626 DBUG_RETURN(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM);
12627 }
12628 }
12629 conn->disable_connect_retry = FALSE;
12630 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12631 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12632 conn->mta_conn_mutex_lock_already = FALSE;
12633 conn->mta_conn_mutex_unlock_later = FALSE;
12634 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12635 pthread_mutex_unlock(&conn->mta_conn_mutex);
12636 error_num = res->fetch_table_status(
12637 sts_mode,
12638 share->records,
12639 share->mean_rec_length,
12640 share->data_file_length,
12641 share->max_data_file_length,
12642 share->index_file_length,
12643 auto_increment_value,
12644 share->create_time,
12645 share->update_time,
12646 share->check_time
12647 );
12648 res->free_result();
12649 delete res;
12650 if (error_num)
12651 {
12652 switch (error_num)
12653 {
12654 case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
12655 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
12656 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
12657 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12658 mysql_share->table_names_str[spider->conn_link_idx[
12659 link_idx]].ptr());
12660 break;
12661 case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
12662 my_printf_error(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
12663 ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
12664 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12665 mysql_share->table_names_str[spider->conn_link_idx[
12666 link_idx]].ptr());
12667 break;
12668 default:
12669 break;
12670 }
12671 DBUG_RETURN(error_num);
12672 }
12673 } else {
12674 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
12675 pthread_mutex_lock(&conn->mta_conn_mutex);
12676 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
12677 conn->need_mon = &spider->need_mons[link_idx];
12678 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
12679 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
12680 conn->mta_conn_mutex_lock_already = TRUE;
12681 conn->mta_conn_mutex_unlock_later = TRUE;
12682 conn->disable_connect_retry = TRUE;
12683 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12684 share);
12685 if (
12686 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
12687 (
12688 spider_db_query(
12689 conn,
12690 mysql_share->show_table_status[1 + pos].ptr(),
12691 mysql_share->show_table_status[1 + pos].length(),
12692 -1,
12693 &spider->need_mons[link_idx]) &&
12694 (error_num = spider_db_errorno(conn))
12695 )
12696 ) {
12697 if (
12698 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
12699 !conn->disable_reconnect
12700 ) {
12701 /* retry */
12702 if ((error_num = spider_db_ping(spider, conn, link_idx)))
12703 {
12704 conn->disable_connect_retry = FALSE;
12705 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12706 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12707 conn->mta_conn_mutex_lock_already = FALSE;
12708 conn->mta_conn_mutex_unlock_later = FALSE;
12709 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12710 pthread_mutex_unlock(&conn->mta_conn_mutex);
12711 DBUG_RETURN(error_num);
12712 }
12713 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
12714 {
12715 conn->disable_connect_retry = FALSE;
12716 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12717 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12718 conn->mta_conn_mutex_lock_already = FALSE;
12719 conn->mta_conn_mutex_unlock_later = FALSE;
12720 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12721 pthread_mutex_unlock(&conn->mta_conn_mutex);
12722 DBUG_RETURN(error_num);
12723 }
12724 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12725 share);
12726 if (spider_db_query(
12727 conn,
12728 mysql_share->show_table_status[1 + pos].ptr(),
12729 mysql_share->show_table_status[1 + pos].length(),
12730 -1,
12731 &spider->need_mons[link_idx])
12732 ) {
12733 conn->disable_connect_retry = FALSE;
12734 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12735 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12736 conn->mta_conn_mutex_lock_already = FALSE;
12737 conn->mta_conn_mutex_unlock_later = FALSE;
12738 DBUG_RETURN(spider_db_errorno(conn));
12739 }
12740 } else {
12741 conn->disable_connect_retry = FALSE;
12742 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12743 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12744 conn->mta_conn_mutex_lock_already = FALSE;
12745 conn->mta_conn_mutex_unlock_later = FALSE;
12746 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12747 pthread_mutex_unlock(&conn->mta_conn_mutex);
12748 DBUG_RETURN(error_num);
12749 }
12750 }
12751 st_spider_db_request_key request_key;
12752 request_key.spider_thread_id = spider->trx->spider_thread_id;
12753 request_key.query_id = spider->trx->thd->query_id;
12754 request_key.handler = spider;
12755 request_key.request_id = 1;
12756 request_key.next = NULL;
12757 if (spider_param_dry_access())
12758 {
12759 conn->disable_connect_retry = FALSE;
12760 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12761 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12762 conn->mta_conn_mutex_lock_already = FALSE;
12763 conn->mta_conn_mutex_unlock_later = FALSE;
12764 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12765 pthread_mutex_unlock(&conn->mta_conn_mutex);
12766 DBUG_RETURN(0);
12767 }
12768 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
12769 {
12770 conn->disable_connect_retry = FALSE;
12771 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12772 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12773 conn->mta_conn_mutex_lock_already = FALSE;
12774 conn->mta_conn_mutex_unlock_later = FALSE;
12775 if (error_num || (error_num = spider_db_errorno(conn)))
12776 DBUG_RETURN(error_num);
12777 else
12778 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
12779 }
12780 conn->disable_connect_retry = FALSE;
12781 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12782 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12783 conn->mta_conn_mutex_lock_already = FALSE;
12784 conn->mta_conn_mutex_unlock_later = FALSE;
12785 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12786 pthread_mutex_unlock(&conn->mta_conn_mutex);
12787 error_num = res->fetch_table_status(
12788 sts_mode,
12789 share->records,
12790 share->mean_rec_length,
12791 share->data_file_length,
12792 share->max_data_file_length,
12793 share->index_file_length,
12794 auto_increment_value,
12795 share->create_time,
12796 share->update_time,
12797 share->check_time
12798 );
12799 res->free_result();
12800 delete res;
12801 if (error_num)
12802 {
12803 switch (error_num)
12804 {
12805 case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
12806 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
12807 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
12808 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12809 mysql_share->table_names_str[spider->conn_link_idx[
12810 link_idx]].ptr());
12811 break;
12812 case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
12813 my_printf_error(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
12814 ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
12815 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12816 mysql_share->table_names_str[spider->conn_link_idx[
12817 link_idx]].ptr());
12818 break;
12819 default:
12820 break;
12821 }
12822 DBUG_RETURN(error_num);
12823 }
12824 }
12825 if (share->static_records_for_status != -1)
12826 {
12827 share->records = (ha_rows) share->static_records_for_status;
12828 }
12829 if (share->static_mean_rec_length != -1)
12830 {
12831 share->mean_rec_length = (ulong) share->static_mean_rec_length;
12832 }
12833 if (auto_increment_value > share->lgtm_tblhnd_share->auto_increment_value)
12834 {
12835 share->lgtm_tblhnd_share->auto_increment_value = auto_increment_value;
12836 DBUG_PRINT("info",("spider auto_increment_value=%llu",
12837 share->lgtm_tblhnd_share->auto_increment_value));
12838 }
12839 DBUG_RETURN(0);
12840 }
12841
crd_mode_exchange(int crd_mode)12842 int spider_mbase_handler::crd_mode_exchange(
12843 int crd_mode
12844 ) {
12845 DBUG_ENTER("spider_mbase_handler::crd_mode_exchange");
12846 DBUG_PRINT("info",("spider crd_mode=%d", crd_mode));
12847 DBUG_RETURN(crd_mode);
12848 }
12849
show_index(int link_idx,int crd_mode)12850 int spider_mbase_handler::show_index(
12851 int link_idx,
12852 int crd_mode
12853 ) {
12854 int error_num;
12855 SPIDER_CONN *conn = spider->conns[link_idx];
12856 SPIDER_SHARE *share = spider->share;
12857 TABLE *table = spider->get_table();
12858 SPIDER_DB_RESULT *res;
12859 int roop_count;
12860 longlong *tmp_cardinality;
12861 uint pos = (2 * spider->conn_link_idx[link_idx]);
12862 DBUG_ENTER("spider_mbase_handler::show_index");
12863 DBUG_PRINT("info",("spider crd_mode=%d", crd_mode));
12864 if (crd_mode == 1)
12865 {
12866 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
12867 pthread_mutex_lock(&conn->mta_conn_mutex);
12868 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
12869 conn->need_mon = &spider->need_mons[link_idx];
12870 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
12871 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
12872 conn->mta_conn_mutex_lock_already = TRUE;
12873 conn->mta_conn_mutex_unlock_later = TRUE;
12874 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12875 share);
12876 if (
12877 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
12878 (
12879 spider_db_query(
12880 conn,
12881 mysql_share->show_index[0 + pos].ptr(),
12882 mysql_share->show_index[0 + pos].length(),
12883 -1,
12884 &spider->need_mons[link_idx]) &&
12885 (error_num = spider_db_errorno(conn))
12886 )
12887 ) {
12888 if (
12889 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
12890 !conn->disable_reconnect
12891 ) {
12892 /* retry */
12893 if ((error_num = spider_db_ping(spider, conn, link_idx)))
12894 {
12895 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12896 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12897 conn->mta_conn_mutex_lock_already = FALSE;
12898 conn->mta_conn_mutex_unlock_later = FALSE;
12899 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12900 pthread_mutex_unlock(&conn->mta_conn_mutex);
12901 DBUG_RETURN(error_num);
12902 }
12903 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
12904 {
12905 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12906 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12907 conn->mta_conn_mutex_lock_already = FALSE;
12908 conn->mta_conn_mutex_unlock_later = FALSE;
12909 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12910 pthread_mutex_unlock(&conn->mta_conn_mutex);
12911 DBUG_RETURN(error_num);
12912 }
12913 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
12914 share);
12915 if (spider_db_query(
12916 conn,
12917 mysql_share->show_index[0 + pos].ptr(),
12918 mysql_share->show_index[0 + pos].length(),
12919 -1,
12920 &spider->need_mons[link_idx])
12921 ) {
12922 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12923 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12924 conn->mta_conn_mutex_lock_already = FALSE;
12925 conn->mta_conn_mutex_unlock_later = FALSE;
12926 DBUG_RETURN(spider_db_errorno(conn));
12927 }
12928 } else {
12929 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12930 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12931 conn->mta_conn_mutex_lock_already = FALSE;
12932 conn->mta_conn_mutex_unlock_later = FALSE;
12933 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12934 pthread_mutex_unlock(&conn->mta_conn_mutex);
12935 DBUG_RETURN(error_num);
12936 }
12937 }
12938 st_spider_db_request_key request_key;
12939 request_key.spider_thread_id = spider->trx->spider_thread_id;
12940 request_key.query_id = spider->trx->thd->query_id;
12941 request_key.handler = spider;
12942 request_key.request_id = 1;
12943 request_key.next = NULL;
12944 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
12945 {
12946 if (error_num || (error_num = spider_db_errorno(conn)))
12947 {
12948 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12949 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12950 conn->mta_conn_mutex_lock_already = FALSE;
12951 conn->mta_conn_mutex_unlock_later = FALSE;
12952 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12953 pthread_mutex_unlock(&conn->mta_conn_mutex);
12954 DBUG_RETURN(error_num);
12955 }
12956 /* no record is ok */
12957 }
12958 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
12959 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
12960 conn->mta_conn_mutex_lock_already = FALSE;
12961 conn->mta_conn_mutex_unlock_later = FALSE;
12962 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
12963 pthread_mutex_unlock(&conn->mta_conn_mutex);
12964 if (res)
12965 {
12966 error_num = res->fetch_table_cardinality(
12967 crd_mode,
12968 table,
12969 share->cardinality,
12970 share->cardinality_upd,
12971 share->bitmap_size
12972 );
12973 }
12974 for (roop_count = 0, tmp_cardinality = share->cardinality;
12975 roop_count < (int) table->s->fields;
12976 roop_count++, tmp_cardinality++)
12977 {
12978 if (!spider_bit_is_set(share->cardinality_upd, roop_count))
12979 {
12980 DBUG_PRINT("info",
12981 ("spider uninitialized column cardinality id=%d", roop_count));
12982 *tmp_cardinality = -1;
12983 }
12984 }
12985 if (res)
12986 {
12987 res->free_result();
12988 delete res;
12989 }
12990 if (error_num)
12991 {
12992 switch (error_num)
12993 {
12994 case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
12995 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
12996 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
12997 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
12998 mysql_share->table_names_str[spider->conn_link_idx[
12999 link_idx]].ptr());
13000 break;
13001 case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
13002 my_printf_error(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
13003 ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
13004 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
13005 mysql_share->table_names_str[spider->conn_link_idx[
13006 link_idx]].ptr());
13007 break;
13008 default:
13009 break;
13010 }
13011 DBUG_RETURN(error_num);
13012 }
13013 } else {
13014 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13015 pthread_mutex_lock(&conn->mta_conn_mutex);
13016 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13017 conn->need_mon = &spider->need_mons[link_idx];
13018 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13019 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13020 conn->mta_conn_mutex_lock_already = TRUE;
13021 conn->mta_conn_mutex_unlock_later = TRUE;
13022 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13023 share);
13024 if (
13025 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
13026 (
13027 spider_db_query(
13028 conn,
13029 mysql_share->show_index[1 + pos].ptr(),
13030 mysql_share->show_index[1 + pos].length(),
13031 -1,
13032 &spider->need_mons[link_idx]) &&
13033 (error_num = spider_db_errorno(conn))
13034 )
13035 ) {
13036 if (
13037 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
13038 !conn->disable_reconnect
13039 ) {
13040 /* retry */
13041 if ((error_num = spider_db_ping(spider, conn, link_idx)))
13042 {
13043 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13044 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13045 conn->mta_conn_mutex_lock_already = FALSE;
13046 conn->mta_conn_mutex_unlock_later = FALSE;
13047 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13048 pthread_mutex_unlock(&conn->mta_conn_mutex);
13049 DBUG_RETURN(error_num);
13050 }
13051 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13052 {
13053 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13054 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13055 conn->mta_conn_mutex_lock_already = FALSE;
13056 conn->mta_conn_mutex_unlock_later = FALSE;
13057 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13058 pthread_mutex_unlock(&conn->mta_conn_mutex);
13059 DBUG_RETURN(error_num);
13060 }
13061 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13062 share);
13063 if (spider_db_query(
13064 conn,
13065 mysql_share->show_index[1 + pos].ptr(),
13066 mysql_share->show_index[1 + pos].length(),
13067 -1,
13068 &spider->need_mons[link_idx])
13069 ) {
13070 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13071 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13072 conn->mta_conn_mutex_lock_already = FALSE;
13073 conn->mta_conn_mutex_unlock_later = FALSE;
13074 DBUG_RETURN(spider_db_errorno(conn));
13075 }
13076 } else {
13077 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13078 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13079 conn->mta_conn_mutex_lock_already = FALSE;
13080 conn->mta_conn_mutex_unlock_later = FALSE;
13081 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13082 pthread_mutex_unlock(&conn->mta_conn_mutex);
13083 DBUG_RETURN(error_num);
13084 }
13085 }
13086 st_spider_db_request_key request_key;
13087 request_key.spider_thread_id = spider->trx->spider_thread_id;
13088 request_key.query_id = spider->trx->thd->query_id;
13089 request_key.handler = spider;
13090 request_key.request_id = 1;
13091 request_key.next = NULL;
13092 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
13093 {
13094 if (error_num || (error_num = spider_db_errorno(conn)))
13095 {
13096 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13097 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13098 conn->mta_conn_mutex_lock_already = FALSE;
13099 conn->mta_conn_mutex_unlock_later = FALSE;
13100 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13101 pthread_mutex_unlock(&conn->mta_conn_mutex);
13102 DBUG_RETURN(error_num);
13103 }
13104 /* no record is ok */
13105 }
13106 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13107 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13108 conn->mta_conn_mutex_lock_already = FALSE;
13109 conn->mta_conn_mutex_unlock_later = FALSE;
13110 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13111 pthread_mutex_unlock(&conn->mta_conn_mutex);
13112 if (res)
13113 {
13114 error_num = res->fetch_table_cardinality(
13115 crd_mode,
13116 table,
13117 share->cardinality,
13118 share->cardinality_upd,
13119 share->bitmap_size
13120 );
13121 }
13122 for (roop_count = 0, tmp_cardinality = share->cardinality;
13123 roop_count < (int) table->s->fields;
13124 roop_count++, tmp_cardinality++)
13125 {
13126 if (!spider_bit_is_set(share->cardinality_upd, roop_count))
13127 {
13128 DBUG_PRINT("info",
13129 ("spider uninitialized column cardinality id=%d", roop_count));
13130 *tmp_cardinality = -1;
13131 }
13132 }
13133 if (res)
13134 {
13135 res->free_result();
13136 delete res;
13137 }
13138 if (error_num)
13139 {
13140 switch (error_num)
13141 {
13142 case ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM:
13143 my_printf_error(ER_SPIDER_REMOTE_TABLE_NOT_FOUND_NUM,
13144 ER_SPIDER_REMOTE_TABLE_NOT_FOUND_STR, MYF(0),
13145 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
13146 mysql_share->table_names_str[spider->conn_link_idx[
13147 link_idx]].ptr());
13148 break;
13149 case ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM:
13150 my_printf_error(ER_SPIDER_INVALID_REMOTE_TABLE_INFO_NUM,
13151 ER_SPIDER_INVALID_REMOTE_TABLE_INFO_STR, MYF(0),
13152 mysql_share->db_names_str[spider->conn_link_idx[link_idx]].ptr(),
13153 mysql_share->table_names_str[spider->conn_link_idx[
13154 link_idx]].ptr());
13155 break;
13156 default:
13157 break;
13158 }
13159 DBUG_RETURN(error_num);
13160 }
13161 }
13162 DBUG_RETURN(0);
13163 }
13164
show_records(int link_idx)13165 int spider_mbase_handler::show_records(
13166 int link_idx
13167 ) {
13168 int error_num;
13169 SPIDER_CONN *conn = spider->conns[link_idx];
13170 SPIDER_DB_RESULT *res;
13171 SPIDER_SHARE *share = spider->share;
13172 uint pos = spider->conn_link_idx[link_idx];
13173 DBUG_ENTER("spider_mbase_handler::show_records");
13174 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13175 pthread_mutex_lock(&conn->mta_conn_mutex);
13176 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13177 conn->need_mon = &spider->need_mons[link_idx];
13178 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13179 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13180 conn->mta_conn_mutex_lock_already = TRUE;
13181 conn->mta_conn_mutex_unlock_later = TRUE;
13182 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13183 share);
13184 if (
13185 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
13186 (
13187 spider_db_query(
13188 conn,
13189 mysql_share->show_records[pos].ptr(),
13190 mysql_share->show_records[pos].length(),
13191 -1,
13192 &spider->need_mons[link_idx]) &&
13193 (error_num = spider_db_errorno(conn))
13194 )
13195 ) {
13196 if (
13197 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
13198 !conn->disable_reconnect
13199 ) {
13200 /* retry */
13201 if ((error_num = spider_db_ping(spider, conn, link_idx)))
13202 {
13203 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13204 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13205 conn->mta_conn_mutex_lock_already = FALSE;
13206 conn->mta_conn_mutex_unlock_later = FALSE;
13207 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13208 pthread_mutex_unlock(&conn->mta_conn_mutex);
13209 DBUG_PRINT("info", ("spider error_num=%d 1", error_num));
13210 DBUG_RETURN(error_num);
13211 }
13212 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13213 {
13214 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13215 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13216 conn->mta_conn_mutex_lock_already = FALSE;
13217 conn->mta_conn_mutex_unlock_later = FALSE;
13218 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13219 pthread_mutex_unlock(&conn->mta_conn_mutex);
13220 DBUG_PRINT("info", ("spider error_num=%d 2", error_num));
13221 DBUG_RETURN(error_num);
13222 }
13223 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13224 share);
13225 if (spider_db_query(
13226 conn,
13227 mysql_share->show_records[pos].ptr(),
13228 mysql_share->show_records[pos].length(),
13229 -1,
13230 &spider->need_mons[link_idx])
13231 ) {
13232 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13233 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13234 conn->mta_conn_mutex_lock_already = FALSE;
13235 conn->mta_conn_mutex_unlock_later = FALSE;
13236 DBUG_PRINT("info", ("spider error_num=%d 3", error_num));
13237 DBUG_RETURN(spider_db_errorno(conn));
13238 }
13239 } else {
13240 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13241 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13242 conn->mta_conn_mutex_lock_already = FALSE;
13243 conn->mta_conn_mutex_unlock_later = FALSE;
13244 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13245 pthread_mutex_unlock(&conn->mta_conn_mutex);
13246 DBUG_PRINT("info", ("spider error_num=%d 4", error_num));
13247 DBUG_RETURN(error_num);
13248 }
13249 }
13250 st_spider_db_request_key request_key;
13251 request_key.spider_thread_id = spider->trx->spider_thread_id;
13252 request_key.query_id = spider->trx->thd->query_id;
13253 request_key.handler = spider;
13254 request_key.request_id = 1;
13255 request_key.next = NULL;
13256 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
13257 {
13258 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13259 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13260 conn->mta_conn_mutex_lock_already = FALSE;
13261 conn->mta_conn_mutex_unlock_later = FALSE;
13262 if (error_num)
13263 {
13264 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13265 pthread_mutex_unlock(&conn->mta_conn_mutex);
13266 DBUG_PRINT("info", ("spider error_num=%d 5", error_num));
13267 DBUG_RETURN(error_num);
13268 }
13269 else if ((error_num = spider_db_errorno(conn)))
13270 {
13271 DBUG_PRINT("info", ("spider error_num=%d 6", error_num));
13272 DBUG_RETURN(error_num);
13273 } else {
13274 DBUG_PRINT("info", ("spider error_num=%d 7",
13275 ER_QUERY_ON_FOREIGN_DATA_SOURCE));
13276 DBUG_RETURN(ER_QUERY_ON_FOREIGN_DATA_SOURCE);
13277 }
13278 }
13279 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13280 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13281 conn->mta_conn_mutex_lock_already = FALSE;
13282 conn->mta_conn_mutex_unlock_later = FALSE;
13283 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13284 pthread_mutex_unlock(&conn->mta_conn_mutex);
13285 error_num = res->fetch_table_records(
13286 1,
13287 spider->table_rows
13288 );
13289 res->free_result();
13290 delete res;
13291 if (error_num)
13292 {
13293 DBUG_PRINT("info", ("spider error_num=%d 7", error_num));
13294 DBUG_RETURN(error_num);
13295 }
13296 spider->trx->direct_aggregate_count++;
13297 DBUG_RETURN(0);
13298 }
13299
show_last_insert_id(int link_idx,ulonglong & last_insert_id)13300 int spider_mbase_handler::show_last_insert_id(
13301 int link_idx,
13302 ulonglong &last_insert_id
13303 ) {
13304 SPIDER_CONN *conn = spider->conns[link_idx];
13305 DBUG_ENTER("spider_mbase_handler::show_last_insert_id");
13306 last_insert_id = conn->db_conn->last_insert_id();
13307 DBUG_RETURN(0);
13308 }
13309
explain_select(key_range * start_key,key_range * end_key,int link_idx)13310 ha_rows spider_mbase_handler::explain_select(
13311 key_range *start_key,
13312 key_range *end_key,
13313 int link_idx
13314 ) {
13315 int error_num;
13316 SPIDER_CONN *conn = spider->conns[link_idx];
13317 SPIDER_RESULT_LIST *result_list = &spider->result_list;
13318 spider_string *str = &result_list->sqls[link_idx];
13319 SPIDER_DB_RESULT *res;
13320 ha_rows rows;
13321 spider_db_handler *dbton_hdl = spider->dbton_handler[conn->dbton_id];
13322 DBUG_ENTER("spider_mbase_handler::explain_select");
13323 if ((error_num = dbton_hdl->append_explain_select_part(
13324 start_key, end_key, SPIDER_SQL_TYPE_OTHER_SQL, link_idx)))
13325 {
13326 my_errno = error_num;
13327 DBUG_RETURN(HA_POS_ERROR);
13328 }
13329
13330 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13331 pthread_mutex_lock(&conn->mta_conn_mutex);
13332 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13333 conn->need_mon = &spider->need_mons[link_idx];
13334 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13335 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13336 conn->mta_conn_mutex_lock_already = TRUE;
13337 conn->mta_conn_mutex_unlock_later = TRUE;
13338 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13339 spider->share);
13340 if (
13341 (error_num = spider_db_set_names(spider, conn, link_idx)) ||
13342 (
13343 spider_db_query(
13344 conn,
13345 str->ptr(),
13346 str->length(),
13347 -1,
13348 &spider->need_mons[link_idx]) &&
13349 (error_num = spider_db_errorno(conn))
13350 )
13351 ) {
13352 if (
13353 error_num == ER_SPIDER_REMOTE_SERVER_GONE_AWAY_NUM &&
13354 !conn->disable_reconnect
13355 ) {
13356 /* retry */
13357 if ((error_num = spider_db_ping(spider, conn, link_idx)))
13358 {
13359 if (spider->check_error_mode(error_num))
13360 my_errno = error_num;
13361 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13362 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13363 conn->mta_conn_mutex_lock_already = FALSE;
13364 conn->mta_conn_mutex_unlock_later = FALSE;
13365 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13366 pthread_mutex_unlock(&conn->mta_conn_mutex);
13367 DBUG_RETURN(HA_POS_ERROR);
13368 }
13369 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13370 {
13371 if (spider->check_error_mode(error_num))
13372 my_errno = error_num;
13373 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13374 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13375 conn->mta_conn_mutex_lock_already = FALSE;
13376 conn->mta_conn_mutex_unlock_later = FALSE;
13377 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13378 pthread_mutex_unlock(&conn->mta_conn_mutex);
13379 DBUG_RETURN(HA_POS_ERROR);
13380 }
13381 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13382 spider->share);
13383 if (spider_db_query(
13384 conn,
13385 str->ptr(),
13386 str->length(),
13387 -1,
13388 &spider->need_mons[link_idx])
13389 ) {
13390 error_num = spider_db_errorno(conn);
13391 if (spider->check_error_mode(error_num))
13392 my_errno = error_num;
13393 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13394 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13395 conn->mta_conn_mutex_lock_already = FALSE;
13396 conn->mta_conn_mutex_unlock_later = FALSE;
13397 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13398 pthread_mutex_unlock(&conn->mta_conn_mutex);
13399 DBUG_RETURN(HA_POS_ERROR);
13400 }
13401 } else {
13402 if (spider->check_error_mode(error_num))
13403 my_errno = error_num;
13404 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13405 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13406 conn->mta_conn_mutex_lock_already = FALSE;
13407 conn->mta_conn_mutex_unlock_later = FALSE;
13408 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13409 pthread_mutex_unlock(&conn->mta_conn_mutex);
13410 DBUG_RETURN(HA_POS_ERROR);
13411 }
13412 }
13413 st_spider_db_request_key request_key;
13414 request_key.spider_thread_id = spider->trx->spider_thread_id;
13415 request_key.query_id = spider->trx->thd->query_id;
13416 request_key.handler = spider;
13417 request_key.request_id = 1;
13418 request_key.next = NULL;
13419 if (!(res = conn->db_conn->store_result(NULL, &request_key, &error_num)))
13420 {
13421 if (error_num || (error_num = spider_db_errorno(conn)))
13422 {
13423 if (spider->check_error_mode(error_num))
13424 my_errno = error_num;
13425 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13426 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13427 conn->mta_conn_mutex_lock_already = FALSE;
13428 conn->mta_conn_mutex_unlock_later = FALSE;
13429 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13430 pthread_mutex_unlock(&conn->mta_conn_mutex);
13431 DBUG_RETURN(HA_POS_ERROR);
13432 } else {
13433 my_errno = ER_QUERY_ON_FOREIGN_DATA_SOURCE;
13434 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13435 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13436 conn->mta_conn_mutex_lock_already = FALSE;
13437 conn->mta_conn_mutex_unlock_later = FALSE;
13438 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13439 pthread_mutex_unlock(&conn->mta_conn_mutex);
13440 DBUG_RETURN(HA_POS_ERROR);
13441 }
13442 }
13443 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13444 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13445 conn->mta_conn_mutex_lock_already = FALSE;
13446 conn->mta_conn_mutex_unlock_later = FALSE;
13447 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13448 pthread_mutex_unlock(&conn->mta_conn_mutex);
13449 error_num = res->fetch_table_records(
13450 2,
13451 rows
13452 );
13453 res->free_result();
13454 delete res;
13455 if (error_num)
13456 {
13457 my_errno = error_num;
13458 DBUG_RETURN(HA_POS_ERROR);
13459 }
13460 DBUG_RETURN(rows);
13461 }
13462
lock_tables(int link_idx)13463 int spider_mbase_handler::lock_tables(
13464 int link_idx
13465 ) {
13466 int error_num;
13467 SPIDER_CONN *conn = spider->conns[link_idx];
13468 spider_string *str = &sql;
13469 DBUG_ENTER("spider_mbase_handler::lock_tables");
13470 str->length(0);
13471 if ((error_num = conn->db_conn->append_lock_tables(str)))
13472 {
13473 DBUG_RETURN(error_num);
13474 }
13475 if (str->length())
13476 {
13477 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13478 pthread_mutex_lock(&conn->mta_conn_mutex);
13479 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13480 conn->need_mon = &spider->need_mons[link_idx];
13481 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13482 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13483 conn->mta_conn_mutex_lock_already = TRUE;
13484 conn->mta_conn_mutex_unlock_later = TRUE;
13485 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13486 {
13487 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13488 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13489 conn->mta_conn_mutex_lock_already = FALSE;
13490 conn->mta_conn_mutex_unlock_later = FALSE;
13491 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13492 pthread_mutex_unlock(&conn->mta_conn_mutex);
13493 DBUG_RETURN(error_num);
13494 }
13495 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13496 spider->share);
13497 if (spider_db_query(
13498 conn,
13499 str->ptr(),
13500 str->length(),
13501 -1,
13502 &spider->need_mons[link_idx])
13503 ) {
13504 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13505 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13506 conn->mta_conn_mutex_lock_already = FALSE;
13507 conn->mta_conn_mutex_unlock_later = FALSE;
13508 DBUG_RETURN(spider_db_errorno(conn));
13509 }
13510 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13511 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13512 conn->mta_conn_mutex_lock_already = FALSE;
13513 conn->mta_conn_mutex_unlock_later = FALSE;
13514 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13515 pthread_mutex_unlock(&conn->mta_conn_mutex);
13516 }
13517 if (!conn->table_locked)
13518 {
13519 conn->table_locked = TRUE;
13520 spider->trx->locked_connections++;
13521 }
13522 DBUG_RETURN(0);
13523 }
13524
unlock_tables(int link_idx)13525 int spider_mbase_handler::unlock_tables(
13526 int link_idx
13527 ) {
13528 int error_num;
13529 SPIDER_CONN *conn = spider->conns[link_idx];
13530 DBUG_ENTER("spider_mbase_handler::unlock_tables");
13531 if (conn->table_locked)
13532 {
13533 spider_string *str = &sql;
13534 conn->table_locked = FALSE;
13535 spider->trx->locked_connections--;
13536
13537 str->length(0);
13538 if ((error_num = conn->db_conn->append_unlock_tables(str)))
13539 {
13540 DBUG_RETURN(error_num);
13541 }
13542 if (str->length())
13543 {
13544 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13545 spider->share);
13546 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13547 pthread_mutex_lock(&conn->mta_conn_mutex);
13548 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13549 conn->need_mon = &spider->need_mons[link_idx];
13550 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13551 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13552 conn->mta_conn_mutex_lock_already = TRUE;
13553 conn->mta_conn_mutex_unlock_later = TRUE;
13554 if (spider_db_query(
13555 conn,
13556 str->ptr(),
13557 str->length(),
13558 -1,
13559 &spider->need_mons[link_idx])
13560 ) {
13561 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13562 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13563 conn->mta_conn_mutex_lock_already = FALSE;
13564 conn->mta_conn_mutex_unlock_later = FALSE;
13565 DBUG_RETURN(spider_db_errorno(conn));
13566 }
13567 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13568 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13569 conn->mta_conn_mutex_lock_already = FALSE;
13570 conn->mta_conn_mutex_unlock_later = FALSE;
13571 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13572 pthread_mutex_unlock(&conn->mta_conn_mutex);
13573 }
13574 }
13575 DBUG_RETURN(0);
13576 }
13577
disable_keys(SPIDER_CONN * conn,int link_idx)13578 int spider_mbase_handler::disable_keys(
13579 SPIDER_CONN *conn,
13580 int link_idx
13581 ) {
13582 int error_num;
13583 SPIDER_SHARE *share = spider->share;
13584 spider_string *str = &spider->result_list.sqls[link_idx];
13585 DBUG_ENTER("spider_mbase_handler::disable_keys");
13586 DBUG_PRINT("info",("spider this=%p", this));
13587 str->length(0);
13588 if ((error_num = append_disable_keys_part(SPIDER_SQL_TYPE_OTHER_HS,
13589 link_idx)))
13590 {
13591 DBUG_RETURN(error_num);
13592 }
13593 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13594 pthread_mutex_lock(&conn->mta_conn_mutex);
13595 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13596 conn->need_mon = &spider->need_mons[link_idx];
13597 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13598 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13599 conn->mta_conn_mutex_lock_already = TRUE;
13600 conn->mta_conn_mutex_unlock_later = TRUE;
13601 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13602 {
13603 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13604 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13605 conn->mta_conn_mutex_lock_already = FALSE;
13606 conn->mta_conn_mutex_unlock_later = FALSE;
13607 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13608 pthread_mutex_unlock(&conn->mta_conn_mutex);
13609 DBUG_RETURN(error_num);
13610 }
13611 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13612 share);
13613 if (spider_db_query(
13614 conn,
13615 str->ptr(),
13616 str->length(),
13617 -1,
13618 &spider->need_mons[link_idx])
13619 ) {
13620 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13621 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13622 conn->mta_conn_mutex_lock_already = FALSE;
13623 conn->mta_conn_mutex_unlock_later = FALSE;
13624 error_num = spider_db_errorno(conn);
13625 DBUG_RETURN(error_num);
13626 }
13627 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13628 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13629 conn->mta_conn_mutex_lock_already = FALSE;
13630 conn->mta_conn_mutex_unlock_later = FALSE;
13631 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13632 pthread_mutex_unlock(&conn->mta_conn_mutex);
13633 DBUG_RETURN(0);
13634 }
13635
enable_keys(SPIDER_CONN * conn,int link_idx)13636 int spider_mbase_handler::enable_keys(
13637 SPIDER_CONN *conn,
13638 int link_idx
13639 ) {
13640 int error_num;
13641 SPIDER_SHARE *share = spider->share;
13642 spider_string *str = &spider->result_list.sqls[link_idx];
13643 DBUG_ENTER("spider_mbase_handler::enable_keys");
13644 DBUG_PRINT("info",("spider this=%p", this));
13645 str->length(0);
13646 if ((error_num = append_enable_keys_part(SPIDER_SQL_TYPE_OTHER_HS,
13647 link_idx)))
13648 {
13649 DBUG_RETURN(error_num);
13650 }
13651 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13652 pthread_mutex_lock(&conn->mta_conn_mutex);
13653 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13654 conn->need_mon = &spider->need_mons[link_idx];
13655 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13656 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13657 conn->mta_conn_mutex_lock_already = TRUE;
13658 conn->mta_conn_mutex_unlock_later = TRUE;
13659 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13660 {
13661 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13662 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13663 conn->mta_conn_mutex_lock_already = FALSE;
13664 conn->mta_conn_mutex_unlock_later = FALSE;
13665 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13666 pthread_mutex_unlock(&conn->mta_conn_mutex);
13667 DBUG_RETURN(error_num);
13668 }
13669 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13670 share);
13671 if (spider_db_query(
13672 conn,
13673 str->ptr(),
13674 str->length(),
13675 -1,
13676 &spider->need_mons[link_idx])
13677 ) {
13678 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13679 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13680 conn->mta_conn_mutex_lock_already = FALSE;
13681 conn->mta_conn_mutex_unlock_later = FALSE;
13682 error_num = spider_db_errorno(conn);
13683 DBUG_RETURN(error_num);
13684 }
13685 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13686 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13687 conn->mta_conn_mutex_lock_already = FALSE;
13688 conn->mta_conn_mutex_unlock_later = FALSE;
13689 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13690 pthread_mutex_unlock(&conn->mta_conn_mutex);
13691 DBUG_RETURN(0);
13692 }
13693
check_table(SPIDER_CONN * conn,int link_idx,HA_CHECK_OPT * check_opt)13694 int spider_mbase_handler::check_table(
13695 SPIDER_CONN *conn,
13696 int link_idx,
13697 HA_CHECK_OPT* check_opt
13698 ) {
13699 int error_num;
13700 SPIDER_SHARE *share = spider->share;
13701 spider_string *str = &spider->result_list.sqls[link_idx];
13702 DBUG_ENTER("spider_mbase_handler::check_table");
13703 DBUG_PRINT("info",("spider this=%p", this));
13704 str->length(0);
13705 if ((error_num = append_check_table_part(SPIDER_SQL_TYPE_OTHER_HS,
13706 link_idx, check_opt)))
13707 {
13708 DBUG_RETURN(error_num);
13709 }
13710 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13711 pthread_mutex_lock(&conn->mta_conn_mutex);
13712 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13713 conn->need_mon = &spider->need_mons[link_idx];
13714 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13715 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13716 conn->mta_conn_mutex_lock_already = TRUE;
13717 conn->mta_conn_mutex_unlock_later = TRUE;
13718 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13719 {
13720 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13721 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13722 conn->mta_conn_mutex_lock_already = FALSE;
13723 conn->mta_conn_mutex_unlock_later = FALSE;
13724 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13725 pthread_mutex_unlock(&conn->mta_conn_mutex);
13726 DBUG_RETURN(error_num);
13727 }
13728 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13729 share);
13730 if (spider_db_query(
13731 conn,
13732 str->ptr(),
13733 str->length(),
13734 -1,
13735 &spider->need_mons[link_idx])
13736 ) {
13737 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13738 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13739 conn->mta_conn_mutex_lock_already = FALSE;
13740 conn->mta_conn_mutex_unlock_later = FALSE;
13741 error_num = spider_db_errorno(conn);
13742 DBUG_RETURN(error_num);
13743 }
13744 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13745 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13746 conn->mta_conn_mutex_lock_already = FALSE;
13747 conn->mta_conn_mutex_unlock_later = FALSE;
13748 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13749 pthread_mutex_unlock(&conn->mta_conn_mutex);
13750 DBUG_RETURN(0);
13751 }
13752
repair_table(SPIDER_CONN * conn,int link_idx,HA_CHECK_OPT * check_opt)13753 int spider_mbase_handler::repair_table(
13754 SPIDER_CONN *conn,
13755 int link_idx,
13756 HA_CHECK_OPT* check_opt
13757 ) {
13758 int error_num;
13759 SPIDER_SHARE *share = spider->share;
13760 spider_string *str = &spider->result_list.sqls[link_idx];
13761 DBUG_ENTER("spider_mbase_handler::repair_table");
13762 DBUG_PRINT("info",("spider this=%p", this));
13763 str->length(0);
13764 if ((error_num = append_repair_table_part(SPIDER_SQL_TYPE_OTHER_HS,
13765 link_idx, check_opt)))
13766 {
13767 DBUG_RETURN(error_num);
13768 }
13769 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13770 pthread_mutex_lock(&conn->mta_conn_mutex);
13771 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13772 conn->need_mon = &spider->need_mons[link_idx];
13773 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13774 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13775 conn->mta_conn_mutex_lock_already = TRUE;
13776 conn->mta_conn_mutex_unlock_later = TRUE;
13777 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13778 {
13779 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13780 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13781 conn->mta_conn_mutex_lock_already = FALSE;
13782 conn->mta_conn_mutex_unlock_later = FALSE;
13783 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13784 pthread_mutex_unlock(&conn->mta_conn_mutex);
13785 DBUG_RETURN(error_num);
13786 }
13787 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13788 share);
13789 if (spider_db_query(
13790 conn,
13791 str->ptr(),
13792 str->length(),
13793 -1,
13794 &spider->need_mons[link_idx])
13795 ) {
13796 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13797 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13798 conn->mta_conn_mutex_lock_already = FALSE;
13799 conn->mta_conn_mutex_unlock_later = FALSE;
13800 error_num = spider_db_errorno(conn);
13801 DBUG_RETURN(error_num);
13802 }
13803 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13804 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13805 conn->mta_conn_mutex_lock_already = FALSE;
13806 conn->mta_conn_mutex_unlock_later = FALSE;
13807 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13808 pthread_mutex_unlock(&conn->mta_conn_mutex);
13809 DBUG_RETURN(0);
13810 }
13811
analyze_table(SPIDER_CONN * conn,int link_idx)13812 int spider_mbase_handler::analyze_table(
13813 SPIDER_CONN *conn,
13814 int link_idx
13815 ) {
13816 int error_num;
13817 SPIDER_SHARE *share = spider->share;
13818 spider_string *str = &spider->result_list.sqls[link_idx];
13819 DBUG_ENTER("spider_mbase_handler::analyze_table");
13820 DBUG_PRINT("info",("spider this=%p", this));
13821 str->length(0);
13822 if ((error_num = append_analyze_table_part(SPIDER_SQL_TYPE_OTHER_HS,
13823 link_idx)))
13824 {
13825 DBUG_RETURN(error_num);
13826 }
13827 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13828 pthread_mutex_lock(&conn->mta_conn_mutex);
13829 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13830 conn->need_mon = &spider->need_mons[link_idx];
13831 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13832 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13833 conn->mta_conn_mutex_lock_already = TRUE;
13834 conn->mta_conn_mutex_unlock_later = TRUE;
13835 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13836 {
13837 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13838 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13839 conn->mta_conn_mutex_lock_already = FALSE;
13840 conn->mta_conn_mutex_unlock_later = FALSE;
13841 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13842 pthread_mutex_unlock(&conn->mta_conn_mutex);
13843 DBUG_RETURN(error_num);
13844 }
13845 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13846 share);
13847 if (spider_db_query(
13848 conn,
13849 str->ptr(),
13850 str->length(),
13851 -1,
13852 &spider->need_mons[link_idx])
13853 ) {
13854 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13855 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13856 conn->mta_conn_mutex_lock_already = FALSE;
13857 conn->mta_conn_mutex_unlock_later = FALSE;
13858 error_num = spider_db_errorno(conn);
13859 DBUG_RETURN(error_num);
13860 }
13861 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13862 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13863 conn->mta_conn_mutex_lock_already = FALSE;
13864 conn->mta_conn_mutex_unlock_later = FALSE;
13865 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13866 pthread_mutex_unlock(&conn->mta_conn_mutex);
13867 DBUG_RETURN(0);
13868 }
13869
optimize_table(SPIDER_CONN * conn,int link_idx)13870 int spider_mbase_handler::optimize_table(
13871 SPIDER_CONN *conn,
13872 int link_idx
13873 ) {
13874 int error_num;
13875 SPIDER_SHARE *share = spider->share;
13876 spider_string *str = &spider->result_list.sqls[link_idx];
13877 DBUG_ENTER("spider_mbase_handler::optimize_table");
13878 DBUG_PRINT("info",("spider this=%p", this));
13879 str->length(0);
13880 if ((error_num = append_optimize_table_part(SPIDER_SQL_TYPE_OTHER_HS,
13881 link_idx)))
13882 {
13883 DBUG_RETURN(error_num);
13884 }
13885 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13886 pthread_mutex_lock(&conn->mta_conn_mutex);
13887 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13888 conn->need_mon = &spider->need_mons[link_idx];
13889 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13890 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13891 conn->mta_conn_mutex_lock_already = TRUE;
13892 conn->mta_conn_mutex_unlock_later = TRUE;
13893 if ((error_num = spider_db_set_names(spider, conn, link_idx)))
13894 {
13895 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13896 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13897 conn->mta_conn_mutex_lock_already = FALSE;
13898 conn->mta_conn_mutex_unlock_later = FALSE;
13899 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13900 pthread_mutex_unlock(&conn->mta_conn_mutex);
13901 DBUG_RETURN(error_num);
13902 }
13903 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13904 share);
13905 if (spider_db_query(
13906 conn,
13907 str->ptr(),
13908 str->length(),
13909 -1,
13910 &spider->need_mons[link_idx])
13911 ) {
13912 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13913 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13914 conn->mta_conn_mutex_lock_already = FALSE;
13915 conn->mta_conn_mutex_unlock_later = FALSE;
13916 error_num = spider_db_errorno(conn);
13917 DBUG_RETURN(error_num);
13918 }
13919 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13920 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13921 conn->mta_conn_mutex_lock_already = FALSE;
13922 conn->mta_conn_mutex_unlock_later = FALSE;
13923 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13924 pthread_mutex_unlock(&conn->mta_conn_mutex);
13925 DBUG_RETURN(0);
13926 }
13927
flush_tables(SPIDER_CONN * conn,int link_idx,bool lock)13928 int spider_mbase_handler::flush_tables(
13929 SPIDER_CONN *conn,
13930 int link_idx,
13931 bool lock
13932 ) {
13933 int error_num;
13934 SPIDER_SHARE *share = spider->share;
13935 spider_string *str = &spider->result_list.sqls[link_idx];
13936 DBUG_ENTER("spider_mbase_handler::flush_tables");
13937 DBUG_PRINT("info",("spider this=%p", this));
13938 str->length(0);
13939 if ((error_num = append_flush_tables_part(SPIDER_SQL_TYPE_OTHER_HS,
13940 link_idx, lock)))
13941 {
13942 DBUG_RETURN(error_num);
13943 }
13944 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13945 share);
13946 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13947 pthread_mutex_lock(&conn->mta_conn_mutex);
13948 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13949 conn->need_mon = &spider->need_mons[link_idx];
13950 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13951 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13952 conn->mta_conn_mutex_lock_already = TRUE;
13953 conn->mta_conn_mutex_unlock_later = TRUE;
13954 if (spider_db_query(
13955 conn,
13956 str->ptr(),
13957 str->length(),
13958 -1,
13959 &spider->need_mons[link_idx])
13960 ) {
13961 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13962 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13963 conn->mta_conn_mutex_lock_already = FALSE;
13964 conn->mta_conn_mutex_unlock_later = FALSE;
13965 error_num = spider_db_errorno(conn);
13966 DBUG_RETURN(error_num);
13967 }
13968 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
13969 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
13970 conn->mta_conn_mutex_lock_already = FALSE;
13971 conn->mta_conn_mutex_unlock_later = FALSE;
13972 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
13973 pthread_mutex_unlock(&conn->mta_conn_mutex);
13974 DBUG_RETURN(0);
13975 }
13976
flush_logs(SPIDER_CONN * conn,int link_idx)13977 int spider_mbase_handler::flush_logs(
13978 SPIDER_CONN *conn,
13979 int link_idx
13980 ) {
13981 int error_num;
13982 SPIDER_SHARE *share = spider->share;
13983 DBUG_ENTER("spider_mbase_handler::flush_logs");
13984 DBUG_PRINT("info",("spider this=%p", this));
13985 spider_conn_set_timeout_from_share(conn, link_idx, spider->trx->thd,
13986 share);
13987 pthread_mutex_assert_not_owner(&conn->mta_conn_mutex);
13988 pthread_mutex_lock(&conn->mta_conn_mutex);
13989 SPIDER_SET_FILE_POS(&conn->mta_conn_mutex_file_pos);
13990 conn->need_mon = &spider->need_mons[link_idx];
13991 DBUG_ASSERT(!conn->mta_conn_mutex_lock_already);
13992 DBUG_ASSERT(!conn->mta_conn_mutex_unlock_later);
13993 conn->mta_conn_mutex_lock_already = TRUE;
13994 conn->mta_conn_mutex_unlock_later = TRUE;
13995 if (spider_db_query(
13996 conn,
13997 SPIDER_SQL_FLUSH_LOGS_STR,
13998 SPIDER_SQL_FLUSH_LOGS_LEN,
13999 -1,
14000 &spider->need_mons[link_idx])
14001 ) {
14002 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
14003 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
14004 conn->mta_conn_mutex_lock_already = FALSE;
14005 conn->mta_conn_mutex_unlock_later = FALSE;
14006 error_num = spider_db_errorno(conn);
14007 DBUG_RETURN(error_num);
14008 }
14009 DBUG_ASSERT(conn->mta_conn_mutex_lock_already);
14010 DBUG_ASSERT(conn->mta_conn_mutex_unlock_later);
14011 conn->mta_conn_mutex_lock_already = FALSE;
14012 conn->mta_conn_mutex_unlock_later = FALSE;
14013 SPIDER_CLEAR_FILE_POS(&conn->mta_conn_mutex_file_pos);
14014 pthread_mutex_unlock(&conn->mta_conn_mutex);
14015 DBUG_RETURN(0);
14016 }
14017
insert_opened_handler(SPIDER_CONN * conn,int link_idx)14018 int spider_mbase_handler::insert_opened_handler(
14019 SPIDER_CONN *conn,
14020 int link_idx
14021 ) {
14022 spider_db_mbase *db_conn = (spider_db_mbase *) conn->db_conn;
14023 SPIDER_LINK_FOR_HASH *tmp_link_for_hash = &link_for_hash[link_idx];
14024 DBUG_ASSERT(tmp_link_for_hash->spider == spider);
14025 DBUG_ASSERT(tmp_link_for_hash->link_idx == link_idx);
14026 uint old_elements = db_conn->handler_open_array.max_element;
14027 DBUG_ENTER("spider_mbase_handler::insert_opened_handler");
14028 DBUG_PRINT("info",("spider this=%p", this));
14029 if (insert_dynamic(&db_conn->handler_open_array,
14030 (uchar*) &tmp_link_for_hash))
14031 {
14032 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14033 }
14034 if (db_conn->handler_open_array.max_element > old_elements)
14035 {
14036 spider_alloc_calc_mem(spider_current_trx,
14037 db_conn->handler_open_array,
14038 (db_conn->handler_open_array.max_element - old_elements) *
14039 db_conn->handler_open_array.size_of_element);
14040 }
14041 DBUG_RETURN(0);
14042 }
14043
delete_opened_handler(SPIDER_CONN * conn,int link_idx)14044 int spider_mbase_handler::delete_opened_handler(
14045 SPIDER_CONN *conn,
14046 int link_idx
14047 ) {
14048 spider_db_mbase *db_conn = (spider_db_mbase *) conn->db_conn;
14049 uint roop_count, elements = db_conn->handler_open_array.elements;
14050 SPIDER_LINK_FOR_HASH *tmp_link_for_hash;
14051 DBUG_ENTER("spider_mbase_handler::delete_opened_handler");
14052 DBUG_PRINT("info",("spider this=%p", this));
14053 for (roop_count = 0; roop_count < elements; roop_count++)
14054 {
14055 get_dynamic(&db_conn->handler_open_array, (uchar *) &tmp_link_for_hash,
14056 roop_count);
14057 if (tmp_link_for_hash == &link_for_hash[link_idx])
14058 {
14059 delete_dynamic_element(&db_conn->handler_open_array, roop_count);
14060 break;
14061 }
14062 }
14063 DBUG_ASSERT(roop_count < elements);
14064 DBUG_RETURN(0);
14065 }
14066
sync_from_clone_source(spider_db_handler * dbton_hdl)14067 int spider_mbase_handler::sync_from_clone_source(
14068 spider_db_handler *dbton_hdl
14069 ) {
14070 DBUG_ENTER("spider_mbase_handler::sync_from_clone_source");
14071 DBUG_PRINT("info",("spider this=%p", this));
14072 DBUG_RETURN(0);
14073 }
14074
support_use_handler(int use_handler)14075 bool spider_mbase_handler::support_use_handler(
14076 int use_handler
14077 ) {
14078 DBUG_ENTER("spider_mbase_handler::support_use_handler");
14079 DBUG_PRINT("info",("spider this=%p", this));
14080 DBUG_RETURN(TRUE);
14081 }
14082
minimum_select_bitmap_create()14083 void spider_mbase_handler::minimum_select_bitmap_create()
14084 {
14085 TABLE *table = spider->get_table();
14086 Field **field_p;
14087 DBUG_ENTER("spider_mbase_handler::minimum_select_bitmap_create");
14088 DBUG_PRINT("info",("spider this=%p", this));
14089 memset(minimum_select_bitmap, 0, no_bytes_in_map(table->read_set));
14090 if (
14091 spider->use_index_merge ||
14092 #ifdef HA_CAN_BULK_ACCESS
14093 (spider->is_clone && !spider->is_bulk_access_clone)
14094 #else
14095 spider->is_clone
14096 #endif
14097 ) {
14098 /* need preparing for cmp_ref */
14099 TABLE_SHARE *table_share = table->s;
14100 if (
14101 table_share->primary_key == MAX_KEY
14102 ) {
14103 /* need all columns */
14104 memset(minimum_select_bitmap, 0xFF, no_bytes_in_map(table->read_set));
14105 DBUG_VOID_RETURN;
14106 } else {
14107 /* need primary key columns */
14108 uint roop_count;
14109 KEY *key_info;
14110 KEY_PART_INFO *key_part;
14111 Field *field;
14112 key_info = &table_share->key_info[table_share->primary_key];
14113 key_part = key_info->key_part;
14114 for (roop_count = 0;
14115 roop_count < spider_user_defined_key_parts(key_info);
14116 roop_count++)
14117 {
14118 field = key_part[roop_count].field;
14119 spider_set_bit(minimum_select_bitmap, field->field_index);
14120 }
14121 }
14122 }
14123 DBUG_PRINT("info",("spider searched_bitmap=%p", spider->searched_bitmap));
14124 for (field_p = table->field; *field_p; field_p++)
14125 {
14126 uint field_index = (*field_p)->field_index;
14127 DBUG_PRINT("info",("spider field_index=%u", field_index));
14128 DBUG_PRINT("info",("spider ft_discard_bitmap=%s",
14129 spider_bit_is_set(spider->ft_discard_bitmap, field_index) ?
14130 "TRUE" : "FALSE"));
14131 DBUG_PRINT("info",("spider searched_bitmap=%s",
14132 spider_bit_is_set(spider->searched_bitmap, field_index) ?
14133 "TRUE" : "FALSE"));
14134 DBUG_PRINT("info",("spider read_set=%s",
14135 bitmap_is_set(table->read_set, field_index) ?
14136 "TRUE" : "FALSE"));
14137 DBUG_PRINT("info",("spider write_set=%s",
14138 bitmap_is_set(table->write_set, field_index) ?
14139 "TRUE" : "FALSE"));
14140 if (
14141 spider_bit_is_set(spider->ft_discard_bitmap, field_index) &
14142 (
14143 spider_bit_is_set(spider->searched_bitmap, field_index) |
14144 bitmap_is_set(table->read_set, field_index) |
14145 bitmap_is_set(table->write_set, field_index)
14146 )
14147 ) {
14148 spider_set_bit(minimum_select_bitmap, field_index);
14149 }
14150 }
14151 DBUG_VOID_RETURN;
14152 }
14153
minimum_select_bit_is_set(uint field_index)14154 bool spider_mbase_handler::minimum_select_bit_is_set(
14155 uint field_index
14156 ) {
14157 DBUG_ENTER("spider_mbase_handler::minimum_select_bit_is_set");
14158 DBUG_PRINT("info",("spider this=%p", this));
14159 DBUG_PRINT("info",("spider field_index=%u", field_index));
14160 DBUG_PRINT("info",("spider minimum_select_bitmap=%s",
14161 spider_bit_is_set(minimum_select_bitmap, field_index) ?
14162 "TRUE" : "FALSE"));
14163 DBUG_RETURN(spider_bit_is_set(minimum_select_bitmap, field_index));
14164 }
14165
copy_minimum_select_bitmap(uchar * bitmap)14166 void spider_mbase_handler::copy_minimum_select_bitmap(
14167 uchar *bitmap
14168 ) {
14169 int roop_count;
14170 TABLE *table = spider->get_table();
14171 DBUG_ENTER("spider_mbase_handler::copy_minimum_select_bitmap");
14172 for (roop_count = 0;
14173 roop_count < (int) ((table->s->fields + 7) / 8);
14174 roop_count++)
14175 {
14176 bitmap[roop_count] =
14177 minimum_select_bitmap[roop_count];
14178 DBUG_PRINT("info",("spider roop_count=%d", roop_count));
14179 DBUG_PRINT("info",("spider bitmap=%d",
14180 bitmap[roop_count]));
14181 }
14182 DBUG_VOID_RETURN;
14183 }
14184
init_union_table_name_pos()14185 int spider_mbase_handler::init_union_table_name_pos()
14186 {
14187 DBUG_ENTER("spider_mbase_handler::init_union_table_name_pos");
14188 DBUG_PRINT("info",("spider this=%p", this));
14189 if (!union_table_name_pos_first)
14190 {
14191 if (!spider_bulk_malloc(spider_current_trx, 236, MYF(MY_WME),
14192 &union_table_name_pos_first, sizeof(SPIDER_INT_HLD),
14193 NullS)
14194 ) {
14195 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14196 }
14197 union_table_name_pos_first->next = NULL;
14198 }
14199 union_table_name_pos_current = union_table_name_pos_first;
14200 union_table_name_pos_current->tgt_num = 0;
14201 DBUG_RETURN(0);
14202 }
14203
set_union_table_name_pos()14204 int spider_mbase_handler::set_union_table_name_pos()
14205 {
14206 DBUG_ENTER("spider_mbase_handler::set_union_table_name_pos");
14207 DBUG_PRINT("info",("spider this=%p", this));
14208 if (union_table_name_pos_current->tgt_num >= SPIDER_INT_HLD_TGT_SIZE)
14209 {
14210 if (!union_table_name_pos_current->next)
14211 {
14212 if (!spider_bulk_malloc(spider_current_trx, 237, MYF(MY_WME),
14213 &union_table_name_pos_current->next, sizeof(SPIDER_INT_HLD),
14214 NullS)
14215 ) {
14216 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14217 }
14218 union_table_name_pos_current->next->next = NULL;
14219 }
14220 union_table_name_pos_current = union_table_name_pos_current->next;
14221 union_table_name_pos_current->tgt_num = 0;
14222 }
14223 union_table_name_pos_current->tgt[union_table_name_pos_current->tgt_num] =
14224 table_name_pos;
14225 ++union_table_name_pos_current->tgt_num;
14226 DBUG_RETURN(0);
14227 }
14228
reset_union_table_name(spider_string * str,int link_idx,ulong sql_type)14229 int spider_mbase_handler::reset_union_table_name(
14230 spider_string *str,
14231 int link_idx,
14232 ulong sql_type
14233 ) {
14234 DBUG_ENTER("spider_mbase_handler::reset_union_table_name");
14235 DBUG_PRINT("info",("spider this=%p", this));
14236 if (!union_table_name_pos_current)
14237 DBUG_RETURN(0);
14238
14239 SPIDER_INT_HLD *tmp_pos = union_table_name_pos_first;
14240 uint cur_num, pos_backup = str->length();
14241 while(TRUE)
14242 {
14243 for (cur_num = 0; cur_num < tmp_pos->tgt_num; ++cur_num)
14244 {
14245 str->length(tmp_pos->tgt[cur_num]);
14246 append_table_name_with_adjusting(str, link_idx, sql_type);
14247 }
14248 if (tmp_pos == union_table_name_pos_current)
14249 break;
14250 tmp_pos = tmp_pos->next;
14251 }
14252 str->length(pos_backup);
14253 DBUG_RETURN(0);
14254 }
14255
14256 #ifdef SPIDER_HAS_GROUP_BY_HANDLER
append_from_and_tables_part(spider_fields * fields,ulong sql_type)14257 int spider_mbase_handler::append_from_and_tables_part(
14258 spider_fields *fields,
14259 ulong sql_type
14260 ) {
14261 int error_num;
14262 spider_string *str;
14263 SPIDER_TABLE_HOLDER *table_holder;
14264 TABLE_LIST *table_list;
14265 DBUG_ENTER("spider_mbase_handler::append_from_and_tables_part");
14266 DBUG_PRINT("info",("spider this=%p", this));
14267 switch (sql_type)
14268 {
14269 case SPIDER_SQL_TYPE_SELECT_SQL:
14270 str = &sql;
14271 break;
14272 default:
14273 DBUG_RETURN(0);
14274 }
14275 fields->set_pos_to_first_table_holder();
14276 table_holder = fields->get_next_table_holder();
14277 table_list = table_holder->table->pos_in_table_list;
14278 error_num = spider_db_mbase_utility->append_from_and_tables(
14279 table_holder->spider, fields, str,
14280 table_list, fields->get_table_count());
14281 DBUG_RETURN(error_num);
14282 }
14283
reappend_tables_part(spider_fields * fields,ulong sql_type)14284 int spider_mbase_handler::reappend_tables_part(
14285 spider_fields *fields,
14286 ulong sql_type
14287 ) {
14288 int error_num;
14289 spider_string *str;
14290 DBUG_ENTER("spider_mbase_handler::reappend_tables_part");
14291 DBUG_PRINT("info",("spider this=%p", this));
14292 switch (sql_type)
14293 {
14294 case SPIDER_SQL_TYPE_SELECT_SQL:
14295 str = &sql;
14296 break;
14297 default:
14298 DBUG_RETURN(0);
14299 }
14300 error_num = spider_db_mbase_utility->reappend_tables(fields,
14301 link_idx_chain, str);
14302 DBUG_RETURN(error_num);
14303 }
14304
append_where_part(ulong sql_type)14305 int spider_mbase_handler::append_where_part(
14306 ulong sql_type
14307 ) {
14308 int error_num;
14309 spider_string *str;
14310 DBUG_ENTER("spider_mbase_handler::append_where_part");
14311 DBUG_PRINT("info",("spider this=%p", this));
14312 switch (sql_type)
14313 {
14314 case SPIDER_SQL_TYPE_SELECT_SQL:
14315 str = &sql;
14316 break;
14317 default:
14318 DBUG_RETURN(0);
14319 }
14320 error_num = spider_db_mbase_utility->append_where(str);
14321 DBUG_RETURN(error_num);
14322 }
14323
append_having_part(ulong sql_type)14324 int spider_mbase_handler::append_having_part(
14325 ulong sql_type
14326 ) {
14327 int error_num;
14328 spider_string *str;
14329 DBUG_ENTER("spider_mbase_handler::append_having_part");
14330 DBUG_PRINT("info",("spider this=%p", this));
14331 switch (sql_type)
14332 {
14333 case SPIDER_SQL_TYPE_SELECT_SQL:
14334 str = &sql;
14335 break;
14336 default:
14337 DBUG_RETURN(0);
14338 }
14339 error_num = spider_db_mbase_utility->append_having(str);
14340 DBUG_RETURN(error_num);
14341 }
14342
append_item_type_part(Item * item,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)14343 int spider_mbase_handler::append_item_type_part(
14344 Item *item,
14345 const char *alias,
14346 uint alias_length,
14347 bool use_fields,
14348 spider_fields *fields,
14349 ulong sql_type
14350 ) {
14351 int error_num;
14352 spider_string *str;
14353 DBUG_ENTER("spider_mbase_handler::append_item_type_part");
14354 DBUG_PRINT("info",("spider this=%p", this));
14355 switch (sql_type)
14356 {
14357 case SPIDER_SQL_TYPE_SELECT_SQL:
14358 str = &sql;
14359 break;
14360 default:
14361 DBUG_RETURN(0);
14362 }
14363 error_num = spider_db_print_item_type(item, NULL, spider, str,
14364 alias, alias_length, dbton_id, use_fields, fields);
14365 DBUG_RETURN(error_num);
14366 }
14367
append_list_item_select_part(List<Item> * select,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)14368 int spider_mbase_handler::append_list_item_select_part(
14369 List<Item> *select,
14370 const char *alias,
14371 uint alias_length,
14372 bool use_fields,
14373 spider_fields *fields,
14374 ulong sql_type
14375 ) {
14376 int error_num;
14377 spider_string *str;
14378 DBUG_ENTER("spider_mbase_handler::append_list_item_select_part");
14379 DBUG_PRINT("info",("spider this=%p", this));
14380 switch (sql_type)
14381 {
14382 case SPIDER_SQL_TYPE_SELECT_SQL:
14383 str = &sql;
14384 break;
14385 default:
14386 DBUG_RETURN(0);
14387 }
14388 error_num = append_list_item_select(select, str, alias, alias_length,
14389 use_fields, fields);
14390 DBUG_RETURN(error_num);
14391 }
14392
append_list_item_select(List<Item> * select,spider_string * str,const char * alias,uint alias_length,bool use_fields,spider_fields * fields)14393 int spider_mbase_handler::append_list_item_select(
14394 List<Item> *select,
14395 spider_string *str,
14396 const char *alias,
14397 uint alias_length,
14398 bool use_fields,
14399 spider_fields *fields
14400 ) {
14401 int error_num;
14402 uint32 length, begin;
14403 List_iterator_fast<Item> it(*select);
14404 Item *item;
14405 Field *field;
14406 const char *item_name;
14407 DBUG_ENTER("spider_mbase_handler::append_list_item_select");
14408 DBUG_PRINT("info",("spider this=%p", this));
14409 begin = str->length();
14410 while ((item = it++))
14411 {
14412 if (item->const_item())
14413 {
14414 DBUG_PRINT("info",("spider const item"));
14415 continue;
14416 }
14417 if ((error_num = spider_db_print_item_type(item, NULL, spider, str,
14418 alias, alias_length, dbton_id, use_fields, fields)))
14419 {
14420 DBUG_RETURN(error_num);
14421 }
14422 field = *(fields->get_next_field_ptr());
14423 if (field)
14424 {
14425 item_name = SPIDER_field_name_str(field);
14426 length = SPIDER_field_name_length(field);
14427 } else {
14428 item_name = SPIDER_item_name_str(item);
14429 length = SPIDER_item_name_length(item);
14430 }
14431 if (str->reserve(
14432 SPIDER_SQL_COMMA_LEN + /* SPIDER_SQL_NAME_QUOTE_LEN */ 2 +
14433 SPIDER_SQL_SPACE_LEN + length
14434 ))
14435 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14436 str->q_append(SPIDER_SQL_SPACE_STR, SPIDER_SQL_SPACE_LEN);
14437 if ((error_num = spider_db_mbase_utility->append_name(str,
14438 item_name, length)))
14439 {
14440 DBUG_RETURN(error_num);
14441 }
14442 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14443 }
14444 if (begin == str->length())
14445 {
14446 /* no columns */
14447 if (str->reserve(SPIDER_SQL_ONE_LEN))
14448 {
14449 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14450 }
14451 str->q_append(SPIDER_SQL_ONE_STR, SPIDER_SQL_ONE_LEN);
14452 } else {
14453 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
14454 }
14455 DBUG_RETURN(0);
14456 }
14457
append_group_by_part(ORDER * order,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)14458 int spider_mbase_handler::append_group_by_part(
14459 ORDER *order,
14460 const char *alias,
14461 uint alias_length,
14462 bool use_fields,
14463 spider_fields *fields,
14464 ulong sql_type
14465 ) {
14466 int error_num;
14467 spider_string *str;
14468 DBUG_ENTER("spider_mbase_handler::append_group_by_part");
14469 DBUG_PRINT("info",("spider this=%p", this));
14470 switch (sql_type)
14471 {
14472 case SPIDER_SQL_TYPE_SELECT_SQL:
14473 str = &sql;
14474 break;
14475 default:
14476 DBUG_RETURN(0);
14477 }
14478 error_num = append_group_by(order, str, alias, alias_length,
14479 use_fields, fields);
14480 DBUG_RETURN(error_num);
14481 }
14482
append_group_by(ORDER * order,spider_string * str,const char * alias,uint alias_length,bool use_fields,spider_fields * fields)14483 int spider_mbase_handler::append_group_by(
14484 ORDER *order,
14485 spider_string *str,
14486 const char *alias,
14487 uint alias_length,
14488 bool use_fields,
14489 spider_fields *fields
14490 ) {
14491 int error_num;
14492 DBUG_ENTER("spider_mbase_handler::append_group_by");
14493 DBUG_PRINT("info",("spider this=%p", this));
14494 if (order)
14495 {
14496 if (str->reserve(SPIDER_SQL_GROUP_LEN))
14497 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14498 str->q_append(SPIDER_SQL_GROUP_STR, SPIDER_SQL_GROUP_LEN);
14499 for (; order; order = order->next)
14500 {
14501 if ((error_num = spider_db_print_item_type((*order->item), NULL, spider,
14502 str, alias, alias_length, dbton_id, use_fields, fields)))
14503 {
14504 DBUG_RETURN(error_num);
14505 }
14506 if (str->reserve(SPIDER_SQL_COMMA_LEN))
14507 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14508 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14509 }
14510 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
14511 }
14512 DBUG_RETURN(0);
14513 }
14514
append_order_by_part(ORDER * order,const char * alias,uint alias_length,bool use_fields,spider_fields * fields,ulong sql_type)14515 int spider_mbase_handler::append_order_by_part(
14516 ORDER *order,
14517 const char *alias,
14518 uint alias_length,
14519 bool use_fields,
14520 spider_fields *fields,
14521 ulong sql_type
14522 ) {
14523 int error_num;
14524 spider_string *str;
14525 DBUG_ENTER("spider_mbase_handler::append_order_by_part");
14526 DBUG_PRINT("info",("spider this=%p", this));
14527 switch (sql_type)
14528 {
14529 case SPIDER_SQL_TYPE_SELECT_SQL:
14530 str = &sql;
14531 break;
14532 default:
14533 DBUG_RETURN(0);
14534 }
14535 error_num = append_order_by(order, str, alias, alias_length,
14536 use_fields, fields);
14537 DBUG_RETURN(error_num);
14538 }
14539
append_order_by(ORDER * order,spider_string * str,const char * alias,uint alias_length,bool use_fields,spider_fields * fields)14540 int spider_mbase_handler::append_order_by(
14541 ORDER *order,
14542 spider_string *str,
14543 const char *alias,
14544 uint alias_length,
14545 bool use_fields,
14546 spider_fields *fields
14547 ) {
14548 int error_num;
14549 DBUG_ENTER("spider_mbase_handler::append_order_by");
14550 DBUG_PRINT("info",("spider this=%p", this));
14551 if (order)
14552 {
14553 if (str->reserve(SPIDER_SQL_ORDER_LEN))
14554 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14555 str->q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
14556 for (; order; order = order->next)
14557 {
14558 if ((error_num = spider_db_print_item_type((*order->item), NULL, spider,
14559 str, alias, alias_length, dbton_id, use_fields, fields)))
14560 {
14561 DBUG_RETURN(error_num);
14562 }
14563 if (SPIDER_order_direction_is_asc(order))
14564 {
14565 if (str->reserve(SPIDER_SQL_COMMA_LEN))
14566 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14567 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14568 } else {
14569 if (str->reserve(SPIDER_SQL_COMMA_LEN + SPIDER_SQL_DESC_LEN))
14570 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14571 str->q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
14572 str->q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14573 }
14574 }
14575 str->length(str->length() - SPIDER_SQL_COMMA_LEN);
14576 }
14577 DBUG_RETURN(0);
14578 }
14579 #endif
14580
spider_mbase_copy_table(spider_mbase_share * db_share)14581 spider_mbase_copy_table::spider_mbase_copy_table(
14582 spider_mbase_share *db_share
14583 ) : spider_db_copy_table(
14584 db_share
14585 ),
14586 mysql_share(db_share)
14587 {
14588 DBUG_ENTER("spider_mbase_copy_table::spider_mbase_copy_table");
14589 DBUG_PRINT("info",("spider this=%p", this));
14590 DBUG_VOID_RETURN;
14591 }
14592
spider_mysql_copy_table(spider_mbase_share * db_share)14593 spider_mysql_copy_table::spider_mysql_copy_table(
14594 spider_mbase_share *db_share
14595 ) : spider_mbase_copy_table(
14596 db_share
14597 ) {
14598 DBUG_ENTER("spider_mysql_copy_table::spider_mysql_copy_table");
14599 DBUG_PRINT("info",("spider this=%p", this));
14600 DBUG_VOID_RETURN;
14601 }
14602
spider_mariadb_copy_table(spider_mbase_share * db_share)14603 spider_mariadb_copy_table::spider_mariadb_copy_table(
14604 spider_mbase_share *db_share
14605 ) : spider_mbase_copy_table(
14606 db_share
14607 ) {
14608 DBUG_ENTER("spider_mariadb_copy_table::spider_mariadb_copy_table");
14609 DBUG_PRINT("info",("spider this=%p", this));
14610 DBUG_VOID_RETURN;
14611 }
14612
~spider_mbase_copy_table()14613 spider_mbase_copy_table::~spider_mbase_copy_table()
14614 {
14615 DBUG_ENTER("spider_mbase_copy_table::~spider_mbase_copy_table");
14616 DBUG_PRINT("info",("spider this=%p", this));
14617 DBUG_VOID_RETURN;
14618 }
14619
~spider_mysql_copy_table()14620 spider_mysql_copy_table::~spider_mysql_copy_table()
14621 {
14622 DBUG_ENTER("spider_mysql_copy_table::~spider_mysql_copy_table");
14623 DBUG_PRINT("info",("spider this=%p", this));
14624 DBUG_VOID_RETURN;
14625 }
14626
~spider_mariadb_copy_table()14627 spider_mariadb_copy_table::~spider_mariadb_copy_table()
14628 {
14629 DBUG_ENTER("spider_mariadb_copy_table::~spider_mariadb_copy_table");
14630 DBUG_PRINT("info",("spider this=%p", this));
14631 DBUG_VOID_RETURN;
14632 }
14633
init()14634 int spider_mbase_copy_table::init()
14635 {
14636 DBUG_ENTER("spider_mbase_copy_table::init");
14637 DBUG_PRINT("info",("spider this=%p", this));
14638 sql.init_calc_mem(78);
14639 DBUG_RETURN(0);
14640 }
14641
set_sql_charset(CHARSET_INFO * cs)14642 void spider_mbase_copy_table::set_sql_charset(
14643 CHARSET_INFO *cs
14644 ) {
14645 DBUG_ENTER("spider_mbase_copy_table::set_sql_charset");
14646 DBUG_PRINT("info",("spider this=%p", this));
14647 sql.set_charset(cs);
14648 DBUG_VOID_RETURN;
14649 }
14650
append_select_str()14651 int spider_mbase_copy_table::append_select_str()
14652 {
14653 DBUG_ENTER("spider_mbase_copy_table::append_select_str");
14654 DBUG_PRINT("info",("spider this=%p", this));
14655 if (sql.reserve(SPIDER_SQL_SELECT_LEN))
14656 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14657 sql.q_append(SPIDER_SQL_SELECT_STR, SPIDER_SQL_SELECT_LEN);
14658 DBUG_RETURN(0);
14659 }
14660
append_insert_str(int insert_flg)14661 int spider_mbase_copy_table::append_insert_str(
14662 int insert_flg
14663 ) {
14664 DBUG_ENTER("spider_mbase_copy_table::append_insert_str");
14665 DBUG_PRINT("info",("spider this=%p", this));
14666 if (insert_flg & SPIDER_DB_INSERT_REPLACE)
14667 {
14668 if (sql.reserve(SPIDER_SQL_REPLACE_LEN))
14669 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14670 sql.q_append(SPIDER_SQL_REPLACE_STR, SPIDER_SQL_REPLACE_LEN);
14671 } else {
14672 if (sql.reserve(SPIDER_SQL_INSERT_LEN))
14673 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14674 sql.q_append(SPIDER_SQL_INSERT_STR, SPIDER_SQL_INSERT_LEN);
14675 }
14676 if (insert_flg & SPIDER_DB_INSERT_LOW_PRIORITY)
14677 {
14678 if (sql.reserve(SPIDER_SQL_LOW_PRIORITY_LEN))
14679 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14680 sql.q_append(SPIDER_SQL_LOW_PRIORITY_STR, SPIDER_SQL_LOW_PRIORITY_LEN);
14681 }
14682 else if (insert_flg & SPIDER_DB_INSERT_DELAYED)
14683 {
14684 if (sql.reserve(SPIDER_SQL_SQL_DELAYED_LEN))
14685 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14686 sql.q_append(SPIDER_SQL_SQL_DELAYED_STR, SPIDER_SQL_SQL_DELAYED_LEN);
14687 }
14688 else if (insert_flg & SPIDER_DB_INSERT_HIGH_PRIORITY)
14689 {
14690 if (sql.reserve(SPIDER_SQL_HIGH_PRIORITY_LEN))
14691 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14692 sql.q_append(SPIDER_SQL_HIGH_PRIORITY_STR, SPIDER_SQL_HIGH_PRIORITY_LEN);
14693 }
14694 if (insert_flg & SPIDER_DB_INSERT_IGNORE)
14695 {
14696 if (sql.reserve(SPIDER_SQL_SQL_IGNORE_LEN))
14697 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14698 sql.q_append(SPIDER_SQL_SQL_IGNORE_STR, SPIDER_SQL_SQL_IGNORE_LEN);
14699 }
14700 DBUG_RETURN(0);
14701 }
14702
append_table_columns(TABLE_SHARE * table_share)14703 int spider_mbase_copy_table::append_table_columns(
14704 TABLE_SHARE *table_share
14705 ) {
14706 int error_num;
14707 Field **field;
14708 DBUG_ENTER("spider_mbase_copy_table::append_table_columns");
14709 DBUG_PRINT("info",("spider this=%p", this));
14710 for (field = table_share->field; *field; field++)
14711 {
14712 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN))
14713 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14714 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14715 if ((error_num = spider_db_append_name_with_quote_str(&sql,
14716 (*field)->field_name, dbton_id)))
14717 DBUG_RETURN(error_num);
14718 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN))
14719 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14720 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14721 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14722 }
14723 sql.length(sql.length() - SPIDER_SQL_COMMA_LEN);
14724 DBUG_RETURN(0);
14725 }
14726
append_from_str()14727 int spider_mbase_copy_table::append_from_str()
14728 {
14729 DBUG_ENTER("spider_mbase_copy_table::append_from_str");
14730 DBUG_PRINT("info",("spider this=%p", this));
14731 if (sql.reserve(SPIDER_SQL_FROM_LEN))
14732 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14733 sql.q_append(SPIDER_SQL_FROM_STR, SPIDER_SQL_FROM_LEN);
14734 DBUG_RETURN(0);
14735 }
14736
append_table_name(int link_idx)14737 int spider_mbase_copy_table::append_table_name(
14738 int link_idx
14739 ) {
14740 int error_num;
14741 DBUG_ENTER("spider_mbase_copy_table::append_table_name");
14742 DBUG_PRINT("info",("spider this=%p", this));
14743 error_num = mysql_share->append_table_name(&sql, link_idx);
14744 DBUG_RETURN(error_num);
14745 }
14746
set_sql_pos()14747 void spider_mbase_copy_table::set_sql_pos()
14748 {
14749 DBUG_ENTER("spider_mbase_copy_table::set_sql_pos");
14750 DBUG_PRINT("info",("spider this=%p", this));
14751 pos = sql.length();
14752 DBUG_VOID_RETURN;
14753 }
14754
set_sql_to_pos()14755 void spider_mbase_copy_table::set_sql_to_pos()
14756 {
14757 DBUG_ENTER("spider_mbase_copy_table::set_sql_to_pos");
14758 DBUG_PRINT("info",("spider this=%p", this));
14759 sql.length(pos);
14760 DBUG_VOID_RETURN;
14761 }
14762
append_copy_where(spider_db_copy_table * source_ct,KEY * key_info,ulong * last_row_pos,ulong * last_lengths)14763 int spider_mbase_copy_table::append_copy_where(
14764 spider_db_copy_table *source_ct,
14765 KEY *key_info,
14766 ulong *last_row_pos,
14767 ulong *last_lengths
14768 ) {
14769 int error_num, roop_count, roop_count2;
14770 DBUG_ENTER("spider_mbase_copy_table::append_copy_where");
14771 DBUG_PRINT("info",("spider this=%p", this));
14772 if (sql.reserve(SPIDER_SQL_WHERE_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
14773 {
14774 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14775 }
14776 sql.q_append(SPIDER_SQL_WHERE_STR, SPIDER_SQL_WHERE_LEN);
14777 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
14778 Field *field;
14779 KEY_PART_INFO *key_part = key_info->key_part;
14780 for (roop_count = spider_user_defined_key_parts(key_info) - 1;
14781 roop_count >= 0; roop_count--)
14782 {
14783 for (roop_count2 = 0; roop_count2 < roop_count; roop_count2++)
14784 {
14785 field = key_part[roop_count2].field;
14786 if ((error_num = copy_key_row(source_ct,
14787 field, &last_row_pos[field->field_index],
14788 &last_lengths[field->field_index],
14789 SPIDER_SQL_EQUAL_STR, SPIDER_SQL_EQUAL_LEN)))
14790 {
14791 DBUG_RETURN(error_num);
14792 }
14793 }
14794 field = key_part[roop_count2].field;
14795 if ((error_num = copy_key_row(source_ct,
14796 field, &last_row_pos[field->field_index],
14797 &last_lengths[field->field_index],
14798 SPIDER_SQL_GT_STR, SPIDER_SQL_GT_LEN)))
14799 {
14800 DBUG_RETURN(error_num);
14801 }
14802 sql.length(sql.length() - SPIDER_SQL_AND_LEN);
14803 if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN +
14804 SPIDER_SQL_OR_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
14805 {
14806 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14807 }
14808 sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
14809 sql.q_append(SPIDER_SQL_OR_STR, SPIDER_SQL_OR_LEN);
14810 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
14811 }
14812 sql.length(sql.length() - SPIDER_SQL_OR_LEN - SPIDER_SQL_OPEN_PAREN_LEN);
14813 DBUG_RETURN(0);
14814 }
14815
append_key_order_str(KEY * key_info,int start_pos,bool desc_flg)14816 int spider_mbase_copy_table::append_key_order_str(
14817 KEY *key_info,
14818 int start_pos,
14819 bool desc_flg
14820 ) {
14821 int length, error_num;
14822 KEY_PART_INFO *key_part;
14823 Field *field;
14824 DBUG_ENTER("spider_mbase_copy_table::append_key_order_str");
14825 DBUG_PRINT("info",("spider this=%p", this));
14826 if ((int) spider_user_defined_key_parts(key_info) > start_pos)
14827 {
14828 if (sql.reserve(SPIDER_SQL_ORDER_LEN))
14829 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14830 sql.q_append(SPIDER_SQL_ORDER_STR, SPIDER_SQL_ORDER_LEN);
14831 if (desc_flg == TRUE)
14832 {
14833 for (
14834 key_part = key_info->key_part + start_pos,
14835 length = 0;
14836 length + start_pos < (int) spider_user_defined_key_parts(key_info);
14837 key_part++,
14838 length++
14839 ) {
14840 field = key_part->field;
14841 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN))
14842 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14843 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14844 if ((error_num = spider_db_append_name_with_quote_str(&sql,
14845 field->field_name, dbton_id)))
14846 DBUG_RETURN(error_num);
14847 if (key_part->key_part_flag & HA_REVERSE_SORT)
14848 {
14849 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN))
14850 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14851 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14852 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14853 } else {
14854 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_DESC_LEN +
14855 SPIDER_SQL_COMMA_LEN))
14856 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14857 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14858 sql.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
14859 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14860 }
14861 }
14862 } else {
14863 for (
14864 key_part = key_info->key_part + start_pos,
14865 length = 0;
14866 length + start_pos < (int) spider_user_defined_key_parts(key_info);
14867 key_part++,
14868 length++
14869 ) {
14870 field = key_part->field;
14871 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN))
14872 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14873 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14874 if ((error_num = spider_db_append_name_with_quote_str(&sql,
14875 field->field_name, dbton_id)))
14876 DBUG_RETURN(error_num);
14877 if (key_part->key_part_flag & HA_REVERSE_SORT)
14878 {
14879 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_DESC_LEN +
14880 SPIDER_SQL_COMMA_LEN))
14881 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14882 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14883 sql.q_append(SPIDER_SQL_DESC_STR, SPIDER_SQL_DESC_LEN);
14884 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14885 } else {
14886 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + SPIDER_SQL_COMMA_LEN))
14887 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14888 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
14889 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14890 }
14891 }
14892 }
14893 sql.length(sql.length() - SPIDER_SQL_COMMA_LEN);
14894 }
14895 DBUG_RETURN(0);
14896 }
14897
append_limit(longlong offset,longlong limit)14898 int spider_mbase_copy_table::append_limit(
14899 longlong offset,
14900 longlong limit
14901 ) {
14902 char buf[SPIDER_LONGLONG_LEN + 1];
14903 uint32 length;
14904 DBUG_ENTER("spider_mbase_copy_table::append_limit");
14905 DBUG_PRINT("info",("spider this=%p", this));
14906 if (offset || limit < 9223372036854775807LL)
14907 {
14908 if (sql.reserve(SPIDER_SQL_LIMIT_LEN + SPIDER_SQL_COMMA_LEN +
14909 ((SPIDER_LONGLONG_LEN) * 2)))
14910 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14911 sql.q_append(SPIDER_SQL_LIMIT_STR, SPIDER_SQL_LIMIT_LEN);
14912 if (offset)
14913 {
14914 length = (uint32) (my_charset_bin.cset->longlong10_to_str)(
14915 &my_charset_bin, buf, SPIDER_LONGLONG_LEN + 1, -10, offset);
14916 sql.q_append(buf, length);
14917 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
14918 }
14919 length = (uint32) (my_charset_bin.cset->longlong10_to_str)(
14920 &my_charset_bin, buf, SPIDER_LONGLONG_LEN + 1, -10, limit);
14921 sql.q_append(buf, length);
14922 }
14923 DBUG_RETURN(0);
14924 }
14925
append_into_str()14926 int spider_mbase_copy_table::append_into_str()
14927 {
14928 DBUG_ENTER("spider_mbase_copy_table::append_into_str");
14929 DBUG_PRINT("info",("spider this=%p", this));
14930 if (sql.reserve(SPIDER_SQL_INTO_LEN))
14931 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14932 sql.q_append(SPIDER_SQL_INTO_STR, SPIDER_SQL_INTO_LEN);
14933 DBUG_RETURN(0);
14934 }
14935
append_open_paren_str()14936 int spider_mbase_copy_table::append_open_paren_str()
14937 {
14938 DBUG_ENTER("spider_mbase_copy_table::append_open_paren_str");
14939 DBUG_PRINT("info",("spider this=%p", this));
14940 if (sql.reserve(SPIDER_SQL_OPEN_PAREN_LEN))
14941 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14942 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
14943 DBUG_RETURN(0);
14944 }
14945
append_values_str()14946 int spider_mbase_copy_table::append_values_str()
14947 {
14948 DBUG_ENTER("spider_mbase_copy_table::append_values_str");
14949 DBUG_PRINT("info",("spider this=%p", this));
14950 if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN + SPIDER_SQL_VALUES_LEN +
14951 SPIDER_SQL_OPEN_PAREN_LEN))
14952 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14953 sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
14954 sql.q_append(SPIDER_SQL_VALUES_STR, SPIDER_SQL_VALUES_LEN);
14955 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
14956 DBUG_RETURN(0);
14957 }
14958
append_select_lock_str(int lock_mode)14959 int spider_mbase_copy_table::append_select_lock_str(
14960 int lock_mode
14961 ) {
14962 DBUG_ENTER("spider_mbase_copy_table::append_select_lock_str");
14963 DBUG_PRINT("info",("spider this=%p", this));
14964 if (lock_mode == SPIDER_LOCK_MODE_EXCLUSIVE)
14965 {
14966 if (sql.reserve(SPIDER_SQL_FOR_UPDATE_LEN))
14967 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14968 sql.q_append(SPIDER_SQL_FOR_UPDATE_STR, SPIDER_SQL_FOR_UPDATE_LEN);
14969 } else if (lock_mode == SPIDER_LOCK_MODE_SHARED)
14970 {
14971 if (sql.reserve(SPIDER_SQL_SHARED_LOCK_LEN))
14972 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
14973 sql.q_append(SPIDER_SQL_SHARED_LOCK_STR, SPIDER_SQL_SHARED_LOCK_LEN);
14974 }
14975 DBUG_RETURN(0);
14976 }
14977
exec_query(SPIDER_CONN * conn,int quick_mode,int * need_mon)14978 int spider_mbase_copy_table::exec_query(
14979 SPIDER_CONN *conn,
14980 int quick_mode,
14981 int *need_mon
14982 ) {
14983 int error_num;
14984 DBUG_ENTER("spider_mbase_copy_table::exec_query");
14985 DBUG_PRINT("info",("spider this=%p", this));
14986 error_num = spider_db_query(conn, sql.ptr(), sql.length(), quick_mode,
14987 need_mon);
14988 DBUG_RETURN(error_num);
14989 }
14990
copy_key_row(spider_db_copy_table * source_ct,Field * field,ulong * row_pos,ulong * length,const char * joint_str,const int joint_length)14991 int spider_mbase_copy_table::copy_key_row(
14992 spider_db_copy_table *source_ct,
14993 Field *field,
14994 ulong *row_pos,
14995 ulong *length,
14996 const char *joint_str,
14997 const int joint_length
14998 ) {
14999 int error_num;
15000 spider_string *source_str = &((spider_mbase_copy_table *) source_ct)->sql;
15001 DBUG_ENTER("spider_mbase_copy_table::copy_key_row");
15002 DBUG_PRINT("info",("spider this=%p", this));
15003 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN))
15004 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15005 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
15006 if ((error_num = spider_db_append_name_with_quote_str(&sql,
15007 field->field_name, dbton_id)))
15008 DBUG_RETURN(error_num);
15009 if (sql.reserve(SPIDER_SQL_NAME_QUOTE_LEN + joint_length + *length +
15010 SPIDER_SQL_AND_LEN))
15011 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15012 sql.q_append(SPIDER_SQL_NAME_QUOTE_STR, SPIDER_SQL_NAME_QUOTE_LEN);
15013 sql.q_append(joint_str, joint_length);
15014 sql.q_append(source_str->ptr() + *row_pos, *length);
15015 sql.q_append(SPIDER_SQL_AND_STR, SPIDER_SQL_AND_LEN);
15016 DBUG_RETURN(0);
15017 }
15018
copy_row(Field * field,SPIDER_DB_ROW * row)15019 int spider_mbase_copy_table::copy_row(
15020 Field *field,
15021 SPIDER_DB_ROW *row
15022 ) {
15023 int error_num;
15024 DBUG_ENTER("spider_mbase_copy_table::copy_row");
15025 DBUG_PRINT("info",("spider this=%p", this));
15026 if (row->is_null())
15027 {
15028 if (sql.reserve(SPIDER_SQL_NULL_LEN + SPIDER_SQL_COMMA_LEN))
15029 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15030 sql.q_append(SPIDER_SQL_NULL_STR, SPIDER_SQL_NULL_LEN);
15031 } else if (field->str_needs_quotes())
15032 {
15033 if (sql.reserve(SPIDER_SQL_VALUE_QUOTE_LEN))
15034 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15035 sql.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
15036 if ((error_num = row->append_escaped_to_str(&sql,
15037 dbton_id)))
15038 DBUG_RETURN(error_num);
15039 if (sql.reserve(SPIDER_SQL_VALUE_QUOTE_LEN + SPIDER_SQL_COMMA_LEN))
15040 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15041 sql.q_append(SPIDER_SQL_VALUE_QUOTE_STR, SPIDER_SQL_VALUE_QUOTE_LEN);
15042 } else {
15043 if ((error_num = row->append_to_str(&sql)))
15044 DBUG_RETURN(error_num);
15045 if (sql.reserve(SPIDER_SQL_COMMA_LEN))
15046 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15047 }
15048 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
15049 DBUG_RETURN(0);
15050 }
15051
copy_rows(TABLE * table,SPIDER_DB_ROW * row,ulong ** last_row_pos,ulong ** last_lengths)15052 int spider_mbase_copy_table::copy_rows(
15053 TABLE *table,
15054 SPIDER_DB_ROW *row,
15055 ulong **last_row_pos,
15056 ulong **last_lengths
15057 ) {
15058 int error_num;
15059 Field **field;
15060 ulong *lengths2, *row_pos2;
15061 DBUG_ENTER("spider_mbase_copy_table::copy_rows");
15062 DBUG_PRINT("info",("spider this=%p", this));
15063 row_pos2 = *last_row_pos;
15064 lengths2 = *last_lengths;
15065
15066 for (
15067 field = table->field;
15068 *field;
15069 field++,
15070 lengths2++
15071 ) {
15072 *row_pos2 = sql.length();
15073 if ((error_num =
15074 copy_row(*field, row)))
15075 DBUG_RETURN(error_num);
15076 *lengths2 = sql.length() - *row_pos2 - SPIDER_SQL_COMMA_LEN;
15077 row->next();
15078 row_pos2++;
15079 }
15080 sql.length(sql.length() - SPIDER_SQL_COMMA_LEN);
15081 if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN +
15082 SPIDER_SQL_COMMA_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
15083 {
15084 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15085 }
15086 sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
15087 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
15088 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
15089 DBUG_RETURN(0);
15090 }
15091
copy_rows(TABLE * table,SPIDER_DB_ROW * row)15092 int spider_mbase_copy_table::copy_rows(
15093 TABLE *table,
15094 SPIDER_DB_ROW *row
15095 ) {
15096 int error_num;
15097 Field **field;
15098 DBUG_ENTER("spider_mbase_copy_table::copy_rows");
15099 DBUG_PRINT("info",("spider this=%p", this));
15100 for (
15101 field = table->field;
15102 *field;
15103 field++
15104 ) {
15105 if ((error_num =
15106 copy_row(*field, row)))
15107 DBUG_RETURN(error_num);
15108 row->next();
15109 }
15110 sql.length(sql.length() - SPIDER_SQL_COMMA_LEN);
15111 if (sql.reserve(SPIDER_SQL_CLOSE_PAREN_LEN +
15112 SPIDER_SQL_COMMA_LEN + SPIDER_SQL_OPEN_PAREN_LEN))
15113 {
15114 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15115 }
15116 sql.q_append(SPIDER_SQL_CLOSE_PAREN_STR, SPIDER_SQL_CLOSE_PAREN_LEN);
15117 sql.q_append(SPIDER_SQL_COMMA_STR, SPIDER_SQL_COMMA_LEN);
15118 sql.q_append(SPIDER_SQL_OPEN_PAREN_STR, SPIDER_SQL_OPEN_PAREN_LEN);
15119 DBUG_RETURN(0);
15120 }
15121
append_insert_terminator()15122 int spider_mbase_copy_table::append_insert_terminator()
15123 {
15124 DBUG_ENTER("spider_mbase_copy_table::append_insert_terminator");
15125 DBUG_PRINT("info",("spider this=%p", this));
15126 sql.length(sql.length() - SPIDER_SQL_COMMA_LEN - SPIDER_SQL_OPEN_PAREN_LEN);
15127 DBUG_RETURN(0);
15128 }
15129
copy_insert_values(spider_db_copy_table * source_ct)15130 int spider_mbase_copy_table::copy_insert_values(
15131 spider_db_copy_table *source_ct
15132 ) {
15133 spider_mbase_copy_table *tmp_ct = (spider_mbase_copy_table *) source_ct;
15134 spider_string *source_str = &tmp_ct->sql;
15135 int values_length = source_str->length() - tmp_ct->pos;
15136 const char *values_ptr = source_str->ptr() + tmp_ct->pos;
15137 DBUG_ENTER("spider_mbase_copy_table::copy_insert_values");
15138 DBUG_PRINT("info",("spider this=%p", this));
15139 if (sql.reserve(values_length))
15140 {
15141 DBUG_RETURN(HA_ERR_OUT_OF_MEM);
15142 }
15143 sql.q_append(values_ptr, values_length);
15144 DBUG_RETURN(0);
15145 }
15146