database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-20 10:24:14 +03:00
Code Activity

MDEV-14630 Replace {STRING|INT|REAL|DECIMAL|DATE}_ITEM to CONST_ITEM

Browse Source
This commit is contained in:
Alexander Barkov
2018-06-06 14:09:06 +04:00
parent 395212446a
commit c20cd68e60
11 changed files with 148 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sql/field.cc
View File

@ -10630,7 +10630,7 @@ Field *Column_definition_attributes::make_field(TABLE_SHARE *share,
bool Field_vers_trx_id::test_if_equality_guarantees_uniqueness(const Item* item) const
{
return item->type() == Item::DATE_ITEM;
return item->is_of_type(Item::CONST_ITEM, TIME_RESULT);
}

33
sql/item.cc
View File

@ -1806,10 +1806,10 @@ Item_splocal::Item_splocal(THD *thd,
Rewritable_query_parameter(pos_in_q, len_in_q),
Type_handler_hybrid_field_type(handler),
m_rcontext_handler(rh),
m_var_idx(sp_var_idx)
m_var_idx(sp_var_idx),
m_type(handler == &type_handler_row ? ROW_ITEM : CONST_ITEM)
{
maybe_null= TRUE;
m_type= sp_map_item_type(handler);
}
@ -3635,11 +3635,8 @@ longlong Item_field::val_int_endpoint(bool left_endp, bool *incl_endp)
bool Item_basic_value::eq(const Item *item, bool binary_cmp) const
{
const Item_basic_value *other= item->get_item_basic_value();
Type other_type;
// Exclude CACHE_OTEM and VARBIN_ITEM
if (!other ||
(other_type= other->type()) == CACHE_ITEM ||
other_type == VARBIN_ITEM)
// Exclude CACHE_ITEM and VARBIN_ITEM
if (!other || type() != other->type())
return false;
const Type_handler *h= type_handler()->type_handler_for_comparison();
bool res= (h == other->type_handler()->type_handler_for_comparison()) &&
@ -4040,8 +4037,6 @@ Item_param::Item_param(THD *thd, const LEX_CSTRING *name_arg,
*/
Type_handler_hybrid_field_type(&type_handler_null),
state(NO_VALUE),
/* Don't pretend to be a literal unless value for this item is set. */
item_type(PARAM_ITEM),
m_empty_string_is_null(false),
indicator(STMT_INDICATOR_NONE),
m_out_param_info(NULL),
@ -4080,7 +4075,6 @@ void Item_param::set_null()
max_length= 0;
decimals= 0;
state= NULL_VALUE;
fix_type(Item::NULL_ITEM);
DBUG_VOID_RETURN;
}
@ -4095,7 +4089,6 @@ void Item_param::set_int(longlong i, uint32 max_length_arg)
decimals= 0;
maybe_null= 0;
null_value= 0;
fix_type(Item::INT_ITEM);
DBUG_VOID_RETURN;
}
@ -4110,7 +4103,6 @@ void Item_param::set_double(double d)
decimals= NOT_FIXED_DEC;
maybe_null= 0;
null_value= 0;
fix_type(Item::REAL_ITEM);
DBUG_VOID_RETURN;
}
@ -4143,7 +4135,6 @@ void Item_param::set_decimal(const char *str, ulong length)
decimals, unsigned_flag);
maybe_null= 0;
null_value= 0;
fix_type(Item::DECIMAL_ITEM);
DBUG_VOID_RETURN;
}
@ -4161,7 +4152,6 @@ void Item_param::set_decimal(const my_decimal *dv, bool unsigned_arg)
decimals, unsigned_flag);
maybe_null= 0;
null_value= 0;
fix_type(Item::DECIMAL_ITEM);
}
@ -4173,7 +4163,6 @@ void Item_param::fix_temporal(uint32 max_length_arg, uint decimals_arg)
decimals= decimals_arg;
maybe_null= 0;
null_value= 0;
fix_type(Item::DATE_ITEM);
}
@ -4258,7 +4247,6 @@ bool Item_param::set_str(const char *str, ulong length,
null_value= 0;
/* max_length and decimals are set after charset conversion */
/* sic: str may be not null-terminated, don't add DBUG_PRINT here */
fix_type(Item::STRING_ITEM);
DBUG_RETURN(FALSE);
}
@ -4292,7 +4280,6 @@ bool Item_param::set_longdata(const char *str, ulong length)
state= LONG_DATA_VALUE;
maybe_null= 0;
null_value= 0;
fix_type(Item::STRING_ITEM);
DBUG_RETURN(FALSE);
}
@ -4394,15 +4381,6 @@ void Item_param::reset()
state= NO_VALUE;
maybe_null= 1;
null_value= 0;
/*
Don't reset item_type to PARAM_ITEM: it's only needed to guard
us from item optimizations at prepare stage, when item doesn't yet
contain a literal of some kind.
In all other cases when this object is accessed its value is
set (this assumption is guarded by 'state' and
DBUG_ASSERTS(state != NO_VALUE) in all Item_param::get_*
methods).
*/
DBUG_VOID_RETURN;
}
@ -4441,7 +4419,6 @@ int Item_param::save_in_field(Field *field, bool no_conversions)
bool Item_param::can_return_value() const
{
DBUG_ASSERT(has_valid_state());
// There's no "default". See comments in Item_param::save_in_field().
switch (state) {
case SHORT_DATA_VALUE:
@ -4725,7 +4702,6 @@ bool Item_param::convert_str_value(THD *thd)
bool Item_param::basic_const_item() const
{
DBUG_ASSERT(has_valid_state());
switch (state) {
case LONG_DATA_VALUE:
case NULL_VALUE:
@ -4853,7 +4829,6 @@ Item_param::set_param_type_and_swap_value(Item_param *src)
{
Type_std_attributes::set(src);
set_handler(src->type_handler());
item_type= src->item_type;
maybe_null= src->maybe_null;
null_value= src->null_value;

80
sql/item.h
View File

@ -720,16 +720,28 @@ public:
static void operator delete(void *ptr, MEM_ROOT *mem_root) {}
enum Type {FIELD_ITEM= 0, FUNC_ITEM, SUM_FUNC_ITEM,
WINDOW_FUNC_ITEM, STRING_ITEM,
INT_ITEM, REAL_ITEM, NULL_ITEM, VARBIN_ITEM,
COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
WINDOW_FUNC_ITEM,
/*
NOT NULL literal-alike constants, which do not change their
value during an SQL statement execution, but can optionally
change their value between statements:
- Item_literal - real NOT NULL constants
- Item_param - can change between statements
- Item_splocal - can change between statements
- Item_user_var_as_out_param - hack
Note, Item_user_var_as_out_param actually abuses the type code.
It should be moved out of the Item tree eventually.
*/
CONST_ITEM,
NULL_ITEM, // Item_null or Item_param bound to NULL
VARBIN_ITEM,
COPY_STR_ITEM, FIELD_AVG_ITEM, DEFAULT_VALUE_ITEM,
PROC_ITEM,COND_ITEM, REF_ITEM, FIELD_STD_ITEM,
FIELD_VARIANCE_ITEM, INSERT_VALUE_ITEM,
SUBSELECT_ITEM, ROW_ITEM, CACHE_ITEM, TYPE_HOLDER,
PARAM_ITEM, TRIGGER_FIELD_ITEM, DECIMAL_ITEM,
PARAM_ITEM, TRIGGER_FIELD_ITEM,
XPATH_NODESET, XPATH_NODESET_CMP,
EXPR_CACHE_ITEM,
DATE_ITEM};
EXPR_CACHE_ITEM};
enum cond_result { COND_UNDEF,COND_OK,COND_TRUE,COND_FALSE };
@ -1077,6 +1089,10 @@ public:
return type_handler()->Item_get_cache(thd, this);
}
virtual enum Type type() const =0;
bool is_of_type(Type t, Item_result cmp) const
{
return type() == t && cmp_type() == cmp;
}
/*
real_type() is the type of base item. This is same as type() for
most items, except Item_ref() and Item_cache_wrapper() where it
@ -2940,6 +2956,7 @@ class Item_literal: public Item_basic_constant
public:
Item_literal(THD *thd): Item_basic_constant(thd)
{ }
enum Type type() const { return CONST_ITEM; }
bool check_partition_func_processor(void *int_arg) { return false;}
bool const_item() const { return true; }
bool basic_const_item() const { return true; }
@ -3518,8 +3535,8 @@ class Item_param :public Item_basic_value,
All Item_param::set_xxx() make sure to do so.
In the state with an assigned value:
- Item_param::basic_const_item() returns true
- Item::type() returns NULL_ITEM, INT_ITEM, REAL_ITEM, DECIMAL_ITEM,
DATE_ITEM, STRING_ITEM, depending on the value assigned.
- Item::type() returns NULL_ITEM or CONST_ITEM,
depending on the value assigned.
So in this state Item_param behaves in many cases like a literal.
When Item_param::cleanup() is called:
@ -3542,20 +3559,6 @@ class Item_param :public Item_basic_value,
DEFAULT_VALUE, IGNORE_VALUE
} state;
enum Type item_type;
bool has_valid_state() const
{
return item_type == PARAM_ITEM || state > NO_VALUE;
}
void fix_type(Type type)
{
item_type= type;
DBUG_ASSERT(is_fixed());
DBUG_ASSERT(has_valid_state());
}
void fix_temporal(uint32 max_length_arg, uint decimals_arg);
struct CONVERSION_INFO
@ -3677,13 +3680,21 @@ public:
enum Type type() const
{
DBUG_ASSERT(has_valid_state());
return item_type;
// Don't pretend to be a constant unless value for this item is set.
switch (state) {
case NO_VALUE: return PARAM_ITEM;
case NULL_VALUE: return NULL_ITEM;
case SHORT_DATA_VALUE: return CONST_ITEM;
case LONG_DATA_VALUE: return CONST_ITEM;
case DEFAULT_VALUE: return PARAM_ITEM;
case IGNORE_VALUE: return PARAM_ITEM;
}
DBUG_ASSERT(0);
return PARAM_ITEM;
}
bool is_order_clause_position() const
{
DBUG_ASSERT(has_valid_state());
return state == SHORT_DATA_VALUE &&
type_handler()->is_order_clause_position_type();
}
@ -3783,12 +3794,10 @@ public:
*/
bool const_item() const
{
DBUG_ASSERT(has_valid_state());
return state != NO_VALUE;
}
virtual table_map used_tables() const
{
DBUG_ASSERT(has_valid_state());
return state != NO_VALUE ? (table_map)0 : PARAM_TABLE_BIT;
}
virtual void print(String *str, enum_query_type query_type);
@ -3878,7 +3887,6 @@ public:
unsigned_flag= flag;
}
Item_int(THD *thd, const char *str_arg, size_t length=64);
enum Type type() const { return INT_ITEM; }
const Type_handler *type_handler() const
{ return type_handler_long_or_longlong(); }
Field *create_field_for_create_select(TABLE *table)
@ -3977,7 +3985,6 @@ public:
Item_decimal(THD *thd, double val, int precision, int scale);
Item_decimal(THD *thd, const uchar *bin, int precision, int scale);
enum Type type() const { return DECIMAL_ITEM; }
const Type_handler *type_handler() const { return &type_handler_newdecimal; }
longlong val_int();
double val_real();
@ -4015,7 +4022,6 @@ public:
decimals= (uint8) decimal_par;
}
int save_in_field(Field *field, bool no_conversions);
enum Type type() const { return REAL_ITEM; }
const Type_handler *type_handler() const { return &type_handler_double; }
double val_real() { return value; }
longlong val_int()
@ -4139,7 +4145,6 @@ public:
{
str_value.print(to);
}
enum Type type() const { return STRING_ITEM; }
double val_real();
longlong val_int();
String *val_str(String*)
@ -4554,7 +4559,6 @@ public:
decimals= dec_arg;
cached_time= *ltime;
}
enum Type type() const { return DATE_ITEM; }
bool eq(const Item *item, bool binary_cmp) const;
bool is_null()
@ -6217,7 +6221,7 @@ public:
for any value.
*/
class Item_cache: public Item_basic_constant,
class Item_cache: public Item_basic_value,
public Type_handler_hybrid_field_type
{
protected:
@ -6240,7 +6244,7 @@ protected:
table_map used_table_map;
public:
Item_cache(THD *thd):
Item_basic_constant(thd),
Item_basic_value(thd),
Type_handler_hybrid_field_type(&type_handler_string),
example(0), cached_field(0),
value_cached(0),
@ -6251,7 +6255,7 @@ public:
}
protected:
Item_cache(THD *thd, const Type_handler *handler):
Item_basic_constant(thd),
Item_basic_value(thd),
Type_handler_hybrid_field_type(handler),
example(0), cached_field(0),
value_cached(0),
@ -6308,7 +6312,7 @@ public:
void cleanup()
{
clear();
Item_basic_constant::cleanup();
Item_basic_value::cleanup();
}
/**
Check if saved item has a non-NULL value.

2
sql/item_func.cc
View File

@ -1919,7 +1919,7 @@ void Item_func_neg::fix_length_and_dec_int()
longlong val= args[0]->val_int();
if ((ulonglong) val >= (ulonglong) LONGLONG_MIN &&
((ulonglong) val != (ulonglong) LONGLONG_MIN ||
args[0]->type() != INT_ITEM))
!args[0]->is_of_type(CONST_ITEM, INT_RESULT)))
{
/*
Ensure that result is converted to DECIMAL, as longlong can't hold

2
sql/item_func.h
View File

@ -2547,7 +2547,7 @@ public:
return NULL;
}
/* We should return something different from FIELD_ITEM here */
enum Type type() const { return STRING_ITEM;}
enum Type type() const { return CONST_ITEM;}
double val_real();
longlong val_int();
String *val_str(String *str);

26
sql/sp_head.cc
View File

@ -70,32 +70,6 @@ static void reset_start_time_for_sp(THD *thd)
}
Item::Type
sp_map_item_type(const Type_handler *handler)
{
if (handler == &type_handler_row)
return Item::ROW_ITEM;
switch (handler->real_field_type()) {
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_TINY:
case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_LONGLONG:
case MYSQL_TYPE_INT24:
return Item::INT_ITEM;
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
return Item::DECIMAL_ITEM;
case MYSQL_TYPE_FLOAT:
case MYSQL_TYPE_DOUBLE:
return Item::REAL_ITEM;
default:
return Item::STRING_ITEM;
}
}
bool Item_splocal::append_for_log(THD *thd, String *str)
{
if (fix_fields_if_needed(thd, NULL))

3
sql/sp_head.h
View File

@ -39,9 +39,6 @@
@{
*/
Item::Type
sp_map_item_type(const Type_handler *handler);
uint
sp_get_flags_for_command(LEX *lex);

67
storage/connect/ha_connect.cc
View File

@ -2726,37 +2726,44 @@ PFIL ha_connect::CondFilter(PGLOBAL g, Item *cond)
if (!i && (ismul))
return NULL;
switch (args[i]->real_type()) {
case COND::STRING_ITEM:
res= pval->val_str(&tmp);
pp->Value= PlugSubAllocStr(g, NULL, res->ptr(), res->length());
pp->Type= (pp->Value) ? TYPE_STRING : TYPE_ERROR;
break;
case COND::INT_ITEM:
pp->Type= TYPE_INT;
pp->Value= PlugSubAlloc(g, NULL, sizeof(int));
*((int*)pp->Value)= (int)pval->val_int();
break;
case COND::DATE_ITEM:
pp->Type= TYPE_DATE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(int));
*((int*)pp->Value)= (int)pval->val_int_from_date();
break;
case COND::REAL_ITEM:
pp->Type= TYPE_DOUBLE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(double));
*((double*)pp->Value)= pval->val_real();
break;
case COND::DECIMAL_ITEM:
pp->Type= TYPE_DOUBLE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(double));
*((double*)pp->Value)= pval->val_real_from_decimal();
break;
switch (args[i]->real_type()) {
case COND::CONST_ITEM:
switch (args[i]->cmp_type()) {
case STRING_RESULT:
res= pval->val_str(&tmp);
pp->Value= PlugSubAllocStr(g, NULL, res->ptr(), res->length());
pp->Type= (pp->Value) ? TYPE_STRING : TYPE_ERROR;
break;
case INT_RESULT:
pp->Type= TYPE_INT;
pp->Value= PlugSubAlloc(g, NULL, sizeof(int));
*((int*)pp->Value)= (int)pval->val_int();
break;
case TIME_RESULT:
pp->Type= TYPE_DATE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(int));
*((int*)pp->Value)= (int)pval->val_int_from_date();
break;
case REAL_RESULT:
pp->Type= TYPE_DOUBLE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(double));
*((double*)pp->Value)= pval->val_real();
break;
case DECIMAL_RESULT:
pp->Type= TYPE_DOUBLE;
pp->Value= PlugSubAlloc(g, NULL, sizeof(double));
*((double*)pp->Value)= pval->val_real_from_decimal();
break;
case ROW_RESULT:
DBUG_ASSERT(0);
return NULL;
}
break;
case COND::CACHE_ITEM: // Possible ???
case COND::NULL_ITEM: // TODO: handle this
default:
return NULL;
} // endswitch type
} // endswitch type
if (trace(1))
htrc("Value type=%hd\n", pp->Type);
@ -3008,12 +3015,8 @@ PCFIL ha_connect::CheckCond(PGLOBAL g, PCFIL filp, const Item *cond)
Item::Type type= args[i]->real_type();
switch (type) {
case COND::STRING_ITEM:
case COND::INT_ITEM:
case COND::REAL_ITEM:
case COND::CONST_ITEM:
case COND::NULL_ITEM:
case COND::DECIMAL_ITEM:
case COND::DATE_ITEM:
case COND::CACHE_ITEM:
break;
default:

18
storage/mroonga/lib/mrn_condition_converter.cpp
View File

@ -179,17 +179,17 @@ namespace mrn {
NormalizedType normalized_type = normalize_field_type(field_type);
switch (normalized_type) {
case STRING_TYPE:
if (value_item->type() == Item::STRING_ITEM &&
if (value_item->is_of_type(Item::CONST_ITEM, STRING_RESULT) &&
func_type == Item_func::EQ_FUNC) {
convertable = have_index(field_item, GRN_OP_EQUAL);
}
break;
case INT_TYPE:
if (field_type == MYSQL_TYPE_ENUM) {
convertable = (value_item->type() == Item::STRING_ITEM ||
value_item->type() == Item::INT_ITEM);
convertable = value_item->is_of_type(Item::CONST_ITEM, STRING_RESULT) ||
value_item->is_of_type(Item::CONST_ITEM, INT_RESULT);
} else {
convertable = value_item->type() == Item::INT_ITEM;
convertable = value_item->is_of_type(Item::CONST_ITEM, INT_RESULT);
}
break;
case TIME_TYPE:
@ -215,14 +215,14 @@ namespace mrn {
NormalizedType normalized_type = normalize_field_type(field_type);
switch (normalized_type) {
case STRING_TYPE:
if (min_item->type() == Item::STRING_ITEM &&
max_item->type() == Item::STRING_ITEM) {
if (min_item->is_of_type(Item::CONST_ITEM, STRING_RESULT) &&
max_item->is_of_type(Item::CONST_ITEM, STRING_RESULT)) {
convertable = have_index(field_item, GRN_OP_LESS);
}
break;
case INT_TYPE:
if (min_item->type() == Item::INT_ITEM &&
max_item->type() == Item::INT_ITEM) {
if (min_item->is_of_type(Item::CONST_ITEM, INT_RESULT) &&
max_item->is_of_type(Item::CONST_ITEM, INT_RESULT)) {
convertable = have_index(field_item, GRN_OP_LESS);
}
break;
@ -587,7 +587,7 @@ namespace mrn {
case INT_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_INT64, 0);
if (field_type == MYSQL_TYPE_ENUM) {
if (const_item->type() == Item::STRING_ITEM) {
if (const_item->is_of_type(Item::CONST_ITEM, STRING_RESULT)) {
String *string;
string = const_item->val_str(NULL);
Field_enum *enum_field = static_cast<Field_enum *>(field_item->field);

8
storage/sphinx/ha_sphinx.cc
View File

@ -2746,7 +2746,9 @@ const Item * ha_sphinx::cond_push ( const Item *cond )
if ( !m_pShare->m_bSphinxQL )
{
// on non-QL tables, intercept query=value condition for SELECT
if (!( args[0]->type()==Item::FIELD_ITEM && args[1]->type()==Item::STRING_ITEM ))
if (!( args[0]->type()==Item::FIELD_ITEM &&
args[1]->is_of_type(Item::CONST_ITEM,
STRING_RESULT)))
break;
Item_field * pField = (Item_field *) args[0];
@ -2762,7 +2764,9 @@ const Item * ha_sphinx::cond_push ( const Item *cond )
} else
{
if (!( args[0]->type()==Item::FIELD_ITEM && args[1]->type()==Item::INT_ITEM ))
if (!( args[0]->type()==Item::FIELD_ITEM &&
args[1]->is_of_type(Item::CONST_ITEM,
INT_RESULT)))
break;
// on QL tables, intercept id=value condition for DELETE

77
storage/spider/spd_db_conn.cc
View File

@ -8449,6 +8449,35 @@ int spider_db_flush_logs(
DBUG_RETURN(0);
}
int spider_db_print_item_type_default(
Item *item,
ha_spider *spider,
spider_string *str
) {
DBUG_ENTER("spider_db_print_item_type_default");
THD *thd = spider->trx->thd;
SPIDER_SHARE *share = spider->share;
if (spider_param_skip_default_condition(thd,
share->skip_default_condition))
DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
if (str)
{
if (spider->share->access_charset->cset == system_charset_info->cset)
{
#if MYSQL_VERSION_ID < 50500
item->print(str->get_str(), QT_IS);
#else
item->print(str->get_str(), QT_TO_SYSTEM_CHARSET);
#endif
} else {
item->print(str->get_str(), QT_ORDINARY);
}
str->mem_calc();
}
DBUG_RETURN(0);
}
int spider_db_print_item_type(
Item *item,
ha_spider *spider,
@ -8483,14 +8512,25 @@ int spider_db_print_item_type(
case Item::ROW_ITEM:
DBUG_RETURN(spider_db_open_item_row((Item_row *) item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
case Item::STRING_ITEM:
DBUG_RETURN(spider_db_open_item_string(item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
case Item::INT_ITEM:
case Item::REAL_ITEM:
case Item::DECIMAL_ITEM:
DBUG_RETURN(spider_db_open_item_int(item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
case Item::CONST_ITEM:
{
switch (item->cmp_type()) {
case ROW_RESULT:
DBUG_ASSERT(0);
// fall through
case TIME_RESULT:
DBUG_RETURN(spider_db_print_item_type_default(item, spider, str));
case STRING_RESULT:
DBUG_RETURN(spider_db_open_item_string(item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
case INT_RESULT:
case REAL_RESULT:
case DECIMAL_RESULT:
DBUG_RETURN(spider_db_open_item_int(item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
}
DBUG_ASSERT(0);
}
case Item::CACHE_ITEM:
DBUG_RETURN(spider_db_open_item_cache((Item_cache *)item, spider, str,
alias, alias_length, dbton_id, use_fields, fields));
@ -8504,26 +8544,7 @@ int spider_db_print_item_type(
#endif
DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
default:
THD *thd = spider->trx->thd;
SPIDER_SHARE *share = spider->share;
if (spider_param_skip_default_condition(thd,
share->skip_default_condition))
DBUG_RETURN(ER_SPIDER_COND_SKIP_NUM);
if (str)
{
if (spider->share->access_charset->cset == system_charset_info->cset)
{
#if MYSQL_VERSION_ID < 50500
item->print(str->get_str(), QT_IS);
#else
item->print(str->get_str(), QT_TO_SYSTEM_CHARSET);
#endif
} else {
item->print(str->get_str(), QT_ORDINARY);
}
str->mem_calc();
}
break;
DBUG_RETURN(spider_db_print_item_type_default(item, spider, str));
}
DBUG_RETURN(0);
}