1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
|
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
*
* Copyright (C) 2008 Sun Microsystems
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <drizzled/server_includes.h>
#include CSTDINT_H
#include <drizzled/functions/get_user_var.h>
#include <drizzled/functions/get_variable.h>
#include <drizzled/sql_parse.h>
#include <drizzled/session.h>
String *
Item_func_get_user_var::val_str(String *str)
{
assert(fixed == 1);
if (!var_entry)
return((String*) 0); // No such variable
return(var_entry->val_str(&null_value, str, decimals));
}
double Item_func_get_user_var::val_real()
{
assert(fixed == 1);
if (!var_entry)
return 0.0; // No such variable
return (var_entry->val_real(&null_value));
}
my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec)
{
assert(fixed == 1);
if (!var_entry)
return 0;
return var_entry->val_decimal(&null_value, dec);
}
int64_t Item_func_get_user_var::val_int()
{
assert(fixed == 1);
if (!var_entry)
return 0L; // No such variable
return (var_entry->val_int(&null_value));
}
/**
Get variable by name and, if necessary, put the record of variable
use into the binary log.
When a user variable is invoked from an update query (INSERT, UPDATE etc),
stores this variable and its value in session->user_var_events, so that it can be
written to the binlog (will be written just before the query is written, see
log.cc).
@param session Current thread
@param name Variable name
@param[out] out_entry variable structure or NULL. The pointer is set
regardless of whether function succeeded or not.
@retval
0 OK
@retval
1 Failed to put appropriate record into binary log
*/
static int get_var_with_binlog(Session *session, enum_sql_command sql_command,
LEX_STRING &name, user_var_entry **out_entry)
{
BINLOG_USER_VAR_EVENT *user_var_event;
user_var_entry *var_entry;
var_entry= get_variable(&session->user_vars, name, 0);
/*
Any reference to user-defined variable which is done from stored
function or trigger affects their execution and the execution of the
calling statement. We must log all such variables even if they are
not involved in table-updating statements.
*/
if (!(opt_bin_log && is_update_query(sql_command)))
{
*out_entry= var_entry;
return 0;
}
if (!var_entry)
{
/*
If the variable does not exist, it's NULL, but we want to create it so
that it gets into the binlog (if it didn't, the slave could be
influenced by a variable of the same name previously set by another
thread).
We create it like if it had been explicitly set with SET before.
The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'.
sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'
in dispatch_command()). Instead of building a one-element list to pass to
sql_set_variables(), we could instead manually call check() and update();
this would save memory and time; but calling sql_set_variables() makes
one unique place to maintain (sql_set_variables()).
Manipulation with lex is necessary since free_underlaid_joins
is going to release memory belonging to the main query.
*/
List<set_var_base> tmp_var_list;
LEX *sav_lex= session->lex, lex_tmp;
session->lex= &lex_tmp;
lex_start(session);
tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(name,
new Item_null())));
/* Create the variable */
if (sql_set_variables(session, &tmp_var_list))
{
session->lex= sav_lex;
goto err;
}
session->lex= sav_lex;
if (!(var_entry= get_variable(&session->user_vars, name, 0)))
goto err;
}
else if (var_entry->used_query_id == session->query_id ||
drizzle_bin_log.is_query_in_union(session, var_entry->used_query_id))
{
/*
If this variable was already stored in user_var_events by this query
(because it's used in more than one place in the query), don't store
it.
*/
*out_entry= var_entry;
return 0;
}
uint32_t size;
/*
First we need to store value of var_entry, when the next situation
appears:
> set @a:=1;
> insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);
We have to write to binlog value @a= 1.
We allocate the user_var_event on user_var_events_alloc pool, not on
the this-statement-execution pool because in SPs user_var_event objects
may need to be valid after current [SP] statement execution pool is
destroyed.
*/
size= ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT)) + var_entry->length;
if (!(user_var_event= (BINLOG_USER_VAR_EVENT *)
alloc_root(session->user_var_events_alloc, size)))
goto err;
user_var_event->value= (char*) user_var_event +
ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT));
user_var_event->user_var_event= var_entry;
user_var_event->type= var_entry->type;
user_var_event->charset_number= var_entry->collation.collation->number;
if (!var_entry->value)
{
/* NULL value*/
user_var_event->length= 0;
user_var_event->value= 0;
}
else
{
user_var_event->length= var_entry->length;
memcpy(user_var_event->value, var_entry->value,
var_entry->length);
}
/* Mark that this variable has been used by this query */
var_entry->used_query_id= session->query_id;
if (insert_dynamic(&session->user_var_events, (unsigned char*) &user_var_event))
goto err;
*out_entry= var_entry;
return 0;
err:
*out_entry= var_entry;
return 1;
}
void Item_func_get_user_var::fix_length_and_dec()
{
Session *session=current_session;
int error;
maybe_null=1;
decimals=NOT_FIXED_DEC;
max_length=MAX_BLOB_WIDTH;
error= get_var_with_binlog(session, session->lex->sql_command, name, &var_entry);
/*
If the variable didn't exist it has been created as a STRING-type.
'var_entry' is NULL only if there occured an error during the call to
get_var_with_binlog.
*/
if (var_entry)
{
m_cached_result_type= var_entry->type;
unsigned_flag= var_entry->unsigned_flag;
max_length= var_entry->length;
collation.set(var_entry->collation);
switch(m_cached_result_type) {
case REAL_RESULT:
max_length= DBL_DIG + 8;
break;
case INT_RESULT:
max_length= MAX_BIGINT_WIDTH;
decimals=0;
break;
case STRING_RESULT:
max_length= MAX_BLOB_WIDTH;
break;
case DECIMAL_RESULT:
max_length= DECIMAL_MAX_STR_LENGTH;
decimals= DECIMAL_MAX_SCALE;
break;
case ROW_RESULT: // Keep compiler happy
default:
assert(0);
break;
}
}
else
{
collation.set(&my_charset_bin, DERIVATION_IMPLICIT);
null_value= 1;
m_cached_result_type= STRING_RESULT;
max_length= MAX_BLOB_WIDTH;
}
}
bool Item_func_get_user_var::const_item() const
{
return (!var_entry || current_session->query_id != var_entry->update_query_id);
}
enum Item_result Item_func_get_user_var::result_type() const
{
return m_cached_result_type;
}
void Item_func_get_user_var::print(String *str,
enum_query_type query_type __attribute__((unused)))
{
str->append(STRING_WITH_LEN("(@"));
str->append(name.str,name.length);
str->append(')');
}
bool Item_func_get_user_var::eq(const Item *item,
bool binary_cmp __attribute__((unused))) const
{
/* Assume we don't have rtti */
if (this == item)
return 1; // Same item is same.
/* Check if other type is also a get_user_var() object */
if (item->type() != FUNC_ITEM ||
((Item_func*) item)->functype() != functype())
return 0;
Item_func_get_user_var *other=(Item_func_get_user_var*) item;
return (name.length == other->name.length &&
!memcmp(name.str, other->name.str, name.length));
}
|