← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2010-12-08 22:35:56 UTC
  • mfrom: (1819.9.158 update-innobase)
  • Revision ID: brian@tangent.org-20101208223556-37mi4omqg7lkjzf3
Merge in Stewart's changes, 1.3 changes.

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
 
}