diff options
Diffstat (limited to 'sql/item_cmpfunc.cc')
| -rw-r--r-- | sql/item_cmpfunc.cc | 1298 |
1 files changed, 1298 insertions, 0 deletions
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc new file mode 100644 index 00000000000..0a75998ffe1 --- /dev/null +++ b/sql/item_cmpfunc.cc @@ -0,0 +1,1298 @@ +/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult 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 + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + + +/* This file defines all compare functions */ + +#ifdef __GNUC__ +#pragma implementation // gcc: Class implementation +#endif + +#include "mysql_priv.h" +#include <m_ctype.h> + +/* +** Test functions +** These returns 0LL if false and 1LL if true and null if some arg is null +** 'AND' and 'OR' never return null +*/ + +longlong Item_func_not::val_int() +{ + double value=args[0]->val(); + null_value=args[0]->null_value; + return !null_value && value == 0 ? 1 : 0; +} + + +static bool convert_constant_item(Field *field, Item **item) +{ + if ((*item)->const_item()) + { + (*item)->save_in_field(field); + if (!((*item)->null_value)) + { + Item *tmp=new Item_int(field->val_int()); + if ((tmp)) + *item=tmp; + return 1; + } + } + return 0; +} + + +void Item_bool_func2::fix_length_and_dec() +{ + max_length=1; + + /* As some compare functions are generated after sql_yacc, + we have to check for out of memory conditons here */ + if (!args[0] || !args[1]) + return; + // Make a special case of compare with fields to get nicer DATE comparisons + if (args[0]->type() == FIELD_ITEM) + { + Field *field=((Item_field*) args[0])->field; + if (field->store_for_compare()) + { + if (convert_constant_item(field,&args[1])) + { + cmp_func= &Item_bool_func2::compare_int; // Works for all types. + return; + } + } + } + if (args[1]->type() == FIELD_ITEM) + { + Field *field=((Item_field*) args[1])->field; + if (field->store_for_compare()) + { + if (convert_constant_item(field,&args[0])) + { + cmp_func= &Item_bool_func2::compare_int; // Works for all types. + return; + } + } + } + set_cmp_func(item_cmp_type(args[0]->result_type(),args[1]->result_type())); +} + + +void Item_bool_func2::set_cmp_func(Item_result type) +{ + switch (type) { + case STRING_RESULT: + cmp_func=&Item_bool_func2::compare_string; + break; + case REAL_RESULT: + cmp_func=&Item_bool_func2::compare_real; + break; + case INT_RESULT: + cmp_func=&Item_bool_func2::compare_int; + break; + } +} + + +int Item_bool_func2::compare_string() +{ + String *res1,*res2; + if ((res1=args[0]->val_str(&tmp_value1))) + { + if ((res2=args[1]->val_str(&tmp_value2))) + { + null_value=0; + return binary ? stringcmp(res1,res2) : sortcmp(res1,res2); + } + } + null_value=1; + return -1; +} + +int Item_bool_func2::compare_real() +{ + double val1=args[0]->val(); + if (!args[0]->null_value) + { + double val2=args[1]->val(); + if (!args[1]->null_value) + { + null_value=0; + if (val1 < val2) return -1; + if (val1 == val2) return 0; + return 1; + } + } + null_value=1; + return -1; +} + + +int Item_bool_func2::compare_int() +{ + longlong val1=args[0]->val_int(); + if (!args[0]->null_value) + { + longlong val2=args[1]->val_int(); + if (!args[1]->null_value) + { + null_value=0; + if (val1 < val2) return -1; + if (val1 == val2) return 0; + return 1; + } + } + null_value=1; + return -1; +} + + + +longlong Item_func_eq::val_int() +{ + int value=(this->*cmp_func)(); + return value == 0 ? 1 : 0; +} + +/* Same as Item_func_eq, but NULL = NULL */ + +longlong Item_func_equal::val_int() +{ + int value=(this->*cmp_func)(); + if (null_value) + { + null_value=0; + return (args[0]->null_value && args[1]->null_value) ? 1 : 0; + } + return value == 0; +} + + +longlong Item_func_ne::val_int() +{ + int value=(this->*cmp_func)(); + return value != 0 ? 1 : 0; +} + + +longlong Item_func_ge::val_int() +{ + int value=(this->*cmp_func)(); + return value >= 0 ? 1 : 0; +} + + +longlong Item_func_gt::val_int() +{ + int value=(this->*cmp_func)(); + return value > 0 ? 1 : 0; +} + +longlong Item_func_le::val_int() +{ + int value=(this->*cmp_func)(); + return value <= 0 && !null_value ? 1 : 0; +} + + +longlong Item_func_lt::val_int() +{ + int value=(this->*cmp_func)(); + return value < 0 && !null_value ? 1 : 0; +} + + +longlong Item_func_strcmp::val_int() +{ + String *a=args[0]->val_str(&tmp_value1); + String *b=args[1]->val_str(&tmp_value2); + if (!a || !b) + { + null_value=1; + return 0; + } + int value=stringcmp(a,b); + null_value=0; + return !value ? 0 : (value < 0 ? (longlong) -1 : (longlong) 1); +} + + +void Item_func_interval::fix_length_and_dec() +{ + bool nums=1; + uint i; + for (i=0 ; i < arg_count ; i++) + { + if (!args[i]) + return; // End of memory + if (args[i]->type() != Item::INT_ITEM && + args[i]->type() != Item::REAL_ITEM) + { + nums=0; + break; + } + } + if (nums && arg_count >= 8) + { + if ((intervals=(double*) sql_alloc(sizeof(double)*arg_count))) + { + for (i=0 ; i < arg_count ; i++) + intervals[i]=args[i]->val(); + } + } + maybe_null=0; max_length=2; + used_tables_cache|=item->used_tables(); +} + +/* + return -1 if null value, + 0 if lower than lowest + 1 - arg_count if between args[n] and args[n+1] + arg_count+1 if higher than biggest argument +*/ + +longlong Item_func_interval::val_int() +{ + double value=item->val(); + if (item->null_value) + return -1; // -1 if null /* purecov: inspected */ + if (intervals) + { // Use binary search to find interval + uint start,end; + start=0; end=arg_count-1; + while (start != end) + { + uint mid=(start+end+1)/2; + if (intervals[mid] <= value) + start=mid; + else + end=mid-1; + } + return (value < intervals[start]) ? 0 : start+1; + } + if (args[0]->val() > value) + return 0; + for (uint i=1 ; i < arg_count ; i++) + { + if (args[i]->val() > value) + return i; + } + return (longlong) arg_count; +} + + +void Item_func_interval::update_used_tables() +{ + Item_func::update_used_tables(); + item->update_used_tables(); + used_tables_cache|=item->used_tables(); + const_item_cache&=item->const_item(); +} + +void Item_func_between::fix_length_and_dec() +{ + max_length=1; + + /* As some compare functions are generated after sql_yacc, + we have to check for out of memory conditons here */ + if (!args[0] || !args[1] || !args[2]) + return; + cmp_type=args[0]->result_type(); + if (args[0]->binary) + string_compare=stringcmp; + else + string_compare=sortcmp; + + // Make a special case of compare with fields to get nicer DATE comparisons + if (args[0]->type() == FIELD_ITEM) + { + Field *field=((Item_field*) args[0])->field; + if (field->store_for_compare()) + { + if (convert_constant_item(field,&args[1])) + cmp_type=INT_RESULT; // Works for all types. + if (convert_constant_item(field,&args[2])) + cmp_type=INT_RESULT; // Works for all types. + } + } +} + + +longlong Item_func_between::val_int() +{ // ANSI BETWEEN + if (cmp_type == STRING_RESULT) + { + String *value,*a,*b; + value=args[0]->val_str(&value0); + if ((null_value=args[0]->null_value)) + return 0; + a=args[1]->val_str(&value1); + b=args[2]->val_str(&value2); + if (!args[1]->null_value && !args[2]->null_value) + return (string_compare(value,a) >= 0 && string_compare(value,b) <= 0) ? + 1 : 0; + if (args[1]->null_value && args[2]->null_value) + null_value=1; + else if (args[1]->null_value) + { + null_value= string_compare(value,b) <= 0; // not null if false range. + } + else + { + null_value= string_compare(value,a) >= 0; // not null if false range. + } + } + else if (cmp_type == INT_RESULT) + { + longlong value=args[0]->val_int(),a,b; + if ((null_value=args[0]->null_value)) + return 0; /* purecov: inspected */ + a=args[1]->val_int(); + b=args[2]->val_int(); + if (!args[1]->null_value && !args[2]->null_value) + return (value >= a && value <= b) ? 1 : 0; + if (args[1]->null_value && args[2]->null_value) + null_value=1; + else if (args[1]->null_value) + { + null_value= value <= b; // not null if false range. + } + else + { + null_value= value >= a; + } + } + else + { + double value=args[0]->val(),a,b; + if ((null_value=args[0]->null_value)) + return 0; /* purecov: inspected */ + a=args[1]->val(); + b=args[2]->val(); + if (!args[1]->null_value && !args[2]->null_value) + return (value >= a && value <= b) ? 1 : 0; + if (args[1]->null_value && args[2]->null_value) + null_value=1; + else if (args[1]->null_value) + { + null_value= value <= b; // not null if false range. + } + else + { + null_value= value >= a; + } + } + return 0; +} + +void +Item_func_ifnull::fix_length_and_dec() +{ + maybe_null=args[1]->maybe_null; + max_length=max(args[0]->max_length,args[1]->max_length); + decimals=max(args[0]->decimals,args[1]->decimals); + cached_result_type=args[0]->result_type(); +} + +double +Item_func_ifnull::val() +{ + double value=args[0]->val(); + if (!args[0]->null_value) + { + null_value=0; + return value; + } + value=args[1]->val(); + if ((null_value=args[1]->null_value)) + return 0.0; + return value; +} + +longlong +Item_func_ifnull::val_int() +{ + longlong value=args[0]->val_int(); + if (!args[0]->null_value) + { + null_value=0; + return value; + } + value=args[1]->val_int(); + if ((null_value=args[1]->null_value)) + return 0; + return value; +} + +String * +Item_func_ifnull::val_str(String *str) +{ + String *res =args[0]->val_str(str); + if (!args[0]->null_value) + { + null_value=0; + return res; + } + res=args[1]->val_str(str); + if ((null_value=args[1]->null_value)) + return 0; + return res; +} + +void +Item_func_if::fix_length_and_dec() +{ + maybe_null=args[1]->maybe_null || args[2]->maybe_null; + max_length=max(args[1]->max_length,args[2]->max_length); + decimals=max(args[0]->decimals,args[1]->decimals); + enum Item_result arg1_type=args[1]->result_type(); + enum Item_result arg2_type=args[2]->result_type(); + if (arg1_type == STRING_RESULT || arg2_type == STRING_RESULT) + cached_result_type = STRING_RESULT; + else if (arg1_type == REAL_RESULT || arg2_type == REAL_RESULT) + cached_result_type = REAL_RESULT; + else + cached_result_type=arg1_type; // Should be INT_RESULT +} + + +double +Item_func_if::val() +{ + Item *arg= args[0]->val_int() ? args[1] : args[2]; + double value=arg->val(); + null_value=arg->null_value; + return value; +} + +longlong +Item_func_if::val_int() +{ + Item *arg= args[0]->val_int() ? args[1] : args[2]; + longlong value=arg->val_int(); + null_value=arg->null_value; + return value; +} + +String * +Item_func_if::val_str(String *str) +{ + Item *arg= args[0]->val_int() ? args[1] : args[2]; + String *res=arg->val_str(str); + null_value=arg->null_value; + return res; +} + + +void +Item_func_nullif::fix_length_and_dec() +{ + Item_bool_func2::fix_length_and_dec(); + maybe_null=1; + if (args[0]) // Only false if EOM + { + max_length=args[0]->max_length; + decimals=args[0]->decimals; + cached_result_type=args[0]->result_type(); + } +} + +/* + nullif() returns NULL if arguments are different, else it returns the + first argument. + Note that we have to evaluate the first argument twice as the compare + may have been done with a different type than return value +*/ + +double +Item_func_nullif::val() +{ + double value; + if (!(this->*cmp_func)() || null_value) + { + null_value=1; + return 0.0; + } + value=args[0]->val(); + null_value=args[0]->null_value; + return value; +} + +longlong +Item_func_nullif::val_int() +{ + longlong value; + if (!(this->*cmp_func)() || null_value) + { + null_value=1; + return 0; + } + value=args[0]->val_int(); + null_value=args[0]->null_value; + return value; +} + +String * +Item_func_nullif::val_str(String *str) +{ + String *res; + if (!(this->*cmp_func)() || null_value) + { + null_value=1; + return 0; + } + res=args[0]->val_str(str); + null_value=args[0]->null_value; + return res; +} + +/* +** CASE expression +*/ + +/* Return the matching ITEM or NULL if all compares (including else) failed */ + +Item *Item_func_case::find_item(String *str) +{ + String *first_expr_str,*tmp; + longlong first_expr_int; + double first_expr_real; + bool int_used, real_used,str_used; + int_used=real_used=str_used=0; + + /* These will be initialized later */ + LINT_INIT(first_expr_str); + LINT_INIT(first_expr_int); + LINT_INIT(first_expr_real); + + // Compare every WHEN argument with it and return the first match + for (uint i=0 ; i < arg_count ; i+=2) + { + if (!first_expr) + { + // No expression between CASE and first WHEN + if (args[i]->val_int()) + return args[i+1]; + continue; + } + switch (args[i]->result_type()) { + case STRING_RESULT: + if (!str_used) + { + str_used=1; + // We can't use 'str' here as this may be overwritten + if (!(first_expr_str= first_expr->val_str(&str_value))) + return else_expr; // Impossible + } + if ((tmp=args[i]->val_str(str))) // If not null + { + if (first_expr->binary || args[i]->binary) + { + if (stringcmp(tmp,first_expr_str)==0) + return args[i+1]; + } + else if (sortcmp(tmp,first_expr_str)==0) + return args[i+1]; + } + break; + case INT_RESULT: + if (!int_used) + { + int_used=1; + first_expr_int= first_expr->val_int(); + if (first_expr->null_value) + return else_expr; + } + if (args[i]->val_int()==first_expr_int && !args[i]->null_value) + return args[i+1]; + break; + case REAL_RESULT: + if (!real_used) + { + real_used=1; + first_expr_real= first_expr->val(); + if (first_expr->null_value) + return else_expr; + } + if (args[i]->val()==first_expr_real && !args[i]->null_value) + return args[i+1]; + } + } + // No, WHEN clauses all missed, return ELSE expression + return else_expr; +} + + + +String *Item_func_case::val_str(String *str) +{ + String *res; + Item *item=find_item(str); + + if (!item) + { + null_value=1; + return 0; + } + if (!(res=item->val_str(str))) + null_value=1; + return res; +} + + +longlong Item_func_case::val_int() +{ + char buff[MAX_FIELD_WIDTH]; + String dummy_str(buff,sizeof(buff)); + Item *item=find_item(&dummy_str); + longlong res; + + if (!item) + { + null_value=1; + return 0; + } + res=item->val_int(); + null_value=item->null_value; + return res; +} + +double Item_func_case::val() +{ + char buff[MAX_FIELD_WIDTH]; + String dummy_str(buff,sizeof(buff)); + Item *item=find_item(&dummy_str); + double res; + + if (!item) + { + null_value=1; + return 0; + } + res=item->val(); + null_value=item->null_value; + return res; +} + + +bool +Item_func_case::fix_fields(THD *thd,TABLE_LIST *tables) +{ + + if (first_expr && first_expr->fix_fields(thd,tables) || + else_expr && else_expr->fix_fields(thd,tables)) + return 1; + if (Item_func::fix_fields(thd,tables)) + return 1; + if (!else_expr || else_expr->maybe_null) + maybe_null=1; // The result may be NULL + return 0; +} + + +void Item_func_case::fix_length_and_dec() +{ + max_length=0; + decimals=0; + cached_result_type = args[1]->result_type(); + for (uint i=0 ; i < arg_count ; i+=2) + { + set_if_bigger(max_length,args[i+1]->max_length); + set_if_bigger(decimals,args[i+1]->decimals); + } + if (else_expr != NULL) + { + set_if_bigger(max_length,else_expr->max_length); + set_if_bigger(decimals,else_expr->decimals); + } +} + + +void Item_func_case::print(String *str) +{ + str->append("case "); // Not yet complete +} + +/* +** Coalesce - return first not NULL argument. +*/ + +String *Item_func_coalesce::val_str(String *str) +{ + null_value=0; + for (uint i=0 ; i < arg_count ; i++) + { + if (args[i]->val_str(str) != NULL) + return args[i]->val_str(str); + } + null_value=1; + return 0; +} + +longlong Item_func_coalesce::val_int() +{ + null_value=0; + for (uint i=0 ; i < arg_count ; i++) + { + longlong res=args[i]->val_int(); + if (!args[i]->null_value) + return res; + } + null_value=1; + return 0; +} + +double Item_func_coalesce::val() +{ + null_value=0; + for (uint i=0 ; i < arg_count ; i++) + { + double res=args[i]->val(); + if (!args[i]->null_value) + return res; + } + null_value=1; + return 0; +} + + +void Item_func_coalesce::fix_length_and_dec() +{ + max_length=0; + decimals=0; + cached_result_type = args[0]->result_type(); + for (uint i=0 ; i < arg_count ; i++) + { + set_if_bigger(max_length,args[i]->max_length); + set_if_bigger(decimals,args[i]->decimals); + } +} + +/**************************************************************************** +** classes and function for the IN operator +****************************************************************************/ + +static int cmp_longlong(longlong *a,longlong *b) +{ + return *a < *b ? -1 : *a == *b ? 0 : 1; +} + +static int cmp_double(double *a,double *b) +{ + return *a < *b ? -1 : *a == *b ? 0 : 1; +} + +int in_vector::find(Item *item) +{ + byte *result=get_value(item); + if (!result || !used_count) + return 0; // Null value + + uint start,end; + start=0; end=used_count-1; + while (start != end) + { + uint mid=(start+end+1)/2; + int res; + if ((res=(*compare)(base+mid*size,result)) == 0) + return 1; + if (res < 0) + start=mid; + else + end=mid-1; + } + return (int) ((*compare)(base+start*size,result) == 0); +} + + +in_string::in_string(uint elements,qsort_cmp cmp_func) + :in_vector(elements,sizeof(String),cmp_func),tmp(buff,sizeof(buff)) +{} + +in_string::~in_string() +{ + for (uint i=0 ; i < count ; i++) + ((String*) base)[i].free(); +} + +void in_string::set(uint pos,Item *item) +{ + String *str=((String*) base)+pos; + String *res=item->val_str(str); + if (res && res != str) + *str= *res; +} + +byte *in_string::get_value(Item *item) +{ + return (byte*) item->val_str(&tmp); +} + + +in_longlong::in_longlong(uint elements) + :in_vector(elements,sizeof(longlong),(qsort_cmp) cmp_longlong) +{} + +void in_longlong::set(uint pos,Item *item) +{ + ((longlong*) base)[pos]=item->val_int(); +} + +byte *in_longlong::get_value(Item *item) +{ + tmp=item->val_int(); + if (item->null_value) + return 0; /* purecov: inspected */ + return (byte*) &tmp; +} + + +in_double::in_double(uint elements) + :in_vector(elements,sizeof(double),(qsort_cmp) cmp_double) +{} + +void in_double::set(uint pos,Item *item) +{ + ((double*) base)[pos]=item->val(); +} + +byte *in_double::get_value(Item *item) +{ + tmp=item->val(); + if (item->null_value) + return 0; /* purecov: inspected */ + return (byte*) &tmp; +} + + +void Item_func_in::fix_length_and_dec() +{ + if (const_item()) + { + switch (item->result_type()) { + case STRING_RESULT: + if (item->binary) + array=new in_string(arg_count,(qsort_cmp) stringcmp); /* purecov: inspected */ + else + array=new in_string(arg_count,(qsort_cmp) sortcmp); + break; + case INT_RESULT: + array= new in_longlong(arg_count); + break; + case REAL_RESULT: + array= new in_double(arg_count); + break; + } + uint j=0; + for (uint i=0 ; i < arg_count ; i++) + { + array->set(j,args[i]); + if (!args[i]->null_value) // Skipp NULL values + j++; + } + if ((array->used_count=j)) + array->sort(); + } + else + { + switch (item->result_type()) { + case STRING_RESULT: + if (item->binary) + in_item= new cmp_item_binary_string; + else + in_item= new cmp_item_sort_string; + break; + case INT_RESULT: + in_item= new cmp_item_int; + break; + case REAL_RESULT: + in_item= new cmp_item_real; + break; + } + } + maybe_null= item->maybe_null; + max_length=2; + used_tables_cache|=item->used_tables(); + const_item_cache&=item->const_item(); +} + + +void Item_func_in::print(String *str) +{ + str->append('('); + item->print(str); + Item_func::print(str); + str->append(')'); +} + + +longlong Item_func_in::val_int() +{ + if (array) + { + int tmp=array->find(item); + null_value=item->null_value; + return tmp; + } + in_item->store_value(item); + if ((null_value=item->null_value)) + return 0; + for (uint i=0 ; i < arg_count ; i++) + { + if (!in_item->cmp(args[i]) && !args[i]->null_value) + return 1; // Would maybe be nice with i ? + } + return 0; +} + + +void Item_func_in::update_used_tables() +{ + Item_func::update_used_tables(); + item->update_used_tables(); + used_tables_cache|=item->used_tables(); + const_item_cache&=item->const_item(); +} + + +longlong Item_func_bit_or::val_int() +{ + ulonglong arg1= (ulonglong) args[0]->val_int(); + if (args[0]->null_value) + { + null_value=1; /* purecov: inspected */ + return 0; /* purecov: inspected */ + } + ulonglong arg2= (ulonglong) args[1]->val_int(); + if (args[1]->null_value) + { + null_value=1; + return 0; + } + null_value=0; + return (longlong) (arg1 | arg2); +} + + +longlong Item_func_bit_and::val_int() +{ + ulonglong arg1= (ulonglong) args[0]->val_int(); + if (args[0]->null_value) + { + null_value=1; /* purecov: inspected */ + return 0; /* purecov: inspected */ + } + ulonglong arg2= (ulonglong) args[1]->val_int(); + if (args[1]->null_value) + { + null_value=1; /* purecov: inspected */ + return 0; /* purecov: inspected */ + } + null_value=0; + return (longlong) (arg1 & arg2); +} + + +bool +Item_cond::fix_fields(THD *thd,TABLE_LIST *tables) +{ + List_iterator<Item> li(list); + Item *item; + char buff[sizeof(char*)]; // Max local vars in function + used_tables_cache=0; + const_item_cache=0; + + if (thd && check_stack_overrun(thd,buff)) + return 0; // Fatal error flag is set! + while ((item=li++)) + { + while (item->type() == Item::COND_ITEM && + ((Item_cond*) item)->functype() == functype()) + { // Identical function + li.replace(((Item_cond*) item)->list); + ((Item_cond*) item)->list.empty(); +#ifdef DELETE_ITEMS + delete (Item_cond*) item; +#endif + item= *li.ref(); // new current item + } + if (item->fix_fields(thd,tables)) + return 1; /* purecov: inspected */ + used_tables_cache|=item->used_tables(); + with_sum_func= with_sum_func || item->with_sum_func; + const_item_cache&=item->const_item(); + } + if (thd) + thd->cond_count+=list.elements; + fix_length_and_dec(); + return 0; +} + + +void Item_cond::split_sum_func(List<Item> &fields) +{ + List_iterator<Item> li(list); + Item *item; + used_tables_cache=0; + const_item_cache=0; + while ((item=li++)) + { + if (item->with_sum_func && item->type() != SUM_FUNC_ITEM) + item->split_sum_func(fields); + else if (item->used_tables() || item->type() == SUM_FUNC_ITEM) + { + fields.push_front(item); + li.replace(new Item_ref((Item**) fields.head_ref(),0,item->name)); + } + item->update_used_tables(); + used_tables_cache|=item->used_tables(); + const_item_cache&=item->const_item(); + } +} + + +table_map +Item_cond::used_tables() const +{ // This caches used_tables + return used_tables_cache; +} + +void Item_cond::update_used_tables() +{ + used_tables_cache=0; + const_item_cache=1; + List_iterator<Item> li(list); + Item *item; + while ((item=li++)) + { + item->update_used_tables(); + used_tables_cache|=item->used_tables(); + const_item_cache&= item->const_item(); + } +} + + +void Item_cond::print(String *str) +{ + str->append('('); + List_iterator<Item> li(list); + Item *item; + if ((item=li++)) + item->print(str); + while ((item=li++)) + { + str->append(' '); + str->append(func_name()); + str->append(' '); + item->print(str); + } + str->append(')'); +} + + +longlong Item_cond_and::val_int() +{ + List_iterator<Item> li(list); + Item *item; + while ((item=li++)) + { + if (item->val_int() == 0) + { + /* TODO: In case of NULL, ANSI would require us to continue evaluation + until we get a FALSE value or run out of values; This would + require a lot of unnecessary evaluation, which we skip for now */ + null_value=item->null_value; + return 0; + } + } + null_value=0; + return 1; +} + +longlong Item_cond_or::val_int() +{ + List_iterator<Item> li(list); + Item *item; + null_value=0; + while ((item=li++)) + { + if (item->val_int() != 0) + { + null_value=0; + return 1; + } + if (item->null_value) + null_value=1; + } + return 0; +} + +longlong Item_func_isnull::val_int() +{ + (void) args[0]->val(); + return (args[0]->null_value) ? 1 : 0; +} + +longlong Item_func_isnotnull::val_int() +{ + (void) args[0]->val(); + return !(args[0]->null_value) ? 1 : 0; +} + + +void Item_func_like::fix_length_and_dec() +{ + decimals=0; max_length=1; + // cmp_type=STRING_RESULT; // For quick select +} + + +longlong Item_func_like::val_int() +{ + String *res,*res2; + res=args[0]->val_str(&tmp_value1); + if (args[0]->null_value) + { + null_value=1; + return 0; + } + res2=args[1]->val_str(&tmp_value2); + if (args[1]->null_value) + { + null_value=1; + return 0; + } + null_value=0; + if (binary) + return wild_compare(*res,*res2,escape) ? 0 : 1; + else + return wild_case_compare(*res,*res2,escape) ? 0 : 1; +} + + +/* We can optimize a where if first character isn't a wildcard */ + +Item_func::optimize_type Item_func_like::select_optimize() const +{ + if (args[1]->type() == STRING_ITEM) + { + if (((Item_string *) args[1])->str_value[0] != wild_many) + { + if ((args[0]->result_type() != STRING_RESULT) || + ((Item_string *) args[1])->str_value[0] != wild_one) + return OPTIMIZE_OP; + } + } + return OPTIMIZE_NONE; +} + +#ifdef USE_REGEX + +bool +Item_func_regex::fix_fields(THD *thd,TABLE_LIST *tables) +{ + if (args[0]->fix_fields(thd,tables) || args[1]->fix_fields(thd,tables)) + return 1; /* purecov: inspected */ + with_sum_func=args[0]->with_sum_func || args[1]->with_sum_func; + max_length=1; decimals=0; + binary=args[0]->binary || args[1]->binary; + used_tables_cache=args[0]->used_tables() | args[1]->used_tables(); + const_item_cache=args[0]->const_item() && args[1]->const_item(); + if (!regex_compiled && args[1]->const_item()) + { + char buff[MAX_FIELD_WIDTH]; + String tmp(buff,sizeof(buff)); + String *res=args[1]->val_str(&tmp); + if (args[1]->null_value) + { // Will always return NULL + maybe_null=1; + return 0; + } + int error; + if ((error=regcomp(&preg,res->c_ptr(), + binary ? REG_EXTENDED | REG_NOSUB : + REG_EXTENDED | REG_NOSUB | REG_ICASE))) + { + (void) regerror(error,&preg,buff,sizeof(buff)); + my_printf_error(ER_REGEXP_ERROR,ER(ER_REGEXP_ERROR),MYF(0),buff); + return 1; + } + regex_compiled=regex_is_const=1; + maybe_null=args[0]->maybe_null; + } + else + maybe_null=1; + return 0; +} + + +longlong Item_func_regex::val_int() +{ + char buff[MAX_FIELD_WIDTH]; + String *res, tmp(buff,sizeof(buff)); + + res=args[0]->val_str(&tmp); + if (args[0]->null_value) + { + null_value=1; + return 0; + } + if (!regex_is_const) + { + char buff2[MAX_FIELD_WIDTH]; + String *res2, tmp2(buff2,sizeof(buff2)); + + res2= args[1]->val_str(&tmp2); + if (args[1]->null_value) + { + null_value=1; + return 0; + } + if (!regex_compiled || stringcmp(res2,&prev_regexp)) + { + prev_regexp.copy(*res2); + if (regex_compiled) + { + regfree(&preg); + regex_compiled=0; + } + if (regcomp(&preg,res2->c_ptr(), + binary ? REG_EXTENDED | REG_NOSUB : + REG_EXTENDED | REG_NOSUB | REG_ICASE)) + + { + null_value=1; + return 0; + } + regex_compiled=1; + } + } + null_value=0; + return regexec(&preg,res->c_ptr(),0,(regmatch_t*) 0,0) ? 0 : 1; +} + + +Item_func_regex::~Item_func_regex() +{ + if (regex_compiled) + { + regfree(&preg); + regex_compiled=0; + } +} + +#endif /* USE_REGEX */ |