← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_func.cc

Merged vcol stuff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_func.cc
 
1
/* Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
/**
 
18
  @file
 
19
 
 
20
  @brief
 
21
  This file defines all numerical functions
 
22
*/
 
23
 
 
24
#include <drizzled/server_includes.h>
 
25
#include "rpl_mi.h"
 
26
#include <mysys/my_bit.h>
 
27
#include <drizzled/drizzled_error_messages.h>
 
28
 
 
29
bool check_reserved_words(LEX_STRING *name)
 
30
{
 
31
  if (!my_strcasecmp(system_charset_info, name->str, "GLOBAL") ||
 
32
      !my_strcasecmp(system_charset_info, name->str, "LOCAL") ||
 
33
      !my_strcasecmp(system_charset_info, name->str, "SESSION"))
 
34
    return true;
 
35
  return false;
 
36
}
 
37
 
 
38
 
 
39
/**
 
40
  @return
 
41
    true if item is a constant
 
42
*/
 
43
 
 
44
bool
 
45
eval_const_cond(COND *cond)
 
46
{
 
47
  return ((Item_func*) cond)->val_int() ? true : false;
 
48
}
 
49
 
 
50
 
 
51
void Item_func::set_arguments(List<Item> &list)
 
52
{
 
53
  allowed_arg_cols= 1;
 
54
  arg_count=list.elements;
 
55
  args= tmp_arg;                                // If 2 arguments
 
56
  if (arg_count <= 2 || (args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
 
57
  {
 
58
    List_iterator_fast<Item> li(list);
 
59
    Item *item;
 
60
    Item **save_args= args;
 
61
 
 
62
    while ((item=li++))
 
63
    {
 
64
      *(save_args++)= item;
 
65
      with_sum_func|=item->with_sum_func;
 
66
    }
 
67
  }
 
68
  list.empty();                                 // Fields are used
 
69
}
 
70
 
 
71
Item_func::Item_func(List<Item> &list)
 
72
  :allowed_arg_cols(1)
 
73
{
 
74
  set_arguments(list);
 
75
}
 
76
 
 
77
Item_func::Item_func(THD *thd, Item_func *item)
 
78
  :Item_result_field(thd, item),
 
79
   allowed_arg_cols(item->allowed_arg_cols),
 
80
   arg_count(item->arg_count),
 
81
   used_tables_cache(item->used_tables_cache),
 
82
   not_null_tables_cache(item->not_null_tables_cache),
 
83
   const_item_cache(item->const_item_cache)
 
84
{
 
85
  if (arg_count)
 
86
  {
 
87
    if (arg_count <=2)
 
88
      args= tmp_arg;
 
89
    else
 
90
    {
 
91
      if (!(args=(Item**) thd->alloc(sizeof(Item*)*arg_count)))
 
92
        return;
 
93
    }
 
94
    memcpy(args, item->args, sizeof(Item*)*arg_count);
 
95
  }
 
96
}
 
97
 
 
98
 
 
99
/*
 
100
  Resolve references to table column for a function and its argument
 
101
 
 
102
  SYNOPSIS:
 
103
  fix_fields()
 
104
  thd           Thread object
 
105
  ref           Pointer to where this object is used.  This reference
 
106
                is used if we want to replace this object with another
 
107
                one (for example in the summary functions).
 
108
 
 
109
  DESCRIPTION
 
110
    Call fix_fields() for all arguments to the function.  The main intention
 
111
    is to allow all Item_field() objects to setup pointers to the table fields.
 
112
 
 
113
    Sets as a side effect the following class variables:
 
114
      maybe_null        Set if any argument may return NULL
 
115
      with_sum_func     Set if any of the arguments contains a sum function
 
116
      used_tables_cache Set to union of the tables used by arguments
 
117
 
 
118
      str_value.charset If this is a string function, set this to the
 
119
                        character set for the first argument.
 
120
                        If any argument is binary, this is set to binary
 
121
 
 
122
   If for any item any of the defaults are wrong, then this can
 
123
   be fixed in the fix_length_and_dec() function that is called
 
124
   after this one or by writing a specialized fix_fields() for the
 
125
   item.
 
126
 
 
127
  RETURN VALUES
 
128
  false ok
 
129
  true  Got error.  Stored with my_error().
 
130
*/
 
131
 
 
132
bool
 
133
Item_func::fix_fields(THD *thd, Item **ref __attribute__((unused)))
 
134
{
 
135
  assert(fixed == 0);
 
136
  Item **arg,**arg_end;
 
137
  void *save_thd_marker= thd->thd_marker;
 
138
  unsigned char buff[STACK_BUFF_ALLOC];                 // Max argument in function
 
139
  thd->thd_marker= 0;
 
140
  used_tables_cache= not_null_tables_cache= 0;
 
141
  const_item_cache=1;
 
142
 
 
143
  if (check_stack_overrun(thd, STACK_MIN_SIZE, buff))
 
144
    return true;                                // Fatal error if flag is set!
 
145
  if (arg_count)
 
146
  {                                             // Print purify happy
 
147
    for (arg=args, arg_end=args+arg_count; arg != arg_end ; arg++)
 
148
    {
 
149
      Item *item;
 
150
      /*
 
151
        We can't yet set item to *arg as fix_fields may change *arg
 
152
        We shouldn't call fix_fields() twice, so check 'fixed' field first
 
153
      */
 
154
      if ((!(*arg)->fixed && (*arg)->fix_fields(thd, arg)))
 
155
        return true;                            /* purecov: inspected */
 
156
      item= *arg;
 
157
 
 
158
      if (allowed_arg_cols)
 
159
      {
 
160
        if (item->check_cols(allowed_arg_cols))
 
161
          return 1;
 
162
      }
 
163
      else
 
164
      {
 
165
        /*  we have to fetch allowed_arg_cols from first argument */
 
166
        assert(arg == args); // it is first argument
 
167
        allowed_arg_cols= item->cols();
 
168
        assert(allowed_arg_cols); // Can't be 0 any more
 
169
      }
 
170
 
 
171
      if (item->maybe_null)
 
172
        maybe_null=1;
 
173
 
 
174
      with_sum_func= with_sum_func || item->with_sum_func;
 
175
      used_tables_cache|=     item->used_tables();
 
176
      not_null_tables_cache|= item->not_null_tables();
 
177
      const_item_cache&=      item->const_item();
 
178
      with_subselect|=        item->with_subselect;
 
179
    }
 
180
  }
 
181
  fix_length_and_dec();
 
182
  if (thd->is_error()) // An error inside fix_length_and_dec occured
 
183
    return true;
 
184
  fixed= 1;
 
185
  thd->thd_marker= save_thd_marker;
 
186
  return false;
 
187
}
 
188
 
 
189
 
 
190
void Item_func::fix_after_pullout(st_select_lex *new_parent,
 
191
                                  Item **ref __attribute__((unused)))
 
192
{
 
193
  Item **arg,**arg_end;
 
194
 
 
195
  used_tables_cache= not_null_tables_cache= 0;
 
196
  const_item_cache=1;
 
197
 
 
198
  if (arg_count)
 
199
  {
 
200
    for (arg=args, arg_end=args+arg_count; arg != arg_end ; arg++)
 
201
    {
 
202
      (*arg)->fix_after_pullout(new_parent, arg);
 
203
      Item *item= *arg;
 
204
 
 
205
      used_tables_cache|=     item->used_tables();
 
206
      not_null_tables_cache|= item->not_null_tables();
 
207
      const_item_cache&=      item->const_item();
 
208
    }
 
209
  }
 
210
}
 
211
 
 
212
 
 
213
bool Item_func::walk(Item_processor processor, bool walk_subquery,
 
214
                     unsigned char *argument)
 
215
{
 
216
  if (arg_count)
 
217
  {
 
218
    Item **arg,**arg_end;
 
219
    for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
 
220
    {
 
221
      if ((*arg)->walk(processor, walk_subquery, argument))
 
222
        return 1;
 
223
    }
 
224
  }
 
225
  return (this->*processor)(argument);
 
226
}
 
227
 
 
228
void Item_func::traverse_cond(Cond_traverser traverser,
 
229
                              void *argument, traverse_order order)
 
230
{
 
231
  if (arg_count)
 
232
  {
 
233
    Item **arg,**arg_end;
 
234
 
 
235
    switch (order) {
 
236
    case(PREFIX):
 
237
      (*traverser)(this, argument);
 
238
      for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
 
239
      {
 
240
        (*arg)->traverse_cond(traverser, argument, order);
 
241
      }
 
242
      break;
 
243
    case (POSTFIX):
 
244
      for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
 
245
      {
 
246
        (*arg)->traverse_cond(traverser, argument, order);
 
247
      }
 
248
      (*traverser)(this, argument);
 
249
    }
 
250
  }
 
251
  else
 
252
    (*traverser)(this, argument);
 
253
}
 
254
 
 
255
 
 
256
/**
 
257
  Transform an Item_func object with a transformer callback function.
 
258
 
 
259
    The function recursively applies the transform method to each
 
260
    argument of the Item_func node.
 
261
    If the call of the method for an argument item returns a new item
 
262
    the old item is substituted for a new one.
 
263
    After this the transformer is applied to the root node
 
264
    of the Item_func object. 
 
265
  @param transformer   the transformer callback function to be applied to
 
266
                       the nodes of the tree of the object
 
267
  @param argument      parameter to be passed to the transformer
 
268
 
 
269
  @return
 
270
    Item returned as the result of transformation of the root node
 
271
*/
 
272
 
 
273
Item *Item_func::transform(Item_transformer transformer, unsigned char *argument)
 
274
{
 
275
  if (arg_count)
 
276
  {
 
277
    Item **arg,**arg_end;
 
278
    for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
 
279
    {
 
280
      Item *new_item= (*arg)->transform(transformer, argument);
 
281
      if (!new_item)
 
282
        return 0;
 
283
 
 
284
      /*
 
285
        THD::change_item_tree() should be called only if the tree was
 
286
        really transformed, i.e. when a new item has been created.
 
287
        Otherwise we'll be allocating a lot of unnecessary memory for
 
288
        change records at each execution.
 
289
      */
 
290
      if (*arg != new_item)
 
291
        current_thd->change_item_tree(arg, new_item);
 
292
    }
 
293
  }
 
294
  return (this->*transformer)(argument);
 
295
}
 
296
 
 
297
 
 
298
/**
 
299
  Compile Item_func object with a processor and a transformer
 
300
  callback functions.
 
301
 
 
302
    First the function applies the analyzer to the root node of
 
303
    the Item_func object. Then if the analizer succeeeds (returns true)
 
304
    the function recursively applies the compile method to each argument
 
305
    of the Item_func node.
 
306
    If the call of the method for an argument item returns a new item
 
307
    the old item is substituted for a new one.
 
308
    After this the transformer is applied to the root node
 
309
    of the Item_func object. 
 
310
 
 
311
  @param analyzer      the analyzer callback function to be applied to the
 
312
                       nodes of the tree of the object
 
313
  @param[in,out] arg_p parameter to be passed to the processor
 
314
  @param transformer   the transformer callback function to be applied to the
 
315
                       nodes of the tree of the object
 
316
  @param arg_t         parameter to be passed to the transformer
 
317
 
 
318
  @return
 
319
    Item returned as the result of transformation of the root node
 
320
*/
 
321
 
 
322
Item *Item_func::compile(Item_analyzer analyzer, unsigned char **arg_p,
 
323
                         Item_transformer transformer, unsigned char *arg_t)
 
324
{
 
325
  if (!(this->*analyzer)(arg_p))
 
326
    return 0;
 
327
  if (arg_count)
 
328
  {
 
329
    Item **arg,**arg_end;
 
330
    for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
 
331
    {
 
332
      /* 
 
333
        The same parameter value of arg_p must be passed
 
334
        to analyze any argument of the condition formula.
 
335
      */   
 
336
      unsigned char *arg_v= *arg_p;
 
337
      Item *new_item= (*arg)->compile(analyzer, &arg_v, transformer, arg_t);
 
338
      if (new_item && *arg != new_item)
 
339
        current_thd->change_item_tree(arg, new_item);
 
340
    }
 
341
  }
 
342
  return (this->*transformer)(arg_t);
 
343
}
 
344
 
 
345
/**
 
346
  See comments in Item_cmp_func::split_sum_func()
 
347
*/
 
348
 
 
349
void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
 
350
                               List<Item> &fields)
 
351
{
 
352
  Item **arg, **arg_end;
 
353
  for (arg= args, arg_end= args+arg_count; arg != arg_end ; arg++)
 
354
    (*arg)->split_sum_func2(thd, ref_pointer_array, fields, arg, true);
 
355
}
 
356
 
 
357
 
 
358
void Item_func::update_used_tables()
 
359
{
 
360
  used_tables_cache=0;
 
361
  const_item_cache=1;
 
362
  for (uint32_t i=0 ; i < arg_count ; i++)
 
363
  {
 
364
    args[i]->update_used_tables();
 
365
    used_tables_cache|=args[i]->used_tables();
 
366
    const_item_cache&=args[i]->const_item();
 
367
  }
 
368
}
 
369
 
 
370
 
 
371
table_map Item_func::used_tables() const
 
372
{
 
373
  return used_tables_cache;
 
374
}
 
375
 
 
376
 
 
377
table_map Item_func::not_null_tables() const
 
378
{
 
379
  return not_null_tables_cache;
 
380
}
 
381
 
 
382
 
 
383
void Item_func::print(String *str, enum_query_type query_type)
 
384
{
 
385
  str->append(func_name());
 
386
  str->append('(');
 
387
  print_args(str, 0, query_type);
 
388
  str->append(')');
 
389
}
 
390
 
 
391
 
 
392
void Item_func::print_args(String *str, uint32_t from, enum_query_type query_type)
 
393
{
 
394
  for (uint32_t i=from ; i < arg_count ; i++)
 
395
  {
 
396
    if (i != from)
 
397
      str->append(',');
 
398
    args[i]->print(str, query_type);
 
399
  }
 
400
}
 
401
 
 
402
 
 
403
void Item_func::print_op(String *str, enum_query_type query_type)
 
404
{
 
405
  str->append('(');
 
406
  for (uint32_t i=0 ; i < arg_count-1 ; i++)
 
407
  {
 
408
    args[i]->print(str, query_type);
 
409
    str->append(' ');
 
410
    str->append(func_name());
 
411
    str->append(' ');
 
412
  }
 
413
  args[arg_count-1]->print(str, query_type);
 
414
  str->append(')');
 
415
}
 
416
 
 
417
 
 
418
bool Item_func::eq(const Item *item, bool binary_cmp) const
 
419
{
 
420
  /* Assume we don't have rtti */
 
421
  if (this == item)
 
422
    return 1;
 
423
  if (item->type() != FUNC_ITEM)
 
424
    return 0;
 
425
  Item_func *item_func=(Item_func*) item;
 
426
  Item_func::Functype func_type;
 
427
  if ((func_type= functype()) != item_func->functype() ||
 
428
      arg_count != item_func->arg_count ||
 
429
      (func_type != Item_func::FUNC_SP &&
 
430
       func_name() != item_func->func_name()) ||
 
431
      (func_type == Item_func::FUNC_SP &&
 
432
       my_strcasecmp(system_charset_info, func_name(), item_func->func_name())))
 
433
    return 0;
 
434
  for (uint32_t i=0; i < arg_count ; i++)
 
435
    if (!args[i]->eq(item_func->args[i], binary_cmp))
 
436
      return 0;
 
437
  return 1;
 
438
}
 
439
 
 
440
 
 
441
Field *Item_func::tmp_table_field(Table *table)
 
442
{
 
443
  Field *field;
 
444
 
 
445
  switch (result_type()) {
 
446
  case INT_RESULT:
 
447
    if (max_length > MY_INT32_NUM_DECIMAL_DIGITS)
 
448
      field= new Field_int64_t(max_length, maybe_null, name, unsigned_flag);
 
449
    else
 
450
      field= new Field_long(max_length, maybe_null, name, unsigned_flag);
 
451
    break;
 
452
  case REAL_RESULT:
 
453
    field= new Field_double(max_length, maybe_null, name, decimals);
 
454
    break;
 
455
  case STRING_RESULT:
 
456
    return make_string_field(table);
 
457
    break;
 
458
  case DECIMAL_RESULT:
 
459
    field= new Field_new_decimal(my_decimal_precision_to_length(decimal_precision(),
 
460
                                                                decimals,
 
461
                                                                unsigned_flag),
 
462
                                 maybe_null, name, decimals, unsigned_flag);
 
463
    break;
 
464
  case ROW_RESULT:
 
465
  default:
 
466
    // This case should never be chosen
 
467
    assert(0);
 
468
    field= 0;
 
469
    break;
 
470
  }
 
471
  if (field)
 
472
    field->init(table);
 
473
  return field;
 
474
}
 
475
 
 
476
 
 
477
my_decimal *Item_func::val_decimal(my_decimal *decimal_value)
 
478
{
 
479
  assert(fixed);
 
480
  int2my_decimal(E_DEC_FATAL_ERROR, val_int(), unsigned_flag, decimal_value);
 
481
  return decimal_value;
 
482
}
 
483
 
 
484
 
 
485
String *Item_real_func::val_str(String *str)
 
486
{
 
487
  assert(fixed == 1);
 
488
  double nr= val_real();
 
489
  if (null_value)
 
490
    return 0; /* purecov: inspected */
 
491
  str->set_real(nr,decimals, &my_charset_bin);
 
492
  return str;
 
493
}
 
494
 
 
495
 
 
496
my_decimal *Item_real_func::val_decimal(my_decimal *decimal_value)
 
497
{
 
498
  assert(fixed);
 
499
  double nr= val_real();
 
500
  if (null_value)
 
501
    return 0; /* purecov: inspected */
 
502
  double2my_decimal(E_DEC_FATAL_ERROR, nr, decimal_value);
 
503
  return decimal_value;
 
504
}
 
505
 
 
506
 
 
507
void Item_func::fix_num_length_and_dec()
 
508
{
 
509
  uint32_t fl_length= 0;
 
510
  decimals=0;
 
511
  for (uint32_t i=0 ; i < arg_count ; i++)
 
512
  {
 
513
    set_if_bigger(decimals,args[i]->decimals);
 
514
    set_if_bigger(fl_length, args[i]->max_length);
 
515
  }
 
516
  max_length=float_length(decimals);
 
517
  if (fl_length > max_length)
 
518
  {
 
519
    decimals= NOT_FIXED_DEC;
 
520
    max_length= float_length(NOT_FIXED_DEC);
 
521
  }
 
522
}
 
523
 
 
524
 
 
525
void Item_func_numhybrid::fix_num_length_and_dec()
 
526
{}
 
527
 
 
528
 
 
529
/**
 
530
  Set max_length/decimals of function if function is fixed point and
 
531
  result length/precision depends on argument ones.
 
532
*/
 
533
 
 
534
void Item_func::count_decimal_length()
 
535
{
 
536
  int max_int_part= 0;
 
537
  decimals= 0;
 
538
  unsigned_flag= 1;
 
539
  for (uint32_t i=0 ; i < arg_count ; i++)
 
540
  {
 
541
    set_if_bigger(decimals, args[i]->decimals);
 
542
    set_if_bigger(max_int_part, args[i]->decimal_int_part());
 
543
    set_if_smaller(unsigned_flag, args[i]->unsigned_flag);
 
544
  }
 
545
  int precision= cmin(max_int_part + decimals, DECIMAL_MAX_PRECISION);
 
546
  max_length= my_decimal_precision_to_length(precision, decimals,
 
547
                                             unsigned_flag);
 
548
}
 
549
 
 
550
 
 
551
/**
 
552
  Set max_length of if it is maximum length of its arguments.
 
553
*/
 
554
 
 
555
void Item_func::count_only_length()
 
556
{
 
557
  max_length= 0;
 
558
  unsigned_flag= 0;
 
559
  for (uint32_t i=0 ; i < arg_count ; i++)
 
560
  {
 
561
    set_if_bigger(max_length, args[i]->max_length);
 
562
    set_if_bigger(unsigned_flag, args[i]->unsigned_flag);
 
563
  }
 
564
}
 
565
 
 
566
 
 
567
/**
 
568
  Set max_length/decimals of function if function is floating point and
 
569
  result length/precision depends on argument ones.
 
570
*/
 
571
 
 
572
void Item_func::count_real_length()
 
573
{
 
574
  uint32_t length= 0;
 
575
  decimals= 0;
 
576
  max_length= 0;
 
577
  for (uint32_t i=0 ; i < arg_count ; i++)
 
578
  {
 
579
    if (decimals != NOT_FIXED_DEC)
 
580
    {
 
581
      set_if_bigger(decimals, args[i]->decimals);
 
582
      set_if_bigger(length, (args[i]->max_length - args[i]->decimals));
 
583
    }
 
584
    set_if_bigger(max_length, args[i]->max_length);
 
585
  }
 
586
  if (decimals != NOT_FIXED_DEC)
 
587
  {
 
588
    max_length= length;
 
589
    length+= decimals;
 
590
    if (length < max_length)  // If previous operation gave overflow
 
591
      max_length= UINT32_MAX;
 
592
    else
 
593
      max_length= length;
 
594
  }
 
595
}
 
596
 
 
597
 
 
598
 
 
599
void Item_func::signal_divide_by_null()
 
600
{
 
601
  THD *thd= current_thd;
 
602
  push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
 
603
  null_value= 1;
 
604
}
 
605
 
 
606
 
 
607
Item *Item_func::get_tmp_table_item(THD *thd)
 
608
{
 
609
  if (!with_sum_func && !const_item() && functype() != SUSERVAR_FUNC)
 
610
    return new Item_field(result_field);
 
611
  return copy_or_same(thd);
 
612
}
 
613
 
 
614
double Item_int_func::val_real()
 
615
{
 
616
  assert(fixed == 1);
 
617
 
 
618
  return unsigned_flag ? (double) ((uint64_t) val_int()) : (double) val_int();
 
619
}
 
620
 
 
621
 
 
622
String *Item_int_func::val_str(String *str)
 
623
{
 
624
  assert(fixed == 1);
 
625
  int64_t nr=val_int();
 
626
  if (null_value)
 
627
    return 0;
 
628
  str->set_int(nr, unsigned_flag, &my_charset_bin);
 
629
  return str;
 
630
}
 
631
 
 
632
 
 
633
void Item_func_connection_id::fix_length_and_dec()
 
634
{
 
635
  Item_int_func::fix_length_and_dec();
 
636
  max_length= 10;
 
637
}
 
638
 
 
639
 
 
640
bool Item_func_connection_id::fix_fields(THD *thd, Item **ref)
 
641
{
 
642
  if (Item_int_func::fix_fields(thd, ref))
 
643
    return true;
 
644
  thd->thread_specific_used= true;
 
645
  value= thd->variables.pseudo_thread_id;
 
646
  return false;
 
647
}
 
648
 
 
649
 
 
650
/**
 
651
  Check arguments here to determine result's type for a numeric
 
652
  function of two arguments.
 
653
*/
 
654
 
 
655
void Item_num_op::find_num_type(void)
 
656
{
 
657
  assert(arg_count == 2);
 
658
  Item_result r0= args[0]->result_type();
 
659
  Item_result r1= args[1]->result_type();
 
660
 
 
661
  if (r0 == REAL_RESULT || r1 == REAL_RESULT ||
 
662
      r0 == STRING_RESULT || r1 ==STRING_RESULT)
 
663
  {
 
664
    count_real_length();
 
665
    max_length= float_length(decimals);
 
666
    hybrid_type= REAL_RESULT;
 
667
  }
 
668
  else if (r0 == DECIMAL_RESULT || r1 == DECIMAL_RESULT)
 
669
  {
 
670
    hybrid_type= DECIMAL_RESULT;
 
671
    result_precision();
 
672
  }
 
673
  else
 
674
  {
 
675
    assert(r0 == INT_RESULT && r1 == INT_RESULT);
 
676
    decimals= 0;
 
677
    hybrid_type=INT_RESULT;
 
678
    result_precision();
 
679
  }
 
680
  return;
 
681
}
 
682
 
 
683
 
 
684
/**
 
685
  Set result type for a numeric function of one argument
 
686
  (can be also used by a numeric function of many arguments, if the result
 
687
  type depends only on the first argument)
 
688
*/
 
689
 
 
690
void Item_func_num1::find_num_type()
 
691
{
 
692
  switch (hybrid_type= args[0]->result_type()) {
 
693
  case INT_RESULT:
 
694
    unsigned_flag= args[0]->unsigned_flag;
 
695
    break;
 
696
  case STRING_RESULT:
 
697
  case REAL_RESULT:
 
698
    hybrid_type= REAL_RESULT;
 
699
    max_length= float_length(decimals);
 
700
    break;
 
701
  case DECIMAL_RESULT:
 
702
    break;
 
703
  default:
 
704
    assert(0);
 
705
  }
 
706
  return;
 
707
}
 
708
 
 
709
 
 
710
void Item_func_num1::fix_num_length_and_dec()
 
711
{
 
712
  decimals= args[0]->decimals;
 
713
  max_length= args[0]->max_length;
 
714
}
 
715
 
 
716
 
 
717
void Item_func_numhybrid::fix_length_and_dec()
 
718
{
 
719
  fix_num_length_and_dec();
 
720
  find_num_type();
 
721
}
 
722
 
 
723
 
 
724
String *Item_func_numhybrid::val_str(String *str)
 
725
{
 
726
  assert(fixed == 1);
 
727
  switch (hybrid_type) {
 
728
  case DECIMAL_RESULT:
 
729
  {
 
730
    my_decimal decimal_value, *val;
 
731
    if (!(val= decimal_op(&decimal_value)))
 
732
      return 0;                                 // null is set
 
733
    my_decimal_round(E_DEC_FATAL_ERROR, val, decimals, false, val);
 
734
    my_decimal2string(E_DEC_FATAL_ERROR, val, 0, 0, 0, str);
 
735
    break;
 
736
  }
 
737
  case INT_RESULT:
 
738
  {
 
739
    int64_t nr= int_op();
 
740
    if (null_value)
 
741
      return 0; /* purecov: inspected */
 
742
    str->set_int(nr, unsigned_flag, &my_charset_bin);
 
743
    break;
 
744
  }
 
745
  case REAL_RESULT:
 
746
  {
 
747
    double nr= real_op();
 
748
    if (null_value)
 
749
      return 0; /* purecov: inspected */
 
750
    str->set_real(nr,decimals,&my_charset_bin);
 
751
    break;
 
752
  }
 
753
  case STRING_RESULT:
 
754
    return str_op(&str_value);
 
755
  default:
 
756
    assert(0);
 
757
  }
 
758
  return str;
 
759
}
 
760
 
 
761
 
 
762
double Item_func_numhybrid::val_real()
 
763
{
 
764
  assert(fixed == 1);
 
765
  switch (hybrid_type) {
 
766
  case DECIMAL_RESULT:
 
767
  {
 
768
    my_decimal decimal_value, *val;
 
769
    double result;
 
770
    if (!(val= decimal_op(&decimal_value)))
 
771
      return 0.0;                               // null is set
 
772
    my_decimal2double(E_DEC_FATAL_ERROR, val, &result);
 
773
    return result;
 
774
  }
 
775
  case INT_RESULT:
 
776
  {
 
777
    int64_t result= int_op();
 
778
    return unsigned_flag ? (double) ((uint64_t) result) : (double) result;
 
779
  }
 
780
  case REAL_RESULT:
 
781
    return real_op();
 
782
  case STRING_RESULT:
 
783
  {
 
784
    char *end_not_used;
 
785
    int err_not_used;
 
786
    String *res= str_op(&str_value);
 
787
    return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
 
788
                             &end_not_used, &err_not_used) : 0.0);
 
789
  }
 
790
  default:
 
791
    assert(0);
 
792
  }
 
793
  return 0.0;
 
794
}
 
795
 
 
796
 
 
797
int64_t Item_func_numhybrid::val_int()
 
798
{
 
799
  assert(fixed == 1);
 
800
  switch (hybrid_type) {
 
801
  case DECIMAL_RESULT:
 
802
  {
 
803
    my_decimal decimal_value, *val;
 
804
    if (!(val= decimal_op(&decimal_value)))
 
805
      return 0;                                 // null is set
 
806
    int64_t result;
 
807
    my_decimal2int(E_DEC_FATAL_ERROR, val, unsigned_flag, &result);
 
808
    return result;
 
809
  }
 
810
  case INT_RESULT:
 
811
    return int_op();
 
812
  case REAL_RESULT:
 
813
    return (int64_t) rint(real_op());
 
814
  case STRING_RESULT:
 
815
  {
 
816
    int err_not_used;
 
817
    String *res;
 
818
    if (!(res= str_op(&str_value)))
 
819
      return 0;
 
820
 
 
821
    char *end= (char*) res->ptr() + res->length();
 
822
    const CHARSET_INFO * const cs= str_value.charset();
 
823
    return (*(cs->cset->strtoll10))(cs, res->ptr(), &end, &err_not_used);
 
824
  }
 
825
  default:
 
826
    assert(0);
 
827
  }
 
828
  return 0;
 
829
}
 
830
 
 
831
 
 
832
my_decimal *Item_func_numhybrid::val_decimal(my_decimal *decimal_value)
 
833
{
 
834
  my_decimal *val= decimal_value;
 
835
  assert(fixed == 1);
 
836
  switch (hybrid_type) {
 
837
  case DECIMAL_RESULT:
 
838
    val= decimal_op(decimal_value);
 
839
    break;
 
840
  case INT_RESULT:
 
841
  {
 
842
    int64_t result= int_op();
 
843
    int2my_decimal(E_DEC_FATAL_ERROR, result, unsigned_flag, decimal_value);
 
844
    break;
 
845
  }
 
846
  case REAL_RESULT:
 
847
  {
 
848
    double result= (double)real_op();
 
849
    double2my_decimal(E_DEC_FATAL_ERROR, result, decimal_value);
 
850
    break;
 
851
  }
 
852
  case STRING_RESULT:
 
853
  {
 
854
    String *res;
 
855
    if (!(res= str_op(&str_value)))
 
856
      return NULL;
 
857
 
 
858
    str2my_decimal(E_DEC_FATAL_ERROR, (char*) res->ptr(),
 
859
                   res->length(), res->charset(), decimal_value);
 
860
    break;
 
861
  }  
 
862
  case ROW_RESULT:
 
863
  default:
 
864
    assert(0);
 
865
  }
 
866
  return val;
 
867
}
 
868
 
 
869
 
 
870
void Item_func_signed::print(String *str, enum_query_type query_type)
 
871
{
 
872
  str->append(STRING_WITH_LEN("cast("));
 
873
  args[0]->print(str, query_type);
 
874
  str->append(STRING_WITH_LEN(" as signed)"));
 
875
 
 
876
}
 
877
 
 
878
 
 
879
int64_t Item_func_signed::val_int_from_str(int *error)
 
880
{
 
881
  char buff[MAX_FIELD_WIDTH], *end, *start;
 
882
  uint32_t length;
 
883
  String tmp(buff,sizeof(buff), &my_charset_bin), *res;
 
884
  int64_t value;
 
885
 
 
886
  /*
 
887
    For a string result, we must first get the string and then convert it
 
888
    to a int64_t
 
889
  */
 
890
 
 
891
  if (!(res= args[0]->val_str(&tmp)))
 
892
  {
 
893
    null_value= 1;
 
894
    *error= 0;
 
895
    return 0;
 
896
  }
 
897
  null_value= 0;
 
898
  start= (char *)res->ptr();
 
899
  length= res->length();
 
900
 
 
901
  end= start + length;
 
902
  value= my_strtoll10(start, &end, error);
 
903
  if (*error > 0 || end != start+ length)
 
904
  {
 
905
    char err_buff[128];
 
906
    String err_tmp(err_buff,(uint32_t) sizeof(err_buff), system_charset_info);
 
907
    err_tmp.copy(start, length, system_charset_info);
 
908
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
909
                        ER_TRUNCATED_WRONG_VALUE,
 
910
                        ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
 
911
                        err_tmp.c_ptr());
 
912
  }
 
913
  return value;
 
914
}
 
915
 
 
916
 
 
917
int64_t Item_func_signed::val_int()
 
918
{
 
919
  int64_t value;
 
920
  int error;
 
921
 
 
922
  if (args[0]->cast_to_int_type() != STRING_RESULT ||
 
923
      args[0]->result_as_int64_t())
 
924
  {
 
925
    value= args[0]->val_int();
 
926
    null_value= args[0]->null_value; 
 
927
    return value;
 
928
  }
 
929
 
 
930
  value= val_int_from_str(&error);
 
931
  if (value < 0 && error == 0)
 
932
  {
 
933
    push_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
 
934
                 "Cast to signed converted positive out-of-range integer to "
 
935
                 "it's negative complement");
 
936
  }
 
937
  return value;
 
938
}
 
939
 
 
940
 
 
941
void Item_func_unsigned::print(String *str, enum_query_type query_type)
 
942
{
 
943
  str->append(STRING_WITH_LEN("cast("));
 
944
  args[0]->print(str, query_type);
 
945
  str->append(STRING_WITH_LEN(" as unsigned)"));
 
946
 
 
947
}
 
948
 
 
949
 
 
950
int64_t Item_func_unsigned::val_int()
 
951
{
 
952
  int64_t value;
 
953
  int error;
 
954
 
 
955
  if (args[0]->cast_to_int_type() == DECIMAL_RESULT)
 
956
  {
 
957
    my_decimal tmp, *dec= args[0]->val_decimal(&tmp);
 
958
    if (!(null_value= args[0]->null_value))
 
959
      my_decimal2int(E_DEC_FATAL_ERROR, dec, 1, &value);
 
960
    else
 
961
      value= 0;
 
962
    return value;
 
963
  }
 
964
  else if (args[0]->cast_to_int_type() != STRING_RESULT ||
 
965
           args[0]->result_as_int64_t())
 
966
  {
 
967
    value= args[0]->val_int();
 
968
    null_value= args[0]->null_value; 
 
969
    return value;
 
970
  }
 
971
 
 
972
  value= val_int_from_str(&error);
 
973
  if (error < 0)
 
974
    push_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
 
975
                 "Cast to unsigned converted negative integer to it's "
 
976
                 "positive complement");
 
977
  return value;
 
978
}
 
979
 
 
980
 
 
981
String *Item_decimal_typecast::val_str(String *str)
 
982
{
 
983
  my_decimal tmp_buf, *tmp= val_decimal(&tmp_buf);
 
984
  if (null_value)
 
985
    return NULL;
 
986
  my_decimal2string(E_DEC_FATAL_ERROR, tmp, 0, 0, 0, str);
 
987
  return str;
 
988
}
 
989
 
 
990
 
 
991
double Item_decimal_typecast::val_real()
 
992
{
 
993
  my_decimal tmp_buf, *tmp= val_decimal(&tmp_buf);
 
994
  double res;
 
995
  if (null_value)
 
996
    return 0.0;
 
997
  my_decimal2double(E_DEC_FATAL_ERROR, tmp, &res);
 
998
  return res;
 
999
}
 
1000
 
 
1001
 
 
1002
int64_t Item_decimal_typecast::val_int()
 
1003
{
 
1004
  my_decimal tmp_buf, *tmp= val_decimal(&tmp_buf);
 
1005
  int64_t res;
 
1006
  if (null_value)
 
1007
    return 0;
 
1008
  my_decimal2int(E_DEC_FATAL_ERROR, tmp, unsigned_flag, &res);
 
1009
  return res;
 
1010
}
 
1011
 
 
1012
 
 
1013
my_decimal *Item_decimal_typecast::val_decimal(my_decimal *dec)
 
1014
{
 
1015
  my_decimal tmp_buf, *tmp= args[0]->val_decimal(&tmp_buf);
 
1016
  bool sign;
 
1017
  uint32_t precision;
 
1018
 
 
1019
  if ((null_value= args[0]->null_value))
 
1020
    return NULL;
 
1021
  my_decimal_round(E_DEC_FATAL_ERROR, tmp, decimals, false, dec);
 
1022
  sign= dec->sign();
 
1023
  if (unsigned_flag)
 
1024
  {
 
1025
    if (sign)
 
1026
    {
 
1027
      my_decimal_set_zero(dec);
 
1028
      goto err;
 
1029
    }
 
1030
  }
 
1031
  precision= my_decimal_length_to_precision(max_length,
 
1032
                                            decimals, unsigned_flag);
 
1033
  if (precision - decimals < (uint) my_decimal_intg(dec))
 
1034
  {
 
1035
    max_my_decimal(dec, precision, decimals);
 
1036
    dec->sign(sign);
 
1037
    goto err;
 
1038
  }
 
1039
  return dec;
 
1040
 
 
1041
err:
 
1042
  push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
1043
                      ER_WARN_DATA_OUT_OF_RANGE,
 
1044
                      ER(ER_WARN_DATA_OUT_OF_RANGE),
 
1045
                      name, 1);
 
1046
  return dec;
 
1047
}
 
1048
 
 
1049
 
 
1050
void Item_decimal_typecast::print(String *str, enum_query_type query_type)
 
1051
{
 
1052
  char len_buf[20*3 + 1];
 
1053
  char *end;
 
1054
 
 
1055
  uint32_t precision= my_decimal_length_to_precision(max_length, decimals,
 
1056
                                                 unsigned_flag);
 
1057
  str->append(STRING_WITH_LEN("cast("));
 
1058
  args[0]->print(str, query_type);
 
1059
  str->append(STRING_WITH_LEN(" as decimal("));
 
1060
 
 
1061
  end=int10_to_str(precision, len_buf,10);
 
1062
  str->append(len_buf, (uint32_t) (end - len_buf));
 
1063
 
 
1064
  str->append(',');
 
1065
 
 
1066
  end=int10_to_str(decimals, len_buf,10);
 
1067
  str->append(len_buf, (uint32_t) (end - len_buf));
 
1068
 
 
1069
  str->append(')');
 
1070
  str->append(')');
 
1071
}
 
1072
 
 
1073
 
 
1074
double Item_func_plus::real_op()
 
1075
{
 
1076
  double value= args[0]->val_real() + args[1]->val_real();
 
1077
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1078
    return 0.0;
 
1079
  return fix_result(value);
 
1080
}
 
1081
 
 
1082
 
 
1083
int64_t Item_func_plus::int_op()
 
1084
{
 
1085
  int64_t value=args[0]->val_int()+args[1]->val_int();
 
1086
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1087
    return 0;
 
1088
  return value;
 
1089
}
 
1090
 
 
1091
 
 
1092
/**
 
1093
  Calculate plus of two decimals.
 
1094
 
 
1095
  @param decimal_value  Buffer that can be used to store result
 
1096
 
 
1097
  @retval
 
1098
    0  Value was NULL;  In this case null_value is set
 
1099
  @retval
 
1100
    \# Value of operation as a decimal
 
1101
*/
 
1102
 
 
1103
my_decimal *Item_func_plus::decimal_op(my_decimal *decimal_value)
 
1104
{
 
1105
  my_decimal value1, *val1;
 
1106
  my_decimal value2, *val2;
 
1107
  val1= args[0]->val_decimal(&value1);
 
1108
  if ((null_value= args[0]->null_value))
 
1109
    return 0;
 
1110
  val2= args[1]->val_decimal(&value2);
 
1111
  if (!(null_value= (args[1]->null_value ||
 
1112
                     (my_decimal_add(E_DEC_FATAL_ERROR, decimal_value, val1,
 
1113
                                     val2) > 3))))
 
1114
    return decimal_value;
 
1115
  return 0;
 
1116
}
 
1117
 
 
1118
/**
 
1119
  Set precision of results for additive operations (+ and -)
 
1120
*/
 
1121
void Item_func_additive_op::result_precision()
 
1122
{
 
1123
  decimals= cmax(args[0]->decimals, args[1]->decimals);
 
1124
  int max_int_part= cmax(args[0]->decimal_precision() - args[0]->decimals,
 
1125
                        args[1]->decimal_precision() - args[1]->decimals);
 
1126
  int precision= cmin(max_int_part + 1 + decimals, DECIMAL_MAX_PRECISION);
 
1127
 
 
1128
  /* Integer operations keep unsigned_flag if one of arguments is unsigned */
 
1129
  if (result_type() == INT_RESULT)
 
1130
    unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
 
1131
  else
 
1132
    unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
 
1133
  max_length= my_decimal_precision_to_length(precision, decimals,
 
1134
                                             unsigned_flag);
 
1135
}
 
1136
 
 
1137
 
 
1138
/**
 
1139
  The following function is here to allow the user to force
 
1140
  subtraction of UNSIGNED BIGINT to return negative values.
 
1141
*/
 
1142
 
 
1143
void Item_func_minus::fix_length_and_dec()
 
1144
{
 
1145
  Item_num_op::fix_length_and_dec();
 
1146
  if (unsigned_flag)
 
1147
    unsigned_flag= 0;
 
1148
}
 
1149
 
 
1150
 
 
1151
double Item_func_minus::real_op()
 
1152
{
 
1153
  double value= args[0]->val_real() - args[1]->val_real();
 
1154
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1155
    return 0.0;
 
1156
  return fix_result(value);
 
1157
}
 
1158
 
 
1159
 
 
1160
int64_t Item_func_minus::int_op()
 
1161
{
 
1162
  int64_t value=args[0]->val_int() - args[1]->val_int();
 
1163
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1164
    return 0;
 
1165
  return value;
 
1166
}
 
1167
 
 
1168
 
 
1169
/**
 
1170
  See Item_func_plus::decimal_op for comments.
 
1171
*/
 
1172
 
 
1173
my_decimal *Item_func_minus::decimal_op(my_decimal *decimal_value)
 
1174
{
 
1175
  my_decimal value1, *val1;
 
1176
  my_decimal value2, *val2= 
 
1177
 
 
1178
  val1= args[0]->val_decimal(&value1);
 
1179
  if ((null_value= args[0]->null_value))
 
1180
    return 0;
 
1181
  val2= args[1]->val_decimal(&value2);
 
1182
  if (!(null_value= (args[1]->null_value ||
 
1183
                     (my_decimal_sub(E_DEC_FATAL_ERROR, decimal_value, val1,
 
1184
                                     val2) > 3))))
 
1185
    return decimal_value;
 
1186
  return 0;
 
1187
}
 
1188
 
 
1189
 
 
1190
double Item_func_mul::real_op()
 
1191
{
 
1192
  assert(fixed == 1);
 
1193
  double value= args[0]->val_real() * args[1]->val_real();
 
1194
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1195
    return 0.0;
 
1196
  return fix_result(value);
 
1197
}
 
1198
 
 
1199
 
 
1200
int64_t Item_func_mul::int_op()
 
1201
{
 
1202
  assert(fixed == 1);
 
1203
  int64_t value=args[0]->val_int()*args[1]->val_int();
 
1204
  if ((null_value=args[0]->null_value || args[1]->null_value))
 
1205
    return 0;
 
1206
  return value;
 
1207
}
 
1208
 
 
1209
 
 
1210
/** See Item_func_plus::decimal_op for comments. */
 
1211
 
 
1212
my_decimal *Item_func_mul::decimal_op(my_decimal *decimal_value)
 
1213
{
 
1214
  my_decimal value1, *val1;
 
1215
  my_decimal value2, *val2;
 
1216
  val1= args[0]->val_decimal(&value1);
 
1217
  if ((null_value= args[0]->null_value))
 
1218
    return 0;
 
1219
  val2= args[1]->val_decimal(&value2);
 
1220
  if (!(null_value= (args[1]->null_value ||
 
1221
                     (my_decimal_mul(E_DEC_FATAL_ERROR, decimal_value, val1,
 
1222
                                    val2) > 3))))
 
1223
    return decimal_value;
 
1224
  return 0;
 
1225
}
 
1226
 
 
1227
 
 
1228
void Item_func_mul::result_precision()
 
1229
{
 
1230
  /* Integer operations keep unsigned_flag if one of arguments is unsigned */
 
1231
  if (result_type() == INT_RESULT)
 
1232
    unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
 
1233
  else
 
1234
    unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
 
1235
  decimals= cmin(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE);
 
1236
  int precision= cmin(args[0]->decimal_precision() + args[1]->decimal_precision(),
 
1237
                     (unsigned int)DECIMAL_MAX_PRECISION);
 
1238
  max_length= my_decimal_precision_to_length(precision, decimals,unsigned_flag);
 
1239
}
 
1240
 
 
1241
 
 
1242
double Item_func_div::real_op()
 
1243
{
 
1244
  assert(fixed == 1);
 
1245
  double value= args[0]->val_real();
 
1246
  double val2= args[1]->val_real();
 
1247
  if ((null_value= args[0]->null_value || args[1]->null_value))
 
1248
    return 0.0;
 
1249
  if (val2 == 0.0)
 
1250
  {
 
1251
    signal_divide_by_null();
 
1252
    return 0.0;
 
1253
  }
 
1254
  return fix_result(value/val2);
 
1255
}
 
1256
 
 
1257
 
 
1258
my_decimal *Item_func_div::decimal_op(my_decimal *decimal_value)
 
1259
{
 
1260
  my_decimal value1, *val1;
 
1261
  my_decimal value2, *val2;
 
1262
  int err;
 
1263
 
 
1264
  val1= args[0]->val_decimal(&value1);
 
1265
  if ((null_value= args[0]->null_value))
 
1266
    return 0;
 
1267
  val2= args[1]->val_decimal(&value2);
 
1268
  if ((null_value= args[1]->null_value))
 
1269
    return 0;
 
1270
  if ((err= my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value,
 
1271
                           val1, val2, prec_increment)) > 3)
 
1272
  {
 
1273
    if (err == E_DEC_DIV_ZERO)
 
1274
      signal_divide_by_null();
 
1275
    null_value= 1;
 
1276
    return 0;
 
1277
  }
 
1278
  return decimal_value;
 
1279
}
 
1280
 
 
1281
 
 
1282
void Item_func_div::result_precision()
 
1283
{
 
1284
  uint32_t precision=cmin(args[0]->decimal_precision() + prec_increment,
 
1285
                     (unsigned int)DECIMAL_MAX_PRECISION);
 
1286
  /* Integer operations keep unsigned_flag if one of arguments is unsigned */
 
1287
  if (result_type() == INT_RESULT)
 
1288
    unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
 
1289
  else
 
1290
    unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
 
1291
  decimals= cmin(args[0]->decimals + prec_increment, (unsigned int)DECIMAL_MAX_SCALE);
 
1292
  max_length= my_decimal_precision_to_length(precision, decimals,
 
1293
                                             unsigned_flag);
 
1294
}
 
1295
 
 
1296
 
 
1297
void Item_func_div::fix_length_and_dec()
 
1298
{
 
1299
  prec_increment= current_thd->variables.div_precincrement;
 
1300
  Item_num_op::fix_length_and_dec();
 
1301
  switch(hybrid_type) {
 
1302
  case REAL_RESULT:
 
1303
  {
 
1304
    decimals=cmax(args[0]->decimals,args[1]->decimals)+prec_increment;
 
1305
    set_if_smaller(decimals, NOT_FIXED_DEC);
 
1306
    max_length=args[0]->max_length - args[0]->decimals + decimals;
 
1307
    uint32_t tmp=float_length(decimals);
 
1308
    set_if_smaller(max_length,tmp);
 
1309
    break;
 
1310
  }
 
1311
  case INT_RESULT:
 
1312
    hybrid_type= DECIMAL_RESULT;
 
1313
    result_precision();
 
1314
    break;
 
1315
  case DECIMAL_RESULT:
 
1316
    result_precision();
 
1317
    break;
 
1318
  default:
 
1319
    assert(0);
 
1320
  }
 
1321
  maybe_null= 1; // devision by zero
 
1322
  return;
 
1323
}
 
1324
 
 
1325
 
 
1326
/* Integer division */
 
1327
int64_t Item_func_int_div::val_int()
 
1328
{
 
1329
  assert(fixed == 1);
 
1330
  int64_t value=args[0]->val_int();
 
1331
  int64_t val2=args[1]->val_int();
 
1332
  if ((null_value= (args[0]->null_value || args[1]->null_value)))
 
1333
    return 0;
 
1334
  if (val2 == 0)
 
1335
  {
 
1336
    signal_divide_by_null();
 
1337
    return 0;
 
1338
  }
 
1339
  return (unsigned_flag ?
 
1340
          (uint64_t) value / (uint64_t) val2 :
 
1341
          value / val2);
 
1342
}
 
1343
 
 
1344
 
 
1345
void Item_func_int_div::fix_length_and_dec()
 
1346
{
 
1347
  Item_result argtype= args[0]->result_type();
 
1348
  /* use precision ony for the data type it is applicable for and valid */
 
1349
  max_length=args[0]->max_length -
 
1350
    (argtype == DECIMAL_RESULT || argtype == INT_RESULT ?
 
1351
     args[0]->decimals : 0);
 
1352
  maybe_null=1;
 
1353
  unsigned_flag=args[0]->unsigned_flag | args[1]->unsigned_flag;
 
1354
}
 
1355
 
 
1356
 
 
1357
int64_t Item_func_mod::int_op()
 
1358
{
 
1359
  assert(fixed == 1);
 
1360
  int64_t value=  args[0]->val_int();
 
1361
  int64_t val2= args[1]->val_int();
 
1362
  int64_t result;
 
1363
 
 
1364
  if ((null_value= args[0]->null_value || args[1]->null_value))
 
1365
    return 0; /* purecov: inspected */
 
1366
  if (val2 == 0)
 
1367
  {
 
1368
    signal_divide_by_null();
 
1369
    return 0;
 
1370
  }
 
1371
 
 
1372
  if (args[0]->unsigned_flag)
 
1373
    result= args[1]->unsigned_flag ? 
 
1374
      ((uint64_t) value) % ((uint64_t) val2) : ((uint64_t) value) % val2;
 
1375
  else
 
1376
    result= args[1]->unsigned_flag ?
 
1377
      value % ((uint64_t) val2) : value % val2;
 
1378
 
 
1379
  return result;
 
1380
}
 
1381
 
 
1382
double Item_func_mod::real_op()
 
1383
{
 
1384
  assert(fixed == 1);
 
1385
  double value= args[0]->val_real();
 
1386
  double val2=  args[1]->val_real();
 
1387
  if ((null_value= args[0]->null_value || args[1]->null_value))
 
1388
    return 0.0; /* purecov: inspected */
 
1389
  if (val2 == 0.0)
 
1390
  {
 
1391
    signal_divide_by_null();
 
1392
    return 0.0;
 
1393
  }
 
1394
  return fmod(value,val2);
 
1395
}
 
1396
 
 
1397
 
 
1398
my_decimal *Item_func_mod::decimal_op(my_decimal *decimal_value)
 
1399
{
 
1400
  my_decimal value1, *val1;
 
1401
  my_decimal value2, *val2;
 
1402
 
 
1403
  val1= args[0]->val_decimal(&value1);
 
1404
  if ((null_value= args[0]->null_value))
 
1405
    return 0;
 
1406
  val2= args[1]->val_decimal(&value2);
 
1407
  if ((null_value= args[1]->null_value))
 
1408
    return 0;
 
1409
  switch (my_decimal_mod(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value,
 
1410
                         val1, val2)) {
 
1411
  case E_DEC_TRUNCATED:
 
1412
  case E_DEC_OK:
 
1413
    return decimal_value;
 
1414
  case E_DEC_DIV_ZERO:
 
1415
    signal_divide_by_null();
 
1416
  default:
 
1417
    null_value= 1;
 
1418
    return 0;
 
1419
  }
 
1420
}
 
1421
 
 
1422
 
 
1423
void Item_func_mod::result_precision()
 
1424
{
 
1425
  decimals= cmax(args[0]->decimals, args[1]->decimals);
 
1426
  max_length= cmax(args[0]->max_length, args[1]->max_length);
 
1427
}
 
1428
 
 
1429
 
 
1430
void Item_func_mod::fix_length_and_dec()
 
1431
{
 
1432
  Item_num_op::fix_length_and_dec();
 
1433
  maybe_null= 1;
 
1434
  unsigned_flag= args[0]->unsigned_flag;
 
1435
}
 
1436
 
 
1437
 
 
1438
double Item_func_neg::real_op()
 
1439
{
 
1440
  double value= args[0]->val_real();
 
1441
  null_value= args[0]->null_value;
 
1442
  return -value;
 
1443
}
 
1444
 
 
1445
 
 
1446
int64_t Item_func_neg::int_op()
 
1447
{
 
1448
  int64_t value= args[0]->val_int();
 
1449
  null_value= args[0]->null_value;
 
1450
  return -value;
 
1451
}
 
1452
 
 
1453
 
 
1454
my_decimal *Item_func_neg::decimal_op(my_decimal *decimal_value)
 
1455
{
 
1456
  my_decimal val, *value= args[0]->val_decimal(&val);
 
1457
  if (!(null_value= args[0]->null_value))
 
1458
  {
 
1459
    my_decimal2decimal(value, decimal_value);
 
1460
    my_decimal_neg(decimal_value);
 
1461
    return decimal_value;
 
1462
  }
 
1463
  return 0;
 
1464
}
 
1465
 
 
1466
 
 
1467
void Item_func_neg::fix_num_length_and_dec()
 
1468
{
 
1469
  decimals= args[0]->decimals;
 
1470
  /* 1 add because sign can appear */
 
1471
  max_length= args[0]->max_length + 1;
 
1472
}
 
1473
 
 
1474
 
 
1475
void Item_func_neg::fix_length_and_dec()
 
1476
{
 
1477
  Item_func_num1::fix_length_and_dec();
 
1478
 
 
1479
  /*
 
1480
    If this is in integer context keep the context as integer if possible
 
1481
    (This is how multiplication and other integer functions works)
 
1482
    Use val() to get value as arg_type doesn't mean that item is
 
1483
    Item_int or Item_real due to existence of Item_param.
 
1484
  */
 
1485
  if (hybrid_type == INT_RESULT && args[0]->const_item())
 
1486
  {
 
1487
    int64_t val= args[0]->val_int();
 
1488
    if ((uint64_t) val >= (uint64_t) INT64_MIN &&
 
1489
        ((uint64_t) val != (uint64_t) INT64_MIN ||
 
1490
          args[0]->type() != INT_ITEM))        
 
1491
    {
 
1492
      /*
 
1493
        Ensure that result is converted to DECIMAL, as int64_t can't hold
 
1494
        the negated number
 
1495
      */
 
1496
      hybrid_type= DECIMAL_RESULT;
 
1497
    }
 
1498
  }
 
1499
  unsigned_flag= 0;
 
1500
  return;
 
1501
}
 
1502
 
 
1503
 
 
1504
double Item_func_abs::real_op()
 
1505
{
 
1506
  double value= args[0]->val_real();
 
1507
  null_value= args[0]->null_value;
 
1508
  return fabs(value);
 
1509
}
 
1510
 
 
1511
 
 
1512
int64_t Item_func_abs::int_op()
 
1513
{
 
1514
  int64_t value= args[0]->val_int();
 
1515
  if ((null_value= args[0]->null_value))
 
1516
    return 0;
 
1517
  return (value >= 0) || unsigned_flag ? value : -value;
 
1518
}
 
1519
 
 
1520
 
 
1521
my_decimal *Item_func_abs::decimal_op(my_decimal *decimal_value)
 
1522
{
 
1523
  my_decimal val, *value= args[0]->val_decimal(&val);
 
1524
  if (!(null_value= args[0]->null_value))
 
1525
  {
 
1526
    my_decimal2decimal(value, decimal_value);
 
1527
    if (decimal_value->sign())
 
1528
      my_decimal_neg(decimal_value);
 
1529
    return decimal_value;
 
1530
  }
 
1531
  return 0;
 
1532
}
 
1533
 
 
1534
 
 
1535
void Item_func_abs::fix_length_and_dec()
 
1536
{
 
1537
  Item_func_num1::fix_length_and_dec();
 
1538
  unsigned_flag= args[0]->unsigned_flag;
 
1539
}
 
1540
 
 
1541
 
 
1542
/** Gateway to natural LOG function. */
 
1543
double Item_func_ln::val_real()
 
1544
{
 
1545
  assert(fixed == 1);
 
1546
  double value= args[0]->val_real();
 
1547
  if ((null_value= args[0]->null_value))
 
1548
    return 0.0;
 
1549
  if (value <= 0.0)
 
1550
  {
 
1551
    signal_divide_by_null();
 
1552
    return 0.0;
 
1553
  }
 
1554
  return log(value);
 
1555
}
 
1556
 
 
1557
/** 
 
1558
  Extended but so slower LOG function.
 
1559
 
 
1560
  We have to check if all values are > zero and first one is not one
 
1561
  as these are the cases then result is not a number.
 
1562
*/ 
 
1563
double Item_func_log::val_real()
 
1564
{
 
1565
  assert(fixed == 1);
 
1566
  double value= args[0]->val_real();
 
1567
  if ((null_value= args[0]->null_value))
 
1568
    return 0.0;
 
1569
  if (value <= 0.0)
 
1570
  {
 
1571
    signal_divide_by_null();
 
1572
    return 0.0;
 
1573
  }
 
1574
  if (arg_count == 2)
 
1575
  {
 
1576
    double value2= args[1]->val_real();
 
1577
    if ((null_value= args[1]->null_value))
 
1578
      return 0.0;
 
1579
    if (value2 <= 0.0 || value == 1.0)
 
1580
    {
 
1581
      signal_divide_by_null();
 
1582
      return 0.0;
 
1583
    }
 
1584
    return log(value2) / log(value);
 
1585
  }
 
1586
  return log(value);
 
1587
}
 
1588
 
 
1589
double Item_func_log2::val_real()
 
1590
{
 
1591
  assert(fixed == 1);
 
1592
  double value= args[0]->val_real();
 
1593
 
 
1594
  if ((null_value=args[0]->null_value))
 
1595
    return 0.0;
 
1596
  if (value <= 0.0)
 
1597
  {
 
1598
    signal_divide_by_null();
 
1599
    return 0.0;
 
1600
  }
 
1601
  return log(value) / M_LN2;
 
1602
}
 
1603
 
 
1604
double Item_func_log10::val_real()
 
1605
{
 
1606
  assert(fixed == 1);
 
1607
  double value= args[0]->val_real();
 
1608
  if ((null_value= args[0]->null_value))
 
1609
    return 0.0;
 
1610
  if (value <= 0.0)
 
1611
  {
 
1612
    signal_divide_by_null();
 
1613
    return 0.0;
 
1614
  }
 
1615
  return log10(value);
 
1616
}
 
1617
 
 
1618
double Item_func_exp::val_real()
 
1619
{
 
1620
  assert(fixed == 1);
 
1621
  double value= args[0]->val_real();
 
1622
  if ((null_value=args[0]->null_value))
 
1623
    return 0.0; /* purecov: inspected */
 
1624
  return fix_result(exp(value));
 
1625
}
 
1626
 
 
1627
double Item_func_sqrt::val_real()
 
1628
{
 
1629
  assert(fixed == 1);
 
1630
  double value= args[0]->val_real();
 
1631
  if ((null_value=(args[0]->null_value || value < 0)))
 
1632
    return 0.0; /* purecov: inspected */
 
1633
  return sqrt(value);
 
1634
}
 
1635
 
 
1636
double Item_func_pow::val_real()
 
1637
{
 
1638
  assert(fixed == 1);
 
1639
  double value= args[0]->val_real();
 
1640
  double val2= args[1]->val_real();
 
1641
  if ((null_value=(args[0]->null_value || args[1]->null_value)))
 
1642
    return 0.0; /* purecov: inspected */
 
1643
  return fix_result(pow(value,val2));
 
1644
}
 
1645
 
 
1646
// Trigonometric functions
 
1647
 
 
1648
double Item_func_acos::val_real()
 
1649
{
 
1650
  assert(fixed == 1);
 
1651
  // the volatile's for BUG #2338 to calm optimizer down (because of gcc's bug)
 
1652
  volatile double value= args[0]->val_real();
 
1653
  if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
 
1654
    return 0.0;
 
1655
  return acos(value);
 
1656
}
 
1657
 
 
1658
double Item_func_asin::val_real()
 
1659
{
 
1660
  assert(fixed == 1);
 
1661
  // the volatile's for BUG #2338 to calm optimizer down (because of gcc's bug)
 
1662
  volatile double value= args[0]->val_real();
 
1663
  if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
 
1664
    return 0.0;
 
1665
  return asin(value);
 
1666
}
 
1667
 
 
1668
double Item_func_atan::val_real()
 
1669
{
 
1670
  assert(fixed == 1);
 
1671
  double value= args[0]->val_real();
 
1672
  if ((null_value=args[0]->null_value))
 
1673
    return 0.0;
 
1674
  if (arg_count == 2)
 
1675
  {
 
1676
    double val2= args[1]->val_real();
 
1677
    if ((null_value=args[1]->null_value))
 
1678
      return 0.0;
 
1679
    return fix_result(atan2(value,val2));
 
1680
  }
 
1681
  return atan(value);
 
1682
}
 
1683
 
 
1684
double Item_func_cos::val_real()
 
1685
{
 
1686
  assert(fixed == 1);
 
1687
  double value= args[0]->val_real();
 
1688
  if ((null_value=args[0]->null_value))
 
1689
    return 0.0;
 
1690
  return cos(value);
 
1691
}
 
1692
 
 
1693
double Item_func_sin::val_real()
 
1694
{
 
1695
  assert(fixed == 1);
 
1696
  double value= args[0]->val_real();
 
1697
  if ((null_value=args[0]->null_value))
 
1698
    return 0.0;
 
1699
  return sin(value);
 
1700
}
 
1701
 
 
1702
double Item_func_tan::val_real()
 
1703
{
 
1704
  assert(fixed == 1);
 
1705
  double value= args[0]->val_real();
 
1706
  if ((null_value=args[0]->null_value))
 
1707
    return 0.0;
 
1708
  return fix_result(tan(value));
 
1709
}
 
1710
 
 
1711
 
 
1712
// Shift-functions, same as << and >> in C/C++
 
1713
 
 
1714
 
 
1715
int64_t Item_func_shift_left::val_int()
 
1716
{
 
1717
  assert(fixed == 1);
 
1718
  uint32_t shift;
 
1719
  uint64_t res= ((uint64_t) args[0]->val_int() <<
 
1720
                  (shift=(uint) args[1]->val_int()));
 
1721
  if (args[0]->null_value || args[1]->null_value)
 
1722
  {
 
1723
    null_value=1;
 
1724
    return 0;
 
1725
  }
 
1726
  null_value=0;
 
1727
  return (shift < sizeof(int64_t)*8 ? (int64_t) res : 0L);
 
1728
}
 
1729
 
 
1730
int64_t Item_func_shift_right::val_int()
 
1731
{
 
1732
  assert(fixed == 1);
 
1733
  uint32_t shift;
 
1734
  uint64_t res= (uint64_t) args[0]->val_int() >>
 
1735
    (shift=(uint) args[1]->val_int());
 
1736
  if (args[0]->null_value || args[1]->null_value)
 
1737
  {
 
1738
    null_value=1;
 
1739
    return 0;
 
1740
  }
 
1741
  null_value=0;
 
1742
  return (shift < sizeof(int64_t)*8 ? (int64_t) res : 0);
 
1743
}
 
1744
 
 
1745
 
 
1746
int64_t Item_func_bit_neg::val_int()
 
1747
{
 
1748
  assert(fixed == 1);
 
1749
  uint64_t res= (uint64_t) args[0]->val_int();
 
1750
  if ((null_value=args[0]->null_value))
 
1751
    return 0;
 
1752
  return ~res;
 
1753
}
 
1754
 
 
1755
 
 
1756
// Conversion functions
 
1757
 
 
1758
void Item_func_integer::fix_length_and_dec()
 
1759
{
 
1760
  max_length=args[0]->max_length - args[0]->decimals+1;
 
1761
  uint32_t tmp=float_length(decimals);
 
1762
  set_if_smaller(max_length,tmp);
 
1763
  decimals=0;
 
1764
}
 
1765
 
 
1766
void Item_func_int_val::fix_num_length_and_dec()
 
1767
{
 
1768
  max_length= args[0]->max_length - (args[0]->decimals ?
 
1769
                                     args[0]->decimals + 1 :
 
1770
                                     0) + 2;
 
1771
  uint32_t tmp= float_length(decimals);
 
1772
  set_if_smaller(max_length,tmp);
 
1773
  decimals= 0;
 
1774
}
 
1775
 
 
1776
 
 
1777
void Item_func_int_val::find_num_type()
 
1778
{
 
1779
  switch(hybrid_type= args[0]->result_type())
 
1780
  {
 
1781
  case STRING_RESULT:
 
1782
  case REAL_RESULT:
 
1783
    hybrid_type= REAL_RESULT;
 
1784
    max_length= float_length(decimals);
 
1785
    break;
 
1786
  case INT_RESULT:
 
1787
  case DECIMAL_RESULT:
 
1788
    /*
 
1789
      -2 because in most high position can't be used any digit for int64_t
 
1790
      and one position for increasing value during operation
 
1791
    */
 
1792
    if ((args[0]->max_length - args[0]->decimals) >=
 
1793
        (DECIMAL_LONGLONG_DIGITS - 2))
 
1794
    {
 
1795
      hybrid_type= DECIMAL_RESULT;
 
1796
    }
 
1797
    else
 
1798
    {
 
1799
      unsigned_flag= args[0]->unsigned_flag;
 
1800
      hybrid_type= INT_RESULT;
 
1801
    }
 
1802
    break;
 
1803
  default:
 
1804
    assert(0);
 
1805
  }
 
1806
  return;
 
1807
}
 
1808
 
 
1809
 
 
1810
int64_t Item_func_ceiling::int_op()
 
1811
{
 
1812
  int64_t result;
 
1813
  switch (args[0]->result_type()) {
 
1814
  case INT_RESULT:
 
1815
    result= args[0]->val_int();
 
1816
    null_value= args[0]->null_value;
 
1817
    break;
 
1818
  case DECIMAL_RESULT:
 
1819
  {
 
1820
    my_decimal dec_buf, *dec;
 
1821
    if ((dec= Item_func_ceiling::decimal_op(&dec_buf)))
 
1822
      my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result);
 
1823
    else
 
1824
      result= 0;
 
1825
    break;
 
1826
  }
 
1827
  default:
 
1828
    result= (int64_t)Item_func_ceiling::real_op();
 
1829
  };
 
1830
  return result;
 
1831
}
 
1832
 
 
1833
 
 
1834
double Item_func_ceiling::real_op()
 
1835
{
 
1836
  /*
 
1837
    the volatile's for BUG #3051 to calm optimizer down (because of gcc's
 
1838
    bug)
 
1839
  */
 
1840
  volatile double value= args[0]->val_real();
 
1841
  null_value= args[0]->null_value;
 
1842
  return ceil(value);
 
1843
}
 
1844
 
 
1845
 
 
1846
my_decimal *Item_func_ceiling::decimal_op(my_decimal *decimal_value)
 
1847
{
 
1848
  my_decimal val, *value= args[0]->val_decimal(&val);
 
1849
  if (!(null_value= (args[0]->null_value ||
 
1850
                     my_decimal_ceiling(E_DEC_FATAL_ERROR, value,
 
1851
                                        decimal_value) > 1)))
 
1852
    return decimal_value;
 
1853
  return 0;
 
1854
}
 
1855
 
 
1856
 
 
1857
int64_t Item_func_floor::int_op()
 
1858
{
 
1859
  int64_t result;
 
1860
  switch (args[0]->result_type()) {
 
1861
  case INT_RESULT:
 
1862
    result= args[0]->val_int();
 
1863
    null_value= args[0]->null_value;
 
1864
    break;
 
1865
  case DECIMAL_RESULT:
 
1866
  {
 
1867
    my_decimal dec_buf, *dec;
 
1868
    if ((dec= Item_func_floor::decimal_op(&dec_buf)))
 
1869
      my_decimal2int(E_DEC_FATAL_ERROR, dec, unsigned_flag, &result);
 
1870
    else
 
1871
      result= 0;
 
1872
    break;
 
1873
  }
 
1874
  default:
 
1875
    result= (int64_t)Item_func_floor::real_op();
 
1876
  };
 
1877
  return result;
 
1878
}
 
1879
 
 
1880
 
 
1881
double Item_func_floor::real_op()
 
1882
{
 
1883
  /*
 
1884
    the volatile's for BUG #3051 to calm optimizer down (because of gcc's
 
1885
    bug)
 
1886
  */
 
1887
  volatile double value= args[0]->val_real();
 
1888
  null_value= args[0]->null_value;
 
1889
  return floor(value);
 
1890
}
 
1891
 
 
1892
 
 
1893
my_decimal *Item_func_floor::decimal_op(my_decimal *decimal_value)
 
1894
{
 
1895
  my_decimal val, *value= args[0]->val_decimal(&val);
 
1896
  if (!(null_value= (args[0]->null_value ||
 
1897
                     my_decimal_floor(E_DEC_FATAL_ERROR, value,
 
1898
                                      decimal_value) > 1)))
 
1899
    return decimal_value;
 
1900
  return 0;
 
1901
}
 
1902
 
 
1903
 
 
1904
void Item_func_round::fix_length_and_dec()
 
1905
{
 
1906
  int      decimals_to_set;
 
1907
  int64_t val1;
 
1908
  bool     val1_unsigned;
 
1909
  
 
1910
  unsigned_flag= args[0]->unsigned_flag;
 
1911
  if (!args[1]->const_item())
 
1912
  {
 
1913
    max_length= args[0]->max_length;
 
1914
    decimals= args[0]->decimals;
 
1915
    if (args[0]->result_type() == DECIMAL_RESULT)
 
1916
    {
 
1917
      max_length++;
 
1918
      hybrid_type= DECIMAL_RESULT;
 
1919
    }
 
1920
    else
 
1921
      hybrid_type= REAL_RESULT;
 
1922
    return;
 
1923
  }
 
1924
 
 
1925
  val1= args[1]->val_int();
 
1926
  val1_unsigned= args[1]->unsigned_flag;
 
1927
  if (val1 < 0)
 
1928
    decimals_to_set= val1_unsigned ? INT_MAX : 0;
 
1929
  else
 
1930
    decimals_to_set= (val1 > INT_MAX) ? INT_MAX : (int) val1;
 
1931
 
 
1932
  if (args[0]->decimals == NOT_FIXED_DEC)
 
1933
  {
 
1934
    max_length= args[0]->max_length;
 
1935
    decimals= cmin(decimals_to_set, NOT_FIXED_DEC);
 
1936
    hybrid_type= REAL_RESULT;
 
1937
    return;
 
1938
  }
 
1939
  
 
1940
  switch (args[0]->result_type()) {
 
1941
  case REAL_RESULT:
 
1942
  case STRING_RESULT:
 
1943
    hybrid_type= REAL_RESULT;
 
1944
    decimals= cmin(decimals_to_set, NOT_FIXED_DEC);
 
1945
    max_length= float_length(decimals);
 
1946
    break;
 
1947
  case INT_RESULT:
 
1948
    if ((!decimals_to_set && truncate) || (args[0]->decimal_precision() < DECIMAL_LONGLONG_DIGITS))
 
1949
    {
 
1950
      int length_can_increase= test(!truncate && (val1 < 0) && !val1_unsigned);
 
1951
      max_length= args[0]->max_length + length_can_increase;
 
1952
      /* Here we can keep INT_RESULT */
 
1953
      hybrid_type= INT_RESULT;
 
1954
      decimals= 0;
 
1955
      break;
 
1956
    }
 
1957
    /* fall through */
 
1958
  case DECIMAL_RESULT:
 
1959
  {
 
1960
    hybrid_type= DECIMAL_RESULT;
 
1961
    decimals_to_set= cmin(DECIMAL_MAX_SCALE, decimals_to_set);
 
1962
    int decimals_delta= args[0]->decimals - decimals_to_set;
 
1963
    int precision= args[0]->decimal_precision();
 
1964
    int length_increase= ((decimals_delta <= 0) || truncate) ? 0:1;
 
1965
 
 
1966
    precision-= decimals_delta - length_increase;
 
1967
    decimals= cmin(decimals_to_set, DECIMAL_MAX_SCALE);
 
1968
    max_length= my_decimal_precision_to_length(precision, decimals,
 
1969
                                               unsigned_flag);
 
1970
    break;
 
1971
  }
 
1972
  default:
 
1973
    assert(0); /* This result type isn't handled */
 
1974
  }
 
1975
}
 
1976
 
 
1977
double my_double_round(double value, int64_t dec, bool dec_unsigned,
 
1978
                       bool truncate)
 
1979
{
 
1980
  double tmp;
 
1981
  bool dec_negative= (dec < 0) && !dec_unsigned;
 
1982
  uint64_t abs_dec= dec_negative ? -dec : dec;
 
1983
  /*
 
1984
    tmp2 is here to avoid return the value with 80 bit precision
 
1985
    This will fix that the test round(0.1,1) = round(0.1,1) is true
 
1986
  */
 
1987
  volatile double tmp2;
 
1988
 
 
1989
  tmp=(abs_dec < array_elements(log_10) ?
 
1990
       log_10[abs_dec] : pow(10.0,(double) abs_dec));
 
1991
 
 
1992
  if (dec_negative && isinf(tmp))
 
1993
    tmp2= 0;
 
1994
  else if (!dec_negative && isinf(value * tmp))
 
1995
    tmp2= value;
 
1996
  else if (truncate)
 
1997
  {
 
1998
    if (value >= 0)
 
1999
      tmp2= dec < 0 ? floor(value/tmp)*tmp : floor(value*tmp)/tmp;
 
2000
    else
 
2001
      tmp2= dec < 0 ? ceil(value/tmp)*tmp : ceil(value*tmp)/tmp;
 
2002
  }
 
2003
  else
 
2004
    tmp2=dec < 0 ? rint(value/tmp)*tmp : rint(value*tmp)/tmp;
 
2005
  return tmp2;
 
2006
}
 
2007
 
 
2008
 
 
2009
double Item_func_round::real_op()
 
2010
{
 
2011
  double value= args[0]->val_real();
 
2012
 
 
2013
  if (!(null_value= args[0]->null_value || args[1]->null_value))
 
2014
    return my_double_round(value, args[1]->val_int(), args[1]->unsigned_flag,
 
2015
                           truncate);
 
2016
 
 
2017
  return 0.0;
 
2018
}
 
2019
 
 
2020
/*
 
2021
  Rounds a given value to a power of 10 specified as the 'to' argument,
 
2022
  avoiding overflows when the value is close to the uint64_t range boundary.
 
2023
*/
 
2024
 
 
2025
static inline uint64_t my_unsigned_round(uint64_t value, uint64_t to)
 
2026
{
 
2027
  uint64_t tmp= value / to * to;
 
2028
  return (value - tmp < (to >> 1)) ? tmp : tmp + to;
 
2029
}
 
2030
 
 
2031
 
 
2032
int64_t Item_func_round::int_op()
 
2033
{
 
2034
  int64_t value= args[0]->val_int();
 
2035
  int64_t dec= args[1]->val_int();
 
2036
  decimals= 0;
 
2037
  uint64_t abs_dec;
 
2038
  if ((null_value= args[0]->null_value || args[1]->null_value))
 
2039
    return 0;
 
2040
  if ((dec >= 0) || args[1]->unsigned_flag)
 
2041
    return value; // integer have not digits after point
 
2042
 
 
2043
  abs_dec= -dec;
 
2044
  int64_t tmp;
 
2045
  
 
2046
  if(abs_dec >= array_elements(log_10_int))
 
2047
    return 0;
 
2048
  
 
2049
  tmp= log_10_int[abs_dec];
 
2050
  
 
2051
  if (truncate)
 
2052
    value= (unsigned_flag) ?
 
2053
      ((uint64_t) value / tmp) * tmp : (value / tmp) * tmp;
 
2054
  else
 
2055
    value= (unsigned_flag || value >= 0) ?
 
2056
      my_unsigned_round((uint64_t) value, tmp) :
 
2057
      -(int64_t) my_unsigned_round((uint64_t) -value, tmp);
 
2058
  return value;
 
2059
}
 
2060
 
 
2061
 
 
2062
my_decimal *Item_func_round::decimal_op(my_decimal *decimal_value)
 
2063
{
 
2064
  my_decimal val, *value= args[0]->val_decimal(&val);
 
2065
  int64_t dec= args[1]->val_int();
 
2066
  if (dec >= 0 || args[1]->unsigned_flag)
 
2067
    dec= cmin(dec, (int64_t) decimals);
 
2068
  else if (dec < INT_MIN)
 
2069
    dec= INT_MIN;
 
2070
    
 
2071
  if (!(null_value= (args[0]->null_value || args[1]->null_value ||
 
2072
                     my_decimal_round(E_DEC_FATAL_ERROR, value, (int) dec,
 
2073
                                      truncate, decimal_value) > 1))) 
 
2074
  {
 
2075
    decimal_value->frac= decimals;
 
2076
    return decimal_value;
 
2077
  }
 
2078
  return 0;
 
2079
}
 
2080
 
 
2081
 
 
2082
void Item_func_rand::seed_random(Item *arg)
 
2083
{
 
2084
  /*
 
2085
    TODO: do not do reinit 'rand' for every execute of PS/SP if
 
2086
    args[0] is a constant.
 
2087
  */
 
2088
  uint32_t tmp= (uint32_t) arg->val_int();
 
2089
  randominit(rand, (uint32_t) (tmp*0x10001L+55555555L),
 
2090
             (uint32_t) (tmp*0x10000001L));
 
2091
}
 
2092
 
 
2093
 
 
2094
bool Item_func_rand::fix_fields(THD *thd,Item **ref)
 
2095
{
 
2096
  if (Item_real_func::fix_fields(thd, ref))
 
2097
    return true;
 
2098
  used_tables_cache|= RAND_TABLE_BIT;
 
2099
  if (arg_count)
 
2100
  {                                     // Only use argument once in query
 
2101
    /*
 
2102
      No need to send a Rand log event if seed was given eg: RAND(seed),
 
2103
      as it will be replicated in the query as such.
 
2104
    */
 
2105
    if (!rand && !(rand= (struct rand_struct*)
 
2106
                   thd->alloc(sizeof(*rand))))
 
2107
      return true;
 
2108
 
 
2109
    if (args[0]->const_item())
 
2110
      seed_random (args[0]);
 
2111
  }
 
2112
  else
 
2113
  {
 
2114
    /*
 
2115
      Save the seed only the first time RAND() is used in the query
 
2116
      Once events are forwarded rather than recreated,
 
2117
      the following can be skipped if inside the slave thread
 
2118
    */
 
2119
    if (!thd->rand_used)
 
2120
    {
 
2121
      thd->rand_used= 1;
 
2122
      thd->rand_saved_seed1= thd->rand.seed1;
 
2123
      thd->rand_saved_seed2= thd->rand.seed2;
 
2124
    }
 
2125
    rand= &thd->rand;
 
2126
  }
 
2127
  return false;
 
2128
}
 
2129
 
 
2130
void Item_func_rand::update_used_tables()
 
2131
{
 
2132
  Item_real_func::update_used_tables();
 
2133
  used_tables_cache|= RAND_TABLE_BIT;
 
2134
}
 
2135
 
 
2136
 
 
2137
double Item_func_rand::val_real()
 
2138
{
 
2139
  assert(fixed == 1);
 
2140
  if (arg_count && !args[0]->const_item())
 
2141
    seed_random (args[0]);
 
2142
  return my_rnd(rand);
 
2143
}
 
2144
 
 
2145
int64_t Item_func_sign::val_int()
 
2146
{
 
2147
  assert(fixed == 1);
 
2148
  double value= args[0]->val_real();
 
2149
  null_value=args[0]->null_value;
 
2150
  return value < 0.0 ? -1 : (value > 0 ? 1 : 0);
 
2151
}
 
2152
 
 
2153
 
 
2154
double Item_func_units::val_real()
 
2155
{
 
2156
  assert(fixed == 1);
 
2157
  double value= args[0]->val_real();
 
2158
  if ((null_value=args[0]->null_value))
 
2159
    return 0;
 
2160
  return value*mul+add;
 
2161
}
 
2162
 
 
2163
 
 
2164
void Item_func_min_max::fix_length_and_dec()
 
2165
{
 
2166
  int max_int_part=0;
 
2167
  bool datetime_found= false;
 
2168
  decimals=0;
 
2169
  max_length=0;
 
2170
  maybe_null=0;
 
2171
  cmp_type=args[0]->result_type();
 
2172
 
 
2173
  for (uint32_t i=0 ; i < arg_count ; i++)
 
2174
  {
 
2175
    set_if_bigger(max_length, args[i]->max_length);
 
2176
    set_if_bigger(decimals, args[i]->decimals);
 
2177
    set_if_bigger(max_int_part, args[i]->decimal_int_part());
 
2178
    if (args[i]->maybe_null)
 
2179
      maybe_null=1;
 
2180
    cmp_type=item_cmp_type(cmp_type,args[i]->result_type());
 
2181
    if (args[i]->result_type() != ROW_RESULT && args[i]->is_datetime())
 
2182
    {
 
2183
      datetime_found= true;
 
2184
      if (!datetime_item || args[i]->field_type() == DRIZZLE_TYPE_DATETIME)
 
2185
        datetime_item= args[i];
 
2186
    }
 
2187
  }
 
2188
  if (cmp_type == STRING_RESULT)
 
2189
  {
 
2190
    agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV, 1);
 
2191
    if (datetime_found)
 
2192
    {
 
2193
      thd= current_thd;
 
2194
      compare_as_dates= true;
 
2195
    }
 
2196
  }
 
2197
  else if ((cmp_type == DECIMAL_RESULT) || (cmp_type == INT_RESULT))
 
2198
    max_length= my_decimal_precision_to_length(max_int_part+decimals, decimals,
 
2199
                                            unsigned_flag);
 
2200
  cached_field_type= agg_field_type(args, arg_count);
 
2201
}
 
2202
 
 
2203
 
 
2204
/*
 
2205
  Compare item arguments in the DATETIME context.
 
2206
 
 
2207
  SYNOPSIS
 
2208
    cmp_datetimes()
 
2209
    value [out]   found least/greatest DATE/DATETIME value
 
2210
 
 
2211
  DESCRIPTION
 
2212
    Compare item arguments as DATETIME values and return the index of the
 
2213
    least/greatest argument in the arguments array.
 
2214
    The correct integer DATE/DATETIME value of the found argument is
 
2215
    stored to the value pointer, if latter is provided.
 
2216
 
 
2217
  RETURN
 
2218
   0    If one of arguments is NULL
 
2219
   #    index of the least/greatest argument
 
2220
*/
 
2221
 
 
2222
uint32_t Item_func_min_max::cmp_datetimes(uint64_t *value)
 
2223
{
 
2224
  uint64_t min_max= 0;
 
2225
  uint32_t min_max_idx= 0;
 
2226
 
 
2227
  for (uint32_t i=0; i < arg_count ; i++)
 
2228
  {
 
2229
    Item **arg= args + i;
 
2230
    bool is_null;
 
2231
    uint64_t res= get_datetime_value(thd, &arg, 0, datetime_item, &is_null);
 
2232
    if ((null_value= args[i]->null_value))
 
2233
      return 0;
 
2234
    if (i == 0 || (res < min_max ? cmp_sign : -cmp_sign) > 0)
 
2235
    {
 
2236
      min_max= res;
 
2237
      min_max_idx= i;
 
2238
    }
 
2239
  }
 
2240
  if (value)
 
2241
  {
 
2242
    *value= min_max;
 
2243
    if (datetime_item->field_type() == DRIZZLE_TYPE_NEWDATE)
 
2244
      *value/= 1000000L;
 
2245
  }
 
2246
  return min_max_idx;
 
2247
}
 
2248
 
 
2249
 
 
2250
String *Item_func_min_max::val_str(String *str)
 
2251
{
 
2252
  assert(fixed == 1);
 
2253
  if (compare_as_dates)
 
2254
  {
 
2255
    String *str_res;
 
2256
    uint32_t min_max_idx= cmp_datetimes(NULL);
 
2257
    if (null_value)
 
2258
      return 0;
 
2259
    str_res= args[min_max_idx]->val_str(str);
 
2260
    str_res->set_charset(collation.collation);
 
2261
    return str_res;
 
2262
  }
 
2263
  switch (cmp_type) {
 
2264
  case INT_RESULT:
 
2265
  {
 
2266
    int64_t nr=val_int();
 
2267
    if (null_value)
 
2268
      return 0;
 
2269
    str->set_int(nr, unsigned_flag, &my_charset_bin);
 
2270
    return str;
 
2271
  }
 
2272
  case DECIMAL_RESULT:
 
2273
  {
 
2274
    my_decimal dec_buf, *dec_val= val_decimal(&dec_buf);
 
2275
    if (null_value)
 
2276
      return 0;
 
2277
    my_decimal2string(E_DEC_FATAL_ERROR, dec_val, 0, 0, 0, str);
 
2278
    return str;
 
2279
  }
 
2280
  case REAL_RESULT:
 
2281
  {
 
2282
    double nr= val_real();
 
2283
    if (null_value)
 
2284
      return 0; /* purecov: inspected */
 
2285
    str->set_real(nr,decimals,&my_charset_bin);
 
2286
    return str;
 
2287
  }
 
2288
  case STRING_RESULT:
 
2289
  {
 
2290
    String *res= NULL;
 
2291
 
 
2292
    for (uint32_t i=0; i < arg_count ; i++)
 
2293
    {
 
2294
      if (i == 0)
 
2295
        res=args[i]->val_str(str);
 
2296
      else
 
2297
      {
 
2298
        String *res2;
 
2299
        res2= args[i]->val_str(res == str ? &tmp_value : str);
 
2300
        if (res2)
 
2301
        {
 
2302
          int cmp= sortcmp(res,res2,collation.collation);
 
2303
          if ((cmp_sign < 0 ? cmp : -cmp) < 0)
 
2304
            res=res2;
 
2305
        }
 
2306
      }
 
2307
      if ((null_value= args[i]->null_value))
 
2308
        return 0;
 
2309
    }
 
2310
    res->set_charset(collation.collation);
 
2311
    return res;
 
2312
  }
 
2313
  case ROW_RESULT:
 
2314
  default:
 
2315
    // This case should never be chosen
 
2316
    assert(0);
 
2317
    return 0;
 
2318
  }
 
2319
  return 0;                                     // Keep compiler happy
 
2320
}
 
2321
 
 
2322
 
 
2323
double Item_func_min_max::val_real()
 
2324
{
 
2325
  assert(fixed == 1);
 
2326
  double value=0.0;
 
2327
  if (compare_as_dates)
 
2328
  {
 
2329
    uint64_t result= 0;
 
2330
    (void)cmp_datetimes(&result);
 
2331
    return (double)result;
 
2332
  }
 
2333
  for (uint32_t i=0; i < arg_count ; i++)
 
2334
  {
 
2335
    if (i == 0)
 
2336
      value= args[i]->val_real();
 
2337
    else
 
2338
    {
 
2339
      double tmp= args[i]->val_real();
 
2340
      if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
 
2341
        value=tmp;
 
2342
    }
 
2343
    if ((null_value= args[i]->null_value))
 
2344
      break;
 
2345
  }
 
2346
  return value;
 
2347
}
 
2348
 
 
2349
 
 
2350
int64_t Item_func_min_max::val_int()
 
2351
{
 
2352
  assert(fixed == 1);
 
2353
  int64_t value=0;
 
2354
  if (compare_as_dates)
 
2355
  {
 
2356
    uint64_t result= 0;
 
2357
    (void)cmp_datetimes(&result);
 
2358
    return (int64_t)result;
 
2359
  }
 
2360
  for (uint32_t i=0; i < arg_count ; i++)
 
2361
  {
 
2362
    if (i == 0)
 
2363
      value=args[i]->val_int();
 
2364
    else
 
2365
    {
 
2366
      int64_t tmp=args[i]->val_int();
 
2367
      if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
 
2368
        value=tmp;
 
2369
    }
 
2370
    if ((null_value= args[i]->null_value))
 
2371
      break;
 
2372
  }
 
2373
  return value;
 
2374
}
 
2375
 
 
2376
 
 
2377
my_decimal *Item_func_min_max::val_decimal(my_decimal *dec)
 
2378
{
 
2379
  assert(fixed == 1);
 
2380
  my_decimal tmp_buf, *tmp, *res= NULL;
 
2381
 
 
2382
  if (compare_as_dates)
 
2383
  {
 
2384
    uint64_t value= 0;
 
2385
    (void)cmp_datetimes(&value);
 
2386
    uint64_t2decimal(value, dec);
 
2387
    return dec;
 
2388
  }
 
2389
  for (uint32_t i=0; i < arg_count ; i++)
 
2390
  {
 
2391
    if (i == 0)
 
2392
      res= args[i]->val_decimal(dec);
 
2393
    else
 
2394
    {
 
2395
      tmp= args[i]->val_decimal(&tmp_buf);      // Zero if NULL
 
2396
      if (tmp && (my_decimal_cmp(tmp, res) * cmp_sign) < 0)
 
2397
      {
 
2398
        if (tmp == &tmp_buf)
 
2399
        {
 
2400
          /* Move value out of tmp_buf as this will be reused on next loop */
 
2401
          my_decimal2decimal(tmp, dec);
 
2402
          res= dec;
 
2403
        }
 
2404
        else
 
2405
          res= tmp;
 
2406
      }
 
2407
    }
 
2408
    if ((null_value= args[i]->null_value))
 
2409
    {
 
2410
      res= 0;
 
2411
      break;
 
2412
    }
 
2413
  }
 
2414
  return res;
 
2415
}
 
2416
 
 
2417
 
 
2418
int64_t Item_func_length::val_int()
 
2419
{
 
2420
  assert(fixed == 1);
 
2421
  String *res=args[0]->val_str(&value);
 
2422
  if (!res)
 
2423
  {
 
2424
    null_value=1;
 
2425
    return 0; /* purecov: inspected */
 
2426
  }
 
2427
  null_value=0;
 
2428
  return (int64_t) res->length();
 
2429
}
 
2430
 
 
2431
 
 
2432
int64_t Item_func_char_length::val_int()
 
2433
{
 
2434
  assert(fixed == 1);
 
2435
  String *res=args[0]->val_str(&value);
 
2436
  if (!res)
 
2437
  {
 
2438
    null_value=1;
 
2439
    return 0; /* purecov: inspected */
 
2440
  }
 
2441
  null_value=0;
 
2442
  return (int64_t) res->numchars();
 
2443
}
 
2444
 
 
2445
 
 
2446
int64_t Item_func_coercibility::val_int()
 
2447
{
 
2448
  assert(fixed == 1);
 
2449
  null_value= 0;
 
2450
  return (int64_t) args[0]->collation.derivation;
 
2451
}
 
2452
 
 
2453
 
 
2454
void Item_func_locate::fix_length_and_dec()
 
2455
{
 
2456
  max_length= MY_INT32_NUM_DECIMAL_DIGITS;
 
2457
  agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV, 1);
 
2458
}
 
2459
 
 
2460
 
 
2461
int64_t Item_func_locate::val_int()
 
2462
{
 
2463
  assert(fixed == 1);
 
2464
  String *a=args[0]->val_str(&value1);
 
2465
  String *b=args[1]->val_str(&value2);
 
2466
  if (!a || !b)
 
2467
  {
 
2468
    null_value=1;
 
2469
    return 0; /* purecov: inspected */
 
2470
  }
 
2471
  null_value=0;
 
2472
  /* must be int64_t to avoid truncation */
 
2473
  int64_t start=  0; 
 
2474
  int64_t start0= 0;
 
2475
  my_match_t match;
 
2476
 
 
2477
  if (arg_count == 3)
 
2478
  {
 
2479
    start0= start= args[2]->val_int() - 1;
 
2480
 
 
2481
    if ((start < 0) || (start > a->length()))
 
2482
      return 0;
 
2483
 
 
2484
    /* start is now sufficiently valid to pass to charpos function */
 
2485
    start= a->charpos((int) start);
 
2486
 
 
2487
    if (start + b->length() > a->length())
 
2488
      return 0;
 
2489
  }
 
2490
 
 
2491
  if (!b->length())                             // Found empty string at start
 
2492
    return start + 1;
 
2493
  
 
2494
  if (!cmp_collation.collation->coll->instr(cmp_collation.collation,
 
2495
                                            a->ptr()+start,
 
2496
                                            (uint) (a->length()-start),
 
2497
                                            b->ptr(), b->length(),
 
2498
                                            &match, 1))
 
2499
    return 0;
 
2500
  return (int64_t) match.mb_len + start0 + 1;
 
2501
}
 
2502
 
 
2503
 
 
2504
void Item_func_locate::print(String *str, enum_query_type query_type)
 
2505
{
 
2506
  str->append(STRING_WITH_LEN("locate("));
 
2507
  args[1]->print(str, query_type);
 
2508
  str->append(',');
 
2509
  args[0]->print(str, query_type);
 
2510
  if (arg_count == 3)
 
2511
  {
 
2512
    str->append(',');
 
2513
    args[2]->print(str, query_type);
 
2514
  }
 
2515
  str->append(')');
 
2516
}
 
2517
 
 
2518
 
 
2519
int64_t Item_func_field::val_int()
 
2520
{
 
2521
  assert(fixed == 1);
 
2522
 
 
2523
  if (cmp_type == STRING_RESULT)
 
2524
  {
 
2525
    String *field;
 
2526
    if (!(field= args[0]->val_str(&value)))
 
2527
      return 0;
 
2528
    for (uint32_t i=1 ; i < arg_count ; i++)
 
2529
    {
 
2530
      String *tmp_value=args[i]->val_str(&tmp);
 
2531
      if (tmp_value && !sortcmp(field,tmp_value,cmp_collation.collation))
 
2532
        return (int64_t) (i);
 
2533
    }
 
2534
  }
 
2535
  else if (cmp_type == INT_RESULT)
 
2536
  {
 
2537
    int64_t val= args[0]->val_int();
 
2538
    if (args[0]->null_value)
 
2539
      return 0;
 
2540
    for (uint32_t i=1; i < arg_count ; i++)
 
2541
    {
 
2542
      if (val == args[i]->val_int() && !args[i]->null_value)
 
2543
        return (int64_t) (i);
 
2544
    }
 
2545
  }
 
2546
  else if (cmp_type == DECIMAL_RESULT)
 
2547
  {
 
2548
    my_decimal dec_arg_buf, *dec_arg,
 
2549
               dec_buf, *dec= args[0]->val_decimal(&dec_buf);
 
2550
    if (args[0]->null_value)
 
2551
      return 0;
 
2552
    for (uint32_t i=1; i < arg_count; i++)
 
2553
    {
 
2554
      dec_arg= args[i]->val_decimal(&dec_arg_buf);
 
2555
      if (!args[i]->null_value && !my_decimal_cmp(dec_arg, dec))
 
2556
        return (int64_t) (i);
 
2557
    }
 
2558
  }
 
2559
  else
 
2560
  {
 
2561
    double val= args[0]->val_real();
 
2562
    if (args[0]->null_value)
 
2563
      return 0;
 
2564
    for (uint32_t i=1; i < arg_count ; i++)
 
2565
    {
 
2566
      if (val == args[i]->val_real() && !args[i]->null_value)
 
2567
        return (int64_t) (i);
 
2568
    }
 
2569
  }
 
2570
  return 0;
 
2571
}
 
2572
 
 
2573
 
 
2574
void Item_func_field::fix_length_and_dec()
 
2575
{
 
2576
  maybe_null=0; max_length=3;
 
2577
  cmp_type= args[0]->result_type();
 
2578
  for (uint32_t i=1; i < arg_count ; i++)
 
2579
    cmp_type= item_cmp_type(cmp_type, args[i]->result_type());
 
2580
  if (cmp_type == STRING_RESULT)
 
2581
    agg_arg_charsets(cmp_collation, args, arg_count, MY_COLL_CMP_CONV, 1);
 
2582
}
 
2583
 
 
2584
 
 
2585
int64_t Item_func_ascii::val_int()
 
2586
{
 
2587
  assert(fixed == 1);
 
2588
  String *res=args[0]->val_str(&value);
 
2589
  if (!res)
 
2590
  {
 
2591
    null_value=1;
 
2592
    return 0;
 
2593
  }
 
2594
  null_value=0;
 
2595
  return (int64_t) (res->length() ? (unsigned char) (*res)[0] : (unsigned char) 0);
 
2596
}
 
2597
 
 
2598
int64_t Item_func_ord::val_int()
 
2599
{
 
2600
  assert(fixed == 1);
 
2601
  String *res=args[0]->val_str(&value);
 
2602
  if (!res)
 
2603
  {
 
2604
    null_value=1;
 
2605
    return 0;
 
2606
  }
 
2607
  null_value=0;
 
2608
  if (!res->length()) return 0;
 
2609
#ifdef USE_MB
 
2610
  if (use_mb(res->charset()))
 
2611
  {
 
2612
    register const char *str=res->ptr();
 
2613
    register uint32_t n=0, l=my_ismbchar(res->charset(),str,str+res->length());
 
2614
    if (!l)
 
2615
      return (int64_t)((unsigned char) *str);
 
2616
    while (l--)
 
2617
      n=(n<<8)|(uint32_t)((unsigned char) *str++);
 
2618
    return (int64_t) n;
 
2619
  }
 
2620
#endif
 
2621
  return (int64_t) ((unsigned char) (*res)[0]);
 
2622
}
 
2623
 
 
2624
        /* Search after a string in a string of strings separated by ',' */
 
2625
        /* Returns number of found type >= 1 or 0 if not found */
 
2626
        /* This optimizes searching in enums to bit testing! */
 
2627
 
 
2628
void Item_func_find_in_set::fix_length_and_dec()
 
2629
{
 
2630
  decimals=0;
 
2631
  max_length=3;                                 // 1-999
 
2632
  agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV, 1);
 
2633
}
 
2634
 
 
2635
static const char separator=',';
 
2636
 
 
2637
int64_t Item_func_find_in_set::val_int()
 
2638
{
 
2639
  assert(fixed == 1);
 
2640
  if (enum_value)
 
2641
  {
 
2642
    uint64_t tmp=(uint64_t) args[1]->val_int();
 
2643
    if (!(null_value=args[1]->null_value || args[0]->null_value))
 
2644
    {
 
2645
      if (tmp & enum_bit)
 
2646
        return enum_value;
 
2647
    }
 
2648
    return 0L;
 
2649
  }
 
2650
 
 
2651
  String *find=args[0]->val_str(&value);
 
2652
  String *buffer=args[1]->val_str(&value2);
 
2653
  if (!find || !buffer)
 
2654
  {
 
2655
    null_value=1;
 
2656
    return 0; /* purecov: inspected */
 
2657
  }
 
2658
  null_value=0;
 
2659
 
 
2660
  int diff;
 
2661
  if ((diff=buffer->length() - find->length()) >= 0)
 
2662
  {
 
2663
    my_wc_t wc;
 
2664
    const CHARSET_INFO * const cs= cmp_collation.collation;
 
2665
    const char *str_begin= buffer->ptr();
 
2666
    const char *str_end= buffer->ptr();
 
2667
    const char *real_end= str_end+buffer->length();
 
2668
    const unsigned char *find_str= (const unsigned char *) find->ptr();
 
2669
    uint32_t find_str_len= find->length();
 
2670
    int position= 0;
 
2671
    while (1)
 
2672
    {
 
2673
      int symbol_len;
 
2674
      if ((symbol_len= cs->cset->mb_wc(cs, &wc, (unsigned char*) str_end, 
 
2675
                                       (unsigned char*) real_end)) > 0)
 
2676
      {
 
2677
        const char *substr_end= str_end + symbol_len;
 
2678
        bool is_last_item= (substr_end == real_end);
 
2679
        bool is_separator= (wc == (my_wc_t) separator);
 
2680
        if (is_separator || is_last_item)
 
2681
        {
 
2682
          position++;
 
2683
          if (is_last_item && !is_separator)
 
2684
            str_end= substr_end;
 
2685
          if (!my_strnncoll(cs, (const unsigned char *) str_begin,
 
2686
                            str_end - str_begin,
 
2687
                            find_str, find_str_len))
 
2688
            return (int64_t) position;
 
2689
          else
 
2690
            str_begin= substr_end;
 
2691
        }
 
2692
        str_end= substr_end;
 
2693
      }
 
2694
      else if (str_end - str_begin == 0 &&
 
2695
               find_str_len == 0 &&
 
2696
               wc == (my_wc_t) separator)
 
2697
        return (int64_t) ++position;
 
2698
      else
 
2699
        return 0L;
 
2700
    }
 
2701
  }
 
2702
  return 0;
 
2703
}
 
2704
 
 
2705
int64_t Item_func_bit_count::val_int()
 
2706
{
 
2707
  assert(fixed == 1);
 
2708
  uint64_t value= (uint64_t) args[0]->val_int();
 
2709
  if ((null_value= args[0]->null_value))
 
2710
    return 0; /* purecov: inspected */
 
2711
  return (int64_t) my_count_bits(value);
 
2712
}
 
2713
 
 
2714
/*
 
2715
** User level locks
 
2716
*/
 
2717
 
 
2718
pthread_mutex_t LOCK_user_locks;
 
2719
static HASH hash_user_locks;
 
2720
 
 
2721
class User_level_lock
 
2722
{
 
2723
  unsigned char *key;
 
2724
  size_t key_length;
 
2725
 
 
2726
public:
 
2727
  int count;
 
2728
  bool locked;
 
2729
  pthread_cond_t cond;
 
2730
  my_thread_id thread_id;
 
2731
  void set_thread(THD *thd) { thread_id= thd->thread_id; }
 
2732
 
 
2733
  User_level_lock(const unsigned char *key_arg,uint32_t length, ulong id) 
 
2734
    :key_length(length),count(1),locked(1), thread_id(id)
 
2735
  {
 
2736
    key= (unsigned char*) my_memdup(key_arg,length,MYF(0));
 
2737
    pthread_cond_init(&cond,NULL);
 
2738
    if (key)
 
2739
    {
 
2740
      if (my_hash_insert(&hash_user_locks,(unsigned char*) this))
 
2741
      {
 
2742
        free(key);
 
2743
        key=0;
 
2744
      }
 
2745
    }
 
2746
  }
 
2747
  ~User_level_lock()
 
2748
  {
 
2749
    if (key)
 
2750
    {
 
2751
      hash_delete(&hash_user_locks,(unsigned char*) this);
 
2752
      free(key);
 
2753
    }
 
2754
    pthread_cond_destroy(&cond);
 
2755
  }
 
2756
  inline bool initialized() { return key != 0; }
 
2757
  friend void item_user_lock_release(User_level_lock *ull);
 
2758
  friend unsigned char *ull_get_key(const User_level_lock *ull, size_t *length,
 
2759
                            bool not_used);
 
2760
};
 
2761
 
 
2762
unsigned char *ull_get_key(const User_level_lock *ull, size_t *length,
 
2763
                   bool not_used __attribute__((unused)))
 
2764
{
 
2765
  *length= ull->key_length;
 
2766
  return ull->key;
 
2767
}
 
2768
 
 
2769
 
 
2770
static bool item_user_lock_inited= 0;
 
2771
 
 
2772
void item_user_lock_init(void)
 
2773
{
 
2774
  pthread_mutex_init(&LOCK_user_locks,MY_MUTEX_INIT_SLOW);
 
2775
  hash_init(&hash_user_locks, system_charset_info,
 
2776
            16,0,0,(hash_get_key) ull_get_key,NULL,0);
 
2777
  item_user_lock_inited= 1;
 
2778
}
 
2779
 
 
2780
void item_user_lock_free(void)
 
2781
{
 
2782
  if (item_user_lock_inited)
 
2783
  {
 
2784
    item_user_lock_inited= 0;
 
2785
    hash_free(&hash_user_locks);
 
2786
    pthread_mutex_destroy(&LOCK_user_locks);
 
2787
  }
 
2788
}
 
2789
 
 
2790
void item_user_lock_release(User_level_lock *ull)
 
2791
{
 
2792
  ull->locked=0;
 
2793
  ull->thread_id= 0;
 
2794
  if (--ull->count)
 
2795
    pthread_cond_signal(&ull->cond);
 
2796
  else
 
2797
    delete ull;
 
2798
}
 
2799
 
 
2800
/**
 
2801
  Wait until we are at or past the given position in the master binlog
 
2802
  on the slave.
 
2803
*/
 
2804
 
 
2805
int64_t Item_master_pos_wait::val_int()
 
2806
{
 
2807
  assert(fixed == 1);
 
2808
  THD* thd = current_thd;
 
2809
  String *log_name = args[0]->val_str(&value);
 
2810
  int event_count= 0;
 
2811
 
 
2812
  null_value=0;
 
2813
  if (thd->slave_thread || !log_name || !log_name->length())
 
2814
  {
 
2815
    null_value = 1;
 
2816
    return 0;
 
2817
  }
 
2818
  int64_t pos = (ulong)args[1]->val_int();
 
2819
  int64_t timeout = (arg_count==3) ? args[2]->val_int() : 0 ;
 
2820
  if ((event_count = active_mi->rli.wait_for_pos(thd, log_name, pos, timeout)) == -2)
 
2821
  {
 
2822
    null_value = 1;
 
2823
    event_count=0;
 
2824
  }
 
2825
  return event_count;
 
2826
}
 
2827
 
 
2828
#ifdef EXTRA_DEBUG
 
2829
void debug_sync_point(const char* lock_name, uint32_t lock_timeout)
 
2830
{
 
2831
}
 
2832
 
 
2833
#endif
 
2834
 
 
2835
 
 
2836
int64_t Item_func_last_insert_id::val_int()
 
2837
{
 
2838
  THD *thd= current_thd;
 
2839
  assert(fixed == 1);
 
2840
  if (arg_count)
 
2841
  {
 
2842
    int64_t value= args[0]->val_int();
 
2843
    null_value= args[0]->null_value;
 
2844
    /*
 
2845
      LAST_INSERT_ID(X) must affect the client's mysql_insert_id() as
 
2846
      documented in the manual. We don't want to touch
 
2847
      first_successful_insert_id_in_cur_stmt because it would make
 
2848
      LAST_INSERT_ID(X) take precedence over an generated auto_increment
 
2849
      value for this row.
 
2850
    */
 
2851
    thd->arg_of_last_insert_id_function= true;
 
2852
    thd->first_successful_insert_id_in_prev_stmt= value;
 
2853
    return value;
 
2854
  }
 
2855
  return thd->read_first_successful_insert_id_in_prev_stmt();
 
2856
}
 
2857
 
 
2858
 
 
2859
bool Item_func_last_insert_id::fix_fields(THD *thd, Item **ref)
 
2860
{
 
2861
  return Item_int_func::fix_fields(thd, ref);
 
2862
}
 
2863
 
 
2864
 
 
2865
/* This function is just used to test speed of different functions */
 
2866
 
 
2867
int64_t Item_func_benchmark::val_int()
 
2868
{
 
2869
  assert(fixed == 1);
 
2870
  char buff[MAX_FIELD_WIDTH];
 
2871
  String tmp(buff,sizeof(buff), &my_charset_bin);
 
2872
  my_decimal tmp_decimal;
 
2873
  THD *thd=current_thd;
 
2874
  uint64_t loop_count;
 
2875
 
 
2876
  loop_count= (uint64_t) args[0]->val_int();
 
2877
 
 
2878
  if (args[0]->null_value ||
 
2879
      (!args[0]->unsigned_flag && (((int64_t) loop_count) < 0)))
 
2880
  {
 
2881
    if (!args[0]->null_value)
 
2882
    {
 
2883
      char buff[22];
 
2884
      llstr(((int64_t) loop_count), buff);
 
2885
      push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
2886
                          ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
 
2887
                          "count", buff, "benchmark");
 
2888
    }
 
2889
 
 
2890
    null_value= 1;
 
2891
    return 0;
 
2892
  }
 
2893
 
 
2894
  null_value=0;
 
2895
  for (uint64_t loop=0 ; loop < loop_count && !thd->killed; loop++)
 
2896
  {
 
2897
    switch (args[1]->result_type()) {
 
2898
    case REAL_RESULT:
 
2899
      (void) args[1]->val_real();
 
2900
      break;
 
2901
    case INT_RESULT:
 
2902
      (void) args[1]->val_int();
 
2903
      break;
 
2904
    case STRING_RESULT:
 
2905
      (void) args[1]->val_str(&tmp);
 
2906
      break;
 
2907
    case DECIMAL_RESULT:
 
2908
      (void) args[1]->val_decimal(&tmp_decimal);
 
2909
      break;
 
2910
    case ROW_RESULT:
 
2911
    default:
 
2912
      // This case should never be chosen
 
2913
      assert(0);
 
2914
      return 0;
 
2915
    }
 
2916
  }
 
2917
  return 0;
 
2918
}
 
2919
 
 
2920
 
 
2921
void Item_func_benchmark::print(String *str, enum_query_type query_type)
 
2922
{
 
2923
  str->append(STRING_WITH_LEN("benchmark("));
 
2924
  args[0]->print(str, query_type);
 
2925
  str->append(',');
 
2926
  args[1]->print(str, query_type);
 
2927
  str->append(')');
 
2928
}
 
2929
 
 
2930
#define extra_size sizeof(double)
 
2931
 
 
2932
static user_var_entry *get_variable(HASH *hash, LEX_STRING &name,
 
2933
                                    bool create_if_not_exists)
 
2934
{
 
2935
  user_var_entry *entry;
 
2936
 
 
2937
  if (!(entry = (user_var_entry*) hash_search(hash, (unsigned char*) name.str,
 
2938
                                              name.length)) &&
 
2939
      create_if_not_exists)
 
2940
  {
 
2941
    uint32_t size=ALIGN_SIZE(sizeof(user_var_entry))+name.length+1+extra_size;
 
2942
    if (!hash_inited(hash))
 
2943
      return 0;
 
2944
    if (!(entry = (user_var_entry*) my_malloc(size,MYF(MY_WME | ME_FATALERROR))))
 
2945
      return 0;
 
2946
    entry->name.str=(char*) entry+ ALIGN_SIZE(sizeof(user_var_entry))+
 
2947
      extra_size;
 
2948
    entry->name.length=name.length;
 
2949
    entry->value=0;
 
2950
    entry->length=0;
 
2951
    entry->update_query_id=0;
 
2952
    entry->collation.set(NULL, DERIVATION_IMPLICIT, 0);
 
2953
    entry->unsigned_flag= 0;
 
2954
    /*
 
2955
      If we are here, we were called from a SET or a query which sets a
 
2956
      variable. Imagine it is this:
 
2957
      INSERT INTO t SELECT @a:=10, @a:=@a+1.
 
2958
      Then when we have a Item_func_get_user_var (because of the @a+1) so we
 
2959
      think we have to write the value of @a to the binlog. But before that,
 
2960
      we have a Item_func_set_user_var to create @a (@a:=10), in this we mark
 
2961
      the variable as "already logged" (line below) so that it won't be logged
 
2962
      by Item_func_get_user_var (because that's not necessary).
 
2963
    */
 
2964
    entry->used_query_id=current_thd->query_id;
 
2965
    entry->type=STRING_RESULT;
 
2966
    memcpy(entry->name.str, name.str, name.length+1);
 
2967
    if (my_hash_insert(hash,(unsigned char*) entry))
 
2968
    {
 
2969
      free((char*) entry);
 
2970
      return 0;
 
2971
    }
 
2972
  }
 
2973
  return entry;
 
2974
}
 
2975
 
 
2976
/*
 
2977
  When a user variable is updated (in a SET command or a query like
 
2978
  SELECT @a:= ).
 
2979
*/
 
2980
 
 
2981
bool Item_func_set_user_var::fix_fields(THD *thd, Item **ref)
 
2982
{
 
2983
  assert(fixed == 0);
 
2984
  /* fix_fields will call Item_func_set_user_var::fix_length_and_dec */
 
2985
  if (Item_func::fix_fields(thd, ref) ||
 
2986
      !(entry= get_variable(&thd->user_vars, name, 1)))
 
2987
    return true;
 
2988
  /* 
 
2989
     Remember the last query which updated it, this way a query can later know
 
2990
     if this variable is a constant item in the query (it is if update_query_id
 
2991
     is different from query_id).
 
2992
  */
 
2993
  entry->update_query_id= thd->query_id;
 
2994
  /*
 
2995
    As it is wrong and confusing to associate any 
 
2996
    character set with NULL, @a should be latin2
 
2997
    after this query sequence:
 
2998
 
 
2999
      SET @a=_latin2'string';
 
3000
      SET @a=NULL;
 
3001
 
 
3002
    I.e. the second query should not change the charset
 
3003
    to the current default value, but should keep the 
 
3004
    original value assigned during the first query.
 
3005
    In order to do it, we don't copy charset
 
3006
    from the argument if the argument is NULL
 
3007
    and the variable has previously been initialized.
 
3008
  */
 
3009
  null_item= (args[0]->type() == NULL_ITEM);
 
3010
  if (!entry->collation.collation || !null_item)
 
3011
    entry->collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
 
3012
  collation.set(entry->collation.collation, DERIVATION_IMPLICIT);
 
3013
  cached_result_type= args[0]->result_type();
 
3014
  return false;
 
3015
}
 
3016
 
 
3017
 
 
3018
void
 
3019
Item_func_set_user_var::fix_length_and_dec()
 
3020
{
 
3021
  maybe_null=args[0]->maybe_null;
 
3022
  max_length=args[0]->max_length;
 
3023
  decimals=args[0]->decimals;
 
3024
  collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
 
3025
}
 
3026
 
 
3027
 
 
3028
/*
 
3029
  Mark field in read_map
 
3030
 
 
3031
  NOTES
 
3032
    This is used by filesort to register used fields in a a temporary
 
3033
    column read set or to register used fields in a view
 
3034
*/
 
3035
 
 
3036
bool Item_func_set_user_var::register_field_in_read_map(unsigned char *arg)
 
3037
{
 
3038
  if (result_field)
 
3039
  {
 
3040
    Table *table= (Table *) arg;
 
3041
    if (result_field->table == table || !table)
 
3042
      bitmap_set_bit(result_field->table->read_set, result_field->field_index);
 
3043
    if (result_field->vcol_info && result_field->vcol_info->expr_item)
 
3044
      return result_field->vcol_info->
 
3045
               expr_item->walk(&Item::register_field_in_read_map, 1, arg);
 
3046
  }
 
3047
  return 0;
 
3048
}
 
3049
 
 
3050
 
 
3051
/*
 
3052
  Mark field in bitmap supplied as *arg
 
3053
 
 
3054
*/
 
3055
 
 
3056
bool Item_func_set_user_var::register_field_in_bitmap(unsigned char *arg)
 
3057
{
 
3058
  MY_BITMAP *bitmap = (MY_BITMAP *) arg;
 
3059
  assert(bitmap);
 
3060
  if (result_field)
 
3061
  {
 
3062
    bitmap_set_bit(bitmap, result_field->field_index);
 
3063
  }
 
3064
  return 0;
 
3065
}
 
3066
 
 
3067
 
 
3068
/**
 
3069
  Set value to user variable.
 
3070
 
 
3071
  @param entry          pointer to structure representing variable
 
3072
  @param set_null       should we set NULL value ?
 
3073
  @param ptr            pointer to buffer with new value
 
3074
  @param length         length of new value
 
3075
  @param type           type of new value
 
3076
  @param cs             charset info for new value
 
3077
  @param dv             derivation for new value
 
3078
  @param unsigned_arg   indiates if a value of type INT_RESULT is unsigned
 
3079
 
 
3080
  @note Sets error and fatal error if allocation fails.
 
3081
 
 
3082
  @retval
 
3083
    false   success
 
3084
  @retval
 
3085
    true    failure
 
3086
*/
 
3087
 
 
3088
static bool
 
3089
update_hash(user_var_entry *entry, bool set_null, void *ptr, uint32_t length,
 
3090
            Item_result type, const CHARSET_INFO * const cs, Derivation dv,
 
3091
            bool unsigned_arg)
 
3092
{
 
3093
  if (set_null)
 
3094
  {
 
3095
    char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3096
    if (entry->value && entry->value != pos)
 
3097
      free(entry->value);
 
3098
    entry->value= 0;
 
3099
    entry->length= 0;
 
3100
  }
 
3101
  else
 
3102
  {
 
3103
    if (type == STRING_RESULT)
 
3104
      length++;                                 // Store strings with end \0
 
3105
    if (length <= extra_size)
 
3106
    {
 
3107
      /* Save value in value struct */
 
3108
      char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3109
      if (entry->value != pos)
 
3110
      {
 
3111
        if (entry->value)
 
3112
          free(entry->value);
 
3113
        entry->value=pos;
 
3114
      }
 
3115
    }
 
3116
    else
 
3117
    {
 
3118
      /* Allocate variable */
 
3119
      if (entry->length != length)
 
3120
      {
 
3121
        char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3122
        if (entry->value == pos)
 
3123
          entry->value=0;
 
3124
        entry->value= (char*) my_realloc(entry->value, length,
 
3125
                                         MYF(MY_ALLOW_ZERO_PTR | MY_WME |
 
3126
                                             ME_FATALERROR));
 
3127
        if (!entry->value)
 
3128
          return 1;
 
3129
      }
 
3130
    }
 
3131
    if (type == STRING_RESULT)
 
3132
    {
 
3133
      length--;                                 // Fix length change above
 
3134
      entry->value[length]= 0;                  // Store end \0
 
3135
    }
 
3136
    memcpy(entry->value,ptr,length);
 
3137
    if (type == DECIMAL_RESULT)
 
3138
      ((my_decimal*)entry->value)->fix_buffer_pointer();
 
3139
    entry->length= length;
 
3140
    entry->collation.set(cs, dv);
 
3141
    entry->unsigned_flag= unsigned_arg;
 
3142
  }
 
3143
  entry->type=type;
 
3144
  return 0;
 
3145
}
 
3146
 
 
3147
 
 
3148
bool
 
3149
Item_func_set_user_var::update_hash(void *ptr, uint32_t length,
 
3150
                                    Item_result res_type,
 
3151
                                    const CHARSET_INFO * const cs, Derivation dv,
 
3152
                                    bool unsigned_arg)
 
3153
{
 
3154
  /*
 
3155
    If we set a variable explicitely to NULL then keep the old
 
3156
    result type of the variable
 
3157
  */
 
3158
  if ((null_value= args[0]->null_value) && null_item)
 
3159
    res_type= entry->type;                      // Don't change type of item
 
3160
  if (::update_hash(entry, (null_value= args[0]->null_value),
 
3161
                    ptr, length, res_type, cs, dv, unsigned_arg))
 
3162
  {
 
3163
    null_value= 1;
 
3164
    return 1;
 
3165
  }
 
3166
  return 0;
 
3167
}
 
3168
 
 
3169
 
 
3170
/** Get the value of a variable as a double. */
 
3171
 
 
3172
double user_var_entry::val_real(bool *null_value)
 
3173
{
 
3174
  if ((*null_value= (value == 0)))
 
3175
    return 0.0;
 
3176
 
 
3177
  switch (type) {
 
3178
  case REAL_RESULT:
 
3179
    return *(double*) value;
 
3180
  case INT_RESULT:
 
3181
    return (double) *(int64_t*) value;
 
3182
  case DECIMAL_RESULT:
 
3183
  {
 
3184
    double result;
 
3185
    my_decimal2double(E_DEC_FATAL_ERROR, (my_decimal *)value, &result);
 
3186
    return result;
 
3187
  }
 
3188
  case STRING_RESULT:
 
3189
    return my_atof(value);                      // This is null terminated
 
3190
  case ROW_RESULT:
 
3191
    assert(1);                          // Impossible
 
3192
    break;
 
3193
  }
 
3194
  return 0.0;                                   // Impossible
 
3195
}
 
3196
 
 
3197
 
 
3198
/** Get the value of a variable as an integer. */
 
3199
 
 
3200
int64_t user_var_entry::val_int(bool *null_value) const
 
3201
{
 
3202
  if ((*null_value= (value == 0)))
 
3203
    return 0L;
 
3204
 
 
3205
  switch (type) {
 
3206
  case REAL_RESULT:
 
3207
    return (int64_t) *(double*) value;
 
3208
  case INT_RESULT:
 
3209
    return *(int64_t*) value;
 
3210
  case DECIMAL_RESULT:
 
3211
  {
 
3212
    int64_t result;
 
3213
    my_decimal2int(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, &result);
 
3214
    return result;
 
3215
  }
 
3216
  case STRING_RESULT:
 
3217
  {
 
3218
    int error;
 
3219
    return my_strtoll10(value, (char**) 0, &error);// String is null terminated
 
3220
  }
 
3221
  case ROW_RESULT:
 
3222
    assert(1);                          // Impossible
 
3223
    break;
 
3224
  }
 
3225
  return 0L;                                    // Impossible
 
3226
}
 
3227
 
 
3228
 
 
3229
/** Get the value of a variable as a string. */
 
3230
 
 
3231
String *user_var_entry::val_str(bool *null_value, String *str,
 
3232
                                uint32_t decimals)
 
3233
{
 
3234
  if ((*null_value= (value == 0)))
 
3235
    return (String*) 0;
 
3236
 
 
3237
  switch (type) {
 
3238
  case REAL_RESULT:
 
3239
    str->set_real(*(double*) value, decimals, &my_charset_bin);
 
3240
    break;
 
3241
  case INT_RESULT:
 
3242
    if (!unsigned_flag)
 
3243
      str->set(*(int64_t*) value, &my_charset_bin);
 
3244
    else
 
3245
      str->set(*(uint64_t*) value, &my_charset_bin);
 
3246
    break;
 
3247
  case DECIMAL_RESULT:
 
3248
    my_decimal2string(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, 0, 0, str);
 
3249
    break;
 
3250
  case STRING_RESULT:
 
3251
    if (str->copy(value, length, collation.collation))
 
3252
      str= 0;                                   // EOM error
 
3253
  case ROW_RESULT:
 
3254
    assert(1);                          // Impossible
 
3255
    break;
 
3256
  }
 
3257
  return(str);
 
3258
}
 
3259
 
 
3260
/** Get the value of a variable as a decimal. */
 
3261
 
 
3262
my_decimal *user_var_entry::val_decimal(bool *null_value, my_decimal *val)
 
3263
{
 
3264
  if ((*null_value= (value == 0)))
 
3265
    return 0;
 
3266
 
 
3267
  switch (type) {
 
3268
  case REAL_RESULT:
 
3269
    double2my_decimal(E_DEC_FATAL_ERROR, *(double*) value, val);
 
3270
    break;
 
3271
  case INT_RESULT:
 
3272
    int2my_decimal(E_DEC_FATAL_ERROR, *(int64_t*) value, 0, val);
 
3273
    break;
 
3274
  case DECIMAL_RESULT:
 
3275
    val= (my_decimal *)value;
 
3276
    break;
 
3277
  case STRING_RESULT:
 
3278
    str2my_decimal(E_DEC_FATAL_ERROR, value, length, collation.collation, val);
 
3279
    break;
 
3280
  case ROW_RESULT:
 
3281
    assert(1);                          // Impossible
 
3282
    break;
 
3283
  }
 
3284
  return(val);
 
3285
}
 
3286
 
 
3287
/**
 
3288
  This functions is invoked on SET \@variable or
 
3289
  \@variable:= expression.
 
3290
 
 
3291
  Evaluate (and check expression), store results.
 
3292
 
 
3293
  @note
 
3294
    For now it always return OK. All problem with value evaluating
 
3295
    will be caught by thd->is_error() check in sql_set_variables().
 
3296
 
 
3297
  @retval
 
3298
    false OK.
 
3299
*/
 
3300
 
 
3301
bool
 
3302
Item_func_set_user_var::check(bool use_result_field)
 
3303
{
 
3304
  if (use_result_field && !result_field)
 
3305
    use_result_field= false;
 
3306
 
 
3307
  switch (cached_result_type) {
 
3308
  case REAL_RESULT:
 
3309
  {
 
3310
    save_result.vreal= use_result_field ? result_field->val_real() :
 
3311
                        args[0]->val_real();
 
3312
    break;
 
3313
  }
 
3314
  case INT_RESULT:
 
3315
  {
 
3316
    save_result.vint= use_result_field ? result_field->val_int() :
 
3317
                       args[0]->val_int();
 
3318
    unsigned_flag= use_result_field ? ((Field_num*)result_field)->unsigned_flag:
 
3319
                    args[0]->unsigned_flag;
 
3320
    break;
 
3321
  }
 
3322
  case STRING_RESULT:
 
3323
  {
 
3324
    save_result.vstr= use_result_field ? result_field->val_str(&value) :
 
3325
                       args[0]->val_str(&value);
 
3326
    break;
 
3327
  }
 
3328
  case DECIMAL_RESULT:
 
3329
  {
 
3330
    save_result.vdec= use_result_field ?
 
3331
                       result_field->val_decimal(&decimal_buff) :
 
3332
                       args[0]->val_decimal(&decimal_buff);
 
3333
    break;
 
3334
  }
 
3335
  case ROW_RESULT:
 
3336
  default:
 
3337
    // This case should never be chosen
 
3338
    assert(0);
 
3339
    break;
 
3340
  }
 
3341
  return(false);
 
3342
}
 
3343
 
 
3344
 
 
3345
/**
 
3346
  This functions is invoked on
 
3347
  SET \@variable or \@variable:= expression.
 
3348
 
 
3349
  @note
 
3350
    We have to store the expression as such in the variable, independent of
 
3351
    the value method used by the user
 
3352
 
 
3353
  @retval
 
3354
    0   OK
 
3355
  @retval
 
3356
    1   EOM Error
 
3357
 
 
3358
*/
 
3359
 
 
3360
bool
 
3361
Item_func_set_user_var::update()
 
3362
{
 
3363
  bool res= false;
 
3364
 
 
3365
  switch (cached_result_type) {
 
3366
  case REAL_RESULT:
 
3367
  {
 
3368
    res= update_hash((void*) &save_result.vreal,sizeof(save_result.vreal),
 
3369
                     REAL_RESULT, &my_charset_bin, DERIVATION_IMPLICIT, 0);
 
3370
    break;
 
3371
  }
 
3372
  case INT_RESULT:
 
3373
  {
 
3374
    res= update_hash((void*) &save_result.vint, sizeof(save_result.vint),
 
3375
                     INT_RESULT, &my_charset_bin, DERIVATION_IMPLICIT,
 
3376
                     unsigned_flag);
 
3377
    break;
 
3378
  }
 
3379
  case STRING_RESULT:
 
3380
  {
 
3381
    if (!save_result.vstr)                                      // Null value
 
3382
      res= update_hash((void*) 0, 0, STRING_RESULT, &my_charset_bin,
 
3383
                       DERIVATION_IMPLICIT, 0);
 
3384
    else
 
3385
      res= update_hash((void*) save_result.vstr->ptr(),
 
3386
                       save_result.vstr->length(), STRING_RESULT,
 
3387
                       save_result.vstr->charset(),
 
3388
                       DERIVATION_IMPLICIT, 0);
 
3389
    break;
 
3390
  }
 
3391
  case DECIMAL_RESULT:
 
3392
  {
 
3393
    if (!save_result.vdec)                                      // Null value
 
3394
      res= update_hash((void*) 0, 0, DECIMAL_RESULT, &my_charset_bin,
 
3395
                       DERIVATION_IMPLICIT, 0);
 
3396
    else
 
3397
      res= update_hash((void*) save_result.vdec,
 
3398
                       sizeof(my_decimal), DECIMAL_RESULT,
 
3399
                       &my_charset_bin, DERIVATION_IMPLICIT, 0);
 
3400
    break;
 
3401
  }
 
3402
  case ROW_RESULT:
 
3403
  default:
 
3404
    // This case should never be chosen
 
3405
    assert(0);
 
3406
    break;
 
3407
  }
 
3408
  return(res);
 
3409
}
 
3410
 
 
3411
 
 
3412
double Item_func_set_user_var::val_real()
 
3413
{
 
3414
  assert(fixed == 1);
 
3415
  check(0);
 
3416
  update();                                     // Store expression
 
3417
  return entry->val_real(&null_value);
 
3418
}
 
3419
 
 
3420
int64_t Item_func_set_user_var::val_int()
 
3421
{
 
3422
  assert(fixed == 1);
 
3423
  check(0);
 
3424
  update();                                     // Store expression
 
3425
  return entry->val_int(&null_value);
 
3426
}
 
3427
 
 
3428
String *Item_func_set_user_var::val_str(String *str)
 
3429
{
 
3430
  assert(fixed == 1);
 
3431
  check(0);
 
3432
  update();                                     // Store expression
 
3433
  return entry->val_str(&null_value, str, decimals);
 
3434
}
 
3435
 
 
3436
 
 
3437
my_decimal *Item_func_set_user_var::val_decimal(my_decimal *val)
 
3438
{
 
3439
  assert(fixed == 1);
 
3440
  check(0);
 
3441
  update();                                     // Store expression
 
3442
  return entry->val_decimal(&null_value, val);
 
3443
}
 
3444
 
 
3445
 
 
3446
double Item_func_set_user_var::val_result()
 
3447
{
 
3448
  assert(fixed == 1);
 
3449
  check(true);
 
3450
  update();                                     // Store expression
 
3451
  return entry->val_real(&null_value);
 
3452
}
 
3453
 
 
3454
int64_t Item_func_set_user_var::val_int_result()
 
3455
{
 
3456
  assert(fixed == 1);
 
3457
  check(true);
 
3458
  update();                                     // Store expression
 
3459
  return entry->val_int(&null_value);
 
3460
}
 
3461
 
 
3462
String *Item_func_set_user_var::str_result(String *str)
 
3463
{
 
3464
  assert(fixed == 1);
 
3465
  check(true);
 
3466
  update();                                     // Store expression
 
3467
  return entry->val_str(&null_value, str, decimals);
 
3468
}
 
3469
 
 
3470
 
 
3471
my_decimal *Item_func_set_user_var::val_decimal_result(my_decimal *val)
 
3472
{
 
3473
  assert(fixed == 1);
 
3474
  check(true);
 
3475
  update();                                     // Store expression
 
3476
  return entry->val_decimal(&null_value, val);
 
3477
}
 
3478
 
 
3479
 
 
3480
void Item_func_set_user_var::print(String *str, enum_query_type query_type)
 
3481
{
 
3482
  str->append(STRING_WITH_LEN("(@"));
 
3483
  str->append(name.str, name.length);
 
3484
  str->append(STRING_WITH_LEN(":="));
 
3485
  args[0]->print(str, query_type);
 
3486
  str->append(')');
 
3487
}
 
3488
 
 
3489
 
 
3490
void Item_func_set_user_var::print_as_stmt(String *str,
 
3491
                                           enum_query_type query_type)
 
3492
{
 
3493
  str->append(STRING_WITH_LEN("set @"));
 
3494
  str->append(name.str, name.length);
 
3495
  str->append(STRING_WITH_LEN(":="));
 
3496
  args[0]->print(str, query_type);
 
3497
  str->append(')');
 
3498
}
 
3499
 
 
3500
bool Item_func_set_user_var::send(Protocol *protocol, String *str_arg)
 
3501
{
 
3502
  if (result_field)
 
3503
  {
 
3504
    check(1);
 
3505
    update();
 
3506
    return protocol->store(result_field);
 
3507
  }
 
3508
  return Item::send(protocol, str_arg);
 
3509
}
 
3510
 
 
3511
void Item_func_set_user_var::make_field(Send_field *tmp_field)
 
3512
{
 
3513
  if (result_field)
 
3514
  {
 
3515
    result_field->make_field(tmp_field);
 
3516
    assert(tmp_field->table_name != 0);
 
3517
    if (Item::name)
 
3518
      tmp_field->col_name=Item::name;               // Use user supplied name
 
3519
  }
 
3520
  else
 
3521
    Item::make_field(tmp_field);
 
3522
}
 
3523
 
 
3524
 
 
3525
/*
 
3526
  Save the value of a user variable into a field
 
3527
 
 
3528
  SYNOPSIS
 
3529
    save_in_field()
 
3530
      field           target field to save the value to
 
3531
      no_conversion   flag indicating whether conversions are allowed
 
3532
 
 
3533
  DESCRIPTION
 
3534
    Save the function value into a field and update the user variable
 
3535
    accordingly. If a result field is defined and the target field doesn't
 
3536
    coincide with it then the value from the result field will be used as
 
3537
    the new value of the user variable.
 
3538
 
 
3539
    The reason to have this method rather than simply using the result
 
3540
    field in the val_xxx() methods is that the value from the result field
 
3541
    not always can be used when the result field is defined.
 
3542
    Let's consider the following cases:
 
3543
    1) when filling a tmp table the result field is defined but the value of it
 
3544
    is undefined because it has to be produced yet. Thus we can't use it.
 
3545
    2) on execution of an INSERT ... SELECT statement the save_in_field()
 
3546
    function will be called to fill the data in the new record. If the SELECT
 
3547
    part uses a tmp table then the result field is defined and should be
 
3548
    used in order to get the correct result.
 
3549
 
 
3550
    The difference between the SET_USER_VAR function and regular functions
 
3551
    like CONCAT is that the Item_func objects for the regular functions are
 
3552
    replaced by Item_field objects after the values of these functions have
 
3553
    been stored in a tmp table. Yet an object of the Item_field class cannot
 
3554
    be used to update a user variable.
 
3555
    Due to this we have to handle the result field in a special way here and
 
3556
    in the Item_func_set_user_var::send() function.
 
3557
 
 
3558
  RETURN VALUES
 
3559
    false       Ok
 
3560
    true        Error
 
3561
*/
 
3562
 
 
3563
int Item_func_set_user_var::save_in_field(Field *field, bool no_conversions,
 
3564
                                          bool can_use_result_field)
 
3565
{
 
3566
  bool use_result_field= (!can_use_result_field ? 0 :
 
3567
                          (result_field && result_field != field));
 
3568
  int error;
 
3569
 
 
3570
  /* Update the value of the user variable */
 
3571
  check(use_result_field);
 
3572
  update();
 
3573
 
 
3574
  if (result_type() == STRING_RESULT ||
 
3575
      (result_type() == REAL_RESULT && field->result_type() == STRING_RESULT))
 
3576
  {
 
3577
    String *result;
 
3578
    const CHARSET_INFO * const cs= collation.collation;
 
3579
    char buff[MAX_FIELD_WIDTH];         // Alloc buffer for small columns
 
3580
    str_value.set_quick(buff, sizeof(buff), cs);
 
3581
    result= entry->val_str(&null_value, &str_value, decimals);
 
3582
 
 
3583
    if (null_value)
 
3584
    {
 
3585
      str_value.set_quick(0, 0, cs);
 
3586
      return set_field_to_null_with_conversions(field, no_conversions);
 
3587
    }
 
3588
 
 
3589
    /* NOTE: If null_value == false, "result" must be not NULL.  */
 
3590
 
 
3591
    field->set_notnull();
 
3592
    error=field->store(result->ptr(),result->length(),cs);
 
3593
    str_value.set_quick(0, 0, cs);
 
3594
  }
 
3595
  else if (result_type() == REAL_RESULT)
 
3596
  {
 
3597
    double nr= entry->val_real(&null_value);
 
3598
    if (null_value)
 
3599
      return set_field_to_null(field);
 
3600
    field->set_notnull();
 
3601
    error=field->store(nr);
 
3602
  }
 
3603
  else if (result_type() == DECIMAL_RESULT)
 
3604
  {
 
3605
    my_decimal decimal_value;
 
3606
    my_decimal *val= entry->val_decimal(&null_value, &decimal_value);
 
3607
    if (null_value)
 
3608
      return set_field_to_null(field);
 
3609
    field->set_notnull();
 
3610
    error=field->store_decimal(val);
 
3611
  }
 
3612
  else
 
3613
  {
 
3614
    int64_t nr= entry->val_int(&null_value);
 
3615
    if (null_value)
 
3616
      return set_field_to_null_with_conversions(field, no_conversions);
 
3617
    field->set_notnull();
 
3618
    error=field->store(nr, unsigned_flag);
 
3619
  }
 
3620
  return error;
 
3621
}
 
3622
 
 
3623
 
 
3624
String *
 
3625
Item_func_get_user_var::val_str(String *str)
 
3626
{
 
3627
  assert(fixed == 1);
 
3628
  if (!var_entry)
 
3629
    return((String*) 0);                        // No such variable
 
3630
  return(var_entry->val_str(&null_value, str, decimals));
 
3631
}
 
3632
 
 
3633
 
 
3634
double Item_func_get_user_var::val_real()
 
3635
{
 
3636
  assert(fixed == 1);
 
3637
  if (!var_entry)
 
3638
    return 0.0;                                 // No such variable
 
3639
  return (var_entry->val_real(&null_value));
 
3640
}
 
3641
 
 
3642
 
 
3643
my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec)
 
3644
{
 
3645
  assert(fixed == 1);
 
3646
  if (!var_entry)
 
3647
    return 0;
 
3648
  return var_entry->val_decimal(&null_value, dec);
 
3649
}
 
3650
 
 
3651
 
 
3652
int64_t Item_func_get_user_var::val_int()
 
3653
{
 
3654
  assert(fixed == 1);
 
3655
  if (!var_entry)
 
3656
    return 0L;                          // No such variable
 
3657
  return (var_entry->val_int(&null_value));
 
3658
}
 
3659
 
 
3660
 
 
3661
/**
 
3662
  Get variable by name and, if necessary, put the record of variable 
 
3663
  use into the binary log.
 
3664
 
 
3665
  When a user variable is invoked from an update query (INSERT, UPDATE etc),
 
3666
  stores this variable and its value in thd->user_var_events, so that it can be
 
3667
  written to the binlog (will be written just before the query is written, see
 
3668
  log.cc).
 
3669
 
 
3670
  @param      thd        Current thread
 
3671
  @param      name       Variable name
 
3672
  @param[out] out_entry  variable structure or NULL. The pointer is set
 
3673
                         regardless of whether function succeeded or not.
 
3674
 
 
3675
  @retval
 
3676
    0  OK
 
3677
  @retval
 
3678
    1  Failed to put appropriate record into binary log
 
3679
 
 
3680
*/
 
3681
 
 
3682
int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
 
3683
                        LEX_STRING &name, user_var_entry **out_entry)
 
3684
{
 
3685
  BINLOG_USER_VAR_EVENT *user_var_event;
 
3686
  user_var_entry *var_entry;
 
3687
  var_entry= get_variable(&thd->user_vars, name, 0);
 
3688
 
 
3689
  /*
 
3690
    Any reference to user-defined variable which is done from stored
 
3691
    function or trigger affects their execution and the execution of the
 
3692
    calling statement. We must log all such variables even if they are 
 
3693
    not involved in table-updating statements.
 
3694
  */
 
3695
  if (!(opt_bin_log && is_update_query(sql_command)))
 
3696
  {
 
3697
    *out_entry= var_entry;
 
3698
    return 0;
 
3699
  }
 
3700
 
 
3701
  if (!var_entry)
 
3702
  {
 
3703
    /*
 
3704
      If the variable does not exist, it's NULL, but we want to create it so
 
3705
      that it gets into the binlog (if it didn't, the slave could be
 
3706
      influenced by a variable of the same name previously set by another
 
3707
      thread).
 
3708
      We create it like if it had been explicitly set with SET before.
 
3709
      The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'.
 
3710
      sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'
 
3711
      in dispatch_command()). Instead of building a one-element list to pass to
 
3712
      sql_set_variables(), we could instead manually call check() and update();
 
3713
      this would save memory and time; but calling sql_set_variables() makes
 
3714
      one unique place to maintain (sql_set_variables()). 
 
3715
 
 
3716
      Manipulation with lex is necessary since free_underlaid_joins
 
3717
      is going to release memory belonging to the main query.
 
3718
    */
 
3719
 
 
3720
    List<set_var_base> tmp_var_list;
 
3721
    LEX *sav_lex= thd->lex, lex_tmp;
 
3722
    thd->lex= &lex_tmp;
 
3723
    lex_start(thd);
 
3724
    tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(name,
 
3725
                                                                       new Item_null())));
 
3726
    /* Create the variable */
 
3727
    if (sql_set_variables(thd, &tmp_var_list))
 
3728
    {
 
3729
      thd->lex= sav_lex;
 
3730
      goto err;
 
3731
    }
 
3732
    thd->lex= sav_lex;
 
3733
    if (!(var_entry= get_variable(&thd->user_vars, name, 0)))
 
3734
      goto err;
 
3735
  }
 
3736
  else if (var_entry->used_query_id == thd->query_id ||
 
3737
           mysql_bin_log.is_query_in_union(thd, var_entry->used_query_id))
 
3738
  {
 
3739
    /* 
 
3740
       If this variable was already stored in user_var_events by this query
 
3741
       (because it's used in more than one place in the query), don't store
 
3742
       it.
 
3743
    */
 
3744
    *out_entry= var_entry;
 
3745
    return 0;
 
3746
  }
 
3747
 
 
3748
  uint32_t size;
 
3749
  /*
 
3750
    First we need to store value of var_entry, when the next situation
 
3751
    appears:
 
3752
    > set @a:=1;
 
3753
    > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);
 
3754
    We have to write to binlog value @a= 1.
 
3755
 
 
3756
    We allocate the user_var_event on user_var_events_alloc pool, not on
 
3757
    the this-statement-execution pool because in SPs user_var_event objects 
 
3758
    may need to be valid after current [SP] statement execution pool is
 
3759
    destroyed.
 
3760
  */
 
3761
  size= ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT)) + var_entry->length;
 
3762
  if (!(user_var_event= (BINLOG_USER_VAR_EVENT *)
 
3763
        alloc_root(thd->user_var_events_alloc, size)))
 
3764
    goto err;
 
3765
 
 
3766
  user_var_event->value= (char*) user_var_event +
 
3767
    ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT));
 
3768
  user_var_event->user_var_event= var_entry;
 
3769
  user_var_event->type= var_entry->type;
 
3770
  user_var_event->charset_number= var_entry->collation.collation->number;
 
3771
  if (!var_entry->value)
 
3772
  {
 
3773
    /* NULL value*/
 
3774
    user_var_event->length= 0;
 
3775
    user_var_event->value= 0;
 
3776
  }
 
3777
  else
 
3778
  {
 
3779
    user_var_event->length= var_entry->length;
 
3780
    memcpy(user_var_event->value, var_entry->value,
 
3781
           var_entry->length);
 
3782
  }
 
3783
  /* Mark that this variable has been used by this query */
 
3784
  var_entry->used_query_id= thd->query_id;
 
3785
  if (insert_dynamic(&thd->user_var_events, (unsigned char*) &user_var_event))
 
3786
    goto err;
 
3787
 
 
3788
  *out_entry= var_entry;
 
3789
  return 0;
 
3790
 
 
3791
err:
 
3792
  *out_entry= var_entry;
 
3793
  return 1;
 
3794
}
 
3795
 
 
3796
void Item_func_get_user_var::fix_length_and_dec()
 
3797
{
 
3798
  THD *thd=current_thd;
 
3799
  int error;
 
3800
  maybe_null=1;
 
3801
  decimals=NOT_FIXED_DEC;
 
3802
  max_length=MAX_BLOB_WIDTH;
 
3803
 
 
3804
  error= get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry);
 
3805
 
 
3806
  /*
 
3807
    If the variable didn't exist it has been created as a STRING-type.
 
3808
    'var_entry' is NULL only if there occured an error during the call to
 
3809
    get_var_with_binlog.
 
3810
  */
 
3811
  if (var_entry)
 
3812
  {
 
3813
    m_cached_result_type= var_entry->type;
 
3814
    unsigned_flag= var_entry->unsigned_flag;
 
3815
    max_length= var_entry->length;
 
3816
 
 
3817
    collation.set(var_entry->collation);
 
3818
    switch(m_cached_result_type) {
 
3819
    case REAL_RESULT:
 
3820
      max_length= DBL_DIG + 8;
 
3821
      break;
 
3822
    case INT_RESULT:
 
3823
      max_length= MAX_BIGINT_WIDTH;
 
3824
      decimals=0;
 
3825
      break;
 
3826
    case STRING_RESULT:
 
3827
      max_length= MAX_BLOB_WIDTH;
 
3828
      break;
 
3829
    case DECIMAL_RESULT:
 
3830
      max_length= DECIMAL_MAX_STR_LENGTH;
 
3831
      decimals= DECIMAL_MAX_SCALE;
 
3832
      break;
 
3833
    case ROW_RESULT:                            // Keep compiler happy
 
3834
    default:
 
3835
      assert(0);
 
3836
      break;
 
3837
    }
 
3838
  }
 
3839
  else
 
3840
  {
 
3841
    collation.set(&my_charset_bin, DERIVATION_IMPLICIT);
 
3842
    null_value= 1;
 
3843
    m_cached_result_type= STRING_RESULT;
 
3844
    max_length= MAX_BLOB_WIDTH;
 
3845
  }
 
3846
}
 
3847
 
 
3848
 
 
3849
bool Item_func_get_user_var::const_item() const
 
3850
{
 
3851
  return (!var_entry || current_thd->query_id != var_entry->update_query_id);
 
3852
}
 
3853
 
 
3854
 
 
3855
enum Item_result Item_func_get_user_var::result_type() const
 
3856
{
 
3857
  return m_cached_result_type;
 
3858
}
 
3859
 
 
3860
 
 
3861
void Item_func_get_user_var::print(String *str,
 
3862
                                   enum_query_type query_type __attribute__((unused)))
 
3863
{
 
3864
  str->append(STRING_WITH_LEN("(@"));
 
3865
  str->append(name.str,name.length);
 
3866
  str->append(')');
 
3867
}
 
3868
 
 
3869
 
 
3870
bool Item_func_get_user_var::eq(const Item *item,
 
3871
                                bool binary_cmp __attribute__((unused))) const
 
3872
{
 
3873
  /* Assume we don't have rtti */
 
3874
  if (this == item)
 
3875
    return 1;                                   // Same item is same.
 
3876
  /* Check if other type is also a get_user_var() object */
 
3877
  if (item->type() != FUNC_ITEM ||
 
3878
      ((Item_func*) item)->functype() != functype())
 
3879
    return 0;
 
3880
  Item_func_get_user_var *other=(Item_func_get_user_var*) item;
 
3881
  return (name.length == other->name.length &&
 
3882
          !memcmp(name.str, other->name.str, name.length));
 
3883
}
 
3884
 
 
3885
 
 
3886
bool Item_user_var_as_out_param::fix_fields(THD *thd, Item **ref)
 
3887
{
 
3888
  assert(fixed == 0);
 
3889
  if (Item::fix_fields(thd, ref) ||
 
3890
      !(entry= get_variable(&thd->user_vars, name, 1)))
 
3891
    return true;
 
3892
  entry->type= STRING_RESULT;
 
3893
  /*
 
3894
    Let us set the same collation which is used for loading
 
3895
    of fields in LOAD DATA INFILE.
 
3896
    (Since Item_user_var_as_out_param is used only there).
 
3897
  */
 
3898
  entry->collation.set(thd->variables.collation_database);
 
3899
  entry->update_query_id= thd->query_id;
 
3900
  return false;
 
3901
}
 
3902
 
 
3903
 
 
3904
void Item_user_var_as_out_param::set_null_value(const CHARSET_INFO * const cs)
 
3905
{
 
3906
  ::update_hash(entry, true, 0, 0, STRING_RESULT, cs,
 
3907
                DERIVATION_IMPLICIT, 0 /* unsigned_arg */);
 
3908
}
 
3909
 
 
3910
 
 
3911
void Item_user_var_as_out_param::set_value(const char *str, uint32_t length,
 
3912
                                           const CHARSET_INFO * const cs)
 
3913
{
 
3914
  ::update_hash(entry, false, (void*)str, length, STRING_RESULT, cs,
 
3915
                DERIVATION_IMPLICIT, 0 /* unsigned_arg */);
 
3916
}
 
3917
 
 
3918
 
 
3919
double Item_user_var_as_out_param::val_real()
 
3920
{
 
3921
  assert(0);
 
3922
  return 0.0;
 
3923
}
 
3924
 
 
3925
 
 
3926
int64_t Item_user_var_as_out_param::val_int()
 
3927
{
 
3928
  assert(0);
 
3929
  return 0;
 
3930
}
 
3931
 
 
3932
 
 
3933
String* Item_user_var_as_out_param::val_str(String *str __attribute__((unused)))
 
3934
{
 
3935
  assert(0);
 
3936
  return 0;
 
3937
}
 
3938
 
 
3939
 
 
3940
my_decimal* Item_user_var_as_out_param::val_decimal(my_decimal *decimal_buffer __attribute__((unused)))
 
3941
{
 
3942
  assert(0);
 
3943
  return 0;
 
3944
}
 
3945
 
 
3946
 
 
3947
void Item_user_var_as_out_param::print(String *str,
 
3948
                                       enum_query_type query_type __attribute__((unused)))
 
3949
{
 
3950
  str->append('@');
 
3951
  str->append(name.str,name.length);
 
3952
}
 
3953
 
 
3954
 
 
3955
Item_func_get_system_var::
 
3956
Item_func_get_system_var(sys_var *var_arg, enum_var_type var_type_arg,
 
3957
                       LEX_STRING *component_arg, const char *name_arg,
 
3958
                       size_t name_len_arg)
 
3959
  :var(var_arg), var_type(var_type_arg), component(*component_arg)
 
3960
{
 
3961
  /* set_name() will allocate the name */
 
3962
  set_name(name_arg, name_len_arg, system_charset_info);
 
3963
}
 
3964
 
 
3965
 
 
3966
bool
 
3967
Item_func_get_system_var::fix_fields(THD *thd, Item **ref)
 
3968
{
 
3969
  Item *item;
 
3970
 
 
3971
  /*
 
3972
    Evaluate the system variable and substitute the result (a basic constant)
 
3973
    instead of this item. If the variable can not be evaluated,
 
3974
    the error is reported in sys_var::item().
 
3975
  */
 
3976
  if (!(item= var->item(thd, var_type, &component)))
 
3977
    return(1);                             // Impossible
 
3978
  item->set_name(name, 0, system_charset_info); // don't allocate a new name
 
3979
  thd->change_item_tree(ref, item);
 
3980
 
 
3981
  return(0);
 
3982
}
 
3983
 
 
3984
 
 
3985
bool Item_func_get_system_var::is_written_to_binlog()
 
3986
{
 
3987
  return var->is_written_to_binlog(var_type);
 
3988
}
 
3989
 
 
3990
int64_t Item_func_bit_xor::val_int()
 
3991
{
 
3992
  assert(fixed == 1);
 
3993
  uint64_t arg1= (uint64_t) args[0]->val_int();
 
3994
  uint64_t arg2= (uint64_t) args[1]->val_int();
 
3995
  if ((null_value= (args[0]->null_value || args[1]->null_value)))
 
3996
    return 0;
 
3997
  return (int64_t) (arg1 ^ arg2);
 
3998
}
 
3999
 
 
4000
 
 
4001
/***************************************************************************
 
4002
  System variables
 
4003
****************************************************************************/
 
4004
 
 
4005
/**
 
4006
  Return value of an system variable base[.name] as a constant item.
 
4007
 
 
4008
  @param thd                    Thread handler
 
4009
  @param var_type               global / session
 
4010
  @param name                   Name of base or system variable
 
4011
  @param component              Component.
 
4012
 
 
4013
  @note
 
4014
    If component.str = 0 then the variable name is in 'name'
 
4015
 
 
4016
  @return
 
4017
    - 0  : error
 
4018
    - #  : constant item
 
4019
*/
 
4020
 
 
4021
 
 
4022
Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
 
4023
                     LEX_STRING component)
 
4024
{
 
4025
  sys_var *var;
 
4026
  LEX_STRING *base_name, *component_name;
 
4027
 
 
4028
  if (component.str)
 
4029
  {
 
4030
    base_name= &component;
 
4031
    component_name= &name;
 
4032
  }
 
4033
  else
 
4034
  {
 
4035
    base_name= &name;
 
4036
    component_name= &component;                 // Empty string
 
4037
  }
 
4038
 
 
4039
  if (!(var= find_sys_var(thd, base_name->str, base_name->length)))
 
4040
    return 0;
 
4041
  if (component.str)
 
4042
  {
 
4043
    if (!var->is_struct())
 
4044
    {
 
4045
      my_error(ER_VARIABLE_IS_NOT_STRUCT, MYF(0), base_name->str);
 
4046
      return 0;
 
4047
    }
 
4048
  }
 
4049
 
 
4050
  set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH);
 
4051
 
 
4052
  return new Item_func_get_system_var(var, var_type, component_name,
 
4053
                                      NULL, 0);
 
4054
}
 
4055
 
 
4056
 
 
4057
/**
 
4058
  Check a user level lock.
 
4059
 
 
4060
  Sets null_value=true on error.
 
4061
 
 
4062
  @retval
 
4063
    1           Available
 
4064
  @retval
 
4065
    0           Already taken, or error
 
4066
*/
 
4067
 
 
4068
int64_t Item_func_is_free_lock::val_int()
 
4069
{
 
4070
  assert(fixed == 1);
 
4071
  String *res=args[0]->val_str(&value);
 
4072
  User_level_lock *ull;
 
4073
 
 
4074
  null_value=0;
 
4075
  if (!res || !res->length())
 
4076
  {
 
4077
    null_value=1;
 
4078
    return 0;
 
4079
  }
 
4080
  
 
4081
  pthread_mutex_lock(&LOCK_user_locks);
 
4082
  ull= (User_level_lock *) hash_search(&hash_user_locks, (unsigned char*) res->ptr(),
 
4083
                                       (size_t) res->length());
 
4084
  pthread_mutex_unlock(&LOCK_user_locks);
 
4085
  if (!ull || !ull->locked)
 
4086
    return 1;
 
4087
  return 0;
 
4088
}
 
4089
 
 
4090
int64_t Item_func_is_used_lock::val_int()
 
4091
{
 
4092
  assert(fixed == 1);
 
4093
  String *res=args[0]->val_str(&value);
 
4094
  User_level_lock *ull;
 
4095
 
 
4096
  null_value=1;
 
4097
  if (!res || !res->length())
 
4098
    return 0;
 
4099
  
 
4100
  pthread_mutex_lock(&LOCK_user_locks);
 
4101
  ull= (User_level_lock *) hash_search(&hash_user_locks, (unsigned char*) res->ptr(),
 
4102
                                       (size_t) res->length());
 
4103
  pthread_mutex_unlock(&LOCK_user_locks);
 
4104
  if (!ull || !ull->locked)
 
4105
    return 0;
 
4106
 
 
4107
  null_value=0;
 
4108
  return ull->thread_id;
 
4109
}
 
4110
 
 
4111
 
 
4112
int64_t Item_func_row_count::val_int()
 
4113
{
 
4114
  assert(fixed == 1);
 
4115
  THD *thd= current_thd;
 
4116
 
 
4117
  return thd->row_count_func;
 
4118
}
 
4119
 
 
4120
int64_t Item_func_found_rows::val_int()
 
4121
{
 
4122
  assert(fixed == 1);
 
4123
  THD *thd= current_thd;
 
4124
 
 
4125
  return thd->found_rows();
 
4126
}