/* Copyright (c) 2000, 2015, Oracle and/or its affiliates.

Copyright (c) 2008, 2015, MariaDB

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; version 2 of the License.

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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */

/**

@file

@brief

Sum functions (COUNT, MIN...)

*/

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation // gcc: Class implementation

#endif

#include <my_global.h>

#include "sql_priv.h"

#include "sql_select.h"

/**

Calculate the affordable RAM limit for structures like TREE or Unique

used in Item_sum_*

*/

ulonglong Item_sum::ram_limitation(THD *thd)

{

return MY_MIN(thd->variables.tmp_table_size,

thd->variables.max_heap_table_size);

}

/**

Prepare an aggregate function item for checking context conditions.

The function initializes the members of the Item_sum object created

for a set function that are used to check validity of the set function

occurrence.

If the set function is not allowed in any subquery where it occurs

an error is reported immediately.

@param thd reference to the thread context info

@note

This function is to be called for any item created for a set function

object when the traversal of trees built for expressions used in the query

is performed at the phase of context analysis. This function is to

be invoked at the descent of this traversal.

@retval

TRUE if an error is reported

@retval

FALSE otherwise

*/

bool Item_sum::init_sum_func_check(THD *thd)

{

SELECT_LEX *curr_sel= thd->lex->current_select;

if (!curr_sel->name_visibility_map)

{

for (SELECT_LEX *sl= curr_sel; sl; sl= sl->context.outer_select())

{

curr_sel->name_visibility_map|= (1 << sl-> nest_level);

}

}

if (!(thd->lex->allow_sum_func & curr_sel->name_visibility_map))

{

my_message(ER_INVALID_GROUP_FUNC_USE, ER_THD(thd, ER_INVALID_GROUP_FUNC_USE),

MYF(0));

return TRUE;

}

/* Set a reference to the nesting set function if there is any */

in_sum_func= thd->lex->in_sum_func;

/* Save a pointer to object to be used in items for nested set functions */

thd->lex->in_sum_func= this;

nest_level= thd->lex->current_select->nest_level;

ref_by= 0;

aggr_level= -1;

aggr_sel= NULL;

max_arg_level= -1;

max_sum_func_level= -1;

outer_fields.empty();

return FALSE;

}

/**

Check constraints imposed on a usage of a set function.

The method verifies whether context conditions imposed on a usage

of any set function are met for this occurrence.

It checks whether the set function occurs in the position where it

can be aggregated and, when it happens to occur in argument of another

set function, the method checks that these two functions are aggregated in

different subqueries.

If the context conditions are not met the method reports an error.

If the set function is aggregated in some outer subquery the method

adds it to the chain of items for such set functions that is attached

to the the st_select_lex structure for this subquery.

A number of designated members of the object are used to check the

conditions. They are specified in the comment before the Item_sum

class declaration.

Additionally a bitmap variable called allow_sum_func is employed.

It is included into the thd->lex structure.

The bitmap contains 1 at n-th position if the set function happens

to occur under a construct of the n-th level subquery where usage

of set functions are allowed (i.e either in the SELECT list or

in the HAVING clause of the corresponding subquery)

Consider the query:

@code

SELECT SUM(t1.b) FROM t1 GROUP BY t1.a

HAVING t1.a IN (SELECT t2.c FROM t2 WHERE AVG(t1.b) > 20) AND

t1.a > (SELECT MIN(t2.d) FROM t2);

@endcode

allow_sum_func will contain:

- for SUM(t1.b) - 1 at the first position

- for AVG(t1.b) - 1 at the first position, 0 at the second position

- for MIN(t2.d) - 1 at the first position, 1 at the second position.

@param thd reference to the thread context info

@param ref location of the pointer to this item in the embedding expression

@note

This function is to be called for any item created for a set function

object when the traversal of trees built for expressions used in the query

is performed at the phase of context analysis. This function is to

be invoked at the ascent of this traversal.

@retval

TRUE if an error is reported

@retval

FALSE otherwise

*/

bool Item_sum::check_sum_func(THD *thd, Item **ref)

{

SELECT_LEX *curr_sel= thd->lex->current_select;

nesting_map allow_sum_func= (thd->lex->allow_sum_func &

curr_sel->name_visibility_map);

bool invalid= FALSE;

DBUG_ASSERT(curr_sel->name_visibility_map); // should be set already

/*

The value of max_arg_level is updated if an argument of the set function

contains a column reference resolved against a subquery whose level is

greater than the current value of max_arg_level.

max_arg_level cannot be greater than nest level.

nest level is always >= 0

*/

if (nest_level == max_arg_level)

{

/*

The function must be aggregated in the current subquery,

If it is there under a construct where it is not allowed

we report an error.

*/

invalid= !(allow_sum_func & ((nesting_map)1 << max_arg_level));

}

else if (max_arg_level >= 0 ||

!(allow_sum_func & ((nesting_map)1 << nest_level)))

{

/*

The set function can be aggregated only in outer subqueries.

Try to find a subquery where it can be aggregated;

If we fail to find such a subquery report an error.

*/

if (register_sum_func(thd, ref))

return TRUE;

invalid= aggr_level < 0 &&

!(allow_sum_func & ((nesting_map)1 << nest_level));

if (!invalid && thd->variables.sql_mode & MODE_ANSI)

invalid= aggr_level < 0 && max_arg_level < nest_level;

}

if (!invalid && aggr_level < 0)

{

aggr_level= nest_level;

aggr_sel= curr_sel;

}

/*

By this moment we either found a subquery where the set function is

to be aggregated and assigned a value that is >= 0 to aggr_level,

or set the value of 'invalid' to TRUE to report later an error.

*/

/*

Additionally we have to check whether possible nested set functions

are acceptable here: they are not, if the level of aggregation of

some of them is less than aggr_level.

*/

if (!invalid)

invalid= aggr_level <= max_sum_func_level;

if (invalid)

{

my_message(ER_INVALID_GROUP_FUNC_USE,

ER_THD(thd, ER_INVALID_GROUP_FUNC_USE),

MYF(0));

return TRUE;

}

if (in_sum_func)

{

/*

If the set function is nested adjust the value of

max_sum_func_level for the nesting set function.

We take into account only enclosed set functions that are to be

aggregated on the same level or above of the nest level of

the enclosing set function.

But we must always pass up the max_sum_func_level because it is

the maximum nested level of all directly and indirectly enclosed

set functions. We must do that even for set functions that are

aggregated inside of their enclosing set function's nest level

because the enclosing function may contain another enclosing

function that is to be aggregated outside or on the same level

as its parent's nest level.

*/

if (in_sum_func->nest_level >= aggr_level)

set_if_bigger(in_sum_func->max_sum_func_level, aggr_level);

set_if_bigger(in_sum_func->max_sum_func_level, max_sum_func_level);

}

/*

Check that non-aggregated fields and sum functions aren't mixed in the

same select in the ONLY_FULL_GROUP_BY mode.

*/

if (outer_fields.elements)

{

Item_field *field;

/*

Here we compare the nesting level of the select to which an outer field

belongs to with the aggregation level of the sum function. All fields in

the outer_fields list are checked.

If the nesting level is equal to the aggregation level then the field is

aggregated by this sum function.

If the nesting level is less than the aggregation level then the field

belongs to an outer select. In this case if there is an embedding sum

function add current field to functions outer_fields list. If there is

no embedding function then the current field treated as non aggregated

and the select it belongs to is marked accordingly.

If the nesting level is greater than the aggregation level then it means

that this field was added by an inner sum function.

Consider an example:

select avg ( <-- we are here, checking outer.f1

select (

select sum(outer.f1 + inner.f1) from inner

) from outer)

from most_outer;

In this case we check that no aggregate functions are used in the

select the field belongs to. If there are some then an error is

raised.

*/

List_iterator<Item_field> of(outer_fields);

while ((field= of++))

{

SELECT_LEX *sel= field->field->table->pos_in_table_list->select_lex;

if (sel->nest_level < aggr_level)

{

if (in_sum_func)

{

/*

Let upper function decide whether this field is a non

aggregated one.

*/

in_sum_func->outer_fields.push_back(field, thd->mem_root);

}

else

sel->set_non_agg_field_used(true);

}

if (sel->nest_level > aggr_level &&

(sel->agg_func_used()) &&

!sel->group_list.elements)

{

my_message(ER_MIX_OF_GROUP_FUNC_AND_FIELDS,

ER_THD(thd, ER_MIX_OF_GROUP_FUNC_AND_FIELDS), MYF(0));

return TRUE;

}

}

}

aggr_sel->set_agg_func_used(true);

update_used_tables();

thd->lex->in_sum_func= in_sum_func;

return FALSE;

}

/**

Attach a set function to the subquery where it must be aggregated.

The function looks for an outer subquery where the set function must be

aggregated. If it finds such a subquery then aggr_level is set to

the nest level of this subquery and the item for the set function

is added to the list of set functions used in nested subqueries

inner_sum_func_list defined for each subquery. When the item is placed

there the field 'ref_by' is set to ref.

@note

Now we 'register' only set functions that are aggregated in outer

subqueries. Actually it makes sense to link all set function for

a subquery in one chain. It would simplify the process of 'splitting'

for set functions.

@param thd reference to the thread context info

@param ref location of the pointer to this item in the embedding expression

@retval

FALSE if the executes without failures (currently always)

@retval

TRUE otherwise

*/

bool Item_sum::register_sum_func(THD *thd, Item **ref)

{

SELECT_LEX *sl;

nesting_map allow_sum_func= thd->lex->allow_sum_func;

for (sl= thd->lex->current_select->context.outer_select() ;

sl && sl->nest_level > max_arg_level;

sl= sl->context.outer_select())

{

if (aggr_level < 0 &&

(allow_sum_func & ((nesting_map)1 << sl->nest_level)))

{

/* Found the most nested subquery where the function can be aggregated */

aggr_level= sl->nest_level;

aggr_sel= sl;

}

}

if (sl && (allow_sum_func & ((nesting_map)1 << sl->nest_level)))

{

/*

We reached the subquery of level max_arg_level and checked

that the function can be aggregated here.

The set function will be aggregated in this subquery.

*/

aggr_level= sl->nest_level;

aggr_sel= sl;

}

if (aggr_level >= 0)

{

ref_by= ref;

/* Add the object to the list of registered objects assigned to aggr_sel */

if (!aggr_sel->inner_sum_func_list)

next= this;

else

{

next= aggr_sel->inner_sum_func_list->next;

aggr_sel->inner_sum_func_list->next= this;

}

aggr_sel->inner_sum_func_list= this;

aggr_sel->with_sum_func= 1;

/*

Mark Item_subselect(s) as containing aggregate function all the way up

to aggregate function's calculation context.

Note that we must not mark the Item of calculation context itself

because with_sum_func on the calculation context st_select_lex is

already set above.

with_sum_func being set for an Item means that this Item refers

(somewhere in it, e.g. one of its arguments if it's a function) directly

or through intermediate items to an aggregate function that is calculated

in a context "outside" of the Item (e.g. in the current or outer select).

with_sum_func being set for an st_select_lex means that this st_select_lex

has aggregate functions directly referenced (i.e. not through a sub-select).

*/

for (sl= thd->lex->current_select;

sl && sl != aggr_sel && sl->master_unit()->item;

sl= sl->master_unit()->outer_select() )

sl->master_unit()->item->with_sum_func= 1;

}

thd->lex->current_select->mark_as_dependent(thd, aggr_sel, NULL);

if ((thd->lex->describe & DESCRIBE_EXTENDED) && aggr_sel)

{

push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE,

ER_WARN_AGGFUNC_DEPENDENCE,

ER_THD(thd, ER_WARN_AGGFUNC_DEPENDENCE),

func_name(),

thd->lex->current_select->select_number,

aggr_sel->select_number);

}

return FALSE;

}

bool Item_sum::collect_outer_ref_processor(uchar *param)

{

Collect_deps_prm *prm= (Collect_deps_prm *)param;

SELECT_LEX *ds;

if ((ds= depended_from()) &&

ds->nest_level_base == prm->nest_level_base &&

ds->nest_level < prm->nest_level)

{

if (prm->collect)

prm->parameters->add_unique(this, &cmp_items);

else

prm->count++;

}

return FALSE;

}

Item_sum::Item_sum(THD *thd, List<Item> &list): Item_func_or_sum(thd, list)

{

if (!(orig_args= (Item **) thd->alloc(sizeof(Item *) * arg_count)))

{

args= NULL;

}

mark_as_sum_func();

init_aggregator();

list.empty(); // Fields are used

}

/**

Constructor used in processing select with temporary tebles.

*/

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

Item_func_or_sum(thd, item),

aggr_sel(item->aggr_sel),

nest_level(item->nest_level), aggr_level(item->aggr_level),

quick_group(item->quick_group),

orig_args(NULL)

{

if (arg_count <= 2)

{

orig_args=tmp_orig_args;

}

else

{

if (!(orig_args= (Item**) thd->alloc(sizeof(Item*)*arg_count)))

return;

}

memcpy(orig_args, item->orig_args, sizeof(Item*)*arg_count);

init_aggregator();

with_distinct= item->with_distinct;

if (item->aggr)

set_aggregator(item->aggr->Aggrtype());

}

void Item_sum::mark_as_sum_func()

{

SELECT_LEX *cur_select= current_thd->lex->current_select;

cur_select->n_sum_items++;

cur_select->with_sum_func= 1;

const_item_cache= false;

with_sum_func= 1;

with_field= 0;

}

void Item_sum::print(String *str, enum_query_type query_type)

{

/* orig_args is not filled with valid values until fix_fields() */

Item **pargs= fixed ? orig_args : args;

str->append(func_name());

for (uint i=0 ; i < arg_count ; i++)

{

if (i)

str->append(',');

pargs[i]->print(str, query_type);

}

str->append(')');

}

void Item_sum::fix_num_length_and_dec()

{

decimals=0;

for (uint i=0 ; i < arg_count ; i++)

set_if_bigger(decimals,args[i]->decimals);

max_length=float_length(decimals);

}

Item *Item_sum::get_tmp_table_item(THD *thd)

{

Item_sum* sum_item= (Item_sum *) copy_or_same(thd);

if (sum_item && sum_item->result_field) // If not a const sum func

{

Field *result_field_tmp= sum_item->result_field;

for (uint i=0 ; i < sum_item->arg_count ; i++)

{

Item *arg= sum_item->args[i];

if (!arg->const_item())

{

if (arg->type() == Item::FIELD_ITEM)

((Item_field*) arg)->field= result_field_tmp++;

else

sum_item->args[i]= new (thd->mem_root) Item_temptable_field(thd, result_field_tmp++);

}

}

}

return sum_item;

}

Field *Item_sum::create_tmp_field(bool group, TABLE *table)

{

Field *UNINIT_VAR(field);

MEM_ROOT *mem_root= table->in_use->mem_root;

switch (result_type()) {

case REAL_RESULT:

field= new (mem_root)

Field_double(max_length, maybe_null, name, decimals, TRUE);

break;

case INT_RESULT:

field= new (mem_root)

Field_longlong(max_length, maybe_null, name, unsigned_flag);

break;

case STRING_RESULT:

return make_string_field(table);

case DECIMAL_RESULT:

field= Field_new_decimal::create_from_item(mem_root, this);

break;

case ROW_RESULT:

case TIME_RESULT:

// This case should never be choosen

DBUG_ASSERT(0);

return 0;

}

if (field)

field->init(table);

return field;

}

void Item_sum::update_used_tables ()

{

if (!Item_sum::const_item())

{

used_tables_cache= 0;

for (uint i=0 ; i < arg_count ; i++)

{

args[i]->update_used_tables();

used_tables_cache|= args[i]->used_tables();

}

/*

MariaDB: don't run the following {

used_tables_cache&= PSEUDO_TABLE_BITS;

// the aggregate function is aggregated into its local context

used_tables_cache|= ((table_map)1 << aggr_sel->join->tables) - 1;

} because if we do it, table elimination will assume that

- constructs like "COUNT(*)" use columns from all tables

- so, it is not possible to eliminate any table

our solution for COUNT(*) is that it has

item->used_tables() == 0 && !item->const_item()

*/

}

}

Item *Item_sum::set_arg(uint i, THD *thd, Item *new_val)

{

thd->change_item_tree(args + i, new_val);

return new_val;

}

int Item_sum::set_aggregator(Aggregator::Aggregator_type aggregator)

{

/*

Dependent subselects may be executed multiple times, making

set_aggregator to be called multiple times. The aggregator type

will be the same, but it needs to be reset so that it is

reevaluated with the new dependent data.

This function may also be called multiple times during query optimization.

In this case, the type may change, so we delete the old aggregator,

and create a new one.

*/

if (aggr && aggregator == aggr->Aggrtype())

{

aggr->clear();

return FALSE;

}

delete aggr;

switch (aggregator)

{

case Aggregator::DISTINCT_AGGREGATOR:

aggr= new Aggregator_distinct(this);

break;

case Aggregator::SIMPLE_AGGREGATOR:

aggr= new Aggregator_simple(this);

break;

};

return aggr ? FALSE : TRUE;

}

void Item_sum::cleanup()

{

if (aggr)

{

delete aggr;

aggr= NULL;

}

Item_result_field::cleanup();

const_item_cache= false;

}

Item *Item_sum::result_item(THD *thd, Field *field)

{

return new (thd->mem_root) Item_field(thd, field);

}

/**

Compare keys consisting of single field that cannot be compared as binary.

Used by the Unique class to compare keys. Will do correct comparisons

for all field types.

@param arg Pointer to the relevant Field class instance

@param key1 left key image

@param key2 right key image

@return comparison result

@retval < 0 if key1 < key2

@retval = 0 if key1 = key2

@retval > 0 if key1 > key2

*/

int simple_str_key_cmp(void* arg, uchar* key1, uchar* key2)

{

Field *f= (Field*) arg;

return f->cmp(key1, key2);

}

C_MODE_START

int count_distinct_walk(void *elem, element_count count, void *arg)

{

(*((ulonglong*)arg))++;

return 0;

}

C_MODE_END

/**

Correctly compare composite keys.

Used by the Unique class to compare keys. Will do correct comparisons

for composite keys with various field types.

@param arg Pointer to the relevant Aggregator_distinct instance

@param key1 left key image

@param key2 right key image

@return comparison result

@retval <0 if key1 < key2

@retval =0 if key1 = key2

@retval >0 if key1 > key2

*/

int Aggregator_distinct::composite_key_cmp(void* arg, uchar* key1, uchar* key2)

{

Aggregator_distinct *aggr= (Aggregator_distinct *) arg;

Field **field = aggr->table->field;

Field **field_end= field + aggr->table->s->fields;

uint32 *lengths=aggr->field_lengths;

for (; field < field_end; ++field)

{

Field* f = *field;

int len = *lengths++;

int res = f->cmp(key1, key2);

if (res)

return res;

key1 += len;

key2 += len;

}

return 0;

}

static enum enum_field_types

calc_tmp_field_type(enum enum_field_types table_field_type,

Item_result result_type)

{

/* Adjust tmp table type according to the chosen aggregation type */

switch (result_type) {

case STRING_RESULT:

case REAL_RESULT:

if (table_field_type != MYSQL_TYPE_FLOAT)

table_field_type= MYSQL_TYPE_DOUBLE;

break;

case INT_RESULT:

table_field_type= MYSQL_TYPE_LONGLONG;

/* fallthrough */

case DECIMAL_RESULT:

if (table_field_type != MYSQL_TYPE_LONGLONG)

table_field_type= MYSQL_TYPE_NEWDECIMAL;

break;

case ROW_RESULT:

default:

DBUG_ASSERT(0);

}

return table_field_type;

}

/***************************************************************************/

C_MODE_START

/* Declarations for auxilary C-callbacks */

int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)

{

return memcmp(key1, key2, *(uint *) arg);

}

static int item_sum_distinct_walk_for_count(void *element,

element_count num_of_dups,

void *item)

{

return ((Aggregator_distinct*) (item))->unique_walk_function_for_count(element);

}

static int item_sum_distinct_walk(void *element, element_count num_of_dups,

void *item)

{

return ((Aggregator_distinct*) (item))->unique_walk_function(element);

}

C_MODE_END

/***************************************************************************/

/**

Called before feeding the first row. Used to allocate/setup

the internal structures used for aggregation.

@param thd Thread descriptor

@return status

@retval FALSE success

@retval TRUE faliure

Prepares Aggregator_distinct to process the incoming stream.

Creates the temporary table and the Unique class if needed.

Called by Item_sum::aggregator_setup()

*/

bool Aggregator_distinct::setup(THD *thd)

{

endup_done= FALSE;

/*

Setup can be called twice for ROLLUP items. This is a bug.

Please add DBUG_ASSERT(tree == 0) here when it's fixed.

*/

if (tree || table || tmp_table_param)

return FALSE;

if (item_sum->setup(thd))

return TRUE;

if (item_sum->sum_func() == Item_sum::COUNT_FUNC ||

item_sum->sum_func() == Item_sum::COUNT_DISTINCT_FUNC)

{

List<Item> list;

SELECT_LEX *select_lex= thd->lex->current_select;

if (!(tmp_table_param= new TMP_TABLE_PARAM))

return TRUE;

/* Create a table with an unique key over all parameters */

for (uint i=0; i < item_sum->get_arg_count() ; i++)

{

Item *item=item_sum->get_arg(i);

if (list.push_back(item, thd->mem_root))

return TRUE; // End of memory

if (item->const_item() && item->is_null())

always_null= true;

}

if (always_null)

return FALSE;

count_field_types(select_lex, tmp_table_param, list, 0);

tmp_table_param->force_copy_fields= item_sum->has_force_copy_fields();

DBUG_ASSERT(table == 0);

/*

Make create_tmp_table() convert BIT columns to BIGINT.

This is needed because BIT fields store parts of their data in table's

null bits, and we don't have methods to compare two table records, which

is needed by Unique which is used when HEAP table is used.

*/

{

List_iterator_fast<Item> li(list);

Item *item;

while ((item= li++))

{

if (item->type() == Item::FIELD_ITEM &&

((Item_field*)item)->field->type() == FIELD_TYPE_BIT)

item->marker=4;

}

}

if (!(table= create_tmp_table(thd, tmp_table_param, list, (ORDER*) 0, 1,

0,

(select_lex->options | thd->variables.option_bits),

HA_POS_ERROR, const_cast<char*>(""))))

return TRUE;

table->file->extra(HA_EXTRA_NO_ROWS); // Don't update rows

table->no_rows=1;

if (table->s->db_type() == heap_hton)

{

/*

No blobs, otherwise it would have been MyISAM: set up a compare

function and its arguments to use with Unique.

*/

qsort_cmp2 compare_key;

void* cmp_arg;

Field **field= table->field;

Field **field_end= field + table->s->fields;

bool all_binary= TRUE;

for (tree_key_length= 0; field < field_end; ++field)

{

Field *f= *field;

enum enum_field_types type= f->type();

tree_key_length+= f->pack_length();

if ((type == MYSQL_TYPE_VARCHAR) ||

(!f->binary() && (type == MYSQL_TYPE_STRING ||

type == MYSQL_TYPE_VAR_STRING)))

{

all_binary= FALSE;

break;

}

}

if (all_binary)

{

cmp_arg= (void*) &tree_key_length;

compare_key= (qsort_cmp2) simple_raw_key_cmp;

}

else

{

if (table->s->fields == 1)

{

/*

If we have only one field, which is the most common use of

count(distinct), it is much faster to use a simpler key

compare method that can take advantage of not having to worry

about other fields.

*/

compare_key= (qsort_cmp2) simple_str_key_cmp;

cmp_arg= (void*) table->field[0];

/* tree_key_length has been set already */

}

else

{

uint32 *length;

compare_key= (qsort_cmp2) composite_key_cmp;

cmp_arg= (void*) this;

field_lengths= (uint32*) thd->alloc(table->s->fields * sizeof(uint32));

for (tree_key_length= 0, length= field_lengths, field= table->field;

field < field_end; ++field, ++length)

{

*length= (*field)->pack_length();

tree_key_length+= *length;

}

}

}

DBUG_ASSERT(tree == 0);

tree= new Unique(compare_key, cmp_arg, tree_key_length,

item_sum->ram_limitation(thd));

/*

The only time tree_key_length could be 0 is if someone does

count(distinct) on a char(0) field - stupid thing to do,

but this has to be handled - otherwise someone can crash

the server with a DoS attack

*/

if (! tree)

return TRUE;

}

return FALSE;

}

else

{

List<Create_field> field_list;

Create_field field_def; /* field definition */

Item *arg;

DBUG_ENTER("Aggregator_distinct::setup");

/* It's legal to call setup() more than once when in a subquery */

if (tree)

DBUG_RETURN(FALSE);

/*

Virtual table and the tree are created anew on each re-execution of

PS/SP. Hence all further allocations are performed in the runtime

mem_root.

*/

if (field_list.push_back(&field_def, thd->mem_root))

DBUG_RETURN(TRUE);

item_sum->null_value= item_sum->maybe_null= 1;

item_sum->quick_group= 0;

DBUG_ASSERT(item_sum->get_arg(0)->fixed);

arg= item_sum->get_arg(0);

if (arg->const_item())

{

(void) arg->is_null();

if (arg->null_value)

always_null= true;

}

if (always_null)

DBUG_RETURN(FALSE);

enum enum_field_types field_type;

field_type= calc_tmp_field_type(arg->field_type(),

arg->result_type());

field_def.init_for_tmp_table(field_type,

arg->max_length,

arg->decimals,

arg->maybe_null,

arg->unsigned_flag);

if (! (table= create_virtual_tmp_table(thd, field_list)))

DBUG_RETURN(TRUE);

/* XXX: check that the case of CHAR(0) works OK */

tree_key_length= table->s->reclength - table->s->null_bytes;

/*

Unique handles all unique elements in a tree until they can't fit

in. Then the tree is dumped to the temporary file. We can use

simple_raw_key_cmp because the table contains numbers only; decimals

are converted to binary representation as well.

*/

tree= new Unique(simple_raw_key_cmp, &tree_key_length, tree_key_length,

item_sum->ram_limitation(thd));

DBUG_RETURN(tree == 0);

}

}

/**

Invalidate calculated value and clear the distinct rows.

Frees space used by the internal data structures.

Removes the accumulated distinct rows. Invalidates the calculated result.

*/

void Aggregator_distinct::clear()

{

endup_done= FALSE;

item_sum->clear();

if (tree)

tree->reset();

/* tree and table can be both null only if always_null */

if (item_sum->sum_func() == Item_sum::COUNT_FUNC ||

item_sum->sum_func() == Item_sum::COUNT_DISTINCT_FUNC)

{

if (!tree && table)

{

table->file->extra(HA_EXTRA_NO_CACHE);

table->file->ha_delete_all_rows();

table->file->extra(HA_EXTRA_WRITE_CACHE);

}

}

else

{

item_sum->null_value= 1;

}

}

/**

Process incoming row.

Add it to Unique/temp hash table if it's unique. Skip the row if

not unique.

Prepare Aggregator_distinct to process the incoming stream.

Create the temporary table and the Unique class if needed.

Called by Item_sum::aggregator_add().

To actually get the result value in item_sum's buffers

Aggregator_distinct::endup() must be called.

@return status

@retval FALSE success

@retval TRUE failure

*/