item_func.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:79k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000-2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* This file defines all numerical functions */
  14. #ifdef USE_PRAGMA_IMPLEMENTATION
  15. #pragma implementation // gcc: Class implementation
  16. #endif
  17. #include "mysql_priv.h"
  18. #include "slave.h" // for wait_for_master_pos
  19. #include <m_ctype.h>
  20. #include <hash.h>
  21. #include <time.h>
  22. #include <ft_global.h>
  23. bool check_reserved_words(LEX_STRING *name)
  24. {
  25.   if (!my_strcasecmp(system_charset_info, name->str, "GLOBAL") ||
  26.       !my_strcasecmp(system_charset_info, name->str, "LOCAL") ||
  27.       !my_strcasecmp(system_charset_info, name->str, "SESSION"))
  28.     return TRUE;
  29.   return FALSE;
  30. }
  31. /* return TRUE if item is a constant */
  32. bool
  33. eval_const_cond(COND *cond)
  34. {
  35.   return ((Item_func*) cond)->val_int() ? TRUE : FALSE;
  36. }
  37. void Item_func::set_arguments(List<Item> &list)
  38. {
  39.   allowed_arg_cols= 1;
  40.   arg_count=list.elements;
  41.   if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
  42.   {
  43.     uint i=0;
  44.     List_iterator_fast<Item> li(list);
  45.     Item *item;
  46.     while ((item=li++))
  47.     {
  48.       args[i++]= item;
  49.       with_sum_func|=item->with_sum_func;
  50.     }
  51.   }
  52.   list.empty(); // Fields are used
  53. }
  54. Item_func::Item_func(List<Item> &list)
  55.   :allowed_arg_cols(1)
  56. {
  57.   set_arguments(list);
  58. }
  59. Item_func::Item_func(THD *thd, Item_func *item)
  60.   :Item_result_field(thd, item),
  61.    allowed_arg_cols(item->allowed_arg_cols),
  62.    arg_count(item->arg_count),
  63.    used_tables_cache(item->used_tables_cache),
  64.    not_null_tables_cache(item->not_null_tables_cache),
  65.    const_item_cache(item->const_item_cache)
  66. {
  67.   if (arg_count)
  68.   {
  69.     if (arg_count <=2)
  70.       args= tmp_arg;
  71.     else
  72.     {
  73.       if (!(args=(Item**) thd->alloc(sizeof(Item*)*arg_count)))
  74. return;
  75.     }
  76.     memcpy((char*) args, (char*) item->args, sizeof(Item*)*arg_count);
  77.   }
  78. }
  79. /*
  80.   Resolve references to table column for a function and it's argument
  81.   SYNOPSIS:
  82.   fix_fields()
  83.   thd Thread object
  84.   tables List of all open tables involved in the query
  85.   ref Pointer to where this object is used.  This reference
  86. is used if we want to replace this object with another
  87. one (for example in the summary functions).
  88.   DESCRIPTION
  89.     Call fix_fields() for all arguments to the function.  The main intention
  90.     is to allow all Item_field() objects to setup pointers to the table fields.
  91.     Sets as a side effect the following class variables:
  92.       maybe_null Set if any argument may return NULL
  93.       with_sum_func Set if any of the arguments contains a sum function
  94.       used_tables_cache Set to union of the tables used by arguments
  95.       str_value.charset If this is a string function, set this to the
  96. character set for the first argument.
  97. If any argument is binary, this is set to binary
  98.    If for any item any of the defaults are wrong, then this can
  99.    be fixed in the fix_length_and_dec() function that is called
  100.    after this one or by writing a specialized fix_fields() for the
  101.    item.
  102.   RETURN VALUES
  103.   0 ok
  104.   1 Got error.  Stored with my_error().
  105. */
  106. bool
  107. Item_func::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  108. {
  109.   DBUG_ASSERT(fixed == 0);
  110.   Item **arg,**arg_end;
  111. #ifndef EMBEDDED_LIBRARY // Avoid compiler warning
  112.   char buff[STACK_BUFF_ALLOC]; // Max argument in function
  113. #endif
  114.   used_tables_cache= not_null_tables_cache= 0;
  115.   const_item_cache=1;
  116.   if (check_stack_overrun(thd, buff))
  117.     return 1; // Fatal error if flag is set!
  118.   if (arg_count)
  119.   { // Print purify happy
  120.     for (arg=args, arg_end=args+arg_count; arg != arg_end ; arg++)
  121.     {
  122.       Item *item;
  123.       /*
  124. We can't yet set item to *arg as fix_fields may change *arg
  125. We shouldn't call fix_fields() twice, so check 'fixed' field first
  126.       */
  127.       if ((!(*arg)->fixed && (*arg)->fix_fields(thd, tables, arg)))
  128. return 1; /* purecov: inspected */
  129.       item= *arg;
  130.       if (allowed_arg_cols)
  131.       {
  132.         if (item->check_cols(allowed_arg_cols))
  133.           return 1;
  134.       }
  135.       else
  136.       {
  137.         /*  we have to fetch allowed_arg_cols from first argument */
  138.         DBUG_ASSERT(arg == args); // it is first argument
  139.         allowed_arg_cols= item->cols();
  140.         DBUG_ASSERT(allowed_arg_cols); // Can't be 0 any more
  141.       }
  142.       if (item->maybe_null)
  143. maybe_null=1;
  144.       with_sum_func= with_sum_func || item->with_sum_func;
  145.       used_tables_cache|=     item->used_tables();
  146.       not_null_tables_cache|= item->not_null_tables();
  147.       const_item_cache&=      item->const_item();
  148.     }
  149.   }
  150.   fix_length_and_dec();
  151.   if (thd->net.last_errno) // An error inside fix_length_and_dec occured
  152.     return 1;
  153.   fixed= 1;
  154.   return 0;
  155. }
  156. bool Item_func::walk (Item_processor processor, byte *argument)
  157. {
  158.   if (arg_count)
  159.   {
  160.     Item **arg,**arg_end;
  161.     for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
  162.     {
  163.       if ((*arg)->walk(processor, argument))
  164. return 1;
  165.     }
  166.   }
  167.   return (this->*processor)(argument);
  168. }
  169. /* See comments in Item_cmp_func::split_sum_func() */
  170. void Item_func::split_sum_func(THD *thd, Item **ref_pointer_array,
  171.                                List<Item> &fields)
  172. {
  173.   Item **arg, **arg_end;
  174.   for (arg= args, arg_end= args+arg_count; arg != arg_end ; arg++)
  175.     (*arg)->split_sum_func2(thd, ref_pointer_array, fields, arg);
  176. }
  177. void Item_func::update_used_tables()
  178. {
  179.   used_tables_cache=0;
  180.   const_item_cache=1;
  181.   for (uint i=0 ; i < arg_count ; i++)
  182.   {
  183.     args[i]->update_used_tables();
  184.     used_tables_cache|=args[i]->used_tables();
  185.     const_item_cache&=args[i]->const_item();
  186.   }
  187. }
  188. table_map Item_func::used_tables() const
  189. {
  190.   return used_tables_cache;
  191. }
  192. table_map Item_func::not_null_tables() const
  193. {
  194.   return not_null_tables_cache;
  195. }
  196. void Item_func::print(String *str)
  197. {
  198.   str->append(func_name());
  199.   str->append('(');
  200.   print_args(str, 0);
  201.   str->append(')');
  202. }
  203. void Item_func::print_args(String *str, uint from)
  204. {
  205.   for (uint i=from ; i < arg_count ; i++)
  206.   {
  207.     if (i != from)
  208.       str->append(',');
  209.     args[i]->print(str);
  210.   }
  211. }
  212. void Item_func::print_op(String *str)
  213. {
  214.   str->append('(');
  215.   for (uint i=0 ; i < arg_count-1 ; i++)
  216.   {
  217.     args[i]->print(str);
  218.     str->append(' ');
  219.     str->append(func_name());
  220.     str->append(' ');
  221.   }
  222.   args[arg_count-1]->print(str);
  223.   str->append(')');
  224. }
  225. bool Item_func::eq(const Item *item, bool binary_cmp) const
  226. {
  227.   /* Assume we don't have rtti */
  228.   if (this == item)
  229.     return 1;
  230.   if (item->type() != FUNC_ITEM)
  231.     return 0;
  232.   Item_func *item_func=(Item_func*) item;
  233.   if (arg_count != item_func->arg_count ||
  234.       func_name() != item_func->func_name())
  235.     return 0;
  236.   for (uint i=0; i < arg_count ; i++)
  237.     if (!args[i]->eq(item_func->args[i], binary_cmp))
  238.       return 0;
  239.   return 1;
  240. }
  241. Field *Item_func::tmp_table_field(TABLE *t_arg)
  242. {
  243.   Field *res;
  244.   LINT_INIT(res);
  245.   switch (result_type()) {
  246.   case INT_RESULT:
  247.     if (max_length > 11)
  248.       res= new Field_longlong(max_length, maybe_null, name, t_arg,
  249.       unsigned_flag);
  250.     else
  251.       res= new Field_long(max_length, maybe_null, name, t_arg,
  252.   unsigned_flag);
  253.     break;
  254.   case REAL_RESULT:
  255.     res= new Field_double(max_length, maybe_null, name, t_arg, decimals);
  256.     break;
  257.   case STRING_RESULT:
  258.     if (max_length > 255)
  259.       res= new Field_blob(max_length, maybe_null, name, t_arg, collation.collation);
  260.     else
  261.       res= new Field_string(max_length, maybe_null, name, t_arg, collation.collation);
  262.     break;
  263.   case ROW_RESULT:
  264.   default:
  265.     // This case should never be choosen
  266.     DBUG_ASSERT(0);
  267.     break;
  268.   }
  269.   return res;
  270. }
  271. String *Item_real_func::val_str(String *str)
  272. {
  273.   DBUG_ASSERT(fixed == 1);
  274.   double nr=val();
  275.   if (null_value)
  276.     return 0; /* purecov: inspected */
  277.   str->set(nr,decimals, &my_charset_bin);
  278.   return str;
  279. }
  280. String *Item_num_func::val_str(String *str)
  281. {
  282.   DBUG_ASSERT(fixed == 1);
  283.   if (hybrid_type == INT_RESULT)
  284.   {
  285.     longlong nr=val_int();
  286.     if (null_value)
  287.       return 0; /* purecov: inspected */
  288.     if (!unsigned_flag)
  289.       str->set(nr,&my_charset_bin);
  290.     else
  291.       str->set((ulonglong) nr,&my_charset_bin);
  292.   }
  293.   else
  294.   {
  295.     double nr=val();
  296.     if (null_value)
  297.       return 0; /* purecov: inspected */
  298.     str->set(nr,decimals,&my_charset_bin);
  299.   }
  300.   return str;
  301. }
  302. void Item_func::fix_num_length_and_dec()
  303. {
  304.   decimals=0;
  305.   for (uint i=0 ; i < arg_count ; i++)
  306.     set_if_bigger(decimals,args[i]->decimals);
  307.   max_length=float_length(decimals);
  308. }
  309. Item *Item_func::get_tmp_table_item(THD *thd)
  310. {
  311.   if (!with_sum_func && !const_item())
  312.     return new Item_field(result_field);
  313.   return copy_or_same(thd);
  314. }
  315. String *Item_int_func::val_str(String *str)
  316. {
  317.   DBUG_ASSERT(fixed == 1);
  318.   longlong nr=val_int();
  319.   if (null_value)
  320.     return 0;
  321.   if (!unsigned_flag)
  322.     str->set(nr,&my_charset_bin);
  323.   else
  324.     str->set((ulonglong) nr,&my_charset_bin);
  325.   return str;
  326. }
  327. /*
  328.   Change from REAL_RESULT (default) to INT_RESULT if both arguments are
  329.   integers
  330. */
  331. void Item_num_op::find_num_type(void)
  332. {
  333.   if (args[0]->result_type() == INT_RESULT &&
  334.       args[1]->result_type() == INT_RESULT)
  335.   {
  336.     hybrid_type=INT_RESULT;
  337.     unsigned_flag=args[0]->unsigned_flag | args[1]->unsigned_flag;
  338.   }
  339. }
  340. String *Item_num_op::val_str(String *str)
  341. {
  342.   DBUG_ASSERT(fixed == 1);
  343.   if (hybrid_type == INT_RESULT)
  344.   {
  345.     longlong nr=val_int();
  346.     if (null_value)
  347.       return 0; /* purecov: inspected */
  348.     if (!unsigned_flag)
  349.       str->set(nr,&my_charset_bin);
  350.     else
  351.       str->set((ulonglong) nr,&my_charset_bin);
  352.   }
  353.   else
  354.   {
  355.     double nr=val();
  356.     if (null_value)
  357.       return 0; /* purecov: inspected */
  358.     str->set(nr,decimals,&my_charset_bin);
  359.   }
  360.   return str;
  361. }
  362. void Item_func_signed::print(String *str)
  363. {
  364.   str->append("cast(", 5);
  365.   args[0]->print(str);
  366.   str->append(" as signed)", 11);
  367. }
  368. longlong Item_func_signed::val_int_from_str(int *error)
  369. {
  370.   char buff[MAX_FIELD_WIDTH], *end;
  371.   String tmp(buff,sizeof(buff), &my_charset_bin), *res;
  372.   longlong value;
  373.   /*
  374.     For a string result, we must first get the string and then convert it
  375.     to a longlong
  376.   */
  377.   if (!(res= args[0]->val_str(&tmp)))
  378.   {
  379.     null_value= 1;
  380.     *error= 0;
  381.     return 0;
  382.   }
  383.   null_value= 0;
  384.   end= (char*) res->ptr()+ res->length();
  385.   value= my_strtoll10(res->ptr(), &end, error);
  386.   if (*error > 0 || end != res->ptr()+ res->length())
  387.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  388.                         ER_TRUNCATED_WRONG_VALUE,
  389.                         ER(ER_TRUNCATED_WRONG_VALUE), "INTEGER",
  390.                         res->c_ptr());
  391.   return value;
  392. }
  393. longlong Item_func_signed::val_int()
  394. {
  395.   longlong value;
  396.   int error;
  397.   if (args[0]->cast_to_int_type() != STRING_RESULT)
  398.   {
  399.     value= args[0]->val_int();
  400.     null_value= args[0]->null_value; 
  401.     return value;
  402.   }
  403.   value= val_int_from_str(&error);
  404.   if (value < 0 && error == 0)
  405.   {
  406.     push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
  407.                  "Cast to signed converted positive out-of-range integer to "
  408.                  "it's negative complement");
  409.   }
  410.   return value;
  411. }
  412. void Item_func_unsigned::print(String *str)
  413. {
  414.   str->append("cast(", 5);
  415.   args[0]->print(str);
  416.   str->append(" as unsigned)", 13);
  417. }
  418. longlong Item_func_unsigned::val_int()
  419. {
  420.   longlong value;
  421.   int error;
  422.   if (args[0]->cast_to_int_type() != STRING_RESULT)
  423.   {
  424.     value= args[0]->val_int();
  425.     null_value= args[0]->null_value; 
  426.     return value;
  427.   }
  428.   value= val_int_from_str(&error);
  429.   if (error < 0)
  430.     push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
  431.                  "Cast to unsigned converted negative integer to it's "
  432.                  "positive complement");
  433.   return value;
  434. }
  435. double Item_func_plus::val()
  436. {
  437.   DBUG_ASSERT(fixed == 1);
  438.   double value=args[0]->val()+args[1]->val();
  439.   if ((null_value=args[0]->null_value || args[1]->null_value))
  440.     return 0.0;
  441.   return value;
  442. }
  443. longlong Item_func_plus::val_int()
  444. {
  445.   DBUG_ASSERT(fixed == 1);
  446.   if (hybrid_type == INT_RESULT)
  447.   {
  448.     longlong value=args[0]->val_int()+args[1]->val_int();
  449.     if ((null_value=args[0]->null_value || args[1]->null_value))
  450.       return 0;
  451.     return value;
  452.   }
  453.   return (longlong) Item_func_plus::val();
  454. }
  455. /*
  456.   The following function is here to allow the user to force
  457.   subtraction of UNSIGNED BIGINT to return negative values.
  458. */
  459. void Item_func_minus::fix_length_and_dec()
  460. {
  461.   Item_num_op::fix_length_and_dec();
  462.   if (unsigned_flag &&
  463.       (current_thd->variables.sql_mode & MODE_NO_UNSIGNED_SUBTRACTION))
  464.     unsigned_flag=0;
  465. }
  466. double Item_func_minus::val()
  467. {
  468.   DBUG_ASSERT(fixed == 1);
  469.   double value=args[0]->val() - args[1]->val();
  470.   if ((null_value=args[0]->null_value || args[1]->null_value))
  471.     return 0.0;
  472.   return value;
  473. }
  474. longlong Item_func_minus::val_int()
  475. {
  476.   DBUG_ASSERT(fixed == 1);
  477.   if (hybrid_type == INT_RESULT)
  478.   {
  479.     longlong value=args[0]->val_int() - args[1]->val_int();
  480.     if ((null_value=args[0]->null_value || args[1]->null_value))
  481.       return 0;
  482.     return value;
  483.   }
  484.   return (longlong) Item_func_minus::val();
  485. }
  486. double Item_func_mul::val()
  487. {
  488.   DBUG_ASSERT(fixed == 1);
  489.   double value=args[0]->val()*args[1]->val();
  490.   if ((null_value=args[0]->null_value || args[1]->null_value))
  491.     return 0.0; /* purecov: inspected */
  492.   return value;
  493. }
  494. longlong Item_func_mul::val_int()
  495. {
  496.   DBUG_ASSERT(fixed == 1);
  497.   if (hybrid_type == INT_RESULT)
  498.   {
  499.     longlong value=args[0]->val_int()*args[1]->val_int();
  500.     if ((null_value=args[0]->null_value || args[1]->null_value))
  501.       return 0; /* purecov: inspected */
  502.     return value;
  503.   }
  504.   return (longlong) Item_func_mul::val();
  505. }
  506. double Item_func_div::val()
  507. {
  508.   DBUG_ASSERT(fixed == 1);
  509.   double value=args[0]->val();
  510.   double val2=args[1]->val();
  511.   if ((null_value= val2 == 0.0 || args[0]->null_value || args[1]->null_value))
  512.     return 0.0;
  513.   return value/val2;
  514. }
  515. longlong Item_func_div::val_int()
  516. {
  517.   DBUG_ASSERT(fixed == 1);
  518.   if (hybrid_type == INT_RESULT)
  519.   {
  520.     longlong value=args[0]->val_int();
  521.     longlong val2=args[1]->val_int();
  522.     if ((null_value= val2 == 0 || args[0]->null_value || args[1]->null_value))
  523.       return 0;
  524.     return value/val2;
  525.   }
  526.   return (longlong) Item_func_div::val();
  527. }
  528. void Item_func_div::fix_length_and_dec()
  529. {
  530.   decimals=max(args[0]->decimals,args[1]->decimals)+2;
  531.   set_if_smaller(decimals, NOT_FIXED_DEC);
  532.   max_length=args[0]->max_length - args[0]->decimals + decimals;
  533.   uint tmp=float_length(decimals);
  534.   set_if_smaller(max_length,tmp);
  535.   maybe_null=1;
  536. }
  537. /* Integer division */
  538. longlong Item_func_int_div::val_int()
  539. {
  540.   DBUG_ASSERT(fixed == 1);
  541.   longlong value=args[0]->val_int();
  542.   longlong val2=args[1]->val_int();
  543.   if ((null_value= val2 == 0 || args[0]->null_value || args[1]->null_value))
  544.     return 0;
  545.   return (unsigned_flag ?
  546.   (ulonglong) value / (ulonglong) val2 :
  547.   value / val2);
  548. }
  549. void Item_func_int_div::fix_length_and_dec()
  550. {
  551.   find_num_type();
  552.   max_length=args[0]->max_length - args[0]->decimals;
  553.   maybe_null=1;
  554. }
  555. double Item_func_mod::val()
  556. {
  557.   DBUG_ASSERT(fixed == 1);
  558.   double x= args[0]->val();
  559.   double y= args[1]->val();
  560.   if ((null_value= (y == 0.0) || args[0]->null_value || args[1]->null_value))
  561.     return 0.0; /* purecov: inspected */
  562.   return fmod(x, y);
  563. }
  564. longlong Item_func_mod::val_int()
  565. {
  566.   DBUG_ASSERT(fixed == 1);
  567.   longlong value=  args[0]->val_int();
  568.   longlong val2= args[1]->val_int();
  569.   if ((null_value=val2 == 0 || args[0]->null_value || args[1]->null_value))
  570.     return 0; /* purecov: inspected */
  571.   return value % val2;
  572. }
  573. void Item_func_mod::fix_length_and_dec()
  574. {
  575.   Item_num_op::fix_length_and_dec();
  576. }
  577. double Item_func_neg::val()
  578. {
  579.   DBUG_ASSERT(fixed == 1);
  580.   double value=args[0]->val();
  581.   null_value=args[0]->null_value;
  582.   return -value;
  583. }
  584. longlong Item_func_neg::val_int()
  585. {
  586.   DBUG_ASSERT(fixed == 1);
  587.   longlong value=args[0]->val_int();
  588.   null_value=args[0]->null_value;
  589.   return -value;
  590. }
  591. void Item_func_neg::fix_length_and_dec()
  592. {
  593.   enum Item_result arg_result= args[0]->result_type();
  594.   enum Item::Type  arg_type= args[0]->type();
  595.   decimals=args[0]->decimals;
  596.   max_length=args[0]->max_length;
  597.   hybrid_type= REAL_RESULT;
  598.   
  599.   /*
  600.     We need to account for added '-' in the following cases:
  601.     A) argument is a real or integer positive constant - in this case 
  602.     argument's max_length is set to actual number of bytes occupied, and not 
  603.     maximum number of bytes real or integer may require. Note that all 
  604.     constants are non negative so we don't need to account for removed '-'.
  605.     B) argument returns a string.
  606.     Use val() to get value as arg_type doesn't mean that item is
  607.     Item_int or Item_real due to existence of Item_param.
  608.   */
  609.   if (arg_result == STRING_RESULT || 
  610.       (arg_type == REAL_ITEM && args[0]->val() >= 0) ||
  611.       (arg_type == INT_ITEM && args[0]->val_int() > 0))
  612.     max_length++;
  613.   if (args[0]->result_type() == INT_RESULT)
  614.   {
  615.     /*
  616.       If this is in integer context keep the context as integer
  617.       (This is how multiplication and other integer functions works)
  618.       We must however do a special case in the case where the argument
  619.       is a unsigned bigint constant as in this case the only safe
  620.       number to convert in integer context is 9223372036854775808.
  621.       (This is needed because the lex parser doesn't anymore handle
  622.       signed integers)
  623.     */
  624.     if (args[0]->type() != INT_ITEM ||
  625. (((ulonglong) args[0]->val_int()) <= (ulonglong) LONGLONG_MIN))
  626.       hybrid_type= INT_RESULT;
  627.   }
  628. }
  629. double Item_func_abs::val()
  630. {
  631.   DBUG_ASSERT(fixed == 1);
  632.   double value=args[0]->val();
  633.   null_value=args[0]->null_value;
  634.   return fabs(value);
  635. }
  636. longlong Item_func_abs::val_int()
  637. {
  638.   DBUG_ASSERT(fixed == 1);
  639.   longlong value=args[0]->val_int();
  640.   null_value=args[0]->null_value;
  641.   return value >= 0 ? value : -value;
  642. }
  643. void Item_func_abs::fix_length_and_dec()
  644. {
  645.   decimals=args[0]->decimals;
  646.   max_length=args[0]->max_length;
  647.   hybrid_type= REAL_RESULT;
  648.   if (args[0]->result_type() == INT_RESULT)
  649.     hybrid_type= INT_RESULT;
  650. }
  651. /* Gateway to natural LOG function */
  652. double Item_func_ln::val()
  653. {
  654.   DBUG_ASSERT(fixed == 1);
  655.   double value=args[0]->val();
  656.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  657.     return 0.0;
  658.   return log(value);
  659. }
  660. /* 
  661.  Extended but so slower LOG function
  662.  We have to check if all values are > zero and first one is not one
  663.  as these are the cases then result is not a number.
  664. */ 
  665. double Item_func_log::val()
  666. {
  667.   DBUG_ASSERT(fixed == 1);
  668.   double value=args[0]->val();
  669.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  670.     return 0.0;
  671.   if (arg_count == 2)
  672.   {
  673.     double value2= args[1]->val();
  674.     if ((null_value=(args[1]->null_value || value2 <= 0.0 || value == 1.0)))
  675.       return 0.0;
  676.     return log(value2) / log(value);
  677.   }
  678.   return log(value);
  679. }
  680. double Item_func_log2::val()
  681. {
  682.   DBUG_ASSERT(fixed == 1);
  683.   double value=args[0]->val();
  684.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  685.     return 0.0;
  686.   return log(value) / log(2.0);
  687. }
  688. double Item_func_log10::val()
  689. {
  690.   DBUG_ASSERT(fixed == 1);
  691.   double value=args[0]->val();
  692.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  693.     return 0.0; /* purecov: inspected */
  694.   return log10(value);
  695. }
  696. double Item_func_exp::val()
  697. {
  698.   DBUG_ASSERT(fixed == 1);
  699.   double value=args[0]->val();
  700.   if ((null_value=args[0]->null_value))
  701.     return 0.0; /* purecov: inspected */
  702.   return exp(value);
  703. }
  704. double Item_func_sqrt::val()
  705. {
  706.   DBUG_ASSERT(fixed == 1);
  707.   double value=args[0]->val();
  708.   if ((null_value=(args[0]->null_value || value < 0)))
  709.     return 0.0; /* purecov: inspected */
  710.   return sqrt(value);
  711. }
  712. double Item_func_pow::val()
  713. {
  714.   DBUG_ASSERT(fixed == 1);
  715.   double value=args[0]->val();
  716.   double val2=args[1]->val();
  717.   if ((null_value=(args[0]->null_value || args[1]->null_value)))
  718.     return 0.0; /* purecov: inspected */
  719.   return pow(value,val2);
  720. }
  721. // Trigonometric functions
  722. double Item_func_acos::val()
  723. {
  724.   DBUG_ASSERT(fixed == 1);
  725.   // the volatile's for BUG #2338 to calm optimizer down (because of gcc's bug)
  726.   volatile double value=args[0]->val();
  727.   if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
  728.     return 0.0;
  729.   return fix_result(acos(value));
  730. }
  731. double Item_func_asin::val()
  732. {
  733.   DBUG_ASSERT(fixed == 1);
  734.   // the volatile's for BUG #2338 to calm optimizer down (because of gcc's bug)
  735.   volatile double value=args[0]->val();
  736.   if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
  737.     return 0.0;
  738.   return fix_result(asin(value));
  739. }
  740. double Item_func_atan::val()
  741. {
  742.   DBUG_ASSERT(fixed == 1);
  743.   double value=args[0]->val();
  744.   if ((null_value=args[0]->null_value))
  745.     return 0.0;
  746.   if (arg_count == 2)
  747.   {
  748.     double val2= args[1]->val();
  749.     if ((null_value=args[1]->null_value))
  750.       return 0.0;
  751.     return fix_result(atan2(value,val2));
  752.   }
  753.   return fix_result(atan(value));
  754. }
  755. double Item_func_cos::val()
  756. {
  757.   DBUG_ASSERT(fixed == 1);
  758.   double value=args[0]->val();
  759.   if ((null_value=args[0]->null_value))
  760.     return 0.0;
  761.   return fix_result(cos(value));
  762. }
  763. double Item_func_sin::val()
  764. {
  765.   DBUG_ASSERT(fixed == 1);
  766.   double value=args[0]->val();
  767.   if ((null_value=args[0]->null_value))
  768.     return 0.0;
  769.   return fix_result(sin(value));
  770. }
  771. double Item_func_tan::val()
  772. {
  773.   DBUG_ASSERT(fixed == 1);
  774.   double value=args[0]->val();
  775.   if ((null_value=args[0]->null_value))
  776.     return 0.0;
  777.   return fix_result(tan(value));
  778. }
  779. // Shift-functions, same as << and >> in C/C++
  780. longlong Item_func_shift_left::val_int()
  781. {
  782.   DBUG_ASSERT(fixed == 1);
  783.   uint shift;
  784.   ulonglong res= ((ulonglong) args[0]->val_int() <<
  785.   (shift=(uint) args[1]->val_int()));
  786.   if (args[0]->null_value || args[1]->null_value)
  787.   {
  788.     null_value=1;
  789.     return 0;
  790.   }
  791.   null_value=0;
  792.   return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
  793. }
  794. longlong Item_func_shift_right::val_int()
  795. {
  796.   DBUG_ASSERT(fixed == 1);
  797.   uint shift;
  798.   ulonglong res= (ulonglong) args[0]->val_int() >>
  799.     (shift=(uint) args[1]->val_int());
  800.   if (args[0]->null_value || args[1]->null_value)
  801.   {
  802.     null_value=1;
  803.     return 0;
  804.   }
  805.   null_value=0;
  806.   return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
  807. }
  808. longlong Item_func_bit_neg::val_int()
  809. {
  810.   DBUG_ASSERT(fixed == 1);
  811.   ulonglong res= (ulonglong) args[0]->val_int();
  812.   if ((null_value=args[0]->null_value))
  813.     return 0;
  814.   return ~res;
  815. }
  816. // Conversion functions
  817. void Item_func_integer::fix_length_and_dec()
  818. {
  819.   max_length=args[0]->max_length - args[0]->decimals+1;
  820.   uint tmp=float_length(decimals);
  821.   set_if_smaller(max_length,tmp);
  822.   decimals=0;
  823. }
  824. longlong Item_func_ceiling::val_int()
  825. {
  826.   DBUG_ASSERT(fixed == 1);
  827.   double value=args[0]->val();
  828.   null_value=args[0]->null_value;
  829.   return (longlong) ceil(value);
  830. }
  831. longlong Item_func_floor::val_int()
  832. {
  833.   DBUG_ASSERT(fixed == 1);
  834.   // the volatile's for BUG #3051 to calm optimizer down (because of gcc's bug)
  835.   volatile double value=args[0]->val();
  836.   null_value=args[0]->null_value;
  837.   return (longlong) floor(value);
  838. }
  839. void Item_func_round::fix_length_and_dec()
  840. {
  841.   max_length=args[0]->max_length;
  842.   decimals=args[0]->decimals;
  843.   if (args[1]->const_item())
  844.   {
  845.     int tmp=(int) args[1]->val_int();
  846.     if (tmp < 0)
  847.       decimals=0;
  848.     else
  849.       decimals=min(tmp,NOT_FIXED_DEC);
  850.     if ((tmp= decimals - args[0]->decimals) > 0)
  851.       max_length+= tmp;
  852.   }
  853. }
  854. double Item_func_round::val()
  855. {
  856.   DBUG_ASSERT(fixed == 1);
  857.   double value=args[0]->val();
  858.   int dec=(int) args[1]->val_int();
  859.   uint abs_dec=abs(dec);
  860.   double tmp;
  861.   /*
  862.     tmp2 is here to avoid return the value with 80 bit precision
  863.     This will fix that the test round(0.1,1) = round(0.1,1) is true
  864.   */
  865.   volatile double tmp2;
  866.   if ((null_value=args[0]->null_value || args[1]->null_value))
  867.     return 0.0;
  868.   tmp=(abs_dec < array_elements(log_10) ?
  869.        log_10[abs_dec] : pow(10.0,(double) abs_dec));
  870.   if (truncate)
  871.   {
  872.     if (value >= 0)
  873.       tmp2= dec < 0 ? floor(value/tmp)*tmp : floor(value*tmp)/tmp;
  874.     else
  875.       tmp2= dec < 0 ? ceil(value/tmp)*tmp : ceil(value*tmp)/tmp;
  876.   }
  877.   else
  878.     tmp2=dec < 0 ? rint(value/tmp)*tmp : rint(value*tmp)/tmp;
  879.   return tmp2;
  880. }
  881. bool Item_func_rand::fix_fields(THD *thd, struct st_table_list *tables,
  882.                                 Item **ref)
  883. {
  884.   if (Item_real_func::fix_fields(thd, tables, ref))
  885.     return TRUE;
  886.   used_tables_cache|= RAND_TABLE_BIT;
  887.   if (arg_count)
  888.   { // Only use argument once in query
  889.     if (!args[0]->const_during_execution())
  890.     {
  891.       my_error(ER_WRONG_ARGUMENTS, MYF(0), "RAND");
  892.       return TRUE;
  893.     }
  894.     /*
  895.       Allocate rand structure once: we must use thd->current_arena
  896.       to create rand in proper mem_root if it's a prepared statement or
  897.       stored procedure.
  898.     */
  899.     if (!rand && !(rand= (struct rand_struct*)
  900.                    thd->current_arena->alloc(sizeof(*rand))))
  901.       return TRUE;
  902.     /*
  903.       PARAM_ITEM is returned if we're in statement prepare and consequently
  904.       no placeholder value is set yet.
  905.     */
  906.     if (args[0]->type() != PARAM_ITEM)
  907.     {
  908.       /*
  909.         TODO: do not do reinit 'rand' for every execute of PS/SP if
  910.         args[0] is a constant.
  911.       */
  912.       uint32 tmp= (uint32) args[0]->val_int();
  913.       randominit(rand, (uint32) (tmp*0x10001L+55555555L),
  914.                  (uint32) (tmp*0x10000001L));
  915.     }
  916.   }
  917.   else
  918.   {
  919.     /*
  920.       No need to send a Rand log event if seed was given eg: RAND(seed),
  921.       as it will be replicated in the query as such.
  922.       Save the seed only the first time RAND() is used in the query
  923.       Once events are forwarded rather than recreated,
  924.       the following can be skipped if inside the slave thread
  925.     */
  926.     thd->rand_used=1;
  927.     thd->rand_saved_seed1=thd->rand.seed1;
  928.     thd->rand_saved_seed2=thd->rand.seed2;
  929.     rand= &thd->rand;
  930.   }
  931.   return FALSE;
  932. }
  933. void Item_func_rand::update_used_tables()
  934. {
  935.   Item_real_func::update_used_tables();
  936.   used_tables_cache|= RAND_TABLE_BIT;
  937. }
  938. double Item_func_rand::val()
  939. {
  940.   DBUG_ASSERT(fixed == 1);
  941.   return my_rnd(rand);
  942. }
  943. longlong Item_func_sign::val_int()
  944. {
  945.   DBUG_ASSERT(fixed == 1);
  946.   double value=args[0]->val();
  947.   null_value=args[0]->null_value;
  948.   return value < 0.0 ? -1 : (value > 0 ? 1 : 0);
  949. }
  950. double Item_func_units::val()
  951. {
  952.   DBUG_ASSERT(fixed == 1);
  953.   double value=args[0]->val();
  954.   if ((null_value=args[0]->null_value))
  955.     return 0;
  956.   return value*mul+add;
  957. }
  958. void Item_func_min_max::fix_length_and_dec()
  959. {
  960.   decimals=0;
  961.   max_length=0;
  962.   maybe_null=1;
  963.   cmp_type=args[0]->result_type();
  964.   for (uint i=0 ; i < arg_count ; i++)
  965.   {
  966.     if (max_length < args[i]->max_length)
  967.       max_length=args[i]->max_length;
  968.     if (decimals < args[i]->decimals)
  969.       decimals=args[i]->decimals;
  970.     if (!args[i]->maybe_null)
  971.       maybe_null=0;
  972.     cmp_type=item_cmp_type(cmp_type,args[i]->result_type());
  973.   }
  974.   if (cmp_type == STRING_RESULT)
  975.     agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV);
  976. }
  977. String *Item_func_min_max::val_str(String *str)
  978. {
  979.   DBUG_ASSERT(fixed == 1);
  980.   switch (cmp_type) {
  981.   case INT_RESULT:
  982.   {
  983.     longlong nr=val_int();
  984.     if (null_value)
  985.       return 0;
  986.     if (!unsigned_flag)
  987.       str->set(nr,&my_charset_bin);
  988.     else
  989.       str->set((ulonglong) nr,&my_charset_bin);
  990.     return str;
  991.   }
  992.   case REAL_RESULT:
  993.   {
  994.     double nr=val();
  995.     if (null_value)
  996.       return 0; /* purecov: inspected */
  997.     str->set(nr,decimals,&my_charset_bin);
  998.     return str;
  999.   }
  1000.   case STRING_RESULT:
  1001.   {
  1002.     String *res;
  1003.     LINT_INIT(res);
  1004.     null_value=1;
  1005.     for (uint i=0; i < arg_count ; i++)
  1006.     {
  1007.       if (null_value)
  1008.       {
  1009. res=args[i]->val_str(str);
  1010. null_value=args[i]->null_value;
  1011.       }
  1012.       else
  1013.       {
  1014. String *res2;
  1015. res2= args[i]->val_str(res == str ? &tmp_value : str);
  1016. if (res2)
  1017. {
  1018.   int cmp= sortcmp(res,res2,collation.collation);
  1019.   if ((cmp_sign < 0 ? cmp : -cmp) < 0)
  1020.     res=res2;
  1021. }
  1022.       }
  1023.     }
  1024.     if (res) // If !NULL
  1025.       res->set_charset(collation.collation);
  1026.     return res;
  1027.   }
  1028.   case ROW_RESULT:
  1029.   default:
  1030.     // This case should never be choosen
  1031.     DBUG_ASSERT(0);
  1032.     return 0;
  1033.   }
  1034.   return 0; // Keep compiler happy
  1035. }
  1036. double Item_func_min_max::val()
  1037. {
  1038.   DBUG_ASSERT(fixed == 1);
  1039.   double value=0.0;
  1040.   null_value=1;
  1041.   for (uint i=0; i < arg_count ; i++)
  1042.   {
  1043.     if (null_value)
  1044.     {
  1045.       value=args[i]->val();
  1046.       null_value=args[i]->null_value;
  1047.     }
  1048.     else
  1049.     {
  1050.       double tmp=args[i]->val();
  1051.       if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
  1052. value=tmp;
  1053.     }
  1054.   }
  1055.   return value;
  1056. }
  1057. longlong Item_func_min_max::val_int()
  1058. {
  1059.   DBUG_ASSERT(fixed == 1);
  1060.   longlong value=0;
  1061.   null_value=1;
  1062.   for (uint i=0; i < arg_count ; i++)
  1063.   {
  1064.     if (null_value)
  1065.     {
  1066.       value=args[i]->val_int();
  1067.       null_value=args[i]->null_value;
  1068.     }
  1069.     else
  1070.     {
  1071.       longlong tmp=args[i]->val_int();
  1072.       if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
  1073. value=tmp;
  1074.     }
  1075.   }
  1076.   return value;
  1077. }
  1078. longlong Item_func_length::val_int()
  1079. {
  1080.   DBUG_ASSERT(fixed == 1);
  1081.   String *res=args[0]->val_str(&value);
  1082.   if (!res)
  1083.   {
  1084.     null_value=1;
  1085.     return 0; /* purecov: inspected */
  1086.   }
  1087.   null_value=0;
  1088.   return (longlong) res->length();
  1089. }
  1090. longlong Item_func_char_length::val_int()
  1091. {
  1092.   DBUG_ASSERT(fixed == 1);
  1093.   String *res=args[0]->val_str(&value);
  1094.   if (!res)
  1095.   {
  1096.     null_value=1;
  1097.     return 0; /* purecov: inspected */
  1098.   }
  1099.   null_value=0;
  1100.   return (longlong) res->numchars();
  1101. }
  1102. longlong Item_func_coercibility::val_int()
  1103. {
  1104.   DBUG_ASSERT(fixed == 1);
  1105.   null_value= 0;
  1106.   return (longlong) args[0]->collation.derivation;
  1107. }
  1108. void Item_func_locate::fix_length_and_dec()
  1109. {
  1110.   maybe_null=0; max_length=11;
  1111.   agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV);
  1112. }
  1113. longlong Item_func_locate::val_int()
  1114. {
  1115.   DBUG_ASSERT(fixed == 1);
  1116.   String *a=args[0]->val_str(&value1);
  1117.   String *b=args[1]->val_str(&value2);
  1118.   if (!a || !b)
  1119.   {
  1120.     null_value=1;
  1121.     return 0; /* purecov: inspected */
  1122.   }
  1123.   null_value=0;
  1124.   uint start=0;
  1125.   uint start0=0;
  1126.   my_match_t match;
  1127.   if (arg_count == 3)
  1128.   {
  1129.     start0= start =(uint) args[2]->val_int()-1;
  1130.     start=a->charpos(start);
  1131.     
  1132.     if (start > a->length() || start+b->length() > a->length())
  1133.       return 0;
  1134.   }
  1135.   if (!b->length()) // Found empty string at start
  1136.     return (longlong) (start+1);
  1137.   
  1138.   if (!cmp_collation.collation->coll->instr(cmp_collation.collation,
  1139.                                             a->ptr()+start, a->length()-start,
  1140.                                             b->ptr(), b->length(),
  1141.                                             &match, 1))
  1142.     return 0;
  1143.   return (longlong) match.mblen + start0 + 1;
  1144. }
  1145. void Item_func_locate::print(String *str)
  1146. {
  1147.   str->append("locate(", 7);
  1148.   args[1]->print(str);
  1149.   str->append(',');
  1150.   args[0]->print(str);
  1151.   if (arg_count == 3)
  1152.   {
  1153.     str->append(',');
  1154.     args[2]->print(str);
  1155.   }
  1156.   str->append(')');
  1157. }
  1158. longlong Item_func_field::val_int()
  1159. {
  1160.   DBUG_ASSERT(fixed == 1);
  1161.   if (cmp_type == STRING_RESULT)
  1162.   {
  1163.     String *field;
  1164.     if (!(field=args[0]->val_str(&value)))
  1165.       return 0; // -1 if null ?
  1166.     for (uint i=1 ; i < arg_count ; i++)
  1167.     {
  1168.       String *tmp_value=args[i]->val_str(&tmp);
  1169.       if (tmp_value && !sortcmp(field,tmp_value,cmp_collation.collation))
  1170.         return (longlong) (i);
  1171.     }
  1172.   }
  1173.   else if (cmp_type == INT_RESULT)
  1174.   {
  1175.     longlong val= args[0]->val_int();
  1176.     if (args[0]->null_value)
  1177.       return 0;
  1178.     for (uint i=1; i < arg_count ; i++)
  1179.     {
  1180.       if (val == args[i]->val_int() && !args[i]->null_value)
  1181.         return (longlong) (i);
  1182.     }
  1183.   }
  1184.   else
  1185.   {
  1186.     double val= args[0]->val();
  1187.     if (args[0]->null_value)
  1188.       return 0;
  1189.     for (uint i=1; i < arg_count ; i++)
  1190.     {
  1191.       if (val == args[i]->val() && !args[i]->null_value)
  1192.         return (longlong) (i);
  1193.     }
  1194.   }
  1195.   return 0;
  1196. }
  1197. void Item_func_field::fix_length_and_dec()
  1198. {
  1199.   maybe_null=0; max_length=3;
  1200.   cmp_type= args[0]->result_type();
  1201.   for (uint i=1; i < arg_count ; i++)
  1202.     cmp_type= item_cmp_type(cmp_type, args[i]->result_type());
  1203.   if (cmp_type == STRING_RESULT)
  1204.     agg_arg_charsets(cmp_collation, args, arg_count, MY_COLL_CMP_CONV);
  1205. }
  1206. longlong Item_func_ascii::val_int()
  1207. {
  1208.   DBUG_ASSERT(fixed == 1);
  1209.   String *res=args[0]->val_str(&value);
  1210.   if (!res)
  1211.   {
  1212.     null_value=1;
  1213.     return 0;
  1214.   }
  1215.   null_value=0;
  1216.   return (longlong) (res->length() ? (uchar) (*res)[0] : (uchar) 0);
  1217. }
  1218. longlong Item_func_ord::val_int()
  1219. {
  1220.   DBUG_ASSERT(fixed == 1);
  1221.   String *res=args[0]->val_str(&value);
  1222.   if (!res)
  1223.   {
  1224.     null_value=1;
  1225.     return 0;
  1226.   }
  1227.   null_value=0;
  1228.   if (!res->length()) return 0;
  1229. #ifdef USE_MB
  1230.   if (use_mb(res->charset()))
  1231.   {
  1232.     register const char *str=res->ptr();
  1233.     register uint32 n=0, l=my_ismbchar(res->charset(),str,str+res->length());
  1234.     if (!l)
  1235.       return (longlong)((uchar) *str);
  1236.     while (l--)
  1237.       n=(n<<8)|(uint32)((uchar) *str++);
  1238.     return (longlong) n;
  1239.   }
  1240. #endif
  1241.   return (longlong) ((uchar) (*res)[0]);
  1242. }
  1243. /* Search after a string in a string of strings separated by ',' */
  1244. /* Returns number of found type >= 1 or 0 if not found */
  1245. /* This optimizes searching in enums to bit testing! */
  1246. void Item_func_find_in_set::fix_length_and_dec()
  1247. {
  1248.   decimals=0;
  1249.   max_length=3; // 1-999
  1250.   if (args[0]->const_item() && args[1]->type() == FIELD_ITEM)
  1251.   {
  1252.     Field *field= ((Item_field*) args[1])->field;
  1253.     if (field->real_type() == FIELD_TYPE_SET)
  1254.     {
  1255.       String *find=args[0]->val_str(&value);
  1256.       if (find)
  1257.       {
  1258. enum_value= find_type(((Field_enum*) field)->typelib,find->ptr(),
  1259.       find->length(), 0);
  1260. enum_bit=0;
  1261. if (enum_value)
  1262.   enum_bit=LL(1) << (enum_value-1);
  1263.       }
  1264.     }
  1265.   }
  1266.   agg_arg_charsets(cmp_collation, args, 2, MY_COLL_CMP_CONV);
  1267. }
  1268. static const char separator=',';
  1269. longlong Item_func_find_in_set::val_int()
  1270. {
  1271.   DBUG_ASSERT(fixed == 1);
  1272.   if (enum_value)
  1273.   {
  1274.     ulonglong tmp=(ulonglong) args[1]->val_int();
  1275.     if (!(null_value=args[1]->null_value || args[0]->null_value))
  1276.     {
  1277.       if (tmp & enum_bit)
  1278. return enum_value;
  1279.     }
  1280.     return 0L;
  1281.   }
  1282.   String *find=args[0]->val_str(&value);
  1283.   String *buffer=args[1]->val_str(&value2);
  1284.   if (!find || !buffer)
  1285.   {
  1286.     null_value=1;
  1287.     return 0; /* purecov: inspected */
  1288.   }
  1289.   null_value=0;
  1290.   int diff;
  1291.   if ((diff=buffer->length() - find->length()) >= 0)
  1292.   {
  1293.     my_wc_t wc;
  1294.     CHARSET_INFO *cs= cmp_collation.collation;
  1295.     const char *str_begin= buffer->ptr();
  1296.     const char *str_end= buffer->ptr();
  1297.     const char *real_end= str_end+buffer->length();
  1298.     const uchar *find_str= (const uchar *) find->ptr();
  1299.     uint find_str_len= find->length();
  1300.     int position= 0;
  1301.     while (1)
  1302.     {
  1303.       int symbol_len;
  1304.       if ((symbol_len= cs->cset->mb_wc(cs, &wc, (uchar*) str_end, 
  1305.                                        (uchar*) real_end)) > 0)
  1306.       {
  1307.         const char *substr_end= str_end + symbol_len;
  1308.         bool is_last_item= (substr_end == real_end);
  1309.         bool is_separator= (wc == (my_wc_t) separator);
  1310.         if (is_separator || is_last_item)
  1311.         {
  1312.           position++;
  1313.           if (is_last_item && !is_separator)
  1314.             str_end= substr_end;
  1315.           if (!my_strnncoll(cs, (const uchar *) str_begin,
  1316.                             str_end - str_begin,
  1317.                             find_str, find_str_len))
  1318.             return (longlong) position;
  1319.           else
  1320.             str_begin= substr_end;
  1321.         }
  1322.         str_end= substr_end;
  1323.       }
  1324.       else if (str_end - str_begin == 0 && 
  1325.                find_str_len == 0 && 
  1326.                wc == (my_wc_t) separator)
  1327.         return (longlong) ++position;
  1328.       else
  1329.         return (longlong) 0;
  1330.     }
  1331.   }
  1332.   return 0;
  1333. }
  1334. longlong Item_func_bit_count::val_int()
  1335. {
  1336.   DBUG_ASSERT(fixed == 1);
  1337.   ulonglong value= (ulonglong) args[0]->val_int();
  1338.   if (args[0]->null_value)
  1339.   {
  1340.     null_value=1; /* purecov: inspected */
  1341.     return 0; /* purecov: inspected */
  1342.   }
  1343.   return (longlong) my_count_bits(value);
  1344. }
  1345. /****************************************************************************
  1346. ** Functions to handle dynamic loadable functions
  1347. ** Original source by: Alexis Mikhailov <root@medinf.chuvashia.su>
  1348. ** Rewritten by monty.
  1349. ****************************************************************************/
  1350. #ifdef HAVE_DLOPEN
  1351. udf_handler::~udf_handler()
  1352. {
  1353.   /* Everything should be properly cleaned up by this moment. */
  1354.   DBUG_ASSERT(not_original || !(initialized || buffers));
  1355. }
  1356. void udf_handler::cleanup()
  1357. {
  1358.   if (!not_original)
  1359.   {
  1360.     if (initialized)
  1361.     {
  1362.       if (u_d->func_deinit != NULL)
  1363.       {
  1364.         void (*deinit)(UDF_INIT *) = (void (*)(UDF_INIT*))
  1365.         u_d->func_deinit;
  1366.         (*deinit)(&initid);
  1367.       }
  1368.       free_udf(u_d);
  1369.       initialized= FALSE;
  1370.     }
  1371.     if (buffers) // Because of bug in ecc
  1372.       delete [] buffers;
  1373.     buffers= 0;
  1374.   }
  1375. }
  1376. bool
  1377. udf_handler::fix_fields(THD *thd, TABLE_LIST *tables, Item_result_field *func,
  1378. uint arg_count, Item **arguments)
  1379. {
  1380. #ifndef EMBEDDED_LIBRARY // Avoid compiler warning
  1381.   char buff[STACK_BUFF_ALLOC]; // Max argument in function
  1382. #endif
  1383.   DBUG_ENTER("Item_udf_func::fix_fields");
  1384.   if (check_stack_overrun(thd, buff))
  1385.     DBUG_RETURN(1); // Fatal error flag is set!
  1386.   udf_func *tmp_udf=find_udf(u_d->name.str,(uint) u_d->name.length,1);
  1387.   if (!tmp_udf)
  1388.   {
  1389.     my_printf_error(ER_CANT_FIND_UDF,ER(ER_CANT_FIND_UDF),MYF(0),u_d->name.str,
  1390.     errno);
  1391.     DBUG_RETURN(1);
  1392.   }
  1393.   u_d=tmp_udf;
  1394.   args=arguments;
  1395.   /* Fix all arguments */
  1396.   func->maybe_null=0;
  1397.   used_tables_cache=0;
  1398.   const_item_cache=1;
  1399.   if ((f_args.arg_count=arg_count))
  1400.   {
  1401.     if (!(f_args.arg_type= (Item_result*)
  1402.   sql_alloc(f_args.arg_count*sizeof(Item_result))))
  1403.     {
  1404.       free_udf(u_d);
  1405.       DBUG_RETURN(1);
  1406.     }
  1407.     uint i;
  1408.     Item **arg,**arg_end;
  1409.     for (i=0, arg=arguments, arg_end=arguments+arg_count;
  1410.  arg != arg_end ;
  1411.  arg++,i++)
  1412.     {
  1413.       if (!(*arg)->fixed && 
  1414.           (*arg)->fix_fields(thd, tables, arg))
  1415. DBUG_RETURN(1);
  1416.       // we can't assign 'item' before, because fix_fields() can change arg
  1417.       Item *item= *arg;
  1418.       if (item->check_cols(1))
  1419. DBUG_RETURN(1);
  1420.       /*
  1421. TODO: We should think about this. It is not always
  1422. right way just to set an UDF result to return my_charset_bin
  1423. if one argument has binary sorting order.
  1424. The result collation should be calculated according to arguments
  1425. derivations in some cases and should not in other cases.
  1426. Moreover, some arguments can represent a numeric input
  1427. which doesn't effect the result character set and collation.
  1428. There is no a general rule for UDF. Everything depends on
  1429. the particular user definted function.
  1430.       */
  1431.       if (item->collation.collation->state & MY_CS_BINSORT)
  1432. func->collation.set(&my_charset_bin);
  1433.       if (item->maybe_null)
  1434. func->maybe_null=1;
  1435.       func->with_sum_func= func->with_sum_func || item->with_sum_func;
  1436.       used_tables_cache|=item->used_tables();
  1437.       const_item_cache&=item->const_item();
  1438.       f_args.arg_type[i]=item->result_type();
  1439.     }
  1440.     if (!(buffers=new String[arg_count]) ||
  1441. !(f_args.args= (char**) sql_alloc(arg_count * sizeof(char *))) ||
  1442. !(f_args.lengths=(ulong*) sql_alloc(arg_count * sizeof(long))) ||
  1443. !(f_args.maybe_null=(char*) sql_alloc(arg_count * sizeof(char))) ||
  1444. !(num_buffer= (char*) sql_alloc(ALIGN_SIZE(sizeof(double))*arg_count)))
  1445.     {
  1446.       free_udf(u_d);
  1447.       DBUG_RETURN(1);
  1448.     }
  1449.   }
  1450.   func->fix_length_and_dec();
  1451.   initid.max_length=func->max_length;
  1452.   initid.maybe_null=func->maybe_null;
  1453.   initid.const_item=const_item_cache;
  1454.   initid.decimals=func->decimals;
  1455.   initid.ptr=0;
  1456.   if (u_d->func_init)
  1457.   {
  1458.     char *to=num_buffer;
  1459.     for (uint i=0; i < arg_count; i++)
  1460.     {
  1461.       f_args.args[i]=0;
  1462.       f_args.lengths[i]=arguments[i]->max_length;
  1463.       f_args.maybe_null[i]=(char) arguments[i]->maybe_null;
  1464.       switch(arguments[i]->type()) {
  1465.       case Item::STRING_ITEM: // Constant string !
  1466.       {
  1467. String *res=arguments[i]->val_str((String *) 0);
  1468. if (arguments[i]->null_value)
  1469.   continue;
  1470. f_args.args[i]=    (char*) res->ptr();
  1471. break;
  1472.       }
  1473.       case Item::INT_ITEM:
  1474. *((longlong*) to) = arguments[i]->val_int();
  1475. if (!arguments[i]->null_value)
  1476. {
  1477.   f_args.args[i]=to;
  1478.   to+= ALIGN_SIZE(sizeof(longlong));
  1479. }
  1480. break;
  1481.       case Item::REAL_ITEM:
  1482. *((double*) to) = arguments[i]->val();
  1483. if (!arguments[i]->null_value)
  1484. {
  1485.   f_args.args[i]=to;
  1486.   to+= ALIGN_SIZE(sizeof(double));
  1487. }
  1488. break;
  1489.       default: // Skip these
  1490. break;
  1491.       }
  1492.     }
  1493.     thd->net.last_error[0]=0;
  1494.     my_bool (*init)(UDF_INIT *, UDF_ARGS *, char *)=
  1495.       (my_bool (*)(UDF_INIT *, UDF_ARGS *,  char *))
  1496.       u_d->func_init;
  1497.     if ((error=(uchar) init(&initid, &f_args, thd->net.last_error)))
  1498.     {
  1499.       my_printf_error(ER_CANT_INITIALIZE_UDF,ER(ER_CANT_INITIALIZE_UDF),MYF(0),
  1500.       u_d->name.str, thd->net.last_error);
  1501.       free_udf(u_d);
  1502.       DBUG_RETURN(1);
  1503.     }
  1504.     func->max_length=min(initid.max_length,MAX_BLOB_WIDTH);
  1505.     func->maybe_null=initid.maybe_null;
  1506.     const_item_cache=initid.const_item;
  1507.     func->decimals=min(initid.decimals,NOT_FIXED_DEC);
  1508.   }
  1509.   initialized=1;
  1510.   if (error)
  1511.   {
  1512.     my_printf_error(ER_CANT_INITIALIZE_UDF,ER(ER_CANT_INITIALIZE_UDF),MYF(0),
  1513.     u_d->name.str, ER(ER_UNKNOWN_ERROR));
  1514.     DBUG_RETURN(1);
  1515.   }
  1516.   DBUG_RETURN(0);
  1517. }
  1518. bool udf_handler::get_arguments()
  1519. {
  1520.   if (error)
  1521.     return 1; // Got an error earlier
  1522.   char *to= num_buffer;
  1523.   uint str_count=0;
  1524.   for (uint i=0; i < f_args.arg_count; i++)
  1525.   {
  1526.     f_args.args[i]=0;
  1527.     switch (f_args.arg_type[i]) {
  1528.     case STRING_RESULT:
  1529.       {
  1530. String *res=args[i]->val_str(&buffers[str_count++]);
  1531. if (!(args[i]->null_value))
  1532. {
  1533.   f_args.args[i]=    (char*) res->ptr();
  1534.   f_args.lengths[i]= res->length();
  1535.   break;
  1536. }
  1537.       }
  1538.     case INT_RESULT:
  1539.       *((longlong*) to) = args[i]->val_int();
  1540.       if (!args[i]->null_value)
  1541.       {
  1542. f_args.args[i]=to;
  1543. to+= ALIGN_SIZE(sizeof(longlong));
  1544.       }
  1545.       break;
  1546.     case REAL_RESULT:
  1547.       *((double*) to) = args[i]->val();
  1548.       if (!args[i]->null_value)
  1549.       {
  1550. f_args.args[i]=to;
  1551. to+= ALIGN_SIZE(sizeof(double));
  1552.       }
  1553.       break;
  1554.     case ROW_RESULT:
  1555.     default:
  1556.       // This case should never be choosen
  1557.       DBUG_ASSERT(0);
  1558.       break;
  1559.     }
  1560.   }
  1561.   return 0;
  1562. }
  1563. /* This returns (String*) 0 in case of NULL values */
  1564. String *udf_handler::val_str(String *str,String *save_str)
  1565. {
  1566.   uchar is_null_tmp=0;
  1567.   ulong res_length;
  1568.   if (get_arguments())
  1569.     return 0;
  1570.   char * (*func)(UDF_INIT *, UDF_ARGS *, char *, ulong *, uchar *, uchar *)=
  1571.     (char* (*)(UDF_INIT *, UDF_ARGS *, char *, ulong *, uchar *, uchar *))
  1572.     u_d->func;
  1573.   if ((res_length=str->alloced_length()) < MAX_FIELD_WIDTH)
  1574.   { // This happens VERY seldom
  1575.     if (str->alloc(MAX_FIELD_WIDTH))
  1576.     {
  1577.       error=1;
  1578.       return 0;
  1579.     }
  1580.   }
  1581.   char *res=func(&initid, &f_args, (char*) str->ptr(), &res_length,
  1582.  &is_null_tmp, &error);
  1583.   if (is_null_tmp || !res || error) // The !res is for safety
  1584.   {
  1585.     return 0;
  1586.   }
  1587.   if (res == str->ptr())
  1588.   {
  1589.     str->length(res_length);
  1590.     return str;
  1591.   }
  1592.   save_str->set(res, res_length, str->charset());
  1593.   return save_str;
  1594. }
  1595. void Item_udf_func::cleanup()
  1596. {
  1597.   udf.cleanup();
  1598.   Item_func::cleanup();
  1599. }
  1600. double Item_func_udf_float::val()
  1601. {
  1602.   DBUG_ASSERT(fixed == 1);
  1603.   DBUG_ENTER("Item_func_udf_float::val");
  1604.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1605.      args[0]->result_type(), arg_count));
  1606.   DBUG_RETURN(udf.val(&null_value));
  1607. }
  1608. String *Item_func_udf_float::val_str(String *str)
  1609. {
  1610.   DBUG_ASSERT(fixed == 1);
  1611.   double nr=val();
  1612.   if (null_value)
  1613.     return 0; /* purecov: inspected */
  1614.   str->set(nr,decimals,&my_charset_bin);
  1615.   return str;
  1616. }
  1617. longlong Item_func_udf_int::val_int()
  1618. {
  1619.   DBUG_ASSERT(fixed == 1);
  1620.   DBUG_ENTER("Item_func_udf_int::val_int");
  1621.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1622.      args[0]->result_type(), arg_count));
  1623.   DBUG_RETURN(udf.val_int(&null_value));
  1624. }
  1625. String *Item_func_udf_int::val_str(String *str)
  1626. {
  1627.   DBUG_ASSERT(fixed == 1);
  1628.   longlong nr=val_int();
  1629.   if (null_value)
  1630.     return 0;
  1631.   if (!unsigned_flag)
  1632.     str->set(nr,&my_charset_bin);
  1633.   else
  1634.     str->set((ulonglong) nr,&my_charset_bin);
  1635.   return str;
  1636. }
  1637. /* Default max_length is max argument length */
  1638. void Item_func_udf_str::fix_length_and_dec()
  1639. {
  1640.   DBUG_ENTER("Item_func_udf_str::fix_length_and_dec");
  1641.   max_length=0;
  1642.   for (uint i = 0; i < arg_count; i++)
  1643.     set_if_bigger(max_length,args[i]->max_length);
  1644.   DBUG_VOID_RETURN;
  1645. }
  1646. String *Item_func_udf_str::val_str(String *str)
  1647. {
  1648.   DBUG_ASSERT(fixed == 1);
  1649.   String *res=udf.val_str(str,&str_value);
  1650.   null_value = !res;
  1651.   return res;
  1652. }
  1653. #else
  1654. bool udf_handler::get_arguments() { return 0; }
  1655. #endif /* HAVE_DLOPEN */
  1656. /*
  1657. ** User level locks
  1658. */
  1659. pthread_mutex_t LOCK_user_locks;
  1660. static HASH hash_user_locks;
  1661. class User_level_lock
  1662. {
  1663.   char *key;
  1664.   uint key_length;
  1665. public:
  1666.   int count;
  1667.   bool locked;
  1668.   pthread_cond_t cond;
  1669.   pthread_t thread;
  1670.   ulong thread_id;
  1671.   User_level_lock(const char *key_arg,uint length, ulong id) 
  1672.     :key_length(length),count(1),locked(1), thread_id(id)
  1673.   {
  1674.     key=(char*) my_memdup((byte*) key_arg,length,MYF(0));
  1675.     pthread_cond_init(&cond,NULL);
  1676.     if (key)
  1677.     {
  1678.       if (my_hash_insert(&hash_user_locks,(byte*) this))
  1679.       {
  1680. my_free((gptr) key,MYF(0));
  1681. key=0;
  1682.       }
  1683.     }
  1684.   }
  1685.   ~User_level_lock()
  1686.   {
  1687.     if (key)
  1688.     {
  1689.       hash_delete(&hash_user_locks,(byte*) this);
  1690.       my_free((gptr) key,MYF(0));
  1691.     }
  1692.     pthread_cond_destroy(&cond);
  1693.   }
  1694.   inline bool initialized() { return key != 0; }
  1695.   friend void item_user_lock_release(User_level_lock *ull);
  1696.   friend char *ull_get_key(const User_level_lock *ull, uint *length,
  1697.                            my_bool not_used);
  1698. };
  1699. char *ull_get_key(const User_level_lock *ull, uint *length,
  1700.   my_bool not_used __attribute__((unused)))
  1701. {
  1702.   *length=(uint) ull->key_length;
  1703.   return (char*) ull->key;
  1704. }
  1705. static bool item_user_lock_inited= 0;
  1706. void item_user_lock_init(void)
  1707. {
  1708.   pthread_mutex_init(&LOCK_user_locks,MY_MUTEX_INIT_SLOW);
  1709.   hash_init(&hash_user_locks,system_charset_info,
  1710.     16,0,0,(hash_get_key) ull_get_key,NULL,0);
  1711.   item_user_lock_inited= 1;
  1712. }
  1713. void item_user_lock_free(void)
  1714. {
  1715.   if (item_user_lock_inited)
  1716.   {
  1717.     item_user_lock_inited= 0;
  1718.     hash_free(&hash_user_locks);
  1719.     pthread_mutex_destroy(&LOCK_user_locks);
  1720.   }
  1721. }
  1722. void item_user_lock_release(User_level_lock *ull)
  1723. {
  1724.   ull->locked=0;
  1725.   if (mysql_bin_log.is_open())
  1726.   {
  1727.     char buf[256];
  1728.     const char *command="DO RELEASE_LOCK("";
  1729.     String tmp(buf,sizeof(buf), system_charset_info);
  1730.     tmp.copy(command, strlen(command), tmp.charset());
  1731.     tmp.append(ull->key,ull->key_length);
  1732.     tmp.append("")", 2);
  1733.     Query_log_event qev(current_thd, tmp.ptr(), tmp.length(),0, FALSE);
  1734.     qev.error_code=0; // this query is always safe to run on slave
  1735.     mysql_bin_log.write(&qev);
  1736.   }
  1737.   if (--ull->count)
  1738.     pthread_cond_signal(&ull->cond);
  1739.   else
  1740.     delete ull;
  1741. }
  1742. /*
  1743.    Wait until we are at or past the given position in the master binlog
  1744.    on the slave
  1745.  */
  1746. longlong Item_master_pos_wait::val_int()
  1747. {
  1748.   DBUG_ASSERT(fixed == 1);
  1749.   THD* thd = current_thd;
  1750.   String *log_name = args[0]->val_str(&value);
  1751.   int event_count= 0;
  1752.   null_value=0;
  1753.   if (thd->slave_thread || !log_name || !log_name->length())
  1754.   {
  1755.     null_value = 1;
  1756.     return 0;
  1757.   }
  1758.   longlong pos = (ulong)args[1]->val_int();
  1759.   longlong timeout = (arg_count==3) ? args[2]->val_int() : 0 ;
  1760. #ifdef HAVE_REPLICATION
  1761.   if ((event_count = active_mi->rli.wait_for_pos(thd, log_name, pos, timeout)) == -2)
  1762.   {
  1763.     null_value = 1;
  1764.     event_count=0;
  1765.   }
  1766. #endif
  1767.   return event_count;
  1768. }
  1769. #ifdef EXTRA_DEBUG
  1770. void debug_sync_point(const char* lock_name, uint lock_timeout)
  1771. {
  1772.   THD* thd=current_thd;
  1773.   User_level_lock* ull;
  1774.   struct timespec abstime;
  1775.   int lock_name_len,error=0;
  1776.   lock_name_len=strlen(lock_name);
  1777.   pthread_mutex_lock(&LOCK_user_locks);
  1778.   if (thd->ull)
  1779.   {
  1780.     item_user_lock_release(thd->ull);
  1781.     thd->ull=0;
  1782.   }
  1783.   /*
  1784.     If the lock has not been aquired by some client, we do not want to
  1785.     create an entry for it, since we immediately release the lock. In
  1786.     this case, we will not be waiting, but rather, just waste CPU and
  1787.     memory on the whole deal
  1788.   */
  1789.   if (!(ull= ((User_level_lock*) hash_search(&hash_user_locks, lock_name,
  1790.  lock_name_len))))
  1791.   {
  1792.     pthread_mutex_unlock(&LOCK_user_locks);
  1793.     return;
  1794.   }
  1795.   ull->count++;
  1796.   /*
  1797.     Structure is now initialized.  Try to get the lock.
  1798.     Set up control struct to allow others to abort locks
  1799.   */
  1800.   thd->proc_info="User lock";
  1801.   thd->mysys_var->current_mutex= &LOCK_user_locks;
  1802.   thd->mysys_var->current_cond=  &ull->cond;
  1803.   set_timespec(abstime,lock_timeout);
  1804.   while (!thd->killed &&
  1805.  (error=pthread_cond_timedwait(&ull->cond,&LOCK_user_locks,&abstime))
  1806.  != ETIME && error != ETIMEDOUT && ull->locked) ;
  1807.   if (ull->locked)
  1808.   {
  1809.     if (!--ull->count)
  1810.       delete ull; // Should never happen
  1811.   }
  1812.   else
  1813.   {
  1814.     ull->locked=1;
  1815.     ull->thread=thd->real_id;
  1816.     thd->ull=ull;
  1817.   }
  1818.   pthread_mutex_unlock(&LOCK_user_locks);
  1819.   pthread_mutex_lock(&thd->mysys_var->mutex);
  1820.   thd->proc_info=0;
  1821.   thd->mysys_var->current_mutex= 0;
  1822.   thd->mysys_var->current_cond=  0;
  1823.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  1824.   pthread_mutex_lock(&LOCK_user_locks);
  1825.   if (thd->ull)
  1826.   {
  1827.     item_user_lock_release(thd->ull);
  1828.     thd->ull=0;
  1829.   }
  1830.   pthread_mutex_unlock(&LOCK_user_locks);
  1831. }
  1832. #endif
  1833. /*
  1834.   Get a user level lock. If the thread has an old lock this is first released.
  1835.   Returns 1:  Got lock
  1836.   Returns 0:  Timeout
  1837.   Returns NULL: Error
  1838. */
  1839. longlong Item_func_get_lock::val_int()
  1840. {
  1841.   DBUG_ASSERT(fixed == 1);
  1842.   String *res=args[0]->val_str(&value);
  1843.   longlong timeout=args[1]->val_int();
  1844.   struct timespec abstime;
  1845.   THD *thd=current_thd;
  1846.   User_level_lock *ull;
  1847.   int error=0;
  1848.   pthread_mutex_lock(&LOCK_user_locks);
  1849.   if (!res || !res->length())
  1850.   {
  1851.     pthread_mutex_unlock(&LOCK_user_locks);
  1852.     null_value=1;
  1853.     return 0;
  1854.   }
  1855.   null_value=0;
  1856.   if (thd->ull)
  1857.   {
  1858.     item_user_lock_release(thd->ull);
  1859.     thd->ull=0;
  1860.   }
  1861.   if (!(ull= ((User_level_lock *) hash_search(&hash_user_locks,
  1862.                                               (byte*) res->ptr(),
  1863.                                               res->length()))))
  1864.   {
  1865.     ull=new User_level_lock(res->ptr(),res->length(), thd->thread_id);
  1866.     if (!ull || !ull->initialized())
  1867.     {
  1868.       delete ull;
  1869.       pthread_mutex_unlock(&LOCK_user_locks);
  1870.       null_value=1; // Probably out of memory
  1871.       return 0;
  1872.     }
  1873.     ull->thread=thd->real_id;
  1874.     thd->ull=ull;
  1875.     pthread_mutex_unlock(&LOCK_user_locks);
  1876.     return 1; // Got new lock
  1877.   }
  1878.   ull->count++;
  1879.   /*
  1880.     Structure is now initialized.  Try to get the lock.
  1881.     Set up control struct to allow others to abort locks.
  1882.   */
  1883.   thd->proc_info="User lock";
  1884.   thd->mysys_var->current_mutex= &LOCK_user_locks;
  1885.   thd->mysys_var->current_cond=  &ull->cond;
  1886.   set_timespec(abstime,timeout);
  1887.   while (!thd->killed &&
  1888.  (error=pthread_cond_timedwait(&ull->cond,&LOCK_user_locks,&abstime))
  1889.  != ETIME && error != ETIMEDOUT && error != EINVAL && ull->locked) ;
  1890.   if (thd->killed)
  1891.     error=EINTR; // Return NULL
  1892.   if (ull->locked)
  1893.   {
  1894.     if (!--ull->count)
  1895.       delete ull; // Should never happen
  1896.     if (error != ETIME && error != ETIMEDOUT)
  1897.     {
  1898.       error=1;
  1899.       null_value=1; // Return NULL
  1900.     }
  1901.   }
  1902.   else
  1903.   {
  1904.     ull->locked=1;
  1905.     ull->thread=thd->real_id;
  1906.     thd->ull=ull;
  1907.     error=0;
  1908.   }
  1909.   pthread_mutex_unlock(&LOCK_user_locks);
  1910.   pthread_mutex_lock(&thd->mysys_var->mutex);
  1911.   thd->proc_info=0;
  1912.   thd->mysys_var->current_mutex= 0;
  1913.   thd->mysys_var->current_cond=  0;
  1914.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  1915.   return !error ? 1 : 0;
  1916. }
  1917. /*
  1918.   Release a user level lock.
  1919.   Return:
  1920.     1 if lock released
  1921.     0 if lock wasn't held
  1922.     (SQL) NULL if no such lock
  1923. */
  1924. longlong Item_func_release_lock::val_int()
  1925. {
  1926.   DBUG_ASSERT(fixed == 1);
  1927.   String *res=args[0]->val_str(&value);
  1928.   User_level_lock *ull;
  1929.   longlong result;
  1930.   if (!res || !res->length())
  1931.   {
  1932.     null_value=1;
  1933.     return 0;
  1934.   }
  1935.   null_value=0;
  1936.   result=0;
  1937.   pthread_mutex_lock(&LOCK_user_locks);
  1938.   if (!(ull= ((User_level_lock*) hash_search(&hash_user_locks,
  1939.                                              (const byte*) res->ptr(),
  1940.                                              res->length()))))
  1941.   {
  1942.     null_value=1;
  1943.   }
  1944.   else
  1945.   {
  1946.     if (ull->locked && pthread_equal(pthread_self(),ull->thread))
  1947.     {
  1948.       result=1; // Release is ok
  1949.       item_user_lock_release(ull);
  1950.       current_thd->ull=0;
  1951.     }
  1952.   }
  1953.   pthread_mutex_unlock(&LOCK_user_locks);
  1954.   return result;
  1955. }
  1956. longlong Item_func_last_insert_id::val_int()
  1957. {
  1958.   DBUG_ASSERT(fixed == 1);
  1959.   if (arg_count)
  1960.   {
  1961.     longlong value=args[0]->val_int();
  1962.     current_thd->insert_id(value);
  1963.     null_value=args[0]->null_value;
  1964.   }
  1965.   else
  1966.     current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
  1967.   return current_thd->insert_id();
  1968. }
  1969. /* This function is just used to test speed of different functions */
  1970. longlong Item_func_benchmark::val_int()
  1971. {
  1972.   DBUG_ASSERT(fixed == 1);
  1973.   char buff[MAX_FIELD_WIDTH];
  1974.   String tmp(buff,sizeof(buff), &my_charset_bin);
  1975.   THD *thd=current_thd;
  1976.   for (ulong loop=0 ; loop < loop_count && !thd->killed; loop++)
  1977.   {
  1978.     switch (args[0]->result_type()) {
  1979.     case REAL_RESULT:
  1980.       (void) args[0]->val();
  1981.       break;
  1982.     case INT_RESULT:
  1983.       (void) args[0]->val_int();
  1984.       break;
  1985.     case STRING_RESULT:
  1986.       (void) args[0]->val_str(&tmp);
  1987.       break;
  1988.     case ROW_RESULT:
  1989.     default:
  1990.       // This case should never be choosen
  1991.       DBUG_ASSERT(0);
  1992.       return 0;
  1993.     }
  1994.   }
  1995.   return 0;
  1996. }
  1997. void Item_func_benchmark::print(String *str)
  1998. {
  1999.   str->append("benchmark(", 10);
  2000.   char buffer[20];
  2001.   // my_charset_bin is good enough for numbers
  2002.   String st(buffer, sizeof(buffer), &my_charset_bin);
  2003.   st.set((ulonglong)loop_count, &my_charset_bin);
  2004.   str->append(st);
  2005.   str->append(',');
  2006.   args[0]->print(str);
  2007.   str->append(')');
  2008. }
  2009. #define extra_size sizeof(double)
  2010. static user_var_entry *get_variable(HASH *hash, LEX_STRING &name,
  2011.     bool create_if_not_exists)
  2012. {
  2013.   user_var_entry *entry;
  2014.   if (!(entry = (user_var_entry*) hash_search(hash, (byte*) name.str,
  2015.       name.length)) &&
  2016.       create_if_not_exists)
  2017.   {
  2018.     uint size=ALIGN_SIZE(sizeof(user_var_entry))+name.length+1+extra_size;
  2019.     if (!hash_inited(hash))
  2020.       return 0;
  2021.     if (!(entry = (user_var_entry*) my_malloc(size,MYF(MY_WME))))
  2022.       return 0;
  2023.     entry->name.str=(char*) entry+ ALIGN_SIZE(sizeof(user_var_entry))+
  2024.       extra_size;
  2025.     entry->name.length=name.length;
  2026.     entry->value=0;
  2027.     entry->length=0;
  2028.     entry->update_query_id=0;
  2029.     entry->collation.set(NULL, DERIVATION_IMPLICIT);
  2030.     /*
  2031.       If we are here, we were called from a SET or a query which sets a
  2032.       variable. Imagine it is this:
  2033.       INSERT INTO t SELECT @a:=10, @a:=@a+1.
  2034.       Then when we have a Item_func_get_user_var (because of the @a+1) so we
  2035.       think we have to write the value of @a to the binlog. But before that,
  2036.       we have a Item_func_set_user_var to create @a (@a:=10), in this we mark
  2037.       the variable as "already logged" (line below) so that it won't be logged
  2038.       by Item_func_get_user_var (because that's not necessary).
  2039.     */
  2040.     entry->used_query_id=current_thd->query_id;
  2041.     entry->type=STRING_RESULT;
  2042.     memcpy(entry->name.str, name.str, name.length+1);
  2043.     if (my_hash_insert(hash,(byte*) entry))
  2044.     {
  2045.       my_free((char*) entry,MYF(0));
  2046.       return 0;
  2047.     }
  2048.   }
  2049.   return entry;
  2050. }
  2051. /*
  2052.   When a user variable is updated (in a SET command or a query like
  2053.   SELECT @a:= ).
  2054. */
  2055. bool Item_func_set_user_var::fix_fields(THD *thd, TABLE_LIST *tables,
  2056. Item **ref)
  2057. {
  2058.   DBUG_ASSERT(fixed == 0);
  2059.   /* fix_fields will call Item_func_set_user_var::fix_length_and_dec */
  2060.   if (Item_func::fix_fields(thd, tables, ref) ||
  2061.       !(entry= get_variable(&thd->user_vars, name, 1)))
  2062.     return 1;
  2063.   /* 
  2064.      Remember the last query which updated it, this way a query can later know
  2065.      if this variable is a constant item in the query (it is if update_query_id
  2066.      is different from query_id).
  2067.   */
  2068.   entry->update_query_id= thd->query_id;
  2069.   /*
  2070.     As it is wrong and confusing to associate any 
  2071.     character set with NULL, @a should be latin2
  2072.     after this query sequence:
  2073.       SET @a=_latin2'string';
  2074.       SET @a=NULL;
  2075.     I.e. the second query should not change the charset
  2076.     to the current default value, but should keep the 
  2077.     original value assigned during the first query.
  2078.     In order to do it, we don't copy charset
  2079.     from the argument if the argument is NULL
  2080.     and the variable has previously been initialized.
  2081.   */
  2082.   if (!entry->collation.collation || !args[0]->null_value)
  2083.     entry->collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
  2084.   collation.set(entry->collation.collation, DERIVATION_IMPLICIT);
  2085.   cached_result_type= args[0]->result_type();
  2086.   return 0;
  2087. }
  2088. void
  2089. Item_func_set_user_var::fix_length_and_dec()
  2090. {
  2091.   maybe_null=args[0]->maybe_null;
  2092.   max_length=args[0]->max_length;
  2093.   decimals=args[0]->decimals;
  2094.   collation.set(args[0]->collation.collation, DERIVATION_IMPLICIT);
  2095. }
  2096. bool Item_func_set_user_var::update_hash(void *ptr, uint length,
  2097.  Item_result type,
  2098.  CHARSET_INFO *cs,
  2099.  Derivation dv)
  2100. {
  2101.   if ((null_value=args[0]->null_value))
  2102.   {
  2103.     char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  2104.     if (entry->value && entry->value != pos)
  2105.       my_free(entry->value,MYF(0));
  2106.     entry->value=0;
  2107.     entry->length=0;
  2108.   }
  2109.   else
  2110.   {
  2111.     if (type == STRING_RESULT)
  2112.       length++; // Store strings with end 
  2113.     if (length <= extra_size)
  2114.     {
  2115.       /* Save value in value struct */
  2116.       char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  2117.       if (entry->value != pos)
  2118.       {
  2119. if (entry->value)
  2120.   my_free(entry->value,MYF(0));
  2121. entry->value=pos;
  2122.       }
  2123.     }
  2124.     else
  2125.     {
  2126.       /* Allocate variable */
  2127.       if (entry->length != length)
  2128.       {
  2129. char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  2130. if (entry->value == pos)
  2131.   entry->value=0;
  2132. if (!(entry->value=(char*) my_realloc(entry->value, length,
  2133.       MYF(MY_ALLOW_ZERO_PTR))))
  2134.   goto err;
  2135.       }
  2136.     }
  2137.     if (type == STRING_RESULT)
  2138.     {
  2139.       length--; // Fix length change above
  2140.       entry->value[length]= 0; // Store end 
  2141.     }
  2142.     memcpy(entry->value,ptr,length);
  2143.     entry->length= length;
  2144.     entry->type=type;
  2145.     entry->collation.set(cs, dv);
  2146.   }
  2147.   return 0;
  2148.  err:
  2149.   current_thd->fatal_error(); // Probably end of memory
  2150.   null_value= 1;
  2151.   return 1;
  2152. }
  2153. /* Get the value of a variable as a double */
  2154. double user_var_entry::val(my_bool *null_value)
  2155. {
  2156.   if ((*null_value= (value == 0)))
  2157.     return 0.0;
  2158.   switch (type) {
  2159.   case REAL_RESULT:
  2160.     return *(double*) value;
  2161.   case INT_RESULT:
  2162.     return (double) *(longlong*) value;
  2163.   case STRING_RESULT:
  2164.     return my_atof(value);                      // This is null terminated
  2165.   case ROW_RESULT:
  2166.     DBUG_ASSERT(1); // Impossible
  2167.     break;
  2168.   }
  2169.   return 0.0; // Impossible
  2170. }
  2171. /* Get the value of a variable as an integer */
  2172. longlong user_var_entry::val_int(my_bool *null_value)
  2173. {
  2174.   if ((*null_value= (value == 0)))
  2175.     return LL(0);
  2176.   switch (type) {
  2177.   case REAL_RESULT:
  2178.     return (longlong) *(double*) value;
  2179.   case INT_RESULT:
  2180.     return *(longlong*) value;
  2181.   case STRING_RESULT:
  2182.   {
  2183.     int error;
  2184.     return my_strtoll10(value, (char**) 0, &error);// String is null terminated
  2185.   }
  2186.   case ROW_RESULT:
  2187.     DBUG_ASSERT(1); // Impossible
  2188.     break;
  2189.   }
  2190.   return LL(0); // Impossible
  2191. }
  2192. /* Get the value of a variable as a string */
  2193. String *user_var_entry::val_str(my_bool *null_value, String *str,
  2194. uint decimals)
  2195. {
  2196.   if ((*null_value= (value == 0)))
  2197.     return (String*) 0;
  2198.   switch (type) {
  2199.   case REAL_RESULT:
  2200.     str->set(*(double*) value, decimals, &my_charset_bin);
  2201.     break;
  2202.   case INT_RESULT:
  2203.     str->set(*(longlong*) value, &my_charset_bin);
  2204.     break;
  2205.   case STRING_RESULT:
  2206.     if (str->copy(value, length, collation.collation))
  2207.       str= 0; // EOM error
  2208.   case ROW_RESULT:
  2209.     DBUG_ASSERT(1); // Impossible
  2210.     break;
  2211.   }
  2212.   return(str);
  2213. }
  2214. /*
  2215.   This functions is invoked on SET @variable or @variable:= expression.
  2216.   Evaluete (and check expression), store results.
  2217.   SYNOPSYS
  2218.     Item_func_set_user_var::check()
  2219.   NOTES
  2220.     For now it always return OK. All problem with value evalueting
  2221.     will be catched by thd->net.report_error check in sql_set_variables().
  2222.   RETURN
  2223.     0 - OK.
  2224. */
  2225. bool
  2226. Item_func_set_user_var::check()
  2227. {
  2228.   DBUG_ENTER("Item_func_set_user_var::check");
  2229.   switch (cached_result_type) {
  2230.   case REAL_RESULT:
  2231.   {
  2232.     save_result.vreal= args[0]->val();
  2233.     break;
  2234.   }
  2235.   case INT_RESULT:
  2236.   {
  2237.     save_result.vint= args[0]->val_int();
  2238.     break;
  2239.   }
  2240.   case STRING_RESULT:
  2241.   {
  2242.     save_result.vstr= args[0]->val_str(&value);
  2243.     break;
  2244.   }
  2245.   case ROW_RESULT:
  2246.   default:
  2247.     // This case should never be choosen
  2248.     DBUG_ASSERT(0);
  2249.     break;
  2250.   }
  2251.   DBUG_RETURN(0);
  2252. }
  2253. /*
  2254.   This functions is invoked on SET @variable or @variable:= expression.
  2255.   SYNOPSIS
  2256.     Item_func_set_user_var::update()
  2257.   NOTES
  2258.     We have to store the expression as such in the variable, independent of
  2259.     the value method used by the user
  2260.   RETURN
  2261.     0 Ok
  2262.     1 EOM Error
  2263. */
  2264. bool
  2265. Item_func_set_user_var::update()
  2266. {
  2267.   bool res;
  2268.   DBUG_ENTER("Item_func_set_user_var::update");
  2269.   LINT_INIT(res);
  2270.   switch (cached_result_type) {
  2271.   case REAL_RESULT:
  2272.   {
  2273.     res= update_hash((void*) &save_result.vreal,sizeof(save_result.vreal),
  2274.      REAL_RESULT, &my_charset_bin, DERIVATION_IMPLICIT);
  2275.     break;
  2276.   }
  2277.   case INT_RESULT:
  2278.   {
  2279.     res= update_hash((void*) &save_result.vint, sizeof(save_result.vint),
  2280.      INT_RESULT, &my_charset_bin, DERIVATION_IMPLICIT);
  2281.     break;
  2282.   }
  2283.   case STRING_RESULT:
  2284.   {
  2285.     if (!save_result.vstr) // Null value
  2286.       res= update_hash((void*) 0, 0, STRING_RESULT, &my_charset_bin,
  2287.        DERIVATION_IMPLICIT);
  2288.     else
  2289.       res= update_hash((void*) save_result.vstr->ptr(),
  2290.        save_result.vstr->length(), STRING_RESULT,
  2291.        save_result.vstr->charset(),
  2292.        DERIVATION_IMPLICIT);
  2293.     break;
  2294.   }
  2295.   case ROW_RESULT:
  2296.   default:
  2297.     // This case should never be choosen
  2298.     DBUG_ASSERT(0);
  2299.     break;
  2300.   }
  2301.   DBUG_RETURN(res);
  2302. }
  2303. double Item_func_set_user_var::val()
  2304. {
  2305.   DBUG_ASSERT(fixed == 1);
  2306.   check();
  2307.   update(); // Store expression
  2308.   return entry->val(&null_value);
  2309. }
  2310. longlong Item_func_set_user_var::val_int()
  2311. {
  2312.   DBUG_ASSERT(fixed == 1);
  2313.   check();
  2314.   update(); // Store expression
  2315.   return entry->val_int(&null_value);
  2316. }
  2317. String *Item_func_set_user_var::val_str(String *str)
  2318. {
  2319.   DBUG_ASSERT(fixed == 1);
  2320.   check();
  2321.   update(); // Store expression
  2322.   return entry->val_str(&null_value, str, decimals);
  2323. }
  2324. void Item_func_set_user_var::print(String *str)
  2325. {
  2326.   str->append("(@", 2);
  2327.   str->append(name.str, name.length);
  2328.   str->append(":=", 2);
  2329.   args[0]->print(str);
  2330.   str->append(')');
  2331. }
  2332. String *
  2333. Item_func_get_user_var::val_str(String *str)
  2334. {
  2335.   DBUG_ASSERT(fixed == 1);
  2336.   DBUG_ENTER("Item_func_get_user_var::val_str");
  2337.   if (!var_entry)
  2338.     DBUG_RETURN((String*) 0); // No such variable
  2339.   DBUG_RETURN(var_entry->val_str(&null_value, str, decimals));
  2340. }
  2341. double Item_func_get_user_var::val()
  2342. {
  2343.   DBUG_ASSERT(fixed == 1);
  2344.   if (!var_entry)
  2345.     return 0.0; // No such variable
  2346.   return (var_entry->val(&null_value));
  2347. }
  2348. longlong Item_func_get_user_var::val_int()
  2349. {
  2350.   DBUG_ASSERT(fixed == 1);
  2351.   if (!var_entry)
  2352.     return LL(0); // No such variable
  2353.   return (var_entry->val_int(&null_value));
  2354. }
  2355. /*
  2356.   Get variable by name and, if necessary, put the record of variable 
  2357.   use into the binary log.
  2358.   
  2359.   SYNOPSIS
  2360.     get_var_with_binlog()
  2361.       thd        Current thread
  2362.       name       Variable name 
  2363.       out_entry  [out] variable structure or NULL. The pointer is set 
  2364.                  regardless of whether function succeeded or not.
  2365.   When a user variable is invoked from an update query (INSERT, UPDATE etc),
  2366.   stores this variable and its value in thd->user_var_events, so that it can be
  2367.   written to the binlog (will be written just before the query is written, see
  2368.   log.cc).
  2369.   
  2370.   RETURN
  2371.     0  OK 
  2372.     1  Failed to put appropiate record into binary log
  2373.     
  2374. */
  2375. int get_var_with_binlog(THD *thd, LEX_STRING &name, 
  2376.                         user_var_entry **out_entry)
  2377. {
  2378.   BINLOG_USER_VAR_EVENT *user_var_event;
  2379.   user_var_entry *var_entry;
  2380.   var_entry= get_variable(&thd->user_vars, name, 0);
  2381.   
  2382.   if (!(opt_bin_log && is_update_query(thd->lex->sql_command)))
  2383.   {
  2384.     *out_entry= var_entry;
  2385.     return 0;
  2386.   }
  2387.   if (!var_entry)
  2388.   {
  2389.     /*
  2390.       If the variable does not exist, it's NULL, but we want to create it so
  2391.       that it gets into the binlog (if it didn't, the slave could be
  2392.       influenced by a variable of the same name previously set by another
  2393.       thread).
  2394.       We create it like if it had been explicitely set with SET before.
  2395.       The 'new' mimicks what sql_yacc.yy does when 'SET @a=10;'.
  2396.       sql_set_variables() is what is called from 'case SQLCOM_SET_OPTION'
  2397.       in dispatch_command()). Instead of building a one-element list to pass to
  2398.       sql_set_variables(), we could instead manually call check() and update();
  2399.       this would save memory and time; but calling sql_set_variables() makes
  2400.       one unique place to maintain (sql_set_variables()). 
  2401.     */
  2402.     List<set_var_base> tmp_var_list;
  2403.     tmp_var_list.push_back(new set_var_user(new Item_func_set_user_var(name,
  2404.                                                                        new Item_null())));
  2405.     /* Create the variable */
  2406.     if (sql_set_variables(thd, &tmp_var_list))
  2407.       goto err;
  2408.     if (!(var_entry= get_variable(&thd->user_vars, name, 0)))
  2409.       goto err;
  2410.   }
  2411.   else if (var_entry->used_query_id == thd->query_id)
  2412.   {
  2413.     /* 
  2414.        If this variable was already stored in user_var_events by this query
  2415.        (because it's used in more than one place in the query), don't store
  2416.        it.
  2417.     */
  2418.     *out_entry= var_entry;
  2419.     return 0;
  2420.   }
  2421.   uint size;
  2422.   /*
  2423.     First we need to store value of var_entry, when the next situation
  2424.     appers:
  2425.     > set @a:=1;
  2426.     > insert into t1 values (@a), (@a:=@a+1), (@a:=@a+1);
  2427.     We have to write to binlog value @a= 1;
  2428.   */
  2429.   size= ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT)) + var_entry->length;      
  2430.   if (!(user_var_event= (BINLOG_USER_VAR_EVENT *) thd->alloc(size)))
  2431.     goto err;
  2432.   
  2433.   user_var_event->value= (char*) user_var_event +
  2434.     ALIGN_SIZE(sizeof(BINLOG_USER_VAR_EVENT));
  2435.   user_var_event->user_var_event= var_entry;
  2436.   user_var_event->type= var_entry->type;
  2437.   user_var_event->charset_number= var_entry->collation.collation->number;
  2438.   if (!var_entry->value)
  2439.   {
  2440.     /* NULL value*/
  2441.     user_var_event->length= 0;
  2442.     user_var_event->value= 0;
  2443.   }
  2444.   else
  2445.   {
  2446.     user_var_event->length= var_entry->length;
  2447.     memcpy(user_var_event->value, var_entry->value,
  2448.            var_entry->length);
  2449.   }
  2450.   /* Mark that this variable has been used by this query */
  2451.   var_entry->used_query_id= thd->query_id;
  2452.   if (insert_dynamic(&thd->user_var_events, (gptr) &user_var_event))
  2453.     goto err;
  2454.   
  2455.   *out_entry= var_entry;
  2456.   return 0;
  2457. err:
  2458.   *out_entry= var_entry;
  2459.   return 1;
  2460. }
  2461. void Item_func_get_user_var::fix_length_and_dec()
  2462. {
  2463.   THD *thd=current_thd;
  2464.   int error;
  2465.   maybe_null=1;
  2466.   decimals=NOT_FIXED_DEC;
  2467.   max_length=MAX_BLOB_WIDTH;
  2468.   error= get_var_with_binlog(thd, name, &var_entry);
  2469.   if (var_entry)
  2470.   {
  2471.     collation.set(var_entry->collation);
  2472.     switch (var_entry->type) {
  2473.     case REAL_RESULT:
  2474.       max_length= DBL_DIG + 8;
  2475.     case INT_RESULT:
  2476.       max_length= MAX_BIGINT_WIDTH;
  2477.       break;
  2478.     case STRING_RESULT:
  2479.       max_length= MAX_BLOB_WIDTH;
  2480.       break;
  2481.     case ROW_RESULT:                            // Keep compiler happy
  2482.       break;
  2483.     }
  2484.   }
  2485.   else
  2486.   {
  2487.     collation.set(&my_charset_bin, DERIVATION_IMPLICIT);
  2488.     null_value= 1;
  2489.   }
  2490.   if (error)
  2491.     thd->fatal_error();
  2492.   return;
  2493. }
  2494. bool Item_func_get_user_var::const_item() const
  2495. {
  2496.   return (!var_entry || current_thd->query_id != var_entry->update_query_id);
  2497. }
  2498. enum Item_result Item_func_get_user_var::result_type() const
  2499. {
  2500.   user_var_entry *entry;
  2501.   if (!(entry = (user_var_entry*) hash_search(&current_thd->user_vars,
  2502.       (byte*) name.str,
  2503.       name.length)))
  2504.     return STRING_RESULT;
  2505.   return entry->type;
  2506. }
  2507. void Item_func_get_user_var::print(String *str)
  2508. {
  2509.   str->append("(@", 2);
  2510.   str->append(name.str,name.length);
  2511.   str->append(')');
  2512. }
  2513. bool Item_func_get_user_var::eq(const Item *item, bool binary_cmp) const
  2514. {
  2515.   /* Assume we don't have rtti */
  2516.   if (this == item)
  2517.     return 1; // Same item is same.
  2518.   /* Check if other type is also a get_user_var() object */
  2519.   if (item->type() != FUNC_ITEM ||
  2520.       ((Item_func*) item)->func_name() != func_name())
  2521.     return 0;
  2522.   Item_func_get_user_var *other=(Item_func_get_user_var*) item;
  2523.   return (name.length == other->name.length &&
  2524.   !memcmp(name.str, other->name.str, name.length));
  2525. }
  2526. Item_func_get_system_var::
  2527. Item_func_get_system_var(sys_var *var_arg, enum_var_type var_type_arg,
  2528.                        LEX_STRING *component_arg, const char *name_arg,
  2529.                        size_t name_len_arg)
  2530.   :var(var_arg), var_type(var_type_arg), component(*component_arg)
  2531. {
  2532.   /* set_name() will allocate the name */
  2533.   set_name(name_arg, name_len_arg, system_charset_info);
  2534. }
  2535. bool
  2536. Item_func_get_system_var::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref)
  2537. {
  2538.   Item *item;
  2539.   DBUG_ENTER("Item_func_get_system_var::fix_fields");
  2540.   /*
  2541.     Evaluate the system variable and substitute the result (a basic constant)
  2542.     instead of this item. If the variable can not be evaluated,
  2543.     the error is reported in sys_var::item().
  2544.   */
  2545.   if (!(item= var->item(thd, var_type, &component)))
  2546.     DBUG_RETURN(1);                             // Impossible
  2547.   item->set_name(name, 0, system_charset_info); // don't allocate a new name
  2548.   thd->change_item_tree(ref, item);
  2549.   DBUG_RETURN(0);
  2550. }
  2551. longlong Item_func_inet_aton::val_int()
  2552. {
  2553.   DBUG_ASSERT(fixed == 1);
  2554.   uint byte_result = 0;
  2555.   ulonglong result = 0; // We are ready for 64 bit addresses
  2556.   const char *p,* end;
  2557.   char c = '.'; // we mark c to indicate invalid IP in case length is 0
  2558.   char buff[36];
  2559.   int dot_count= 0;
  2560.   String *s,tmp(buff,sizeof(buff),&my_charset_bin);
  2561.   if (!(s = args[0]->val_str(&tmp))) // If null value
  2562.     goto err;
  2563.   null_value=0;
  2564.   end= (p = s->ptr()) + s->length();
  2565.   while (p < end)
  2566.   {
  2567.     c = *p++;
  2568.     int digit = (int) (c - '0'); // Assume ascii
  2569.     if (digit >= 0 && digit <= 9)
  2570.     {
  2571.       if ((byte_result = byte_result * 10 + digit) > 255)
  2572. goto err; // Wrong address
  2573.     }
  2574.     else if (c == '.')
  2575.     {
  2576.       dot_count++;
  2577.       result= (result << 8) + (ulonglong) byte_result;
  2578.       byte_result = 0;
  2579.     }
  2580.     else
  2581.       goto err; // Invalid character
  2582.   }
  2583.   if (c != '.') // IP number can't end on '.'
  2584.   {
  2585.     /*
  2586.       Handle short-forms addresses according to standard. Examples:
  2587.       127 -> 0.0.0.127
  2588.       127.1 -> 127.0.0.1
  2589.       127.2.1 -> 127.2.0.1
  2590.     */
  2591.     switch (dot_count) {
  2592.     case 1: result<<= 8; /* Fall through */
  2593.     case 2: result<<= 8; /* Fall through */
  2594.     }
  2595.     return (result << 8) + (ulonglong) byte_result;
  2596.   }
  2597. err:
  2598.   null_value=1;
  2599.   return 0;
  2600. }
  2601. void Item_func_match::init_search(bool no_order)
  2602. {
  2603.   DBUG_ENTER("Item_func_match::init_search");
  2604.   /* Check if init_search() has been called before */
  2605.   if (ft_handler)
  2606.     DBUG_VOID_RETURN;
  2607.   if (key == NO_SUCH_KEY)
  2608.   {
  2609.     List<Item> fields;
  2610.     fields.push_back(new Item_string(" ",1, cmp_collation.collation));
  2611.     for (uint i=1; i < arg_count; i++)
  2612.       fields.push_back(args[i]);
  2613.     concat=new Item_func_concat_ws(fields);
  2614.     /*
  2615.       Above function used only to get value and do not need fix_fields for it:
  2616.       Item_string - basic constant
  2617.       fields - fix_fields() was already called for this arguments
  2618.       Item_func_concat_ws - do not need fix_fields() to produce value
  2619.     */
  2620.     concat->quick_fix_field();
  2621.   }
  2622.   if (master)
  2623.   {
  2624.     join_key=master->join_key=join_key|master->join_key;
  2625.     master->init_search(no_order);
  2626.     ft_handler=master->ft_handler;
  2627.     join_key=master->join_key;
  2628.     DBUG_VOID_RETURN;
  2629.   }
  2630.   String *ft_tmp= 0;
  2631.   // MATCH ... AGAINST (NULL) is meaningless, but possible
  2632.   if (!(ft_tmp=key_item()->val_str(&value)))
  2633.   {
  2634.     ft_tmp= &value;
  2635.     value.set("",0,cmp_collation.collation);
  2636.   }
  2637.   if (ft_tmp->charset() != cmp_collation.collation)
  2638.   {
  2639.     uint dummy_errors;
  2640.     search_value.copy(ft_tmp->ptr(), ft_tmp->length(), ft_tmp->charset(),
  2641.                       cmp_collation.collation, &dummy_errors);
  2642.     ft_tmp= &search_value;
  2643.   }
  2644.   if (join_key && !no_order)
  2645.     flags|=FT_SORTED;
  2646.   ft_handler=table->file->ft_init_ext(flags, key, ft_tmp);
  2647.   if (join_key)
  2648.     table->file->ft_handler=ft_handler;
  2649.   DBUG_VOID_RETURN;
  2650. }
  2651. bool Item_func_match::fix_fields(THD *thd, TABLE_LIST *tlist, Item **ref)
  2652. {
  2653.   DBUG_ASSERT(fixed == 0);
  2654.   Item *item;
  2655.   LINT_INIT(item); // Safe as arg_count is > 1
  2656.   maybe_null=1;
  2657.   join_key=0;
  2658.   /*
  2659.     const_item is assumed in quite a bit of places, so it would be difficult
  2660.     to remove;  If it would ever to be removed, this should include
  2661.     modifications to find_best and auto_close as complement to auto_init code
  2662.     above.
  2663.    */
  2664.   if (Item_func::fix_fields(thd, tlist, ref) ||
  2665.       !args[0]->const_during_execution())
  2666.   {
  2667.     my_error(ER_WRONG_ARGUMENTS,MYF(0),"AGAINST");
  2668.     return 1;
  2669.   }
  2670.   const_item_cache=0;
  2671.   for (uint i=1 ; i < arg_count ; i++)
  2672.   {
  2673.     item=args[i];
  2674.     if (item->type() == Item::REF_ITEM)
  2675.       args[i]= item= *((Item_ref *)item)->ref;
  2676.     if (item->type() != Item::FIELD_ITEM)
  2677.       key=NO_SUCH_KEY;
  2678.   }
  2679.   /*
  2680.     Check that all columns come from the same table.
  2681.     We've already checked that columns in MATCH are fields so
  2682.     PARAM_TABLE_BIT can only appear from AGAINST argument.
  2683.   */
  2684.   if ((used_tables_cache & ~PARAM_TABLE_BIT) != item->used_tables())
  2685.     key=NO_SUCH_KEY;
  2686.   if (key == NO_SUCH_KEY && !(flags & FT_BOOL))
  2687.   {
  2688.     my_error(ER_WRONG_ARGUMENTS,MYF(0),"MATCH");
  2689.     return 1;
  2690.   }
  2691.   table=((Item_field *)item)->field->table;
  2692.   if (!(table->file->table_flags() & HA_CAN_FULLTEXT))
  2693.   {
  2694.     my_error(ER_TABLE_CANT_HANDLE_FT, MYF(0));
  2695.     return 1;
  2696.   }
  2697.   table->fulltext_searched=1;
  2698.   return agg_arg_collations_for_comparison(cmp_collation, args+1, arg_count-1);
  2699. }
  2700. bool Item_func_match::fix_index()
  2701. {
  2702.   Item_field *item;
  2703.   uint ft_to_key[MAX_KEY], ft_cnt[MAX_KEY], fts=0, keynr;
  2704.   uint max_cnt=0, mkeys=0, i;
  2705.   if (key == NO_SUCH_KEY)
  2706.     return 0;
  2707.   
  2708.   if (!table) 
  2709.     goto err;
  2710.   for (keynr=0 ; keynr < table->keys ; keynr++)
  2711.   {
  2712.     if ((table->key_info[keynr].flags & HA_FULLTEXT) &&
  2713.         (table->keys_in_use_for_query.is_set(keynr)))
  2714.     {
  2715.       ft_to_key[fts]=keynr;
  2716.       ft_cnt[fts]=0;
  2717.       fts++;
  2718.     }
  2719.   }
  2720.   if (!fts)
  2721.     goto err;
  2722.   for (i=1; i < arg_count; i++)
  2723.   {
  2724.     item=(Item_field*)args[i];
  2725.     for (keynr=0 ; keynr < fts ; keynr++)
  2726.     {
  2727.       KEY *ft_key=&table->key_info[ft_to_key[keynr]];
  2728.       uint key_parts=ft_key->key_parts;
  2729.       for (uint part=0 ; part < key_parts ; part++)
  2730.       {
  2731. if (item->field->eq(ft_key->key_part[part].field))
  2732.   ft_cnt[keynr]++;
  2733.       }
  2734.     }
  2735.   }
  2736.   for (keynr=0 ; keynr < fts ; keynr++)
  2737.   {
  2738.     if (ft_cnt[keynr] > max_cnt)
  2739.     {
  2740.       mkeys=0;
  2741.       max_cnt=ft_cnt[mkeys]=ft_cnt[keynr];
  2742.       ft_to_key[mkeys]=ft_to_key[keynr];
  2743.       continue;
  2744.     }
  2745.     if (max_cnt && ft_cnt[keynr] == max_cnt)
  2746.     {
  2747.       mkeys++;
  2748.       ft_cnt[mkeys]=ft_cnt[keynr];
  2749.       ft_to_key[mkeys]=ft_to_key[keynr];
  2750.       continue;
  2751.     }
  2752.   }
  2753.   for (keynr=0 ; keynr <= mkeys ; keynr++)
  2754.   {
  2755.     // partial keys doesn't work
  2756.     if (max_cnt < arg_count-1 ||
  2757.         max_cnt < table->key_info[ft_to_key[keynr]].key_parts)
  2758.       continue;
  2759.     key=ft_to_key[keynr];
  2760.     return 0;
  2761.   }
  2762. err:
  2763.   if (flags & FT_BOOL)
  2764.   {
  2765.     key=NO_SUCH_KEY;
  2766.     return 0;
  2767.   }
  2768.   my_error(ER_FT_MATCHING_KEY_NOT_FOUND,MYF(0));
  2769.   return 1;
  2770. }
  2771. bool Item_func_match::eq(const Item *item, bool binary_cmp) const
  2772. {
  2773.   if (item->type() != FUNC_ITEM || ((Item_func*)item)->functype() != FT_FUNC ||
  2774.       flags != ((Item_func_match*)item)->flags)
  2775.     return 0;
  2776.   Item_func_match *ifm=(Item_func_match*) item;
  2777.   if (key == ifm->key && table == ifm->table &&
  2778.       key_item()->eq(ifm->key_item(), binary_cmp))
  2779.     return 1;
  2780.   return 0;
  2781. }
  2782. double Item_func_match::val()
  2783. {
  2784.   DBUG_ASSERT(fixed == 1);
  2785.   DBUG_ENTER("Item_func_match::val");
  2786.   if (ft_handler == NULL)
  2787.     DBUG_RETURN(-1.0);
  2788.   if (table->null_row) /* NULL row from an outer join */
  2789.     return 0.0;
  2790.   if (join_key)
  2791.   {
  2792.     if (table->file->ft_handler)
  2793.       DBUG_RETURN(ft_handler->please->get_relevance(ft_handler));
  2794.     join_key=0;
  2795.   }
  2796.   if (key == NO_SUCH_KEY)
  2797.   {
  2798.     String *a= concat->val_str(&value);
  2799.     if ((null_value= (a == 0)))
  2800.       DBUG_RETURN(0);
  2801.     DBUG_RETURN(ft_handler->please->find_relevance(ft_handler,
  2802.       (byte *)a->ptr(), a->length()));
  2803.   }
  2804.   else
  2805.     DBUG_RETURN(ft_handler->please->find_relevance(ft_handler,
  2806.                                                    table->record[0], 0));
  2807. }
  2808. void Item_func_match::print(String *str)
  2809. {
  2810.   str->append("(match ", 7);
  2811.   print_args(str, 1);
  2812.   str->append(" against (", 10);
  2813.   args[0]->print(str);
  2814.   if (flags & FT_BOOL)
  2815.     str->append(" in boolean mode", 16);
  2816.   else if (flags & FT_EXPAND)
  2817.     str->append(" with query expansion", 21);
  2818.   str->append("))", 2);
  2819. }
  2820. longlong Item_func_bit_xor::val_int()
  2821. {
  2822.   DBUG_ASSERT(fixed == 1);
  2823.   ulonglong arg1= (ulonglong) args[0]->val_int();
  2824.   ulonglong arg2= (ulonglong) args[1]->val_int();
  2825.   if ((null_value= (args[0]->null_value || args[1]->null_value)))
  2826.     return 0;
  2827.   return (longlong) (arg1 ^ arg2);
  2828. }
  2829. /***************************************************************************
  2830.   System variables
  2831. ****************************************************************************/
  2832. /*
  2833.   Return value of an system variable base[.name] as a constant item
  2834.   SYNOPSIS
  2835.     get_system_var()
  2836.     thd Thread handler
  2837.     var_type global / session
  2838.     name Name of base or system variable
  2839.     component Component.
  2840.   NOTES
  2841.     If component.str = 0 then the variable name is in 'name'
  2842.   RETURN
  2843.     0 error
  2844.     # constant item
  2845. */
  2846. Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
  2847.      LEX_STRING component)
  2848. {
  2849.   sys_var *var;
  2850.   LEX_STRING *base_name, *component_name;
  2851.   if (component.str == 0 &&
  2852.       !my_strcasecmp(system_charset_info, name.str, "VERSION"))
  2853.     return new Item_string(NULL, server_version,
  2854.    (uint) strlen(server_version),
  2855.    system_charset_info, DERIVATION_SYSCONST);
  2856.   if (component.str)
  2857.   {
  2858.     base_name= &component;
  2859.     component_name= &name;
  2860.   }
  2861.   else
  2862.   {
  2863.     base_name= &name;
  2864.     component_name= &component; // Empty string
  2865.   }
  2866.   if (!(var= find_sys_var(base_name->str, base_name->length)))
  2867.     return 0;
  2868.   if (component.str)
  2869.   {
  2870.     if (!var->is_struct())
  2871.     {
  2872.       net_printf(thd, ER_VARIABLE_IS_NOT_STRUCT, base_name->str);
  2873.       return 0;
  2874.     }
  2875.   }
  2876.   thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
  2877.   set_if_smaller(component_name->length, MAX_SYS_VAR_LENGTH);
  2878.   return new Item_func_get_system_var(var, var_type, component_name,
  2879.                                       NULL, 0);
  2880. }
  2881. /*
  2882.   Check a user level lock.
  2883.   SYNOPSIS:
  2884.     val_int()
  2885.   RETURN VALUES
  2886.     1 Available
  2887.     0 Already taken
  2888.     NULL Error
  2889. */
  2890. longlong Item_func_is_free_lock::val_int()
  2891. {
  2892.   DBUG_ASSERT(fixed == 1);
  2893.   String *res=args[0]->val_str(&value);
  2894.   User_level_lock *ull;
  2895.   null_value=0;
  2896.   if (!res || !res->length())
  2897.   {
  2898.     null_value=1;
  2899.     return 0;
  2900.   }
  2901.   
  2902.   pthread_mutex_lock(&LOCK_user_locks);
  2903.   ull= (User_level_lock *) hash_search(&hash_user_locks, (byte*) res->ptr(),
  2904.   res->length());
  2905.   pthread_mutex_unlock(&LOCK_user_locks);
  2906.   if (!ull || !ull->locked)
  2907.     return 1;
  2908.   return 0;
  2909. }
  2910. longlong Item_func_is_used_lock::val_int()
  2911. {
  2912.   DBUG_ASSERT(fixed == 1);
  2913.   String *res=args[0]->val_str(&value);
  2914.   User_level_lock *ull;
  2915.   null_value=1;
  2916.   if (!res || !res->length())
  2917.     return 0;
  2918.   
  2919.   pthread_mutex_lock(&LOCK_user_locks);
  2920.   ull= (User_level_lock *) hash_search(&hash_user_locks, (byte*) res->ptr(),
  2921.   res->length());
  2922.   pthread_mutex_unlock(&LOCK_user_locks);
  2923.   if (!ull || !ull->locked)
  2924.     return 0;
  2925.   null_value=0;
  2926.   return ull->thread_id;
  2927. }
  2928. longlong Item_func_found_rows::val_int()
  2929. {
  2930.   DBUG_ASSERT(fixed == 1);
  2931.   THD *thd= current_thd;
  2932.   return thd->found_rows();
  2933. }