bug (16/26)

Tue Sep 8 21:44:00 GMT 1998

	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_SHORT;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 2; }
  void sql_type(String &str) const;
};


class Field_medium :public Field_num {
public:
  Field_medium(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	      uint null_bit_arg,
	      enum utype unireg_check_arg, char *field_name_arg,
	      struct st_table *table_arg,
	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_INT24;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 3; }
  void sql_type(String &str) const;
};


class Field_long :public Field_num {
public:
  Field_long(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	     uint null_bit_arg,
	     enum utype unireg_check_arg, char *field_name_arg,
	     struct st_table *table_arg,
	     bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  Field_long(uint len_arg,bool maybe_null, char *field_name_arg,
	     struct st_table *table_arg,bool unsigned_arg)
    :Field_num((char*) 0, len_arg, maybe_null ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg,0,0,unsigned_arg)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_LONG;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 4; }
  void sql_type(String &str) const;
};


class Field_longlong :public Field_num {
public:
  Field_longlong(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	      uint null_bit_arg,
	      enum utype unireg_check_arg, char *field_name_arg,
	      struct st_table *table_arg,
	      bool zero_arg, bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       0, zero_arg,unsigned_arg)
    {}
  Field_longlong(uint len_arg,bool maybe_null, char *field_name_arg,
		 struct st_table *table_arg)
    :Field_num((char*) 0, len_arg, maybe_null ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg,0,0,0)
    {}
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_LONGLONG;}
  enum ha_base_keytype key_type() const
    { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 8; }
  void sql_type(String &str) const;
};


class Field_float :public Field_num {
public:
  Field_float(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	      uint null_bit_arg,
	      enum utype unireg_check_arg, char *field_name_arg,
	      struct st_table *table_arg,
	       uint dec_arg,bool zero_arg,bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       dec_arg, zero_arg,unsigned_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_FLOAT;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return sizeof(float); }
  void sql_type(String &str) const;
};


class Field_double :public Field_num {
public:
  Field_double(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	       uint null_bit_arg,
	       enum utype unireg_check_arg, char *field_name_arg,
	       struct st_table *table_arg,
	       uint dec_arg,bool zero_arg,bool unsigned_arg)
    :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg,
	       dec_arg, zero_arg,unsigned_arg)
    {}
  Field_double(uint len_arg, bool maybe_null, char *field_name_arg,
	       struct st_table *table_arg, uint dec_arg)
    :Field_num((char*) 0, len_arg, maybe_null ? (uchar*) "": 0, (uint) 0,
	       NONE, field_name_arg, table_arg,dec_arg,0,0)
    {}
  enum_field_types type() const { return FIELD_TYPE_DOUBLE;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return sizeof(double); }
  void sql_type(String &str) const;
};


class Field_null :public Field_str {
  static uchar null[1];
public:
  Field_null(char *ptr_arg, uint len_arg,
	     enum utype unireg_check_arg, char *field_name_arg,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, len_arg, null, 1,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_NULL;}
  void store(const char *to,uint length) { null[0]=1; }
  void store(double nr  )   { null[0]=1; }
  void store(longlong nr  ) { null[0]=1; }
  double val_real(void)		{ return 0.0;}
  longlong val_int(void)	{ return 0;}
  void val_str(String *value)	{ value->length(0); }
  int cmp(const char *a,const char* b) { return 0;}
  void sort_string(char *buff,uint length)  {}
  uint pack_length() const { return 0; }
  void sql_type(String &str) const { str.set("null",4); }
  uint size_of() const { return sizeof(*this); }
};


class Field_timestamp :public Field_num {
public:
  Field_timestamp(char *ptr_arg, uint len_arg,
		  enum utype unireg_check_arg, char *field_name_arg,
		  struct st_table *table_arg);
  enum Item_result result_type () const { return INT_RESULT; }
  enum_field_types type() const { return FIELD_TYPE_TIMESTAMP;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 4; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
  inline void set_time()
    {
      long skr= (long) time((time_t*) 0);
      { *(( ptr )+3)=(( skr ));	*(( ptr )+2)=((( skr ) >> 8));	*(( ptr )+1)=((( skr ) >> 16));	*(( ptr )+0)=((( skr ) >> 24)); } ;
    }
  inline long get_time()
    {
      long tmp;
      { int32 def_temp;	((byte*) &def_temp)[0]=( ptr )[0];	((byte*) &def_temp)[1]=( ptr )[1];	((byte*) &def_temp)[2]=( ptr )[2];	((byte*) &def_temp)[3]=( ptr )[3];	( tmp )=def_temp; } ;
      return tmp;
    }
  void fill_and_store(char *from,uint len);
};


class Field_date :public Field_str {
public:
  Field_date(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
	     enum utype unireg_check_arg, char *field_name_arg,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, 10, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_DATE;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
  enum Item_result cmp_type () const { return INT_RESULT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 4; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
};


class Field_time :public Field_str {
public:
  Field_time(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
	     enum utype unireg_check_arg, char *field_name_arg,
	     struct st_table *table_arg)
    :Field_str(ptr_arg, 8, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_TIME;}
  enum ha_base_keytype key_type() const { return HA_KEYTYPE_UINT24; }
  enum Item_result cmp_type () const { return INT_RESULT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 3; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
};


class Field_datetime :public Field_str {
public:
  Field_datetime(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
		 enum utype unireg_check_arg, char *field_name_arg,
		 struct st_table *table_arg)
    :Field_str(ptr_arg, 19, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {}
  enum_field_types type() const { return FIELD_TYPE_DATETIME;}

  enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONGLONG; }

  enum Item_result cmp_type () const { return INT_RESULT; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return 8; }
  void sql_type(String &str) const;
  bool store_for_compare() { return 1; }
};


class Field_string :public Field_str {
  bool binary_flag;
public:
  Field_string(char *ptr_arg, uint len_arg,uchar *null_ptr_arg,
	       uint null_bit_arg,
	       enum utype unireg_check_arg, char *field_name_arg,
	       struct st_table *table_arg,bool binary_arg)
    :binary_flag(binary_arg),
     Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {
      if (binary_arg)
	flags|= 128 ;
    }
  Field_string(uint len_arg,bool maybe_null, char *field_name_arg,
	       struct st_table *table_arg, bool binary_arg)
    :binary_flag(binary_arg),
     Field_str(__null ,len_arg, maybe_null ? (uchar*) "": 0,0,
	       NONE, field_name_arg, table_arg)
    {
      if (binary_arg)
	flags|= 128 ;
    }

  enum_field_types type() const { return FIELD_TYPE_STRING;}
  enum ha_base_keytype key_type() const
    { return binary_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
  bool zero_pack() const { return 0; }
  bool binary() const { return binary_flag; }
  void reset(void) { memset(( ptr ),( ' ' ),( field_length )) ; }
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  void sql_type(String &str) const;
  uint size_of() const { return sizeof(*this); }
};


class Field_blob :public Field_str {
  uint packlength;
  String value;					 
  bool binary_flag;
public:
  Field_blob(char *ptr_arg, uchar *null_ptr_arg, uint null_bit_arg,
	     enum utype unireg_check_arg, char *field_name_arg,
	     struct st_table *table_arg,uint blob_pack_length,
	     bool binary_arg);
  enum_field_types type() const { return FIELD_TYPE_BLOB;}
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return packlength+sizeof(char*); }
  void store_length(ulong number);
  ulong get_length(void);
  bool binary() const { return binary_flag; }
  inline void get_ptr(char **str)
    {
      memcpy(str,ptr+packlength,sizeof(char*));
    }
  inline void set_ptr(char *length,char *data)
    {
      memcpy(ptr,length,packlength);
      memcpy(ptr+packlength,&data,sizeof(char*));
    }
  void sql_type(String &str) const;
  void free() { value.free(); }
  friend void field_conv(Field *to,Field *from);
  uint size_of() const { return sizeof(*this); }
};


class Field_enum :public Field_str {
protected:
  uint packlength;
public:
  TYPELIB *typelib;
  Field_enum(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
		 uint null_bit_arg,
		 enum utype unireg_check_arg, char *field_name_arg,
		 struct st_table *table_arg,uint packlength_arg,
		 TYPELIB *typelib_arg)
    :typelib(typelib_arg),packlength(packlength_arg),
     Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
	       unireg_check_arg, field_name_arg, table_arg)
    {
      flags|= 256 ;
    }
  enum_field_types type() const { return FIELD_TYPE_STRING; }
  enum Item_result cmp_type () const { return INT_RESULT; }
  enum ha_base_keytype key_type() const;
  void store(const char *to,uint length);
  void store(double nr);
  void store(longlong nr);
  double val_real(void);
  longlong val_int(void);
  void val_str(String*);
  int cmp(const char *,const char*);
  void sort_string(char *buff,uint length);
  uint pack_length() const { return packlength; }
  void store_type(ulonglong value);
  void sql_type(String &str) const;
  uint size_of() const { return sizeof(*this); }
  enum_field_types real_type() const { return FIELD_TYPE_ENUM; }
  bool optimize_range() { return 0; }
};


class Field_set :public Field_enum {
public:
  Field_set(char *ptr_arg, uint len_arg, uchar *null_ptr_arg,
	    uint null_bit_arg,
	    enum utype unireg_check_arg, char *field_name_arg,
	    struct st_table *table_arg,uint packlength_arg,
	    TYPELIB *typelib_arg)
    :Field_enum(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
		    unireg_check_arg, field_name_arg,
		    table_arg, packlength_arg,
		    typelib_arg)
    {}
  void store(const char *to,uint length);
  void store(double nr) { store((longlong) nr); }
  void store(longlong nr);
  void val_str(String*);
  void sql_type(String &str) const;
  enum_field_types real_type() const { return FIELD_TYPE_SET; }
};


class create_field :public Sql_alloc {
public:
  char	*field_name;
  char	*change;				 
  Item	*def;					 
  enum	enum_field_types sql_type;
  uint	length,decimals,flags,pack_length;
  Field::utype unireg_check;
  TYPELIB *interval;				 
  Field *field;					 

  uint8 row,col,sc_length;			 
  uint	offset,pack_flag;
  create_field() {}
  create_field(Field *field);
};


class Send_field {
 public:
  char *table_name,*col_name;
  uint length,flags,decimals;
  enum_field_types type;
  Send_field() {}
};


class Copy_field :public Sql_alloc {
  void (*get_copy_func(Field *to,Field *from))(Copy_field *);
public:
  char *from_ptr,*to_ptr;
  uchar *from_null_ptr,*to_null_ptr;
  my_bool *null_row;
  uint	from_bit,to_bit;
  uint from_length,to_length;
  Field *from_field,*to_field;
  String tmp;					 

  Copy_field() {}
  ~Copy_field() {}
  void set(Field *to,Field *from,bool save);	 
  void set(char *to,Field *from);		 
  void (*do_copy)(Copy_field *);
  void (*do_copy2)(Copy_field *);		 
};


Field *make_field(char *ptr, uint field_length,
		  uchar *null_pos, uint null_bit,
		  uint pack_flag, Field::utype unireg_check,
		  TYPELIB *interval, char *field_name,
		  struct st_table *table);
uint pack_length_to_packflag(uint type);
uint calc_pack_length(enum_field_types type,uint length);
bool set_field_to_null(Field *field);
uint find_enum(TYPELIB *typelib,const char *x, uint length);
ulonglong find_set(TYPELIB *typelib,const char *x, uint length);

 
# 130 "mysql_priv.h" 2

# 1 "sql_udf.h" 1
 

#pragma interface


typedef struct st_udf_func
{
  char *name;
  int name_length;
  Item_result returns;
  char *dl;
  void *dlhandle;
  void *func;
  void *func_init;
  void *func_deinit;
  ulong usage_count;
} udf_func;
	

# 131 "mysql_priv.h" 2

# 1 "item.h" 1
 

#pragma interface			


struct st_table_list;
void item_init(void);			 

class Item :public Sql_alloc {
public:
  enum Type {FIELD_ITEM,FUNC_ITEM,SUM_FUNC_ITEM,STRING_ITEM,
	     INT_ITEM,REAL_ITEM,NULL_ITEM,VARBIN_ITEM,
	     COPY_STR_ITEM,FIELD_AVG_ITEM,
	     PROC_ITEM,COND_ITEM,REF_ITEM,FIELD_STD_ITEM};
  enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };

  my_bool maybe_null;			 
  my_bool null_value;			 
  my_bool binary;
  my_bool with_sum_func;

  uint8 marker,decimals;
  uint	max_length;
  my_string name;			 
  String str_value;			 
  Item *next;

   
  Item();
  virtual ~Item() { name=0; }		 
  void set_name(char* str,uint length=0);
  void init_make_field(Send_field *tmp_field,enum enum_field_types type);
  virtual bool fix_fields(THD *,struct st_table_list *);
  virtual bool save_in_field(Field *field);
  virtual void save_org_in_field(Field *field)
    { (void) save_in_field(field); }
  virtual bool send(String *str);
  virtual bool eq(const Item *) const;
  virtual Item_result result_type () const { return REAL_RESULT; }
  virtual enum Type type() const =0;
  virtual double val()=0;
  virtual longlong val_int()=0;
  virtual String *str(String*)=0;
  virtual void make_field(Send_field *field)=0;
  virtual Field *tmp_table_field() { return 0; }
  virtual char *full_name() { return name ? name : "???"; }
  virtual double val_result() { return val(); }
  virtual longlong val_int_result() { return val_int(); }
  virtual String *str_result(String* tmp) { return str(tmp); }
  virtual table_map used_tables() const { return (table_map) 0L; }
  virtual bool basic_const_item() const { return 0; }
  virtual Item *new_item() { return 0; }	 
  virtual cond_result eq_cmp_result() const { return COND_OK; }
  inline uint float_length(uint decimals_par) const {return (13+decimals_par);}
  inline bool const_item() const { return used_tables() == 0; }
  virtual void print(String *str) { str->append(full_name()); }
  virtual void update_used_tables() {}
  virtual void split_sum_func(List<Item> &fields) { return; }
};


class Item_ident :public Item
{
public:
  char *table_name,*field_name;
  Item_ident(char *table_name_par,char *field_name_par)
    :table_name(table_name_par),field_name(field_name_par)
    { name = field_name_par; }
  char *full_name();
};

class Item_field :public Item_ident
{
  void set_field(Field *field);
public:
  Field *field,*result_field;
   

  Item_field(char *table_name_par,char *field_name_par)
    :field(0),result_field(0),Item_ident(table_name_par,field_name_par) {}
  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
  bool eq(const Item *item) const;
  double val();
  longlong val_int();
  String *str(String*);
  double val_result();
  longlong val_int_result();
  String *str_result(String* tmp);
  bool send(String *str) { return result_field->send(str); }
  void make_field(Send_field *field);
  bool fix_fields(THD *,struct st_table_list *);
  bool save_in_field(Field *field);
  void save_org_in_field(Field *field);
  table_map used_tables() const;
  enum Item_result result_type () const
  {
    return field->result_type();
  }
  Field *tmp_table_field() { return result_field; }
};


class Item_null :public Item
{
public:
  Item_null(char *name_par=0)
    { maybe_null=null_value= (1) ; name= name_par ? name_par : "NULL";}
  enum Type type() const { return NULL_ITEM; }
  bool eq(const Item *item) const;
  double val();
  longlong val_int();
  String *str(String *str);
  void make_field(Send_field *field);
  bool save_in_field(Field *field);
  enum Item_result result_type () const
  { return STRING_RESULT; }
  bool send(String *str);
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_null(name); }
};


class Item_int :public Item
{
public:
  const longlong value;
  Item_int(int32 i,uint length=11) :value((longlong) i)
    { max_length=length;}

  Item_int(longlong i,uint length=21) :value(i)
    { max_length=length;}

  Item_int(char *str,longlong i,uint length) :value(i)
    { max_length=length; name=str;}
  Item_int(const char *str) :
    value(str[0] == '-' ? strtoll(str,__null ,10) :
	  (longlong) strtoull(str,__null ,10))
    { max_length=strlen(str); name=(char*) str;}
  enum Type type() const { return INT_ITEM; }
  virtual enum Item_result result_type () const { return INT_RESULT; }
  longlong val_int() { return value; }
  double val() { return (double) value; }
  String *str(String*);
  void make_field(Send_field *field);
  bool save_in_field(Field *field);
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_int(name,value,max_length); }
  void print(String *str);
};


class Item_real :public Item
{
public:
  const double value;
   
  Item_real(const char *str) :value(atof(str))
  {
    name=(char*) str;
    this->decimals=nr_of_decimals(str);
    max_length=strlen(str);
  }
  Item_real(const char *str,double val,uint decimal_par,uint length) :value(val)
  {
    name=(char*) str;
    decimals=decimal_par;
    max_length=length;
  }
  Item_real(double value_par) :value(value_par) {}
  bool save_in_field(Field *field);
  enum Type type() const { return REAL_ITEM; }
  double val() { return value; }
  longlong val_int() { return (longlong) (value+0.5);}
  String *str(String*);
  void make_field(Send_field *field);
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_real(name,value,decimals,max_length); }
};


class Item_string :public Item
{
public:
  Item_string(const char *str,uint length)
  {
    str_value.set(str,length);
    max_length=length;
    name=(char*) str_value.ptr();
  }
  Item_string(char *name_par,const char *str,uint length)
  {
    str_value.set(str,length);
    max_length=length;
    name=name_par;
  }
  ~Item_string() {}
  enum Type type() const { return STRING_ITEM; }
  double val() { return atof(str_value.ptr()); }
  longlong val_int() { return strtoll(str_value.ptr(),__null ,10); }
  String *str(String*) { return (String*) &str_value; }
  bool save_in_field(Field *field);
  void make_field(Send_field *field);
  enum Item_result result_type () const { return STRING_RESULT; }
  bool basic_const_item() const { return 1; }
  Item *new_item() { return new Item_string(name,str_value.ptr(),max_length); }
  String *const_string() { return &str_value; }
  inline void append(char *str,uint length) { str_value.append(str,length); }
};


class Item_empty_string :public Item_string
{
public:
  Item_empty_string(char *header,uint length) :Item_string("",0)
    { name=header; max_length=length;}
};

class Item_varbinary :public Item
{
public:
  Item_varbinary(const char *str,uint str_length);
  ~Item_varbinary() {}
  enum Type type() const { return VARBIN_ITEM; }
  double val() { return (double) val_int(); }
  longlong val_int();
  String *str(String*) { return &str_value; }
  bool save_in_field(Field *field);
  void make_field(Send_field *field);
  enum Item_result result_type () const { return STRING_RESULT; }
};


class Item_result_field :public Item	 
{
public:
  Field *result_field;			 
  Item_result_field() :result_field(0) {}
  Field *tmp_table_field() { return result_field; }
};


class Item_ref :public Item_ident
{
  Item **ref;
public:
  Item_ref(char *table_name_par,char *field_name_par)
    :ref(0), Item_ident(table_name_par,field_name_par) {}
  Item_ref(Item **item, char *table_name_par,char *field_name_par)
    :ref(item), Item_ident(table_name_par,field_name_par) {}
  enum Type type() const		{ return REF_ITEM; }
  bool eq(const Item *item) const	{ return (*ref)->eq(item); }
  ~Item_ref() { if (ref) delete *ref; }
  double val()
  {
    double tmp=(*ref)->val_result();
    null_value=(*ref)->null_value;
    return tmp;
  }
  longlong val_int()
  {
    longlong tmp=(*ref)->val_int_result();
    null_value=(*ref)->null_value;
    return tmp;
  }
  String *str(String* tmp)
  {
    tmp=(*ref)->str_result(tmp);
    null_value=(*ref)->null_value;
    return tmp;
  }
  bool send(String *tmp)		{ return (*ref)->send(tmp); }
  void make_field(Send_field *field)	{ (*ref)->make_field(field); }
  bool fix_fields(THD *,struct st_table_list *);
  bool save_in_field(Field *field)	{ return (*ref)->save_in_field(field); }
  void save_org_in_field(Field *field)	{ (*ref)->save_org_in_field(field); }
  enum Item_result result_type () const { return (*ref)->result_type(); }
  table_map used_tables() const		{ return (*ref)->used_tables(); }
};


# 1 "item_sum.h" 1
 

#pragma interface			


class Item_sum :public Item_result_field
{
public:
  enum Sumfunctype {COUNT_FUNC,SUM_FUNC,AVG_FUNC,MIN_FUNC,MAX_FUNC,
		    UNIQUE_USERS_FUNC,STD_FUNC,SUM_BIT_FUNC };
  Item *item;
  bool quick_group;

  Item_sum(Item *item_par) :item(item_par),quick_group(1) {}
  ~Item_sum() { delete item; result_field=0;}
  enum Type type() const { return SUM_FUNC_ITEM; }
  virtual enum Sumfunctype sum_func () const=0;
  virtual void reset()=0;
  virtual void add()=0;
  virtual void reset_field()=0;
  virtual void update_field(int offset)=0;
  virtual bool keep_field_type(void) const { return 0; }
  virtual void fix_length_and_dec() { maybe_null=1; null_value=1; }
  virtual char *func_name() const { return "?"; }
  ulong used_tables() const { return ~(table_map) 0; }
  void update_used_tables() { }
  void make_field(Send_field *field);
  void print(String *str);
};


class Item_sum_num :public Item_sum
{
public:
  Item_sum_num(Item *item_par) :Item_sum(item_par) {}
  bool fix_fields(THD *,struct st_table_list *);
  longlong val_int() { return (longlong) val(); }  
  String *str(String*str);
  void reset_field();
};


class Item_sum_int :public Item_sum_num
{
public:
  Item_sum_int(Item *item_par) :Item_sum_num(item_par) {}
  double val() { return (double) val_int(); }
  String *str(String*str);
  enum Item_result result_type () const { return INT_RESULT; }
};


class Item_sum_sum :public Item_sum_num
{
  double sum;
  void fix_length_and_dec() { maybe_null=null_value=0; }

  public:
  Item_sum_sum(Item *item_par) :Item_sum_num(item_par),sum(0.0) {}
  enum Sumfunctype sum_func () const {return SUM_FUNC;}
  void reset();
  void add();
  double val();
  void reset_field();
  void update_field(int offset);
  char *func_name() const { return "sum"; }
};


class Item_sum_count :public Item_sum_int
{
  ulong count;
  void fix_length_and_dec()
    { decimals=0; max_length=11; maybe_null=null_value=0; }

  public:
  Item_sum_count(Item *item_par) :Item_sum_int(item_par),count(0) {}
  enum Sumfunctype sum_func () const {return COUNT_FUNC;}
  void reset();
  void add();
  longlong val_int();
  void reset_field();