← Back to branch summary

~jaypipes/drizzle/new-test-runner

« back to all changes in this revision

Viewing changes to storage/innobase/include/eval0eval.ic

  • Committer: Jay Pipes
  • Date: 2008-12-11 17:52:34 UTC
  • mfrom: (482.16.152 testable)
  • Revision ID: jpipes@serialcoder-20081211175234-uqsfvmgxejvmellq
merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/eval0eval.ic
 
1
/******************************************************
 
2
SQL evaluator: evaluates simple data structures, like expressions, in
 
3
a query graph
 
4
 
 
5
(c) 1997 Innobase Oy
 
6
 
 
7
Created 12/29/1997 Heikki Tuuri
 
8
*******************************************************/
 
9
 
 
10
#include "que0que.h"
 
11
#include "rem0cmp.h"
 
12
#ifndef PARS0GRM_H
 
13
# define PARS0GRM_H
 
14
# include "pars0grm.h"
 
15
#endif
 
16
 
 
17
/*********************************************************************
 
18
Evaluates a function node. */
 
19
UNIV_INTERN
 
20
void
 
21
eval_func(
 
22
/*======*/
 
23
        func_node_t*    func_node);     /* in: function node */
 
24
/*********************************************************************
 
25
Allocate a buffer from global dynamic memory for a value of a que_node.
 
26
NOTE that this memory must be explicitly freed when the query graph is
 
27
freed. If the node already has allocated buffer, that buffer is freed
 
28
here. NOTE that this is the only function where dynamic memory should be
 
29
allocated for a query node val field. */
 
30
UNIV_INTERN
 
31
byte*
 
32
eval_node_alloc_val_buf(
 
33
/*====================*/
 
34
                                /* out: pointer to allocated buffer */
 
35
        que_node_t*     node,   /* in: query graph node; sets the val field
 
36
                                data field to point to the new buffer, and
 
37
                                len field equal to size */
 
38
        ulint           size);  /* in: buffer size */
 
39
 
 
40
 
 
41
/*********************************************************************
 
42
Allocates a new buffer if needed. */
 
43
UNIV_INLINE
 
44
byte*
 
45
eval_node_ensure_val_buf(
 
46
/*=====================*/
 
47
                                /* out: pointer to buffer */
 
48
        que_node_t*     node,   /* in: query graph node; sets the val field
 
49
                                data field to point to the new buffer, and
 
50
                                len field equal to size */
 
51
        ulint           size)   /* in: buffer size */
 
52
{
 
53
        dfield_t*       dfield;
 
54
        byte*           data;
 
55
 
 
56
        dfield = que_node_get_val(node);
 
57
        dfield_set_len(dfield, size);
 
58
 
 
59
        data = dfield_get_data(dfield);
 
60
 
 
61
        if (!data || que_node_get_val_buf_size(node) < size) {
 
62
 
 
63
                data = eval_node_alloc_val_buf(node, size);
 
64
        }
 
65
 
 
66
        return(data);
 
67
}
 
68
 
 
69
/*********************************************************************
 
70
Evaluates a symbol table symbol. */
 
71
UNIV_INLINE
 
72
void
 
73
eval_sym(
 
74
/*=====*/
 
75
        sym_node_t*     sym_node)       /* in: symbol table node */
 
76
{
 
77
 
 
78
        ut_ad(que_node_get_type(sym_node) == QUE_NODE_SYMBOL);
 
79
 
 
80
        if (sym_node->indirection) {
 
81
                /* The symbol table node is an alias for a variable or a
 
82
                column */
 
83
 
 
84
                dfield_copy_data(que_node_get_val(sym_node),
 
85
                                 que_node_get_val(sym_node->indirection));
 
86
        }
 
87
}
 
88
 
 
89
/*********************************************************************
 
90
Evaluates an expression. */
 
91
UNIV_INLINE
 
92
void
 
93
eval_exp(
 
94
/*=====*/
 
95
        que_node_t*     exp_node)       /* in: expression */
 
96
{
 
97
        if (que_node_get_type(exp_node) == QUE_NODE_SYMBOL) {
 
98
 
 
99
                eval_sym((sym_node_t*)exp_node);
 
100
 
 
101
                return;
 
102
        }
 
103
 
 
104
        eval_func(exp_node);
 
105
}
 
106
 
 
107
/*********************************************************************
 
108
Sets an integer value as the value of an expression node. */
 
109
UNIV_INLINE
 
110
void
 
111
eval_node_set_int_val(
 
112
/*==================*/
 
113
        que_node_t*     node,   /* in: expression node */
 
114
        lint            val)    /* in: value to set */
 
115
{
 
116
        dfield_t*       dfield;
 
117
        byte*           data;
 
118
 
 
119
        dfield = que_node_get_val(node);
 
120
 
 
121
        data = dfield_get_data(dfield);
 
122
 
 
123
        if (data == NULL) {
 
124
                data = eval_node_alloc_val_buf(node, 4);
 
125
        }
 
126
 
 
127
        ut_ad(dfield_get_len(dfield) == 4);
 
128
 
 
129
        mach_write_to_4(data, (ulint)val);
 
130
}
 
131
 
 
132
/*********************************************************************
 
133
Gets an integer non-SQL null value from an expression node. */
 
134
UNIV_INLINE
 
135
lint
 
136
eval_node_get_int_val(
 
137
/*==================*/
 
138
                                /* out: integer value */
 
139
        que_node_t*     node)   /* in: expression node */
 
140
{
 
141
        dfield_t*       dfield;
 
142
 
 
143
        dfield = que_node_get_val(node);
 
144
 
 
145
        ut_ad(dfield_get_len(dfield) == 4);
 
146
 
 
147
        return((int)mach_read_from_4(dfield_get_data(dfield)));
 
148
}
 
149
 
 
150
/*********************************************************************
 
151
Gets a iboolean value from a query node. */
 
152
UNIV_INLINE
 
153
ibool
 
154
eval_node_get_ibool_val(
 
155
/*====================*/
 
156
                                /* out: iboolean value */
 
157
        que_node_t*     node)   /* in: query graph node */
 
158
{
 
159
        dfield_t*       dfield;
 
160
        byte*           data;
 
161
 
 
162
        dfield = que_node_get_val(node);
 
163
 
 
164
        data = dfield_get_data(dfield);
 
165
 
 
166
        ut_ad(data != NULL);
 
167
 
 
168
        return(mach_read_from_1(data));
 
169
}
 
170
 
 
171
/*********************************************************************
 
172
Sets a iboolean value as the value of a function node. */
 
173
UNIV_INLINE
 
174
void
 
175
eval_node_set_ibool_val(
 
176
/*====================*/
 
177
        func_node_t*    func_node,      /* in: function node */
 
178
        ibool           val)            /* in: value to set */
 
179
{
 
180
        dfield_t*       dfield;
 
181
        byte*           data;
 
182
 
 
183
        dfield = que_node_get_val(func_node);
 
184
 
 
185
        data = dfield_get_data(dfield);
 
186
 
 
187
        if (data == NULL) {
 
188
                /* Allocate 1 byte to hold the value */
 
189
 
 
190
                data = eval_node_alloc_val_buf(func_node, 1);
 
191
        }
 
192
 
 
193
        ut_ad(dfield_get_len(dfield) == 1);
 
194
 
 
195
        mach_write_to_1(data, val);
 
196
}
 
197
 
 
198
/*********************************************************************
 
199
Copies a binary string value as the value of a query graph node. Allocates a
 
200
new buffer if necessary. */
 
201
UNIV_INLINE
 
202
void
 
203
eval_node_copy_and_alloc_val(
 
204
/*=========================*/
 
205
        que_node_t*     node,   /* in: query graph node */
 
206
        const byte*     str,    /* in: binary string */
 
207
        ulint           len)    /* in: string length or UNIV_SQL_NULL */
 
208
{
 
209
        byte*           data;
 
210
 
 
211
        if (len == UNIV_SQL_NULL) {
 
212
                dfield_set_len(que_node_get_val(node), len);
 
213
 
 
214
                return;
 
215
        }
 
216
 
 
217
        data = eval_node_ensure_val_buf(node, len);
 
218
 
 
219
        ut_memcpy(data, str, len);
 
220
}
 
221
 
 
222
/*********************************************************************
 
223
Copies a query node value to another node. */
 
224
UNIV_INLINE
 
225
void
 
226
eval_node_copy_val(
 
227
/*===============*/
 
228
        que_node_t*     node1,  /* in: node to copy to */
 
229
        que_node_t*     node2)  /* in: node to copy from */
 
230
{
 
231
        dfield_t*       dfield2;
 
232
 
 
233
        dfield2 = que_node_get_val(node2);
 
234
 
 
235
        eval_node_copy_and_alloc_val(node1, dfield_get_data(dfield2),
 
236
                                     dfield_get_len(dfield2));
 
237
}