diff options
Diffstat (limited to 'sql/item_cmpfunc.h')
| -rw-r--r-- | sql/item_cmpfunc.h | 662 |
1 files changed, 510 insertions, 152 deletions
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h index 8f1aa525190..ad2b929c19e 100644 --- a/sql/item_cmpfunc.h +++ b/sql/item_cmpfunc.h @@ -1,4 +1,4 @@ -/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB +/* Copyright (C) 2000-2003 MySQL AB This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -21,134 +21,333 @@ #pragma interface /* gcc class implementation */ #endif +extern Item_result item_cmp_type(Item_result a,Item_result b); +class Item_bool_func2; +class Arg_comparator; + +typedef int (Arg_comparator::*arg_cmp_func)(); + +class Arg_comparator: public Sql_alloc +{ + Item **a, **b; + arg_cmp_func func; + Item_bool_func2 *owner; + Arg_comparator *comparators; // used only for compare_row() + +public: + DTCollation cmp_collation; + + Arg_comparator() {}; + Arg_comparator(Item **a1, Item **a2): a(a1), b(a2) {}; + + int set_compare_func(Item_bool_func2 *owner, Item_result type); + inline int set_compare_func(Item_bool_func2 *owner_arg) + { + return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(), + (*b)->result_type())); + } + inline int set_cmp_func(Item_bool_func2 *owner_arg, + Item **a1, Item **a2, + Item_result type) + { + a= a1; + b= a2; + return set_compare_func(owner_arg, type); + } + inline int set_cmp_func(Item_bool_func2 *owner_arg, + Item **a1, Item **a2) + { + return set_cmp_func(owner_arg, a1, a2, item_cmp_type((*a1)->result_type(), + (*a2)->result_type())); + } + inline int compare() { return (this->*func)(); } + + int compare_string(); // compare args[0] & args[1] + int compare_binary_string(); // compare args[0] & args[1] + int compare_real(); // compare args[0] & args[1] + int compare_int_signed(); // compare args[0] & args[1] + int compare_int_signed_unsigned(); + int compare_int_unsigned_signed(); + int compare_int_unsigned(); + int compare_row(); // compare args[0] & args[1] + int compare_e_string(); // compare args[0] & args[1] + int compare_e_binary_string(); // compare args[0] & args[1] + int compare_e_real(); // compare args[0] & args[1] + int compare_e_int(); // compare args[0] & args[1] + int compare_e_int_diff_signedness(); + int compare_e_row(); // compare args[0] & args[1] + + static arg_cmp_func comparator_matrix [4][2]; + + friend class Item_func; +}; + 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) {} + Item_bool_func(THD *thd, Item_bool_func *item) :Item_int_func(thd, item) {} + bool is_bool_func() { return 1; } void fix_length_and_dec() { decimals=0; max_length=1; } - unsigned int size_of() { return sizeof(*this);} +}; + +class Item_cache; +class Item_in_optimizer: public Item_bool_func +{ +protected: + Item_cache *cache; + bool save_cache; +public: + Item_in_optimizer(Item *a, Item_in_subselect *b): + Item_bool_func(a, my_reinterpret_cast(Item *)(b)), cache(0), save_cache(0) + {} + bool fix_fields(THD *, struct st_table_list *, Item **); + bool fix_left(THD *thd, struct st_table_list *tables, Item **ref); + bool is_null(); + /* + Item_in_optimizer item is special boolean function. On value request + (one of val, val_int or val_str methods) it evaluate left expression + of IN by storing it value in cache item (one of Item_cache* items), + then it test cache is it NULL. If left expression (cache) is NULL then + Item_in_optimizer return NULL, else it evaluate Item_in_subselect. + */ + longlong val_int(); + void cleanup(); + const char *func_name() const { return "<in_optimizer>"; } + Item_cache **get_cache() { return &cache; } + void keep_top_level_cache(); +}; + +class Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const = 0; + virtual const char* symbol(bool invert) const = 0; + virtual bool eqne_op() const = 0; + virtual bool l_op() const = 0; +}; + +class Eq_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? "<>" : "="; } + virtual bool eqne_op() const { return 1; } + virtual bool l_op() const { return 0; } +}; + +class Ne_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? "=" : "<>"; } + virtual bool eqne_op() const { return 1; } + virtual bool l_op() const { return 0; } +}; + +class Gt_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? "<=" : ">"; } + virtual bool eqne_op() const { return 0; } + virtual bool l_op() const { return 0; } +}; + +class Lt_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? ">=" : "<"; } + virtual bool eqne_op() const { return 0; } + virtual bool l_op() const { return 1; } +}; + +class Ge_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? "<" : ">="; } + virtual bool eqne_op() const { return 0; } + virtual bool l_op() const { return 0; } +}; + +class Le_creator :public Comp_creator +{ +public: + virtual Item_bool_func2* create(Item *a, Item *b) const; + virtual const char* symbol(bool invert) const { return invert? ">" : "<="; } + virtual bool eqne_op() const { return 0; } + virtual bool l_op() const { return 1; } }; class Item_bool_func2 :public Item_int_func { /* Bool with 2 string args */ protected: + Arg_comparator cmp; String tmp_value1,tmp_value2; + public: - Item_bool_func2(Item *a,Item *b) :Item_int_func(a,b) {} + Item_bool_func2(Item *a,Item *b) + :Item_int_func(a,b), cmp(tmp_arg, tmp_arg+1) {} void fix_length_and_dec(); - void set_cmp_func(Item_result type); - int (Item_bool_func2::*cmp_func)(); - int compare_string(); /* compare arg[0] & arg[1] */ - int compare_real(); /* compare arg[0] & arg[1] */ - int compare_int(); /* compare arg[0] & arg[1] */ + void set_cmp_func() + { + cmp.set_cmp_func(this, tmp_arg, tmp_arg+1); + } optimize_type select_optimize() const { return OPTIMIZE_OP; } virtual enum Functype rev_functype() const { return UNKNOWN_FUNC; } bool have_rev_func() const { return rev_functype() != UNKNOWN_FUNC; } void print(String *str) { Item_func::print_op(str); } bool is_null() { return test(args[0]->is_null() || args[1]->is_null()); } - unsigned int size_of() { return sizeof(*this);} + bool is_bool_func() { return 1; } + CHARSET_INFO *compare_collation() { return cmp.cmp_collation.collation; } + + friend class Arg_comparator; }; +class Item_bool_rowready_func2 :public Item_bool_func2 +{ + Item *orig_a, *orig_b; /* propagate_const can change parameters */ +public: + Item_bool_rowready_func2(Item *a,Item *b) :Item_bool_func2(a,b), + orig_a(a), orig_b(b) + { + allowed_arg_cols= a->cols(); + } + void cleanup() + { + DBUG_ENTER("Item_bool_rowready_func2::cleanup"); + Item_bool_func2::cleanup(); + tmp_arg[0]= orig_a; + tmp_arg[1]= orig_b; + DBUG_VOID_RETURN; + } + Item *neg_transformer(THD *thd); + virtual Item *negated_item(); +}; class Item_func_not :public Item_bool_func { public: Item_func_not(Item *a) :Item_bool_func(a) {} longlong val_int(); + enum Functype functype() const { return NOT_FUNC; } const char *func_name() const { return "not"; } + Item *neg_transformer(THD *thd); }; -class Item_func_eq :public Item_bool_func2 +class Item_func_not_all :public Item_func_not { + bool abort_on_null; public: - Item_func_eq(Item *a,Item *b) :Item_bool_func2(a,b) { }; + bool show; + + Item_func_not_all(Item *a) :Item_func_not(a), abort_on_null(0), show(0) {} + virtual void top_level_item() { abort_on_null= 1; } + bool top_level() { return abort_on_null; } + longlong val_int(); + enum Functype functype() const { return NOT_ALL_FUNC; } + const char *func_name() const { return "<not>"; } + void print(String *str); +}; + +class Item_func_eq :public Item_bool_rowready_func2 +{ +public: + Item_func_eq(Item *a,Item *b) :Item_bool_rowready_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; } const char *func_name() const { return "="; } + Item *negated_item(); }; -class Item_func_equal :public Item_bool_func2 +class Item_func_equal :public Item_bool_rowready_func2 { - Item_result cmp_result_type; public: - Item_func_equal(Item *a,Item *b) :Item_bool_func2(a,b) { }; + Item_func_equal(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}; longlong val_int(); void fix_length_and_dec(); enum Functype functype() const { return EQUAL_FUNC; } enum Functype rev_functype() const { return EQUAL_FUNC; } cond_result eq_cmp_result() const { return COND_TRUE; } const char *func_name() const { return "<=>"; } - unsigned int size_of() { return sizeof(*this);} + Item *neg_transformer(THD *thd) { return 0; } }; -class Item_func_ge :public Item_bool_func2 +class Item_func_ge :public Item_bool_rowready_func2 { public: - Item_func_ge(Item *a,Item *b) :Item_bool_func2(a,b) { }; + Item_func_ge(Item *a,Item *b) :Item_bool_rowready_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; } const char *func_name() const { return ">="; } + Item *negated_item(); }; -class Item_func_gt :public Item_bool_func2 +class Item_func_gt :public Item_bool_rowready_func2 { public: - Item_func_gt(Item *a,Item *b) :Item_bool_func2(a,b) { }; + Item_func_gt(Item *a,Item *b) :Item_bool_rowready_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; } const char *func_name() const { return ">"; } + Item *negated_item(); }; -class Item_func_le :public Item_bool_func2 +class Item_func_le :public Item_bool_rowready_func2 { public: - Item_func_le(Item *a,Item *b) :Item_bool_func2(a,b) { }; + Item_func_le(Item *a,Item *b) :Item_bool_rowready_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; } const char *func_name() const { return "<="; } + Item *negated_item(); }; -class Item_func_lt :public Item_bool_func2 +class Item_func_lt :public Item_bool_rowready_func2 { public: - Item_func_lt(Item *a,Item *b) :Item_bool_func2(a,b) { } + Item_func_lt(Item *a,Item *b) :Item_bool_rowready_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; } const char *func_name() const { return "<"; } + Item *negated_item(); }; -class Item_func_ne :public Item_bool_func2 +class Item_func_ne :public Item_bool_rowready_func2 { public: - Item_func_ne(Item *a,Item *b) :Item_bool_func2(a,b) { } + Item_func_ne(Item *a,Item *b) :Item_bool_rowready_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; } + optimize_type select_optimize() const { return OPTIMIZE_KEY; } const char *func_name() const { return "<>"; } + Item *negated_item(); }; class Item_func_between :public Item_int_func { - int (*string_compare)(const String *x,const String *y); + DTCollation cmp_collation; public: Item_result cmp_type; String value0,value1,value2; @@ -158,6 +357,8 @@ public: enum Functype functype() const { return BETWEEN; } const char *func_name() const { return "between"; } void fix_length_and_dec(); + void print(String *str); + CHARSET_INFO *compare_collation() { return cmp_collation.collation; } }; @@ -166,7 +367,6 @@ 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; } const char *func_name() const { return "strcmp"; } }; @@ -174,36 +374,34 @@ public: class Item_func_interval :public Item_int_func { - Item *item; + Item_row *row; double *intervals; public: - Item_func_interval(Item *a,List<Item> &list) - :Item_int_func(list),item(a),intervals(0) {} + Item_func_interval(Item_row *a) + :Item_int_func(a),row(a),intervals(0) { allowed_arg_cols= a->cols(); } 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 split_sum_func(List<Item> &fields); void fix_length_and_dec(); - ~Item_func_interval() { delete item; } const char *func_name() const { return "interval"; } - void update_used_tables(); - unsigned int size_of() { return sizeof(*this);} }; class Item_func_ifnull :public Item_func { enum Item_result cached_result_type; + enum_field_types cached_field_type; + bool field_type_defined; public: - Item_func_ifnull(Item *a,Item *b) :Item_func(a,b) { } + Item_func_ifnull(Item *a,Item *b) + :Item_func(a,b), cached_result_type(INT_RESULT) + {} double val(); longlong val_int(); String *val_str(String *str); enum Item_result result_type () const { return cached_result_type; } + enum_field_types field_type() const; void fix_length_and_dec(); const char *func_name() const { return "ifnull"; } + Field *tmp_table_field(TABLE *table); table_map not_null_tables() const { return 0; } }; @@ -212,15 +410,18 @@ 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) { } + Item_func_if(Item *a,Item *b,Item *c) + :Item_func(a,b,c), cached_result_type(INT_RESULT) + {} double val(); longlong val_int(); String *val_str(String *str); enum Item_result result_type () const { return cached_result_type; } - bool fix_fields(THD *thd,struct st_table_list *tlist) + bool fix_fields(THD *thd,struct st_table_list *tlist, Item **ref) { + DBUG_ASSERT(fixed == 0); args[0]->top_level_item(); - return Item_func::fix_fields(thd,tlist); + return Item_func::fix_fields(thd, tlist, ref); } void fix_length_and_dec(); const char *func_name() const { return "if"; } @@ -232,13 +433,16 @@ class Item_func_nullif :public Item_bool_func2 { enum Item_result cached_result_type; public: - Item_func_nullif(Item *a,Item *b) :Item_bool_func2(a,b) { } + Item_func_nullif(Item *a,Item *b) + :Item_bool_func2(a,b), cached_result_type(INT_RESULT) + {} double val(); longlong val_int(); String *val_str(String *str); enum Item_result result_type () const { return cached_result_type; } void fix_length_and_dec(); const char *func_name() const { return "nullif"; } + void print(String *str) { Item_func::print(str); } table_map not_null_tables() const { return 0; } bool is_null(); }; @@ -248,7 +452,9 @@ class Item_func_coalesce :public Item_func { enum Item_result cached_result_type; public: - Item_func_coalesce(List<Item> &list) :Item_func(list) {} + Item_func_coalesce(List<Item> &list) + :Item_func(list),cached_result_type(INT_RESULT) + {} double val(); longlong val_int(); String *val_str(String *); @@ -261,25 +467,40 @@ public: class Item_func_case :public Item_func { - Item * first_expr, *else_expr; + int first_expr_num, else_expr_num; enum Item_result cached_result_type; String tmp_value; -public: - Item_func_case(List<Item> &list, Item *first_expr_, Item *else_expr_) - :Item_func(list), first_expr(first_expr_), else_expr(else_expr_) {} + uint ncases; + Item_result cmp_type; + DTCollation cmp_collation; +public: + Item_func_case(List<Item> &list, Item *first_expr_arg, Item *else_expr_arg) + :Item_func(), first_expr_num(-1), else_expr_num(-1), + cached_result_type(INT_RESULT) + { + ncases= list.elements; + if (first_expr_arg) + { + first_expr_num= list.elements; + list.push_back(first_expr_arg); + } + if (else_expr_arg) + { + else_expr_num= list.elements; + list.push_back(else_expr_arg); + } + set_arguments(list); + } double val(); longlong val_int(); String *val_str(String *); void fix_length_and_dec(); - void update_used_tables(); table_map not_null_tables() const { return 0; } enum Item_result result_type () const { return cached_result_type; } const char *func_name() const { return "case"; } void print(String *str); - bool fix_fields(THD *thd,struct st_table_list *tlist); - void split_sum_func(List<Item> &fields); Item *find_item(String *str); - unsigned int size_of() { return sizeof(*this);} + CHARSET_INFO *compare_collation() { return cmp_collation.collation; } }; @@ -290,37 +511,38 @@ class in_vector :public Sql_alloc protected: char *base; uint size; - qsort_cmp compare; + qsort2_cmp compare; + CHARSET_INFO *collation; uint count; public: uint used_count; - in_vector(uint elements,uint element_length,qsort_cmp cmp_func) + in_vector() {} + in_vector(uint elements,uint element_length,qsort2_cmp cmp_func, + CHARSET_INFO *cmp_coll) :base((char*) sql_calloc(elements*element_length)), - size(element_length), compare(cmp_func), count(elements), - used_count(elements) {} + size(element_length), compare(cmp_func), collation(cmp_coll), + 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); + qsort2(base,used_count,size,compare,collation); } 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(uint elements,qsort2_cmp cmp_func, CHARSET_INFO *cs); ~in_string(); void set(uint pos,Item *item); byte *get_value(Item *item); }; - class in_longlong :public in_vector { longlong tmp; @@ -330,7 +552,6 @@ public: byte *get_value(Item *item); }; - class in_double :public in_vector { double tmp; @@ -340,7 +561,6 @@ public: byte *get_value(Item *item); }; - /* ** Classes for easy comparing of non const items */ @@ -348,111 +568,198 @@ public: class cmp_item :public Sql_alloc { public: - cmp_item() {} + CHARSET_INFO *cmp_charset; + cmp_item() { cmp_charset= &my_charset_bin; } virtual ~cmp_item() {} - virtual void store_value(Item *item)=0; - virtual int cmp(Item *item)=0; + virtual void store_value(Item *item)= 0; + virtual int cmp(Item *item)= 0; + // for optimized IN with row + virtual int compare(cmp_item *item)= 0; + static cmp_item* get_comparator(Item *); + virtual cmp_item *make_same()= 0; + virtual void store_value_by_template(cmp_item *tmpl, Item *item) + { + store_value(item); + } }; - -class cmp_item_sort_string :public cmp_item { - protected: - char value_buff[80]; - String value,*value_res; +class cmp_item_string :public cmp_item +{ +protected: + String *value_res; public: - cmp_item_sort_string() :value(value_buff,sizeof(value_buff)) {} - void store_value(Item *item) - { - value_res=item->val_str(&value); - } - int cmp(Item *arg) - { - char buff[80]; - String tmp(buff,sizeof(buff)),*res; - if (!(res=arg->val_str(&tmp))) - return 1; /* Can't be right */ - return sortcmp(value_res,res); - } + cmp_item_string (CHARSET_INFO *cs) { cmp_charset= cs; } + friend class cmp_item_sort_string; + friend class cmp_item_sort_string_in_static; }; -class cmp_item_binary_string :public cmp_item_sort_string { +class cmp_item_sort_string :public cmp_item_string +{ +protected: + char value_buff[80]; + String value; public: - cmp_item_binary_string() {} + cmp_item_sort_string(CHARSET_INFO *cs): + cmp_item_string(cs), + value(value_buff, sizeof(value_buff), cs) {} + void store_value(Item *item) + { + value_res= item->val_str(&value); + } int cmp(Item *arg) - { - char buff[80]; - String tmp(buff,sizeof(buff)),*res; - if (!(res=arg->val_str(&tmp))) - return 1; /* Can't be right */ - return stringcmp(value_res,res); - } + { + char buff[80]; + String tmp(buff, sizeof(buff), cmp_charset), *res; + if (!(res= arg->val_str(&tmp))) + return 1; /* Can't be right */ + return sortcmp(value_res, res, cmp_charset); + } + int compare(cmp_item *c) + { + cmp_item_string *cmp= (cmp_item_string *)c; + return sortcmp(value_res, cmp->value_res, cmp_charset); + } + cmp_item *make_same(); }; - class cmp_item_int :public cmp_item { longlong value; public: void store_value(Item *item) - { - value=item->val_int(); - } + { + value= item->val_int(); + } int cmp(Item *arg) - { - return value != arg->val_int(); - } + { + return value != arg->val_int(); + } + int compare(cmp_item *c) + { + cmp_item_int *cmp= (cmp_item_int *)c; + return (value < cmp->value) ? -1 : ((value == cmp->value) ? 0 : 1); + } + cmp_item *make_same(); }; - class cmp_item_real :public cmp_item { double value; public: void store_value(Item *item) - { - value= item->val(); - } + { + value= item->val(); + } int cmp(Item *arg) - { - return value != arg->val(); - } + { + return value != arg->val(); + } + int compare(cmp_item *c) + { + cmp_item_real *cmp= (cmp_item_real *)c; + return (value < cmp->value)? -1 : ((value == cmp->value) ? 0 : 1); + } + cmp_item *make_same(); +}; + +class cmp_item_row :public cmp_item +{ + cmp_item **comparators; + uint n; +public: + cmp_item_row(): comparators(0), n(0) {} + ~cmp_item_row(); + void store_value(Item *item); + int cmp(Item *arg); + int compare(cmp_item *arg); + cmp_item *make_same(); + void store_value_by_template(cmp_item *tmpl, Item *); }; +class in_row :public in_vector +{ + cmp_item_row tmp; +public: + in_row(uint elements, Item *); + ~in_row(); + void set(uint pos,Item *item); + byte *get_value(Item *item); +}; + +/* + cmp_item for optimized IN with row (right part string, which never + be changed) +*/ + +class cmp_item_sort_string_in_static :public cmp_item_string +{ + protected: + String value; +public: + cmp_item_sort_string_in_static(CHARSET_INFO *cs): + cmp_item_string(cs) {} + void store_value(Item *item) + { + value_res= item->val_str(&value); + } + int cmp(Item *item) + { + // Should never be called + DBUG_ASSERT(0); + return 1; + } + int compare(cmp_item *c) + { + cmp_item_string *cmp= (cmp_item_string *)c; + return sortcmp(value_res, cmp->value_res, cmp_charset); + } + cmp_item *make_same() + { + return new cmp_item_sort_string_in_static(cmp_charset); + } +}; + class Item_func_in :public Item_int_func { - Item *item; + Item_result cmp_type; in_vector *array; cmp_item *in_item; + bool have_null; + DTCollation cmp_collation; public: - Item_func_in(Item *a,List<Item> &list) - :Item_int_func(list),item(a),array(0),in_item(0) {} - longlong val_int(); - bool fix_fields(THD *thd,struct st_table_list *tlist) + Item_func_in(List<Item> &list) + :Item_int_func(list), array(0), in_item(0), have_null(0) { - bool res= (item->fix_fields(thd,tlist) || Item_func::fix_fields(thd,tlist)); - with_sum_func= with_sum_func || item->with_sum_func; - return res; + allowed_arg_cols= args[0]->cols(); } + longlong val_int(); void fix_length_and_dec(); - ~Item_func_in() { delete item; delete array; delete in_item; } + void cleanup() + { + DBUG_ENTER("Item_func_in::cleanup"); + Item_int_func::cleanup(); + delete array; + delete in_item; + array= 0; + in_item= 0; + DBUG_VOID_RETURN; + } optimize_type select_optimize() const { return array ? OPTIMIZE_KEY : OPTIMIZE_NONE; } - Item *key_item() const { return item; } void print(String *str); enum Functype functype() const { return IN_FUNC; } const char *func_name() const { return " IN "; } - void update_used_tables(); - void split_sum_func(List<Item> &fields); - unsigned int size_of() { return sizeof(*this);} + bool nulls_in_row(); + bool is_bool_func() { return 1; } + CHARSET_INFO *compare_collation() { return cmp_collation.collation; } }; - - /* Functions used by where clause */ class Item_func_isnull :public Item_bool_func { +protected: longlong cached_value; public: Item_func_isnull(Item *a) :Item_bool_func(a) {} @@ -461,11 +768,11 @@ public: void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=0; - Item_func_isnull::update_used_tables(); + update_used_tables(); } const char *func_name() const { return "isnull"; } /* Optimize case of not_null_column IS NULL */ - void update_used_tables() + virtual void update_used_tables() { if (!args[0]->maybe_null) { @@ -485,7 +792,24 @@ public: } table_map not_null_tables() const { return 0; } optimize_type select_optimize() const { return OPTIMIZE_NULL; } - unsigned int size_of() { return sizeof(*this);} + Item *neg_transformer(THD *thd); + CHARSET_INFO *compare_collation() { return args[0]->collation.collation; } +}; + +/* Functions used by HAVING for rewriting IN subquery */ + +class Item_in_subselect; +class Item_is_not_null_test :public Item_func_isnull +{ + Item_in_subselect* owner; +public: + Item_is_not_null_test(Item_in_subselect* ow, Item *a) + :Item_func_isnull(a), owner(ow) + {} + enum Functype functype() const { return ISNOTNULLTEST_FUNC; } + longlong val_int(); + const char *func_name() const { return "<is_not_null_test>"; } + void update_used_tables(); }; @@ -502,6 +826,9 @@ public: const char *func_name() const { return "isnotnull"; } optimize_type select_optimize() const { return OPTIMIZE_NULL; } table_map not_null_tables() const { return 0; } + Item *neg_transformer(THD *thd); + void print(String *str); + CHARSET_INFO *compare_collation() { return args[0]->collation.collation; } }; @@ -522,20 +849,20 @@ class Item_func_like :public Item_bool_func2 bool turboBM_matches(const char* text, int text_len) const; enum { alphabet_size = 256 }; + Item *escape_item; + public: char escape; - Item_func_like(Item *a,Item *b, char* escape_arg) + Item_func_like(Item *a,Item *b, Item *escape_arg) :Item_bool_func2(a,b), canDoTurboBM(false), pattern(0), pattern_len(0), - bmGs(0), bmBc(0), escape(*escape_arg) {} + bmGs(0), bmBc(0), escape_item(escape_arg) {} longlong val_int(); enum Functype functype() const { return LIKE_FUNC; } optimize_type select_optimize() const; cond_result eq_cmp_result() const { return COND_TRUE; } const char *func_name() const { return "like"; } - void fix_length_and_dec(); - bool fix_fields(THD *thd,struct st_table_list *tlist); - unsigned int size_of() { return sizeof(*this);} + bool fix_fields(THD *thd, struct st_table_list *tlist, Item **ref); }; #ifdef USE_REGEX @@ -548,14 +875,16 @@ class Item_func_regex :public Item_bool_func bool regex_compiled; bool regex_is_const; String prev_regexp; + DTCollation cmp_collation; public: Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b), regex_compiled(0),regex_is_const(0) {} - ~Item_func_regex(); + void cleanup(); longlong val_int(); - bool fix_fields(THD *thd,struct st_table_list *tlist); - const char *func_name() const { return "regex"; } - unsigned int size_of() { return sizeof(*this);} + bool fix_fields(THD *thd, struct st_table_list *tlist, Item **ref); + const char *func_name() const { return "regexp"; } + void print(String *str) { print_op(str); } + CHARSET_INFO *compare_collation() { return cmp_collation.collation; } }; #else @@ -566,6 +895,7 @@ public: Item_func_regex(Item *a,Item *b) :Item_bool_func(a,b) {} longlong val_int() { return 0;} const char *func_name() const { return "regex"; } + void print(String *str) { print_op(str); } }; #endif /* USE_REGEX */ @@ -582,21 +912,31 @@ protected: public: /* Item_cond() is only used to create top level items */ - Item_cond() : Item_bool_func(), abort_on_null(1) { const_item_cache=0; } - Item_cond(Item *i1,Item *i2) :Item_bool_func(), abort_on_null(0) - { list.push_back(i1); list.push_back(i2); } + Item_cond(): Item_bool_func(), abort_on_null(1) + { const_item_cache=0; } + Item_cond(Item *i1,Item *i2) + :Item_bool_func(), abort_on_null(0) + { + list.push_back(i1); + list.push_back(i2); + } + Item_cond(THD *thd, Item_cond *item); + Item_cond(List<Item> &nlist) + :Item_bool_func(), list(nlist), abort_on_null(0) {} bool add(Item *item) { return list.push_back(item); } - bool fix_fields(THD *,struct st_table_list *); + bool fix_fields(THD *, struct st_table_list *, Item **ref); enum Type type() const { return COND_ITEM; } List<Item>* argument_list() { return &list; } table_map used_tables() const; void update_used_tables(); void print(String *str); - void split_sum_func(List<Item> &fields); + void split_sum_func(Item **ref_pointer_array, List<Item> &fields); friend int setup_conds(THD *thd,TABLE_LIST *tables,COND **conds); - unsigned int size_of() { return sizeof(*this);} void top_level_item() { abort_on_null=1; } + void copy_andor_arguments(THD *thd, Item_cond *item); + bool walk(Item_processor processor, byte *arg); + void neg_arguments(THD *thd); }; @@ -605,9 +945,19 @@ class Item_cond_and :public Item_cond public: Item_cond_and() :Item_cond() {} Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {} + Item_cond_and(THD *thd, Item_cond_and *item) :Item_cond(thd, item) {} + Item_cond_and(List<Item> &list): Item_cond(list) {} enum Functype functype() const { return COND_AND_FUNC; } longlong val_int(); const char *func_name() const { return "and"; } + Item* copy_andor_structure(THD *thd) + { + Item_cond_and *item; + if ((item= new Item_cond_and(thd, this))) + item->copy_andor_arguments(thd, this); + return item; + } + Item *neg_transformer(THD *thd); }; class Item_cond_or :public Item_cond @@ -615,29 +965,28 @@ class Item_cond_or :public Item_cond public: Item_cond_or() :Item_cond() {} Item_cond_or(Item *i1,Item *i2) :Item_cond(i1,i2) {} + Item_cond_or(THD *thd, Item_cond_or *item) :Item_cond(thd, item) {} + Item_cond_or(List<Item> &list): Item_cond(list) {} enum Functype functype() const { return COND_OR_FUNC; } longlong val_int(); const char *func_name() const { return "or"; } table_map not_null_tables() const { return and_tables_cache; } + Item* copy_andor_structure(THD *thd) + { + Item_cond_or *item; + if ((item= new Item_cond_or(thd, this))) + item->copy_andor_arguments(thd, this); + return item; + } + Item *neg_transformer(THD *thd); }; -/* Some usefull inline functions */ - -inline Item *and_conds(Item *a,Item *b) -{ - if (!b) return a; - if (!a) return b; - Item *cond=new Item_cond_and(a,b); - if (cond) - cond->update_used_tables(); - return cond; -} - /* XOR is Item_cond, not an Item_int_func bevause we could like to optimize (a XOR b) later on. It's low prio, though */ + class Item_cond_xor :public Item_cond { public: @@ -651,4 +1000,13 @@ public: }; +/* Some usefull inline functions */ + +inline Item *and_conds(Item *a, Item *b) +{ + if (!b) return a; + if (!a) return b; + return new Item_cond_and(a, b); +} + Item *and_expressions(Item *a, Item *b, Item **org_item); |