home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / item_func.cpp < prev    next >
C/C++ Source or Header  |  2000-11-16  |  46KB  |  2,047 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.  
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.  
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.  
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. /* This file defines all numerical functions */
  19.  
  20. #ifdef __GNUC__
  21. #pragma implementation                // gcc: Class implementation
  22. #endif
  23.  
  24. #include "mysql_priv.h"
  25. #include <m_ctype.h>
  26. #include <hash.h>
  27. #include <time.h>
  28. #include <ft_global.h>
  29.  
  30. /* return TRUE if item is a constant */
  31.  
  32. bool
  33. eval_const_cond(COND *cond)
  34. {
  35.   return ((Item_func*) cond)->val_int() ? TRUE : FALSE;
  36. }
  37.  
  38.  
  39. Item_func::Item_func(List<Item> &list)
  40. {
  41.   arg_count=list.elements;
  42.   if ((args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
  43.   {
  44.     uint i=0;
  45.     List_iterator<Item> li(list);
  46.     Item *item;
  47.  
  48.     while ((item=li++))
  49.     {
  50.       args[i++]= item;
  51.       with_sum_func|=item->with_sum_func;
  52.     }
  53.   }
  54.   list.empty();                    // Fields are used
  55. }
  56.  
  57. bool
  58. Item_func::fix_fields(THD *thd,TABLE_LIST *tables)
  59. {
  60.   Item **arg,**arg_end;
  61.   char buff[sizeof(double)];            // Max argument in function
  62.   binary=0;
  63.   used_tables_cache=0;
  64.   const_item_cache=1;
  65.  
  66.   if (thd && check_stack_overrun(thd,buff))
  67.     return 0;                    // Fatal error if flag is set!
  68.   if (arg_count)
  69.   {                        // Print purify happy
  70.     for (arg=args, arg_end=args+arg_count; arg != arg_end ; arg++)
  71.     {
  72.       if ((*arg)->fix_fields(thd,tables))
  73.     return 1;                /* purecov: inspected */
  74.       if ((*arg)->maybe_null)
  75.     maybe_null=1;
  76.       if ((*arg)->binary)
  77.     binary=1;
  78.       with_sum_func= with_sum_func || (*arg)->with_sum_func;
  79.       used_tables_cache|=(*arg)->used_tables();
  80.       const_item_cache&= (*arg)->const_item();
  81.     }
  82.   }
  83.   fix_length_and_dec();
  84.   return 0;
  85. }
  86.  
  87.  
  88. void Item_func::split_sum_func(List<Item> &fields)
  89. {
  90.   Item **arg,**arg_end;
  91.   for (arg=args, arg_end=args+arg_count; arg != arg_end ; arg++)
  92.   {
  93.     if ((*arg)->with_sum_func && (*arg)->type() != SUM_FUNC_ITEM)
  94.       (*arg)->split_sum_func(fields);
  95.     else if ((*arg)->used_tables() || (*arg)->type() == SUM_FUNC_ITEM)
  96.     {
  97.       fields.push_front(*arg);
  98.       *arg=new Item_ref((Item**) fields.head_ref(),0,(*arg)->name);
  99.     }
  100.   }
  101. }
  102.  
  103.  
  104. void Item_func::update_used_tables()
  105. {
  106.   used_tables_cache=0;
  107.   const_item_cache=1;
  108.   for (uint i=0 ; i < arg_count ; i++)
  109.   {
  110.     args[i]->update_used_tables();
  111.     used_tables_cache|=args[i]->used_tables();
  112.     const_item_cache&=args[i]->const_item();
  113.   }
  114. }
  115.  
  116.  
  117. table_map Item_func::used_tables() const
  118. {
  119.   return used_tables_cache;
  120. }
  121.  
  122. void Item_func::print(String *str)
  123. {
  124.   str->append(func_name());
  125.   str->append('(');
  126.   for (uint i=0 ; i < arg_count ; i++)
  127.   {
  128.     if (i)
  129.       str->append(',');
  130.     args[i]->print(str);
  131.   }
  132.   str->append(')');
  133. }
  134.  
  135.  
  136. void Item_func::print_op(String *str)
  137. {
  138.   str->append('(');
  139.   for (uint i=0 ; i < arg_count-1 ; i++)
  140.   {
  141.     args[i]->print(str);
  142.     str->append(' ');
  143.     str->append(func_name());
  144.     str->append(' ');
  145.   }
  146.   args[arg_count-1]->print(str);
  147.   str->append(')');
  148. }
  149.  
  150. bool Item_func::eq(const Item *item) const
  151. {
  152.   /* Assume we don't have rtti */
  153.   if (this == item)
  154.     return 1;
  155.   if (item->type() != FUNC_ITEM)
  156.     return 0;
  157.   Item_func *item_func=(Item_func*) item;
  158.   if (arg_count != item_func->arg_count ||
  159.       func_name() != item_func->func_name())
  160.     return 0;
  161.   for (uint i=0; i < arg_count ; i++)
  162.     if (!args[i]->eq(item_func->args[i]))
  163.       return 0;
  164.   return 1;
  165. }
  166.  
  167.  
  168. String *Item_real_func::val_str(String *str)
  169. {
  170.   double nr=val();
  171.   if (null_value)
  172.     return 0; /* purecov: inspected */
  173.   else
  174.     str->set(nr,decimals);
  175.   return str;
  176. }
  177.  
  178.  
  179. String *Item_num_func::val_str(String *str)
  180. {
  181.   if (hybrid_type == INT_RESULT)
  182.   {
  183.     longlong nr=val_int();
  184.     if (null_value)
  185.       return 0; /* purecov: inspected */
  186.     else
  187.       str->set(nr);
  188.   }
  189.   else
  190.   {
  191.     double nr=val();
  192.     if (null_value)
  193.       return 0; /* purecov: inspected */
  194.     else
  195.       str->set(nr,decimals);
  196.   }
  197.   return str;
  198. }
  199.  
  200.  
  201. void Item_func::fix_num_length_and_dec()
  202. {
  203.   decimals=0;
  204.   for (uint i=0 ; i < arg_count ; i++)
  205.     set_if_bigger(decimals,args[i]->decimals);
  206.   max_length=float_length(decimals);
  207. }
  208.  
  209.  
  210. String *Item_int_func::val_str(String *str)
  211. {
  212.   longlong nr=val_int();
  213.   if (null_value)
  214.     return 0;
  215.   else
  216.     str->set(nr);
  217.   return str;
  218. }
  219.  
  220. /* Change from REAL_RESULT (default) to INT_RESULT if both arguments are integers */
  221.  
  222. void Item_num_op::find_num_type(void)
  223. {
  224.   if (args[0]->result_type() == INT_RESULT &&
  225.       args[1]->result_type() == INT_RESULT)
  226.     hybrid_type=INT_RESULT;
  227. }
  228.  
  229. String *Item_num_op::val_str(String *str)
  230. {
  231.   if (hybrid_type == INT_RESULT)
  232.   {
  233.     longlong nr=val_int();
  234.     if (null_value)
  235.       return 0; /* purecov: inspected */
  236.     else
  237.       str->set(nr);
  238.   }
  239.   else
  240.   {
  241.     double nr=val();
  242.     if (null_value)
  243.       return 0; /* purecov: inspected */
  244.     else
  245.       str->set(nr,decimals);
  246.   }
  247.   return str;
  248. }
  249.  
  250.  
  251. double Item_func_plus::val()
  252. {
  253.   double value=args[0]->val()+args[1]->val();
  254.   if ((null_value=args[0]->null_value || args[1]->null_value))
  255.     return 0.0;
  256.   return value;
  257. }
  258.  
  259. longlong Item_func_plus::val_int()
  260. {
  261.   longlong value=args[0]->val_int()+args[1]->val_int();
  262.   if ((null_value=args[0]->null_value || args[1]->null_value))
  263.     return 0;
  264.   return value;
  265. }
  266.  
  267. double Item_func_minus::val()
  268. {
  269.   double value=args[0]->val() - args[1]->val();
  270.   if ((null_value=args[0]->null_value || args[1]->null_value))
  271.     return 0.0;
  272.   return value;
  273. }
  274.  
  275. longlong Item_func_minus::val_int()
  276. {
  277.   longlong value=args[0]->val_int() - args[1]->val_int();
  278.   if ((null_value=args[0]->null_value || args[1]->null_value))
  279.     return 0;
  280.   return value;
  281. }
  282.  
  283. double Item_func_mul::val()
  284. {
  285.   double value=args[0]->val()*args[1]->val();
  286.   if ((null_value=args[0]->null_value || args[1]->null_value))
  287.     return 0.0; /* purecov: inspected */
  288.   return value;
  289. }
  290.  
  291. longlong Item_func_mul::val_int()
  292. {
  293.   longlong value=args[0]->val_int()*args[1]->val_int();
  294.   if ((null_value=args[0]->null_value || args[1]->null_value))
  295.     return 0; /* purecov: inspected */
  296.   return value;
  297. }
  298.  
  299.  
  300. double Item_func_div::val()
  301. {
  302.   double value=args[0]->val();
  303.   double val2=args[1]->val();
  304.   if ((null_value= val2 == 0.0 || args[0]->null_value || args[1]->null_value))
  305.     return 0.0;
  306.   return value/val2;
  307. }
  308.  
  309. longlong Item_func_div::val_int()
  310. {
  311.   longlong value=args[0]->val_int();
  312.   longlong val2=args[1]->val_int();
  313.   if ((null_value= val2 == 0 || args[0]->null_value || args[1]->null_value))
  314.     return 0;
  315.   return value/val2;
  316. }
  317.  
  318. void Item_func_div::fix_length_and_dec()
  319. {
  320.   decimals=max(args[0]->decimals,args[1]->decimals)+2;
  321.   max_length=args[0]->max_length - args[0]->decimals + decimals;
  322.   uint tmp=float_length(decimals);
  323.   set_if_smaller(max_length,tmp);
  324.   maybe_null=1;
  325. }
  326.  
  327. double Item_func_mod::val()
  328. {
  329.   double value= floor(args[0]->val()+0.5);
  330.   double val2=floor(args[1]->val()+0.5);
  331.   if ((null_value=val2 == 0.0 || args[0]->null_value || args[1]->null_value))
  332.     return 0.0; /* purecov: inspected */
  333.   return fmod(value,val2);
  334. }
  335.  
  336. longlong Item_func_mod::val_int()
  337. {
  338.   longlong value=  args[0]->val_int();
  339.   longlong val2= args[1]->val_int();
  340.   if ((null_value=val2 == 0 || args[0]->null_value || args[1]->null_value))
  341.     return 0; /* purecov: inspected */
  342.   return value % val2;
  343. }
  344.  
  345. void Item_func_mod::fix_length_and_dec()
  346. {
  347.   max_length=args[1]->max_length;
  348.   decimals=0;
  349.   maybe_null=1;
  350.   find_num_type();
  351. }
  352.  
  353.  
  354. double Item_func_neg::val()
  355. {
  356.   double value=args[0]->val();
  357.   null_value=args[0]->null_value;
  358.   return -value;
  359. }
  360.  
  361. longlong Item_func_neg::val_int()
  362. {
  363.   longlong value=args[0]->val_int();
  364.   null_value=args[0]->null_value;
  365.   return -value;
  366. }
  367.  
  368. void Item_func_neg::fix_length_and_dec()
  369. {
  370.   decimals=args[0]->decimals;
  371.   max_length=args[0]->max_length;
  372.   hybrid_type= args[0]->result_type() == INT_RESULT ? INT_RESULT : REAL_RESULT;
  373. }
  374.  
  375. double Item_func_abs::val()
  376. {
  377.   double value=args[0]->val();
  378.   null_value=args[0]->null_value;
  379.   return fabs(value);
  380. }
  381.  
  382. longlong Item_func_abs::val_int()
  383. {
  384.   longlong value=args[0]->val_int();
  385.   null_value=args[0]->null_value;
  386.   return value >= 0 ? value : -value;
  387. }
  388.  
  389. void Item_func_abs::fix_length_and_dec()
  390. {
  391.   decimals=args[0]->decimals;
  392.   max_length=args[0]->max_length;
  393.   hybrid_type= args[0]->result_type() == INT_RESULT ? INT_RESULT : REAL_RESULT;
  394. }
  395.  
  396. double Item_func_log::val()
  397. {
  398.   double value=args[0]->val();
  399.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  400.     return 0.0; /* purecov: inspected */
  401.   return log(value);
  402. }
  403.  
  404. double Item_func_log10::val()
  405. {
  406.   double value=args[0]->val();
  407.   if ((null_value=(args[0]->null_value || value <= 0.0)))
  408.     return 0.0; /* purecov: inspected */
  409.   return log10(value);
  410. }
  411.  
  412. double Item_func_exp::val()
  413. {
  414.   double value=args[0]->val();
  415.   if ((null_value=args[0]->null_value))
  416.     return 0.0; /* purecov: inspected */
  417.   return exp(value);
  418. }
  419.  
  420. double Item_func_sqrt::val()
  421. {
  422.   double value=args[0]->val();
  423.   if ((null_value=(args[0]->null_value || value < 0)))
  424.     return 0.0; /* purecov: inspected */
  425.   return sqrt(value);
  426. }
  427.  
  428. double Item_func_pow::val()
  429. {
  430.   double value=args[0]->val();
  431.   double val2=args[1]->val();
  432.   if ((null_value=(args[0]->null_value || args[1]->null_value)))
  433.     return 0.0; /* purecov: inspected */
  434.   return pow(value,val2);
  435. }
  436.  
  437. // Trigonometric functions
  438.  
  439. double Item_func_acos::val()
  440. {
  441.   double value=args[0]->val();
  442.   if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
  443.     return 0.0;
  444.   return fix_result(acos(value));
  445. }
  446.  
  447. double Item_func_asin::val()
  448. {
  449.   double value=args[0]->val();
  450.   if ((null_value=(args[0]->null_value || (value < -1.0 || value > 1.0))))
  451.     return 0.0;
  452.   return fix_result(asin(value));
  453. }
  454.  
  455. double Item_func_atan::val()
  456. {
  457.   double value=args[0]->val();
  458.   if ((null_value=args[0]->null_value))
  459.     return 0.0;
  460.   if (arg_count == 2)
  461.   {
  462.     double val2= args[1]->val();
  463.     if ((null_value=args[1]->null_value))
  464.       return 0.0;
  465.     return fix_result(atan2(value,val2));
  466.   }
  467.   return fix_result(atan(value));
  468. }
  469.  
  470. double Item_func_cos::val()
  471. {
  472.   double value=args[0]->val();
  473.   if ((null_value=args[0]->null_value))
  474.     return 0.0;
  475.   return fix_result(cos(value));
  476. }
  477.  
  478. double Item_func_sin::val()
  479. {
  480.   double value=args[0]->val();
  481.   if ((null_value=args[0]->null_value))
  482.     return 0.0;
  483.   return fix_result(sin(value));
  484. }
  485.  
  486. double Item_func_tan::val()
  487. {
  488.   double value=args[0]->val();
  489.   if ((null_value=args[0]->null_value))
  490.     return 0.0;
  491.   return fix_result(tan(value));
  492. }
  493.  
  494.  
  495. // Shift-functions, same as << and >> in C/C++
  496.  
  497.  
  498. longlong Item_func_shift_left::val_int()
  499. {
  500.   uint shift;
  501.   ulonglong res= ((ulonglong) args[0]->val_int() <<
  502.           (shift=(uint) args[1]->val_int()));
  503.   if (args[0]->null_value || args[1]->null_value)
  504.   {
  505.     null_value=1;
  506.     return 0;
  507.   }
  508.   null_value=0;
  509.   return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
  510. }
  511.  
  512. longlong Item_func_shift_right::val_int()
  513. {
  514.   uint shift;
  515.   ulonglong res= (ulonglong) args[0]->val_int() >>
  516.     (shift=(uint) args[1]->val_int());
  517.   if (args[0]->null_value || args[1]->null_value)
  518.   {
  519.     null_value=1;
  520.     return 0;
  521.   }
  522.   null_value=0;
  523.   return (shift < sizeof(longlong)*8 ? (longlong) res : LL(0));
  524. }
  525.  
  526.  
  527. longlong Item_func_bit_neg::val_int()
  528. {
  529.   ulonglong res= (ulonglong) args[0]->val_int();
  530.   if ((null_value=args[0]->null_value))
  531.     return 0;
  532.   return ~res;
  533. }
  534.  
  535.  
  536. // Conversion functions
  537.  
  538. void Item_func_integer::fix_length_and_dec()
  539. {
  540.   max_length=args[0]->max_length - args[0]->decimals+1;
  541.   uint tmp=float_length(decimals);
  542.   set_if_smaller(max_length,tmp);
  543.   decimals=0;
  544. }
  545.  
  546. longlong Item_func_ceiling::val_int()
  547. {
  548.   double value=args[0]->val();
  549.   null_value=args[0]->null_value;
  550.   return (longlong) ceil(value);
  551. }
  552.  
  553. longlong Item_func_floor::val_int()
  554. {
  555.   double value=args[0]->val();
  556.   null_value=args[0]->null_value;
  557.   return (longlong) floor(value);
  558. }
  559.  
  560. void Item_func_round::fix_length_and_dec()
  561. {
  562.   max_length=args[0]->max_length;
  563.   decimals=args[0]->decimals;
  564.   if (args[1]->const_item())
  565.   {
  566.     int tmp=(int) args[1]->val_int();
  567.     if (tmp < 0)
  568.       decimals=0;
  569.     else
  570.       decimals=tmp;
  571.   }
  572. }
  573.  
  574. double Item_func_round::val()
  575. {
  576.   double value=args[0]->val();
  577.   int dec=(int) args[1]->val_int();
  578.   uint abs_dec=abs(dec);
  579.  
  580.   if ((null_value=args[0]->null_value || args[1]->null_value))
  581.     return 0.0;
  582.   double tmp=(abs_dec < array_elements(log_10) ?
  583.           log_10[abs_dec] : pow(10.0,(double) abs_dec));
  584.  
  585.   if (truncate)
  586.     return dec < 0 ? floor(value/tmp)*tmp : floor(value*tmp)/tmp;
  587.   return dec < 0 ? rint(value/tmp)*tmp : rint(value*tmp)/tmp;
  588. }
  589.  
  590.  
  591. double Item_func_rand::val()
  592. {
  593.   if (arg_count)
  594.   {                    // Only use argument once in query
  595.     ulong tmp=((ulong) args[0]->val_int())+55555555L;
  596.     randominit(¤t_thd->rand,tmp,tmp/2);
  597. #ifdef DELETE_ITEMS
  598.     delete args[0];
  599. #endif
  600.     arg_count=0;
  601.   }
  602.   return rnd(¤t_thd->rand);
  603. }
  604.  
  605. longlong Item_func_sign::val_int()
  606. {
  607.   double value=args[0]->val();
  608.   null_value=args[0]->null_value;
  609.   return value < 0.0 ? -1 : (value > 0 ? 1 : 0);
  610. }
  611.  
  612.  
  613. double Item_func_units::val()
  614. {
  615.   double value=args[0]->val();
  616.   if ((null_value=args[0]->null_value))
  617.     return 0;
  618.   return value*mul+add;
  619. }
  620.  
  621.  
  622. void Item_func_min_max::fix_length_and_dec()
  623. {
  624.   decimals=0;
  625.   max_length=0;
  626.   maybe_null=1;
  627.   binary=0;
  628.   cmp_type=args[0]->result_type();
  629.   for (uint i=0 ; i < arg_count ; i++)
  630.   {
  631.     if (max_length < args[i]->max_length)
  632.       max_length=args[i]->max_length;
  633.     if (decimals < args[i]->decimals)
  634.       decimals=args[i]->decimals;
  635.     if (!args[i]->maybe_null)
  636.       maybe_null=0;
  637.     cmp_type=item_cmp_type(cmp_type,args[i]->result_type());
  638.     if (args[i]->binary)
  639.       binary=1;
  640.   }
  641. }
  642.  
  643.  
  644. String *Item_func_min_max::val_str(String *str)
  645. {
  646.   switch (cmp_type) {
  647.   case INT_RESULT:
  648.   {
  649.     longlong nr=val_int();
  650.     if (null_value)
  651.       return 0;
  652.     else
  653.       str->set(nr);
  654.     return str;
  655.   }
  656.   case REAL_RESULT:
  657.   {
  658.     double nr=val();
  659.     if (null_value)
  660.       return 0; /* purecov: inspected */
  661.     else
  662.       str->set(nr,decimals);
  663.     return str;
  664.   }
  665.   case STRING_RESULT:
  666.   {
  667.     String *res;
  668.     LINT_INIT(res);
  669.     null_value=1;
  670.     for (uint i=0; i < arg_count ; i++)
  671.     {
  672.       if (null_value)
  673.       {
  674.     res=args[i]->val_str(str);
  675.     null_value=args[i]->null_value;
  676.       }
  677.       else
  678.       {
  679.     String *res2;
  680.     res2= args[i]->val_str(res == str ? &tmp_value : str);
  681.     if (res2)
  682.     {
  683.       int cmp=binary ? stringcmp(res,res2) : sortcmp(res,res2);
  684.       if ((cmp_sign < 0 ? cmp : -cmp) < 0)
  685.         res=res2;
  686.     }
  687.       }
  688.     }
  689.     return res;
  690.   }
  691.   }
  692.   return 0;                    // Keep compiler happy
  693. }
  694.  
  695.  
  696. double Item_func_min_max::val()
  697. {
  698.   double value=0.0;
  699.   null_value=1;
  700.   for (uint i=0; i < arg_count ; i++)
  701.   {
  702.     if (null_value)
  703.     {
  704.       value=args[i]->val();
  705.       null_value=args[i]->null_value;
  706.     }
  707.     else
  708.     {
  709.       double tmp=args[i]->val();
  710.       if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
  711.     value=tmp;
  712.     }
  713.   }
  714.   return value;
  715. }
  716.  
  717.  
  718. longlong Item_func_min_max::val_int()
  719. {
  720.   longlong value=0;
  721.   null_value=1;
  722.   for (uint i=0; i < arg_count ; i++)
  723.   {
  724.     if (null_value)
  725.     {
  726.       value=args[i]->val_int();
  727.       null_value=args[i]->null_value;
  728.     }
  729.     else
  730.     {
  731.       longlong tmp=args[i]->val_int();
  732.       if (!args[i]->null_value && (tmp < value ? cmp_sign : -cmp_sign) > 0)
  733.     value=tmp;
  734.     }
  735.   }
  736.   return value;
  737. }
  738.  
  739.  
  740. longlong Item_func_length::val_int()
  741. {
  742.   String *res=args[0]->val_str(&value);
  743.   if (!res)
  744.   {
  745.     null_value=1;
  746.     return 0; /* purecov: inspected */
  747.   }
  748.   null_value=0;
  749.   return (longlong) res->length();
  750. }
  751.  
  752. longlong Item_func_char_length::val_int()
  753. {
  754.   String *res=args[0]->val_str(&value);
  755.   if (!res)
  756.   {
  757.     null_value=1;
  758.     return 0; /* purecov: inspected */
  759.   }
  760.   null_value=0;
  761.   return (longlong) (!args[0]->binary) ? res->numchars() : res->length();
  762. }
  763.  
  764.  
  765. longlong Item_func_locate::val_int()
  766. {
  767.   String *a=args[0]->val_str(&value1);
  768.   String *b=args[1]->val_str(&value2);
  769. #ifdef USE_MB
  770.   bool binary_str = args[0]->binary || args[1]->binary;
  771. #endif
  772.   if (!a || !b)
  773.   {
  774.     null_value=1;
  775.     return 0; /* purecov: inspected */
  776.   }
  777.   null_value=0;
  778.   uint start=0;
  779. #ifdef USE_MB
  780.   uint start0=0;
  781. #endif
  782.   if (arg_count == 3)
  783.   {
  784.     start=(uint) args[2]->val_int()-1;
  785. #ifdef USE_MB
  786.     if (use_mb(default_charset_info))
  787.     {
  788.       start0=start;
  789.       if (!binary_str)
  790.         start=a->charpos(start);
  791.     }
  792. #endif
  793.     if (start > a->length() || start+b->length() > a->length())
  794.       return 0;
  795.   }
  796.   if (!b->length())                // Found empty string at start
  797.     return (longlong) (start+1);
  798. #ifdef USE_MB
  799.   if (use_mb(default_charset_info) && !binary_str)
  800.   {
  801.     const char *ptr=a->ptr()+start;
  802.     const char *search=b->ptr();
  803.     const char *strend = ptr+a->length();
  804.     const char *end=strend-b->length()+1;
  805.     const char *search_end=search+b->length();
  806.     register  uint32 l;
  807.     while (ptr < end)
  808.     {
  809.       if (*ptr == *search)
  810.       {
  811.         register char *i,*j;
  812.         i=(char*) ptr+1; j=(char*) search+1;
  813.         while (j != search_end)
  814.           if (*i++ != *j++) goto skipp;
  815.         return (longlong) start0+1;
  816.       }
  817.   skipp:
  818.       if ((l=my_ismbchar(default_charset_info,ptr,strend))) ptr+=l;
  819.       else ++ptr;
  820.       ++start0;
  821.     }
  822.     return 0;
  823.   }
  824. #endif /* USE_MB */
  825.   return (longlong) (a->strstr(*b,start)+1) ;
  826. }
  827.  
  828.  
  829. longlong Item_func_field::val_int()
  830. {
  831.   String *field;
  832.   if (!(field=item->val_str(&value)))
  833.     return 0;                    // -1 if null ?
  834.   for (uint i=0 ; i < arg_count ; i++)
  835.   {
  836.     String *tmp_value=args[i]->val_str(&tmp);
  837.     if (tmp_value && field->length() == tmp_value->length() &&
  838.     !memcmp(field->ptr(),tmp_value->ptr(),tmp_value->length()))
  839.       return (longlong) (i+1);
  840.   }
  841.   return 0;
  842. }
  843.  
  844.  
  845. longlong Item_func_ascii::val_int()
  846. {
  847.   String *res=args[0]->val_str(&value);
  848.   if (!res)
  849.   {
  850.     null_value=1;
  851.     return 0;
  852.   }
  853.   null_value=0;
  854.   return (longlong) (res->length() ? (uchar) (*res)[0] : (uchar) 0);
  855. }
  856.  
  857. longlong Item_func_ord::val_int()
  858. {
  859.   String *res=args[0]->val_str(&value);
  860.   if (!res)
  861.   {
  862.     null_value=1;
  863.     return 0;
  864.   }
  865.   null_value=0;
  866.   if (!res->length()) return 0;
  867. #ifdef USE_MB
  868.   if (use_mb(default_charset_info) && !args[0]->binary)
  869.   {
  870.     register const char *str=res->ptr();
  871.     register uint32 n=0, l=my_ismbchar(default_charset_info,
  872.                                        str,str+res->length());
  873.     if (!l) return (longlong)((uchar) *str);
  874.     while (l--)
  875.       n=(n<<8)|(uint32)((uchar) *str++);
  876.     return (longlong) n;
  877.   }
  878. #endif
  879.   return (longlong) ((uchar) (*res)[0]);
  880. }
  881.  
  882.     /* Search after a string in a string of strings separated by ',' */
  883.     /* Returns number of found type >= 1 or 0 if not found */
  884.     /* This optimizes searching in enums to bit testing! */
  885.  
  886. void Item_func_find_in_set::fix_length_and_dec()
  887. {
  888.   decimals=0;
  889.   max_length=3;                    // 1-999
  890.   if (args[0]->const_item() && args[1]->type() == FIELD_ITEM)
  891.   {
  892.     Field *field= ((Item_field*) args[1])->field;
  893.     if (field->real_type() == FIELD_TYPE_SET)
  894.     {
  895.       String *find=args[0]->val_str(&value);
  896.       if (find)
  897.       {
  898.     enum_value=find_enum(((Field_enum*) field)->typelib,find->ptr(),
  899.                  find->length());
  900.     enum_bit=0;
  901.     if (enum_value)
  902.       enum_bit=LL(1) << (enum_value-1);
  903.       }
  904.     }
  905.   }
  906. }
  907.  
  908. static const char separator=',';
  909.  
  910. longlong Item_func_find_in_set::val_int()
  911. {
  912.   if (enum_value)
  913.   {
  914.     ulonglong tmp=(ulonglong) args[1]->val_int();
  915.     if (!(null_value=args[1]->null_value || args[0]->null_value))
  916.     {
  917.       if (tmp & enum_bit)
  918.     return enum_value;
  919.     }
  920.     return 0L;
  921.   }
  922.  
  923.   String *find=args[0]->val_str(&value);
  924.   String *buffer=args[1]->val_str(&value2);
  925.   if (!find || !buffer)
  926.   {
  927.     null_value=1;
  928.     return 0; /* purecov: inspected */
  929.   }
  930.   null_value=0;
  931.  
  932.   int diff;
  933.   if ((diff=buffer->length() - find->length()) >= 0)
  934.   {
  935.     const char *f_pos=find->ptr();
  936.     const char *f_end=f_pos+find->length();
  937.     const char *str=buffer->ptr();
  938.     const char *end=str+diff+1;
  939.     const char *real_end=str+buffer->length();
  940.     uint position=1;
  941.     do
  942.     {
  943.       const char *pos= f_pos;
  944.       while (pos != f_end)
  945.       {
  946.     if (toupper(*str) != toupper(*pos))
  947.       goto not_found;
  948.     str++;
  949.     pos++;
  950.       }
  951.       if (str == real_end || str[0] == separator)
  952.     return (longlong) position;
  953.   not_found:
  954.       while (str < end && str[0] != separator)
  955.     str++;
  956.       position++;
  957.     } while (++str <= end);
  958.   }
  959.   return 0;
  960. }
  961.  
  962. static char nbits[256] = {
  963.   0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
  964.   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  965.   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  966.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  967.   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  968.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  969.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  970.   3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  971.   1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  972.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  973.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  974.   3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  975.   2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  976.   3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  977.   3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  978.   4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
  979. };
  980.  
  981. uint count_bits(ulonglong v)
  982. {
  983. #if SIZEOF_LONG_LONG > 4
  984.   /* The following code is a bit faster on 16 bit machines than if we would
  985.      only shift v */
  986.   ulong v2=(ulong) (v >> 32);
  987.   return (uint) (uchar) (nbits[(uchar)  v] +
  988.                          nbits[(uchar) (v >> 8)] +
  989.                          nbits[(uchar) (v >> 16)] +
  990.                          nbits[(uchar) (v >> 24)] +
  991.                          nbits[(uchar) (v2)] +
  992.                          nbits[(uchar) (v2 >> 8)] +
  993.                          nbits[(uchar) (v2 >> 16)] +
  994.                          nbits[(uchar) (v2 >> 24)]);
  995. #else
  996.   return (uint) (uchar) (nbits[(uchar)  v] +
  997.                          nbits[(uchar) (v >> 8)] +
  998.                          nbits[(uchar) (v >> 16)] +
  999.                          nbits[(uchar) (v >> 24)]);
  1000. #endif
  1001. }
  1002.  
  1003. longlong Item_func_bit_count::val_int()
  1004. {
  1005.   ulonglong value= (ulonglong) args[0]->val_int();
  1006.   if (args[0]->null_value)
  1007.   {
  1008.     null_value=1; /* purecov: inspected */
  1009.     return 0; /* purecov: inspected */
  1010.   }
  1011.   return (longlong) count_bits(value);
  1012. }
  1013.  
  1014.  
  1015. /****************************************************************************
  1016. ** Functions to handle dynamic loadable functions
  1017. ** Original source by: Alexis Mikhailov <root@medinf.chuvashia.su>
  1018. ** Rewritten by monty.
  1019. ****************************************************************************/
  1020.  
  1021. #ifdef HAVE_DLOPEN
  1022.  
  1023. udf_handler::~udf_handler()
  1024. {
  1025.   if (initialized)
  1026.   {
  1027.     if (u_d->func_deinit != NULL)
  1028.     {
  1029.       void (*deinit)(UDF_INIT *) = (void (*)(UDF_INIT*))
  1030.     u_d->func_deinit;
  1031.       (*deinit)(&initid);
  1032.     }
  1033.     free_udf(u_d);
  1034.   }
  1035.   delete [] buffers;
  1036. }
  1037.  
  1038.  
  1039. bool
  1040. udf_handler::fix_fields(THD *thd,TABLE_LIST *tables,Item_result_field *func,
  1041.             uint arg_count, Item **arguments)
  1042. {
  1043.   char buff[sizeof(double)];            // Max argument in function
  1044.   DBUG_ENTER("Item_udf_func::fix_fields");
  1045.  
  1046.   if (thd)
  1047.   {
  1048.     if (check_stack_overrun(thd,buff))
  1049.       return 0;                    // Fatal error flag is set!
  1050.   }
  1051.   else
  1052.     thd=current_thd;                // In WHERE / const clause
  1053.   udf_func *tmp_udf=find_udf(u_d->name,(uint) strlen(u_d->name),1);
  1054.  
  1055.   if (!tmp_udf)
  1056.   {
  1057.     my_printf_error(ER_CANT_FIND_UDF,ER(ER_CANT_FIND_UDF),MYF(0),u_d->name,
  1058.             errno);
  1059.     DBUG_RETURN(1);
  1060.   }
  1061.   u_d=tmp_udf;
  1062.   args=arguments;
  1063.  
  1064.   /* Fix all arguments */
  1065.   func->binary=func->maybe_null=0;
  1066.   used_tables_cache=0;
  1067.   const_item_cache=1;
  1068.  
  1069.   if ((f_args.arg_count=arg_count))
  1070.   {
  1071.     if (!(f_args.arg_type= (Item_result*)
  1072.       sql_alloc(f_args.arg_count*sizeof(Item_result))))
  1073.  
  1074.     {
  1075.       free_udf(u_d);
  1076.       DBUG_RETURN(1);
  1077.     }
  1078.     uint i;
  1079.     Item **arg,**arg_end;
  1080.     for (i=0, arg=arguments, arg_end=arguments+arg_count;
  1081.      arg != arg_end ;
  1082.      arg++,i++)
  1083.     {
  1084.       if ((*arg)->fix_fields(thd,tables))
  1085.     return 1;
  1086.       if ((*arg)->binary)
  1087.     func->binary=1;
  1088.       if ((*arg)->maybe_null)
  1089.     func->maybe_null=1;
  1090.       func->with_sum_func= func->with_sum_func || (*arg)->with_sum_func;
  1091.       used_tables_cache|=(*arg)->used_tables();
  1092.       const_item_cache&=(*arg)->const_item();
  1093.       f_args.arg_type[i]=(*arg)->result_type();
  1094.     }
  1095.     if (!(buffers=new String[arg_count]) ||
  1096.     !(f_args.args= (char**) sql_alloc(arg_count * sizeof(char *))) ||
  1097.     !(f_args.lengths=(ulong*) sql_alloc(arg_count * sizeof(long))) ||
  1098.     !(f_args.maybe_null=(char*) sql_alloc(arg_count * sizeof(char))) ||
  1099.     !(num_buffer= (char*) sql_alloc(ALIGN_SIZE(sizeof(double))*arg_count)))
  1100.     {
  1101.       free_udf(u_d);
  1102.       DBUG_RETURN(1);
  1103.     }
  1104.   }
  1105.   func->fix_length_and_dec();
  1106.   initid.max_length=func->max_length;
  1107.   initid.maybe_null=func->maybe_null;
  1108.   initid.const_item=const_item_cache;
  1109.   initid.decimals=func->decimals;
  1110.   initid.ptr=0;
  1111.  
  1112.   if (u_d->func_init)
  1113.   {
  1114.     char *to=num_buffer;
  1115.     for (uint i=0; i < arg_count; i++)
  1116.     {
  1117.       f_args.args[i]=0;
  1118.       f_args.lengths[i]=arguments[i]->max_length;
  1119.       f_args.maybe_null[i]=(char) arguments[i]->maybe_null;
  1120.  
  1121.       switch(arguments[i]->type()) {
  1122.       case Item::STRING_ITEM:            // Constant string !
  1123.       {
  1124.     String *res=arguments[i]->val_str((String *) 0);
  1125.     if (arguments[i]->null_value)
  1126.       continue;
  1127.     f_args.args[i]=    (char*) res->ptr();
  1128.     break;
  1129.       }
  1130.       case Item::INT_ITEM:
  1131.     *((longlong*) to) = arguments[i]->val_int();
  1132.     if (!arguments[i]->null_value)
  1133.     {
  1134.       f_args.args[i]=to;
  1135.       to+= ALIGN_SIZE(sizeof(longlong));
  1136.     }
  1137.     break;
  1138.       case Item::REAL_ITEM:
  1139.     *((double*) to) = arguments[i]->val();
  1140.     if (!arguments[i]->null_value)
  1141.     {
  1142.       f_args.args[i]=to;
  1143.       to+= ALIGN_SIZE(sizeof(double));
  1144.     }
  1145.     break;
  1146.       default:                    // Skip these
  1147.     break;
  1148.       }
  1149.     }
  1150.     thd->net.last_error[0]=0;
  1151.     my_bool (*init)(UDF_INIT *, UDF_ARGS *, char *)=
  1152.       (my_bool (*)(UDF_INIT *, UDF_ARGS *,  char *))
  1153.       u_d->func_init;
  1154.     if ((error=(uchar) init(&initid, &f_args, thd->net.last_error)))
  1155.     {
  1156.       my_printf_error(ER_CANT_INITIALIZE_UDF,ER(ER_CANT_INITIALIZE_UDF),MYF(0),
  1157.               u_d->name,thd->net.last_error);
  1158.       free_udf(u_d);
  1159.       DBUG_RETURN(1);
  1160.     }
  1161.     func->max_length=min(initid.max_length,MAX_BLOB_WIDTH);
  1162.     func->maybe_null=initid.maybe_null;
  1163.     const_item_cache=initid.const_item;
  1164.     func->decimals=min(initid.decimals,31);
  1165.   }
  1166.   initialized=1;
  1167.   if (error)
  1168.   {
  1169.     my_printf_error(ER_CANT_INITIALIZE_UDF,ER(ER_CANT_INITIALIZE_UDF),MYF(0),
  1170.             u_d->name, ER(ER_UNKNOWN_ERROR));
  1171.     DBUG_RETURN(1);
  1172.   }
  1173.   DBUG_RETURN(0);
  1174. }
  1175.  
  1176.  
  1177. bool udf_handler::get_arguments()
  1178. {
  1179.   if (error)
  1180.     return 1;                    // Got an error earlier
  1181.   char *to= num_buffer;
  1182.   uint str_count=0;
  1183.   for (uint i=0; i < f_args.arg_count; i++)
  1184.   {
  1185.     f_args.args[i]=0;
  1186.     switch (f_args.arg_type[i]) {
  1187.     case STRING_RESULT:
  1188.       {
  1189.     String *res=args[i]->val_str(&buffers[str_count++]);
  1190.     if (!(args[i]->null_value))
  1191.     {
  1192.       f_args.args[i]=    (char*) res->ptr();
  1193.       f_args.lengths[i]= res->length();
  1194.       break;
  1195.     }
  1196.       }
  1197.     case INT_RESULT:
  1198.       *((longlong*) to) = args[i]->val_int();
  1199.       if (!args[i]->null_value)
  1200.       {
  1201.     f_args.args[i]=to;
  1202.     to+= ALIGN_SIZE(sizeof(longlong));
  1203.       }
  1204.       break;
  1205.     case REAL_RESULT:
  1206.       *((double*) to) = args[i]->val();
  1207.       if (!args[i]->null_value)
  1208.       {
  1209.     f_args.args[i]=to;
  1210.     to+= ALIGN_SIZE(sizeof(double));
  1211.       }
  1212.       break;
  1213.     }
  1214.   }
  1215.   return 0;
  1216. }
  1217.  
  1218. /* This returns (String*) 0 in case of NULL values */
  1219.  
  1220. String *udf_handler::val_str(String *str,String *save_str)
  1221. {
  1222.   uchar is_null=0;
  1223.   ulong res_length;
  1224.  
  1225.   if (get_arguments())
  1226.     return 0;
  1227.   char * (*func)(UDF_INIT *, UDF_ARGS *, char *, ulong *, uchar *, uchar *)=
  1228.     (char* (*)(UDF_INIT *, UDF_ARGS *, char *, ulong *, uchar *, uchar *))
  1229.     u_d->func;
  1230.  
  1231.   if ((res_length=str->alloced_length()) < MAX_FIELD_WIDTH)
  1232.   {                        // This happens VERY seldom
  1233.     if (str->alloc(MAX_FIELD_WIDTH))
  1234.     {
  1235.       error=1;
  1236.       return 0;
  1237.     }
  1238.   }
  1239.   char *res=func(&initid, &f_args, (char*) str->ptr(), &res_length, &is_null,
  1240.         &error);
  1241.   if (is_null || !res || error)            // The !res is for safety
  1242.   {
  1243.     return 0;
  1244.   }
  1245.   if (res == str->ptr())
  1246.   {
  1247.     str->length(res_length);
  1248.     return str;
  1249.   }
  1250.   save_str->set(res, res_length);
  1251.   return save_str;
  1252. }
  1253.  
  1254.  
  1255.  
  1256. double Item_func_udf_float::val()
  1257. {
  1258.   DBUG_ENTER("Item_func_udf_float::val");
  1259.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1260.              args[0]->result_type(), arg_count));
  1261.   DBUG_RETURN(udf.val(&null_value));
  1262. }
  1263.  
  1264.  
  1265. String *Item_func_udf_float::val_str(String *str)
  1266. {
  1267.   double nr=val();
  1268.   if (null_value)
  1269.     return 0;                    /* purecov: inspected */
  1270.   else
  1271.     str->set(nr,decimals);
  1272.   return str;
  1273. }
  1274.  
  1275.  
  1276. longlong Item_func_udf_int::val_int()
  1277. {
  1278.   DBUG_ENTER("Item_func_udf_int::val_int");
  1279.   DBUG_PRINT("info",("result_type: %d  arg_count: %d",
  1280.              args[0]->result_type(), arg_count));
  1281.  
  1282.   DBUG_RETURN(udf.val_int(&null_value));
  1283. }
  1284.  
  1285.  
  1286. String *Item_func_udf_int::val_str(String *str)
  1287. {
  1288.   longlong nr=val_int();
  1289.   if (null_value)
  1290.     return 0;
  1291.   else
  1292.     str->set(nr);
  1293.   return str;
  1294. }
  1295.  
  1296. /* Default max_length is max argument length */
  1297.  
  1298. void Item_func_udf_str::fix_length_and_dec()
  1299. {
  1300.   DBUG_ENTER("Item_func_udf_str::fix_length_and_dec");
  1301.   max_length=0;
  1302.   for (uint i = 0; i < arg_count; i++)
  1303.     set_if_bigger(max_length,args[i]->max_length);
  1304.   DBUG_VOID_RETURN;
  1305. }
  1306.  
  1307. String *Item_func_udf_str::val_str(String *str)
  1308. {
  1309.   String *res=udf.val_str(str,&str_value);
  1310.   null_value = !res;
  1311.   return res;
  1312. }
  1313.  
  1314. #else
  1315. bool udf_handler::get_arguments() { return 0; }
  1316. #endif /* HAVE_DLOPEN */
  1317.  
  1318. /*
  1319. ** User level locks
  1320. */
  1321.  
  1322. pthread_mutex_t LOCK_user_locks;
  1323. static HASH hash_user_locks;
  1324.  
  1325. class ULL
  1326. {
  1327.   char *key;
  1328.   uint key_length;
  1329.  
  1330. public:
  1331.   int count;
  1332.   bool locked;
  1333.   pthread_cond_t cond;
  1334.   pthread_t thread;
  1335.  
  1336.   ULL(const char *key_arg,uint length) :key_length(length),count(1),locked(1)
  1337.   {
  1338.     key=(char*) my_memdup((byte*) key_arg,length,MYF(0));
  1339.     pthread_cond_init(&cond,NULL);
  1340.     if (key)
  1341.     {
  1342.       if (hash_insert(&hash_user_locks,(byte*) this))
  1343.       {
  1344.     my_free((gptr) key,MYF(0));
  1345.     key=0;
  1346.       }
  1347.     }
  1348.   }
  1349.   ~ULL()
  1350.   {
  1351.     if (key)
  1352.     {
  1353.       hash_delete(&hash_user_locks,(byte*) this);
  1354.       my_free((gptr) key,MYF(0));
  1355.     }
  1356.     pthread_cond_destroy(&cond);
  1357.   }
  1358.   inline bool initialized() { return key != 0; }
  1359.   friend void item_user_lock_release(ULL *ull);
  1360.   friend char *ull_get_key(const ULL *ull,uint *length,my_bool not_used);
  1361. };
  1362.  
  1363. char *ull_get_key(const ULL *ull,uint *length,
  1364.           my_bool not_used __attribute__((unused)))
  1365. {
  1366.   *length=(uint) ull->key_length;
  1367.   return (char*) ull->key;
  1368. }
  1369.  
  1370. void item_user_lock_init(void)
  1371. {
  1372.   pthread_mutex_init(&LOCK_user_locks,NULL);
  1373.   hash_init(&hash_user_locks,16,0,0,(hash_get_key) ull_get_key,NULL,0);
  1374. }
  1375.  
  1376. void item_user_lock_free(void)
  1377. {
  1378.   hash_free(&hash_user_locks);
  1379. }
  1380.  
  1381. void item_user_lock_release(ULL *ull)
  1382. {
  1383.   ull->locked=0;
  1384.   if (--ull->count)
  1385.     pthread_cond_signal(&ull->cond);
  1386.   else
  1387.     delete ull;
  1388. }
  1389.  
  1390. /*
  1391.   Get a user level lock. If the thread has an old lock this is first released.
  1392.   Returns 1:  Got lock
  1393.   Returns 0:  Timeout
  1394.   Returns NULL: Error
  1395. */
  1396.  
  1397. longlong Item_func_get_lock::val_int()
  1398. {
  1399.   String *res=args[0]->val_str(&value);
  1400.   longlong timeout=args[1]->val_int();
  1401.   struct timespec abstime;
  1402.   THD *thd=current_thd;
  1403.   ULL *ull;
  1404.   int error;
  1405.  
  1406.   pthread_mutex_lock(&LOCK_user_locks);
  1407.  
  1408.   if (!res || !res->length())
  1409.   {
  1410.     pthread_mutex_unlock(&LOCK_user_locks);
  1411.     null_value=1;
  1412.     return 0;
  1413.   }
  1414.   null_value=0;
  1415.  
  1416.   if (thd->ull)
  1417.   {
  1418.     item_user_lock_release(thd->ull);
  1419.     thd->ull=0;
  1420.   }
  1421.  
  1422.   if (!(ull= ((ULL*) hash_search(&hash_user_locks,(byte*) res->ptr(),
  1423.                  res->length()))))
  1424.   {
  1425.     ull=new ULL(res->ptr(),res->length());
  1426.     if (!ull || !ull->initialized())
  1427.     {
  1428.       delete ull;
  1429.       pthread_mutex_unlock(&LOCK_user_locks);
  1430.       null_value=1;                // Probably out of memory
  1431.       return 0;
  1432.     }
  1433.     ull->thread=thd->real_id;
  1434.     thd->ull=ull;
  1435.     pthread_mutex_unlock(&LOCK_user_locks);
  1436.     return 1;                    // Got new lock
  1437.   }
  1438.   ull->count++;
  1439.  
  1440.   /* structure is now initialized.  Try to get the lock */
  1441.   /* Set up control struct to allow others to abort locks */
  1442.   pthread_mutex_lock(&thd->mysys_var->mutex);
  1443.   thd->proc_info="User lock";
  1444.   thd->mysys_var->current_mutex= &LOCK_user_locks;
  1445.   thd->mysys_var->current_cond=  &ull->cond;
  1446.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  1447.  
  1448.   abstime.tv_sec=time((time_t*) 0)+(time_t) timeout;
  1449.   abstime.tv_nsec=0;
  1450.   while ((error=pthread_cond_timedwait(&ull->cond,&LOCK_user_locks,&abstime))
  1451.      != ETIME && error != ETIMEDOUT && ull->locked)
  1452.   {
  1453.     if (thd->killed || abort_loop)
  1454.     {
  1455.       error=EINTR;                // Return NULL
  1456.       break;
  1457.     }
  1458.   }
  1459.   if (ull->locked)
  1460.   {
  1461.     if (!--ull->count)
  1462.       delete ull;                // Should never happen
  1463.     if (error != ETIME && error != ETIMEDOUT)
  1464.     {
  1465.       error=1;
  1466.       null_value=1;                // Return NULL
  1467.     }
  1468.   }
  1469.   else
  1470.   {
  1471.     ull->locked=1;
  1472.     ull->thread=thd->real_id;
  1473.     thd->ull=ull;
  1474.     error=0;
  1475.   }
  1476.   pthread_mutex_unlock(&LOCK_user_locks);
  1477.  
  1478.   pthread_mutex_lock(&thd->mysys_var->mutex);
  1479.   thd->proc_info=0;
  1480.   thd->mysys_var->current_mutex= 0;
  1481.   thd->mysys_var->current_cond=  0;
  1482.   pthread_mutex_unlock(&thd->mysys_var->mutex);
  1483.  
  1484.   return !error ? 1 : 0;
  1485. }
  1486.  
  1487.  
  1488. /*
  1489. ** Release a user level lock.
  1490. ** Returns 1 if lock released
  1491. ** 0 if lock wasn't held
  1492. ** NULL if no such lock
  1493. */
  1494.  
  1495. longlong Item_func_release_lock::val_int()
  1496. {
  1497.   String *res=args[0]->val_str(&value);
  1498.   ULL *ull;
  1499.   longlong result;
  1500.   if (!res || !res->length())
  1501.   {
  1502.     null_value=1;
  1503.     return 0;
  1504.   }
  1505.   null_value=0;
  1506.  
  1507.   result=0;
  1508.   pthread_mutex_lock(&LOCK_user_locks);
  1509.   if (!(ull= ((ULL*) hash_search(&hash_user_locks,(const byte*) res->ptr(),
  1510.                  res->length()))))
  1511.   {
  1512.     null_value=1;
  1513.   }
  1514.   else
  1515.   {
  1516.     if (ull->locked && pthread_equal(pthread_self(),ull->thread))
  1517.     {
  1518.       result=1;                    // Release is ok
  1519.       item_user_lock_release(ull);
  1520.       current_thd->ull=0;
  1521.     }
  1522.   }
  1523.   pthread_mutex_unlock(&LOCK_user_locks);
  1524.   return result;
  1525. }
  1526.  
  1527.  
  1528. longlong Item_func_set_last_insert_id::val_int()
  1529. {
  1530.   longlong value=args[0]->val_int();
  1531.   current_thd->insert_id(value);
  1532.   null_value=args[0]->null_value;
  1533.   return value;
  1534. }
  1535.  
  1536. /* This function is just used to test speed of different functions */
  1537.  
  1538. longlong Item_func_benchmark::val_int()
  1539. {
  1540.   char buff[MAX_FIELD_WIDTH];
  1541.   String tmp(buff,sizeof(buff));
  1542.   THD *thd=current_thd;
  1543.  
  1544.   for (ulong loop=0 ; loop < loop_count && !thd->killed; loop++)
  1545.   {
  1546.     switch (args[0]->result_type()) {
  1547.     case REAL_RESULT:
  1548.       (void) args[0]->val();
  1549.       break;
  1550.     case INT_RESULT:
  1551.       (void) args[0]->val_int();
  1552.       break;
  1553.     case STRING_RESULT:
  1554.       (void) args[0]->val_str(&tmp);
  1555.       break;
  1556.     }
  1557.   }
  1558.   return 0;
  1559. }
  1560.  
  1561. #define extra_size sizeof(double)
  1562.  
  1563. static user_var_entry *get_variable(HASH *hash, LEX_STRING &name,
  1564.                     bool create_if_not_exists)
  1565. {
  1566.   user_var_entry *entry;
  1567.  
  1568.   if (!(entry = (user_var_entry*) hash_search(hash, (byte*) name.str,
  1569.                           name.length)) &&
  1570.       create_if_not_exists)
  1571.   {
  1572.     uint size=ALIGN_SIZE(sizeof(user_var_entry))+name.length+1+extra_size;
  1573.     if (!hash_inited(hash))
  1574.       return 0;
  1575.     if (!(entry = (user_var_entry*) my_malloc(size,MYF(MY_WME))))
  1576.       return 0;
  1577.     entry->name.str=(char*) entry+ ALIGN_SIZE(sizeof(user_var_entry))+
  1578.       extra_size;
  1579.     entry->name.length=name.length;
  1580.     entry->value=0;
  1581.     entry->length=0;
  1582.     entry->type=STRING_RESULT;
  1583.     memcpy(entry->name.str, name.str, name.length+1);
  1584.     if (hash_insert(hash,(byte*) entry))
  1585.     {
  1586.       my_free((char*) entry,MYF(0));
  1587.       return 0;
  1588.     }
  1589.   }
  1590.   return entry;
  1591. }
  1592.  
  1593.  
  1594. bool Item_func_set_user_var::fix_fields(THD *thd,TABLE_LIST *tables)
  1595. {
  1596.   if (!thd)
  1597.     thd=current_thd;
  1598.   if (Item_func::fix_fields(thd,tables) ||
  1599.       !(entry= get_variable(&thd->user_vars, name, 1)))
  1600.     return 1;
  1601.   return 0;
  1602. }
  1603.  
  1604.  
  1605. void
  1606. Item_func_set_user_var::fix_length_and_dec()
  1607. {
  1608.   maybe_null=args[0]->maybe_null;
  1609.   max_length=args[0]->max_length;
  1610.   decimals=args[0]->decimals;
  1611.   cached_result_type=args[0]->result_type();
  1612. }
  1613.  
  1614. void Item_func_set_user_var::update_hash(void *ptr, uint length,
  1615.                      Item_result type)
  1616. {
  1617.   if ((null_value=args[0]->null_value))
  1618.   {
  1619.     char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  1620.     if (entry->value && entry->value != pos)
  1621.       my_free(entry->value,MYF(0));
  1622.     entry->value=0;
  1623.     entry->length=0;
  1624.   }
  1625.   else
  1626.   {
  1627.     if (length <= extra_size)
  1628.     {
  1629.       /* Save value in value struct */
  1630.       char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  1631.       if (entry->value != pos)
  1632.       {
  1633.     if (entry->value)
  1634.       my_free(entry->value,MYF(0));
  1635.     entry->value=pos;
  1636.       }
  1637.     }
  1638.     else
  1639.     {
  1640.       /* Allocate variable */
  1641.       if (entry->length != length)
  1642.       {
  1643.     char *pos= (char*) entry+ ALIGN_SIZE(sizeof(user_var_entry));
  1644.     if (entry->value == pos)
  1645.       entry->value=0;
  1646.     if (!(entry->value=(char*) my_realloc(entry->value, length,
  1647.                           MYF(MY_ALLOW_ZERO_PTR))))
  1648.       goto err;
  1649.       }
  1650.     }
  1651.     memcpy(entry->value,ptr,length);
  1652.     entry->length= length;
  1653.     entry->type=type;
  1654.   }
  1655.   return;
  1656.  
  1657.  err:
  1658.   current_thd->fatal_error=1;            // Probably end of memory
  1659.   null_value=1;
  1660.   return;
  1661. }
  1662.  
  1663.  
  1664. bool
  1665. Item_func_set_user_var::update()
  1666. {
  1667.   switch (cached_result_type) {
  1668.   case REAL_RESULT:
  1669.     (void) val();
  1670.     break;
  1671.   case INT_RESULT:
  1672.     (void) val_int();
  1673.     break;
  1674.   case STRING_RESULT:
  1675.     char buffer[MAX_FIELD_WIDTH];
  1676.     String tmp(buffer,sizeof(buffer));
  1677.     (void) val_str(&tmp);
  1678.     break;
  1679.   }
  1680.   return current_thd->fatal_error;
  1681. }
  1682.  
  1683.  
  1684. double
  1685. Item_func_set_user_var::val()
  1686. {
  1687.   double value=args[0]->val();
  1688.   update_hash((void*) &value,sizeof(value), REAL_RESULT);
  1689.   return value;
  1690. }
  1691.  
  1692. longlong
  1693. Item_func_set_user_var::val_int()
  1694. {
  1695.   longlong value=args[0]->val_int();
  1696.   update_hash((void*) &value,sizeof(longlong),INT_RESULT);
  1697.   return value;
  1698. }
  1699.  
  1700. String *
  1701. Item_func_set_user_var::val_str(String *str)
  1702. {
  1703.   String *res=args[0]->val_str(str);
  1704.   if (!res)                    // Null value
  1705.     update_hash((void*) 0,0,STRING_RESULT);
  1706.   else
  1707.     update_hash(res->c_ptr(),res->length()+1,STRING_RESULT);
  1708.   return res;
  1709. }
  1710.  
  1711.  
  1712. user_var_entry *Item_func_get_user_var::get_entry()
  1713. {
  1714.   if (!entry  || ! entry->value)
  1715.   {
  1716.     null_value=1;
  1717.     return 0;
  1718.   }
  1719.   null_value=0;
  1720.   return entry;
  1721. }
  1722.  
  1723.  
  1724. String *
  1725. Item_func_get_user_var::val_str(String *str)
  1726. {
  1727.   user_var_entry *entry=get_entry();
  1728.   if (!entry)
  1729.     return NULL;
  1730.   switch (entry->type) {
  1731.   case REAL_RESULT:
  1732.     str->set(*(double*) entry->value);
  1733.     break;
  1734.   case INT_RESULT:
  1735.     str->set(*(longlong*) entry->value);
  1736.     break;
  1737.   case STRING_RESULT:
  1738.     if (str->copy(entry->value, entry->length-1))
  1739.     {
  1740.       null_value=1;
  1741.       return NULL;
  1742.     }
  1743.     break;
  1744.   }
  1745.   return str;
  1746. }
  1747.  
  1748.  
  1749. double Item_func_get_user_var::val()
  1750. {
  1751.   user_var_entry *entry=get_entry();
  1752.   if (!entry)
  1753.     return 0.0;
  1754.   switch (entry->type) {
  1755.   case REAL_RESULT:
  1756.     return *(double*) entry->value;
  1757.   case INT_RESULT:
  1758.     return (double) *(longlong*) entry->value;
  1759.   case STRING_RESULT:
  1760.     return atof(entry->value);            // This is null terminated
  1761.   }
  1762.   return 0.0;                    // Impossible
  1763. }
  1764.  
  1765.  
  1766. longlong Item_func_get_user_var::val_int()
  1767. {
  1768.   user_var_entry *entry=get_entry();
  1769.   if (!entry)
  1770.     return LL(0);
  1771.   switch (entry->type) {
  1772.   case REAL_RESULT:
  1773.     return (longlong) *(double*) entry->value;
  1774.   case INT_RESULT:
  1775.     return *(longlong*) entry->value;
  1776.   case STRING_RESULT:
  1777.     return strtoull(entry->value,NULL,10);    // String is null terminated
  1778.   }
  1779.   return LL(0);                    // Impossible
  1780. }
  1781.  
  1782.  
  1783. void Item_func_get_user_var::fix_length_and_dec()
  1784. {
  1785.   maybe_null=1;
  1786.   decimals=NOT_FIXED_DEC;
  1787.   max_length=MAX_BLOB_WIDTH;
  1788.   entry= get_variable(¤t_thd->user_vars, name, 0);
  1789. }
  1790.  
  1791.  
  1792. enum Item_result Item_func_get_user_var::result_type() const
  1793. {
  1794.   user_var_entry *entry;
  1795.   if (!(entry = (user_var_entry*) hash_search(¤t_thd->user_vars,
  1796.                           (byte*) name.str,
  1797.                           name.length)))
  1798.     return STRING_RESULT;
  1799.   return entry->type;
  1800. }
  1801.  
  1802. longlong Item_func_inet_aton::val_int()
  1803. {
  1804.   uint byte_result = 0;
  1805.   ulonglong result = 0;            // We are ready for 64 bit addresses
  1806.   const char *p,* end;
  1807.   char c = '.'; // we mark c to indicate invalid IP in case length is 0
  1808.   char buff[36];
  1809.  
  1810.   String *s,tmp(buff,sizeof(buff));
  1811.   if (!(s = args[0]->val_str(&tmp)))        // If null value
  1812.     goto err;
  1813.   null_value=0;
  1814.  
  1815.   end= (p = s->ptr()) + s->length();
  1816.   while (p < end)
  1817.   {
  1818.     c = *p++;
  1819.     int digit = (int) (c - '0');        // Assume ascii
  1820.     if (digit >= 0 && digit <= 9)
  1821.     {
  1822.       if ((byte_result = byte_result * 10 + digit) > 255)
  1823.     goto err;                // Wrong address
  1824.     }
  1825.     else if (c == '.')
  1826.     {
  1827.       result= (result << 8) + (ulonglong) byte_result;
  1828.       byte_result = 0;
  1829.     }
  1830.     else
  1831.       goto err;                    // Invalid character
  1832.   }
  1833.   if (c != '.')                    // IP number can't end on '.'
  1834.     return (result << 8) + (ulonglong) byte_result;
  1835.  
  1836. err:
  1837.   null_value=1;
  1838.   return 0;
  1839. }
  1840.  
  1841. double Item_func_match::val()
  1842. {
  1843.   // Don't know how to return an error from val(), so NULL will be returned
  1844.   if ((null_value=(ft_handler==NULL)))
  1845.     return 0.0;
  1846.  
  1847.   if (join_key)
  1848.   {
  1849.     if (table->file->ft_handler)
  1850.       return ft_get_relevance(ft_handler);
  1851.  
  1852.     join_key=0; // Magic here ! See ha_myisam::ft_read()
  1853.   }
  1854.  
  1855.   /* we'll have to find ft_relevance manually in ft_handler array */
  1856.  
  1857.   int a,b,c;
  1858.   FT_DOC  *docs=ft_handler->doc;
  1859.   my_off_t docid=table->file->row_position();
  1860.  
  1861.   if ((null_value=(docid==HA_OFFSET_ERROR)))
  1862.     return 0.0;
  1863.  
  1864.   // Assuming docs[] is sorted by dpos...
  1865.  
  1866.   for (a=0, b=ft_handler->ndocs, c=(a+b)/2; b-a>1; c=(a+b)/2)
  1867.   {
  1868.     if (docs[c].dpos > docid)
  1869.       b=c;
  1870.     else
  1871.       a=c;
  1872.   }
  1873.   if (docs[a].dpos == docid)
  1874.     return docs[a].weight;
  1875.   else
  1876.     return 0.0;
  1877.  
  1878. }
  1879.  
  1880. void Item_func_match::init_search(bool no_order)
  1881. {
  1882.   if (ft_handler)
  1883.     return;
  1884.  
  1885.   if (master)
  1886.   {
  1887.     join_key=master->join_key=join_key|master->join_key;
  1888.     master->init_search(no_order);
  1889.     ft_handler=master->ft_handler;
  1890.     join_key=master->join_key;
  1891.     return;
  1892.   }
  1893.  
  1894.   String *ft_tmp=0;
  1895.   char tmp1[FT_QUERY_MAXLEN];
  1896.   String tmp2(tmp1,sizeof(tmp1));
  1897.  
  1898.   ft_tmp=key_item()->val_str(&tmp2);
  1899.   ft_handler=(FT_DOCLIST *)
  1900.      table->file->ft_init_ext(key, (byte*) ft_tmp->ptr(), ft_tmp->length(),
  1901.                               join_key && !no_order);
  1902.  
  1903.   if (join_key)
  1904.   {
  1905.     table->file->ft_handler=ft_handler;
  1906.     return;
  1907.   }
  1908. }
  1909.  
  1910. bool Item_func_match::fix_fields(THD *thd,struct st_table_list *tlist)
  1911. {
  1912.   List_iterator<Item> li(fields);
  1913.   Item *item;
  1914.  
  1915.   /* Why testing for const_item ? Monty */
  1916.   /* I'll remove it later, but this should include modifications to
  1917.      find_best and auto_close as complement to auto_init code above. SerG */
  1918.   /* I'd rather say now that const_item is assumed in quite a bit of
  1919.      places, so it would be difficult to remove. SerG */
  1920.   if (Item_func::fix_fields(thd,tlist) || !const_item())
  1921.     return 1;
  1922.  
  1923.   while ((item=li++))
  1924.   {
  1925.     if (item->type() != Item::FIELD_ITEM || item->fix_fields(thd,tlist) ||
  1926.     !item->used_tables())
  1927.       return 1;
  1928.     used_tables_cache|=item->used_tables();
  1929.   }
  1930.   /* check that all columns comes from the same table */
  1931.   if (count_bits(used_tables_cache) != 1)
  1932.     return 1;
  1933.   const_item_cache=0;
  1934.   table=((Item_field *)fields.head())->field->table;
  1935.   return 0;
  1936. }
  1937.  
  1938.  
  1939. bool Item_func_match::fix_index()
  1940. {
  1941.   List_iterator<Item> li(fields);
  1942.   Item_field *item;
  1943.   uint ft_to_key[MAX_KEY], ft_cnt[MAX_KEY], fts=0, key;
  1944.  
  1945.   for (key=0 ; key<table->keys ; key++)
  1946.   {
  1947.     if ((table->key_info[key].flags & HA_FULLTEXT) &&
  1948.         (table->keys_in_use_for_query & (((key_map)1) << key)))
  1949.     {
  1950.       ft_to_key[fts]=key;
  1951.       ft_cnt[fts]=0;
  1952.       fts++;
  1953.     }
  1954.   }
  1955.  
  1956.   if (!fts)
  1957.   {
  1958.     my_printf_error(ER_FT_MATCHING_KEY_NOT_FOUND,
  1959.                  ER(ER_FT_MATCHING_KEY_NOT_FOUND),MYF(0));
  1960.     return 1;
  1961.   }
  1962.  
  1963.   while ((item=(Item_field*)(li++)))
  1964.   {
  1965.     for (key=0 ; key<fts ; key++)
  1966.     {
  1967.       KEY *ft_key=&table->key_info[ft_to_key[key]];
  1968.       uint key_parts=ft_key->key_parts;
  1969.  
  1970.       for (uint part=0 ; part < key_parts ; part++)
  1971.       {
  1972.     if (item->field->eq(ft_key->key_part[part].field))
  1973.       ft_cnt[key]++;
  1974.       }
  1975.     }
  1976.   }
  1977.  
  1978.   uint max_cnt=0, mkeys=0;
  1979.   for (key=0 ; key<fts ; key++)
  1980.   {
  1981.     if (ft_cnt[key] > max_cnt)
  1982.     {
  1983.       mkeys=0;
  1984.       max_cnt=ft_cnt[mkeys]=ft_cnt[key];
  1985.       ft_to_key[mkeys]=ft_to_key[key];
  1986.       continue;
  1987.     }
  1988.     if (ft_cnt[key] == max_cnt)
  1989.     {
  1990.       mkeys++;
  1991.       ft_cnt[mkeys]=ft_cnt[key];
  1992.       ft_to_key[mkeys]=ft_to_key[key];
  1993.       continue;
  1994.     }
  1995.   }
  1996.  
  1997.   for (key=0 ; key<=mkeys ; key++)
  1998.   {
  1999.     // for now, partial keys won't work. SerG
  2000.     if (max_cnt < fields.elements ||
  2001.         max_cnt < table->key_info[ft_to_key[key]].key_parts)
  2002.       continue;
  2003.  
  2004.     this->key=ft_to_key[key];
  2005.     maybe_null=1;
  2006.     join_key=0;
  2007.  
  2008.     return 0;
  2009.   }
  2010.  
  2011.   my_printf_error(ER_FT_MATCHING_KEY_NOT_FOUND,
  2012.                ER(ER_FT_MATCHING_KEY_NOT_FOUND),MYF(0));
  2013.   return 1;
  2014. }
  2015.  
  2016. bool Item_func_match::eq(const Item *item) const
  2017. {
  2018.   if (item->type() != FUNC_ITEM)
  2019.     return 0;
  2020.  
  2021.   if (func_name() != ((Item_func*)item)->func_name())
  2022.     return 0;
  2023.  
  2024.   Item_func_match *ifm=(Item_func_match*) item;
  2025.  
  2026.   if (key == ifm->key && table == ifm->table &&
  2027.       key_item()->eq(ifm->key_item()))
  2028.     return 1;
  2029.  
  2030.   return 0;
  2031. }
  2032.  
  2033.  
  2034. /***************************************************************************
  2035.   System variables
  2036.   This has to be recoded after we get more than 3 system variables
  2037. ****************************************************************************/
  2038.  
  2039. Item *get_system_var(LEX_STRING name)
  2040. {
  2041.   if (!strcmp(name.str,"IDENTITY"))
  2042.     return new Item_int((char*) "@@IDENTITY",
  2043.             current_thd->insert_id(),21);
  2044.   my_error(ER_UNKNOWN_SYSTEM_VARIABLE,MYF(0),name);
  2045.   return 0;
  2046. }
  2047.