The world's most popular open source database

MySQL 5.1: Item_func_group_concat Class Reference

Item_func_group_concat Class Reference

#include <item_sum.h>

Inheritance diagram for Item_func_group_concat:

[legend]Collaboration diagram for Item_func_group_concat:

[legend]List of all members.


Public Member Functions
	Item_func_group_concat (Name_resolution_context context_arg, bool is_distinct, List< Item > is_select, SQL_LIST is_order, String is_separator)
	Item_func_group_concat (THD thd, Item_func_group_concat item)
	~Item_func_group_concat ()
void	cleanup ()
enum Sumfunctype	sum_func () const
const char *	func_name () const
virtual Item_result	result_type () const
enum_field_types	field_type () const
void	clear ()
bool	add ()
void	reset_field ()
void	update_field ()
bool	fix_fields (THD , Item *)
bool	setup (THD *thd)
void	make_unique ()
double	val_real ()
longlong	val_int ()
my_decimal *	val_decimal (my_decimal *decimal_value)
String *	val_str (String *str)
Item *	copy_or_same (THD *thd)
void	no_rows_in_result ()
void	print (String *str)
virtual bool	change_context_processor (byte *cntx)
Private Attributes
TMP_TABLE_PARAM *	tmp_table_param
MYSQL_ERROR *	warning
String	result
String *	separator
TREE	tree_base
TREE *	tree
TABLE *	table
ORDER **	order
Name_resolution_context *	context
uint	arg_count_order
uint	arg_count_field
uint	count_cut_values
bool	distinct
bool	warning_for_row
bool	always_null
bool	force_copy_fields
bool	no_appended
Item_func_group_concat *	original
Friends
int	group_concat_key_cmp_with_distinct (void arg, byte key1, byte *key2)
int	group_concat_key_cmp_with_order (void arg, byte key1, byte *key2)
int	group_concat_key_cmp_with_distinct_and_order (void arg, byte key1, byte *key2)
int	dump_leaf_key (byte key, element_count count __attribute__((unused)), Item_func_group_concat group_concat_item)

Detailed Description

Definition at line 1074 of file item_sum.h.

Constructor & Destructor Documentation

Item_func_group_concat::Item_func_group_concat	(	Name_resolution_context *	context_arg,
		bool	is_distinct,
		List< Item > *	is_select,
		SQL_LIST *	is_order,
		String *	is_separator
	)

Definition at line 3043 of file item_sum.cc.

References arg_count_field, arg_count_order, Item_sum::args, FALSE, st_sql_list::first, NULL, order, Item_sum::quick_group, and sql_alloc().

Referenced by copy_or_same().

03046   :tmp_table_param(0), warning(0),
03047    separator(separator_arg), tree(0), table(0),
03048    order(0), context(context_arg),
03049    arg_count_order(order_list ? order_list->elements : 0),
03050    arg_count_field(select_list->elements),
03051    count_cut_values(0),
03052    distinct(distinct_arg),
03053    warning_for_row(FALSE),
03054    force_copy_fields(0), original(0)
03055 {
03056   Item *item_select;
03057   Item **arg_ptr;
03058 
03059   quick_group= FALSE;
03060   arg_count= arg_count_field + arg_count_order;
03061 
03062   /*
03063     We need to allocate:
03064     args - arg_count_field+arg_count_order
03065            (for possible order items in temporare tables)
03066     order - arg_count_order
03067   */
03068   if (!(args= (Item**) sql_alloc(sizeof(Item*) * arg_count +
03069                                  sizeof(ORDER*)*arg_count_order)))
03070     return;
03071 
03072   order= (ORDER**)(args + arg_count);
03073 
03074   /* fill args items of show and sort */
03075   List_iterator_fast<Item> li(*select_list);
03076 
03077   for (arg_ptr=args ; (item_select= li++) ; arg_ptr++)
03078     *arg_ptr= item_select;
03079 
03080   if (arg_count_order)
03081   {
03082     ORDER **order_ptr= order;
03083     for (ORDER *order_item= (ORDER*) order_list->first;
03084          order_item != NULL;
03085          order_item= order_item->next)
03086     {
03087       (*order_ptr++)= order_item;
03088       *arg_ptr= *order_item->item;
03089       order_item->item= arg_ptr++;
03090     }
03091   }
03092 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 3095 of file item_sum.cc.

References Item_sum::quick_group.

03097   :Item_sum(thd, item),
03098   tmp_table_param(item->tmp_table_param),
03099   warning(item->warning),
03100   separator(item->separator),
03101   tree(item->tree),
03102   table(item->table),
03103   order(item->order),
03104   context(item->context),
03105   arg_count_order(item->arg_count_order),
03106   arg_count_field(item->arg_count_field),
03107   count_cut_values(item->count_cut_values),
03108   distinct(item->distinct),
03109   warning_for_row(item->warning_for_row),
03110   always_null(item->always_null),
03111   force_copy_fields(item->force_copy_fields),
03112   original(item)
03113 {
03114   quick_group= item->quick_group;
03115 }

Item_func_group_concat::~Item_func_group_concat ( ) [inline]

Definition at line 1116 of file item_sum.h.

01116 {}

Member Function Documentation

bool Item_func_group_concat::add ( ) [virtual]

Implements Item_sum.

Definition at line 3187 of file item_sum.cc.

References always_null, arg_count_field, arg_count_order, Item_sum::args, copy_fields(), copy_funcs(), st_tree::custom_arg, distinct, dump_leaf_key, Item::el(), f, FALSE, String::length(), Item::max_length, st_table_share::null_bytes, Item::null_value, st_table::record, result, st_table::s, table, tmp_table_param, tree, tree_insert(), and warning_for_row.

03188 {
03189   if (always_null)
03190     return 0;
03191   copy_fields(tmp_table_param);
03192   copy_funcs(tmp_table_param->items_to_copy);
03193 
03194   for (uint i= 0; i < arg_count_field; i++)
03195   {
03196     Item *show_item= args[i];
03197     if (!show_item->const_item())
03198     {
03199       Field *f= show_item->get_tmp_table_field();
03200       if (f->is_null_in_record((const uchar*) table->record[0]))
03201         return 0;                               // Skip row if it contains null
03202     }
03203   }
03204 
03205   null_value= FALSE;
03206 
03207   TREE_ELEMENT *el= 0;                          // Only for safety
03208   if (tree)
03209     el= tree_insert(tree, table->record[0] + table->s->null_bytes, 0,
03210                     tree->custom_arg);
03211   /*
03212     If the row is not a duplicate (el->count == 1)
03213     we can dump the row here in case of GROUP_CONCAT(DISTINCT...)
03214     instead of doing tree traverse later.
03215   */
03216   if (result.length() <= max_length &&
03217       !warning_for_row &&
03218       (!tree || (el->count == 1 && distinct && !arg_count_order)))
03219     dump_leaf_key(table->record[0] + table->s->null_bytes, 1, this);
03220 
03221   return 0;
03222 }

Here is the call graph for this function:

virtual bool Item_func_group_concat::change_context_processor ( byte * cntx ) [inline, virtual]

Reimplemented from Item.

Definition at line 1159 of file item_sum.h.

References context, and FALSE.

01160     { context= (Name_resolution_context *)cntx; return FALSE; }

void Item_func_group_concat::cleanup ( ) [virtual]

Reimplemented from Item_result_field.

Definition at line 3119 of file item_sum.cc.

References Item_result_field::cleanup(), count_cut_values, current_thd, DBUG_ASSERT, DBUG_ENTER, DBUG_VOID_RETURN, delete_tree(), ER, ER_CUT_VALUE_GROUP_CONCAT, free_tmp_table(), st_table::in_use, MYSQL_ERRMSG_SIZE, original, MYSQL_ERROR::set_msg(), table, tmp_table_param, tree, and warning.

03120 {
03121   THD *thd= current_thd;
03122 
03123   DBUG_ENTER("Item_func_group_concat::cleanup");
03124   Item_sum::cleanup();
03125 
03126   /* Adjust warning message to include total number of cut values */
03127   if (warning)
03128   {
03129     char warn_buff[MYSQL_ERRMSG_SIZE];
03130     sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
03131     warning->set_msg(thd, warn_buff);
03132     warning= 0;
03133   }
03134 
03135   /*
03136     Free table and tree if they belong to this item (if item have not pointer
03137     to original item from which was made copy => it own its objects )
03138   */
03139   if (!original)
03140   {
03141     delete tmp_table_param;
03142     tmp_table_param= 0;
03143     if (table)
03144     {
03145       THD *thd= table->in_use;
03146       free_tmp_table(thd, table);
03147       table= 0;
03148       if (tree)
03149       {
03150         delete_tree(tree);
03151         tree= 0;
03152       }
03153       if (warning)
03154       {
03155         char warn_buff[MYSQL_ERRMSG_SIZE];
03156         sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
03157         warning->set_msg(thd, warn_buff);
03158         warning= 0;
03159       }
03160     }
03161     DBUG_ASSERT(tree == 0);
03162     DBUG_ASSERT(warning == 0);
03163   }
03164   DBUG_VOID_RETURN;
03165 }

Here is the call graph for this function:

void Item_func_group_concat::clear ( ) [virtual]

Implements Item_sum.

Definition at line 3174 of file item_sum.cc.

References String::copy(), FALSE, String::length(), no_appended, Item::null_value, reset_tree(), result, tree, TRUE, and warning_for_row.

03175 {
03176   result.length(0);
03177   result.copy();
03178   null_value= TRUE;
03179   warning_for_row= FALSE;
03180   no_appended= TRUE;
03181   if (tree)
03182     reset_tree(tree);
03183   /* No need to reset the table as we never call write_row */
03184 }

Here is the call graph for this function:

Item * Item_func_group_concat::copy_or_same ( THD * thd ) [virtual]

Reimplemented from Item.

Definition at line 3168 of file item_sum.cc.

References Item_func_group_concat().

03169 {
03170   return new (thd->mem_root) Item_func_group_concat(thd, this);
03171 }

Here is the call graph for this function:

enum_field_types Item_func_group_concat::field_type ( ) const [inline, virtual]

Reimplemented from Item.

Definition at line 1122 of file item_sum.h.

References DTCollation::collation, Item::collation, CONVERT_IF_BIGGER_TO_BLOB, FIELD_TYPE_BLOB, Item::max_length, charset_info_st::mbmaxlen, and MYSQL_TYPE_VARCHAR.

01123   {
01124     if (max_length/collation.collation->mbmaxlen > CONVERT_IF_BIGGER_TO_BLOB )
01125       return FIELD_TYPE_BLOB;
01126     else
01127       return MYSQL_TYPE_VARCHAR;
01128   }

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

Reimplemented from Item.

Definition at line 3226 of file item_sum.cc.

References agg_item_charsets(), arg_count_order, Item_sum::args, Item::check_cols(), Item_sum::check_sum_func(), Item::collation, DBUG_ASSERT, FALSE, Item::fixed, func_name(), Item_sum::init_sum_func_check(), Item::max_length, Item::maybe_null, MY_COLL_ALLOW_CONV, Item::null_value, result, Item_result_field::result_field, String::set_charset(), and TRUE.

03227 {
03228   uint i;                       /* for loop variable */
03229   DBUG_ASSERT(fixed == 0);
03230 
03231   if (init_sum_func_check(thd))
03232     return TRUE;
03233 
03234   maybe_null= 1;
03235 
03236   /*
03237     Fix fields for select list and ORDER clause
03238   */
03239 
03240   for (i=0 ; i < arg_count ; i++)
03241   {
03242     if ((!args[i]->fixed &&
03243          args[i]->fix_fields(thd, args + i)) ||
03244         args[i]->check_cols(1))
03245       return TRUE;
03246   }
03247 
03248   if (agg_item_charsets(collation, func_name(),
03249                         args,
03250                         /* skip charset aggregation for order columns */
03251                         arg_count - arg_count_order,
03252                         MY_COLL_ALLOW_CONV, 1))
03253     return 1;
03254 
03255   result.set_charset(collation.collation);
03256   result_field= 0;
03257   null_value= 1;
03258   max_length= thd->variables.group_concat_max_len;
03259 
03260   if (check_sum_func(thd, ref))
03261     return TRUE;
03262 
03263   fixed= 1;
03264   return FALSE;
03265 }

Here is the call graph for this function:

const char* Item_func_group_concat::func_name ( ) const [inline, virtual]

Implements Item_sum.

Definition at line 1120 of file item_sum.h.

Referenced by fix_fields().

01120 { return "group_concat"; }

Here is the caller graph for this function:

void Item_func_group_concat::make_unique ( ) [virtual]

Reimplemented from Item_sum.

Definition at line 3374 of file item_sum.cc.

References force_copy_fields, original, table, tmp_table_param, and tree.

03375 {
03376   tmp_table_param= 0;
03377   table=0;
03378   original= 0;
03379   force_copy_fields= 1;
03380   tree= 0;
03381 }

void Item_func_group_concat::no_rows_in_result ( ) [inline, virtual]

Reimplemented from Item_sum.

Definition at line 1157 of file item_sum.h.

01157 {}

void Item_func_group_concat::print ( String * str ) [virtual]

Reimplemented from Item_sum.

Definition at line 3409 of file item_sum.cc.

References String::append(), arg_count_field, arg_count_order, Item_sum::args, distinct, st_order::item, order, Item::print(), separator, and STRING_WITH_LEN.

03410 {
03411   str->append(STRING_WITH_LEN("group_concat("));
03412   if (distinct)
03413     str->append(STRING_WITH_LEN("distinct "));
03414   for (uint i= 0; i < arg_count_field; i++)
03415   {
03416     if (i)
03417       str->append(',');
03418     args[i]->print(str);
03419   }
03420   if (arg_count_order)
03421   {
03422     str->append(STRING_WITH_LEN(" order by "));
03423     for (uint i= 0 ; i < arg_count_order ; i++)
03424     {
03425       if (i)
03426         str->append(',');
03427       (*order[i]->item)->print(str);
03428       if (order[i]->asc)
03429         str->append(STRING_WITH_LEN(" ASC"));
03430       else
03431         str->append(STRING_WITH_LEN(" DESC"));
03432     }
03433   }
03434   str->append(STRING_WITH_LEN(" separator \'"));
03435   str->append(*separator);
03436   str->append(STRING_WITH_LEN("\')"));
03437 }

Here is the call graph for this function:

void Item_func_group_concat::reset_field ( ) [inline, virtual]

Implements Item_sum.

Definition at line 1131 of file item_sum.h.

References DBUG_ASSERT.

01131 { DBUG_ASSERT(0); }        // not used

virtual Item_result Item_func_group_concat::result_type ( ) const [inline, virtual]

Reimplemented from Item.

Definition at line 1121 of file item_sum.h.

References STRING_RESULT.

01121 { return STRING_RESULT; }

bool Item_func_group_concat::setup ( THD * thd ) [virtual]

Reimplemented from Item_sum.

Definition at line 3268 of file item_sum.cc.

References always_null, arg_count_field, arg_count_order, Item_sum::args, context, count_field_types(), create_tmp_table(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, distinct, handler::extra(), FALSE, st_table::file, force_copy_fields, group_concat_key_cmp_with_distinct, group_concat_key_cmp_with_distinct_and_order, group_concat_key_cmp_with_order, HA_EXTRA_NO_ROWS, HA_POS_ERROR, init_tree(), list(), Item::max_length, min, st_table::no_rows, NULL, st_table_share::null_bytes, order, st_table_share::reclength, st_table::s, setup_order(), table, Name_resolution_context::table_list, tmp_table_param, tree, tree_base, and TRUE.

03269 {
03270   List<Item> list;
03271   SELECT_LEX *select_lex= thd->lex->current_select;
03272   qsort_cmp2 compare_key;
03273   DBUG_ENTER("Item_func_group_concat::setup");
03274 
03275   /*
03276     Currently setup() can be called twice. Please add
03277     assertion here when this is fixed.
03278   */
03279   if (table || tree)
03280     DBUG_RETURN(FALSE);
03281 
03282   if (!(tmp_table_param= new TMP_TABLE_PARAM))
03283     DBUG_RETURN(TRUE);
03284 
03285   /* We'll convert all blobs to varchar fields in the temporary table */
03286   tmp_table_param->convert_blob_length= max_length;
03287   /* Push all not constant fields to the list and create a temp table */
03288   always_null= 0;
03289   for (uint i= 0; i < arg_count_field; i++)
03290   {
03291     Item *item= args[i];
03292     if (list.push_back(item))
03293       DBUG_RETURN(TRUE);
03294     if (item->const_item())
03295     {
03296       if (item->is_null())
03297       {
03298         always_null= 1;
03299         DBUG_RETURN(FALSE);
03300       }
03301     }
03302   }
03303 
03304   List<Item> all_fields(list);
03305   /*
03306     Try to find every ORDER expression in the list of GROUP_CONCAT
03307     arguments. If an expression is not found, prepend it to
03308     "all_fields". The resulting field list is used as input to create
03309     tmp table columns.
03310   */
03311   if (arg_count_order &&
03312       setup_order(thd, args, context->table_list, list, all_fields, *order))
03313     DBUG_RETURN(TRUE);
03314 
03315   count_field_types(tmp_table_param,all_fields,0);
03316   tmp_table_param->force_copy_fields= force_copy_fields;
03317   DBUG_ASSERT(table == 0);
03318   /*
03319     We have to create a temporary table to get descriptions of fields
03320     (types, sizes and so on).
03321 
03322     Note that in the table, we first have the ORDER BY fields, then the
03323     field list.
03324 
03325     We need to set set_sum_field in true for storing value of blob in buffer
03326     of a record instead of a pointer of one.
03327   */
03328   if (!(table= create_tmp_table(thd, tmp_table_param, all_fields,
03329                                 (ORDER*) 0, 0, TRUE,
03330                                 (select_lex->options | thd->options),
03331                                 HA_POS_ERROR, (char*) "")))
03332     DBUG_RETURN(TRUE);
03333   table->file->extra(HA_EXTRA_NO_ROWS);
03334   table->no_rows= 1;
03335 
03336 
03337   if (distinct || arg_count_order)
03338   {
03339     /*
03340       Need sorting: init tree and choose a function to sort.
03341       Don't reserve space for NULLs: if any of gconcat arguments is NULL,
03342       the row is not added to the result.
03343     */
03344     uint tree_key_length= table->s->reclength - table->s->null_bytes;
03345 
03346     tree= &tree_base;
03347     if (arg_count_order)
03348     {
03349       if (distinct)
03350         compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct_and_order;
03351       else
03352         compare_key= (qsort_cmp2) group_concat_key_cmp_with_order;
03353     }
03354     else
03355     {
03356       compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct;
03357     }
03358     /*
03359       Create a tree for sorting. The tree is used to sort and to remove
03360       duplicate values (according to the syntax of this function). If there
03361       is no DISTINCT or ORDER BY clauses, we don't create this tree.
03362     */
03363     init_tree(tree, min(thd->variables.max_heap_table_size,
03364                         thd->variables.sortbuff_size/16), 0,
03365               tree_key_length, compare_key, 0, NULL, (void*) this);
03366   }
03367 
03368   DBUG_RETURN(FALSE);
03369 }

Here is the call graph for this function:

enum Sumfunctype Item_func_group_concat::sum_func ( ) const [inline, virtual]

Implements Item_sum.

Definition at line 1119 of file item_sum.h.

References Item_sum::GROUP_CONCAT_FUNC.

01119 {return GROUP_CONCAT_FUNC;}

void Item_func_group_concat::update_field ( ) [inline, virtual]

Implements Item_sum.

Definition at line 1132 of file item_sum.h.

References DBUG_ASSERT.

01132 { DBUG_ASSERT(0); }       // not used

my_decimal* Item_func_group_concat::val_decimal ( my_decimal * decimal_value ) [inline, virtual]

Implements Item.

Definition at line 1151 of file item_sum.h.

References Item::val_decimal_from_string().

01152   {
01153     return val_decimal_from_string(decimal_value);
01154   }

Here is the call graph for this function:

longlong Item_func_group_concat::val_int ( void ) [inline, virtual]

Implements Item.

Definition at line 1141 of file item_sum.h.

References error, String::length(), my_strtoll10(), String::ptr(), Item::str_value, and val_str().

01142   {
01143     String *res;
01144     char *end_ptr;
01145     int error;
01146     if (!(res= val_str(&str_value)))
01147       return (longlong) 0;
01148     end_ptr= (char*) res->ptr()+ res->length();
01149     return my_strtoll10(res->ptr(), &end_ptr, &error);
01150   }

Here is the call graph for this function:

double Item_func_group_concat::val_real ( void ) [inline, virtual]

Implements Item.

Definition at line 1136 of file item_sum.h.

References String::c_ptr(), my_atof(), Item::str_value, and val_str().

01137   {
01138     String *res;  res=val_str(&str_value);
01139     return res ? my_atof(res->c_ptr()) : 0.0;
01140   }

Here is the call graph for this function:

String * Item_func_group_concat::val_str ( String * str ) [virtual]

Implements Item.

Definition at line 3384 of file item_sum.cc.

References count_cut_values, DBUG_ASSERT, dump_leaf_key, ER, ER_CUT_VALUE_GROUP_CONCAT, Item::fixed, left_root_right, String::length(), Item::null_value, push_warning(), result, table, tree, tree_walk(), MYSQL_ERROR::WARN_LEVEL_WARN, and warning.

Referenced by val_int(), and val_real().

03385 {
03386   DBUG_ASSERT(fixed == 1);
03387   if (null_value)
03388     return 0;
03389   if (count_cut_values && !warning)
03390   {
03391     /*
03392       ER_CUT_VALUE_GROUP_CONCAT needs an argument, but this gets set in
03393       Item_func_group_concat::cleanup().
03394     */
03395     DBUG_ASSERT(table);
03396     warning= push_warning(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
03397                           ER_CUT_VALUE_GROUP_CONCAT,
03398                           ER(ER_CUT_VALUE_GROUP_CONCAT));
03399   }
03400   if (result.length())
03401     return &result;
03402   if (tree)
03403     tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this,
03404               left_root_right);
03405   return &result;
03406 }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

int dump_leaf_key	(	byte *	key,
		element_count count	__attribute__((unused)),
		Item_func_group_concat *	group_concat_item
	)			`[friend]`

Definition at line 2982 of file item_sum.cc.

Referenced by add(), and val_str().

02984 {
02985   TABLE *table= item->table;
02986   String tmp((char *)table->record[1], table->s->reclength,
02987              default_charset_info);
02988   String tmp2;
02989   String *result= &item->result;
02990   Item **arg= item->args, **arg_end= item->args + item->arg_count_field;
02991 
02992   if (item->no_appended)
02993     item->no_appended= FALSE;
02994   else
02995     result->append(*item->separator);
02996 
02997   tmp.length(0);
02998 
02999   for (; arg < arg_end; arg++)
03000   {
03001     String *res;
03002     if (! (*arg)->const_item())
03003     {
03004       /*
03005         We have to use get_tmp_table_field() instead of
03006         real_item()->get_tmp_table_field() because we want the field in
03007         the temporary table, not the original field
03008         We also can't use table->field array to access the fields
03009         because it contains both order and arg list fields.
03010       */
03011       Field *field= (*arg)->get_tmp_table_field();
03012       uint offset= field->offset() - table->s->null_bytes;
03013       DBUG_ASSERT(offset < table->s->reclength);
03014       res= field->val_str(&tmp, (char *) key + offset);
03015     }
03016     else
03017       res= (*arg)->val_str(&tmp);
03018     if (res)
03019       result->append(*res);
03020   }
03021 
03022   /* stop if length of result more than max_length */
03023   if (result->length() > item->max_length)
03024   {
03025     item->count_cut_values++;
03026     result->length(item->max_length);
03027     item->warning_for_row= TRUE;
03028     return 1;
03029   }
03030   return 0;
03031 }

int group_concat_key_cmp_with_distinct	(	void *	arg,
		byte *	key1,
		byte *	key2
	)			`[friend]`

Definition at line 2883 of file item_sum.cc.

Referenced by setup().

02885 {
02886   Item_func_group_concat* grp_item= (Item_func_group_concat*)arg;
02887   TABLE *table= grp_item->table;
02888   Item **field_item, **end;
02889 
02890   for (field_item= grp_item->args, end= field_item + grp_item->arg_count_field;
02891        field_item < end;
02892        field_item++)
02893   {
02894     /*
02895       We have to use get_tmp_table_field() instead of
02896       real_item()->get_tmp_table_field() because we want the field in
02897       the temporary table, not the original field
02898     */
02899     Field *field= (*field_item)->get_tmp_table_field();
02900     /* 
02901       If field_item is a const item then either get_tp_table_field returns 0
02902       or it is an item over a const table. 
02903     */
02904     if (field && !(*field_item)->const_item())
02905     {
02906       int res;
02907       uint offset= field->offset() - table->s->null_bytes;
02908       if ((res= field->cmp((char *) key1 + offset, (char *) key2 + offset)))
02909         return res;
02910     }
02911   }
02912   return 0;
02913 }

int group_concat_key_cmp_with_distinct_and_order	(	void *	arg,
		byte *	key1,
		byte *	key2
	)			`[friend]`

Definition at line 2969 of file item_sum.cc.

Referenced by setup().

02971 {
02972   if (!group_concat_key_cmp_with_distinct(arg,key1,key2))
02973     return 0;
02974   return(group_concat_key_cmp_with_order(arg,key1,key2));
02975 }

int group_concat_key_cmp_with_order	(	void *	arg,
		byte *	key1,
		byte *	key2
	)			`[friend]`

Definition at line 2921 of file item_sum.cc.

Referenced by setup().

02922 {
02923   Item_func_group_concat* grp_item= (Item_func_group_concat*) arg;
02924   ORDER **order_item, **end;
02925   TABLE *table= grp_item->table;
02926 
02927   for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
02928        order_item < end;
02929        order_item++)
02930   {
02931     Item *item= *(*order_item)->item;
02932     /*
02933       We have to use get_tmp_table_field() instead of
02934       real_item()->get_tmp_table_field() because we want the field in
02935       the temporary table, not the original field
02936     */
02937     Field *field= item->get_tmp_table_field();
02938     /* 
02939       If item is a const item then either get_tp_table_field returns 0
02940       or it is an item over a const table. 
02941     */
02942     if (field && !item->const_item())
02943     {
02944       int res;
02945       uint offset= field->offset() - table->s->null_bytes;
02946       if ((res= field->cmp((char *) key1 + offset, (char *) key2 + offset)))
02947         return (*order_item)->asc ? res : -res;
02948     }
02949   }
02950   /*
02951     We can't return 0 because in that case the tree class would remove this
02952     item as double value. This would cause problems for case-changes and
02953     if the returned values are not the same we do the sort on.
02954   */
02955   return 1;
02956 }