bug (17/26)

[Brian Grossman]

  void update_field(int offset);
  char *func_name() const { return "count"; }
};


class Item_sum_avg :public Item_sum_num
{
  void fix_length_and_dec() { decimals+=4; maybe_null=1; }

  double sum;
  ulong count;

  public:
  Item_sum_avg(Item *item_par) :Item_sum_num(item_par),count(0) {}
  enum Sumfunctype sum_func () const {return AVG_FUNC;}
  void reset();
  void add();
  double val();
  void reset_field();
  void update_field(int offset);
  char *func_name() const { return "avg"; }
};


class Item_sum_std :public Item_sum_num
{
  double sum;
  double sum_sqr;
  ulong count;
  void fix_length_and_dec() { decimals+=4; maybe_null=1; }

  public:
  Item_sum_std(Item *item_par) :Item_sum_num(item_par),count(0) {}
  enum Sumfunctype sum_func () const { return STD_FUNC; }
  void reset();
  void add();
  double val();
  void reset_field();
  void update_field(int offset);
  char *func_name() const { return "std"; }
};


 

class Item_sum_hybrid :public Item_sum
{
 protected:
  String value,tmp_value;
  double sum;
  Item_result hybrid_type;
  int cmp_sign;

  public:
  Item_sum_hybrid(Item *item_par,int sign) :Item_sum(item_par),cmp_sign(sign) {}
  bool fix_fields(THD *,struct st_table_list *);

  void reset()
  {
    sum=0.0;
    value.length(0);
    null_value=1;
    add();
  }
  double val();
  longlong val_int() { return (longlong) val(); }  
  void reset_field();
  String *str(String *);

  bool keep_field_type(void) const { return 1; }
  enum Item_result result_type () const { return hybrid_type; }
  void update_field(int offset);
  void min_max_update_str_field(int offset);
  void min_max_update_real_field(int offset);
  void min_max_update_int_field(int offset);
};


class Item_sum_min :public Item_sum_hybrid
{
public:
  Item_sum_min(Item *item_par) :Item_sum_hybrid(item_par,1) {}
  enum Sumfunctype sum_func () const {return MIN_FUNC;}

  void add();
  char *func_name() const { return "min"; }
};


class Item_sum_max :public Item_sum_hybrid
{
public:
  Item_sum_max(Item *item_par) :Item_sum_hybrid(item_par,-1) {}
  enum Sumfunctype sum_func () const {return MAX_FUNC;}

  void add();
  char *func_name() const { return "max"; }
};


class Item_sum_bit :public Item_sum_int
{
  void fix_length_and_dec()
    { decimals=0; max_length=21; maybe_null=null_value=0; }

 protected:
  ulonglong bits,reset_bits;

  public:
  Item_sum_bit(Item *item_par,ulonglong reset_arg)
    :Item_sum_int(item_par),reset_bits(reset_arg) {}
  enum Sumfunctype sum_func () const {return SUM_BIT_FUNC;}
  void reset();
  longlong val_int();
  void reset_field();
};


class Item_sum_or :public Item_sum_bit
{
  public:
  Item_sum_or(Item *item_par) :Item_sum_bit(item_par, 0LL ) {}
  void add();
  void update_field(int offset);
  char *func_name() const { return "bit_or"; }
};


class Item_sum_and :public Item_sum_bit
{
  public:
  Item_sum_and(Item *item_par) :Item_sum_bit(item_par,(ulonglong)  ~0LL ) {}
  void add();
  void update_field(int offset);
  char *func_name() const { return "bit_and"; }
};


 

class Item_avg_field :public Item_result_field
{
public:
  Field *field;
  Item_avg_field(Item_sum_avg *item);
  enum Type type() const { return FIELD_AVG_ITEM; }
  double val();
  longlong val_int() { return (longlong) val(); }
  String *str(String*);
  void make_field(Send_field *field);
};


class Item_std_field :public Item_result_field
{
public:
  Field *field;
  Item_std_field(Item_sum_std *item);
  enum Type type() const { return FIELD_STD_ITEM; }
  double val();
  longlong val_int() { return (longlong) val(); }
  String *str(String*);
  void make_field(Send_field *field);
};
# 295 "item.h" 2

# 1 "item_func.h" 1
 













 


#pragma interface			









class Item_func :public Item_result_field
{
protected:
  Item **args;
  uint arg_count;
public:
  table_map used_tables_cache;
  enum Functype { UNKNOWN_FUNC,EQ_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,GE_FUNC,GT_FUNC,
		  LIKE_FUNC,NOTLIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
		  COND_AND_FUNC,COND_OR_FUNC,BETWEEN,IN_FUNC,INTERVAL_FUNC};
  enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP };
  enum Type type() const { return FUNC_ITEM; }
  virtual enum Functype functype() const   { return UNKNOWN_FUNC; }
  Item_func(void)
  {
    arg_count=0;
  }
  Item_func(Item *a)
  {
    arg_count=1;
    args=(Item**) sql_alloc(sizeof(Item*));
    args[0]=a;
  }
  Item_func(Item *a,Item *b)
  {
    arg_count=2;
    args=(Item**) sql_alloc(sizeof(Item*)*2);
    args[0]=a; args[1]=b;
  }
  Item_func(Item *a,Item *b,Item *c)
  {
    arg_count=3;
    args=(Item**) sql_alloc(sizeof(Item*)*3);
    args[0]=a; args[1]=b; args[2]=c;
  }
  Item_func(Item *a,Item *b,Item *c,Item *d)
  {
    arg_count=4;
    args=(Item**) sql_alloc(sizeof(Item*)*4);
    args[0]=a; args[1]=b; args[2]=c; args[3]=d;
  }
  Item_func(List<Item> &list);
  ~Item_func();
  bool fix_fields(THD *,struct st_table_list *);
  void make_field(Send_field *field);
  ulong used_tables() const;
  void update_used_tables();
  virtual void fix_length_and_dec()=0;
  virtual optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  virtual Item *key_item() const { return args[0]; }
  virtual char *func_name() const { return "?"; }
  inline Item **arguments() const { return args; }
  inline uint argument_count() const { return arg_count; }
  inline void remove_arguments() { arg_count=0; }
  void split_sum_func(List<Item> &fields);
  void print(String *str);
  void print_op(String *str);
  void fix_num_length_and_dec();
};


class Item_num_func :public Item_func
{
public:
  Item_num_func() :Item_func() {}
  Item_num_func(Item *a) :Item_func(a) {}
  Item_num_func(Item *a,Item *b) :Item_func(a,b) {}
  Item_num_func(List<Item> &list) :Item_func(list) {}
  String *str(String*str);
  longlong val_int() { return (longlong) val(); }
  enum Item_result result_type () const { return REAL_RESULT; }
  void fix_length_and_dec() { fix_num_length_and_dec(); }
};


class Item_num_op :public Item_num_func
{
 public:
  Item_num_op(Item *a,Item *b) :Item_num_func(a,b) {}
  void print(String *str) { print_op(str); }
};


class Item_int_func :public Item_func
{
public:
  Item_int_func() :Item_func() {}
  Item_int_func(Item *a) :Item_func(a) {}
  Item_int_func(Item *a,Item *b) :Item_func(a,b) {}
  Item_int_func(Item *a,Item *b,Item *c) :Item_func(a,b,c) {}
  Item_int_func(List<Item> &list) :Item_func(list) {}
  double val() { return (double) val_int(); }
  String *str(String*str);
  enum Item_result result_type () const { return INT_RESULT; }
  void fix_length_and_dec() { decimals=0; max_length=21; }
};

class Item_func_plus :public Item_num_op
{
public:
  Item_func_plus(Item *a,Item *b) :Item_num_op(a,b) {}
  char *func_name() const { return "+"; }
  double val();
};

class Item_func_minus :public Item_num_op
{
public:
  Item_func_minus(Item *a,Item *b) :Item_num_op(a,b) {}
  char *func_name() const { return "-"; }
  double val();
};

class Item_func_mul :public Item_num_op
{
public:
  Item_func_mul(Item *a,Item *b) :Item_num_op(a,b) {}
  char *func_name() const { return "*"; }
  double val();
};


class Item_func_div :public Item_num_op
{
public:
  Item_func_div(Item *a,Item *b) :Item_num_op(a,b) {}
  double val();
  char *func_name() const { return "/"; }
  void fix_length_and_dec();
};


class Item_func_mod :public Item_num_op
{
public:
  Item_func_mod(Item *a,Item *b) :Item_num_op(a,b) {}
  longlong val_int();
  double val();
  char *func_name() const { return "%"; }
  void fix_length_and_dec();
};


class Item_func_neg :public Item_num_func
{
public:
  Item_func_neg(Item *a) :Item_num_func(a) {}
  double val();
  char *func_name() const { return "-"; }
  void fix_length_and_dec();
};

class Item_func_abs :public Item_num_func
{
public:
  Item_func_abs(Item *a) :Item_num_func(a) {}
  char *func_name() const { return "abs"; }
  double val();
};

 

class Item_dec_func :public Item_num_func
{
 public:
  Item_dec_func(Item *a) :Item_num_func(a) {}
  Item_dec_func(Item *a,Item *b) :Item_num_func(a,b) {}
  void fix_length_and_dec()
  {
    decimals=6; max_length=float_length(decimals);
    maybe_null=1;
  }
  inline double fix_result(double value)
  {

    if (finite(value) && value != 1.7976931348623157e+308  )
      return value;

    null_value=1;
    return 0.0;
  }
};

class Item_func_exp :public Item_dec_func
{
public:
  Item_func_exp(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "exp"; }
};

class Item_func_log :public Item_dec_func
{
public:
  Item_func_log(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "log"; }
};


class Item_func_log10 :public Item_dec_func
{
public:
  Item_func_log10(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "log10"; }
};


class Item_func_sqrt :public Item_dec_func
{
public:
  Item_func_sqrt(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "sqrt"; }
};


class Item_func_pow :public Item_dec_func
{
public:
  Item_func_pow(Item *a,Item *b) :Item_dec_func(a,b) {}
  double val();
  char *func_name() const { return "pow"; }
};


class Item_func_acos :public Item_dec_func
{
 public:
  Item_func_acos(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "acos"; }
};

class Item_func_asin :public Item_dec_func
{
 public:
  Item_func_asin(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "asin"; }
};

class Item_func_atan :public Item_dec_func
{
 public:
  Item_func_atan(Item *a) :Item_dec_func(a) {}
  Item_func_atan(Item *a,Item *b) :Item_dec_func(a,b) {}
  double val();
  char *func_name() const { return "atan"; }
};

class Item_func_cos :public Item_dec_func
{
 public:
  Item_func_cos(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "cos"; }
};

class Item_func_sin :public Item_dec_func
{
 public:
  Item_func_sin(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "sin"; }
};

class Item_func_tan :public Item_dec_func
{
 public:
  Item_func_tan(Item *a) :Item_dec_func(a) {}
  double val();
  char *func_name() const { return "tan"; }
};

class Item_func_integer :public Item_int_func
{
public:
  Item_func_integer(Item *a) :Item_int_func(a) {}
  void fix_length_and_dec();
};


class Item_func_ceiling :public Item_func_integer
{
public:
  Item_func_ceiling(Item *a) :Item_func_integer(a) {}
  char *func_name() const { return "ceiling"; }
  longlong val_int();
};

class Item_func_floor :public Item_func_integer
{
public:
  Item_func_floor(Item *a) :Item_func_integer(a) {}
  char *func_name() const { return "floor"; }
  longlong val_int();
};

 

class Item_func_round :public Item_num_func
{
  bool truncate;
public:
  Item_func_round(Item *a,Item *b,bool trunc_arg)
    :Item_num_func(a,b),truncate(trunc_arg) {}
  char *func_name() const { return truncate ? "truncate" : "round"; }
  double val();
  void fix_length_and_dec();
};


class Item_func_rand :public Item_num_func
{
public:
  Item_func_rand(Item *a) :Item_num_func(a) {}
  Item_func_rand()	  :Item_num_func()  {}
  double val();
  char *func_name() const { return "rand"; }
  void fix_length_and_dec() { max_length=6; decimals=4; }
};


class Item_func_sign :public Item_int_func
{
public:
  Item_func_sign(Item *a) :Item_int_func(a) {}
  char *func_name() const { return "sign"; }
  longlong val_int();
};


class Item_func_units :public Item_num_func
{
  char *name;
  double mul,add;
 public:
  Item_func_units(char *name_arg,Item *a,double mul_arg,double add_arg)
    :Item_num_func(a),name(name_arg),mul(mul_arg),add(add_arg) {}
  double val();
  char *func_name() const { return name; }
  void fix_length_and_dec() { decimals=6; max_length=float_length(decimals); }
};


class Item_func_min_max :public Item_num_func
{
public:
  Item_func_min_max(List<Item> &list) :Item_num_func(list) {}
  void fix_length_and_dec();
};

class Item_func_min :public Item_func_min_max
{
public:
  Item_func_min(List<Item> &list) :Item_func_min_max(list) {}
  double val();
  char *func_name() const { return "min"; }
};

class Item_func_max :public Item_func_min_max
{
public:
  Item_func_max(List<Item> &list) :Item_func_min_max(list) {}
  double val();
  char *func_name() const { return "max"; }
};


class Item_func_length :public Item_int_func
{
  String value;
public:
  Item_func_length(Item *a) :Item_int_func(a) {}
  longlong val_int();
  char *func_name() const { return "length"; }
  void fix_length_and_dec() { max_length=10; }
};


class Item_func_locate :public Item_int_func
{
  String value1,value2;
public:
  Item_func_locate(Item *a,Item *b) :Item_int_func(a,b) {}
  Item_func_locate(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
  char *func_name() const { return "locate"; }
  longlong val_int();
  void fix_length_and_dec() { maybe_null=0; max_length=11; }
};


class Item_func_field :public Item_int_func
{
  Item *item;
  String value,tmp;
public:
  Item_func_field(Item *a,List<Item> &list) :Item_int_func(list),item(a) {}
  ~Item_func_field() { delete item; }
  longlong val_int();
  bool fix_fields(THD *thd,struct st_table_list *tlist)
  {
    return (item->fix_fields(thd,tlist) || Item_func::fix_fields(thd,tlist));
  }
  char *func_name() const { return "field"; }
  void fix_length_and_dec() { maybe_null=0; max_length=2; }
};


class Item_func_ascii :public Item_int_func
{
  String value;
public:
  Item_func_ascii(Item *a) :Item_int_func(a) {}
  longlong val_int();
  char *func_name() const { return "ascii"; }
  void fix_length_and_dec() { max_length=3; }
};


class Item_func_find_in_set :public Item_int_func
{
  String value,value2;
  uint enum_value;
  ulonglong enum_bit;
public:
  Item_func_find_in_set(Item *a,Item *b) :Item_int_func(a,b),enum_value(0) {}
  longlong val_int();
  char *func_name() const { return "find_in_set"; }
  void fix_length_and_dec();
};


class Item_func_bit_or :public Item_int_func
{
public:
  Item_func_bit_or(Item *a,Item *b) :Item_int_func(a,b) {}
  longlong val_int();
  char *func_name() const { return "|"; }
  void fix_length_and_dec() { decimals=0; max_length=10; }
};

class Item_func_bit_and :public Item_int_func
{
public:
  Item_func_bit_and(Item *a,Item *b) :Item_int_func(a,b) {}
  longlong val_int();
  char *func_name() const { return "&"; }
  void fix_length_and_dec() { decimals=0; max_length=10; }
};

class Item_func_bit_count :public Item_int_func
{
public:
  Item_func_bit_count(Item *a) :Item_int_func(a) {}
  longlong val_int();
  char *func_name() const { return "bit_count"; }
  void fix_length_and_dec() { decimals=0; max_length=2; }
};


# 568 "item_func.h"


class Item_func_udf_float :public Item_num_func
{
 public:
  Item_func_udf_float(udf_func *udf) :Item_num_func() {}
  Item_func_udf_float(udf_func *udf, List<Item> &list) :Item_num_func(list) {}
  ~Item_func_udf_float() {}
  double val() { return 0.0; }
};


class Item_func_udf_int :public Item_int_func
{
public:
  Item_func_udf_int(udf_func *udf) :Item_int_func() {}
  Item_func_udf_int(udf_func *udf, List<Item> &list) :Item_int_func(list) {}
  ~Item_func_udf_int() {}
  longlong val_int() { return 0; }
};


class Item_func_udf_str :public Item_func
{
public:
  Item_func_udf_str(udf_func *udf) :Item_func() {}
  Item_func_udf_str(udf_func *udf, List<Item> &list)  :Item_func(list) {}
  ~Item_func_udf_str() {}
  String *str(String *) { null_value=1; return 0; }
  double val() { null_value=1; return 0.0; }
  longlong val_int() { null_value=1; return 0; }
  enum Item_result result_type () const { return STRING_RESULT; }
  void fix_length_and_dec() { maybe_null=1; max_length=0; }
};



 



class ULL;
void item_user_lock_init(void);
void item_user_lock_release(ULL *ull);

class Item_func_get_lock :public Item_int_func
{
  String value;
 public:
  Item_func_get_lock(Item *a,Item *b) :Item_int_func(a,b) {}
  longlong val_int();
  char *func_name() const { return "get_lock"; }
  void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1;}
};

class Item_func_release_lock :public Item_int_func
{
  String value;
 public:
  Item_func_release_lock(Item *a) :Item_int_func(a) {}
  longlong val_int();
  char *func_name() const { return "release_lock"; }
  void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1;}
};
# 296 "item.h" 2

# 1 "item_cmpfunc.h" 1
 













 


#pragma interface			


class Item_bool_func :public Item_int_func
{
public:
  Item_bool_func() :Item_int_func() {}
  Item_bool_func(Item *a) :Item_int_func(a) {}
  Item_bool_func(Item *a,Item *b) :Item_int_func(a,b) {}
  void fix_length_and_dec() { decimals=0; max_length=1; }
};

class Item_bool_func2 :public Item_int_func
{						 
protected:
  String tmp_value1,tmp_value2;
public:
  Item_result cmp_type;
  Item_bool_func2(Item *a,Item *b) :Item_int_func(a,b) {}
  void fix_length_and_dec();
  int compare();				 
  optimize_type select_optimize() const { return OPTIMIZE_OP; }
  virtual enum Functype rev_functype() const { return UNKNOWN_FUNC; }
  void print(String *str) { Item_func::print_op(str); }
};


class Item_func_not :public Item_bool_func
{
public:
  Item_func_not(Item *a) :Item_bool_func(a) {}
  longlong val_int();
  char *func_name() const { return "not"; }
};

class Item_func_eq :public Item_bool_func2
{
public:
  Item_func_eq(Item *a,Item *b) :Item_bool_func2(a,b) { };
  longlong val_int();
  enum Functype functype() const { return EQ_FUNC; }
  enum Functype rev_functype() const { return EQ_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  char *func_name() const { return "="; }
};


class Item_func_ge :public Item_bool_func2
{
public:
  Item_func_ge(Item *a,Item *b) :Item_bool_func2(a,b) { };
  longlong val_int();
  enum Functype functype() const { return GE_FUNC; }
  enum Functype rev_functype() const { return LE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  char *func_name() const { return ">="; }
};


class Item_func_gt :public Item_bool_func2
{
public:
  Item_func_gt(Item *a,Item *b) :Item_bool_func2(a,b) { };
  longlong val_int();
  enum Functype functype() const { return GT_FUNC; }
  enum Functype rev_functype() const { return LT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  char *func_name() const { return ">"; }
};


class Item_func_le :public Item_bool_func2
{
public:
  Item_func_le(Item *a,Item *b) :Item_bool_func2(a,b) { };
  longlong val_int();
  enum Functype functype() const { return LE_FUNC; }
  enum Functype rev_functype() const { return GE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  char *func_name() const { return "<="; }
};


class Item_func_lt :public Item_bool_func2
{
public:
  Item_func_lt(Item *a,Item *b) :Item_bool_func2(a,b) { }
  longlong val_int();
  enum Functype functype() const { return LT_FUNC; }
  enum Functype rev_functype() const { return GT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  char *func_name() const { return "<"; }
};


class Item_func_ne :public Item_bool_func2
{
public:
  Item_func_ne(Item *a,Item *b) :Item_bool_func2(a,b) { }
  longlong val_int();
  enum Functype functype() const { return NE_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  char *func_name() const { return "<>"; }
};


class Item_func_between :public Item_int_func
{
  int (*string_compare)(const String *x,const String *y);
public:
  String value0,value1,value2;
  Item_func_between(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
  longlong val_int();
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
  enum Functype functype() const   { return BETWEEN; }
  char *func_name() const { return "between"; }
  void fix_length_and_dec();
};


class Item_func_strcmp :public Item_bool_func2
{
public:
  Item_func_strcmp(Item *a,Item *b) :Item_bool_func2(a,b) {}
  longlong val_int();
  void fix_length_and_dec() { max_length=2; }
  optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  char *func_name() const { return "strcmp"; }
};


class Item_func_interval :public Item_int_func
{
  Item *item;
  double *intervals;
public:
  Item_func_interval(Item *a,List<Item> &list)
    :Item_int_func(list),item(a),intervals(0) {}
  longlong val_int();
  bool fix_fields(THD *thd,struct st_table_list *tlist)
  {
    return (item->fix_fields(thd,tlist) || Item_func::fix_fields(thd,tlist));
  }
  void fix_length_and_dec();
  ~Item_func_interval() { delete item; }
  char *func_name() const { return "interval"; }
  void update_used_tables();
};


class Item_func_ifnull :public Item_func
{
  enum Item_result cached_result_type;
public:
  Item_func_ifnull(Item *a,Item *b) :Item_func(a,b) { }
  double val();
  longlong val_int();
  String *str(String *str);
  enum Item_result result_type () const { return cached_result_type; }
  void fix_length_and_dec();
  char *func_name() const { return "ifnull"; }
};


class Item_func_if :public Item_func
{
  enum Item_result cached_result_type;
public:
  Item_func_if(Item *a,Item *b,Item *c) :Item_func(a,b,c) { }
  double val();
  longlong val_int();
  String *str(String *str);
  enum Item_result result_type () const { return cached_result_type; }
  void fix_length_and_dec();
  char *func_name() const { return "if"; }
};


 

class in_vector :public Sql_alloc
{
 protected:
  char *base;
  uint size;
  qsort_cmp compare;
  uint count;
public:
  uint used_count;
  in_vector(uint elements,uint element_length,qsort_cmp cmp_func)
    :base((char*) sql_calloc(elements*element_length)),
     size(element_length), compare(cmp_func), count(elements),
     used_count(elements) {}
  virtual ~in_vector() {}
  virtual void set(uint pos,Item *item)=0;
  virtual byte *get_value(Item *item)=0;
  void sort()
    {
      qsort(base,used_count,size,compare);
    }
  int find(Item *item);
};


class in_string :public in_vector
{
  char buff[80];
  String tmp;
public:
  in_string(uint elements,qsort_cmp cmp_func);
  ~in_string();
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
};


class in_longlong :public in_vector
{
  longlong tmp;
public:
  in_longlong(uint elements);
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
};


class in_double :public in_vector
{
  double tmp;
public:
  in_double(uint elements);
  void set(uint pos,Item *item);
  byte *get_value(Item *item);
};


 



class cmp_item :public Sql_alloc
{
public:
  cmp_item() {}
  virtual ~cmp_item() {}
  virtual void store_value(Item *item)=0;
  virtual int cmp(Item *item)=0;
};


class cmp_item_sort_string :public cmp_item {
 protected:
  char value_buff[80];
  String value,*value_res;
public:
  cmp_item_sort_string() :value(value_buff,sizeof(value_buff)) {}