diff options
Diffstat (limited to 'sql/item_sum.cc')
| -rw-r--r-- | sql/item_sum.cc | 456 |
1 files changed, 456 insertions, 0 deletions
diff --git a/sql/item_sum.cc b/sql/item_sum.cc index e303c26262e..55a2765cba3 100644 --- a/sql/item_sum.cc +++ b/sql/item_sum.cc @@ -1329,3 +1329,459 @@ String *Item_sum_udf_str::val_str(String *str) } #endif /* HAVE_DLOPEN */ + + +/***************************************************************************** + GROUP_CONCAT function + Syntax: + GROUP_CONCAT([DISTINCT] expr,... [ORDER BY col [ASC|DESC],...] + [SEPARATOR str_const]) + concat of values from "group by" operation +*****************************************************************************/ + +/* + function of sort for syntax: + GROUP_CONCAT(DISTINCT expr,...) +*/ + +static int group_concat_key_cmp_with_distinct(void* arg, byte* key1, byte* key2) +{ + Item_func_group_concat* item= (Item_func_group_concat*)arg; + for (int i= 0; i<item->arg_count_field; i++) + { + Item *field_item= item->expr[i]; + Field *field= field_item->tmp_table_field(); + if (field) + { + uint offset= field->offset(); + + int res= field->key_cmp(key1 + offset, key2 + offset); + /* + if key1 and key2 is not equal than field->key_cmp return offset. This function + must return value 1 for this case. + */ + if (res) + return 1; + } + } + return 0; +} + +/* + function of sort for syntax: + GROUP_CONCAT(expr,... ORDER BY col,... ) +*/ + +static int group_concat_key_cmp_with_order(void* arg, byte* key1, byte* key2) +{ + Item_func_group_concat* item= (Item_func_group_concat*)arg; + for (int i=0; i<item->arg_count_order; i++) + { + ORDER *order_item= item->order[i]; + Item *item= *order_item->item; + Field *field= item->tmp_table_field(); + if (field) + { + uint offset= field->offset(); + + bool dir= order_item->asc; + int res= field->key_cmp(key1 + offset, key2 + offset); + if (res) + return dir ? res : -res; + } + } + /* + We can't return 0 becouse tree class remove this item as dubl value. + */ + return 1; +} + +/* + function of sort for syntax: + GROUP_CONCAT(DISTINCT expr,... ORDER BY col,... ) +*/ + +static int group_concat_key_cmp_with_distinct_and_order(void* arg, byte* key1, byte* key2) +{ + Item_func_group_concat* item= (Item_func_group_concat*)arg; + if (!group_concat_key_cmp_with_distinct(arg,key1,key2)) + return 0; + return(group_concat_key_cmp_with_order(arg,key1,key2)); +} + +/* + create result + item is pointer to Item_func_group_concat +*/ + +static int dump_leaf_key(byte* key, uint32 count __attribute__((unused)), + Item_func_group_concat *group_concat_item) +{ + char buff[MAX_FIELD_WIDTH]; + String tmp((char *)&buff,sizeof(buff),default_charset_info); + String tmp2((char *)&buff,sizeof(buff),default_charset_info); + + tmp.length(0); + + for (int i= 0; i < group_concat_item->arg_show_fields; i++) + { + Item *show_item= group_concat_item->expr[i]; + if (!show_item->const_item()) + { + Field *f= show_item->tmp_table_field(); + uint offset= f->offset(); + char *sv= f->ptr; + f->ptr= (char *)key + offset; + String *res= f->val_str(&tmp,&tmp2); + group_concat_item->result.append(*res); + f->ptr= sv; + } + else + { + String *res= show_item->val_str(&tmp); + if (res) + group_concat_item->result.append(*res); + } + } + if (group_concat_item->tree_mode) // Last item of tree + { + group_concat_item->show_elements++; + if (group_concat_item->show_elements < + group_concat_item->tree->elements_in_tree) + group_concat_item->result.append(*group_concat_item->separator); + } + else + { + group_concat_item->result.append(*group_concat_item->separator); + } + /* + if length of result more than group_concat_max_len - stop ! + */ + if (group_concat_item->result.length() > + group_concat_item->group_concat_max_len) + { + group_concat_item->count_cut_values++; + group_concat_item->result.length(group_concat_item->group_concat_max_len); + group_concat_item->warning_for_row= TRUE; + return 1; + } + return 0; +} + +/* + Constructor of Item_func_group_concat + is_distinct - distinct + is_select - list of expression for show values + is_order - list of sort columns + is_separator - string value of separator +*/ + +Item_func_group_concat::Item_func_group_concat(int is_distinct,List<Item> *is_select, + SQL_LIST *is_order,String *is_separator): + Item_sum(), + tmp_table_param(0), + warning_available(false), + separator(is_separator), + tree(&tree_base), + table(0), + distinct(is_distinct), + tree_mode(0), + count_cut_values(0) +{ + original= 0; + quick_group= 0; + mark_as_sum_func(); + SELECT_LEX *select_lex= current_lex->current_select->select_lex(); + order= 0; + + arg_show_fields= arg_count_field= is_select->elements; + arg_count_order= is_order ? is_order->elements : 0; + arg_count= arg_count_field; + + /* + We need to allocate: + args - arg_count+arg_count_order (for possible order items in temporare + tables) + expr - arg_count_field + order - arg_count_order + */ + args= (Item**)sql_alloc(sizeof(Item*)*(arg_count+arg_count_order+arg_count_field)+ + sizeof(ORDER*)*arg_count_order); + if (!args) + { + my_error(ER_OUTOFMEMORY,MYF(0)); + } + expr= args; + expr+= arg_count+arg_count_order; + if (arg_count_order) + { + order= (ORDER**)(expr + arg_count_field); + } + /* + fill args items of show and sort + */ + int i= 0; + List_iterator_fast<Item> li(*is_select); + Item *item_select; + + while ((item_select= li++)) + { + args[i]= expr[i]= item_select; + i++; + } + + if (order) + { + uint j= 0; + for (ORDER *order_item= (ORDER*)is_order->first; + order_item != NULL; + order_item= order_item->next) + { + order[j++]= order_item; + } + } +} + + +Item_func_group_concat::~Item_func_group_concat() +{ + /* + Free table and tree if they belong to this item (if item have not pointer + to original item from which was made copy => it own its objects ) + */ + if (!original) + { + if (warning_available) + { + char warn_buff[MYSQL_ERRMSG_SIZE]; + sprintf(warn_buff, ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values); + ((MYSQL_ERROR *)warning)->set_msg((char *)&warn_buff); + } + if (table) + free_tmp_table(current_thd, table); + if (tmp_table_param) + delete tmp_table_param; + if (tree_mode) + delete_tree(tree); + } +} + + +void Item_func_group_concat::reset() +{ + result.length(0); + result.copy(); + null_value= TRUE; + warning_for_row= false; + if (table) + { + table->file->extra(HA_EXTRA_NO_CACHE); + table->file->delete_all_rows(); + table->file->extra(HA_EXTRA_WRITE_CACHE); + } + if (tree_mode) + reset_tree(tree); + add(); +} + + +bool Item_func_group_concat::add() +{ + copy_fields(tmp_table_param); + copy_funcs(tmp_table_param->items_to_copy); + + bool record_is_null= TRUE; + for (int i= 0; i < arg_show_fields; i++) + { + Item *show_item= expr[i]; + if (!show_item->const_item()) + { + Field *f= show_item->tmp_table_field(); + if (!f->is_null()) + record_is_null= FALSE; + } + } + if (record_is_null) + return 0; + null_value= FALSE; + if (tree_mode) + { + if (!tree_insert(tree, table->record[0], 0,tree->custom_arg)) + return 1; + } + else + { + if (result.length() <= group_concat_max_len && !warning_for_row) + dump_leaf_key(table->record[0],1, + (Item_func_group_concat*)this); + } + return 0; +} + + +void Item_func_group_concat::reset_field() +{ + if (tree_mode) + reset_tree(tree); +} + + +bool +Item_func_group_concat::fix_fields(THD *thd, TABLE_LIST *tables, Item **ref) +{ + if (!thd->allow_sum_func) + { + my_error(ER_INVALID_GROUP_FUNC_USE,MYF(0)); + return 1; + } + + thd->allow_sum_func= 0; + maybe_null= 0; + for (uint i= 0 ; i < arg_count ; i++) + { + if (args[i]->fix_fields(thd, tables, args + i) || args[i]->check_cols(1)) + return 1; + maybe_null |= args[i]->maybe_null; + } + for (int i= 0 ; i < arg_count_field ; i++) + { + if (expr[i]->fix_fields(thd, tables, expr + i) || expr[i]->check_cols(1)) + return 1; + maybe_null |= expr[i]->maybe_null; + } + /* + Fix fields for order clause in function: + GROUP_CONCAT(expr,... ORDER BY col,... ) + */ + for (int i= 0 ; i < arg_count_order ; i++) + { + ORDER *order_item= order[i]; + Item *item=*order_item->item; + if (item->fix_fields(thd, tables, &item) || item->check_cols(1)) + return 1; + } + result_field= 0; + null_value= 1; + fix_length_and_dec(); + thd->allow_sum_func= 1; + if (!(tmp_table_param= new TMP_TABLE_PARAM)) + return 1; + tables_list= tables; + fixed= 1; + return 0; +} + + +bool Item_func_group_concat::setup(THD *thd) +{ + List<Item> list; + SELECT_LEX *select_lex= current_lex->current_select->select_lex(); + + if (select_lex->linkage == GLOBAL_OPTIONS_TYPE) + return 1; + /* + all not constant fields are push to list and create temp table + */ + for (uint i= 0; i < arg_count; i++) + { + Item *item= args[i]; + if (list.push_back(item)) + return 1; + if (item->const_item()) + { + (void) item->val_int(); + if (item->null_value) + always_null= 1; + } + } + + List<Item> all_fields(list); + if (arg_count_order) + { + bool hidden_group_fields; + setup_group(thd, args, tables_list, list, all_fields, *order, + &hidden_group_fields); + } + + count_field_types(tmp_table_param,all_fields,0); + /* + We have to create a temporary table for that we get descriptions of fields + (types, sizes and so on). + */ + if (!(table=create_tmp_table(thd, tmp_table_param, all_fields, 0, + 0, 0, 0,select_lex->options | thd->options))) + return 1; + table->file->extra(HA_EXTRA_NO_ROWS); + table->no_rows= 1; + qsort_cmp2 compare_key; + + tree_mode= distinct || arg_count_order; + /* + choise function of sort + */ + if (tree_mode) + { + if (arg_count_order) + { + if (distinct) + compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct_and_order; + else + compare_key= (qsort_cmp2) group_concat_key_cmp_with_order; + } + else + { + if (distinct) + compare_key= (qsort_cmp2) group_concat_key_cmp_with_distinct; + else + compare_key= NULL; + } + /* + Create a tree of sort. Tree is used for a sort and a remove dubl + values (according with syntax of the function). If function does't + contain DISTINCT and ORDER BY clauses, we don't create this tree. + */ + init_tree(tree, min(thd->variables.max_heap_table_size, + thd->variables.sortbuff_size/16), 0, + table->reclength, compare_key, 0, NULL, (void*) this); + max_elements_in_tree= ((table->reclength) ? + thd->variables.max_heap_table_size/table->reclength : 1); + }; + item_thd= thd; + + group_concat_max_len= thd->variables.group_concat_max_len; + + /* + Copy table and tree_mode if they belong to this item (if item have not + pointer to original item from which was made copy => it own its objects) + */ + if (original) + { + original->table= table; + original->tree_mode= tree_mode; + } + return 0; +} + +String* Item_func_group_concat::val_str(String* str) +{ + if (null_value) + return 0; + if (tree_mode) + { + show_elements= 0; + tree_walk(tree, (tree_walk_action)&dump_leaf_key, (void*)this, + left_root_right); + } + else + { + if (!warning_for_row) + result.length(result.length()-separator->length()); + } + if (count_cut_values && !warning_available) + { + warning_available= TRUE; + warning= push_warning(item_thd, MYSQL_ERROR::WARN_LEVEL_WARN, + ER_CUT_VALUE_GROUP_CONCAT, NULL); + } + return &result; +} |