~drizzle-trunk/drizzle/development : revision 1899

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,

743

{

744

List<Item_field> indexed_fields;

745

List_iterator<Item_field> indexed_fields_it(indexed_fields);

746

order_st *cur_group;

746

Order *cur_group;

747

Item_field *cur_item;

748

key_map possible_keys(0);

749

1236

read_record.end_read_record();

1237

}

1238

1239

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

1239

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

1240

{

1241

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

1242

{

1265

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

1266

@endcode

1267

*/

1268

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

1268

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

1269

{

1270

if (tab->cached_eq_ref_table) // If cached

1271

return tab->eq_ref_table;

1284

{

1285

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

1286

{ // Not a const ref

1287

order_st *order;

1287

Order *order;

1288

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

1289

{

1290

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

4254

@retval

4255

-1 Reverse key can be used

4256

*/

4257

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

4257

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

4258

{

4259

KeyPartInfo *key_part= NULL;

4260

KeyPartInfo *key_part_end= NULL;

4360

- MAX_KEY If we can't use other key

4361

- the number of found key Otherwise

4362

*/

4363

static uint32_t test_if_subkey(order_st *order,

4363

static uint32_t test_if_subkey(Order *order,

4364

Table *table,

4365

uint32_t ref,

4366

uint32_t ref_key_parts,

4462

*/

4463

bool find_field_in_order_list (Field *field, void *data)

4464

{

4465

order_st *group= (order_st *) data;

4465

Order *group= (Order *) data;

4466

bool part_found= 0;

4467

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

4467

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

4468

{

4469

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

4470

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

4534

@retval

4535

1 We can use an index.

4536

*/

4537

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

4537

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

4538

{

4539

int32_t ref_key;

4540

uint32_t ref_key_parts;

4551

*/

4552

usable_keys= *map;

4553

4554

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

4554

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

4555

{

4556

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

4557

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

4977

-1 Some fatal error

4978

1 No records

4979

*/

4980

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

4980

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

4981

{

4982

uint32_t length= 0;

4983

ha_rows examined_rows;

5004

is_order_by ? &table->keys_in_use_for_order_by :

5005

&table->keys_in_use_for_group_by))

5006

return(0);

5007

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

5007

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

5008

length++;

5009

if (!(join->sortorder=

5010

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

5262

return(1);

5263

}

5264

5265

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

5265

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

5266

{

5267

uint32_t count;

5268

SortField *sort,*pos;

5269

5270

count=0;

5271

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

5271

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

5272

count++;

5273

if (!sortorder)

5274

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

5393

static bool find_order_in_list(Session *session,

5394

Item **ref_pointer_array,

5395

TableList *tables,

5396

order_st *order,

5396

Order *order,

5397

List<Item> &fields,

5398

List<Item> &all_fields,

5399

bool is_group_field)

5532

TableList *tables,

5533

List<Item> &fields,

5534

List<Item> &all_fields,

5535

order_st *order)

5535

Order *order)

5536

{

5537

session->where="order clause";

5538

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

5574

TableList *tables,

5575

List<Item> &fields,

5576

List<Item> &all_fields,

5577

order_st *order,

5577

Order *order,

5578

bool *hidden_group_fields)

5579

{

5580

*hidden_group_fields=0;

5581

order_st *ord;

5581

Order *ord;

5582

5583

if (!order)

5584

return 0; /* Everything is ok */

5668

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

5669

optimize away 'order by'.

5670

*/

5671

order_st *create_distinct_group(Session *session,

5671

Order *create_distinct_group(Session *session,

5672

Item **ref_pointer_array,

5673

order_st *order_list,

5673

Order *order_list,

5674

List<Item> &fields,

5675

List<Item> &,

5676

bool *all_order_by_fields_used)

5677

{

5678

List_iterator<Item> li(fields);

5679

Item *item;

5680

order_st *order,*group,**prev;

5680

Order *order,*group,**prev;

5681

5682

*all_order_by_fields_used= 1;

5683

while ((item=li++))

5688

{

5689

if (order->in_field_list)

5690

{

5691

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

5691

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

5692

if (!ord)

5693

return 0;

5694

*prev=ord;

5708

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

5709

GROUP BY list.

5710

*/

5711

order_st *ord_iter;

5711

Order *ord_iter;

5712

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

5713

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

5714

goto next_item;

5715

5716

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

5716

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

5717

if (!ord)

5718

return 0;

5719

6249

@retval

6250

1 on error

6251

*/

6252

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

6252

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

6253

{

6254

if (expr->arg_count)

6255

{

6263

Item *item= *arg;

6264

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

6265

{

6266

order_st *group_tmp;

6266

Order *group_tmp;

6267

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

6268

{

6269

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

6415

if (group_list.elements)

6416

{

6417

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

6418

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

6418

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

6419

switch (olap)

6420

{

6421

case CUBE_TYPE:

6446

if (order_list.elements)

6447

{

6448

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

6449

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

6449

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

6450

}

6451

6452

// limit