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.h < prev    next >
C/C++ Source or Header  |  2000-09-26  |  13KB  |  434 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. #ifdef __GNUC__
  19. #pragma interface            /* gcc class implementation */
  20. #endif
  21.  
  22. struct st_table_list;
  23. void item_init(void);                /* Init item functions */
  24.  
  25. class Item {
  26.   Item(const Item &);                /* Prevent use of theese */
  27.   void operator=(Item &);
  28. public:
  29.   static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
  30.   static void operator delete(void *ptr,size_t size) {} /*lint -e715 */
  31.  
  32.   enum Type {FIELD_ITEM,FUNC_ITEM,SUM_FUNC_ITEM,STRING_ITEM,
  33.          INT_ITEM,REAL_ITEM,NULL_ITEM,VARBIN_ITEM,
  34.          COPY_STR_ITEM,FIELD_AVG_ITEM,
  35.          PROC_ITEM,COND_ITEM,REF_ITEM,FIELD_STD_ITEM, CONST_ITEM};
  36.   enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
  37.  
  38.   String str_value;            /* used to store value */
  39.   my_string name;            /* Name from select */
  40.   Item *next;
  41.   uint32 max_length;
  42.   uint8 marker,decimals;
  43.   my_bool maybe_null;            /* If item may be null */
  44.   my_bool null_value;            /* if item is null */
  45.   my_bool binary;
  46.   my_bool with_sum_func;
  47.  
  48.  
  49.   // alloc & destruct is done as start of select using sql_alloc
  50.   Item();
  51.   virtual ~Item() { name=0; }        /*lint -e1509 */
  52.   void set_name(char* str,uint length=0);
  53.   void init_make_field(Send_field *tmp_field,enum enum_field_types type);
  54.   virtual bool fix_fields(THD *,struct st_table_list *);
  55.   virtual bool save_in_field(Field *field);
  56.   virtual void save_org_in_field(Field *field)
  57.     { (void) save_in_field(field); }
  58.   virtual bool send(String *str);
  59.   virtual bool eq(const Item *) const;
  60.   virtual Item_result result_type () const { return REAL_RESULT; }
  61.   virtual enum Type type() const =0;
  62.   virtual double val()=0;
  63.   virtual longlong val_int()=0;
  64.   virtual String *val_str(String*)=0;
  65.   virtual void make_field(Send_field *field)=0;
  66.   virtual Field *tmp_table_field() { return 0; }
  67.   virtual const char *full_name() const { return name ? name : "???"; }
  68.   virtual double  val_result() { return val(); }
  69.   virtual longlong val_int_result() { return val_int(); }
  70.   virtual String *str_result(String* tmp) { return val_str(tmp); }
  71.   virtual table_map used_tables() const { return (table_map) 0L; }
  72.   virtual bool basic_const_item() const { return 0; }
  73.   virtual Item *new_item() { return 0; }    /* Only for const items */
  74.   virtual cond_result eq_cmp_result() const { return COND_OK; }
  75.   inline uint float_length(uint decimals_par) const
  76.   { return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;}
  77.   virtual bool const_item() const { return used_tables() == 0; }
  78.   virtual void print(String *str_arg) { str_arg->append(full_name()); }
  79.   virtual void update_used_tables() {}
  80.   virtual void split_sum_func(List<Item> &fields) {}
  81.   virtual bool get_date(TIME *ltime,bool fuzzydate);
  82.   virtual bool get_time(TIME *ltime);
  83. };
  84.  
  85.  
  86. class Item_ident :public Item
  87. {
  88. public:
  89.   const char *db_name;
  90.   const char *table_name;
  91.   const char *field_name;
  92.   Item_ident(const char *db_name_par,const char *table_name_par,
  93.          const char *field_name_par)
  94.     :db_name(db_name_par),table_name(table_name_par),field_name(field_name_par)
  95.     { name = (char*) field_name_par; }
  96.   const char *full_name() const;
  97. };
  98.  
  99. class Item_field :public Item_ident
  100. {
  101.   void set_field(Field *field);
  102. public:
  103.   Field *field,*result_field;
  104.   // Item_field() {}
  105.  
  106.   Item_field(const char *db_par,const char *table_name_par,
  107.          const char *field_name_par)
  108.     :Item_ident(db_par,table_name_par,field_name_par),field(0),result_field(0)
  109.   {}
  110.   Item_field(Field *field);
  111.   enum Type type() const { return FIELD_ITEM; }
  112.   bool eq(const Item *item) const;
  113.   double val();
  114.   longlong val_int();
  115.   String *val_str(String*);
  116.   double val_result();
  117.   longlong val_int_result();
  118.   String *str_result(String* tmp);
  119.   bool send(String *str_arg) { return result_field->send(str_arg); }
  120.   void make_field(Send_field *field);
  121.   bool fix_fields(THD *,struct st_table_list *);
  122.   bool save_in_field(Field *field);
  123.   void save_org_in_field(Field *field);
  124.   table_map used_tables() const;
  125.   enum Item_result result_type () const
  126.   {
  127.     return field->result_type();
  128.   }
  129.   Field *tmp_table_field() { return result_field; }
  130.   bool get_date(TIME *ltime,bool fuzzydate);  
  131.   bool get_time(TIME *ltime);  
  132. };
  133.  
  134.  
  135. class Item_null :public Item
  136. {
  137. public:
  138.   Item_null(char *name_par=0)
  139.     { maybe_null=null_value=TRUE; name= name_par ? name_par : (char*) "NULL";}
  140.   enum Type type() const { return NULL_ITEM; }
  141.   bool eq(const Item *item) const;
  142.   double val();
  143.   longlong val_int();
  144.   String *val_str(String *str);
  145.   void make_field(Send_field *field);
  146.   bool save_in_field(Field *field);
  147.   enum Item_result result_type () const
  148.   { return STRING_RESULT; }
  149.   bool send(String *str);
  150.   bool basic_const_item() const { return 1; }
  151.   Item *new_item() { return new Item_null(name); }
  152. };
  153.  
  154.  
  155. class Item_int :public Item
  156. {
  157. public:
  158.   const longlong value;
  159.   Item_int(int32 i,uint length=11) :value((longlong) i)
  160.     { max_length=length;}
  161. #ifdef HAVE_LONG_LONG
  162.   Item_int(longlong i,uint length=21) :value(i)
  163.     { max_length=length;}
  164. #endif
  165.   Item_int(const char *str_arg,longlong i,uint length) :value(i)
  166.     { max_length=length; name=(char*) str_arg;}
  167.   Item_int(const char *str_arg) :
  168.     value(str_arg[0] == '-' ? strtoll(str_arg,(char**) 0,10) :
  169.       (longlong) strtoull(str_arg,(char**) 0,10))
  170.     { max_length= (uint) strlen(str_arg); name=(char*) str_arg;}
  171.   enum Type type() const { return INT_ITEM; }
  172.   virtual enum Item_result result_type () const { return INT_RESULT; }
  173.   longlong val_int() { return value; }
  174.   double val() { return (double) value; }
  175.   String *val_str(String*);
  176.   void make_field(Send_field *field);
  177.   bool save_in_field(Field *field);
  178.   bool basic_const_item() const { return 1; }
  179.   Item *new_item() { return new Item_int(name,value,max_length); }
  180.   void print(String *str);
  181. };
  182.  
  183.  
  184. class Item_real :public Item
  185. {
  186. public:
  187.   const double value;
  188.   // Item_real() :value(0) {}
  189.   Item_real(const char *str_arg,uint length) :value(atof(str_arg))
  190.   {
  191.     name=(char*) str_arg;
  192.     decimals=nr_of_decimals(str_arg);
  193.     max_length=length;
  194.   }
  195.   Item_real(const char *str,double val_arg,uint decimal_par,uint length)
  196.     :value(val_arg)
  197.   {
  198.     name=(char*) str;
  199.     decimals=decimal_par;
  200.     max_length=length;
  201.   }
  202.   Item_real(double value_par) :value(value_par) {}
  203.   bool save_in_field(Field *field);
  204.   enum Type type() const { return REAL_ITEM; }
  205.   double val() { return value; }
  206.   longlong val_int() { return (longlong) (value+(value > 0 ? 0.5 : -0.5));}
  207.   String *val_str(String*);
  208.   void make_field(Send_field *field);
  209.   bool basic_const_item() const { return 1; }
  210.   Item *new_item() { return new Item_real(name,value,decimals,max_length); }
  211. };
  212.  
  213.  
  214. class Item_float :public Item_real
  215. {
  216. public:
  217.   Item_float(const char *str,uint length) :Item_real(str,length)
  218.   {
  219.     decimals=NOT_FIXED_DEC;
  220.     max_length=DBL_DIG+8;
  221.   }
  222. };
  223.  
  224. class Item_string :public Item
  225. {
  226. public:
  227.   Item_string(const char *str,uint length)
  228.   {
  229.     str_value.set(str,length);
  230.     max_length=length;
  231.     name=(char*) str_value.ptr();
  232.     decimals=NOT_FIXED_DEC;
  233.   }
  234.   Item_string(const char *name_par,const char *str,uint length)
  235.   {
  236.     str_value.set(str,length);
  237.     max_length=length;
  238.     name=(char*) name_par;
  239.     decimals=NOT_FIXED_DEC;
  240.   }
  241.   ~Item_string() {}
  242.   enum Type type() const { return STRING_ITEM; }
  243.   double val() { return atof(str_value.ptr()); }
  244.   longlong val_int() { return strtoll(str_value.ptr(),(char**) 0,10); }
  245.   String *val_str(String*) { return (String*) &str_value; }
  246.   bool save_in_field(Field *field);
  247.   void make_field(Send_field *field);
  248.   enum Item_result result_type () const { return STRING_RESULT; }
  249.   bool basic_const_item() const { return 1; }
  250.   Item *new_item() { return new Item_string(name,str_value.ptr(),max_length); }
  251.   String *const_string() { return &str_value; }
  252.   inline void append(char *str,uint length) { str_value.append(str,length); }
  253.   void print(String *str);
  254. };
  255.  
  256. /* for show tables */
  257.  
  258. class Item_datetime :public Item_string
  259. {
  260. public:
  261.   Item_datetime(const char *item_name): Item_string(item_name,"",0)
  262.   { max_length=19;}
  263.   void make_field(Send_field *field);
  264. };
  265.  
  266. class Item_empty_string :public Item_string
  267. {
  268. public:
  269.   Item_empty_string(const char *header,uint length) :Item_string("",0)
  270.     { name=(char*) header; max_length=length;}
  271. };
  272.  
  273. class Item_varbinary :public Item
  274. {
  275. public:
  276.   Item_varbinary(const char *str,uint str_length);
  277.   ~Item_varbinary() {}
  278.   enum Type type() const { return VARBIN_ITEM; }
  279.   double val() { return (double) Item_varbinary::val_int(); }
  280.   longlong val_int();
  281.   String *val_str(String*) { return &str_value; }
  282.   bool save_in_field(Field *field);
  283.   void make_field(Send_field *field);
  284.   enum Item_result result_type () const { return INT_RESULT; }
  285. };
  286.  
  287.  
  288. class Item_result_field :public Item    /* Item with result field */
  289. {
  290. public:
  291.   Field *result_field;                /* Save result here */
  292.   Item_result_field() :result_field(0) {}
  293.   ~Item_result_field() {}            /* Required with gcc 2.95 */
  294.   Field *tmp_table_field() { return result_field; }
  295.   virtual void fix_length_and_dec()=0;
  296. };
  297.  
  298.  
  299. class Item_ref :public Item_ident
  300. {
  301.   Item **ref;
  302. public:
  303.   Item_ref(char *db_par,char *table_name_par,char *field_name_par)
  304.     :Item_ident(db_par,table_name_par,field_name_par),ref(0) {}
  305.   Item_ref(Item **item, char *table_name_par,char *field_name_par)
  306.     :Item_ident(NullS,table_name_par,field_name_par),ref(item) {}
  307.   enum Type type() const        { return REF_ITEM; }
  308.   bool eq(const Item *item) const    { return (*ref)->eq(item); }
  309.   ~Item_ref() { if (ref) delete *ref; }
  310.   double val()
  311.   {
  312.     double tmp=(*ref)->val_result();
  313.     null_value=(*ref)->null_value;
  314.     return tmp;
  315.   }
  316.   longlong val_int()
  317.   {
  318.     longlong tmp=(*ref)->val_int_result();
  319.     null_value=(*ref)->null_value;
  320.     return tmp;
  321.   }
  322.   String *val_str(String* tmp)
  323.   {
  324.     tmp=(*ref)->str_result(tmp);
  325.     null_value=(*ref)->null_value;
  326.     return tmp;
  327.   }
  328.   bool get_date(TIME *ltime,bool fuzzydate)
  329.   {  
  330.     return (null_value=(*ref)->get_date(ltime,fuzzydate));
  331.   }
  332.   bool send(String *tmp)        { return (*ref)->send(tmp); }
  333.   void make_field(Send_field *field)    { (*ref)->make_field(field); }
  334.   bool fix_fields(THD *,struct st_table_list *);
  335.   bool save_in_field(Field *field)    { return (*ref)->save_in_field(field); }
  336.   void save_org_in_field(Field *field)    { (*ref)->save_org_in_field(field); }
  337.   enum Item_result result_type () const { return (*ref)->result_type(); }
  338.   table_map used_tables() const        { return (*ref)->used_tables(); }
  339. };
  340.  
  341.  
  342. #include "item_sum.h"
  343. #include "item_func.h"
  344. #include "item_cmpfunc.h"
  345. #include "item_strfunc.h"
  346. #include "item_timefunc.h"
  347. #include "item_uniq.h"
  348.  
  349. class Item_copy_string :public Item
  350. {
  351. public:
  352.   Item *item;
  353.   Item_copy_string(Item *i) :item(i)
  354.   {
  355.     null_value=maybe_null=item->maybe_null;
  356.     decimals=item->decimals;
  357.     max_length=item->max_length;
  358.     name=item->name;
  359.   }
  360.   ~Item_copy_string() { delete item; }
  361.   enum Type type() const { return COPY_STR_ITEM; }
  362.   enum Item_result result_type () const { return STRING_RESULT; }
  363.   double val()
  364.   { return null_value ? 0.0 : atof(str_value.c_ptr()); }
  365.   longlong val_int()
  366.   { return null_value ? LL(0) : strtoll(str_value.c_ptr(),(char**) 0,10); }
  367.   String *val_str(String*);
  368.   void make_field(Send_field *field) { item->make_field(field); }
  369.   void copy();
  370.   table_map used_tables() const { return (table_map) 1L; }
  371.   bool const_item() const { return 0; }
  372. };
  373.  
  374.  
  375. class Item_buff :public Sql_alloc
  376. {
  377. public:
  378.   my_bool null_value;
  379.   Item_buff() :null_value(0) {}
  380.   virtual bool cmp(void)=0;
  381.   virtual ~Item_buff(); /*line -e1509 */
  382. };
  383.  
  384. class Item_str_buff :public Item_buff
  385. {
  386.   Item *item;
  387.   String value,tmp_value;
  388. public:
  389.   Item_str_buff(Item *arg) :item(arg),value(arg->max_length) {}
  390.   bool cmp(void);
  391.   ~Item_str_buff();                // Deallocate String:s
  392. };
  393.  
  394.  
  395. class Item_real_buff :public Item_buff
  396. {
  397.   Item *item;
  398.   double value;
  399. public:
  400.   Item_real_buff(Item *item_par) :item(item_par),value(0.0) {}
  401.   bool cmp(void);
  402. };
  403.  
  404. class Item_int_buff :public Item_buff
  405. {
  406.   Item *item;
  407.   longlong value;
  408. public:
  409.   Item_int_buff(Item *item_par) :item(item_par),value(0) {}
  410.   bool cmp(void);
  411. };
  412.  
  413.  
  414. class Item_field_buff :public Item_buff
  415. {
  416.   char *buff;
  417.   Field *field;
  418.   uint length;
  419.  
  420. public:
  421.   Item_field_buff(Item_field *item)
  422.   {
  423.     field=item->field;
  424.     buff= (char*) sql_calloc(length=field->pack_length());
  425.   }
  426.   bool cmp(void);
  427. };
  428.  
  429. extern Item_buff *new_Item_buff(Item *item);
  430. extern Item_result item_cmp_type(Item_result a,Item_result b);
  431. extern Item *resolve_const_item(Item *item,Item *cmp_item);
  432. extern bool field_is_equal_to_item(Field *field,Item *item);
  433. Item *get_system_var(LEX_STRING name);
  434.