~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Committer: tdavies
Date: 2010-10-31 07:38:13 UTC
mto: (1897.2.4 merge)
mto: This revision was merged to the branch mainline in revision 1899.
Revision ID: tdavies@molly-20101031073813-mmu12nqc0bwezxny

struct order_st changed and renamed to c++ class named:Order

files modified:
drizzled/cursor.h

drizzled/item.cc

drizzled/item/subselect.cc

drizzled/item/sum.cc

drizzled/item/sum.h

drizzled/join.cc

drizzled/join.h

drizzled/optimizer/explain_plan.cc

drizzled/optimizer/range.cc

drizzled/optimizer/range.h

drizzled/order.h

drizzled/select_create.h

drizzled/sql_delete.cc

drizzled/sql_derived.cc

drizzled/sql_lex.cc

drizzled/sql_lex.h

drizzled/sql_select.cc

drizzled/sql_select.h

drizzled/sql_union.cc

drizzled/sql_update.cc

drizzled/statement/alter_table.cc

drizzled/statement/alter_table.h

drizzled/statement/create_index.cc

drizzled/statement/drop_index.cc

drizzled/statement/update.cc

drizzled/table.cc

drizzled/table.h

Show diffs side-by-side

added added

removed removed

drizzled/sql_select.cc

138

select_lex->where,

139

select_lex->order_list.elements +

140

select_lex->group_list.elements,

141

(order_st*) select_lex->order_list.first,

142

(order_st*) select_lex->group_list.first,

141

(Order*) select_lex->order_list.first,

142

(Order*) select_lex->group_list.first,

143

select_lex->having,

144

select_lex->options | session->options |

145

setup_tables_done_option,

352

List<Item> &fields,

353

COND *conds,

354

uint32_t og_num,

355

order_st *order,

356

order_st *group,

355

Order *order,

356

Order *group,

357

Item *having,

358

uint64_t select_options,

359

select_result *result,

756

{

757

List<Item_field> indexed_fields;

758

List_iterator<Item_field> indexed_fields_it(indexed_fields);

759

order_st *cur_group;

759

Order *cur_group;

760

Item_field *cur_item;

761

key_map possible_keys(0);

762

1482

read_record.end_read_record();

1483

}

1484

1485

bool only_eq_ref_tables(Join *join,order_st *order,table_map tables)

1485

bool only_eq_ref_tables(Join *join,Order *order,table_map tables)

1486

{

1487

for (JoinTable **tab=join->map2table ; tables ; tab++, tables>>=1)

1488

{

1511

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.b,t1.a

1512

@endcode

1513

1514

bool eq_ref_table(Join *join, order_st *start_order, JoinTable *tab)

1514

bool eq_ref_table(Join *join, Order *start_order, JoinTable *tab)

1515

{

1516

if (tab->cached_eq_ref_table) // If cached

1517

return tab->eq_ref_table;

1530

{

1531

if (! (*ref_item)->const_item())

1532

{ // Not a const ref

1533

order_st *order;

1533

Order *order;

1534

for (order=start_order ; order ; order=order->next)

1535

{

1536

if ((*ref_item)->eq(order->item[0],0))

4500

@retval

4501

-1 Reverse key can be used

4502

4503

static int test_if_order_by_key(order_st *order, Table *table, uint32_t idx, uint32_t *used_key_parts)

4503

static int test_if_order_by_key(Order *order, Table *table, uint32_t idx, uint32_t *used_key_parts)

4504

{

4505

KeyPartInfo *key_part= NULL;

4506

KeyPartInfo *key_part_end= NULL;

4606

- MAX_KEY If we can't use other key

4607

- the number of found key Otherwise

4608

4609

static uint32_t test_if_subkey(order_st *order,

4609

static uint32_t test_if_subkey(Order *order,

4610

Table *table,

4611

uint32_t ref,

4612

uint32_t ref_key_parts,

4708

4709

bool find_field_in_order_list (Field *field, void *data)

4710

{

4711

order_st *group= (order_st *) data;

4711

Order *group= (Order *) data;

4712

bool part_found= 0;

4713

for (order_st *tmp_group= group; tmp_group; tmp_group=tmp_group->next)

4713

for (Order *tmp_group= group; tmp_group; tmp_group=tmp_group->next)

4714

{

4715

Item *item= (*tmp_group->item)->real_item();

4716

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

4780

@retval

4781

1 We can use an index.

4782

4783

bool test_if_skip_sort_order(JoinTable *tab, order_st *order, ha_rows select_limit, bool no_changes, const key_map *map)

4783

bool test_if_skip_sort_order(JoinTable *tab, Order *order, ha_rows select_limit, bool no_changes, const key_map *map)

4784

{

4785

int32_t ref_key;

4786

uint32_t ref_key_parts;

4797

4798

usable_keys= *map;

4799

4800

for (order_st *tmp_order=order; tmp_order ; tmp_order=tmp_order->next)

4800

for (Order *tmp_order=order; tmp_order ; tmp_order=tmp_order->next)

4801

{

4802

Item *item= (*tmp_order->item)->real_item();

4803

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

5223

-1 Some fatal error

5224

1 No records

5225

5226

int create_sort_index(Session *session, Join *join, order_st *order, ha_rows filesort_limit, ha_rows select_limit, bool is_order_by)

5226

int create_sort_index(Session *session, Join *join, Order *order, ha_rows filesort_limit, ha_rows select_limit, bool is_order_by)

5227

{

5228

uint32_t length= 0;

5229

ha_rows examined_rows;

5250

is_order_by ? &table->keys_in_use_for_order_by :

5251

&table->keys_in_use_for_group_by))

5252

return(0);

5253

for (order_st *ord= join->order; ord; ord= ord->next)

5253

for (Order *ord= join->order; ord; ord= ord->next)

5254

length++;

5255

if (!(join->sortorder=

5256

make_unireg_sortorder(order, &length, join->sortorder)))

5508

return(1);

5509

}

5510

5511

SortField *make_unireg_sortorder(order_st *order, uint32_t *length, SortField *sortorder)

5511

SortField *make_unireg_sortorder(Order *order, uint32_t *length, SortField *sortorder)

5512

{

5513

uint32_t count;

5514

SortField *sort,*pos;

5515

5516

count=0;

5517

for (order_st *tmp = order; tmp; tmp=tmp->next)

5517

for (Order *tmp = order; tmp; tmp=tmp->next)

5518

count++;

5519

if (!sortorder)

5520

sortorder= (SortField*) memory::sql_alloc(sizeof(SortField) *

5639

static bool find_order_in_list(Session *session,

5640

Item **ref_pointer_array,

5641

TableList *tables,

5642

order_st *order,

5642

Order *order,

5643

List<Item> &fields,

5644

List<Item> &all_fields,

5645

bool is_group_field)

5778

TableList *tables,

5779

List<Item> &fields,

5780

List<Item> &all_fields,

5781

order_st *order)

5781

Order *order)

5782

{

5783

session->where="order clause";

5784

for (; order; order=order->next)

5820

TableList *tables,

5821

List<Item> &fields,

5822

List<Item> &all_fields,

5823

order_st *order,

5823

Order *order,

5824

bool *hidden_group_fields)

5825

{

5826

*hidden_group_fields=0;

5827

order_st *ord;

5827

Order *ord;

5828

5829

if (!order)

5830

return 0; /* Everything is ok */

5914

Try to use the fields in the order given by 'order' to allow one to

5915

optimize away 'order by'.

5916

5917

order_st *create_distinct_group(Session *session,

5917

Order *create_distinct_group(Session *session,

5918

Item **ref_pointer_array,

5919

order_st *order_list,

5919

Order *order_list,

5920

List<Item> &fields,

5921

List<Item> &,

5922

bool *all_order_by_fields_used)

5923

{

5924

List_iterator<Item> li(fields);

5925

Item *item;

5926

order_st *order,*group,**prev;

5926

Order *order,*group,**prev;

5927

5928

*all_order_by_fields_used= 1;

5929

while ((item=li++))

5934

{

5935

if (order->in_field_list)

5936

{

5937

order_st *ord=(order_st*) session->memdup((char*) order,sizeof(order_st));

5937

Order *ord=(Order*) session->memdup((char*) order,sizeof(Order));

5938

if (!ord)

5939

return 0;

5940

*prev=ord;

5954

Don't put duplicate columns from the SELECT list into the

5955

GROUP BY list.

5956

5957

order_st *ord_iter;

5957

Order *ord_iter;

5958

for (ord_iter= group; ord_iter; ord_iter= ord_iter->next)

5959

if ((*ord_iter->item)->eq(item, 1))

5960

goto next_item;

5961

5962

order_st *ord=(order_st*) session->calloc(sizeof(order_st));

5962

Order *ord=(Order*) session->calloc(sizeof(Order));

5963

if (!ord)

5964

return 0;

5965

6495

@retval

6496

1 on error

6497

6498

bool change_group_ref(Session *session, Item_func *expr, order_st *group_list, bool *changed)

6498

bool change_group_ref(Session *session, Item_func *expr, Order *group_list, bool *changed)

6499

{

6500

if (expr->arg_count)

6501

{

6509

Item *item= *arg;

6510

if (item->type() == Item::FIELD_ITEM || item->type() == Item::REF_ITEM)

6511

{

6512

order_st *group_tmp;

6512

Order *group_tmp;

6513

for (group_tmp= group_list; group_tmp; group_tmp= group_tmp->next)

6514

{

6515

if (item->eq(*group_tmp->item,0))

6661

if (group_list.elements)

6662

{

6663

str->append(STRING_WITH_LEN(" group by "));

6664

print_order(str, (order_st *) group_list.first, query_type);

6664

print_order(str, (Order *) group_list.first, query_type);

6665

switch (olap)

6666

{

6667

case CUBE_TYPE:

6692

if (order_list.elements)

6693

{

6694

str->append(STRING_WITH_LEN(" order by "));

6695

print_order(str, (order_st *) order_list.first, query_type);

6695

print_order(str, (Order *) order_list.first, query_type);

6696

}

6697

6698

// limit

Older »