开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_func.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：46k
源码类别：

MySQL数据库

开发平台：

Visual C++

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