The world's most popular open source database

MySQL 5.1: Item_sum_hybrid Class Reference

Item_sum_hybrid Class Reference

#include <item_sum.h>

Inheritance diagram for Item_sum_hybrid:

[legend]Collaboration diagram for Item_sum_hybrid:

[legend]List of all members.


Public Member Functions
	Item_sum_hybrid (Item *item_par, int sign)
	Item_sum_hybrid (THD thd, Item_sum_hybrid item)
bool	fix_fields (THD , Item *)
table_map	used_tables () const
bool	const_item () const
void	clear ()
double	val_real ()
longlong	val_int ()
my_decimal *	val_decimal (my_decimal *)
void	reset_field ()
String *	val_str (String *)
void	make_const ()
bool	keep_field_type (void) const
enum Item_result	result_type () const
enum enum_field_types	field_type () const
void	update_field ()
void	min_max_update_str_field ()
void	min_max_update_real_field ()
void	min_max_update_int_field ()
void	min_max_update_decimal_field ()
void	cleanup ()
bool	any_value ()
void	no_rows_in_result ()
Field *	create_tmp_field (bool group, TABLE *table, uint convert_blob_length)
Protected Attributes
String	value
String	tmp_value
double	sum
longlong	sum_int
my_decimal	sum_dec
Item_result	hybrid_type
enum_field_types	hybrid_field_type
int	cmp_sign
table_map	used_table_cache
bool	was_values

Detailed Description

Definition at line 731 of file item_sum.h.

Constructor & Destructor Documentation

Item_sum_hybrid::Item_sum_hybrid	(	Item *	item_par,
		int	sign
	)			`[inline]`

Definition at line 745 of file item_sum.h.

References Item::collation, my_charset_bin, and DTCollation::set().

00746     :Item_sum(item_par), sum(0.0), sum_int(0),
00747     hybrid_type(INT_RESULT), hybrid_field_type(FIELD_TYPE_LONGLONG),
00748     cmp_sign(sign), used_table_cache(~(table_map) 0),
00749     was_values(TRUE)
00750   { collation.set(&my_charset_bin); }

Here is the call graph for this function:

Item_sum_hybrid::Item_sum_hybrid	(	THD *	thd,
		Item_sum_hybrid *	item
	)

Definition at line 463 of file item_sum.cc.

References Item::collation, DBUG_ASSERT, DECIMAL_RESULT, hybrid_type, INT_RESULT, my_decimal2decimal(), REAL_RESULT, ROW_RESULT, DTCollation::set(), STRING_RESULT, sum, sum_dec, and sum_int.

00464   :Item_sum(thd, item), value(item->value), hybrid_type(item->hybrid_type),
00465   hybrid_field_type(item->hybrid_field_type), cmp_sign(item->cmp_sign),
00466   used_table_cache(item->used_table_cache), was_values(item->was_values)
00467 {
00468   /* copy results from old value */
00469   switch (hybrid_type) {
00470   case INT_RESULT:
00471     sum_int= item->sum_int;
00472     break;
00473   case DECIMAL_RESULT:
00474     my_decimal2decimal(&item->sum_dec, &sum_dec);
00475     break;
00476   case REAL_RESULT:
00477     sum= item->sum;
00478     break;
00479   case STRING_RESULT:
00480     /*
00481       This can happen with ROLLUP. Note that the value is already
00482       copied at function call.
00483     */
00484     break;
00485   case ROW_RESULT:
00486   default:
00487     DBUG_ASSERT(0);
00488   }
00489   collation.set(item->collation);
00490 }

Here is the call graph for this function:

Member Function Documentation

bool Item_sum_hybrid::any_value ( ) [inline]

Definition at line 772 of file item_sum.h.

References was_values.

Referenced by Item_func_not_all::empty_underlying_subquery().

00772 { return was_values; }

Here is the caller graph for this function:

void Item_sum_hybrid::cleanup ( ) [virtual]

Reimplemented from Item_result_field.

Definition at line 1600 of file item_sum.cc.

References Item_result_field::cleanup(), DBUG_ENTER, DBUG_VOID_RETURN, TRUE, used_table_cache, and was_values.

01601 {
01602   DBUG_ENTER("Item_sum_hybrid::cleanup");
01603   Item_sum::cleanup();
01604   used_table_cache= ~(table_map) 0;
01605 
01606   /*
01607     by default it is TRUE to avoid TRUE reporting by
01608     Item_func_not_all/Item_func_nop_all if this item was never called.
01609 
01610     no_rows_in_result() set it to FALSE if was not results found.
01611     If some results found it will be left unchanged.
01612   */
01613   was_values= TRUE;
01614   DBUG_VOID_RETURN;
01615 }

Here is the call graph for this function:

void Item_sum_hybrid::clear ( ) [virtual]

Implements Item_sum.

Definition at line 1475 of file item_sum.cc.

References DECIMAL_RESULT, hybrid_type, INT_RESULT, String::length(), my_decimal_set_zero(), Item::null_value, REAL_RESULT, sum, sum_dec, sum_int, and value.

Referenced by no_rows_in_result().

01476 {
01477   switch (hybrid_type) {
01478   case INT_RESULT:
01479     sum_int= 0;
01480     break;
01481   case DECIMAL_RESULT:
01482     my_decimal_set_zero(&sum_dec);
01483     break;
01484   case REAL_RESULT:
01485     sum= 0.0;
01486     break;
01487   default:
01488     value.length(0);
01489   }
01490   null_value= 1;
01491 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool Item_sum_hybrid::const_item ( ) const [inline, virtual]

Reimplemented from Item_sum.

Definition at line 754 of file item_sum.h.

References used_table_cache.

00754 { return !used_table_cache; }

Field * Item_sum_hybrid::create_tmp_field	(	bool	group,
		TABLE *	table,
		uint	convert_blob_length
	)			`[virtual]`

Reimplemented from Item_sum.

Definition at line 548 of file item_sum.cc.

References Item_sum::args, DTCollation::collation, Item::collation, Item_sum::create_tmp_field(), create_tmp_field_from_field(), current_thd, Item::FIELD_ITEM, field_type(), Field::flags, Field::init(), Item::maybe_null, MYSQL_TYPE_DATE, MYSQL_TYPE_DATETIME, MYSQL_TYPE_TIME, MYSQL_TYPE_TIMESTAMP, Item::name, NOT_NULL_FLAG, NULL, and Item_sum::type().

00550 {
00551   Field *field;
00552   if (args[0]->type() == Item::FIELD_ITEM)
00553   {
00554     field= ((Item_field*) args[0])->field;
00555     
00556     if ((field= create_tmp_field_from_field(current_thd, field, name, table,
00557                                             NULL, convert_blob_length)))
00558       field->flags&= ~NOT_NULL_FLAG;
00559     return field;
00560   }
00561   /*
00562     DATE/TIME fields have STRING_RESULT result types.
00563     In order to preserve field type, it's needed to handle DATE/TIME
00564     fields creations separately.
00565   */
00566   switch (args[0]->field_type()) {
00567   case MYSQL_TYPE_DATE:
00568     field= new Field_date(maybe_null, name, collation.collation);
00569     break;
00570   case MYSQL_TYPE_TIME:
00571     field= new Field_time(maybe_null, name, collation.collation);
00572     break;
00573   case MYSQL_TYPE_TIMESTAMP:
00574   case MYSQL_TYPE_DATETIME:
00575     field= new Field_datetime(maybe_null, name, collation.collation);
00576     break;
00577   default:
00578     return Item_sum::create_tmp_field(group, table, convert_blob_length);
00579   }
00580   if (field)
00581     field->init(table);
00582   return field;
00583 }

Here is the call graph for this function:

enum enum_field_types Item_sum_hybrid::field_type ( ) const [inline, virtual]

Reimplemented from Item.

Definition at line 765 of file item_sum.h.

References hybrid_field_type.

Referenced by create_tmp_field().

00765 { return hybrid_field_type; }

Here is the caller graph for this function:

bool Item_sum_hybrid::fix_fields	(	THD *	,
		Item **
	)			`[virtual]`

Reimplemented from Item.

Definition at line 493 of file item_sum.cc.

References Item_sum::args, Item::check_cols(), Item_sum::check_sum_func(), Item::collation, DBUG_ASSERT, DECIMAL_RESULT, Item::decimals, FALSE, Item::FIELD_ITEM, Item::field_type(), Item::fix_fields(), Item_sum::fix_length_and_dec(), Item::fixed, Item::float_length(), hybrid_field_type, hybrid_type, Item_sum::init_sum_func_check(), INT_RESULT, Item::max_length, Item::maybe_null, my_decimal_set_zero(), Item::null_value, REAL_RESULT, Item_result_field::result_field, Item::result_type(), ROW_RESULT, DTCollation::set(), STRING_RESULT, sum, sum_dec, sum_int, TRUE, Item::type(), and Item::unsigned_flag.

00494 {
00495   DBUG_ASSERT(fixed == 0);
00496 
00497   Item *item= args[0];
00498 
00499   if (init_sum_func_check(thd))
00500     return TRUE;
00501 
00502   // 'item' can be changed during fix_fields
00503   if (!item->fixed &&
00504       item->fix_fields(thd, args) ||
00505       (item= args[0])->check_cols(1))
00506     return TRUE;
00507   decimals=item->decimals;
00508 
00509   switch (hybrid_type= item->result_type()) {
00510   case INT_RESULT:
00511     max_length= 20;
00512     sum_int= 0;
00513     break;
00514   case DECIMAL_RESULT:
00515     max_length= item->max_length;
00516     my_decimal_set_zero(&sum_dec);
00517     break;
00518   case REAL_RESULT:
00519     max_length= float_length(decimals);
00520     sum= 0.0;
00521     break;
00522   case STRING_RESULT:
00523     max_length= item->max_length;
00524     break;
00525   case ROW_RESULT:
00526   default:
00527     DBUG_ASSERT(0);
00528   };
00529   /* MIN/MAX can return NULL for empty set indepedent of the used column */
00530   maybe_null= 1;
00531   unsigned_flag=item->unsigned_flag;
00532   collation.set(item->collation);
00533   result_field=0;
00534   null_value=1;
00535   fix_length_and_dec();
00536   if (item->type() == Item::FIELD_ITEM)
00537     hybrid_field_type= ((Item_field*) item)->field->type();
00538   else
00539     hybrid_field_type= Item::field_type();
00540 
00541   if (check_sum_func(thd, ref))
00542     return TRUE;
00543 
00544   fixed= 1;
00545   return FALSE;
00546 }

Here is the call graph for this function:

bool Item_sum_hybrid::keep_field_type ( void ) const [inline, virtual]

Reimplemented from Item_sum.

Definition at line 763 of file item_sum.h.

00763 { return 1; }

void Item_sum_hybrid::make_const ( ) [inline]

Definition at line 762 of file item_sum.h.

References used_table_cache.

00762 { used_table_cache=0; }

void Item_sum_hybrid::min_max_update_decimal_field ( )

Definition at line 2186 of file item_sum.cc.

References Item_sum::args, cmp_sign, Field::is_null(), my_decimal_cmp(), Item::null_value, Item_result_field::result_field, Field::set_notnull(), Field::set_null(), Field::store_decimal(), Item::val_decimal(), and Field::val_decimal().

Referenced by update_field().

02187 {
02188   /* TODO: optimize: do not get result_field in case of args[0] is NULL */
02189   my_decimal old_val, nr_val;
02190   const my_decimal *old_nr= result_field->val_decimal(&old_val);
02191   const my_decimal *nr= args[0]->val_decimal(&nr_val);
02192   if (!args[0]->null_value)
02193   {
02194     if (result_field->is_null(0))
02195       old_nr=nr;
02196     else
02197     {
02198       bool res= my_decimal_cmp(old_nr, nr) > 0;
02199       /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
02200       if ((cmp_sign > 0) ^ (!res))
02201         old_nr=nr;
02202     }
02203     result_field->set_notnull();
02204   }
02205   else if (result_field->is_null(0))
02206     result_field->set_null();
02207   result_field->store_decimal(old_nr);
02208 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Item_sum_hybrid::min_max_update_int_field ( )

Definition at line 2158 of file item_sum.cc.

References Item_sum::args, cmp_sign, Field::is_null(), Item::null_value, Item_result_field::result_field, Field::set_notnull(), Field::set_null(), Field::store(), Item::unsigned_flag, Item::val_int(), and Field::val_int().

Referenced by update_field().

02159 {
02160   longlong nr,old_nr;
02161 
02162   old_nr=result_field->val_int();
02163   nr=args[0]->val_int();
02164   if (!args[0]->null_value)
02165   {
02166     if (result_field->is_null(0))
02167       old_nr=nr;
02168     else
02169     {
02170       bool res=(unsigned_flag ?
02171                 (ulonglong) old_nr > (ulonglong) nr :
02172                 old_nr > nr);
02173       /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
02174       if ((cmp_sign > 0) ^ (!res))
02175         old_nr=nr;
02176     }
02177     result_field->set_notnull();
02178   }
02179   else if (result_field->is_null(0))
02180     result_field->set_null();
02181   result_field->store(old_nr, unsigned_flag);
02182 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Item_sum_hybrid::min_max_update_real_field ( )

Definition at line 2138 of file item_sum.cc.

Referenced by update_field().

02139 {
02140   double nr,old_nr;
02141 
02142   old_nr=result_field->val_real();
02143   nr= args[0]->val_real();
02144   if (!args[0]->null_value)
02145   {
02146     if (result_field->is_null(0) ||
02147         (cmp_sign > 0 ? old_nr > nr : old_nr < nr))
02148       old_nr=nr;
02149     result_field->set_notnull();
02150   }
02151   else if (result_field->is_null(0))
02152     result_field->set_null();
02153   result_field->store(old_nr);
02154 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Item_sum_hybrid::min_max_update_str_field ( )

Definition at line 2121 of file item_sum.cc.

References Item_sum::args, String::charset(), cmp_sign, DTCollation::collation, Item::collation, Field::is_null(), String::length(), Item::null_value, String::ptr(), Item_result_field::result_field, Field::set_notnull(), sortcmp(), Field::store(), tmp_value, Field::val_str(), Item::val_str(), and value.

Referenced by update_field().

02122 {
02123   String *res_str=args[0]->val_str(&value);
02124 
02125   if (!args[0]->null_value)
02126   {
02127     result_field->val_str(&tmp_value);
02128 
02129     if (result_field->is_null() ||
02130         (cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
02131       result_field->store(res_str->ptr(),res_str->length(),res_str->charset());
02132     result_field->set_notnull();
02133   }
02134 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Item_sum_hybrid::no_rows_in_result ( ) [virtual]

Reimplemented from Item_sum.

Definition at line 1617 of file item_sum.cc.

References clear(), FALSE, and was_values.

01618 {
01619   was_values= FALSE;
01620   clear();
01621 }

Here is the call graph for this function:

void Item_sum_hybrid::reset_field ( ) [virtual]

Implements Item_sum.

Definition at line 1831 of file item_sum.cc.

References Item_sum::args, Field::charset(), DBUG_ASSERT, DECIMAL_RESULT, decimal_zero, hybrid_type, INT_RESULT, MAX_FIELD_WIDTH, Item::maybe_null, Item::null_value, REAL_RESULT, Field::reset(), Item_result_field::result_field, ROW_RESULT, Field::set_notnull(), Field::set_null(), Field::store(), Field::store_decimal(), STRING_RESULT, Item::unsigned_flag, Item::val_decimal(), Item::val_int(), Item::val_real(), Item::val_str(), and value.

01832 {
01833   switch(hybrid_type) {
01834   case STRING_RESULT:
01835   {
01836     char buff[MAX_FIELD_WIDTH];
01837     String tmp(buff,sizeof(buff),result_field->charset()),*res;
01838 
01839     res=args[0]->val_str(&tmp);
01840     if (args[0]->null_value)
01841     {
01842       result_field->set_null();
01843       result_field->reset();
01844     }
01845     else
01846     {
01847       result_field->set_notnull();
01848       result_field->store(res->ptr(),res->length(),tmp.charset());
01849     }
01850     break;
01851   }
01852   case INT_RESULT:
01853   {
01854     longlong nr=args[0]->val_int();
01855 
01856     if (maybe_null)
01857     {
01858       if (args[0]->null_value)
01859       {
01860         nr=0;
01861         result_field->set_null();
01862       }
01863       else
01864         result_field->set_notnull();
01865     }
01866     result_field->store(nr, unsigned_flag);
01867     break;
01868   }
01869   case REAL_RESULT:
01870   {
01871     double nr= args[0]->val_real();
01872 
01873     if (maybe_null)
01874     {
01875       if (args[0]->null_value)
01876       {
01877         nr=0.0;
01878         result_field->set_null();
01879       }
01880       else
01881         result_field->set_notnull();
01882     }
01883     result_field->store(nr);
01884     break;
01885   }
01886   case DECIMAL_RESULT:
01887   {
01888     my_decimal value, *arg_dec= args[0]->val_decimal(&value);
01889 
01890     if (maybe_null)
01891     {
01892       if (args[0]->null_value)
01893         result_field->set_null();
01894       else
01895         result_field->set_notnull();
01896     }
01897     /*
01898       We must store zero in the field as we will use the field value in
01899       add()
01900     */
01901     if (!arg_dec)                               // Null
01902       arg_dec= &decimal_zero;
01903     result_field->store_decimal(arg_dec);
01904     break;
01905   }
01906   case ROW_RESULT:
01907   default:
01908     DBUG_ASSERT(0);
01909   }
01910 }

Here is the call graph for this function:

enum Item_result Item_sum_hybrid::result_type ( ) const [inline, virtual]

Reimplemented from Item.

Definition at line 764 of file item_sum.h.

References hybrid_type.

00764 { return hybrid_type; }

void Item_sum_hybrid::update_field ( ) [virtual]

Implements Item_sum.

Definition at line 2102 of file item_sum.cc.

References DECIMAL_RESULT, hybrid_type, INT_RESULT, min_max_update_decimal_field(), min_max_update_int_field(), min_max_update_real_field(), min_max_update_str_field(), and STRING_RESULT.

02103 {
02104   switch (hybrid_type) {
02105   case STRING_RESULT:
02106     min_max_update_str_field();
02107     break;
02108   case INT_RESULT:
02109     min_max_update_int_field();
02110     break;
02111   case DECIMAL_RESULT:
02112     min_max_update_decimal_field();
02113     break;
02114   default:
02115     min_max_update_real_field();
02116   }
02117 }

Here is the call graph for this function:

table_map Item_sum_hybrid::used_tables ( ) const [inline, virtual]

Reimplemented from Item_sum.

Definition at line 753 of file item_sum.h.

References used_table_cache.

00753 { return used_table_cache; }

my_decimal * Item_sum_hybrid::val_decimal ( my_decimal * ) [virtual]

Implements Item.

Definition at line 1544 of file item_sum.cc.

References DBUG_ASSERT, DECIMAL_RESULT, double2my_decimal(), E_DEC_FATAL_ERROR, Item::fixed, hybrid_type, int2my_decimal(), INT_RESULT, Item::null_value, REAL_RESULT, ROW_RESULT, STRING_RESULT, sum, sum_dec, sum_int, Item::unsigned_flag, and value.

01545 {
01546   DBUG_ASSERT(fixed == 1);
01547   if (null_value)
01548     return 0;
01549   switch (hybrid_type) {
01550   case STRING_RESULT:
01551     string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
01552     break;
01553   case REAL_RESULT:
01554     double2my_decimal(E_DEC_FATAL_ERROR, sum, val);
01555     break;
01556   case DECIMAL_RESULT:
01557     val= &sum_dec;
01558     break;
01559   case INT_RESULT:
01560     int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
01561     break;
01562   case ROW_RESULT:
01563   default:
01564     // This case should never be choosen
01565     DBUG_ASSERT(0);
01566     break;
01567   }
01568   return val;                                   // Keep compiler happy
01569 }

Here is the call graph for this function:

longlong Item_sum_hybrid::val_int ( ) [virtual]

Implements Item.

Definition at line 1524 of file item_sum.cc.

References DBUG_ASSERT, DECIMAL_RESULT, E_DEC_FATAL_ERROR, Item::fixed, hybrid_type, INT_RESULT, my_decimal2int(), Item::null_value, rint, sum_dec, sum_int, Item::unsigned_flag, and val_real().

01525 {
01526   DBUG_ASSERT(fixed == 1);
01527   if (null_value)
01528     return 0;
01529   switch (hybrid_type) {
01530   case INT_RESULT:
01531     return sum_int;
01532   case DECIMAL_RESULT:
01533   {
01534     longlong result;
01535     my_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
01536     return sum_int;
01537   }
01538   default:
01539     return (longlong) rint(Item_sum_hybrid::val_real());
01540   }
01541 }

Here is the call graph for this function:

double Item_sum_hybrid::val_real ( ) [virtual]

Implements Item.

Definition at line 1493 of file item_sum.cc.

References String::charset(), DBUG_ASSERT, DECIMAL_RESULT, E_DEC_FATAL_ERROR, Item::fixed, hybrid_type, INT_RESULT, String::length(), my_decimal2double(), my_strntod, Item::null_value, String::ptr(), REAL_RESULT, ROW_RESULT, Item::str_value, STRING_RESULT, sum, sum_dec, sum_int, ulonglong2double, Item::unsigned_flag, and val_str().

Referenced by val_int().

01494 {
01495   DBUG_ASSERT(fixed == 1);
01496   if (null_value)
01497     return 0.0;
01498   switch (hybrid_type) {
01499   case STRING_RESULT:
01500   {
01501     char *end_not_used;
01502     int err_not_used;
01503     String *res;  res=val_str(&str_value);
01504     return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
01505                              &end_not_used, &err_not_used) : 0.0);
01506   }
01507   case INT_RESULT:
01508     if (unsigned_flag)
01509       return ulonglong2double(sum_int);
01510     return (double) sum_int;
01511   case DECIMAL_RESULT:
01512     my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
01513     return sum;
01514   case REAL_RESULT:
01515     return sum;
01516   case ROW_RESULT:
01517   default:
01518     // This case should never be choosen
01519     DBUG_ASSERT(0);
01520     return 0;
01521   }
01522 }

Here is the call graph for this function:

Here is the caller graph for this function:

String * Item_sum_hybrid::val_str ( String * ) [virtual]

Implements Item.

Definition at line 1573 of file item_sum.cc.

References DBUG_ASSERT, DECIMAL_RESULT, Item::decimals, E_DEC_FATAL_ERROR, Item::fixed, hybrid_type, INT_RESULT, my_charset_bin, my_decimal2string(), Item::null_value, REAL_RESULT, ROW_RESULT, String::set_int(), String::set_real(), STRING_RESULT, sum, sum_dec, sum_int, Item::unsigned_flag, and value.

Referenced by val_real().

01574 {
01575   DBUG_ASSERT(fixed == 1);
01576   if (null_value)
01577     return 0;
01578   switch (hybrid_type) {
01579   case STRING_RESULT:
01580     return &value;
01581   case REAL_RESULT:
01582     str->set_real(sum,decimals, &my_charset_bin);
01583     break;
01584   case DECIMAL_RESULT:
01585     my_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
01586     return str;
01587   case INT_RESULT:
01588     str->set_int(sum_int, unsigned_flag, &my_charset_bin);
01589     break;
01590   case ROW_RESULT:
01591   default:
01592     // This case should never be choosen
01593     DBUG_ASSERT(0);
01594     break;
01595   }
01596   return str;                                   // Keep compiler happy
01597 }