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

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

MySQL数据库

开发平台：

Visual C++

item_cmpfunc.cc：源码内容
  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 */
  18. /* This file defines all compare functions */
  20. #ifdef __GNUC__
  21. #pragma implementation // gcc: Class implementation
  22. #endif
  24. #include "mysql_priv.h"
  25. #include <m_ctype.h>
  27. /*
  28. ** Test functions
  29. ** These returns 0LL if false and 1LL if true and null if some arg is null
  30. ** 'AND' and 'OR' never return null
  31. */
  33. longlong Item_func_not::val_int()
  34. {
  35.   double value=args[0]->val();
  36.   null_value=args[0]->null_value;
  37.   return !null_value && value == 0 ? 1 : 0;
  38. }
  41. static bool convert_constant_item(Field *field, Item **item)
  42. {
  43.   if ((*item)->const_item())
  44.   {
  45.     (*item)->save_in_field(field);
  46.     if (!((*item)->null_value))
  47.     {
  48.       Item *tmp=new Item_int(field->val_int());
  49.       if ((tmp))
  50. *item=tmp;
  51.       return 1;
  52.     }
  53.   }
  54.   return 0;
  55. }
  58. void Item_bool_func2::fix_length_and_dec()
  59. {
  60.   max_length=1;
  62.   /* As some compare functions are generated after sql_yacc,
  63.      we have to check for out of memory conditons here */
  64.   if (!args[0] || !args[1])
  65.     return;
  66.   // Make a special case of compare with fields to get nicer DATE comparisons
  67.   if (args[0]->type() == FIELD_ITEM)
  68.   {
  69.     Field *field=((Item_field*) args[0])->field;
  70.     if (field->store_for_compare())
  71.     {
  72.       if (convert_constant_item(field,&args[1]))
  73.       {
  74. cmp_func= &Item_bool_func2::compare_int;  // Works for all types.
  75. return;
  76.       }
  77.     }
  78.   }
  79.   if (args[1]->type() == FIELD_ITEM)
  80.   {
  81.     Field *field=((Item_field*) args[1])->field;
  82.     if (field->store_for_compare())
  83.     {
  84.       if (convert_constant_item(field,&args[0]))
  85.       {
  86. cmp_func= &Item_bool_func2::compare_int;  // Works for all types.
  87. return;
  88.       }
  89.     }
  90.   }
  91.   set_cmp_func(item_cmp_type(args[0]->result_type(),args[1]->result_type()));
  92. }
  95. void Item_bool_func2::set_cmp_func(Item_result type)
  96. {
  97.   switch (type) {
  98.   case STRING_RESULT:
  99.     cmp_func=&Item_bool_func2::compare_string;
  100.     break;
  101.   case REAL_RESULT:
  102.     cmp_func=&Item_bool_func2::compare_real;
  103.     break;
  104.   case INT_RESULT:
  105.     cmp_func=&Item_bool_func2::compare_int;
  106.     break;
  107.   }
  108. }
  111. int Item_bool_func2::compare_string()
  112. {
  113.   String *res1,*res2;
  114.   if ((res1=args[0]->val_str(&tmp_value1)))
  115.   {
  116.     if ((res2=args[1]->val_str(&tmp_value2)))
  117.     {
  118.       null_value=0;
  119.       return binary ? stringcmp(res1,res2) : sortcmp(res1,res2);
  120.     }
  121.   }
  122.   null_value=1;
  123.   return -1;
  124. }
  126. int Item_bool_func2::compare_real()
  127. {
  128.   double val1=args[0]->val();
  129.   if (!args[0]->null_value)
  130.   {
  131.     double val2=args[1]->val();
  132.     if (!args[1]->null_value)
  133.     {
  134.       null_value=0;
  135.       if (val1 < val2) return -1;
  136.       if (val1 == val2) return 0;
  137.       return 1;
  138.     }
  139.   }
  140.   null_value=1;
  141.   return -1;
  142. }
  145. int Item_bool_func2::compare_int()
  146. {
  147.   longlong val1=args[0]->val_int();
  148.   if (!args[0]->null_value)
  149.   {
  150.     longlong val2=args[1]->val_int();
  151.     if (!args[1]->null_value)
  152.     {
  153.       null_value=0;
  154.       if (val1 < val2) return -1;
  155.       if (val1 == val2)   return 0;
  156.       return 1;
  157.     }
  158.   }
  159.   null_value=1;
  160.   return -1;
  161. }
  165. longlong Item_func_eq::val_int()
  166. {
  167.   int value=(this->*cmp_func)();
  168.   return value == 0 ? 1 : 0;
  169. }
  171. /* Same as Item_func_eq, but NULL = NULL */
  173. void Item_func_equal::fix_length_and_dec()
  174. {
  175.   Item_bool_func2::fix_length_and_dec();
  176.   cmp_result_type=item_cmp_type(args[0]->result_type(),args[1]->result_type());
  177.   maybe_null=null_value=0;
  178. }
  180. longlong Item_func_equal::val_int()
  181. {
  182.   switch (cmp_result_type) {
  183.   case STRING_RESULT:
  184.   {
  185.     String *res1,*res2;
  186.     res1=args[0]->val_str(&tmp_value1);
  187.     res2=args[1]->val_str(&tmp_value2);
  188.     if (!res1 || !res2)
  189.       return test(res1 == res2);
  190.     return (binary ? test(stringcmp(res1,res2) == 0) :
  191.     test(sortcmp(res1,res2) == 0));
  192.   }
  193.   case REAL_RESULT:
  194.   {
  195.     double val1=args[0]->val();
  196.     double val2=args[1]->val();
  197.     if (args[0]->null_value || args[1]->null_value)
  198.       return test(args[0]->null_value && args[1]->null_value);
  199.     return test(val1 == val2);
  200.   }
  201.   case INT_RESULT:
  202.   {
  203.     longlong val1=args[0]->val_int();
  204.     longlong val2=args[1]->val_int();
  205.     if (args[0]->null_value || args[1]->null_value)
  206.       return test(args[0]->null_value && args[1]->null_value);
  207.     return test(val1 == val2);
  208.   }
  209.   }
  210.   return 0; // Impossible
  211. }
  214. longlong Item_func_ne::val_int()
  215. {
  216.   int value=(this->*cmp_func)();
  217.   return value != 0 && !null_value ? 1 : 0;
  218. }
  221. longlong Item_func_ge::val_int()
  222. {
  223.   int value=(this->*cmp_func)();
  224.   return value >= 0 ? 1 : 0;
  225. }
  228. longlong Item_func_gt::val_int()
  229. {
  230.   int value=(this->*cmp_func)();
  231.   return value > 0 ? 1 : 0;
  232. }
  234. longlong Item_func_le::val_int()
  235. {
  236.   int value=(this->*cmp_func)();
  237.   return value <= 0 && !null_value ? 1 : 0;
  238. }
  241. longlong Item_func_lt::val_int()
  242. {
  243.   int value=(this->*cmp_func)();
  244.   return value < 0 && !null_value ? 1 : 0;
  245. }
  248. longlong Item_func_strcmp::val_int()
  249. {
  250.   String *a=args[0]->val_str(&tmp_value1);
  251.   String *b=args[1]->val_str(&tmp_value2);
  252.   if (!a || !b)
  253.   {
  254.     null_value=1;
  255.     return 0;
  256.   }
  257.   int value=stringcmp(a,b);
  258.   null_value=0;
  259.   return !value ? 0 : (value < 0 ? (longlong) -1 : (longlong) 1);
  260. }
  263. void Item_func_interval::fix_length_and_dec()
  264. {
  265.   bool nums=1;
  266.   uint i;
  267.   for (i=0 ; i < arg_count ; i++)
  268.   {
  269.     if (!args[i])
  270.       return; // End of memory
  271.     if (args[i]->type() != Item::INT_ITEM &&
  272. args[i]->type() != Item::REAL_ITEM)
  273.     {
  274.       nums=0;
  275.       break;
  276.     }
  277.   }
  278.   if (nums && arg_count >= 8)
  279.   {
  280.     if ((intervals=(double*) sql_alloc(sizeof(double)*arg_count)))
  281.     {
  282.       for (i=0 ; i < arg_count ; i++)
  283. intervals[i]=args[i]->val();
  284.     }
  285.   }
  286.   maybe_null=0; max_length=2;
  287.   used_tables_cache|=item->used_tables();
  288. }
  290. /*
  291.   return -1 if null value,
  292.   0 if lower than lowest
  293.   1 - arg_count if between args[n] and args[n+1]
  294.   arg_count+1 if higher than biggest argument
  295. */
  297. longlong Item_func_interval::val_int()
  298. {
  299.   double value=item->val();
  300.   if (item->null_value)
  301.     return -1; // -1 if null /* purecov: inspected */
  302.   if (intervals)
  303.   { // Use binary search to find interval
  304.     uint start,end;
  305.     start=0; end=arg_count-1;
  306.     while (start != end)
  307.     {
  308.       uint mid=(start+end+1)/2;
  309.       if (intervals[mid] <= value)
  310. start=mid;
  311.       else
  312. end=mid-1;
  313.     }
  314.     return (value < intervals[start]) ? 0 : start+1;
  315.   }
  316.   if (args[0]->val() > value)
  317.     return 0;
  318.   for (uint i=1 ; i < arg_count ; i++)
  319.   {
  320.     if (args[i]->val() > value)
  321.       return i;
  322.   }
  323.   return (longlong) arg_count;
  324. }
  327. void Item_func_interval::update_used_tables()
  328. {
  329.   Item_func::update_used_tables();
  330.   item->update_used_tables();
  331.   used_tables_cache|=item->used_tables();
  332.   const_item_cache&=item->const_item();
  333. }
  335. void Item_func_between::fix_length_and_dec()
  336. {
  337.    max_length=1;
  339.   /* As some compare functions are generated after sql_yacc,
  340.      we have to check for out of memory conditons here */
  341.   if (!args[0] || !args[1] || !args[2])
  342.     return;
  343.   cmp_type=args[0]->result_type();
  344.   if (args[0]->binary)
  345.     string_compare=stringcmp;
  346.   else
  347.     string_compare=sortcmp;
  349.   // Make a special case of compare with fields to get nicer DATE comparisons
  350.   if (args[0]->type() == FIELD_ITEM)
  351.   {
  352.     Field *field=((Item_field*) args[0])->field;
  353.     if (field->store_for_compare())
  354.     {
  355.       if (convert_constant_item(field,&args[1]))
  356. cmp_type=INT_RESULT; // Works for all types.
  357.       if (convert_constant_item(field,&args[2]))
  358. cmp_type=INT_RESULT; // Works for all types.
  359.     }
  360.   }
  361. }
  364. longlong Item_func_between::val_int()
  365. { // ANSI BETWEEN
  366.   if (cmp_type == STRING_RESULT)
  367.   {
  368.     String *value,*a,*b;
  369.     value=args[0]->val_str(&value0);
  370.     if ((null_value=args[0]->null_value))
  371.       return 0;
  372.     a=args[1]->val_str(&value1);
  373.     b=args[2]->val_str(&value2);
  374.     if (!args[1]->null_value && !args[2]->null_value)
  375.       return (string_compare(value,a) >= 0 && string_compare(value,b) <= 0) ?
  376. 1 : 0;
  377.     if (args[1]->null_value && args[2]->null_value)
  378.       null_value=1;
  379.     else if (args[1]->null_value)
  380.     {
  381.       null_value= string_compare(value,b) <= 0; // not null if false range.
  382.     }
  383.     else
  384.     {
  385.       null_value= string_compare(value,a) >= 0; // not null if false range.
  386.     }
  387.   }
  388.   else if (cmp_type == INT_RESULT)
  389.   {
  390.     longlong value=args[0]->val_int(),a,b;
  391.     if ((null_value=args[0]->null_value))
  392.       return 0; /* purecov: inspected */
  393.     a=args[1]->val_int();
  394.     b=args[2]->val_int();
  395.     if (!args[1]->null_value && !args[2]->null_value)
  396.       return (value >= a && value <= b) ? 1 : 0;
  397.     if (args[1]->null_value && args[2]->null_value)
  398.       null_value=1;
  399.     else if (args[1]->null_value)
  400.     {
  401.       null_value= value <= b; // not null if false range.
  402.     }
  403.     else
  404.     {
  405.       null_value= value >= a;
  406.     }
  407.   }
  408.   else
  409.   {
  410.     double value=args[0]->val(),a,b;
  411.     if ((null_value=args[0]->null_value))
  412.       return 0; /* purecov: inspected */
  413.     a=args[1]->val();
  414.     b=args[2]->val();
  415.     if (!args[1]->null_value && !args[2]->null_value)
  416.       return (value >= a && value <= b) ? 1 : 0;
  417.     if (args[1]->null_value && args[2]->null_value)
  418.       null_value=1;
  419.     else if (args[1]->null_value)
  420.     {
  421.       null_value= value <= b; // not null if false range.
  422.     }
  423.     else
  424.     {
  425.       null_value= value >= a;
  426.     }
  427.   }
  428.   return 0;
  429. }
  431. void
  432. Item_func_ifnull::fix_length_and_dec()
  433. {
  434.   maybe_null=args[1]->maybe_null;
  435.   max_length=max(args[0]->max_length,args[1]->max_length);
  436.   decimals=max(args[0]->decimals,args[1]->decimals);
  437.   cached_result_type=args[0]->result_type();
  438. }
  440. double
  441. Item_func_ifnull::val()
  442. {
  443.   double value=args[0]->val();
  444.   if (!args[0]->null_value)
  445.   {
  446.     null_value=0;
  447.     return value;
  448.   }
  449.   value=args[1]->val();
  450.   if ((null_value=args[1]->null_value))
  451.     return 0.0;
  452.   return value;
  453. }
  455. longlong
  456. Item_func_ifnull::val_int()
  457. {
  458.   longlong value=args[0]->val_int();
  459.   if (!args[0]->null_value)
  460.   {
  461.     null_value=0;
  462.     return value;
  463.   }
  464.   value=args[1]->val_int();
  465.   if ((null_value=args[1]->null_value))
  466.     return 0;
  467.   return value;
  468. }
  470. String *
  471. Item_func_ifnull::val_str(String *str)
  472. {
  473.   String *res  =args[0]->val_str(str);
  474.   if (!args[0]->null_value)
  475.   {
  476.     null_value=0;
  477.     return res;
  478.   }
  479.   res=args[1]->val_str(str);
  480.   if ((null_value=args[1]->null_value))
  481.     return 0;
  482.   return res;
  483. }
  485. void
  486. Item_func_if::fix_length_and_dec()
  487. {
  488.   maybe_null=args[1]->maybe_null || args[2]->maybe_null;
  489.   max_length=max(args[1]->max_length,args[2]->max_length);
  490.   decimals=max(args[0]->decimals,args[1]->decimals);
  491.   enum Item_result arg1_type=args[1]->result_type();
  492.   enum Item_result arg2_type=args[2]->result_type();
  493.   if (arg1_type == STRING_RESULT || arg2_type == STRING_RESULT)
  494.     cached_result_type = STRING_RESULT;
  495.   else if (arg1_type == REAL_RESULT || arg2_type == REAL_RESULT)
  496.     cached_result_type = REAL_RESULT;
  497.   else
  498.     cached_result_type=arg1_type; // Should be INT_RESULT
  499. }
  502. double
  503. Item_func_if::val()
  504. {
  505.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  506.   double value=arg->val();
  507.   null_value=arg->null_value;
  508.   return value;
  509. }
  511. longlong
  512. Item_func_if::val_int()
  513. {
  514.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  515.   longlong value=arg->val_int();
  516.   null_value=arg->null_value;
  517.   return value;
  518. }
  520. String *
  521. Item_func_if::val_str(String *str)
  522. {
  523.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  524.   String *res=arg->val_str(str);
  525.   null_value=arg->null_value;
  526.   return res;
  527. }
  530. void
  531. Item_func_nullif::fix_length_and_dec()
  532. {
  533.   Item_bool_func2::fix_length_and_dec();
  534.   maybe_null=1;
  535.   if (args[0]) // Only false if EOM
  536.   {
  537.     max_length=args[0]->max_length;
  538.     decimals=args[0]->decimals;
  539.     cached_result_type=args[0]->result_type();
  540.   }
  541. }
  543. /*
  544.   nullif() returns NULL if arguments are different, else it returns the
  545.   first argument.
  546.   Note that we have to evaluate the first argument twice as the compare
  547.   may have been done with a different type than return value
  548. */
  550. double
  551. Item_func_nullif::val()
  552. {
  553.   double value;
  554.   if (!(this->*cmp_func)() || null_value)
  555.   {
  556.     null_value=1;
  557.     return 0.0;
  558.   }
  559.   value=args[0]->val();
  560.   null_value=args[0]->null_value;
  561.   return value;
  562. }
  564. longlong
  565. Item_func_nullif::val_int()
  566. {
  567.   longlong value;
  568.   if (!(this->*cmp_func)() || null_value)
  569.   {
  570.     null_value=1;
  571.     return 0;
  572.   }
  573.   value=args[0]->val_int();
  574.   null_value=args[0]->null_value;
  575.   return value;
  576. }
  578. String *
  579. Item_func_nullif::val_str(String *str)
  580. {
  581.   String *res;
  582.   if (!(this->*cmp_func)() || null_value)
  583.   {
  584.     null_value=1;
  585.     return 0;
  586.   }
  587.   res=args[0]->val_str(str);
  588.   null_value=args[0]->null_value;
  589.   return res;
  590. }
  592. /*
  593. ** CASE expression 
  594. */
  596. /* Return the matching ITEM or NULL if all compares (including else) failed */
  598. Item *Item_func_case::find_item(String *str)
  599. {
  600.   String *first_expr_str,*tmp;
  601.   longlong first_expr_int;
  602.   double   first_expr_real;
  603.   bool int_used, real_used,str_used;
  604.   int_used=real_used=str_used=0;
  606.   /* These will be initialized later */
  607.   LINT_INIT(first_expr_str);
  608.   LINT_INIT(first_expr_int);
  609.   LINT_INIT(first_expr_real);
  611.   // Compare every WHEN argument with it and return the first match
  612.   for (uint i=0 ; i < arg_count ; i+=2)
  613.   {
  614.     if (!first_expr)
  615.     {
  616.       // No expression between CASE and first WHEN
  617.       if (args[i]->val_int())
  618. return args[i+1];
  619.       continue;
  620.     }
  621.     switch (args[i]->result_type()) {
  622.     case STRING_RESULT:
  623.       if (!str_used)
  624.       {
  625. str_used=1;
  626. // We can't use 'str' here as this may be overwritten
  627. if (!(first_expr_str= first_expr->val_str(&str_value)))
  628.   return else_expr; // Impossible
  629.       }
  630.       if ((tmp=args[i]->val_str(str))) // If not null
  631.       {
  632. if (first_expr->binary || args[i]->binary)
  633. {
  634.   if (stringcmp(tmp,first_expr_str)==0)
  635.     return args[i+1];
  636. }
  637. else if (sortcmp(tmp,first_expr_str)==0)
  638.   return args[i+1];
  639.       }
  640.       break;
  641.     case INT_RESULT:
  642.       if (!int_used)
  643.       {
  644. int_used=1;
  645. first_expr_int= first_expr->val_int();
  646. if (first_expr->null_value)
  647.   return else_expr;
  648.       }
  649.       if (args[i]->val_int()==first_expr_int && !args[i]->null_value) 
  650.         return args[i+1];
  651.       break;
  652.     case REAL_RESULT: 
  653.       if (!real_used)
  654.       {
  655. real_used=1;
  656. first_expr_real= first_expr->val();
  657. if (first_expr->null_value)
  658.   return else_expr;
  659.       }
  660.       if (args[i]->val()==first_expr_real && !args[i]->null_value) 
  661.         return args[i+1];
  662.     }
  663.   }
  664.   // No, WHEN clauses all missed, return ELSE expression
  665.   return else_expr;
  666. }
  670. String *Item_func_case::val_str(String *str)
  671. {
  672.   String *res;
  673.   Item *item=find_item(str);
  675.   if (!item)
  676.   {
  677.     null_value=1;
  678.     return 0;
  679.   }
  680.   if (!(res=item->val_str(str)))
  681.     null_value=1;
  682.   return res;
  683. }
  686. longlong Item_func_case::val_int()
  687. {
  688.   char buff[MAX_FIELD_WIDTH];
  689.   String dummy_str(buff,sizeof(buff));
  690.   Item *item=find_item(&dummy_str);
  691.   longlong res;
  693.   if (!item)
  694.   {
  695.     null_value=1;
  696.     return 0;
  697.   }
  698.   res=item->val_int();
  699.   null_value=item->null_value;
  700.   return res;
  701. }
  703. double Item_func_case::val()
  704. {
  705.   char buff[MAX_FIELD_WIDTH];
  706.   String dummy_str(buff,sizeof(buff));
  707.   Item *item=find_item(&dummy_str);
  708.   double res;
  710.   if (!item)
  711.   {
  712.     null_value=1;
  713.     return 0;
  714.   }
  715.   res=item->val();
  716.   null_value=item->null_value;
  717.   return res;
  718. }
  721. bool
  722. Item_func_case::fix_fields(THD *thd,TABLE_LIST *tables)
  723. {
  724.   if (first_expr && first_expr->fix_fields(thd,tables) ||
  725.       else_expr && else_expr->fix_fields(thd,tables))
  726.     return 1;
  727.   if (Item_func::fix_fields(thd,tables))
  728.     return 1;
  729.   if (first_expr)
  730.   {
  731.     used_tables_cache|=(first_expr)->used_tables();
  732.     const_item_cache&= (first_expr)->const_item();
  733.   }
  734.   if (else_expr)
  735.   {
  736.     used_tables_cache|=(else_expr)->used_tables();
  737.     const_item_cache&= (else_expr)->const_item();
  738.   }
  739.   if (!else_expr || else_expr->maybe_null)
  740.     maybe_null=1; // The result may be NULL
  741.   return 0;
  742. }
  744. void Item_func_case::update_used_tables()
  745. {
  746.   Item_func::update_used_tables();
  747.   if (first_expr)
  748.   {
  749.     used_tables_cache|=(first_expr)->used_tables();
  750.     const_item_cache&= (first_expr)->const_item();
  751.   }
  752.   if (else_expr)
  753.   {
  754.     used_tables_cache|=(else_expr)->used_tables();
  755.     const_item_cache&= (else_expr)->const_item();
  756.   }
  757. }
  760. void Item_func_case::fix_length_and_dec()
  761. {
  762.   max_length=0;
  763.   decimals=0;
  764.   cached_result_type = args[1]->result_type();
  765.   for (uint i=0 ; i < arg_count ; i+=2)
  766.   {
  767.     set_if_bigger(max_length,args[i+1]->max_length);
  768.     set_if_bigger(decimals,args[i+1]->decimals);
  769.   }
  770.   if (else_expr != NULL) 
  771.   {
  772.     set_if_bigger(max_length,else_expr->max_length);
  773.     set_if_bigger(decimals,else_expr->decimals);
  774.   }
  775. }
  777. /* TODO:  Fix this so that it prints the whole CASE expression */
  779. void Item_func_case::print(String *str)
  780. {
  781.   str->append("case "); // Not yet complete
  782. }
  784. /*
  785. ** Coalesce - return first not NULL argument.
  786. */
  788. String *Item_func_coalesce::val_str(String *str)
  789. {
  790.   null_value=0;
  791.   for (uint i=0 ; i < arg_count ; i++)
  792.   {
  793.     if (args[i]->val_str(str) != NULL)
  794.       return args[i]->val_str(str);
  795.   }
  796.   null_value=1;
  797.   return 0;
  798. }
  800. longlong Item_func_coalesce::val_int()
  801. {
  802.   null_value=0;
  803.   for (uint i=0 ; i < arg_count ; i++)
  804.   {
  805.     longlong res=args[i]->val_int();
  806.     if (!args[i]->null_value)
  807.       return res;
  808.   }
  809.   null_value=1;
  810.   return 0;
  811. }
  813. double Item_func_coalesce::val()
  814. {
  815.   null_value=0;
  816.   for (uint i=0 ; i < arg_count ; i++)
  817.   {
  818.     double res=args[i]->val();
  819.     if (!args[i]->null_value)
  820.       return res;
  821.   }
  822.   null_value=1;
  823.   return 0;
  824. }
  827. void Item_func_coalesce::fix_length_and_dec()
  828. {
  829.   max_length=0;
  830.   decimals=0;
  831.   cached_result_type = args[0]->result_type();
  832.   for (uint i=0 ; i < arg_count ; i++)
  833.   {
  834.     set_if_bigger(max_length,args[i]->max_length);
  835.     set_if_bigger(decimals,args[i]->decimals);
  836.   }
  837. }
  839. /****************************************************************************
  840. ** classes and function for the IN operator
  841. ****************************************************************************/
  843. static int cmp_longlong(longlong *a,longlong *b)
  844. {
  845.   return *a < *b ? -1 : *a == *b ? 0 : 1;
  846. }
  848. static int cmp_double(double *a,double *b)
  849. {
  850.   return *a < *b ? -1 : *a == *b ? 0 : 1;
  851. }
  853. int in_vector::find(Item *item)
  854. {
  855.   byte *result=get_value(item);
  856.   if (!result || !used_count)
  857.     return 0; // Null value
  859.   uint start,end;
  860.   start=0; end=used_count-1;
  861.   while (start != end)
  862.   {
  863.     uint mid=(start+end+1)/2;
  864.     int res;
  865.     if ((res=(*compare)(base+mid*size,result)) == 0)
  866.       return 1;
  867.     if (res < 0)
  868.       start=mid;
  869.     else
  870.       end=mid-1;
  871.   }
  872.   return (int) ((*compare)(base+start*size,result) == 0);
  873. }
  876. in_string::in_string(uint elements,qsort_cmp cmp_func)
  877.   :in_vector(elements,sizeof(String),cmp_func),tmp(buff,sizeof(buff))
  878. {}
  880. in_string::~in_string()
  881. {
  882.   for (uint i=0 ; i < count ; i++)
  883.     ((String*) base)[i].free();
  884. }
  886. void in_string::set(uint pos,Item *item)
  887. {
  888.   String *str=((String*) base)+pos;
  889.   String *res=item->val_str(str);
  890.   if (res && res != str)
  891.     *str= *res;
  892. }
  894. byte *in_string::get_value(Item *item)
  895. {
  896.   return (byte*) item->val_str(&tmp);
  897. }
  900. in_longlong::in_longlong(uint elements)
  901.   :in_vector(elements,sizeof(longlong),(qsort_cmp) cmp_longlong)
  902. {}
  904. void in_longlong::set(uint pos,Item *item)
  905. {
  906.   ((longlong*) base)[pos]=item->val_int();
  907. }
  909. byte *in_longlong::get_value(Item *item)
  910. {
  911.   tmp=item->val_int();
  912.   if (item->null_value)
  913.     return 0; /* purecov: inspected */
  914.   return (byte*) &tmp;
  915. }
  918. in_double::in_double(uint elements)
  919.   :in_vector(elements,sizeof(double),(qsort_cmp) cmp_double)
  920. {}
  922. void in_double::set(uint pos,Item *item)
  923. {
  924.   ((double*) base)[pos]=item->val();
  925. }
  927. byte *in_double::get_value(Item *item)
  928. {
  929.   tmp=item->val();
  930.   if (item->null_value)
  931.     return 0; /* purecov: inspected */
  932.   return (byte*) &tmp;
  933. }
  936. void Item_func_in::fix_length_and_dec()
  937. {
  938.   if (const_item())
  939.   {
  940.     switch (item->result_type()) {
  941.     case STRING_RESULT:
  942.       if (item->binary)
  943. array=new in_string(arg_count,(qsort_cmp) stringcmp); /* purecov: inspected */
  944.       else
  945. array=new in_string(arg_count,(qsort_cmp) sortcmp);
  946.       break;
  947.     case INT_RESULT:
  948.       array= new in_longlong(arg_count);
  949.       break;
  950.     case REAL_RESULT:
  951.       array= new in_double(arg_count);
  952.       break;
  953.     }
  954.     uint j=0;
  955.     for (uint i=0 ; i < arg_count ; i++)
  956.     {
  957.       array->set(j,args[i]);
  958.       if (!args[i]->null_value) // Skipp NULL values
  959. j++;
  960.     }
  961.     if ((array->used_count=j))
  962.       array->sort();
  963.   }
  964.   else
  965.   {
  966.     switch (item->result_type()) {
  967.     case STRING_RESULT:
  968.       if (item->binary)
  969. in_item= new cmp_item_binary_string;
  970.       else
  971. in_item= new cmp_item_sort_string;
  972.       break;
  973.     case INT_RESULT:
  974.       in_item=   new cmp_item_int;
  975.       break;
  976.     case REAL_RESULT:
  977.       in_item=   new cmp_item_real;
  978.       break;
  979.     }
  980.   }
  981.   maybe_null= item->maybe_null;
  982.   max_length=2;
  983.   used_tables_cache|=item->used_tables();
  984.   const_item_cache&=item->const_item();
  985. }
  988. void Item_func_in::print(String *str)
  989. {
  990.   str->append('(');
  991.   item->print(str);
  992.   Item_func::print(str);
  993.   str->append(')');
  994. }
  997. longlong Item_func_in::val_int()
  998. {
  999.   if (array)
  1000.   {
  1001.     int tmp=array->find(item);
  1002.     null_value=item->null_value;
  1003.     return tmp;
  1004.   }
  1005.   in_item->store_value(item);
  1006.   if ((null_value=item->null_value))
  1007.     return 0;
  1008.   for (uint i=0 ; i < arg_count ; i++)
  1009.   {
  1010.     if (!in_item->cmp(args[i]) && !args[i]->null_value)
  1011.       return 1; // Would maybe be nice with i ?
  1012.   }
  1013.   return 0;
  1014. }
  1017. void Item_func_in::update_used_tables()
  1018. {
  1019.   Item_func::update_used_tables();
  1020.   item->update_used_tables();
  1021.   used_tables_cache|=item->used_tables();
  1022.   const_item_cache&=item->const_item();
  1023. }
  1026. longlong Item_func_bit_or::val_int()
  1027. {
  1028.   ulonglong arg1= (ulonglong) args[0]->val_int();
  1029.   if (args[0]->null_value)
  1030.   {
  1031.     null_value=1; /* purecov: inspected */
  1032.     return 0; /* purecov: inspected */
  1033.   }
  1034.   ulonglong arg2= (ulonglong) args[1]->val_int();
  1035.   if (args[1]->null_value)
  1036.   {
  1037.     null_value=1;
  1038.     return 0;
  1039.   }
  1040.   null_value=0;
  1041.   return (longlong) (arg1 | arg2);
  1042. }
  1045. longlong Item_func_bit_and::val_int()
  1046. {
  1047.   ulonglong arg1= (ulonglong) args[0]->val_int();
  1048.   if (args[0]->null_value)
  1049.   {
  1050.     null_value=1; /* purecov: inspected */
  1051.     return 0; /* purecov: inspected */
  1052.   }
  1053.   ulonglong arg2= (ulonglong) args[1]->val_int();
  1054.   if (args[1]->null_value)
  1055.   {
  1056.     null_value=1; /* purecov: inspected */
  1057.     return 0; /* purecov: inspected */
  1058.   }
  1059.   null_value=0;
  1060.   return (longlong) (arg1 & arg2);
  1061. }
  1064. bool
  1065. Item_cond::fix_fields(THD *thd,TABLE_LIST *tables)
  1066. {
  1067.   List_iterator<Item> li(list);
  1068.   Item *item;
  1069.   char buff[sizeof(char*)]; // Max local vars in function
  1070.   used_tables_cache=0;
  1071.   const_item_cache=0;
  1073.   if (thd && check_stack_overrun(thd,buff))
  1074.     return 0; // Fatal error flag is set!
  1075.   while ((item=li++))
  1076.   {
  1077.     while (item->type() == Item::COND_ITEM &&
  1078.    ((Item_cond*) item)->functype() == functype())
  1079.     { // Identical function
  1080.       li.replace(((Item_cond*) item)->list);
  1081.       ((Item_cond*) item)->list.empty();
  1082. #ifdef DELETE_ITEMS
  1083.       delete (Item_cond*) item;
  1084. #endif
  1085.       item= *li.ref(); // new current item
  1086.     }
  1087.     if (item->fix_fields(thd,tables))
  1088.       return 1; /* purecov: inspected */
  1089.     used_tables_cache|=item->used_tables();
  1090.     with_sum_func= with_sum_func || item->with_sum_func;
  1091.     const_item_cache&=item->const_item();
  1092.   }
  1093.   if (thd)
  1094.     thd->cond_count+=list.elements;
  1095.   fix_length_and_dec();
  1096.   return 0;
  1097. }
  1100. void Item_cond::split_sum_func(List<Item> &fields)
  1101. {
  1102.   List_iterator<Item> li(list);
  1103.   Item *item;
  1104.   used_tables_cache=0;
  1105.   const_item_cache=0;
  1106.   while ((item=li++))
  1107.   {
  1108.     if (item->with_sum_func && item->type() != SUM_FUNC_ITEM)
  1109.       item->split_sum_func(fields);
  1110.     else if (item->used_tables() || item->type() == SUM_FUNC_ITEM)
  1111.     {
  1112.       fields.push_front(item);
  1113.       li.replace(new Item_ref((Item**) fields.head_ref(),0,item->name));
  1114.     }
  1115.     item->update_used_tables();
  1116.     used_tables_cache|=item->used_tables();
  1117.     const_item_cache&=item->const_item();
  1118.   }
  1119. }
  1122. table_map
  1123. Item_cond::used_tables() const
  1124. { // This caches used_tables
  1125.   return used_tables_cache;
  1126. }
  1128. void Item_cond::update_used_tables()
  1129. {
  1130.   used_tables_cache=0;
  1131.   const_item_cache=1;
  1132.   List_iterator<Item> li(list);
  1133.   Item *item;
  1134.   while ((item=li++))
  1135.   {
  1136.     item->update_used_tables();
  1137.     used_tables_cache|=item->used_tables();
  1138.     const_item_cache&= item->const_item();
  1139.   }
  1140. }
  1143. void Item_cond::print(String *str)
  1144. {
  1145.   str->append('(');
  1146.   List_iterator<Item> li(list);
  1147.   Item *item;
  1148.   if ((item=li++))
  1149.     item->print(str);
  1150.   while ((item=li++))
  1151.   {
  1152.     str->append(' ');
  1153.     str->append(func_name());
  1154.     str->append(' ');
  1155.     item->print(str);
  1156.   }
  1157.   str->append(')');
  1158. }
  1161. longlong Item_cond_and::val_int()
  1162. {
  1163.   List_iterator<Item> li(list);
  1164.   Item *item;
  1165.   while ((item=li++))
  1166.   {
  1167.     if (item->val_int() == 0)
  1168.     {
  1169.       /* TODO: In case of NULL, ANSI would require us to continue evaluation
  1170.  until we get a FALSE value or run out of values; This would
  1171.  require a lot of unnecessary evaluation, which we skip for now */
  1172.       null_value=item->null_value;
  1173.       return 0;
  1174.     }
  1175.   }
  1176.   null_value=0;
  1177.   return 1;
  1178. }
  1180. longlong Item_cond_or::val_int()
  1181. {
  1182.   List_iterator<Item> li(list);
  1183.   Item *item;
  1184.   null_value=0;
  1185.   while ((item=li++))
  1186.   {
  1187.     if (item->val_int() != 0)
  1188.     {
  1189.       null_value=0;
  1190.       return 1;
  1191.     }
  1192.     if (item->null_value)
  1193.       null_value=1;
  1194.   }
  1195.   return 0;
  1196. }
  1198. longlong Item_func_isnull::val_int()
  1199. {
  1200.   (void) args[0]->val();
  1201.   return (args[0]->null_value) ? 1 : 0;
  1202. }
  1204. longlong Item_func_isnotnull::val_int()
  1205. {
  1206.   (void) args[0]->val();
  1207.   return !(args[0]->null_value) ? 1 : 0;
  1208. }
  1211. void Item_func_like::fix_length_and_dec()
  1212. {
  1213.   decimals=0; max_length=1;
  1214.   //  cmp_type=STRING_RESULT; // For quick select
  1215. }
  1218. longlong Item_func_like::val_int()
  1219. {
  1220.   String *res,*res2;
  1221.   res=args[0]->val_str(&tmp_value1);
  1222.   if (args[0]->null_value)
  1223.   {
  1224.     null_value=1;
  1225.     return 0;
  1226.   }
  1227.   res2=args[1]->val_str(&tmp_value2);
  1228.   if (args[1]->null_value)
  1229.   {
  1230.     null_value=1;
  1231.     return 0;
  1232.   }
  1233.   null_value=0;
  1234.   if (binary)
  1235.     return wild_compare(*res,*res2,escape) ? 0 : 1;
  1236.   else
  1237.     return wild_case_compare(*res,*res2,escape) ? 0 : 1;
  1238. }
  1241. /* We can optimize a where if first character isn't a wildcard */
  1243. Item_func::optimize_type Item_func_like::select_optimize() const
  1244. {
  1245.   if (args[1]->type() == STRING_ITEM)
  1246.   {
  1247.     if (((Item_string *) args[1])->str_value[0] != wild_many)
  1248.     {
  1249.       if ((args[0]->result_type() != STRING_RESULT) ||
  1250.   ((Item_string *) args[1])->str_value[0] != wild_one)
  1251. return OPTIMIZE_OP;
  1252.     }
  1253.   }
  1254.   return OPTIMIZE_NONE;
  1255. }
  1257. #ifdef USE_REGEX
  1259. bool
  1260. Item_func_regex::fix_fields(THD *thd,TABLE_LIST *tables)
  1261. {
  1262.   if (args[0]->fix_fields(thd,tables) || args[1]->fix_fields(thd,tables))
  1263.     return 1; /* purecov: inspected */
  1264.   with_sum_func=args[0]->with_sum_func || args[1]->with_sum_func;
  1265.   max_length=1; decimals=0;
  1266.   binary=args[0]->binary || args[1]->binary;
  1267.   used_tables_cache=args[0]->used_tables() | args[1]->used_tables();
  1268.   const_item_cache=args[0]->const_item() && args[1]->const_item();
  1269.   if (!regex_compiled && args[1]->const_item())
  1270.   {
  1271.     char buff[MAX_FIELD_WIDTH];
  1272.     String tmp(buff,sizeof(buff));
  1273.     String *res=args[1]->val_str(&tmp);
  1274.     if (args[1]->null_value)
  1275.     { // Will always return NULL
  1276.       maybe_null=1;
  1277.       return 0;
  1278.     }
  1279.     int error;
  1280.     if ((error=regcomp(&preg,res->c_ptr(),
  1281.        binary ? REG_EXTENDED | REG_NOSUB :
  1282.        REG_EXTENDED | REG_NOSUB | REG_ICASE)))
  1283.     {
  1284.       (void) regerror(error,&preg,buff,sizeof(buff));
  1285.       my_printf_error(ER_REGEXP_ERROR,ER(ER_REGEXP_ERROR),MYF(0),buff);
  1286.       return 1;
  1287.     }
  1288.     regex_compiled=regex_is_const=1;
  1289.     maybe_null=args[0]->maybe_null;
  1290.   }
  1291.   else
  1292.     maybe_null=1;
  1293.   return 0;
  1294. }
  1297. longlong Item_func_regex::val_int()
  1298. {
  1299.   char buff[MAX_FIELD_WIDTH];
  1300.   String *res, tmp(buff,sizeof(buff));
  1302.   res=args[0]->val_str(&tmp);
  1303.   if (args[0]->null_value)
  1304.   {
  1305.     null_value=1;
  1306.     return 0;
  1307.   }
  1308.   if (!regex_is_const)
  1309.   {
  1310.     char buff2[MAX_FIELD_WIDTH];
  1311.     String *res2, tmp2(buff2,sizeof(buff2));
  1313.     res2= args[1]->val_str(&tmp2);
  1314.     if (args[1]->null_value)
  1315.     {
  1316.       null_value=1;
  1317.       return 0;
  1318.     }
  1319.     if (!regex_compiled || stringcmp(res2,&prev_regexp))
  1320.     {
  1321.       prev_regexp.copy(*res2);
  1322.       if (regex_compiled)
  1323.       {
  1324. regfree(&preg);
  1325. regex_compiled=0;
  1326.       }
  1327.       if (regcomp(&preg,res2->c_ptr(),
  1328.   binary ? REG_EXTENDED | REG_NOSUB :
  1329.   REG_EXTENDED | REG_NOSUB | REG_ICASE))
  1331.       {
  1332. null_value=1;
  1333. return 0;
  1334.       }
  1335.       regex_compiled=1;
  1336.     }
  1337.   }
  1338.   null_value=0;
  1339.   return regexec(&preg,res->c_ptr(),0,(regmatch_t*) 0,0) ? 0 : 1;
  1340. }
  1343. Item_func_regex::~Item_func_regex()
  1344. {
  1345.   if (regex_compiled)
  1346.   {
  1347.     regfree(&preg);
  1348.     regex_compiled=0;
  1349.   }
  1350. }
  1352. #endif /* USE_REGEX */