drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
pars0pars.cc
1/*****************************************************************************
2
3Copyright (C) 1996, 2010, Innobase Oy. All Rights Reserved.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License as published by the Free Software
7Foundation; version 2 of the License.
8
9This program is distributed in the hope that it will be useful, but WITHOUT
10ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
13You should have received a copy of the GNU General Public License along with
14this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15St, Fifth Floor, Boston, MA 02110-1301 USA
16
17*****************************************************************************/
18
19/**************************************************/
25
26/* Historical note: Innobase executed its first SQL string (CREATE TABLE)
27on 1/27/1998 */
28
29#include "pars0pars.h"
30
31#include "plugin/innobase/include/yyparse.h"
32
33#ifdef UNIV_NONINL
34#include "pars0pars.ic"
35#endif
36
37#include "row0sel.h"
38#include "row0ins.h"
39#include "row0upd.h"
40#include "dict0dict.h"
41#include "dict0mem.h"
42#include "dict0crea.h"
43#include "que0que.h"
44#include "pars0grm.hh"
45#include "pars0opt.h"
46#include "data0data.h"
47#include "data0type.h"
48#include "trx0trx.h"
49#include "trx0roll.h"
50#include "lock0lock.h"
51#include "eval0eval.h"
52
53#ifdef UNIV_SQL_DEBUG
56UNIV_INTERN ibool pars_print_lexed = FALSE;
57#endif /* UNIV_SQL_DEBUG */
58
59/* Global variable used while parsing a single procedure or query : the code is
60NOT re-entrant */
61UNIV_INTERN sym_tab_t* pars_sym_tab_global;
62
63/* Global variables used to denote certain reserved words, used in
64constructing the parsing tree */
65
66UNIV_INTERN pars_res_word_t pars_to_char_token = {PARS_TO_CHAR_TOKEN};
67UNIV_INTERN pars_res_word_t pars_to_number_token = {PARS_TO_NUMBER_TOKEN};
68UNIV_INTERN pars_res_word_t pars_to_binary_token = {PARS_TO_BINARY_TOKEN};
69UNIV_INTERN pars_res_word_t pars_binary_to_number_token = {PARS_BINARY_TO_NUMBER_TOKEN};
70UNIV_INTERN pars_res_word_t pars_substr_token = {PARS_SUBSTR_TOKEN};
71UNIV_INTERN pars_res_word_t pars_replstr_token = {PARS_REPLSTR_TOKEN};
72UNIV_INTERN pars_res_word_t pars_concat_token = {PARS_CONCAT_TOKEN};
73UNIV_INTERN pars_res_word_t pars_instr_token = {PARS_INSTR_TOKEN};
74UNIV_INTERN pars_res_word_t pars_length_token = {PARS_LENGTH_TOKEN};
75UNIV_INTERN pars_res_word_t pars_sysdate_token = {PARS_SYSDATE_TOKEN};
76UNIV_INTERN pars_res_word_t pars_printf_token = {PARS_PRINTF_TOKEN};
77UNIV_INTERN pars_res_word_t pars_assert_token = {PARS_ASSERT_TOKEN};
78UNIV_INTERN pars_res_word_t pars_rnd_token = {PARS_RND_TOKEN};
79UNIV_INTERN pars_res_word_t pars_rnd_str_token = {PARS_RND_STR_TOKEN};
80UNIV_INTERN pars_res_word_t pars_count_token = {PARS_COUNT_TOKEN};
81UNIV_INTERN pars_res_word_t pars_sum_token = {PARS_SUM_TOKEN};
82UNIV_INTERN pars_res_word_t pars_distinct_token = {PARS_DISTINCT_TOKEN};
83UNIV_INTERN pars_res_word_t pars_binary_token = {PARS_BINARY_TOKEN};
84UNIV_INTERN pars_res_word_t pars_blob_token = {PARS_BLOB_TOKEN};
85UNIV_INTERN pars_res_word_t pars_int_token = {PARS_INT_TOKEN};
86UNIV_INTERN pars_res_word_t pars_char_token = {PARS_CHAR_TOKEN};
87UNIV_INTERN pars_res_word_t pars_float_token = {PARS_FLOAT_TOKEN};
88UNIV_INTERN pars_res_word_t pars_update_token = {PARS_UPDATE_TOKEN};
89UNIV_INTERN pars_res_word_t pars_asc_token = {PARS_ASC_TOKEN};
90UNIV_INTERN pars_res_word_t pars_desc_token = {PARS_DESC_TOKEN};
91UNIV_INTERN pars_res_word_t pars_open_token = {PARS_OPEN_TOKEN};
92UNIV_INTERN pars_res_word_t pars_close_token = {PARS_CLOSE_TOKEN};
93UNIV_INTERN pars_res_word_t pars_share_token = {PARS_SHARE_TOKEN};
94UNIV_INTERN pars_res_word_t pars_unique_token = {PARS_UNIQUE_TOKEN};
95UNIV_INTERN pars_res_word_t pars_clustered_token = {PARS_CLUSTERED_TOKEN};
96
98UNIV_INTERN ulint pars_star_denoter = 12345678;
99
100
101/*********************************************************************/
104static
105ulint
106pars_func_get_class(
107/*================*/
108 int func)
109{
110 switch (func) {
111 case '+': case '-': case '*': case '/':
112 return(PARS_FUNC_ARITH);
113
114 case '=': case '<': case '>':
115 case PARS_GE_TOKEN: case PARS_LE_TOKEN: case PARS_NE_TOKEN:
116 return(PARS_FUNC_CMP);
117
118 case PARS_AND_TOKEN: case PARS_OR_TOKEN: case PARS_NOT_TOKEN:
119 return(PARS_FUNC_LOGICAL);
120
121 case PARS_COUNT_TOKEN: case PARS_SUM_TOKEN:
122 return(PARS_FUNC_AGGREGATE);
123
124 case PARS_TO_CHAR_TOKEN:
125 case PARS_TO_NUMBER_TOKEN:
126 case PARS_TO_BINARY_TOKEN:
127 case PARS_BINARY_TO_NUMBER_TOKEN:
128 case PARS_SUBSTR_TOKEN:
129 case PARS_CONCAT_TOKEN:
130 case PARS_LENGTH_TOKEN:
131 case PARS_INSTR_TOKEN:
132 case PARS_SYSDATE_TOKEN:
133 case PARS_NOTFOUND_TOKEN:
134 case PARS_PRINTF_TOKEN:
135 case PARS_ASSERT_TOKEN:
136 case PARS_RND_TOKEN:
137 case PARS_RND_STR_TOKEN:
138 case PARS_REPLSTR_TOKEN:
139 return(PARS_FUNC_PREDEFINED);
140
141 default:
142 return(PARS_FUNC_OTHER);
143 }
144}
145
146/*********************************************************************/
149static
150func_node_t*
151pars_func_low(
152/*==========*/
153 int func,
154 que_node_t* arg)
155{
156 func_node_t* node;
157
158 node = static_cast<func_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(func_node_t)));
159
160 node->common.type = QUE_NODE_FUNC;
161 dfield_set_data(&(node->common.val), NULL, 0);
162 node->common.val_buf_size = 0;
163
164 node->func = func;
165
166 node->func_class = pars_func_get_class(func);
167
168 node->args = arg;
169
170 UT_LIST_ADD_LAST(func_node_list, pars_sym_tab_global->func_node_list,
171 node);
172 return(node);
173}
174
175/*********************************************************************/
178UNIV_INTERN
179func_node_t*
181/*======*/
182 que_node_t* res_word,
183 que_node_t* arg)
184{
185 return(pars_func_low(((pars_res_word_t*)res_word)->code, arg));
186}
187
188/*********************************************************************/
191UNIV_INTERN
192func_node_t*
194/*====*/
195 int func,
196 que_node_t* arg1,
197 que_node_t* arg2)
199{
200 que_node_list_add_last(NULL, arg1);
201
202 if (arg2) {
203 que_node_list_add_last(arg1, arg2);
204 }
205
206 return(pars_func_low(func, arg1));
207}
208
209/*********************************************************************/
212UNIV_INTERN
213order_node_t*
215/*==========*/
216 sym_node_t* column,
217 pars_res_word_t* asc)
218{
219 order_node_t* node;
220
221 node = static_cast<order_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(order_node_t)));
222
223 node->common.type = QUE_NODE_ORDER;
224
225 node->column = column;
226
227 if (asc == &pars_asc_token) {
228 node->asc = TRUE;
229 } else {
230 ut_a(asc == &pars_desc_token);
231 node->asc = FALSE;
232 }
233
234 return(node);
235}
236
237/*********************************************************************/
241static
242ibool
243pars_is_string_type(
244/*================*/
245 ulint mtype)
246{
247 switch (mtype) {
248 case DATA_VARCHAR: case DATA_CHAR:
249 case DATA_FIXBINARY: case DATA_BINARY:
250 return(TRUE);
251 }
252
253 return(FALSE);
254}
255
256/*********************************************************************/
259static
260void
261pars_resolve_func_data_type(
262/*========================*/
263 func_node_t* node)
264{
265 que_node_t* arg;
266
267 ut_a(que_node_get_type(node) == QUE_NODE_FUNC);
268
269 arg = node->args;
270
271 switch (node->func) {
272 case PARS_SUM_TOKEN:
273 case '+': case '-': case '*': case '/':
274 /* Inherit the data type from the first argument (which must
275 not be the SQL null literal whose type is DATA_ERROR) */
276
279
281 == DATA_INT);
282 break;
283
284 case PARS_COUNT_TOKEN:
285 ut_a(arg);
286 dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
287 break;
288
289 case PARS_TO_CHAR_TOKEN:
290 case PARS_RND_STR_TOKEN:
292 dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
293 DATA_ENGLISH, 0);
294 break;
295
296 case PARS_TO_BINARY_TOKEN:
297 if (dtype_get_mtype(que_node_get_data_type(arg)) == DATA_INT) {
298 dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
299 DATA_ENGLISH, 0);
300 } else {
301 dtype_set(que_node_get_data_type(node), DATA_BINARY,
302 0, 0);
303 }
304 break;
305
306 case PARS_TO_NUMBER_TOKEN:
307 case PARS_BINARY_TO_NUMBER_TOKEN:
308 case PARS_LENGTH_TOKEN:
309 case PARS_INSTR_TOKEN:
310 ut_a(pars_is_string_type(que_node_get_data_type(arg)->mtype));
311 dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
312 break;
313
314 case PARS_SYSDATE_TOKEN:
315 ut_a(arg == NULL);
316 dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
317 break;
318
319 case PARS_SUBSTR_TOKEN:
320 case PARS_CONCAT_TOKEN:
321 ut_a(pars_is_string_type(que_node_get_data_type(arg)->mtype));
322 dtype_set(que_node_get_data_type(node), DATA_VARCHAR,
323 DATA_ENGLISH, 0);
324 break;
325
326 case '>': case '<': case '=':
327 case PARS_GE_TOKEN:
328 case PARS_LE_TOKEN:
329 case PARS_NE_TOKEN:
330 case PARS_AND_TOKEN:
331 case PARS_OR_TOKEN:
332 case PARS_NOT_TOKEN:
333 case PARS_NOTFOUND_TOKEN:
334
335 /* We currently have no iboolean type: use integer type */
336 dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
337 break;
338
339 case PARS_RND_TOKEN:
341 dtype_set(que_node_get_data_type(node), DATA_INT, 0, 4);
342 break;
343
344 default:
345 ut_error;
346 }
347}
348
349/*********************************************************************/
352static
353void
354pars_resolve_exp_variables_and_types(
355/*=================================*/
356 sel_node_t* select_node,
360 que_node_t* exp_node)
361{
362 func_node_t* func_node;
363 que_node_t* arg;
364 sym_node_t* sym_node;
365 sym_node_t* node;
366
367 ut_a(exp_node);
368
369 if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
370 func_node = static_cast<func_node_t *>(exp_node);
371
372 arg = func_node->args;
373
374 while (arg) {
375 pars_resolve_exp_variables_and_types(select_node, arg);
376
377 arg = que_node_get_next(arg);
378 }
379
380 pars_resolve_func_data_type(func_node);
381
382 return;
383 }
384
385 ut_a(que_node_get_type(exp_node) == QUE_NODE_SYMBOL);
386
387 sym_node = static_cast<sym_node_t *>(exp_node);
388
389 if (sym_node->resolved) {
390
391 return;
392 }
393
394 /* Not resolved yet: look in the symbol table for a variable
395 or a cursor or a function with the same name */
396
397 node = UT_LIST_GET_FIRST(pars_sym_tab_global->sym_list);
398
399 while (node) {
400 if (node->resolved
401 && ((node->token_type == SYM_VAR)
402 || (node->token_type == SYM_CURSOR)
403 || (node->token_type == SYM_FUNCTION))
404 && node->name
405 && (sym_node->name_len == node->name_len)
406 && (ut_memcmp(sym_node->name, node->name,
407 node->name_len) == 0)) {
408
409 /* Found a variable or a cursor declared with
410 the same name */
411
412 break;
413 }
414
415 node = UT_LIST_GET_NEXT(sym_list, node);
416 }
417
418 if (!node) {
419 fprintf(stderr, "PARSER ERROR: Unresolved identifier %s\n",
420 sym_node->name);
421 }
422
423 ut_a(node);
424
425 sym_node->resolved = TRUE;
426 sym_node->token_type = SYM_IMPLICIT_VAR;
427 sym_node->alias = node;
428 sym_node->indirection = node;
429
430 if (select_node) {
431 UT_LIST_ADD_LAST(col_var_list, select_node->copy_variables,
432 sym_node);
433 }
434
437}
438
439/*********************************************************************/
443static
444void
445pars_resolve_exp_list_variables_and_types(
446/*======================================*/
447 sel_node_t* select_node,
448 que_node_t* exp_node)
450{
451 while (exp_node) {
452 pars_resolve_exp_variables_and_types(select_node, exp_node);
453
454 exp_node = que_node_get_next(exp_node);
455 }
456}
457
458/*********************************************************************/
460static
461void
462pars_resolve_exp_columns(
463/*=====================*/
464 sym_node_t* table_node,
465 que_node_t* exp_node)
466{
467 func_node_t* func_node;
468 que_node_t* arg;
469 sym_node_t* sym_node;
470 dict_table_t* table;
471 sym_node_t* t_node;
472 ulint n_cols;
473 ulint i;
474
475 ut_a(exp_node);
476
477 if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
478 func_node = static_cast<func_node_t *>(exp_node);
479
480 arg = func_node->args;
481
482 while (arg) {
483 pars_resolve_exp_columns(table_node, arg);
484
485 arg = que_node_get_next(arg);
486 }
487
488 return;
489 }
490
491 ut_a(que_node_get_type(exp_node) == QUE_NODE_SYMBOL);
492
493 sym_node = static_cast<sym_node_t *>(exp_node);
494
495 if (sym_node->resolved) {
496
497 return;
498 }
499
500 /* Not resolved yet: look in the table list for a column with the
501 same name */
502
503 t_node = table_node;
504
505 while (t_node) {
506 table = t_node->table;
507
508 n_cols = dict_table_get_n_cols(table);
509
510 for (i = 0; i < n_cols; i++) {
511 const dict_col_t* col
512 = dict_table_get_nth_col(table, i);
513 const char* col_name
514 = dict_table_get_col_name(table, i);
515
516 if ((sym_node->name_len == ut_strlen(col_name))
517 && (0 == ut_memcmp(sym_node->name, col_name,
518 sym_node->name_len))) {
519 /* Found */
520 sym_node->resolved = TRUE;
521 sym_node->token_type = SYM_COLUMN;
522 sym_node->table = table;
523 sym_node->col_no = i;
524 sym_node->prefetch_buf = NULL;
525
527 col,
528 dfield_get_type(&sym_node
529 ->common.val));
530
531 return;
532 }
533 }
534
535 t_node = static_cast<sym_node_t *>(que_node_get_next(t_node));
536 }
537}
538
539/*********************************************************************/
541static
542void
543pars_resolve_exp_list_columns(
544/*==========================*/
545 sym_node_t* table_node,
546 que_node_t* exp_node)
548{
549 while (exp_node) {
550 pars_resolve_exp_columns(table_node, exp_node);
551
552 exp_node = que_node_get_next(exp_node);
553 }
554}
555
556/*********************************************************************/
558static
559void
560pars_retrieve_table_def(
561/*====================*/
562 sym_node_t* sym_node)
563{
564 const char* table_name;
565
566 ut_a(sym_node);
567 ut_a(que_node_get_type(sym_node) == QUE_NODE_SYMBOL);
568
569 sym_node->resolved = TRUE;
570 sym_node->token_type = SYM_TABLE;
571
572 table_name = (const char*) sym_node->name;
573
574 sym_node->table = dict_table_get_low(table_name);
575
576 ut_a(sym_node->table);
577}
578
579/*********************************************************************/
582static
583ulint
584pars_retrieve_table_list_defs(
585/*==========================*/
586 sym_node_t* sym_node)
587{
588 ulint count = 0;
589
590 if (sym_node == NULL) {
591
592 return(count);
593 }
594
595 while (sym_node) {
596 pars_retrieve_table_def(sym_node);
597
598 count++;
599
600 sym_node = static_cast<sym_node_t *>(que_node_get_next(sym_node));
601 }
602
603 return(count);
604}
605
606/*********************************************************************/
608static
609void
610pars_select_all_columns(
611/*====================*/
612 sel_node_t* select_node)
614{
615 sym_node_t* col_node;
616 sym_node_t* table_node;
617 dict_table_t* table;
618 ulint i;
619
620 select_node->select_list = NULL;
621
622 table_node = select_node->table_list;
623
624 while (table_node) {
625 table = table_node->table;
626
627 for (i = 0; i < dict_table_get_n_user_cols(table); i++) {
628 const char* col_name = dict_table_get_col_name(
629 table, i);
630
631 col_node = sym_tab_add_id(pars_sym_tab_global,
632 (byte*)col_name,
633 ut_strlen(col_name));
634
635 select_node->select_list = que_node_list_add_last(
636 select_node->select_list, col_node);
637 }
638
639 table_node = static_cast<sym_node_t *>(que_node_get_next(table_node));
640 }
641}
642
643/*********************************************************************/
647UNIV_INTERN
648sel_node_t*
650/*=============*/
651 que_node_t* select_list,
652 sym_node_t* into_list)
653{
654 sel_node_t* node;
655
656 node = sel_node_create(pars_sym_tab_global->heap);
657
658 node->select_list = select_list;
659 node->into_list = into_list;
660
661 pars_resolve_exp_list_variables_and_types(NULL, into_list);
662
663 return(node);
664}
665
666/*********************************************************************/
669static
670void
671pars_check_aggregate(
672/*=================*/
673 sel_node_t* select_node)
675{
676 que_node_t* exp_node;
677 func_node_t* func_node;
678 ulint n_nodes = 0;
679 ulint n_aggregate_nodes = 0;
680
681 exp_node = select_node->select_list;
682
683 while (exp_node) {
684
685 n_nodes++;
686
687 if (que_node_get_type(exp_node) == QUE_NODE_FUNC) {
688
689 func_node = static_cast<func_node_t *>(exp_node);
690
691 if (func_node->func_class == PARS_FUNC_AGGREGATE) {
692
693 n_aggregate_nodes++;
694 }
695 }
696
697 exp_node = que_node_get_next(exp_node);
698 }
699
700 if (n_aggregate_nodes > 0) {
701 ut_a(n_nodes == n_aggregate_nodes);
702
703 select_node->is_aggregate = TRUE;
704 } else {
705 select_node->is_aggregate = FALSE;
706 }
707}
708
709/*********************************************************************/
712UNIV_INTERN
713sel_node_t*
715/*==================*/
716 sel_node_t* select_node,
718 sym_node_t* table_list,
719 que_node_t* search_cond,
720 pars_res_word_t* for_update,
721 pars_res_word_t* lock_shared,
722 order_node_t* order_by)
723{
724 select_node->state = SEL_NODE_OPEN;
725
726 select_node->table_list = table_list;
727 select_node->n_tables = pars_retrieve_table_list_defs(table_list);
728
729 if (select_node->select_list == &pars_star_denoter) {
730
731 /* SELECT * FROM ... */
732 pars_select_all_columns(select_node);
733 }
734
735 if (select_node->into_list) {
737 == que_node_list_get_len(select_node->select_list));
738 }
739
740 UT_LIST_INIT(select_node->copy_variables);
741
742 pars_resolve_exp_list_columns(table_list, select_node->select_list);
743 pars_resolve_exp_list_variables_and_types(select_node,
744 select_node->select_list);
745 pars_check_aggregate(select_node);
746
747 select_node->search_cond = search_cond;
748
749 if (search_cond) {
750 pars_resolve_exp_columns(table_list, search_cond);
751 pars_resolve_exp_variables_and_types(select_node, search_cond);
752 }
753
754 if (for_update) {
755 ut_a(!lock_shared);
756
757 select_node->set_x_locks = TRUE;
758 select_node->row_lock_mode = LOCK_X;
759
760 select_node->consistent_read = FALSE;
761 select_node->read_view = NULL;
762 } else if (lock_shared){
763 select_node->set_x_locks = FALSE;
764 select_node->row_lock_mode = LOCK_S;
765
766 select_node->consistent_read = FALSE;
767 select_node->read_view = NULL;
768 } else {
769 select_node->set_x_locks = FALSE;
770 select_node->row_lock_mode = LOCK_S;
771
772 select_node->consistent_read = TRUE;
773 }
774
775 select_node->order_by = order_by;
776
777 if (order_by) {
778 pars_resolve_exp_columns(table_list, order_by->column);
779 }
780
781 /* The final value of the following fields depend on the environment
782 where the select statement appears: */
783
784 select_node->can_get_updated = FALSE;
785 select_node->explicit_cursor = NULL;
786
787 opt_search_plan(select_node);
788
789 return(select_node);
790}
791
792/*********************************************************************/
795UNIV_INTERN
796que_node_t*
798/*====================*/
799 sym_node_t* sym_node,
801 sel_node_t* select_node)
802{
803 sym_node->resolved = TRUE;
804 sym_node->token_type = SYM_CURSOR;
805 sym_node->cursor_def = select_node;
806
807 select_node->state = SEL_NODE_CLOSED;
808 select_node->explicit_cursor = sym_node;
809
810 return(sym_node);
811}
812
813/*********************************************************************/
816UNIV_INTERN
817que_node_t*
819/*======================*/
820 sym_node_t* sym_node)
822{
823 sym_node->resolved = TRUE;
824 sym_node->token_type = SYM_FUNCTION;
825
826 /* Check that the function exists. */
827 ut_a(pars_info_get_user_func(pars_sym_tab_global->info,
828 sym_node->name));
829
830 return(sym_node);
831}
832
833/*********************************************************************/
836UNIV_INTERN
837upd_node_t*
839/*========================*/
840 ibool is_delete,
841 sym_node_t* table_sym,
842 col_assign_node_t* col_assign_list)
844{
845 upd_node_t* node;
846
847 node = upd_node_create(pars_sym_tab_global->heap);
848
849 node->is_delete = is_delete;
850
851 node->table_sym = table_sym;
852 node->col_assign_list = col_assign_list;
853
854 return(node);
855}
856
857/*********************************************************************/
860UNIV_INTERN
861col_assign_node_t*
863/*===================*/
864 sym_node_t* column,
865 que_node_t* exp)
866{
867 col_assign_node_t* node;
868
869 node = static_cast<col_assign_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap,
870 sizeof(col_assign_node_t)));
871 node->common.type = QUE_NODE_COL_ASSIGNMENT;
872
873 node->col = column;
874 node->val = exp;
875
876 return(node);
877}
878
879/*********************************************************************/
881static
882void
883pars_process_assign_list(
884/*=====================*/
885 upd_node_t* node)
886{
887 col_assign_node_t* col_assign_list;
888 sym_node_t* table_sym;
889 col_assign_node_t* assign_node;
890 upd_field_t* upd_field;
891 dict_index_t* clust_index;
892 sym_node_t* col_sym;
893 ulint changes_ord_field;
894 ulint changes_field_size;
895 ulint n_assigns;
896 ulint i;
897
898 table_sym = node->table_sym;
899 col_assign_list = static_cast<col_assign_node_t *>(node->col_assign_list);
900 clust_index = dict_table_get_first_index(node->table);
901
902 assign_node = col_assign_list;
903 n_assigns = 0;
904
905 while (assign_node) {
906 pars_resolve_exp_columns(table_sym, assign_node->col);
907 pars_resolve_exp_columns(table_sym, assign_node->val);
908 pars_resolve_exp_variables_and_types(NULL, assign_node->val);
909#if 0
911 dfield_get_type(que_node_get_val(
912 assign_node->col)))
914 dfield_get_type(que_node_get_val(
915 assign_node->val))));
916#endif
917
918 /* Add to the update node all the columns found in assignment
919 values as columns to copy: therefore, TRUE */
920
921 opt_find_all_cols(TRUE, clust_index, &(node->columns), NULL,
922 assign_node->val);
923 n_assigns++;
924
925 assign_node = static_cast<col_assign_node_t *>(que_node_get_next(assign_node));
926 }
927
928 node->update = upd_create(n_assigns, pars_sym_tab_global->heap);
929
930 assign_node = col_assign_list;
931
932 changes_field_size = UPD_NODE_NO_SIZE_CHANGE;
933
934 for (i = 0; i < n_assigns; i++) {
935 upd_field = upd_get_nth_field(node->update, i);
936
937 col_sym = assign_node->col;
938
939 upd_field_set_field_no(upd_field, dict_index_get_nth_col_pos(
940 clust_index, col_sym->col_no),
941 clust_index, NULL);
942 upd_field->exp = assign_node->val;
943
945 dict_index_get_nth_col(clust_index,
946 upd_field->field_no),
947 dict_table_is_comp(node->table))) {
948 changes_field_size = 0;
949 }
950
951 assign_node = static_cast<col_assign_node_t *>(que_node_get_next(assign_node));
952 }
953
954 /* Find out if the update can modify an ordering field in any index */
955
956 changes_ord_field = UPD_NODE_NO_ORD_CHANGE;
957
959 node->update)) {
960 changes_ord_field = 0;
961 }
962
963 node->cmpl_info = changes_ord_field | changes_field_size;
964}
965
966/*********************************************************************/
969UNIV_INTERN
970upd_node_t*
972/*==================*/
973 upd_node_t* node,
974 sym_node_t* cursor_sym,
976 que_node_t* search_cond)
977{
978 sym_node_t* table_sym;
979 sel_node_t* sel_node;
980 plan_t* plan;
981
982 table_sym = node->table_sym;
983
984 pars_retrieve_table_def(table_sym);
985 node->table = table_sym->table;
986
987 UT_LIST_INIT(node->columns);
988
989 /* Make the single table node into a list of table nodes of length 1 */
990
991 que_node_list_add_last(NULL, table_sym);
992
993 if (cursor_sym) {
994 pars_resolve_exp_variables_and_types(NULL, cursor_sym);
995
996 sel_node = cursor_sym->alias->cursor_def;
997
998 node->searched_update = FALSE;
999 } else {
1000 sel_node = pars_select_list(NULL, NULL);
1001
1002 pars_select_statement(sel_node, table_sym, search_cond, NULL,
1003 &pars_share_token, NULL);
1004 node->searched_update = TRUE;
1005 sel_node->common.parent = node;
1006 }
1007
1008 node->select = sel_node;
1009
1010 ut_a(!node->is_delete || (node->col_assign_list == NULL));
1011 ut_a(node->is_delete || (node->col_assign_list != NULL));
1012
1013 if (node->is_delete) {
1014 node->cmpl_info = 0;
1015 } else {
1016 pars_process_assign_list(node);
1017 }
1018
1019 if (node->searched_update) {
1020 node->has_clust_rec_x_lock = TRUE;
1021 sel_node->set_x_locks = TRUE;
1022 sel_node->row_lock_mode = LOCK_X;
1023 } else {
1024 node->has_clust_rec_x_lock = sel_node->set_x_locks;
1025 }
1026
1027 ut_a(sel_node->n_tables == 1);
1028 ut_a(sel_node->consistent_read == FALSE);
1029 ut_a(sel_node->order_by == NULL);
1030 ut_a(sel_node->is_aggregate == FALSE);
1031
1032 sel_node->can_get_updated = TRUE;
1033
1034 node->state = UPD_NODE_UPDATE_CLUSTERED;
1035
1036 plan = sel_node_get_nth_plan(sel_node, 0);
1037
1038 plan->no_prefetch = TRUE;
1039
1040 if (!dict_index_is_clust(plan->index)) {
1041
1042 plan->must_get_clust = TRUE;
1043
1044 node->pcur = &(plan->clust_pcur);
1045 } else {
1046 node->pcur = &(plan->pcur);
1047 }
1048
1049 return(node);
1050}
1051
1052/*********************************************************************/
1055UNIV_INTERN
1056ins_node_t*
1058/*==================*/
1059 sym_node_t* table_sym,
1060 que_node_t* values_list,
1061 sel_node_t* select)
1062{
1063 ins_node_t* node;
1064 dtuple_t* row;
1065 ulint ins_type;
1066
1067 ut_a(values_list || select);
1068 ut_a(!values_list || !select);
1069
1070 if (values_list) {
1071 ins_type = INS_VALUES;
1072 } else {
1073 ins_type = INS_SEARCHED;
1074 }
1075
1076 pars_retrieve_table_def(table_sym);
1077
1078 node = ins_node_create(ins_type, table_sym->table,
1079 pars_sym_tab_global->heap);
1080
1081 row = dtuple_create(pars_sym_tab_global->heap,
1083
1084 dict_table_copy_types(row, table_sym->table);
1085
1086 ins_node_set_new_row(node, row);
1087
1088 node->select = select;
1089
1090 if (select) {
1091 select->common.parent = node;
1092
1094 == dict_table_get_n_user_cols(table_sym->table));
1095 }
1096
1097 node->values_list = values_list;
1098
1099 if (node->values_list) {
1100 pars_resolve_exp_list_variables_and_types(NULL, values_list);
1101
1102 ut_a(que_node_list_get_len(values_list)
1103 == dict_table_get_n_user_cols(table_sym->table));
1104 }
1105
1106 return(node);
1107}
1108
1109/*********************************************************************/
1111static
1112void
1113pars_set_dfield_type(
1114/*=================*/
1115 dfield_t* dfield,
1116 pars_res_word_t* type,
1118 ulint len,
1119 ibool is_unsigned,
1121 ibool is_not_null)
1123{
1124 ulint flags = 0;
1125
1126 if (is_not_null) {
1127 flags |= DATA_NOT_NULL;
1128 }
1129
1130 if (is_unsigned) {
1131 flags |= DATA_UNSIGNED;
1132 }
1133
1134 if (type == &pars_int_token) {
1135 ut_a((len == 0) || (len == 8));
1136 if (len == 8) {
1137 dtype_set(dfield_get_type(dfield), DATA_INT, flags, 8);
1138 } else {
1139 dtype_set(dfield_get_type(dfield), DATA_INT, flags, 4);
1140 }
1141
1142 } else if (type == &pars_char_token) {
1143 ut_a(len == 0);
1144
1145 dtype_set(dfield_get_type(dfield), DATA_VARCHAR,
1146 DATA_ENGLISH | flags, 0);
1147 } else if (type == &pars_binary_token) {
1148 ut_a(len != 0);
1149
1150 dtype_set(dfield_get_type(dfield), DATA_FIXBINARY,
1151 DATA_BINARY_TYPE | flags, len);
1152 } else if (type == &pars_blob_token) {
1153 ut_a(len == 0);
1154
1155 dtype_set(dfield_get_type(dfield), DATA_BLOB,
1156 DATA_BINARY_TYPE | flags, 0);
1157 } else {
1158 ut_error;
1159 }
1160}
1161
1162/*********************************************************************/
1165UNIV_INTERN
1166sym_node_t*
1168/*======================*/
1169 sym_node_t* node,
1171 pars_res_word_t* type)
1172{
1173 node->resolved = TRUE;
1174 node->token_type = SYM_VAR;
1175
1176 node->param_type = PARS_NOT_PARAM;
1177
1178 pars_set_dfield_type(que_node_get_val(node), type, 0, FALSE, FALSE);
1179
1180 return(node);
1181}
1182
1183/*********************************************************************/
1186UNIV_INTERN
1187sym_node_t*
1189/*=======================*/
1190 sym_node_t* node,
1192 ulint param_type,
1194 pars_res_word_t* type)
1195{
1196 ut_a((param_type == PARS_INPUT) || (param_type == PARS_OUTPUT));
1197
1198 pars_variable_declaration(node, type);
1199
1200 node->param_type = param_type;
1201
1202 return(node);
1203}
1204
1205/*********************************************************************/
1207static
1208void
1209pars_set_parent_in_list(
1210/*====================*/
1211 que_node_t* node_list,
1212 que_node_t* parent)
1214{
1215 que_common_t* common;
1216
1217 common = static_cast<que_common_t *>(node_list);
1218
1219 while (common) {
1220 common->parent = parent;
1221
1222 common = static_cast<que_common_t *>(que_node_get_next(common));
1223 }
1224}
1225
1226/*********************************************************************/
1229UNIV_INTERN
1230elsif_node_t*
1232/*===============*/
1233 que_node_t* cond,
1234 que_node_t* stat_list)
1235{
1236 elsif_node_t* node;
1237
1238 node = static_cast<elsif_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(elsif_node_t)));
1239
1240 node->common.type = QUE_NODE_ELSIF;
1241
1242 node->cond = cond;
1243
1244 pars_resolve_exp_variables_and_types(NULL, cond);
1245
1246 node->stat_list = stat_list;
1247
1248 return(node);
1249}
1250
1251/*********************************************************************/
1254UNIV_INTERN
1255if_node_t*
1257/*==============*/
1258 que_node_t* cond,
1259 que_node_t* stat_list,
1260 que_node_t* else_part)
1262{
1263 if_node_t* node;
1264 elsif_node_t* elsif_node;
1265
1266 node = static_cast<if_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(if_node_t)));
1267
1268 node->common.type = QUE_NODE_IF;
1269
1270 node->cond = cond;
1271
1272 pars_resolve_exp_variables_and_types(NULL, cond);
1273
1274 node->stat_list = stat_list;
1275
1276 if (else_part && (que_node_get_type(else_part) == QUE_NODE_ELSIF)) {
1277
1278 /* There is a list of elsif conditions */
1279
1280 node->else_part = NULL;
1281 node->elsif_list = static_cast<elsif_node_t *>(else_part);
1282
1283 elsif_node = static_cast<elsif_node_t *>(else_part);
1284
1285 while (elsif_node) {
1286 pars_set_parent_in_list(elsif_node->stat_list, node);
1287
1288 elsif_node = static_cast<elsif_node_t *>(que_node_get_next(elsif_node));
1289 }
1290 } else {
1291 node->else_part = else_part;
1292 node->elsif_list = NULL;
1293
1294 pars_set_parent_in_list(else_part, node);
1295 }
1296
1297 pars_set_parent_in_list(stat_list, node);
1298
1299 return(node);
1300}
1301
1302/*********************************************************************/
1305UNIV_INTERN
1306while_node_t*
1308/*=================*/
1309 que_node_t* cond,
1310 que_node_t* stat_list)
1311{
1312 while_node_t* node;
1313
1314 node = static_cast<while_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(while_node_t)));
1315
1316 node->common.type = QUE_NODE_WHILE;
1317
1318 node->cond = cond;
1319
1320 pars_resolve_exp_variables_and_types(NULL, cond);
1321
1322 node->stat_list = stat_list;
1323
1324 pars_set_parent_in_list(stat_list, node);
1325
1326 return(node);
1327}
1328
1329/*********************************************************************/
1332UNIV_INTERN
1333for_node_t*
1335/*===============*/
1336 sym_node_t* loop_var,
1337 que_node_t* loop_start_limit,
1338 que_node_t* loop_end_limit,
1339 que_node_t* stat_list)
1340{
1341 for_node_t* node;
1342
1343 node = static_cast<for_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(for_node_t)));
1344
1345 node->common.type = QUE_NODE_FOR;
1346
1347 pars_resolve_exp_variables_and_types(NULL, loop_var);
1348 pars_resolve_exp_variables_and_types(NULL, loop_start_limit);
1349 pars_resolve_exp_variables_and_types(NULL, loop_end_limit);
1350
1351 node->loop_var = loop_var->indirection;
1352
1353 ut_a(loop_var->indirection);
1354
1355 node->loop_start_limit = loop_start_limit;
1356 node->loop_end_limit = loop_end_limit;
1357
1358 node->stat_list = stat_list;
1359
1360 pars_set_parent_in_list(stat_list, node);
1361
1362 return(node);
1363}
1364
1365/*********************************************************************/
1368UNIV_INTERN
1369exit_node_t*
1371/*=====================*/
1372{
1373 exit_node_t* node;
1374
1375 node = static_cast<exit_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(exit_node_t)));
1376 node->common.type = QUE_NODE_EXIT;
1377
1378 return(node);
1379}
1380
1381/*********************************************************************/
1384UNIV_INTERN
1385return_node_t*
1387/*=======================*/
1388{
1389 return_node_t* node;
1390
1391 node = static_cast<return_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap,
1392 sizeof(return_node_t)));
1393 node->common.type = QUE_NODE_RETURN;
1394
1395 return(node);
1396}
1397
1398/*********************************************************************/
1401UNIV_INTERN
1402assign_node_t*
1404/*======================*/
1405 sym_node_t* var,
1406 que_node_t* val)
1407{
1408 assign_node_t* node;
1409
1410 node = static_cast<assign_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap,
1411 sizeof(assign_node_t)));
1412 node->common.type = QUE_NODE_ASSIGNMENT;
1413
1414 node->var = var;
1415 node->val = val;
1416
1417 pars_resolve_exp_variables_and_types(NULL, var);
1418 pars_resolve_exp_variables_and_types(NULL, val);
1419
1420 ut_a(dtype_get_mtype(dfield_get_type(que_node_get_val(var)))
1421 == dtype_get_mtype(dfield_get_type(que_node_get_val(val))));
1422
1423 return(node);
1424}
1425
1426/*********************************************************************/
1429UNIV_INTERN
1430func_node_t*
1432/*================*/
1433 que_node_t* res_word,
1434 que_node_t* args)
1435{
1436 func_node_t* node;
1437
1438 node = pars_func(res_word, args);
1439
1440 pars_resolve_exp_list_variables_and_types(NULL, args);
1441
1442 return(node);
1443}
1444
1445/*********************************************************************/
1449UNIV_INTERN
1450fetch_node_t*
1452/*=================*/
1453 sym_node_t* cursor,
1454 sym_node_t* into_list,
1455 sym_node_t* user_func)
1456{
1457 sym_node_t* cursor_decl;
1458 fetch_node_t* node;
1459
1460 /* Logical XOR. */
1461 ut_a(!into_list != !user_func);
1462
1463 node = static_cast<fetch_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(fetch_node_t)));
1464
1465 node->common.type = QUE_NODE_FETCH;
1466
1467 pars_resolve_exp_variables_and_types(NULL, cursor);
1468
1469 if (into_list) {
1470 pars_resolve_exp_list_variables_and_types(NULL, into_list);
1471 node->into_list = into_list;
1472 node->func = NULL;
1473 } else {
1474 pars_resolve_exp_variables_and_types(NULL, user_func);
1475
1476 node->func = pars_info_get_user_func(pars_sym_tab_global->info,
1477 user_func->name);
1478 ut_a(node->func);
1479
1480 node->into_list = NULL;
1481 }
1482
1483 cursor_decl = cursor->alias;
1484
1485 ut_a(cursor_decl->token_type == SYM_CURSOR);
1486
1487 node->cursor_def = cursor_decl->cursor_def;
1488
1489 if (into_list) {
1490 ut_a(que_node_list_get_len(into_list)
1492 }
1493
1494 return(node);
1495}
1496
1497/*********************************************************************/
1500UNIV_INTERN
1501open_node_t*
1503/*================*/
1504 ulint type,
1506 sym_node_t* cursor)
1507{
1508 sym_node_t* cursor_decl;
1509 open_node_t* node;
1510
1511 node = static_cast<open_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap, sizeof(open_node_t)));
1512
1513 node->common.type = QUE_NODE_OPEN;
1514
1515 pars_resolve_exp_variables_and_types(NULL, cursor);
1516
1517 cursor_decl = cursor->alias;
1518
1519 ut_a(cursor_decl->token_type == SYM_CURSOR);
1520
1521 node->op_type = static_cast<open_node_op>(type);
1522 node->cursor_def = cursor_decl->cursor_def;
1523
1524 return(node);
1525}
1526
1527/*********************************************************************/
1530UNIV_INTERN
1531row_printf_node_t*
1533/*======================*/
1534 sel_node_t* sel_node)
1535{
1536 row_printf_node_t* node;
1537
1538 node = static_cast<row_printf_node_t *>(mem_heap_alloc(pars_sym_tab_global->heap,
1539 sizeof(row_printf_node_t)));
1540 node->common.type = QUE_NODE_ROW_PRINTF;
1541
1542 node->sel_node = sel_node;
1543
1544 sel_node->common.parent = node;
1545
1546 return(node);
1547}
1548
1549/*********************************************************************/
1552UNIV_INTERN
1555/*=======================*/
1556{
1557 return(commit_node_create(pars_sym_tab_global->heap));
1558}
1559
1560/*********************************************************************/
1563UNIV_INTERN
1566/*=========================*/
1567{
1568 return(roll_node_create(pars_sym_tab_global->heap));
1569}
1570
1571/*********************************************************************/
1574UNIV_INTERN
1575sym_node_t*
1577/*============*/
1578 sym_node_t* sym_node,
1580 pars_res_word_t* type,
1581 sym_node_t* len,
1583 void* is_unsigned,
1585 void* is_not_null)
1587{
1588 ulint len2;
1589
1590 if (len) {
1591 len2 = eval_node_get_int_val(len);
1592 } else {
1593 len2 = 0;
1594 }
1595
1596 pars_set_dfield_type(que_node_get_val(sym_node), type, len2,
1597 is_unsigned != NULL, is_not_null != NULL);
1598
1599 return(sym_node);
1600}
1601
1602/*********************************************************************/
1605UNIV_INTERN
1606tab_node_t*
1608/*==============*/
1609 sym_node_t* table_sym,
1611 sym_node_t* column_defs,
1612 void* /*not_fit_in_memory __attribute__((unused))*/)
1623{
1624 dict_table_t* table;
1625 sym_node_t* column;
1626 tab_node_t* node;
1627 const dtype_t* dtype;
1628 ulint n_cols;
1629
1630 n_cols = que_node_list_get_len(column_defs);
1631
1632 /* As the InnoDB SQL parser is for internal use only,
1633 for creating some system tables, this function will only
1634 create tables in the old (not compact) record format. */
1635 table = dict_mem_table_create(table_sym->name, 0, n_cols, 0);
1636
1637#ifdef UNIV_DEBUG
1638 if (not_fit_in_memory != NULL) {
1639 table->does_not_fit_in_memory = TRUE;
1640 }
1641#endif /* UNIV_DEBUG */
1642 column = column_defs;
1643
1644 while (column) {
1645 dtype = dfield_get_type(que_node_get_val(column));
1646
1647 dict_mem_table_add_col(table, table->heap,
1648 column->name, dtype->mtype,
1649 dtype->prtype, dtype->len);
1650 column->resolved = TRUE;
1651 column->token_type = SYM_COLUMN;
1652
1653 column = static_cast<sym_node_t *>(que_node_get_next(column));
1654 }
1655
1656 node = tab_create_graph_create(table, pars_sym_tab_global->heap);
1657
1658 table_sym->resolved = TRUE;
1659 table_sym->token_type = SYM_TABLE;
1660
1661 return(node);
1662}
1663
1664/*********************************************************************/
1667UNIV_INTERN
1668ind_node_t*
1670/*==============*/
1671 pars_res_word_t* unique_def,
1672 pars_res_word_t* clustered_def,
1673 sym_node_t* index_sym,
1675 sym_node_t* table_sym,
1677 sym_node_t* column_list)
1678{
1679 dict_index_t* index;
1680 sym_node_t* column;
1681 ind_node_t* node;
1682 ulint n_fields;
1683 ulint ind_type;
1684
1685 n_fields = que_node_list_get_len(column_list);
1686
1687 ind_type = 0;
1688
1689 if (unique_def) {
1690 ind_type = ind_type | DICT_UNIQUE;
1691 }
1692
1693 if (clustered_def) {
1694 ind_type = ind_type | DICT_CLUSTERED;
1695 }
1696
1697 index = dict_mem_index_create(table_sym->name, index_sym->name, 0,
1698 ind_type, n_fields);
1699 column = column_list;
1700
1701 while (column) {
1702 dict_mem_index_add_field(index, column->name, 0);
1703
1704 column->resolved = TRUE;
1705 column->token_type = SYM_COLUMN;
1706
1707 column = static_cast<sym_node_t *>(que_node_get_next(column));
1708 }
1709
1710 node = ind_create_graph_create(index, pars_sym_tab_global->heap);
1711
1712 table_sym->resolved = TRUE;
1713 table_sym->token_type = SYM_TABLE;
1714
1715 index_sym->resolved = TRUE;
1716 index_sym->token_type = SYM_TABLE;
1717
1718 return(node);
1719}
1720
1721/*********************************************************************/
1724UNIV_INTERN
1725que_fork_t*
1727/*======================*/
1728 sym_node_t* sym_node,
1730 sym_node_t* param_list,
1731 que_node_t* stat_list)
1732{
1733 proc_node_t* node;
1734 que_fork_t* fork;
1735 que_thr_t* thr;
1736 mem_heap_t* heap;
1737
1738 heap = pars_sym_tab_global->heap;
1739
1740 fork = que_fork_create(NULL, NULL, QUE_FORK_PROCEDURE, heap);
1741 fork->trx = NULL;
1742
1743 thr = que_thr_create(fork, heap);
1744
1745 node = static_cast<proc_node_t *>(mem_heap_alloc(heap, sizeof(proc_node_t)));
1746
1747 node->common.type = QUE_NODE_PROC;
1748 node->common.parent = thr;
1749
1750 sym_node->token_type = SYM_PROCEDURE_NAME;
1751 sym_node->resolved = TRUE;
1752
1753 node->proc_id = sym_node;
1754 node->param_list = param_list;
1755 node->stat_list = stat_list;
1756
1757 pars_set_parent_in_list(stat_list, node);
1758
1759 node->sym_tab = pars_sym_tab_global;
1760
1761 thr->child = node;
1762
1763 pars_sym_tab_global->query_graph = fork;
1764
1765 return(fork);
1766}
1767
1768/*************************************************************/
1774UNIV_INTERN
1775que_fork_t*
1777/*=======================*/
1778 sym_node_t* /*sym_node __attribute__((unused))*/)
1780{
1781 ut_error;
1782 return(NULL);
1783}
1784
1785/*************************************************************/
1787#ifdef __cplusplus
1788extern "C"
1789#endif
1790UNIV_INTERN
1791void
1793/*===============*/
1794 char* buf,
1795 int* result,
1796 int max_size)
1798{
1799 int len;
1800
1801 len = pars_sym_tab_global->string_len
1802 - pars_sym_tab_global->next_char_pos;
1803 if (len == 0) {
1804#ifdef YYDEBUG
1805 /* fputs("SQL string ends\n", stderr); */
1806#endif
1807 *result = 0;
1808
1809 return;
1810 }
1811
1812 if (len > max_size) {
1813 len = max_size;
1814 }
1815
1816#ifdef UNIV_SQL_DEBUG
1817 if (pars_print_lexed) {
1818
1819 if (len >= 5) {
1820 len = 5;
1821 }
1822
1823 fwrite(pars_sym_tab_global->sql_string
1824 + pars_sym_tab_global->next_char_pos,
1825 1, len, stderr);
1826 }
1827#endif /* UNIV_SQL_DEBUG */
1828
1829 ut_memcpy(buf, pars_sym_tab_global->sql_string
1830 + pars_sym_tab_global->next_char_pos, len);
1831 *result = len;
1832
1833 pars_sym_tab_global->next_char_pos += len;
1834}
1835
1836/*************************************************************/
1838UNIV_INTERN
1839void
1841/*====*/
1842 const char* /*s __attribute__((unused))*/)
1844{
1845 ut_ad(s);
1846
1847 fputs("PARSER ERROR: Syntax error in SQL string\n", stderr);
1848
1849 ut_error;
1850}
1851
1852/*************************************************************/
1855UNIV_INTERN
1856que_t*
1858/*=====*/
1859 pars_info_t* info,
1860 const char* str)
1861{
1862 sym_node_t* sym_node;
1863 mem_heap_t* heap;
1864 que_t* graph;
1865
1866 ut_ad(str);
1867
1868 heap = mem_heap_create(256);
1869
1870 /* Currently, the parser is not reentrant: */
1871 ut_ad(mutex_own(&(dict_sys->mutex)));
1872
1873 pars_sym_tab_global = sym_tab_create(heap);
1874
1875 pars_sym_tab_global->string_len = strlen(str);
1876 pars_sym_tab_global->sql_string = static_cast<const char *>(mem_heap_dup(
1877 heap, str, pars_sym_tab_global->string_len + 1));
1878 pars_sym_tab_global->next_char_pos = 0;
1879 pars_sym_tab_global->info = info;
1880
1881 innodb_parse();
1882
1883 sym_node = UT_LIST_GET_FIRST(pars_sym_tab_global->sym_list);
1884
1885 while (sym_node) {
1886 ut_a(sym_node->resolved);
1887
1888 sym_node = UT_LIST_GET_NEXT(sym_list, sym_node);
1889 }
1890
1891 graph = pars_sym_tab_global->query_graph;
1892
1893 graph->sym_tab = pars_sym_tab_global;
1894 graph->info = info;
1895
1896 /* fprintf(stderr, "SQL graph size %lu\n", mem_heap_get_size(heap)); */
1897
1898 return(graph);
1899}
1900
1901/******************************************************************/
1906UNIV_INTERN
1907que_thr_t*
1909/*=========================*/
1910 que_node_t* node,
1912 trx_t* trx,
1913 mem_heap_t* heap)
1914{
1915 que_fork_t* fork;
1916 que_thr_t* thr;
1917
1918 fork = que_fork_create(NULL, NULL, QUE_FORK_MYSQL_INTERFACE, heap);
1919 fork->trx = trx;
1920
1921 thr = que_thr_create(fork, heap);
1922
1923 thr->child = node;
1924
1925 que_node_set_parent(node, thr);
1926
1927 trx->graph = NULL;
1928
1929 return(thr);
1930}
1931
1932/****************************************************************/
1935UNIV_INTERN
1936pars_info_t*
1938/*==================*/
1939{
1940 pars_info_t* info;
1941 mem_heap_t* heap;
1942
1943 heap = mem_heap_create(512);
1944
1945 info = static_cast<pars_info_t *>(mem_heap_alloc(heap, sizeof(*info)));
1946
1947 info->heap = heap;
1948 info->funcs = NULL;
1949 info->bound_lits = NULL;
1950 info->bound_ids = NULL;
1951 info->graph_owns_us = TRUE;
1952
1953 return(info);
1954}
1955
1956/****************************************************************/
1958UNIV_INTERN
1959void
1961/*===========*/
1962 pars_info_t* info)
1963{
1964 mem_heap_free(info->heap);
1965}
1966
1967/****************************************************************/
1969UNIV_INTERN
1970void
1972/*==================*/
1973 pars_info_t* info,
1974 const char* name,
1975 const void* address,
1976 ulint length,
1977 ulint type,
1978 ulint prtype)
1980{
1981 pars_bound_lit_t* pbl;
1982
1983 ut_ad(!pars_info_get_bound_lit(info, name));
1984
1985 pbl = static_cast<pars_bound_lit_t *>(mem_heap_alloc(info->heap, sizeof(*pbl)));
1986
1987 pbl->name = name;
1988 pbl->address = address;
1989 pbl->length = length;
1990 pbl->type = type;
1991 pbl->prtype = prtype;
1992
1993 if (!info->bound_lits) {
1994 info->bound_lits = ib_vector_create(info->heap, 8);
1995 }
1996
1997 ib_vector_push(info->bound_lits, pbl);
1998}
1999
2000/****************************************************************/
2003UNIV_INTERN
2004void
2006/*======================*/
2007 pars_info_t* info,
2008 const char* name,
2009 const char* str)
2010{
2011 pars_info_add_literal(info, name, str, strlen(str),
2012 DATA_VARCHAR, DATA_ENGLISH);
2013}
2014
2015/****************************************************************/
2024UNIV_INTERN
2025void
2027/*=======================*/
2028 pars_info_t* info,
2029 const char* name,
2030 lint val)
2031{
2032 byte* buf = static_cast<byte *>(mem_heap_alloc(info->heap, 4));
2033
2034 mach_write_to_4(buf, val);
2035 pars_info_add_literal(info, name, buf, 4, DATA_INT, 0);
2036}
2037
2038/****************************************************************/
2047UNIV_INTERN
2048void
2050/*======================*/
2051 pars_info_t* info,
2052 const char* name,
2053 ib_uint64_t val)
2054{
2055 byte* buf = static_cast<byte *>(mem_heap_alloc(info->heap, 8));
2056
2057 mach_write_to_8(buf, val);
2058
2059 pars_info_add_literal(info, name, buf, 8, DATA_FIXBINARY, 0);
2060}
2061
2062/****************************************************************/
2064UNIV_INTERN
2065void
2067/*===================*/
2068 pars_info_t* info,
2069 const char* name,
2070 pars_user_func_cb_t func,
2071 void* arg)
2072{
2073 pars_user_func_t* puf;
2074
2075 ut_ad(!pars_info_get_user_func(info, name));
2076
2077 puf = static_cast<pars_user_func_t *>(mem_heap_alloc(info->heap, sizeof(*puf)));
2078
2079 puf->name = name;
2080 puf->func = func;
2081 puf->arg = arg;
2082
2083 if (!info->funcs) {
2084 info->funcs = ib_vector_create(info->heap, 8);
2085 }
2086
2087 ib_vector_push(info->funcs, puf);
2088}
2089
2090/****************************************************************/
2092UNIV_INTERN
2093void
2095/*=============*/
2096 pars_info_t* info,
2097 const char* name,
2098 const char* id)
2099{
2100 pars_bound_id_t* bid;
2101
2102 ut_ad(!pars_info_get_bound_id(info, name));
2103
2104 bid = static_cast<pars_bound_id_t *>(mem_heap_alloc(info->heap, sizeof(*bid)));
2105
2106 bid->name = name;
2107 bid->id = id;
2108
2109 if (!info->bound_ids) {
2110 info->bound_ids = ib_vector_create(info->heap, 8);
2111 }
2112
2113 ib_vector_push(info->bound_ids, bid);
2114}
2115
2116/****************************************************************/
2119UNIV_INTERN
2120pars_user_func_t*
2122/*====================*/
2123 pars_info_t* info,
2124 const char* name)
2125{
2126 ulint i;
2127 ib_vector_t* vec;
2128
2129 if (!info || !info->funcs) {
2130 return(NULL);
2131 }
2132
2133 vec = info->funcs;
2134
2135 for (i = 0; i < ib_vector_size(vec); i++) {
2136 pars_user_func_t* puf = static_cast<pars_user_func_t *>(ib_vector_get(vec, i));
2137
2138 if (strcmp(puf->name, name) == 0) {
2139 return(puf);
2140 }
2141 }
2142
2143 return(NULL);
2144}
2145
2146/****************************************************************/
2149UNIV_INTERN
2150pars_bound_lit_t*
2152/*====================*/
2153 pars_info_t* info,
2154 const char* name)
2155{
2156 ulint i;
2157 ib_vector_t* vec;
2158
2159 if (!info || !info->bound_lits) {
2160 return(NULL);
2161 }
2162
2163 vec = info->bound_lits;
2164
2165 for (i = 0; i < ib_vector_size(vec); i++) {
2166 pars_bound_lit_t* pbl = static_cast<pars_bound_lit_t *>(ib_vector_get(vec, i));
2167
2168 if (strcmp(pbl->name, name) == 0) {
2169 return(pbl);
2170 }
2171 }
2172
2173 return(NULL);
2174}
2175
2176/****************************************************************/
2179UNIV_INTERN
2180pars_bound_id_t*
2182/*===================*/
2183 pars_info_t* info,
2184 const char* name)
2185{
2186 ulint i;
2187 ib_vector_t* vec;
2188
2189 if (!info || !info->bound_ids) {
2190 return(NULL);
2191 }
2192
2193 vec = info->bound_ids;
2194
2195 for (i = 0; i < ib_vector_size(vec); i++) {
2196 pars_bound_id_t* bid = static_cast<pars_bound_id_t *>(ib_vector_get(vec, i));
2197
2198 if (strcmp(bid->name, name) == 0) {
2199 return(bid);
2200 }
2201 }
2202
2203 return(NULL);
2204}
UNIV_INLINE void dfield_set_data(dfield_t *field, const void *data, ulint len)
UNIV_INLINE dtuple_t * dtuple_create(mem_heap_t *heap, ulint n_fields)
UNIV_INLINE void dfield_set_type(dfield_t *field, dtype_t *type)
UNIV_INLINE void dtype_set(dtype_t *type, ulint mtype, ulint prtype, ulint len)
UNIV_INLINE ulint dtype_get_mtype(const dtype_t *type)
UNIV_INLINE void dtype_copy(dtype_t *type1, const dtype_t *type2)
UNIV_INLINE const dict_col_t * dict_index_get_nth_col(const dict_index_t *index, ulint pos)
UNIV_INLINE ulint dict_col_get_fixed_size(const dict_col_t *col, ulint comp)
UNIV_INLINE ulint dict_index_is_clust(const dict_index_t *index) __attribute__((pure))
UNIV_INLINE dict_table_t * dict_table_get_low(const char *table_name)
UNIV_INLINE ulint dict_table_get_n_user_cols(const dict_table_t *table)
UNIV_INLINE ulint dict_table_get_n_cols(const dict_table_t *table)
UNIV_INLINE void dict_col_copy_type(const dict_col_t *col, dtype_t *type)
UNIV_INLINE ibool dict_table_is_comp(const dict_table_t *table)
#define DICT_UNIQUE
Definition dict0mem.h:52
#define DICT_CLUSTERED
Definition dict0mem.h:51
UNIV_INLINE lint eval_node_get_int_val(que_node_t *node)
UNIV_INLINE void mach_write_to_8(byte *b, ib_uint64_t n)
UNIV_INLINE void mach_write_to_4(byte *b, ulint n)
#define mem_heap_create(N)
Definition mem0mem.h:91
UNIV_INTERN void * mem_heap_dup(mem_heap_t *heap, const void *data, ulint len)
Definition mem0mem.cc:117
UNIV_INLINE void * mem_heap_alloc(mem_heap_t *heap, ulint n)
#define mem_heap_free(heap)
Definition mem0mem.h:111
UNIV_INTERN void opt_search_plan(sel_node_t *sel_node)
Definition pars0opt.cc:1103
UNIV_INTERN void opt_find_all_cols(ibool copy_val, dict_index_t *index, sym_node_list_t *col_list, plan_t *plan, que_node_t *exp)
Definition pars0opt.cc:833
UNIV_INTERN que_node_t * pars_cursor_declaration(sym_node_t *sym_node, sel_node_t *select_node)
Definition pars0pars.cc:797
#define PARS_FUNC_OTHER
Definition pars0pars.h:744
UNIV_INTERN void pars_info_add_id(pars_info_t *info, const char *name, const char *id)
UNIV_INTERN ind_node_t * pars_create_index(pars_res_word_t *unique_def, pars_res_word_t *clustered_def, sym_node_t *index_sym, sym_node_t *table_sym, sym_node_t *column_list)
UNIV_INTERN void pars_info_add_str_literal(pars_info_t *info, const char *name, const char *str)
ulint pars_star_denoter
Definition pars0pars.cc:98
UNIV_INTERN pars_info_t * pars_info_create(void)
UNIV_INTERN upd_node_t * pars_update_statement_start(ibool is_delete, sym_node_t *table_sym, col_assign_node_t *col_assign_list)
Definition pars0pars.cc:838
UNIV_INTERN void pars_info_add_ull_literal(pars_info_t *info, const char *name, ib_uint64_t val)
#define PARS_FUNC_AGGREGATE
Definition pars0pars.h:743
UNIV_INTERN assign_node_t * pars_assignment_statement(sym_node_t *var, que_node_t *val)
UNIV_INTERN sym_node_t * pars_parameter_declaration(sym_node_t *node, ulint param_type, pars_res_word_t *type)
UNIV_INTERN func_node_t * pars_op(int func, que_node_t *arg1, que_node_t *arg2)
Definition pars0pars.cc:193
UNIV_INTERN void yyerror(const char *s)
UNIV_INTERN sym_node_t * pars_variable_declaration(sym_node_t *node, pars_res_word_t *type)
#define PARS_FUNC_LOGICAL
Definition pars0pars.h:740
UNIV_INTERN exit_node_t * pars_exit_statement(void)
UNIV_INTERN open_node_t * pars_open_statement(ulint type, sym_node_t *cursor)
UNIV_INTERN void pars_info_free(pars_info_t *info)
UNIV_INTERN while_node_t * pars_while_statement(que_node_t *cond, que_node_t *stat_list)
UNIV_INTERN pars_bound_id_t * pars_info_get_bound_id(pars_info_t *info, const char *name)
#define PARS_FUNC_CMP
Definition pars0pars.h:741
UNIV_INTERN pars_bound_lit_t * pars_info_get_bound_lit(pars_info_t *info, const char *name)
UNIV_INTERN que_fork_t * pars_stored_procedure_call(sym_node_t *sym_node)
UNIV_INTERN que_fork_t * pars_procedure_definition(sym_node_t *sym_node, sym_node_t *param_list, que_node_t *stat_list)
UNIV_INTERN que_node_t * pars_function_declaration(sym_node_t *sym_node)
Definition pars0pars.cc:818
UNIV_INTERN fetch_node_t * pars_fetch_statement(sym_node_t *cursor, sym_node_t *into_list, sym_node_t *user_func)
UNIV_INTERN roll_node_t * pars_rollback_statement(void)
#define PARS_FUNC_ARITH
Definition pars0pars.h:739
UNIV_INTERN func_node_t * pars_func(que_node_t *res_word, que_node_t *arg)
Definition pars0pars.cc:180
UNIV_INTERN upd_node_t * pars_update_statement(upd_node_t *node, sym_node_t *cursor_sym, que_node_t *search_cond)
Definition pars0pars.cc:971
UNIV_INTERN sel_node_t * pars_select_list(que_node_t *select_list, sym_node_t *into_list)
Definition pars0pars.cc:649
UNIV_INTERN commit_node_t * pars_commit_statement(void)
UNIV_INTERN void pars_get_lex_chars(char *buf, int *result, int max_size)
UNIV_INTERN que_thr_t * pars_complete_graph_for_exec(que_node_t *node, trx_t *trx, mem_heap_t *heap)
UNIV_INTERN col_assign_node_t * pars_column_assignment(sym_node_t *column, que_node_t *exp)
Definition pars0pars.cc:862
UNIV_INTERN sel_node_t * pars_select_statement(sel_node_t *select_node, sym_node_t *table_list, que_node_t *search_cond, pars_res_word_t *for_update, pars_res_word_t *consistent_read, order_node_t *order_by)
Definition pars0pars.cc:714
UNIV_INTERN order_node_t * pars_order_by(sym_node_t *column, pars_res_word_t *asc)
Definition pars0pars.cc:214
UNIV_INTERN row_printf_node_t * pars_row_printf_statement(sel_node_t *sel_node)
UNIV_INTERN elsif_node_t * pars_elsif_element(que_node_t *cond, que_node_t *stat_list)
#define PARS_FUNC_PREDEFINED
Definition pars0pars.h:742
UNIV_INTERN if_node_t * pars_if_statement(que_node_t *cond, que_node_t *stat_list, que_node_t *else_part)
UNIV_INTERN void pars_info_add_literal(pars_info_t *info, const char *name, const void *address, ulint length, ulint type, ulint prtype)
UNIV_INTERN void pars_info_add_function(pars_info_t *info, const char *name, pars_user_func_cb_t func, void *arg)
UNIV_INTERN void pars_info_add_int4_literal(pars_info_t *info, const char *name, lint val)
void *(* pars_user_func_cb_t)(void *arg, void *user_arg)
Definition pars0pars.h:42
UNIV_INTERN func_node_t * pars_procedure_call(que_node_t *res_word, que_node_t *args)
UNIV_INTERN que_t * pars_sql(pars_info_t *info, const char *str)
UNIV_INTERN pars_user_func_t * pars_info_get_user_func(pars_info_t *info, const char *name)
UNIV_INTERN tab_node_t * pars_create_table(sym_node_t *table_sym, sym_node_t *column_defs, void *not_fit_in_memory)
UNIV_INTERN for_node_t * pars_for_statement(sym_node_t *loop_var, que_node_t *loop_start_limit, que_node_t *loop_end_limit, que_node_t *stat_list)
UNIV_INTERN sym_node_t * pars_column_def(sym_node_t *sym_node, pars_res_word_t *type, sym_node_t *len, void *is_unsigned, void *is_not_null)
UNIV_INTERN return_node_t * pars_return_statement(void)
UNIV_INTERN ins_node_t * pars_insert_statement(sym_node_t *table_sym, que_node_t *values_list, sel_node_t *select)
@ SYM_COLUMN
Definition pars0sym.h:144
@ SYM_PROCEDURE_NAME
Definition pars0sym.h:146
@ SYM_VAR
Definition pars0sym.h:138
@ SYM_CURSOR
Definition pars0sym.h:145
@ SYM_TABLE
Definition pars0sym.h:143
@ SYM_IMPLICIT_VAR
Definition pars0sym.h:140
@ SYM_FUNCTION
Definition pars0sym.h:148
UNIV_INTERN sym_tab_t * sym_tab_create(mem_heap_t *heap)
Definition pars0sym.cc:49
UNIV_INTERN sym_node_t * sym_tab_add_id(sym_tab_t *sym_tab, byte *name, ulint len)
Definition pars0sym.cc:321
UNIV_INLINE dfield_t * que_node_get_val(que_node_t *node)
UNIV_INLINE ulint que_node_get_type(que_node_t *node)
UNIV_INLINE ulint que_node_list_get_len(que_node_t *node_list)
UNIV_INTERN que_thr_t * que_thr_create(que_fork_t *parent, mem_heap_t *heap)
Definition que0que.cc:200
UNIV_INLINE dtype_t * que_node_get_data_type(que_node_t *node)
UNIV_INLINE que_node_t * que_node_list_add_last(que_node_t *node_list, que_node_t *node)
UNIV_INTERN que_fork_t * que_fork_create(que_t *graph, que_node_t *parent, ulint fork_type, mem_heap_t *heap)
Definition que0que.cc:154
UNIV_INLINE que_node_t * que_node_get_next(que_node_t *node)
UNIV_INLINE void que_node_set_parent(que_node_t *node, que_node_t *parent)
UNIV_INTERN ins_node_t * ins_node_create(ulint ins_type, dict_table_t *table, mem_heap_t *heap)
Definition row0ins.cc:69
UNIV_INTERN void ins_node_set_new_row(ins_node_t *node, dtuple_t *row)
Definition row0ins.cc:186
UNIV_INTERN sel_node_t * sel_node_create(mem_heap_t *heap)
Definition row0sel.cc:255
@ SEL_NODE_OPEN
Definition row0sel.h:283
@ SEL_NODE_CLOSED
Definition row0sel.h:281
UNIV_INLINE plan_t * sel_node_get_nth_plan(sel_node_t *node, ulint i)
open_node_op
Definition row0sel.h:363
UNIV_INLINE upd_t * upd_create(ulint n, mem_heap_t *heap)
UNIV_INTERN upd_node_t * upd_node_create(mem_heap_t *heap)
Definition row0upd.cc:310
UNIV_INLINE void upd_field_set_field_no(upd_field_t *upd_field, ulint field_no, dict_index_t *index, trx_t *trx)
UNIV_INTERN ibool row_upd_changes_some_index_ord_field_binary(const dict_table_t *table, const upd_t *update)
Definition row0upd.cc:1362
que_common_t common
Definition pars0pars.h:725
sym_node_t * var
Definition pars0pars.h:726
que_node_t * val
Definition pars0pars.h:727
que_common_t common
Definition pars0pars.h:732
mem_heap_t * heap
Definition dict0mem.h:470
unsigned mtype
Definition data0type.h:461
unsigned len
Definition data0type.h:472
unsigned prtype
Definition data0type.h:462
que_node_t * cond
Definition pars0pars.h:676
que_common_t common
Definition pars0pars.h:675
que_node_t * stat_list
Definition pars0pars.h:677
que_common_t common
Definition pars0pars.h:715
sym_node_t * into_list
Definition row0sel.h:345
sel_node_t * cursor_def
Definition row0sel.h:344
pars_user_func_t * func
Definition row0sel.h:348
que_common_t common
Definition row0sel.h:343
que_node_t * loop_start_limit
Definition pars0pars.h:704
que_common_t common
Definition pars0pars.h:698
que_node_t * loop_end_limit
Definition pars0pars.h:705
que_node_t * stat_list
Definition pars0pars.h:710
sym_node_t * loop_var
Definition pars0pars.h:699
que_node_t * args
Definition pars0pars.h:646
que_common_t common
Definition pars0pars.h:643
elsif_node_t * elsif_list
Definition pars0pars.h:686
que_node_t * cond
Definition pars0pars.h:683
que_node_t * else_part
Definition pars0pars.h:685
que_common_t common
Definition pars0pars.h:682
que_node_t * stat_list
Definition pars0pars.h:684
sel_node_t * select
Definition row0ins.h:117
dict_table_t * table
Definition row0ins.h:116
enum open_node_op op_type
Definition row0sel.h:371
sel_node_t * cursor_def
Definition row0sel.h:374
que_common_t common
Definition row0sel.h:370
que_common_t common
Definition pars0pars.h:658
sym_node_t * column
Definition pars0pars.h:659
const char * name
Definition pars0pars.h:630
const char * id
Definition pars0pars.h:631
const char * name
Definition pars0pars.h:621
const void * address
Definition pars0pars.h:622
ib_vector_t * funcs
Definition pars0pars.h:601
ib_vector_t * bound_lits
Definition pars0pars.h:603
mem_heap_t * heap
Definition pars0pars.h:599
ib_vector_t * bound_ids
Definition pars0pars.h:605
pars_user_func_cb_t func
Definition pars0pars.h:615
const char * name
Definition pars0pars.h:614
ibool must_get_clust
Definition row0sel.h:258
btr_pcur_t clust_pcur
Definition row0sel.h:272
btr_pcur_t pcur
Definition row0sel.h:207
ibool no_prefetch
Definition row0sel.h:243
dict_index_t * index
Definition row0sel.h:206
sym_node_t * proc_id
Definition pars0pars.h:666
sym_node_t * param_list
Definition pars0pars.h:668
que_node_t * stat_list
Definition pars0pars.h:669
que_common_t common
Definition pars0pars.h:665
sym_tab_t * sym_tab
Definition pars0pars.h:670
que_node_t * parent
Definition que0types.h:49
pars_info_t * info
Definition que0que.h:415
sym_tab_t * sym_tab
Definition que0que.h:412
trx_t * trx
Definition que0que.h:403
que_common_t common
Definition pars0pars.h:720
que_common_t common
Definition row0sel.h:379
sel_node_t * sel_node
Definition row0sel.h:380
sym_node_t * into_list
Definition row0sel.h:294
sym_node_t * table_list
Definition row0sel.h:295
sym_node_t * explicit_cursor
Definition row0sel.h:333
ibool can_get_updated
Definition row0sel.h:322
read_view_t * read_view
Definition row0sel.h:309
ibool set_x_locks
Definition row0sel.h:298
que_node_t * select_list
Definition row0sel.h:293
ulint row_lock_mode
Definition row0sel.h:301
ibool is_aggregate
Definition row0sel.h:316
que_node_t * search_cond
Definition row0sel.h:308
ibool consistent_read
Definition row0sel.h:312
enum sel_node_state state
Definition row0sel.h:291
order_node_t * order_by
Definition row0sel.h:314
que_common_t common
Definition row0sel.h:290
sym_node_t * alias
Definition pars0sym.h:178
sel_buf_t * prefetch_buf
Definition pars0sym.h:217
enum sym_tab_entry token_type
Definition pars0sym.h:208
dict_table_t * table
Definition pars0sym.h:212
sym_node_t * indirection
Definition pars0sym.h:173
const char * name
Definition pars0sym.h:210
sel_node_t * cursor_def
Definition pars0sym.h:221
que_t * graph
Definition trx0trx.h:613
unsigned field_no
Definition row0upd.h:371
que_node_t * exp
Definition row0upd.h:380
upd_t * update
Definition row0upd.h:426
sel_node_t * select
Definition row0upd.h:417
dict_table_t * table
Definition row0upd.h:425
btr_pcur_t * pcur
Definition row0upd.h:420
mem_heap_t * heap
Definition row0upd.h:456
que_common_t common
Definition pars0pars.h:691
que_node_t * stat_list
Definition pars0pars.h:693
que_node_t * cond
Definition pars0pars.h:692
UNIV_INTERN roll_node_t * roll_node_create(mem_heap_t *heap)
Definition trx0roll.cc:1295
UNIV_INTERN commit_node_t * commit_node_create(mem_heap_t *heap)
Definition trx0trx.cc:1530
struct roll_node_struct roll_node_t
Definition trx0types.h:60
struct commit_node_struct commit_node_t
Definition trx0types.h:62
#define ut_error
Definition ut0dbg.h:115
#define ut_ad(EXPR)
Definition ut0dbg.h:127
#define ut_a(EXPR)
Definition ut0dbg.h:105
#define UT_LIST_GET_FIRST(BASE)
Definition ut0lst.h:223
#define UT_LIST_ADD_LAST(NAME, BASE, N)
Definition ut0lst.h:118
#define UT_LIST_GET_NEXT(NAME, N)
Definition ut0lst.h:200
#define UT_LIST_INIT(BASE)
Definition ut0lst.h:83
UNIV_INLINE void * ut_memcpy(void *dest, const void *sour, ulint n)
UNIV_INLINE ulint ut_strlen(const char *str)
UNIV_INLINE int ut_memcmp(const void *str1, const void *str2, ulint n)
UNIV_INTERN void ib_vector_push(ib_vector_t *vec, void *elem)
Definition ut0vec.cc:58
UNIV_INTERN ib_vector_t * ib_vector_create(mem_heap_t *heap, ulint size)
Definition ut0vec.cc:37
struct ib_vector_struct ib_vector_t
Definition ut0vec.h:34
UNIV_INLINE void * ib_vector_get(ib_vector_t *vec, ulint n)
UNIV_INLINE ulint ib_vector_size(const ib_vector_t *vec)