home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / item_cmpfunc.cpp < prev    next >
C/C++ Source or Header  |  2000-10-18  |  28KB  |  1,299 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. /* This file defines all compare functions */
  19.  
  20. #ifdef __GNUC__
  21. #pragma implementation                // gcc: Class implementation
  22. #endif
  23.  
  24. #include "mysql_priv.h"
  25. #include <m_ctype.h>
  26.  
  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. */
  32.  
  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. }
  39.  
  40.  
  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. }
  56.  
  57.  
  58. void Item_bool_func2::fix_length_and_dec()
  59. {
  60.   max_length=1;
  61.  
  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. }
  93.  
  94.  
  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. }
  109.  
  110.  
  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. }
  125.  
  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. }
  143.  
  144.  
  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. }
  162.  
  163.  
  164.  
  165. longlong Item_func_eq::val_int()
  166. {
  167.   int value=(this->*cmp_func)();
  168.   return value == 0 ? 1 : 0;
  169. }
  170.  
  171. /* Same as Item_func_eq, but NULL = NULL */
  172.  
  173. longlong Item_func_equal::val_int()
  174. {
  175.   int value=(this->*cmp_func)();
  176.   if (null_value)
  177.   {
  178.     null_value=0;
  179.     return (args[0]->null_value && args[1]->null_value) ? 1 : 0;
  180.   }
  181.   return value == 0;
  182. }
  183.  
  184.  
  185. longlong Item_func_ne::val_int()
  186. {
  187.   int value=(this->*cmp_func)();
  188.   return value != 0 && !null_value ? 1 : 0;
  189. }
  190.  
  191.  
  192. longlong Item_func_ge::val_int()
  193. {
  194.   int value=(this->*cmp_func)();
  195.   return value >= 0 ? 1 : 0;
  196. }
  197.  
  198.  
  199. longlong Item_func_gt::val_int()
  200. {
  201.   int value=(this->*cmp_func)();
  202.   return value > 0 ? 1 : 0;
  203. }
  204.  
  205. longlong Item_func_le::val_int()
  206. {
  207.   int value=(this->*cmp_func)();
  208.   return value <= 0 && !null_value ? 1 : 0;
  209. }
  210.  
  211.  
  212. longlong Item_func_lt::val_int()
  213. {
  214.   int value=(this->*cmp_func)();
  215.   return value < 0 && !null_value ? 1 : 0;
  216. }
  217.  
  218.  
  219. longlong Item_func_strcmp::val_int()
  220. {
  221.   String *a=args[0]->val_str(&tmp_value1);
  222.   String *b=args[1]->val_str(&tmp_value2);
  223.   if (!a || !b)
  224.   {
  225.     null_value=1;
  226.     return 0;
  227.   }
  228.   int value=stringcmp(a,b);
  229.   null_value=0;
  230.   return !value ? 0 : (value < 0 ? (longlong) -1 : (longlong) 1);
  231. }
  232.  
  233.  
  234. void Item_func_interval::fix_length_and_dec()
  235. {
  236.   bool nums=1;
  237.   uint i;
  238.   for (i=0 ; i < arg_count ; i++)
  239.   {
  240.     if (!args[i])
  241.       return;                    // End of memory
  242.     if (args[i]->type() != Item::INT_ITEM &&
  243.     args[i]->type() != Item::REAL_ITEM)
  244.     {
  245.       nums=0;
  246.       break;
  247.     }
  248.   }
  249.   if (nums && arg_count >= 8)
  250.   {
  251.     if ((intervals=(double*) sql_alloc(sizeof(double)*arg_count)))
  252.     {
  253.       for (i=0 ; i < arg_count ; i++)
  254.     intervals[i]=args[i]->val();
  255.     }
  256.   }
  257.   maybe_null=0; max_length=2;
  258.   used_tables_cache|=item->used_tables();
  259. }
  260.  
  261. /*
  262.   return -1 if null value,
  263.       0 if lower than lowest
  264.       1 - arg_count if between args[n] and args[n+1]
  265.       arg_count+1 if higher than biggest argument
  266. */
  267.  
  268. longlong Item_func_interval::val_int()
  269. {
  270.   double value=item->val();
  271.   if (item->null_value)
  272.     return -1;                // -1 if null /* purecov: inspected */
  273.   if (intervals)
  274.   {                    // Use binary search to find interval
  275.     uint start,end;
  276.     start=0; end=arg_count-1;
  277.     while (start != end)
  278.     {
  279.       uint mid=(start+end+1)/2;
  280.       if (intervals[mid] <= value)
  281.     start=mid;
  282.       else
  283.     end=mid-1;
  284.     }
  285.     return (value < intervals[start]) ? 0 : start+1;
  286.   }
  287.   if (args[0]->val() > value)
  288.     return 0;
  289.   for (uint i=1 ; i < arg_count ; i++)
  290.   {
  291.     if (args[i]->val() > value)
  292.       return i;
  293.   }
  294.   return (longlong) arg_count;
  295. }
  296.  
  297.  
  298. void Item_func_interval::update_used_tables()
  299. {
  300.   Item_func::update_used_tables();
  301.   item->update_used_tables();
  302.   used_tables_cache|=item->used_tables();
  303.   const_item_cache&=item->const_item();
  304. }
  305.  
  306. void Item_func_between::fix_length_and_dec()
  307. {
  308.    max_length=1;
  309.  
  310.   /* As some compare functions are generated after sql_yacc,
  311.      we have to check for out of memory conditons here */
  312.   if (!args[0] || !args[1] || !args[2])
  313.     return;
  314.   cmp_type=args[0]->result_type();
  315.   if (args[0]->binary)
  316.     string_compare=stringcmp;
  317.   else
  318.     string_compare=sortcmp;
  319.  
  320.   // Make a special case of compare with fields to get nicer DATE comparisons
  321.   if (args[0]->type() == FIELD_ITEM)
  322.   {
  323.     Field *field=((Item_field*) args[0])->field;
  324.     if (field->store_for_compare())
  325.     {
  326.       if (convert_constant_item(field,&args[1]))
  327.     cmp_type=INT_RESULT;            // Works for all types.
  328.       if (convert_constant_item(field,&args[2]))
  329.     cmp_type=INT_RESULT;            // Works for all types.
  330.     }
  331.   }
  332. }
  333.  
  334.  
  335. longlong Item_func_between::val_int()
  336. {                        // ANSI BETWEEN
  337.   if (cmp_type == STRING_RESULT)
  338.   {
  339.     String *value,*a,*b;
  340.     value=args[0]->val_str(&value0);
  341.     if ((null_value=args[0]->null_value))
  342.       return 0;
  343.     a=args[1]->val_str(&value1);
  344.     b=args[2]->val_str(&value2);
  345.     if (!args[1]->null_value && !args[2]->null_value)
  346.       return (string_compare(value,a) >= 0 && string_compare(value,b) <= 0) ?
  347.     1 : 0;
  348.     if (args[1]->null_value && args[2]->null_value)
  349.       null_value=1;
  350.     else if (args[1]->null_value)
  351.     {
  352.       null_value= string_compare(value,b) <= 0; // not null if false range.
  353.     }
  354.     else
  355.     {
  356.       null_value= string_compare(value,a) >= 0; // not null if false range.
  357.     }
  358.   }
  359.   else if (cmp_type == INT_RESULT)
  360.   {
  361.     longlong value=args[0]->val_int(),a,b;
  362.     if ((null_value=args[0]->null_value))
  363.       return 0; /* purecov: inspected */
  364.     a=args[1]->val_int();
  365.     b=args[2]->val_int();
  366.     if (!args[1]->null_value && !args[2]->null_value)
  367.       return (value >= a && value <= b) ? 1 : 0;
  368.     if (args[1]->null_value && args[2]->null_value)
  369.       null_value=1;
  370.     else if (args[1]->null_value)
  371.     {
  372.       null_value= value <= b;            // not null if false range.
  373.     }
  374.     else
  375.     {
  376.       null_value= value >= a;
  377.     }
  378.   }
  379.   else
  380.   {
  381.     double value=args[0]->val(),a,b;
  382.     if ((null_value=args[0]->null_value))
  383.       return 0; /* purecov: inspected */
  384.     a=args[1]->val();
  385.     b=args[2]->val();
  386.     if (!args[1]->null_value && !args[2]->null_value)
  387.       return (value >= a && value <= b) ? 1 : 0;
  388.     if (args[1]->null_value && args[2]->null_value)
  389.       null_value=1;
  390.     else if (args[1]->null_value)
  391.     {
  392.       null_value= value <= b;            // not null if false range.
  393.     }
  394.     else
  395.     {
  396.       null_value= value >= a;
  397.     }
  398.   }
  399.   return 0;
  400. }
  401.  
  402. void
  403. Item_func_ifnull::fix_length_and_dec()
  404. {
  405.   maybe_null=args[1]->maybe_null;
  406.   max_length=max(args[0]->max_length,args[1]->max_length);
  407.   decimals=max(args[0]->decimals,args[1]->decimals);
  408.   cached_result_type=args[0]->result_type();
  409. }
  410.  
  411. double
  412. Item_func_ifnull::val()
  413. {
  414.   double value=args[0]->val();
  415.   if (!args[0]->null_value)
  416.   {
  417.     null_value=0;
  418.     return value;
  419.   }
  420.   value=args[1]->val();
  421.   if ((null_value=args[1]->null_value))
  422.     return 0.0;
  423.   return value;
  424. }
  425.  
  426. longlong
  427. Item_func_ifnull::val_int()
  428. {
  429.   longlong value=args[0]->val_int();
  430.   if (!args[0]->null_value)
  431.   {
  432.     null_value=0;
  433.     return value;
  434.   }
  435.   value=args[1]->val_int();
  436.   if ((null_value=args[1]->null_value))
  437.     return 0;
  438.   return value;
  439. }
  440.  
  441. String *
  442. Item_func_ifnull::val_str(String *str)
  443. {
  444.   String *res  =args[0]->val_str(str);
  445.   if (!args[0]->null_value)
  446.   {
  447.     null_value=0;
  448.     return res;
  449.   }
  450.   res=args[1]->val_str(str);
  451.   if ((null_value=args[1]->null_value))
  452.     return 0;
  453.   return res;
  454. }
  455.  
  456. void
  457. Item_func_if::fix_length_and_dec()
  458. {
  459.   maybe_null=args[1]->maybe_null || args[2]->maybe_null;
  460.   max_length=max(args[1]->max_length,args[2]->max_length);
  461.   decimals=max(args[0]->decimals,args[1]->decimals);
  462.   enum Item_result arg1_type=args[1]->result_type();
  463.   enum Item_result arg2_type=args[2]->result_type();
  464.   if (arg1_type == STRING_RESULT || arg2_type == STRING_RESULT)
  465.     cached_result_type = STRING_RESULT;
  466.   else if (arg1_type == REAL_RESULT || arg2_type == REAL_RESULT)
  467.     cached_result_type = REAL_RESULT;
  468.   else
  469.     cached_result_type=arg1_type;        // Should be INT_RESULT
  470. }
  471.  
  472.  
  473. double
  474. Item_func_if::val()
  475. {
  476.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  477.   double value=arg->val();
  478.   null_value=arg->null_value;
  479.   return value;
  480. }
  481.  
  482. longlong
  483. Item_func_if::val_int()
  484. {
  485.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  486.   longlong value=arg->val_int();
  487.   null_value=arg->null_value;
  488.   return value;
  489. }
  490.  
  491. String *
  492. Item_func_if::val_str(String *str)
  493. {
  494.   Item *arg= args[0]->val_int() ? args[1] : args[2];
  495.   String *res=arg->val_str(str);
  496.   null_value=arg->null_value;
  497.   return res;
  498. }
  499.  
  500.  
  501. void
  502. Item_func_nullif::fix_length_and_dec()
  503. {
  504.   Item_bool_func2::fix_length_and_dec();
  505.   maybe_null=1;
  506.   if (args[0])                    // Only false if EOM
  507.   {
  508.     max_length=args[0]->max_length;
  509.     decimals=args[0]->decimals;
  510.     cached_result_type=args[0]->result_type();
  511.   }
  512. }
  513.  
  514. /*
  515.   nullif() returns NULL if arguments are different, else it returns the
  516.   first argument.
  517.   Note that we have to evaluate the first argument twice as the compare
  518.   may have been done with a different type than return value
  519. */
  520.  
  521. double
  522. Item_func_nullif::val()
  523. {
  524.   double value;
  525.   if (!(this->*cmp_func)() || null_value)
  526.   {
  527.     null_value=1;
  528.     return 0.0;
  529.   }
  530.   value=args[0]->val();
  531.   null_value=args[0]->null_value;
  532.   return value;
  533. }
  534.  
  535. longlong
  536. Item_func_nullif::val_int()
  537. {
  538.   longlong value;
  539.   if (!(this->*cmp_func)() || null_value)
  540.   {
  541.     null_value=1;
  542.     return 0;
  543.   }
  544.   value=args[0]->val_int();
  545.   null_value=args[0]->null_value;
  546.   return value;
  547. }
  548.  
  549. String *
  550. Item_func_nullif::val_str(String *str)
  551. {
  552.   String *res;
  553.   if (!(this->*cmp_func)() || null_value)
  554.   {
  555.     null_value=1;
  556.     return 0;
  557.   }
  558.   res=args[0]->val_str(str);
  559.   null_value=args[0]->null_value;
  560.   return res;
  561. }
  562.  
  563. /*
  564. ** CASE expression 
  565. */
  566.  
  567. /* Return the matching ITEM or NULL if all compares (including else) failed */
  568.  
  569. Item *Item_func_case::find_item(String *str)
  570. {
  571.   String *first_expr_str,*tmp;
  572.   longlong first_expr_int;
  573.   double   first_expr_real;
  574.   bool int_used, real_used,str_used;
  575.   int_used=real_used=str_used=0;
  576.  
  577.   /* These will be initialized later */
  578.   LINT_INIT(first_expr_str);
  579.   LINT_INIT(first_expr_int);
  580.   LINT_INIT(first_expr_real);
  581.  
  582.   // Compare every WHEN argument with it and return the first match
  583.   for (uint i=0 ; i < arg_count ; i+=2)
  584.   {
  585.     if (!first_expr)
  586.     {
  587.       // No expression between CASE and first WHEN
  588.       if (args[i]->val_int())
  589.     return args[i+1];
  590.       continue;
  591.     }
  592.     switch (args[i]->result_type()) {
  593.     case STRING_RESULT:
  594.       if (!str_used)
  595.       {
  596.     str_used=1;
  597.     // We can't use 'str' here as this may be overwritten
  598.     if (!(first_expr_str= first_expr->val_str(&str_value)))
  599.       return else_expr;            // Impossible
  600.       }
  601.       if ((tmp=args[i]->val_str(str)))        // If not null
  602.       {
  603.     if (first_expr->binary || args[i]->binary)
  604.     {
  605.       if (stringcmp(tmp,first_expr_str)==0)
  606.         return args[i+1];
  607.     }
  608.     else if (sortcmp(tmp,first_expr_str)==0)
  609.       return args[i+1];
  610.       }
  611.       break;
  612.     case INT_RESULT:
  613.       if (!int_used)
  614.       {
  615.     int_used=1;
  616.     first_expr_int= first_expr->val_int();
  617.     if (first_expr->null_value)
  618.       return else_expr;
  619.       }
  620.       if (args[i]->val_int()==first_expr_int && !args[i]->null_value) 
  621.         return args[i+1];
  622.       break;
  623.     case REAL_RESULT: 
  624.       if (!real_used)
  625.       {
  626.     real_used=1;
  627.     first_expr_real= first_expr->val();
  628.     if (first_expr->null_value)
  629.       return else_expr;
  630.       }
  631.       if (args[i]->val()==first_expr_real && !args[i]->null_value) 
  632.         return args[i+1];
  633.     }
  634.   }
  635.   // No, WHEN clauses all missed, return ELSE expression
  636.   return else_expr;
  637. }
  638.  
  639.  
  640.  
  641. String *Item_func_case::val_str(String *str)
  642. {
  643.   String *res;
  644.   Item *item=find_item(str);
  645.  
  646.   if (!item)
  647.   {
  648.     null_value=1;
  649.     return 0;
  650.   }
  651.   if (!(res=item->val_str(str)))
  652.     null_value=1;
  653.   return res;
  654. }
  655.  
  656.  
  657. longlong Item_func_case::val_int()
  658. {
  659.   char buff[MAX_FIELD_WIDTH];
  660.   String dummy_str(buff,sizeof(buff));
  661.   Item *item=find_item(&dummy_str);
  662.   longlong res;
  663.  
  664.   if (!item)
  665.   {
  666.     null_value=1;
  667.     return 0;
  668.   }
  669.   res=item->val_int();
  670.   null_value=item->null_value;
  671.   return res;
  672. }
  673.  
  674. double Item_func_case::val()
  675. {
  676.   char buff[MAX_FIELD_WIDTH];
  677.   String dummy_str(buff,sizeof(buff));
  678.   Item *item=find_item(&dummy_str);
  679.   double res;
  680.  
  681.   if (!item)
  682.   {
  683.     null_value=1;
  684.     return 0;
  685.   }
  686.   res=item->val();
  687.   null_value=item->null_value;
  688.   return res;
  689. }
  690.  
  691.  
  692. bool
  693. Item_func_case::fix_fields(THD *thd,TABLE_LIST *tables)
  694. {
  695.  
  696.   if (first_expr && first_expr->fix_fields(thd,tables) ||
  697.       else_expr && else_expr->fix_fields(thd,tables))
  698.     return 1;
  699.   if (Item_func::fix_fields(thd,tables))
  700.     return 1;
  701.   if (!else_expr || else_expr->maybe_null)
  702.     maybe_null=1;                // The result may be NULL
  703.   return 0;
  704. }
  705.  
  706.  
  707. void Item_func_case::fix_length_and_dec()
  708. {
  709.   max_length=0;
  710.   decimals=0;
  711.   cached_result_type = args[1]->result_type();
  712.   for (uint i=0 ; i < arg_count ; i+=2)
  713.   {
  714.     set_if_bigger(max_length,args[i+1]->max_length);
  715.     set_if_bigger(decimals,args[i+1]->decimals);
  716.   }
  717.   if (else_expr != NULL) 
  718.   {
  719.     set_if_bigger(max_length,else_expr->max_length);
  720.     set_if_bigger(decimals,else_expr->decimals);
  721.   }
  722. }
  723.  
  724.  
  725. void Item_func_case::print(String *str)
  726. {
  727.   str->append("case ");                // Not yet complete
  728. }
  729.  
  730. /*
  731. ** Coalesce - return first not NULL argument.
  732. */
  733.  
  734. String *Item_func_coalesce::val_str(String *str)
  735. {
  736.   null_value=0;
  737.   for (uint i=0 ; i < arg_count ; i++)
  738.   {
  739.     if (args[i]->val_str(str) != NULL)
  740.       return args[i]->val_str(str);
  741.   }
  742.   null_value=1;
  743.   return 0;
  744. }
  745.  
  746. longlong Item_func_coalesce::val_int()
  747. {
  748.   null_value=0;
  749.   for (uint i=0 ; i < arg_count ; i++)
  750.   {
  751.     longlong res=args[i]->val_int();
  752.     if (!args[i]->null_value)
  753.       return res;
  754.   }
  755.   null_value=1;
  756.   return 0;
  757. }
  758.  
  759. double Item_func_coalesce::val()
  760. {
  761.   null_value=0;
  762.   for (uint i=0 ; i < arg_count ; i++)
  763.   {
  764.     double res=args[i]->val();
  765.     if (!args[i]->null_value)
  766.       return res;
  767.   }
  768.   null_value=1;
  769.   return 0;
  770. }
  771.  
  772.  
  773. void Item_func_coalesce::fix_length_and_dec()
  774. {
  775.   max_length=0;
  776.   decimals=0;
  777.   cached_result_type = args[0]->result_type();
  778.   for (uint i=0 ; i < arg_count ; i++)
  779.   {
  780.     set_if_bigger(max_length,args[i]->max_length);
  781.     set_if_bigger(decimals,args[i]->decimals);
  782.   }
  783. }
  784.  
  785. /****************************************************************************
  786. ** classes and function for the IN operator
  787. ****************************************************************************/
  788.  
  789. static int cmp_longlong(longlong *a,longlong *b)
  790. {
  791.   return *a < *b ? -1 : *a == *b ? 0 : 1;
  792. }
  793.  
  794. static int cmp_double(double *a,double *b)
  795. {
  796.   return *a < *b ? -1 : *a == *b ? 0 : 1;
  797. }
  798.  
  799. int in_vector::find(Item *item)
  800. {
  801.   byte *result=get_value(item);
  802.   if (!result || !used_count)
  803.     return 0;                // Null value
  804.  
  805.   uint start,end;
  806.   start=0; end=used_count-1;
  807.   while (start != end)
  808.   {
  809.     uint mid=(start+end+1)/2;
  810.     int res;
  811.     if ((res=(*compare)(base+mid*size,result)) == 0)
  812.       return 1;
  813.     if (res < 0)
  814.       start=mid;
  815.     else
  816.       end=mid-1;
  817.   }
  818.   return (int) ((*compare)(base+start*size,result) == 0);
  819. }
  820.  
  821.  
  822. in_string::in_string(uint elements,qsort_cmp cmp_func)
  823.   :in_vector(elements,sizeof(String),cmp_func),tmp(buff,sizeof(buff))
  824. {}
  825.  
  826. in_string::~in_string()
  827. {
  828.   for (uint i=0 ; i < count ; i++)
  829.     ((String*) base)[i].free();
  830. }
  831.  
  832. void in_string::set(uint pos,Item *item)
  833. {
  834.   String *str=((String*) base)+pos;
  835.   String *res=item->val_str(str);
  836.   if (res && res != str)
  837.     *str= *res;
  838. }
  839.  
  840. byte *in_string::get_value(Item *item)
  841. {
  842.   return (byte*) item->val_str(&tmp);
  843. }
  844.  
  845.  
  846. in_longlong::in_longlong(uint elements)
  847.   :in_vector(elements,sizeof(longlong),(qsort_cmp) cmp_longlong)
  848. {}
  849.  
  850. void in_longlong::set(uint pos,Item *item)
  851. {
  852.   ((longlong*) base)[pos]=item->val_int();
  853. }
  854.  
  855. byte *in_longlong::get_value(Item *item)
  856. {
  857.   tmp=item->val_int();
  858.   if (item->null_value)
  859.     return 0; /* purecov: inspected */
  860.   return (byte*) &tmp;
  861. }
  862.  
  863.  
  864. in_double::in_double(uint elements)
  865.   :in_vector(elements,sizeof(double),(qsort_cmp) cmp_double)
  866. {}
  867.  
  868. void in_double::set(uint pos,Item *item)
  869. {
  870.   ((double*) base)[pos]=item->val();
  871. }
  872.  
  873. byte *in_double::get_value(Item *item)
  874. {
  875.   tmp=item->val();
  876.   if (item->null_value)
  877.     return 0; /* purecov: inspected */
  878.   return (byte*) &tmp;
  879. }
  880.  
  881.  
  882. void Item_func_in::fix_length_and_dec()
  883. {
  884.   if (const_item())
  885.   {
  886.     switch (item->result_type()) {
  887.     case STRING_RESULT:
  888.       if (item->binary)
  889.     array=new in_string(arg_count,(qsort_cmp) stringcmp); /* purecov: inspected */
  890.       else
  891.     array=new in_string(arg_count,(qsort_cmp) sortcmp);
  892.       break;
  893.     case INT_RESULT:
  894.       array= new in_longlong(arg_count);
  895.       break;
  896.     case REAL_RESULT:
  897.       array= new in_double(arg_count);
  898.       break;
  899.     }
  900.     uint j=0;
  901.     for (uint i=0 ; i < arg_count ; i++)
  902.     {
  903.       array->set(j,args[i]);
  904.       if (!args[i]->null_value)            // Skipp NULL values
  905.     j++;
  906.     }
  907.     if ((array->used_count=j))
  908.       array->sort();
  909.   }
  910.   else
  911.   {
  912.     switch (item->result_type()) {
  913.     case STRING_RESULT:
  914.       if (item->binary)
  915.     in_item= new cmp_item_binary_string;
  916.       else
  917.     in_item= new cmp_item_sort_string;
  918.       break;
  919.     case INT_RESULT:
  920.       in_item=      new cmp_item_int;
  921.       break;
  922.     case REAL_RESULT:
  923.       in_item=      new cmp_item_real;
  924.       break;
  925.     }
  926.   }
  927.   maybe_null= item->maybe_null;
  928.   max_length=2;
  929.   used_tables_cache|=item->used_tables();
  930.   const_item_cache&=item->const_item();
  931. }
  932.  
  933.  
  934. void Item_func_in::print(String *str)
  935. {
  936.   str->append('(');
  937.   item->print(str);
  938.   Item_func::print(str);
  939.   str->append(')');
  940. }
  941.  
  942.  
  943. longlong Item_func_in::val_int()
  944. {
  945.   if (array)
  946.   {
  947.     int tmp=array->find(item);
  948.     null_value=item->null_value;
  949.     return tmp;
  950.   }
  951.   in_item->store_value(item);
  952.   if ((null_value=item->null_value))
  953.     return 0;
  954.   for (uint i=0 ; i < arg_count ; i++)
  955.   {
  956.     if (!in_item->cmp(args[i]) && !args[i]->null_value)
  957.       return 1;                    // Would maybe be nice with i ?
  958.   }
  959.   return 0;
  960. }
  961.  
  962.  
  963. void Item_func_in::update_used_tables()
  964. {
  965.   Item_func::update_used_tables();
  966.   item->update_used_tables();
  967.   used_tables_cache|=item->used_tables();
  968.   const_item_cache&=item->const_item();
  969. }
  970.  
  971.  
  972. longlong Item_func_bit_or::val_int()
  973. {
  974.   ulonglong arg1= (ulonglong) args[0]->val_int();
  975.   if (args[0]->null_value)
  976.   {
  977.     null_value=1; /* purecov: inspected */
  978.     return 0; /* purecov: inspected */
  979.   }
  980.   ulonglong arg2= (ulonglong) args[1]->val_int();
  981.   if (args[1]->null_value)
  982.   {
  983.     null_value=1;
  984.     return 0;
  985.   }
  986.   null_value=0;
  987.   return (longlong) (arg1 | arg2);
  988. }
  989.  
  990.  
  991. longlong Item_func_bit_and::val_int()
  992. {
  993.   ulonglong arg1= (ulonglong) args[0]->val_int();
  994.   if (args[0]->null_value)
  995.   {
  996.     null_value=1; /* purecov: inspected */
  997.     return 0; /* purecov: inspected */
  998.   }
  999.   ulonglong arg2= (ulonglong) args[1]->val_int();
  1000.   if (args[1]->null_value)
  1001.   {
  1002.     null_value=1; /* purecov: inspected */
  1003.     return 0; /* purecov: inspected */
  1004.   }
  1005.   null_value=0;
  1006.   return (longlong) (arg1 & arg2);
  1007. }
  1008.  
  1009.  
  1010. bool
  1011. Item_cond::fix_fields(THD *thd,TABLE_LIST *tables)
  1012. {
  1013.   List_iterator<Item> li(list);
  1014.   Item *item;
  1015.   char buff[sizeof(char*)];            // Max local vars in function
  1016.   used_tables_cache=0;
  1017.   const_item_cache=0;
  1018.  
  1019.   if (thd && check_stack_overrun(thd,buff))
  1020.     return 0;                    // Fatal error flag is set!
  1021.   while ((item=li++))
  1022.   {
  1023.     while (item->type() == Item::COND_ITEM &&
  1024.        ((Item_cond*) item)->functype() == functype())
  1025.     {                        // Identical function
  1026.       li.replace(((Item_cond*) item)->list);
  1027.       ((Item_cond*) item)->list.empty();
  1028. #ifdef DELETE_ITEMS
  1029.       delete (Item_cond*) item;
  1030. #endif
  1031.       item= *li.ref();                // new current item
  1032.     }
  1033.     if (item->fix_fields(thd,tables))
  1034.       return 1; /* purecov: inspected */
  1035.     used_tables_cache|=item->used_tables();
  1036.     with_sum_func= with_sum_func || item->with_sum_func;
  1037.     const_item_cache&=item->const_item();
  1038.   }
  1039.   if (thd)
  1040.     thd->cond_count+=list.elements;
  1041.   fix_length_and_dec();
  1042.   return 0;
  1043. }
  1044.  
  1045.  
  1046. void Item_cond::split_sum_func(List<Item> &fields)
  1047. {
  1048.   List_iterator<Item> li(list);
  1049.   Item *item;
  1050.   used_tables_cache=0;
  1051.   const_item_cache=0;
  1052.   while ((item=li++))
  1053.   {
  1054.     if (item->with_sum_func && item->type() != SUM_FUNC_ITEM)
  1055.       item->split_sum_func(fields);
  1056.     else if (item->used_tables() || item->type() == SUM_FUNC_ITEM)
  1057.     {
  1058.       fields.push_front(item);
  1059.       li.replace(new Item_ref((Item**) fields.head_ref(),0,item->name));
  1060.     }
  1061.     item->update_used_tables();
  1062.     used_tables_cache|=item->used_tables();
  1063.     const_item_cache&=item->const_item();
  1064.   }
  1065. }
  1066.  
  1067.  
  1068. table_map
  1069. Item_cond::used_tables() const
  1070. {                        // This caches used_tables
  1071.   return used_tables_cache;
  1072. }
  1073.  
  1074. void Item_cond::update_used_tables()
  1075. {
  1076.   used_tables_cache=0;
  1077.   const_item_cache=1;
  1078.   List_iterator<Item> li(list);
  1079.   Item *item;
  1080.   while ((item=li++))
  1081.   {
  1082.     item->update_used_tables();
  1083.     used_tables_cache|=item->used_tables();
  1084.     const_item_cache&= item->const_item();
  1085.   }
  1086. }
  1087.  
  1088.  
  1089. void Item_cond::print(String *str)
  1090. {
  1091.   str->append('(');
  1092.   List_iterator<Item> li(list);
  1093.   Item *item;
  1094.   if ((item=li++))
  1095.     item->print(str);
  1096.   while ((item=li++))
  1097.   {
  1098.     str->append(' ');
  1099.     str->append(func_name());
  1100.     str->append(' ');
  1101.     item->print(str);
  1102.   }
  1103.   str->append(')');
  1104. }
  1105.  
  1106.  
  1107. longlong Item_cond_and::val_int()
  1108. {
  1109.   List_iterator<Item> li(list);
  1110.   Item *item;
  1111.   while ((item=li++))
  1112.   {
  1113.     if (item->val_int() == 0)
  1114.     {
  1115.       /* TODO: In case of NULL, ANSI would require us to continue evaluation
  1116.      until we get a FALSE value or run out of values; This would
  1117.      require a lot of unnecessary evaluation, which we skip for now */
  1118.       null_value=item->null_value;
  1119.       return 0;
  1120.     }
  1121.   }
  1122.   null_value=0;
  1123.   return 1;
  1124. }
  1125.  
  1126. longlong Item_cond_or::val_int()
  1127. {
  1128.   List_iterator<Item> li(list);
  1129.   Item *item;
  1130.   null_value=0;
  1131.   while ((item=li++))
  1132.   {
  1133.     if (item->val_int() != 0)
  1134.     {
  1135.       null_value=0;
  1136.       return 1;
  1137.     }
  1138.     if (item->null_value)
  1139.       null_value=1;
  1140.   }
  1141.   return 0;
  1142. }
  1143.  
  1144. longlong Item_func_isnull::val_int()
  1145. {
  1146.   (void) args[0]->val();
  1147.   return (args[0]->null_value) ? 1 : 0;
  1148. }
  1149.  
  1150. longlong Item_func_isnotnull::val_int()
  1151. {
  1152.   (void) args[0]->val();
  1153.   return !(args[0]->null_value) ? 1 : 0;
  1154. }
  1155.  
  1156.  
  1157. void Item_func_like::fix_length_and_dec()
  1158. {
  1159.   decimals=0; max_length=1;
  1160.   //  cmp_type=STRING_RESULT;            // For quick select
  1161. }
  1162.  
  1163.  
  1164. longlong Item_func_like::val_int()
  1165. {
  1166.   String *res,*res2;
  1167.   res=args[0]->val_str(&tmp_value1);
  1168.   if (args[0]->null_value)
  1169.   {
  1170.     null_value=1;
  1171.     return 0;
  1172.   }
  1173.   res2=args[1]->val_str(&tmp_value2);
  1174.   if (args[1]->null_value)
  1175.   {
  1176.     null_value=1;
  1177.     return 0;
  1178.   }
  1179.   null_value=0;
  1180.   if (binary)
  1181.     return wild_compare(*res,*res2,escape) ? 0 : 1;
  1182.   else
  1183.     return wild_case_compare(*res,*res2,escape) ? 0 : 1;
  1184. }
  1185.  
  1186.  
  1187. /* We can optimize a where if first character isn't a wildcard */
  1188.  
  1189. Item_func::optimize_type Item_func_like::select_optimize() const
  1190. {
  1191.   if (args[1]->type() == STRING_ITEM)
  1192.   {
  1193.     if (((Item_string *) args[1])->str_value[0] != wild_many)
  1194.     {
  1195.       if ((args[0]->result_type() != STRING_RESULT) ||
  1196.       ((Item_string *) args[1])->str_value[0] != wild_one)
  1197.     return OPTIMIZE_OP;
  1198.     }
  1199.   }
  1200.   return OPTIMIZE_NONE;
  1201. }
  1202.  
  1203. #ifdef USE_REGEX
  1204.  
  1205. bool
  1206. Item_func_regex::fix_fields(THD *thd,TABLE_LIST *tables)
  1207. {
  1208.   if (args[0]->fix_fields(thd,tables) || args[1]->fix_fields(thd,tables))
  1209.     return 1;                    /* purecov: inspected */
  1210.   with_sum_func=args[0]->with_sum_func || args[1]->with_sum_func;
  1211.   max_length=1; decimals=0;
  1212.   binary=args[0]->binary || args[1]->binary;
  1213.   used_tables_cache=args[0]->used_tables() | args[1]->used_tables();
  1214.   const_item_cache=args[0]->const_item() && args[1]->const_item();
  1215.   if (!regex_compiled && args[1]->const_item())
  1216.   {
  1217.     char buff[MAX_FIELD_WIDTH];
  1218.     String tmp(buff,sizeof(buff));
  1219.     String *res=args[1]->val_str(&tmp);
  1220.     if (args[1]->null_value)
  1221.     {                        // Will always return NULL
  1222.       maybe_null=1;
  1223.       return 0;
  1224.     }
  1225.     int error;
  1226.     if ((error=regcomp(&preg,res->c_ptr(),
  1227.                binary ? REG_EXTENDED | REG_NOSUB :
  1228.                REG_EXTENDED | REG_NOSUB | REG_ICASE)))
  1229.     {
  1230.       (void) regerror(error,&preg,buff,sizeof(buff));
  1231.       my_printf_error(ER_REGEXP_ERROR,ER(ER_REGEXP_ERROR),MYF(0),buff);
  1232.       return 1;
  1233.     }
  1234.     regex_compiled=regex_is_const=1;
  1235.     maybe_null=args[0]->maybe_null;
  1236.   }
  1237.   else
  1238.     maybe_null=1;
  1239.   return 0;
  1240. }
  1241.  
  1242.  
  1243. longlong Item_func_regex::val_int()
  1244. {
  1245.   char buff[MAX_FIELD_WIDTH];
  1246.   String *res, tmp(buff,sizeof(buff));
  1247.  
  1248.   res=args[0]->val_str(&tmp);
  1249.   if (args[0]->null_value)
  1250.   {
  1251.     null_value=1;
  1252.     return 0;
  1253.   }
  1254.   if (!regex_is_const)
  1255.   {
  1256.     char buff2[MAX_FIELD_WIDTH];
  1257.     String *res2, tmp2(buff2,sizeof(buff2));
  1258.  
  1259.     res2= args[1]->val_str(&tmp2);
  1260.     if (args[1]->null_value)
  1261.     {
  1262.       null_value=1;
  1263.       return 0;
  1264.     }
  1265.     if (!regex_compiled || stringcmp(res2,&prev_regexp))
  1266.     {
  1267.       prev_regexp.copy(*res2);
  1268.       if (regex_compiled)
  1269.       {
  1270.     regfree(&preg);
  1271.     regex_compiled=0;
  1272.       }
  1273.       if (regcomp(&preg,res2->c_ptr(),
  1274.           binary ? REG_EXTENDED | REG_NOSUB :
  1275.           REG_EXTENDED | REG_NOSUB | REG_ICASE))
  1276.  
  1277.       {
  1278.     null_value=1;
  1279.     return 0;
  1280.       }
  1281.       regex_compiled=1;
  1282.     }
  1283.   }
  1284.   null_value=0;
  1285.   return regexec(&preg,res->c_ptr(),0,(regmatch_t*) 0,0) ? 0 : 1;
  1286. }
  1287.  
  1288.  
  1289. Item_func_regex::~Item_func_regex()
  1290. {
  1291.   if (regex_compiled)
  1292.   {
  1293.     regfree(&preg);
  1294.     regex_compiled=0;
  1295.   }
  1296. }
  1297.  
  1298. #endif /* USE_REGEX */
  1299.