← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/pars/pars0sym.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/pars/pars0sym.c
 
1
/******************************************************
 
2
SQL parser symbol table
 
3
 
 
4
(c) 1997 Innobase Oy
 
5
 
 
6
Created 12/15/1997 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#include "pars0sym.h"
 
10
 
 
11
#ifdef UNIV_NONINL
 
12
#include "pars0sym.ic"
 
13
#endif
 
14
 
 
15
#include "mem0mem.h"
 
16
#include "data0type.h"
 
17
#include "data0data.h"
 
18
#include "pars0grm.h"
 
19
#include "pars0pars.h"
 
20
#include "que0que.h"
 
21
#include "eval0eval.h"
 
22
#include "row0sel.h"
 
23
 
 
24
/**********************************************************************
 
25
Creates a symbol table for a single stored procedure or query. */
 
26
 
 
27
sym_tab_t*
 
28
sym_tab_create(
 
29
/*===========*/
 
30
                                /* out, own: symbol table */
 
31
        mem_heap_t*     heap)   /* in: memory heap where to create */
 
32
{
 
33
        sym_tab_t*      sym_tab;
 
34
 
 
35
        sym_tab = mem_heap_alloc(heap, sizeof(sym_tab_t));
 
36
 
 
37
        UT_LIST_INIT(sym_tab->sym_list);
 
38
        UT_LIST_INIT(sym_tab->func_node_list);
 
39
 
 
40
        sym_tab->heap = heap;
 
41
 
 
42
        return(sym_tab);
 
43
}
 
44
 
 
45
/**********************************************************************
 
46
Frees the memory allocated dynamically AFTER parsing phase for variables
 
47
etc. in the symbol table. Does not free the mem heap where the table was
 
48
originally created. Frees also SQL explicit cursor definitions. */
 
49
 
 
50
void
 
51
sym_tab_free_private(
 
52
/*=================*/
 
53
        sym_tab_t*      sym_tab)        /* in, own: symbol table */
 
54
{
 
55
        sym_node_t*     sym;
 
56
        func_node_t*    func;
 
57
 
 
58
        sym = UT_LIST_GET_FIRST(sym_tab->sym_list);
 
59
 
 
60
        while (sym) {
 
61
                eval_node_free_val_buf(sym);
 
62
 
 
63
                if (sym->prefetch_buf) {
 
64
                        sel_col_prefetch_buf_free(sym->prefetch_buf);
 
65
                }
 
66
 
 
67
                if (sym->cursor_def) {
 
68
                        que_graph_free_recursive(sym->cursor_def);
 
69
                }
 
70
 
 
71
                sym = UT_LIST_GET_NEXT(sym_list, sym);
 
72
        }
 
73
 
 
74
        func = UT_LIST_GET_FIRST(sym_tab->func_node_list);
 
75
 
 
76
        while (func) {
 
77
                eval_node_free_val_buf(func);
 
78
 
 
79
                func = UT_LIST_GET_NEXT(func_node_list, func);
 
80
        }
 
81
}
 
82
 
 
83
/**********************************************************************
 
84
Adds an integer literal to a symbol table. */
 
85
 
 
86
sym_node_t*
 
87
sym_tab_add_int_lit(
 
88
/*================*/
 
89
                                        /* out: symbol table node */
 
90
        sym_tab_t*      sym_tab,        /* in: symbol table */
 
91
        ulint           val)            /* in: integer value */
 
92
{
 
93
        sym_node_t*     node;
 
94
        byte*           data;
 
95
 
 
96
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
97
 
 
98
        node->common.type = QUE_NODE_SYMBOL;
 
99
 
 
100
        node->resolved = TRUE;
 
101
        node->token_type = SYM_LIT;
 
102
 
 
103
        node->indirection = NULL;
 
104
 
 
105
        dtype_set(&(node->common.val.type), DATA_INT, 0, 4);
 
106
 
 
107
        data = mem_heap_alloc(sym_tab->heap, 4);
 
108
        mach_write_to_4(data, val);
 
109
 
 
110
        dfield_set_data(&(node->common.val), data, 4);
 
111
 
 
112
        node->common.val_buf_size = 0;
 
113
        node->prefetch_buf = NULL;
 
114
        node->cursor_def = NULL;
 
115
 
 
116
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
117
 
 
118
        node->sym_table = sym_tab;
 
119
 
 
120
        return(node);
 
121
}
 
122
 
 
123
/**********************************************************************
 
124
Adds a string literal to a symbol table. */
 
125
 
 
126
sym_node_t*
 
127
sym_tab_add_str_lit(
 
128
/*================*/
 
129
                                        /* out: symbol table node */
 
130
        sym_tab_t*      sym_tab,        /* in: symbol table */
 
131
        byte*           str,            /* in: string with no quotes around
 
132
                                        it */
 
133
        ulint           len)            /* in: string length */
 
134
{
 
135
        sym_node_t*     node;
 
136
        byte*           data;
 
137
 
 
138
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
139
 
 
140
        node->common.type = QUE_NODE_SYMBOL;
 
141
 
 
142
        node->resolved = TRUE;
 
143
        node->token_type = SYM_LIT;
 
144
 
 
145
        node->indirection = NULL;
 
146
 
 
147
        dtype_set(&(node->common.val.type), DATA_VARCHAR, DATA_ENGLISH, 0);
 
148
 
 
149
        if (len) {
 
150
                data = mem_heap_alloc(sym_tab->heap, len);
 
151
                ut_memcpy(data, str, len);
 
152
        } else {
 
153
                data = NULL;
 
154
        }
 
155
 
 
156
        dfield_set_data(&(node->common.val), data, len);
 
157
 
 
158
        node->common.val_buf_size = 0;
 
159
        node->prefetch_buf = NULL;
 
160
        node->cursor_def = NULL;
 
161
 
 
162
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
163
 
 
164
        node->sym_table = sym_tab;
 
165
 
 
166
        return(node);
 
167
}
 
168
 
 
169
/**********************************************************************
 
170
Add a bound literal to a symbol table. */
 
171
 
 
172
sym_node_t*
 
173
sym_tab_add_bound_lit(
 
174
/*==================*/
 
175
                                        /* out: symbol table node */
 
176
        sym_tab_t*      sym_tab,        /* in: symbol table */
 
177
        const char*     name,           /* in: name of bound literal */
 
178
        ulint*          lit_type)       /* out: type of literal (PARS_*_LIT) */
 
179
{
 
180
        sym_node_t*             node;
 
181
        pars_bound_lit_t*       blit;
 
182
        ulint                   len = 0;
 
183
 
 
184
        blit = pars_info_get_bound_lit(sym_tab->info, name);
 
185
        ut_a(blit);
 
186
 
 
187
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
188
 
 
189
        node->common.type = QUE_NODE_SYMBOL;
 
190
 
 
191
        node->resolved = TRUE;
 
192
        node->token_type = SYM_LIT;
 
193
 
 
194
        node->indirection = NULL;
 
195
 
 
196
        switch (blit->type) {
 
197
        case DATA_FIXBINARY:
 
198
                len = blit->length;
 
199
                *lit_type = PARS_FIXBINARY_LIT;
 
200
                break;
 
201
 
 
202
        case DATA_BLOB:
 
203
                *lit_type = PARS_BLOB_LIT;
 
204
                break;
 
205
 
 
206
        case DATA_VARCHAR:
 
207
                *lit_type = PARS_STR_LIT;
 
208
                break;
 
209
 
 
210
        case DATA_CHAR:
 
211
                ut_a(blit->length > 0);
 
212
 
 
213
                len = blit->length;
 
214
                *lit_type = PARS_STR_LIT;
 
215
                break;
 
216
 
 
217
        case DATA_INT:
 
218
                ut_a(blit->length > 0);
 
219
                ut_a(blit->length <= 8);
 
220
 
 
221
                len = blit->length;
 
222
                *lit_type = PARS_INT_LIT;
 
223
                break;
 
224
 
 
225
        default:
 
226
                ut_error;
 
227
        }
 
228
 
 
229
        dtype_set(&(node->common.val.type), blit->type, blit->prtype, len);
 
230
 
 
231
        dfield_set_data(&(node->common.val), blit->address, blit->length);
 
232
 
 
233
        node->common.val_buf_size = 0;
 
234
        node->prefetch_buf = NULL;
 
235
        node->cursor_def = NULL;
 
236
 
 
237
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
238
 
 
239
        node->sym_table = sym_tab;
 
240
 
 
241
        return(node);
 
242
}
 
243
 
 
244
/**********************************************************************
 
245
Adds an SQL null literal to a symbol table. */
 
246
 
 
247
sym_node_t*
 
248
sym_tab_add_null_lit(
 
249
/*=================*/
 
250
                                        /* out: symbol table node */
 
251
        sym_tab_t*      sym_tab)        /* in: symbol table */
 
252
{
 
253
        sym_node_t*     node;
 
254
 
 
255
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
256
 
 
257
        node->common.type = QUE_NODE_SYMBOL;
 
258
 
 
259
        node->resolved = TRUE;
 
260
        node->token_type = SYM_LIT;
 
261
 
 
262
        node->indirection = NULL;
 
263
 
 
264
        node->common.val.type.mtype = DATA_ERROR;
 
265
 
 
266
        dfield_set_data(&(node->common.val), NULL, UNIV_SQL_NULL);
 
267
 
 
268
        node->common.val_buf_size = 0;
 
269
        node->prefetch_buf = NULL;
 
270
        node->cursor_def = NULL;
 
271
 
 
272
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
273
 
 
274
        node->sym_table = sym_tab;
 
275
 
 
276
        return(node);
 
277
}
 
278
 
 
279
/**********************************************************************
 
280
Adds an identifier to a symbol table. */
 
281
 
 
282
sym_node_t*
 
283
sym_tab_add_id(
 
284
/*===========*/
 
285
                                        /* out: symbol table node */
 
286
        sym_tab_t*      sym_tab,        /* in: symbol table */
 
287
        byte*           name,           /* in: identifier name */
 
288
        ulint           len)            /* in: identifier length */
 
289
{
 
290
        sym_node_t*     node;
 
291
 
 
292
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
293
 
 
294
        node->common.type = QUE_NODE_SYMBOL;
 
295
 
 
296
        node->resolved = FALSE;
 
297
        node->indirection = NULL;
 
298
 
 
299
        node->name = mem_heap_strdupl(sym_tab->heap, (char*) name, len);
 
300
        node->name_len = len;
 
301
 
 
302
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
303
 
 
304
        dfield_set_data(&(node->common.val), NULL, UNIV_SQL_NULL);
 
305
 
 
306
        node->common.val_buf_size = 0;
 
307
        node->prefetch_buf = NULL;
 
308
        node->cursor_def = NULL;
 
309
 
 
310
        node->sym_table = sym_tab;
 
311
 
 
312
        return(node);
 
313
}
 
314
 
 
315
/**********************************************************************
 
316
Add a bound identifier to a symbol table. */
 
317
 
 
318
sym_node_t*
 
319
sym_tab_add_bound_id(
 
320
/*===========*/
 
321
                                        /* out: symbol table node */
 
322
        sym_tab_t*      sym_tab,        /* in: symbol table */
 
323
        const char*     name)           /* in: name of bound id */
 
324
{
 
325
        sym_node_t*             node;
 
326
        pars_bound_id_t*        bid;
 
327
 
 
328
        bid = pars_info_get_bound_id(sym_tab->info, name);
 
329
        ut_a(bid);
 
330
 
 
331
        node = mem_heap_alloc(sym_tab->heap, sizeof(sym_node_t));
 
332
 
 
333
        node->common.type = QUE_NODE_SYMBOL;
 
334
 
 
335
        node->resolved = FALSE;
 
336
        node->indirection = NULL;
 
337
 
 
338
        node->name = mem_heap_strdup(sym_tab->heap, bid->id);
 
339
        node->name_len = strlen(node->name);
 
340
 
 
341
        UT_LIST_ADD_LAST(sym_list, sym_tab->sym_list, node);
 
342
 
 
343
        dfield_set_data(&(node->common.val), NULL, UNIV_SQL_NULL);
 
344
 
 
345
        node->common.val_buf_size = 0;
 
346
        node->prefetch_buf = NULL;
 
347
        node->cursor_def = NULL;
 
348
 
 
349
        node->sym_table = sym_tab;
 
350
 
 
351
        return(node);
 
352
}