← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_func.cc

  • Committer: Monty
  • Date: 2008-10-02 05:41:33 UTC
  • mfrom: (398.1.10 codestyle)
  • Revision ID: mordred@scylla.inaugust.com-20081002054133-tyxv5bmqpazfaqqi
Merged up to 408 of stdint-includes-fix.

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
  uchar 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
                     uchar *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, uchar *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, uchar **arg_p,
 
323
                         Item_transformer transformer, uchar *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
      uchar *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 (uint 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, uint from, enum_query_type query_type)
 
393
{
 
394
  for (uint 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 (uint 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 (uint 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
  uint fl_length= 0;
 
510
  decimals=0;
 
511
  for (uint 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 (uint 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 (uint 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 (uint 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
  uint 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
  uint 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
  uint 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
    uint 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
  uint 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
  uint 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
  uint 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
  uint 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 && my_isinf(tmp))
 
1993
    tmp2= 0;
 
1994
  else if (!dec_negative && my_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 (uint 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
uint Item_func_min_max::cmp_datetimes(uint64_t *value)
 
2223
{
 
2224
  uint64_t min_max= 0;
 
2225
  uint min_max_idx= 0;
 
2226
 
 
2227
  for (uint 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
    uint 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 (uint 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 (uint 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 (uint 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 (uint 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 (uint 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 (uint 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 (uint 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 (uint 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 (uint 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() ? (uchar) (*res)[0] : (uchar) 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)((uchar) *str);
 
2616
    while (l--)
 
2617
      n=(n<<8)|(uint32_t)((uchar) *str++);
 
2618
    return (int64_t) n;
 
2619
  }
 
2620
#endif
 
2621
  return (int64_t) ((uchar) (*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 uchar *find_str= (const uchar *) find->ptr();
 
2669
    uint 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, (uchar*) str_end, 
 
2675
                                       (uchar*) 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 uchar *) 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
  uchar *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 uchar *key_arg,uint length, ulong id) 
 
2734
    :key_length(length),count(1),locked(1), thread_id(id)
 
2735
  {
 
2736
    key= (uchar*) 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,(uchar*) this))
 
2741
      {
 
2742
        my_free(key,MYF(0));
 
2743
        key=0;
 
2744
      }
 
2745
    }
 
2746
  }
 
2747
  ~User_level_lock()
 
2748
  {
 
2749
    if (key)
 
2750
    {
 
2751
      hash_delete(&hash_user_locks,(uchar*) this);
 
2752
      my_free(key, MYF(0));
 
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 uchar *ull_get_key(const User_level_lock *ull, size_t *length,
 
2759
                            bool not_used);
 
2760
};
 
2761
 
 
2762
uchar *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
#ifdef HAVE_REPLICATION
 
2819
  int64_t pos = (ulong)args[1]->val_int();
 
2820
  int64_t timeout = (arg_count==3) ? args[2]->val_int() : 0 ;
 
2821
  if ((event_count = active_mi->rli.wait_for_pos(thd, log_name, pos, timeout)) == -2)
 
2822
  {
 
2823
    null_value = 1;
 
2824
    event_count=0;
 
2825
  }
 
2826
#endif
 
2827
  return event_count;
 
2828
}
 
2829
 
 
2830
#ifdef EXTRA_DEBUG
 
2831
void debug_sync_point(const char* lock_name, uint lock_timeout)
 
2832
{
 
2833
}
 
2834
 
 
2835
#endif
 
2836
 
 
2837
 
 
2838
int64_t Item_func_last_insert_id::val_int()
 
2839
{
 
2840
  THD *thd= current_thd;
 
2841
  assert(fixed == 1);
 
2842
  if (arg_count)
 
2843
  {
 
2844
    int64_t value= args[0]->val_int();
 
2845
    null_value= args[0]->null_value;
 
2846
    /*
 
2847
      LAST_INSERT_ID(X) must affect the client's mysql_insert_id() as
 
2848
      documented in the manual. We don't want to touch
 
2849
      first_successful_insert_id_in_cur_stmt because it would make
 
2850
      LAST_INSERT_ID(X) take precedence over an generated auto_increment
 
2851
      value for this row.
 
2852
    */
 
2853
    thd->arg_of_last_insert_id_function= true;
 
2854
    thd->first_successful_insert_id_in_prev_stmt= value;
 
2855
    return value;
 
2856
  }
 
2857
  return thd->read_first_successful_insert_id_in_prev_stmt();
 
2858
}
 
2859
 
 
2860
 
 
2861
bool Item_func_last_insert_id::fix_fields(THD *thd, Item **ref)
 
2862
{
 
2863
  return Item_int_func::fix_fields(thd, ref);
 
2864
}
 
2865
 
 
2866
 
 
2867
/* This function is just used to test speed of different functions */
 
2868
 
 
2869
int64_t Item_func_benchmark::val_int()
 
2870
{
 
2871
  assert(fixed == 1);
 
2872
  char buff[MAX_FIELD_WIDTH];
 
2873
  String tmp(buff,sizeof(buff), &my_charset_bin);
 
2874
  my_decimal tmp_decimal;
 
2875
  THD *thd=current_thd;
 
2876
  uint64_t loop_count;
 
2877
 
 
2878
  loop_count= (uint64_t) args[0]->val_int();
 
2879
 
 
2880
  if (args[0]->null_value ||
 
2881
      (!args[0]->unsigned_flag && (((int64_t) loop_count) < 0)))
 
2882
  {
 
2883
    if (!args[0]->null_value)
 
2884
    {
 
2885
      char buff[22];
 
2886
      llstr(((int64_t) loop_count), buff);
 
2887
      push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
2888
                          ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
 
2889
                          "count", buff, "benchmark");
 
2890
    }
 
2891
 
 
2892
    null_value= 1;
 
2893
    return 0;
 
2894
  }
 
2895
 
 
2896
  null_value=0;
 
2897
  for (uint64_t loop=0 ; loop < loop_count && !thd->killed; loop++)
 
2898
  {
 
2899
    switch (args[1]->result_type()) {
 
2900
    case REAL_RESULT:
 
2901
      (void) args[1]->val_real();
 
2902
      break;
 
2903
    case INT_RESULT:
 
2904
      (void) args[1]->val_int();
 
2905
      break;
 
2906
    case STRING_RESULT:
 
2907
      (void) args[1]->val_str(&tmp);
 
2908
      break;
 
2909
    case DECIMAL_RESULT:
 
2910
      (void) args[1]->val_decimal(&tmp_decimal);
 
2911
      break;
 
2912
    case ROW_RESULT:
 
2913
    default:
 
2914
      // This case should never be chosen
 
2915
      assert(0);
 
2916
      return 0;
 
2917
    }
 
2918
  }
 
2919
  return 0;
 
2920
}
 
2921
 
 
2922
 
 
2923
void Item_func_benchmark::print(String *str, enum_query_type query_type)
 
2924
{
 
2925
  str->append(STRING_WITH_LEN("benchmark("));
 
2926
  args[0]->print(str, query_type);
 
2927
  str->append(',');
 
2928
  args[1]->print(str, query_type);
 
2929
  str->append(')');
 
2930
}
 
2931
 
 
2932
#define extra_size sizeof(double)
 
2933
 
 
2934
static user_var_entry *get_variable(HASH *hash, LEX_STRING &name,
 
2935
                                    bool create_if_not_exists)
 
2936
{
 
2937
  user_var_entry *entry;
 
2938
 
 
2939
  if (!(entry = (user_var_entry*) hash_search(hash, (uchar*) name.str,
 
2940
                                              name.length)) &&
 
2941
      create_if_not_exists)
 
2942
  {
 
2943
    uint size=ALIGN_SIZE(sizeof(user_var_entry))+name.length+1+extra_size;
 
2944
    if (!hash_inited(hash))
 
2945
      return 0;
 
2946
    if (!(entry = (user_var_entry*) my_malloc(size,MYF(MY_WME | ME_FATALERROR))))
 
2947
      return 0;
 
2948
    entry->name.str=(char*) entry+ ALIGN_SIZE(sizeof(user_var_entry))+
 
2949
      extra_size;
 
2950
    entry->name.length=name.length;
 
2951
    entry->value=0;
 
2952
    entry->length=0;
 
2953
    entry->update_query_id=0;
 
2954
    entry->collation.set(NULL, DERIVATION_IMPLICIT, 0);
 
2955
    entry->unsigned_flag= 0;
 
2956
    /*
 
2957
      If we are here, we were called from a SET or a query which sets a
 
2958
      variable. Imagine it is this:
 
2959
      INSERT INTO t SELECT @a:=10, @a:=@a+1.
 
2960
      Then when we have a Item_func_get_user_var (because of the @a+1) so we
 
2961
      think we have to write the value of @a to the binlog. But before that,
 
2962
      we have a Item_func_set_user_var to create @a (@a:=10), in this we mark
 
2963
      the variable as "already logged" (line below) so that it won't be logged
 
2964
      by Item_func_get_user_var (because that's not necessary).
 
2965
    */
 
2966
    entry->used_query_id=current_thd->query_id;
 
2967
    entry->type=STRING_RESULT;
 
2968
    memcpy(entry->name.str, name.str, name.length+1);
 
2969
    if (my_hash_insert(hash,(uchar*) entry))
 
2970
    {
 
2971
      my_free((char*) entry,MYF(0));
 
2972
      return 0;
 
2973
    }
 
2974
  }
 
2975
  return entry;
 
2976
}
 
2977
 
 
2978
/*
 
2979
  When a user variable is updated (in a SET command or a query like
 
2980
  SELECT @a:= ).
 
2981
*/
 
2982
 
 
2983
bool Item_func_set_user_var::fix_fields(THD *thd, Item **ref)
 
2984
{
 
2985
  assert(fixed == 0);
 
2986
  /* fix_fields will call Item_func_set_user_var::fix_length_and_dec */
 
2987
  if (Item_func::fix_fields(thd, ref) ||
 
2988
      !(entry= get_variable(&thd->user_vars, name, 1)))
 
2989
    return true;
 
2990
  /* 
 
2991
     Remember the last query which updated it, this way a query can later know
 
2992
     if this variable is a constant item in the query (it is if update_query_id
 
2993
     is different from query_id).
 
2994
  */
 
2995
  entry->update_query_id= thd->query_id;
 
2996
  /*
 
2997
    As it is wrong and confusing to associate any 
 
2998
    character set with NULL, @a should be latin2
 
2999
    after this query sequence:
 
3000
 
 
3001
      SET @a=_latin2'string';
 
3002
      SET @a=NULL;
 
3003
 
 
3004
    I.e. the second query should not change the charset
 
3005
    to the current default value, but should keep the 
 
3006
    original value assigned during the first query.
 
3007
    In order to do it, we don't copy charset
 
3008
    from the argument if the argument is NULL
 
3009
    and the variable has previously been initialized.
 
3010
  */
 
3011
  null_item= (args[0]->type() == NULL_ITEM);
 
3012
  if (!entry->collation.collation || !null_item)
 
3013
    entry->collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
 
3014
  collation.set(entry->collation.collation, DERIVATION_IMPLICIT);
 
3015
  cached_result_type= args[0]->result_type();
 
3016
  return false;
 
3017
}
 
3018
 
 
3019
 
 
3020
void
 
3021
Item_func_set_user_var::fix_length_and_dec()
 
3022
{
 
3023
  maybe_null=args[0]->maybe_null;
 
3024
  max_length=args[0]->max_length;
 
3025
  decimals=args[0]->decimals;
 
3026
  collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
 
3027
}
 
3028
 
 
3029
 
 
3030
/*
 
3031
  Mark field in read_map
 
3032
 
 
3033
  NOTES
 
3034
    This is used by filesort to register used fields in a a temporary
 
3035
    column read set or to register used fields in a view
 
3036
*/
 
3037
 
 
3038
bool Item_func_set_user_var::register_field_in_read_map(uchar *arg)
 
3039
{
 
3040
  if (result_field)
 
3041
  {
 
3042
    Table *table= (Table *) arg;
 
3043
    if (result_field->table == table || !table)
 
3044
      bitmap_set_bit(result_field->table->read_set, result_field->field_index);
 
3045
  }
 
3046
  return 0;
 
3047
}
 
3048
 
 
3049
 
 
3050
/**
 
3051
  Set value to user variable.
 
3052
 
 
3053
  @param entry          pointer to structure representing variable
 
3054
  @param set_null       should we set NULL value ?
 
3055
  @param ptr            pointer to buffer with new value
 
3056
  @param length         length of new value
 
3057
  @param type           type of new value
 
3058
  @param cs             charset info for new value
 
3059
  @param dv             derivation for new value
 
3060
  @param unsigned_arg   indiates if a value of type INT_RESULT is unsigned
 
3061
 
 
3062
  @note Sets error and fatal error if allocation fails.
 
3063
 
 
3064
  @retval
 
3065
    false   success
 
3066
  @retval
 
3067
    true    failure
 
3068
*/
 
3069
 
 
3070
static bool
 
3071
update_hash(user_var_entry *entry, bool set_null, void *ptr, uint length,
 
3072
            Item_result type, const CHARSET_INFO * const cs, Derivation dv,
 
3073
            bool unsigned_arg)
 
3074
{
 
3075
  if (set_null)
 
3076
  {
 
3077
    char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3078
    if (entry->value && entry->value != pos)
 
3079
      my_free(entry->value,MYF(0));
 
3080
    entry->value= 0;
 
3081
    entry->length= 0;
 
3082
  }
 
3083
  else
 
3084
  {
 
3085
    if (type == STRING_RESULT)
 
3086
      length++;                                 // Store strings with end \0
 
3087
    if (length <= extra_size)
 
3088
    {
 
3089
      /* Save value in value struct */
 
3090
      char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3091
      if (entry->value != pos)
 
3092
      {
 
3093
        if (entry->value)
 
3094
          my_free(entry->value,MYF(0));
 
3095
        entry->value=pos;
 
3096
      }
 
3097
    }
 
3098
    else
 
3099
    {
 
3100
      /* Allocate variable */
 
3101
      if (entry->length != length)
 
3102
      {
 
3103
        char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
 
3104
        if (entry->value == pos)
 
3105
          entry->value=0;
 
3106
        entry->value= (char*) my_realloc(entry->value, length,
 
3107
                                         MYF(MY_ALLOW_ZERO_PTR | MY_WME |
 
3108
                                             ME_FATALERROR));
 
3109
        if (!entry->value)
 
3110
          return 1;
 
3111
      }
 
3112
    }
 
3113
    if (type == STRING_RESULT)
 
3114
    {
 
3115
      length--;                                 // Fix length change above
 
3116
      entry->value[length]= 0;                  // Store end \0
 
3117
    }
 
3118
    memcpy(entry->value,ptr,length);
 
3119
    if (type == DECIMAL_RESULT)
 
3120
      ((my_decimal*)entry->value)->fix_buffer_pointer();
 
3121
    entry->length= length;
 
3122
    entry->collation.set(cs, dv);
 
3123
    entry->unsigned_flag= unsigned_arg;
 
3124
  }
 
3125
  entry->type=type;
 
3126
  return 0;
 
3127
}
 
3128
 
 
3129
 
 
3130
bool
 
3131
Item_func_set_user_var::update_hash(void *ptr, uint length,
 
3132
                                    Item_result res_type,
 
3133
                                    const CHARSET_INFO * const cs, Derivation dv,
 
3134
                                    bool unsigned_arg)
 
3135
{
 
3136
  /*
 
3137
    If we set a variable explicitely to NULL then keep the old
 
3138
    result type of the variable
 
3139
  */
 
3140
  if ((null_value= args[0]->null_value) && null_item)
 
3141
    res_type= entry->type;                      // Don't change type of item
 
3142
  if (::update_hash(entry, (null_value= args[0]->null_value),
 
3143
                    ptr, length, res_type, cs, dv, unsigned_arg))
 
3144
  {
 
3145
    null_value= 1;
 
3146
    return 1;
 
3147
  }
 
3148
  return 0;
 
3149
}
 
3150
 
 
3151
 
 
3152
/** Get the value of a variable as a double. */
 
3153
 
 
3154
double user_var_entry::val_real(bool *null_value)
 
3155
{
 
3156
  if ((*null_value= (value == 0)))
 
3157
    return 0.0;
 
3158
 
 
3159
  switch (type) {
 
3160
  case REAL_RESULT:
 
3161
    return *(double*) value;
 
3162
  case INT_RESULT:
 
3163
    return (double) *(int64_t*) value;
 
3164
  case DECIMAL_RESULT:
 
3165
  {
 
3166
    double result;
 
3167
    my_decimal2double(E_DEC_FATAL_ERROR, (my_decimal *)value, &result);
 
3168
    return result;
 
3169
  }
 
3170
  case STRING_RESULT:
 
3171
    return my_atof(value);                      // This is null terminated
 
3172
  case ROW_RESULT:
 
3173
    assert(1);                          // Impossible
 
3174
    break;
 
3175
  }
 
3176
  return 0.0;                                   // Impossible
 
3177
}
 
3178
 
 
3179
 
 
3180
/** Get the value of a variable as an integer. */
 
3181
 
 
3182
int64_t user_var_entry::val_int(bool *null_value) const
 
3183
{
 
3184
  if ((*null_value= (value == 0)))
 
3185
    return 0L;
 
3186
 
 
3187
  switch (type) {
 
3188
  case REAL_RESULT:
 
3189
    return (int64_t) *(double*) value;
 
3190
  case INT_RESULT:
 
3191
    return *(int64_t*) value;
 
3192
  case DECIMAL_RESULT:
 
3193
  {
 
3194
    int64_t result;
 
3195
    my_decimal2int(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, &result);
 
3196
    return result;
 
3197
  }
 
3198
  case STRING_RESULT:
 
3199
  {
 
3200
    int error;
 
3201
    return my_strtoll10(value, (char**) 0, &error);// String is null terminated
 
3202
  }
 
3203
  case ROW_RESULT:
 
3204
    assert(1);                          // Impossible
 
3205
    break;
 
3206
  }
 
3207
  return 0L;                                    // Impossible
 
3208
}
 
3209
 
 
3210
 
 
3211
/** Get the value of a variable as a string. */
 
3212
 
 
3213
String *user_var_entry::val_str(bool *null_value, String *str,
 
3214
                                uint decimals)
 
3215
{
 
3216
  if ((*null_value= (value == 0)))
 
3217
    return (String*) 0;
 
3218
 
 
3219
  switch (type) {
 
3220
  case REAL_RESULT:
 
3221
    str->set_real(*(double*) value, decimals, &my_charset_bin);
 
3222
    break;
 
3223
  case INT_RESULT:
 
3224
    if (!unsigned_flag)
 
3225
      str->set(*(int64_t*) value, &my_charset_bin);
 
3226
    else
 
3227
      str->set(*(uint64_t*) value, &my_charset_bin);
 
3228
    break;
 
3229
  case DECIMAL_RESULT:
 
3230
    my_decimal2string(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, 0, 0, str);
 
3231
    break;
 
3232
  case STRING_RESULT:
 
3233
    if (str->copy(value, length, collation.collation))
 
3234
      str= 0;                                   // EOM error
 
3235
  case ROW_RESULT:
 
3236
    assert(1);                          // Impossible
 
3237
    break;
 
3238
  }
 
3239
  return(str);
 
3240
}
 
3241
 
 
3242
/** Get the value of a variable as a decimal. */
 
3243
 
 
3244
my_decimal *user_var_entry::val_decimal(bool *null_value, my_decimal *val)
 
3245
{
 
3246
  if ((*null_value= (value == 0)))
 
3247
    return 0;
 
3248
 
 
3249
  switch (type) {
 
3250
  case REAL_RESULT:
 
3251
    double2my_decimal(E_DEC_FATAL_ERROR, *(double*) value, val);
 
3252
    break;
 
3253
  case INT_RESULT:
 
3254
    int2my_decimal(E_DEC_FATAL_ERROR, *(int64_t*) value, 0, val);
 
3255
    break;
 
3256
  case DECIMAL_RESULT:
 
3257
    val= (my_decimal *)value;
 
3258
    break;
 
3259
  case STRING_RESULT:
 
3260
    str2my_decimal(E_DEC_FATAL_ERROR, value, length, collation.collation, val);
 
3261
    break;
 
3262
  case ROW_RESULT:
 
3263
    assert(1);                          // Impossible
 
3264
    break;
 
3265
  }
 
3266
  return(val);
 
3267
}
 
3268
 
 
3269
/**
 
3270
  This functions is invoked on SET \@variable or
 
3271
  \@variable:= expression.
 
3272
 
 
3273
  Evaluate (and check expression), store results.
 
3274
 
 
3275
  @note
 
3276
    For now it always return OK. All problem with value evaluating
 
3277
    will be caught by thd->is_error() check in sql_set_variables().
 
3278
 
 
3279
  @retval
 
3280
    false OK.
 
3281
*/
 
3282
 
 
3283
bool
 
3284
Item_func_set_user_var::check(bool use_result_field)
 
3285
{
 
3286
  if (use_result_field && !result_field)
 
3287
    use_result_field= false;
 
3288
 
 
3289
  switch (cached_result_type) {
 
3290
  case REAL_RESULT:
 
3291
  {
 
3292
    save_result.vreal= use_result_field ? result_field->val_real() :
 
3293
                        args[0]->val_real();
 
3294
    break;
 
3295
  }
 
3296
  case INT_RESULT:
 
3297
  {
 
3298
    save_result.vint= use_result_field ? result_field->val_int() :
 
3299
                       args[0]->val_int();
 
3300
    unsigned_flag= use_result_field ? ((Field_num*)result_field)->unsigned_flag:
 
3301
                    args[0]->unsigned_flag;
 
3302
    break;
 
3303
  }
 
3304
  case STRING_RESULT:
 
3305
  {
 
3306
    save_result.vstr= use_result_field ? result_field->val_str(&value) :
 
3307
                       args[0]->val_str(&value);
 
3308
    break;
 
3309
  }
 
3310
  case DECIMAL_RESULT:
 
3311
  {
 
3312
    save_result.vdec= use_result_field ?
 
3313
                       result_field->val_decimal(&decimal_buff) :
 
3314
                       args[0]->val_decimal(&decimal_buff);
 
3315
    break;
 
3316
  }
 
3317
  case ROW_RESULT:
 
3318
  default:
 
3319
    // This case should never be chosen
 
3320
    assert(0);
 
3321
    break;
 
3322
  }
 
3323
  return(false);
 
3324
}
 
3325
 
 
3326
 
 
3327
/**
 
3328
  This functions is invoked on
 
3329
  SET \@variable or \@variable:= expression.
 
3330
 
 
3331
  @note
 
3332
    We have to store the expression as such in the variable, independent of
 
3333
    the value method used by the user
 
3334
 
 
3335
  @retval
 
3336
    0   OK
 
3337
  @retval
 
3338
    1   EOM Error
 
3339
 
 
3340
*/
 
3341
 
 
3342
bool
 
3343
Item_func_set_user_var::update()
 
3344
{
 
3345
  bool res= false;
 
3346
 
 
3347
  switch (cached_result_type) {
 
3348
  case REAL_RESULT:
 
3349
  {
 
3350
    res= update_hash((void*) &save_result.vreal,sizeof(save_result.vreal),
 
3351
                     REAL_RESULT, &my_charset_bin, DERIVATION_IMPLICIT, 0);
 
3352
    break;
 
3353
  }
 
3354
  case INT_RESULT:
 
3355
  {
 
3356
    res= update_hash((void*) &save_result.vint, sizeof(save_result.vint),
 
3357
                     INT_RESULT, &my_charset_bin, DERIVATION_IMPLICIT,
 
3358
                     unsigned_flag);
 
3359
    break;
 
3360
  }
 
3361
  case STRING_RESULT:
 
3362
  {
 
3363
    if (!save_result.vstr)                                      // Null value
 
3364
      res= update_hash((void*) 0, 0, STRING_RESULT, &my_charset_bin,
 
3365
                       DERIVATION_IMPLICIT, 0);
 
3366
    else
 
3367
      res= update_hash((void*) save_result.vstr->ptr(),
 
3368
                       save_result.vstr->length(), STRING_RESULT,
 
3369
                       save_result.vstr->charset(),
 
3370
                       DERIVATION_IMPLICIT, 0);
 
3371
    break;
 
3372
  }
 
3373
  case DECIMAL_RESULT:
 
3374
  {
 
3375
    if (!save_result.vdec)                                      // Null value
 
3376
      res= update_hash((void*) 0, 0, DECIMAL_RESULT, &my_charset_bin,
 
3377
                       DERIVATION_IMPLICIT, 0);
 
3378
    else
 
3379
      res= update_hash((void*) save_result.vdec,
 
3380
                       sizeof(my_decimal), DECIMAL_RESULT,
 
3381
                       &my_charset_bin, DERIVATION_IMPLICIT, 0);
 
3382
    break;
 
3383
  }
 
3384
  case ROW_RESULT:
 
3385
  default:
 
3386
    // This case should never be chosen
 
3387
    assert(0);
 
3388
    break;
 
3389
  }
 
3390
  return(res);
 
3391
}
 
3392
 
 
3393
 
 
3394
double Item_func_set_user_var::val_real()
 
3395
{
 
3396
  assert(fixed == 1);
 
3397
  check(0);
 
3398
  update();                                     // Store expression
 
3399
  return entry->val_real(&null_value);
 
3400
}
 
3401
 
 
3402
int64_t Item_func_set_user_var::val_int()
 
3403
{
 
3404
  assert(fixed == 1);
 
3405
  check(0);
 
3406
  update();                                     // Store expression
 
3407
  return entry->val_int(&null_value);
 
3408
}
 
3409
 
 
3410
String *Item_func_set_user_var::val_str(String *str)
 
3411
{
 
3412
  assert(fixed == 1);
 
3413
  check(0);
 
3414
  update();                                     // Store expression
 
3415
  return entry->val_str(&null_value, str, decimals);
 
3416
}
 
3417
 
 
3418
 
 
3419
my_decimal *Item_func_set_user_var::val_decimal(my_decimal *val)
 
3420
{
 
3421
  assert(fixed == 1);
 
3422
  check(0);
 
3423
  update();                                     // Store expression
 
3424
  return entry->val_decimal(&null_value, val);
 
3425
}
 
3426
 
 
3427
 
 
3428
double Item_func_set_user_var::val_result()
 
3429
{
 
3430
  assert(fixed == 1);
 
3431
  check(true);
 
3432
  update();                                     // Store expression
 
3433
  return entry->val_real(&null_value);
 
3434
}
 
3435
 
 
3436
int64_t Item_func_set_user_var::val_int_result()
 
3437
{
 
3438
  assert(fixed == 1);
 
3439
  check(true);
 
3440
  update();                                     // Store expression
 
3441
  return entry->val_int(&null_value);
 
3442
}
 
3443
 
 
3444
String *Item_func_set_user_var::str_result(String *str)
 
3445
{
 
3446
  assert(fixed == 1);
 
3447
  check(true);
 
3448
  update();                                     // Store expression
 
3449
  return entry->val_str(&null_value, str, decimals);
 
3450
}
 
3451
 
 
3452
 
 
3453
my_decimal *Item_func_set_user_var::val_decimal_result(my_decimal *val)
 
3454
{
 
3455
  assert(fixed == 1);
 
3456
  check(true);
 
3457
  update();                                     // Store expression
 
3458
  return entry->val_decimal(&null_value, val);
 
3459
}
 
3460
 
 
3461
 
 
3462
void Item_func_set_user_var::print(String *str, enum_query_type query_type)
 
3463
{
 
3464
  str->append(STRING_WITH_LEN("(@"));
 
3465
  str->append(name.str, name.length);
 
3466
  str->append(STRING_WITH_LEN(":="));
 
3467
  args[0]->print(str, query_type);
 
3468
  str->append(')');
 
3469
}
 
3470
 
 
3471
 
 
3472
void Item_func_set_user_var::print_as_stmt(String *str,
 
3473
                                           enum_query_type query_type)
 
3474
{
 
3475
  str->append(STRING_WITH_LEN("set @"));
 
3476
  str->append(name.str, name.length);
 
3477
  str->append(STRING_WITH_LEN(":="));
 
3478
  args[0]->print(str, query_type);
 
3479
  str->append(')');
 
3480
}
 
3481
 
 
3482
bool Item_func_set_user_var::send(Protocol *protocol, String *str_arg)
 
3483
{
 
3484
  if (result_field)
 
3485
  {
 
3486
    check(1);
 
3487
    update();
 
3488
    return protocol->store(result_field);
 
3489
  }
 
3490
  return Item::send(protocol, str_arg);
 
3491
}
 
3492
 
 
3493
void Item_func_set_user_var::make_field(Send_field *tmp_field)
 
3494
{
 
3495
  if (result_field)
 
3496
  {
 
3497
    result_field->make_field(tmp_field);
 
3498
    assert(tmp_field->table_name != 0);
 
3499
    if (Item::name)
 
3500
      tmp_field->col_name=Item::name;               // Use user supplied name
 
3501
  }
 
3502
  else
 
3503
    Item::make_field(tmp_field);
 
3504
}
 
3505
 
 
3506
 
 
3507
/*
 
3508
  Save the value of a user variable into a field
 
3509
 
 
3510
  SYNOPSIS
 
3511
    save_in_field()
 
3512
      field           target field to save the value to
 
3513
      no_conversion   flag indicating whether conversions are allowed
 
3514
 
 
3515
  DESCRIPTION
 
3516
    Save the function value into a field and update the user variable
 
3517
    accordingly. If a result field is defined and the target field doesn't
 
3518
    coincide with it then the value from the result field will be used as
 
3519
    the new value of the user variable.
 
3520
 
 
3521
    The reason to have this method rather than simply using the result
 
3522
    field in the val_xxx() methods is that the value from the result field
 
3523
    not always can be used when the result field is defined.
 
3524
    Let's consider the following cases:
 
3525
    1) when filling a tmp table the result field is defined but the value of it
 
3526
    is undefined because it has to be produced yet. Thus we can't use it.
 
3527
    2) on execution of an INSERT ... SELECT statement the save_in_field()
 
3528
    function will be called to fill the data in the new record. If the SELECT
 
3529
    part uses a tmp table then the result field is defined and should be
 
3530
    used in order to get the correct result.
 
3531
 
 
3532
    The difference between the SET_USER_VAR function and regular functions
 
3533
    like CONCAT is that the Item_func objects for the regular functions are
 
3534
    replaced by Item_field objects after the values of these functions have
 
3535
    been stored in a tmp table. Yet an object of the Item_field class cannot
 
3536
    be used to update a user variable.
 
3537
    Due to this we have to handle the result field in a special way here and
 
3538
    in the Item_func_set_user_var::send() function.
 
3539
 
 
3540
  RETURN VALUES
 
3541
    false       Ok
 
3542
    true        Error
 
3543
*/
 
3544
 
 
3545
int Item_func_set_user_var::save_in_field(Field *field, bool no_conversions,
 
3546
                                          bool can_use_result_field)
 
3547
{
 
3548
  bool use_result_field= (!can_use_result_field ? 0 :
 
3549
                          (result_field && result_field != field));
 
3550
  int error;
 
3551
 
 
3552
  /* Update the value of the user variable */
 
3553
  check(use_result_field);
 
3554
  update();
 
3555
 
 
3556
  if (result_type() == STRING_RESULT ||
 
3557
      (result_type() == REAL_RESULT && field->result_type() == STRING_RESULT))
 
3558
  {
 
3559
    String *result;
 
3560
    const CHARSET_INFO * const cs= collation.collation;
 
3561
    char buff[MAX_FIELD_WIDTH];         // Alloc buffer for small columns
 
3562
    str_value.set_quick(buff, sizeof(buff), cs);
 
3563
    result= entry->val_str(&null_value, &str_value, decimals);
 
3564
 
 
3565
    if (null_value)
 
3566
    {
 
3567
      str_value.set_quick(0, 0, cs);
 
3568
      return set_field_to_null_with_conversions(field, no_conversions);
 
3569
    }
 
3570
 
 
3571
    /* NOTE: If null_value == false, "result" must be not NULL.  */
 
3572
 
 
3573
    field->set_notnull();
 
3574
    error=field->store(result->ptr(),result->length(),cs);
 
3575
    str_value.set_quick(0, 0, cs);
 
3576
  }
 
3577
  else if (result_type() == REAL_RESULT)
 
3578
  {
 
3579
    double nr= entry->val_real(&null_value);
 
3580
    if (null_value)
 
3581
      return set_field_to_null(field);
 
3582
    field->set_notnull();
 
3583
    error=field->store(nr);
 
3584
  }
 
3585
  else if (result_type() == DECIMAL_RESULT)
 
3586
  {
 
3587
    my_decimal decimal_value;
 
3588
    my_decimal *val= entry->val_decimal(&null_value, &decimal_value);
 
3589
    if (null_value)
 
3590
      return set_field_to_null(field);
 
3591
    field->set_notnull();
 
3592
    error=field->store_decimal(val);
 
3593
  }
 
3594
  else
 
3595
  {
 
3596
    int64_t nr= entry->val_int(&null_value);
 
3597
    if (null_value)
 
3598
      return set_field_to_null_with_conversions(field, no_conversions);
 
3599
    field->set_notnull();
 
3600
    error=field->store(nr, unsigned_flag);
 
3601
  }
 
3602
  return error;
 
3603
}
 
3604
 
 
3605
 
 
3606
String *
 
3607
Item_func_get_user_var::val_str(String *str)
 
3608
{
 
3609
  assert(fixed == 1);
 
3610
  if (!var_entry)
 
3611
    return((String*) 0);                        // No such variable
 
3612
  return(var_entry->val_str(&null_value, str, decimals));
 
3613
}
 
3614
 
 
3615
 
 
3616
double Item_func_get_user_var::val_real()
 
3617
{
 
3618
  assert(fixed == 1);
 
3619
  if (!var_entry)
 
3620
    return 0.0;                                 // No such variable
 
3621
  return (var_entry->val_real(&null_value));
 
3622
}
 
3623
 
 
3624
 
 
3625
my_decimal *Item_func_get_user_var::val_decimal(my_decimal *dec)
 
3626
{
 
3627
  assert(fixed == 1);
 
3628
  if (!var_entry)
 
3629
    return 0;
 
3630
  return var_entry->val_decimal(&null_value, dec);
 
3631
}
 
3632
 
 
3633
 
 
3634
int64_t Item_func_get_user_var::val_int()
 
3635
{
 
3636
  assert(fixed == 1);
 
3637
  if (!var_entry)
 
3638
    return 0L;                          // No such variable
 
3639
  return (var_entry->val_int(&null_value));
 
3640
}
 
3641
 
 
3642
 
 
3643
/**
 
3644
  Get variable by name and, if necessary, put the record of variable 
 
3645
  use into the binary log.
 
3646
 
 
3647
  When a user variable is invoked from an update query (INSERT, UPDATE etc),
 
3648
  stores this variable and its value in thd->user_var_events, so that it can be
 
3649
  written to the binlog (will be written just before the query is written, see
 
3650
  log.cc).
 
3651
 
 
3652
  @param      thd        Current thread
 
3653
  @param      name       Variable name
 
3654
  @param[out] out_entry  variable structure or NULL. The pointer is set
 
3655
                         regardless of whether function succeeded or not.
 
3656
 
 
3657
  @retval
 
3658
    0  OK
 
3659
  @retval
 
3660
    1  Failed to put appropriate record into binary log
 
3661
 
 
3662
*/
 
3663
 
 
3664
int get_var_with_binlog(THD *thd, enum_sql_command sql_command,
 
3665
                        LEX_STRING &name, user_var_entry **out_entry)
 
3666
{
 
3667
  BINLOG_USER_VAR_EVENT *user_var_event;
 
3668
  user_var_entry *var_entry;
 
3669
  var_entry= get_variable(&thd->user_vars, name, 0);
 
3670
 
 
3671
  /*
 
3672
    Any reference to user-defined variable which is done from stored
 
3673
    function or trigger affects their execution and the execution of the
 
3674
    calling statement. We must log all such variables even if they are 
 
3675
    not involved in table-updating statements.
 
3676
  */
 
3677
  if (!(opt_bin_log && 
 
3678
       (is_update_query(sql_command) || thd->in_sub_stmt)))
 
3679
  {
 
3680
    *out_entry= var_entry;
 
3681
    return 0;
 
3682
  }
 
3683
 
 
3684
  if (!var_entry)
 
3685
  {
 
3686
    /*
 
3687
      If the variable does not exist, it's NULL, but we want to create it so
 
3688
      that it gets into the binlog (if it didn't, the slave could be
 
3689
      influenced by a variable of the same name previously set by another
 
3690
      thread).
 
3691
      We create it like if it had been explicitly set with SET before.
 
3692
      The 'new' mimics what sql_yacc.yy does when 'SET @a=10;'.
 
3693
      sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'
 
3694
      in dispatch_command()). Instead of building a one-element list to pass to
 
3695
      sql_set_variables(), we could instead manually call check() and update();
 
3696
      this would save memory and time; but calling sql_set_variables() makes
 
3697
      one unique place to maintain (sql_set_variables()). 
 
3698
 
 
3699
      Manipulation with lex is necessary since free_underlaid_joins
 
3700
      is going to release memory belonging to the main query.
 
3701
    */
 
3702
 
 
3703
    List<set_var_base> tmp_var_list;
 
3704
    LEX *sav_lex= thd->lex, lex_tmp;
 
3705
    thd->lex= &lex_tmp;
 
3706
    lex_start(thd);
 
3707
    tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(name,
 
3708
                                                                       new Item_null())));
 
3709
    /* Create the variable */
 
3710
    if (sql_set_variables(thd, &tmp_var_list))
 
3711
    {
 
3712
      thd->lex= sav_lex;
 
3713
      goto err;
 
3714
    }
 
3715
    thd->lex= sav_lex;
 
3716
    if (!(var_entry= get_variable(&thd->user_vars, name, 0)))
 
3717
      goto err;
 
3718
  }
 
3719
  else if (var_entry->used_query_id == thd->query_id ||
 
3720
           mysql_bin_log.is_query_in_union(thd, var_entry->used_query_id))
 
3721
  {
 
3722
    /* 
 
3723
       If this variable was already stored in user_var_events by this query
 
3724
       (because it's used in more than one place in the query), don't store
 
3725
       it.
 
3726
    */
 
3727
    *out_entry= var_entry;
 
3728
    return 0;
 
3729
  }
 
3730
 
 
3731
  uint size;
 
3732
  /*
 
3733
    First we need to store value of var_entry, when the next situation
 
3734
    appears:
 
3735
    > set @a:=1;
 
3736
    > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);
 
3737
    We have to write to binlog value @a= 1.
 
3738
 
 
3739
    We allocate the user_var_event on user_var_events_alloc pool, not on
 
3740
    the this-statement-execution pool because in SPs user_var_event objects 
 
3741
    may need to be valid after current [SP] statement execution pool is
 
3742
    destroyed.
 
3743
  */
 
3744
  size= ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT)) + var_entry->length;
 
3745
  if (!(user_var_event= (BINLOG_USER_VAR_EVENT *)
 
3746
        alloc_root(thd->user_var_events_alloc, size)))
 
3747
    goto err;
 
3748
 
 
3749
  user_var_event->value= (char*) user_var_event +
 
3750
    ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT));
 
3751
  user_var_event->user_var_event= var_entry;
 
3752
  user_var_event->type= var_entry->type;
 
3753
  user_var_event->charset_number= var_entry->collation.collation->number;
 
3754
  if (!var_entry->value)
 
3755
  {
 
3756
    /* NULL value*/
 
3757
    user_var_event->length= 0;
 
3758
    user_var_event->value= 0;
 
3759
  }
 
3760
  else
 
3761
  {
 
3762
    user_var_event->length= var_entry->length;
 
3763
    memcpy(user_var_event->value, var_entry->value,
 
3764
           var_entry->length);
 
3765
  }
 
3766
  /* Mark that this variable has been used by this query */
 
3767
  var_entry->used_query_id= thd->query_id;
 
3768
  if (insert_dynamic(&thd->user_var_events, (uchar*) &user_var_event))
 
3769
    goto err;
 
3770
 
 
3771
  *out_entry= var_entry;
 
3772
  return 0;
 
3773
 
 
3774
err:
 
3775
  *out_entry= var_entry;
 
3776
  return 1;
 
3777
}
 
3778
 
 
3779
void Item_func_get_user_var::fix_length_and_dec()
 
3780
{
 
3781
  THD *thd=current_thd;
 
3782
  int error;
 
3783
  maybe_null=1;
 
3784
  decimals=NOT_FIXED_DEC;
 
3785
  max_length=MAX_BLOB_WIDTH;
 
3786
 
 
3787
  error= get_var_with_binlog(thd, thd->lex->sql_command, name, &var_entry);
 
3788
 
 
3789
  /*
 
3790
    If the variable didn't exist it has been created as a STRING-type.
 
3791
    'var_entry' is NULL only if there occured an error during the call to
 
3792
    get_var_with_binlog.
 
3793
  */
 
3794
  if (var_entry)
 
3795
  {
 
3796
    m_cached_result_type= var_entry->type;
 
3797
    unsigned_flag= var_entry->unsigned_flag;
 
3798
    max_length= var_entry->length;
 
3799
 
 
3800
    collation.set(var_entry->collation);
 
3801
    switch(m_cached_result_type) {
 
3802
    case REAL_RESULT:
 
3803
      max_length= DBL_DIG + 8;
 
3804
      break;
 
3805
    case INT_RESULT:
 
3806
      max_length= MAX_BIGINT_WIDTH;
 
3807
      decimals=0;
 
3808
      break;
 
3809
    case STRING_RESULT:
 
3810
      max_length= MAX_BLOB_WIDTH;
 
3811
      break;
 
3812
    case DECIMAL_RESULT:
 
3813
      max_length= DECIMAL_MAX_STR_LENGTH;
 
3814
      decimals= DECIMAL_MAX_SCALE;
 
3815
      break;
 
3816
    case ROW_RESULT:                            // Keep compiler happy
 
3817
    default:
 
3818
      assert(0);
 
3819
      break;
 
3820
    }
 
3821
  }
 
3822
  else
 
3823
  {
 
3824
    collation.set(&my_charset_bin, DERIVATION_IMPLICIT);
 
3825
    null_value= 1;
 
3826
    m_cached_result_type= STRING_RESULT;
 
3827
    max_length= MAX_BLOB_WIDTH;
 
3828
  }
 
3829
}
 
3830
 
 
3831
 
 
3832
bool Item_func_get_user_var::const_item() const
 
3833
{
 
3834
  return (!var_entry || current_thd->query_id != var_entry->update_query_id);
 
3835
}
 
3836
 
 
3837
 
 
3838
enum Item_result Item_func_get_user_var::result_type() const
 
3839
{
 
3840
  return m_cached_result_type;
 
3841
}
 
3842
 
 
3843
 
 
3844
void Item_func_get_user_var::print(String *str,
 
3845
                                   enum_query_type query_type __attribute__((unused)))
 
3846
{
 
3847
  str->append(STRING_WITH_LEN("(@"));
 
3848
  str->append(name.str,name.length);
 
3849
  str->append(')');
 
3850
}
 
3851
 
 
3852
 
 
3853
bool Item_func_get_user_var::eq(const Item *item,
 
3854
                                bool binary_cmp __attribute__((unused))) const
 
3855
{
 
3856
  /* Assume we don't have rtti */
 
3857
  if (this == item)
 
3858
    return 1;                                   // Same item is same.
 
3859
  /* Check if other type is also a get_user_var() object */
 
3860
  if (item->type() != FUNC_ITEM ||
 
3861
      ((Item_func*) item)->functype() != functype())
 
3862
    return 0;
 
3863
  Item_func_get_user_var *other=(Item_func_get_user_var*) item;
 
3864
  return (name.length == other->name.length &&
 
3865
          !memcmp(name.str, other->name.str, name.length));
 
3866
}
 
3867
 
 
3868
 
 
3869
bool Item_user_var_as_out_param::fix_fields(THD *thd, Item **ref)
 
3870
{
 
3871
  assert(fixed == 0);
 
3872
  if (Item::fix_fields(thd, ref) ||
 
3873
      !(entry= get_variable(&thd->user_vars, name, 1)))
 
3874
    return true;
 
3875
  entry->type= STRING_RESULT;
 
3876
  /*
 
3877
    Let us set the same collation which is used for loading
 
3878
    of fields in LOAD DATA INFILE.
 
3879
    (Since Item_user_var_as_out_param is used only there).
 
3880
  */
 
3881
  entry->collation.set(thd->variables.collation_database);
 
3882
  entry->update_query_id= thd->query_id;
 
3883
  return false;
 
3884
}
 
3885
 
 
3886
 
 
3887
void Item_user_var_as_out_param::set_null_value(const CHARSET_INFO * const cs)
 
3888
{
 
3889
  ::update_hash(entry, true, 0, 0, STRING_RESULT, cs,
 
3890
                DERIVATION_IMPLICIT, 0 /* unsigned_arg */);
 
3891
}
 
3892
 
 
3893
 
 
3894
void Item_user_var_as_out_param::set_value(const char *str, uint length,
 
3895
                                           const CHARSET_INFO * const cs)
 
3896
{
 
3897
  ::update_hash(entry, false, (void*)str, length, STRING_RESULT, cs,
 
3898
                DERIVATION_IMPLICIT, 0 /* unsigned_arg */);
 
3899
}
 
3900
 
 
3901
 
 
3902
double Item_user_var_as_out_param::val_real()
 
3903
{
 
3904
  assert(0);
 
3905
  return 0.0;
 
3906
}
 
3907
 
 
3908
 
 
3909
int64_t Item_user_var_as_out_param::val_int()
 
3910
{
 
3911
  assert(0);
 
3912
  return 0;
 
3913
}
 
3914
 
 
3915
 
 
3916
String* Item_user_var_as_out_param::val_str(String *str __attribute__((unused)))
 
3917
{
 
3918
  assert(0);
 
3919
  return 0;
 
3920
}
 
3921
 
 
3922
 
 
3923
my_decimal* Item_user_var_as_out_param::val_decimal(my_decimal *decimal_buffer __attribute__((unused)))
 
3924
{
 
3925
  assert(0);
 
3926
  return 0;
 
3927
}
 
3928
 
 
3929
 
 
3930
void Item_user_var_as_out_param::print(String *str,
 
3931
                                       enum_query_type query_type __attribute__((unused)))
 
3932
{
 
3933
  str->append('@');
 
3934
  str->append(name.str,name.length);
 
3935
}
 
3936
 
 
3937
 
 
3938
Item_func_get_system_var::
 
3939
Item_func_get_system_var(sys_var *var_arg, enum_var_type var_type_arg,
 
3940
                       LEX_STRING *component_arg, const char *name_arg,
 
3941
                       size_t name_len_arg)
 
3942
  :var(var_arg), var_type(var_type_arg), component(*component_arg)
 
3943
{
 
3944
  /* set_name() will allocate the name */
 
3945
  set_name(name_arg, name_len_arg, system_charset_info);
 
3946
}
 
3947
 
 
3948
 
 
3949
bool
 
3950
Item_func_get_system_var::fix_fields(THD *thd, Item **ref)
 
3951
{
 
3952
  Item *item;
 
3953
 
 
3954
  /*
 
3955
    Evaluate the system variable and substitute the result (a basic constant)
 
3956
    instead of this item. If the variable can not be evaluated,
 
3957
    the error is reported in sys_var::item().
 
3958
  */
 
3959
  if (!(item= var->item(thd, var_type, &component)))
 
3960
    return(1);                             // Impossible
 
3961
  item->set_name(name, 0, system_charset_info); // don't allocate a new name
 
3962
  thd->change_item_tree(ref, item);
 
3963
 
 
3964
  return(0);
 
3965
}
 
3966
 
 
3967
 
 
3968
bool Item_func_get_system_var::is_written_to_binlog()
 
3969
{
 
3970
  return var->is_written_to_binlog(var_type);
 
3971
}
 
3972
 
 
3973
int64_t Item_func_bit_xor::val_int()
 
3974
{
 
3975
  assert(fixed == 1);
 
3976
  uint64_t arg1= (uint64_t) args[0]->val_int();
 
3977
  uint64_t arg2= (uint64_t) args[1]->val_int();
 
3978
  if ((null_value= (args[0]->null_value || args[1]->null_value)))
 
3979
    return 0;
 
3980
  return (int64_t) (arg1 ^ arg2);
 
3981
}
 
3982
 
 
3983
 
 
3984
/***************************************************************************
 
3985
  System variables
 
3986
****************************************************************************/
 
3987
 
 
3988
/**
 
3989
  Return value of an system variable base[.name] as a constant item.
 
3990
 
 
3991
  @param thd                    Thread handler
 
3992
  @param var_type               global / session
 
3993
  @param name                   Name of base or system variable
 
3994
  @param component              Component.
 
3995
 
 
3996
  @note
 
3997
    If component.str = 0 then the variable name is in 'name'
 
3998
 
 
3999
  @return
 
4000
    - 0  : error
 
4001
    - #  : constant item
 
4002
*/
 
4003
 
 
4004
 
 
4005
Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
 
4006
                     LEX_STRING component)
 
4007
{
 
4008
  sys_var *var;
 
4009
  LEX_STRING *base_name, *component_name;
 
4010
 
 
4011
  if (component.str)
 
4012
  {
 
4013
    base_name= &component;
 
4014
    component_name= &name;
 
4015
  }
 
4016
  else
 
4017
  {
 
4018
    base_name= &name;
 
4019
    component_name= &component;                 // Empty string
 
4020
  }
 
4021
 
 
4022
  if (!(var= find_sys_var(thd, base_name->str, base_name->length)))
 
4023
    return 0;
 
4024
  if (component.str)
 
4025
  {
 
4026
    if (!var->is_struct())
 
4027
    {
 
4028
      my_error(ER_VARIABLE_IS_NOT_STRUCT, MYF(0), base_name->str);
 
4029
      return 0;
 
4030
    }
 
4031
  }
 
4032
 
 
4033
  set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH);
 
4034
 
 
4035
  return new Item_func_get_system_var(var, var_type, component_name,
 
4036
                                      NULL, 0);
 
4037
}
 
4038
 
 
4039
 
 
4040
/**
 
4041
  Check a user level lock.
 
4042
 
 
4043
  Sets null_value=true on error.
 
4044
 
 
4045
  @retval
 
4046
    1           Available
 
4047
  @retval
 
4048
    0           Already taken, or error
 
4049
*/
 
4050
 
 
4051
int64_t Item_func_is_free_lock::val_int()
 
4052
{
 
4053
  assert(fixed == 1);
 
4054
  String *res=args[0]->val_str(&value);
 
4055
  User_level_lock *ull;
 
4056
 
 
4057
  null_value=0;
 
4058
  if (!res || !res->length())
 
4059
  {
 
4060
    null_value=1;
 
4061
    return 0;
 
4062
  }
 
4063
  
 
4064
  pthread_mutex_lock(&LOCK_user_locks);
 
4065
  ull= (User_level_lock *) hash_search(&hash_user_locks, (uchar*) res->ptr(),
 
4066
                                       (size_t) res->length());
 
4067
  pthread_mutex_unlock(&LOCK_user_locks);
 
4068
  if (!ull || !ull->locked)
 
4069
    return 1;
 
4070
  return 0;
 
4071
}
 
4072
 
 
4073
int64_t Item_func_is_used_lock::val_int()
 
4074
{
 
4075
  assert(fixed == 1);
 
4076
  String *res=args[0]->val_str(&value);
 
4077
  User_level_lock *ull;
 
4078
 
 
4079
  null_value=1;
 
4080
  if (!res || !res->length())
 
4081
    return 0;
 
4082
  
 
4083
  pthread_mutex_lock(&LOCK_user_locks);
 
4084
  ull= (User_level_lock *) hash_search(&hash_user_locks, (uchar*) res->ptr(),
 
4085
                                       (size_t) res->length());
 
4086
  pthread_mutex_unlock(&LOCK_user_locks);
 
4087
  if (!ull || !ull->locked)
 
4088
    return 0;
 
4089
 
 
4090
  null_value=0;
 
4091
  return ull->thread_id;
 
4092
}
 
4093
 
 
4094
 
 
4095
int64_t Item_func_row_count::val_int()
 
4096
{
 
4097
  assert(fixed == 1);
 
4098
  THD *thd= current_thd;
 
4099
 
 
4100
  return thd->row_count_func;
 
4101
}
 
4102
 
 
4103
int64_t Item_func_found_rows::val_int()
 
4104
{
 
4105
  assert(fixed == 1);
 
4106
  THD *thd= current_thd;
 
4107
 
 
4108
  return thd->found_rows();
 
4109
}