~drizzle-trunk/drizzle/development

if ((curr_join->group_list && (!test_if_subpart(curr_join->group_list, curr_join->order) || curr_join->select_distinct)) || (curr_join->select_distinct && curr_join->tmp_table_param.using_indirect_summary_function))

2224

{ /* Must copy to another table */

2225

/* Free first data from old join */

2226

curr_join->join_free();

2227

if (make_simple_join(curr_join, curr_tmp_table))

2228

return;

2229

calc_group_buffer(curr_join, group_list);

2230

count_field_types(select_lex, &curr_join->tmp_table_param,

2231

curr_join->tmp_all_fields1,

2232

curr_join->select_distinct && !curr_join->group_list);

2233

curr_join->tmp_table_param.hidden_field_count=

2234

(curr_join->tmp_all_fields1.elements-

2235

curr_join->tmp_fields_list1.elements);

2236

2237

2238

if (exec_tmp_table2)

2239

curr_tmp_table= exec_tmp_table2;

2240

else

2241

{

2242

/* group data to new table */

2243

2244

2245

If the access method is loose index scan then all MIN/MAX

2246

functions are precomputed, and should be treated as regular

2247

functions. See extended comment in JOIN::exec.

2248

2249

if (curr_join->join_tab->is_using_loose_index_scan())

2250

curr_join->tmp_table_param.precomputed_group_by= true;

2251

2252

if (!(curr_tmp_table=

2253

exec_tmp_table2= create_tmp_table(thd,

2254

&curr_join->tmp_table_param,

2255

*curr_all_fields,

2256

(order_st*) 0,

2257

curr_join->select_distinct &&

2258

!curr_join->group_list,

2259

1, curr_join->select_options,

2260

HA_POS_ERROR,

2261

(char *) "")))

2262

return;

2263

curr_join->exec_tmp_table2= exec_tmp_table2;

2264

}

2265

if (curr_join->group_list)

2266

{

2267

thd_proc_info(thd, "Creating sort index");

2268

if (curr_join->join_tab == join_tab && save_join_tab())

2269

{

2270

return;

2271

}

2272

if (create_sort_index(thd, curr_join, curr_join->group_list,

2273

HA_POS_ERROR, HA_POS_ERROR, false) ||

2274

make_group_fields(this, curr_join))

2275

{

2276

return;

2277

}

2278

sortorder= curr_join->sortorder;

2279

}

2280

2281

thd_proc_info(thd, "Copying to group table");

2282

tmp_error= -1;

2283

if (curr_join != this)

2284

{

2285

if (sum_funcs2)

2286

{

2287

curr_join->sum_funcs= sum_funcs2;

2288

curr_join->sum_funcs_end= sum_funcs_end2;

2289

}

2290

else

2291

{

2292

curr_join->alloc_func_list();

2293

sum_funcs2= curr_join->sum_funcs;

2294

sum_funcs_end2= curr_join->sum_funcs_end;

2295

}

2296

}

2297

if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,

2298

1, true))

2299

return;

2300

curr_join->group_list= 0;

2301

if (!curr_join->sort_and_group &&

2302

curr_join->const_tables != curr_join->tables)

2303

curr_join->join_tab[curr_join->const_tables].sorted= 0;

2304

if (setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||

2305

(tmp_error= do_select(curr_join, (List<Item> *) 0, curr_tmp_table)))

2306

{

2307

error= tmp_error;

2308

return;

2309

}

2310

end_read_record(&curr_join->join_tab->read_record);

2311

curr_join->const_tables= curr_join->tables; // Mark free for cleanup()

2312

curr_join->join_tab[0].table= 0; // Table is freed

2313

2314

// No sum funcs anymore

2315

if (!items2)

2316

{

2317

items2= items1 + all_fields.elements;

2318

if (change_to_use_tmp_fields(thd, items2,

2319

tmp_fields_list2, tmp_all_fields2,

2320

fields_list.elements, tmp_all_fields1))

2321

return;

2322

curr_join->tmp_fields_list2= tmp_fields_list2;

2323

curr_join->tmp_all_fields2= tmp_all_fields2;

2324

}

2325

curr_fields_list= &curr_join->tmp_fields_list2;

2326

curr_all_fields= &curr_join->tmp_all_fields2;

2327

curr_join->set_items_ref_array(items2);

2328

curr_join->tmp_table_param.field_count+=

2329

curr_join->tmp_table_param.sum_func_count;

2330

curr_join->tmp_table_param.sum_func_count= 0;

2331

}

2332

if (curr_tmp_table->distinct)

2333

curr_join->select_distinct=0; /* Each row is unique */

2334

2335

curr_join->join_free(); /* Free quick selects */

2336

if (curr_join->select_distinct && ! curr_join->group_list)

2337

{

2338

thd_proc_info(thd, "Removing duplicates");

2339

if (curr_join->tmp_having)

2340

curr_join->tmp_having->update_used_tables();

2341

if (remove_duplicates(curr_join, curr_tmp_table,

2342

*curr_fields_list, curr_join->tmp_having))

2343

return;

2344

curr_join->tmp_having=0;

2345

curr_join->select_distinct=0;

2346

}

2347

curr_tmp_table->reginfo.lock_type= TL_UNLOCK;

2348

if (make_simple_join(curr_join, curr_tmp_table))

2349

return;

2350

calc_group_buffer(curr_join, curr_join->group_list);

2351

count_field_types(select_lex, &curr_join->tmp_table_param,

2352

*curr_all_fields, 0);

2353

2354

}

2355

2356

if (curr_join->group || curr_join->tmp_table_param.sum_func_count)

2357

{

2358

if (make_group_fields(this, curr_join))

2359

{

2360

return;

2361

}

2362

if (!items3)

2363

{

2364

if (!items0)

2365

init_items_ref_array();

2366

items3= ref_pointer_array + (all_fields.elements*4);

2367

setup_copy_fields(thd, &curr_join->tmp_table_param,

2368

items3, tmp_fields_list3, tmp_all_fields3,

2369

curr_fields_list->elements, *curr_all_fields);

2370

tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;

2371

tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;

2372

tmp_table_param.save_copy_field_end=

2373

curr_join->tmp_table_param.copy_field_end;

2374

curr_join->tmp_all_fields3= tmp_all_fields3;

2375

curr_join->tmp_fields_list3= tmp_fields_list3;

2376

}

2377

else

2378

{

2379

curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;

2380

curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;

2381

curr_join->tmp_table_param.copy_field_end=

2382

tmp_table_param.save_copy_field_end;

2383

}

2384

curr_fields_list= &tmp_fields_list3;

2385

curr_all_fields= &tmp_all_fields3;

2386

curr_join->set_items_ref_array(items3);

2387

2388

if (curr_join->make_sum_func_list(*curr_all_fields, *curr_fields_list,

2389

1, true) ||

2390

setup_sum_funcs(curr_join->thd, curr_join->sum_funcs) ||

2391

thd->is_fatal_error)

2392

return;

2393

}

2394

if (curr_join->group_list || curr_join->order)

2395

{

2396

thd_proc_info(thd, "Sorting result");

2397

/* If we have already done the group, add HAVING to sorted table */

2398

if (curr_join->tmp_having && ! curr_join->group_list &&

2399

! curr_join->sort_and_group)

2400

{

2401

// Some tables may have been const

2402

curr_join->tmp_having->update_used_tables();

2403

JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables];

2404

table_map used_tables= (curr_join->const_table_map |

2405

curr_table->table->map);

2406

2407

Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,

2408

used_tables,

2409

used_tables, 0);

2410

if (sort_table_cond)

2411

{

2412

if (!curr_table->select)

2413

if (!(curr_table->select= new SQL_SELECT))

2414

return;

2415

if (!curr_table->select->cond)

2416

curr_table->select->cond= sort_table_cond;

2417

else // This should never happen

2418

{

2419

if (!(curr_table->select->cond=

2420

new Item_cond_and(curr_table->select->cond,

2421

sort_table_cond)))

2422

return;

2423

2424

Item_cond_and do not need fix_fields for execution, its parameters

2425

are fixed or do not need fix_fields, too

2426

2427

curr_table->select->cond->quick_fix_field();

2428

}

2429

curr_table->select_cond= curr_table->select->cond;

2430

curr_table->select_cond->top_level_item();

2431

curr_join->tmp_having= make_cond_for_table(curr_join->tmp_having,

2432

~ (table_map) 0,

2433

~used_tables, 0);

2434

}

2435

}

2436

{

2437

if (group)

2438

curr_join->select_limit= HA_POS_ERROR;

2439

else

2440

{

2441

2442

We can abort sorting after thd->select_limit rows if we there is no

2443

WHERE clause for any tables after the sorted one.

2444

2445

JOIN_TAB *curr_table= &curr_join->join_tab[curr_join->const_tables+1];

2446

JOIN_TAB *end_table= &curr_join->join_tab[curr_join->tables];

2447

for (; curr_table < end_table ; curr_table++)

2448

{

2449

2450

table->keyuse is set in the case there was an original WHERE clause

2451

on the table that was optimized away.

2452

2453

if (curr_table->select_cond ||

2454

(curr_table->keyuse && !curr_table->first_inner))

2455

{

2456

/* We have to sort all rows */

2457

curr_join->select_limit= HA_POS_ERROR;

2458

break;

2459

}

2460

}

2461

}

2462

if (curr_join->join_tab == join_tab && save_join_tab())

2463

{

2464

return;

2465

}

2466

2467

Here we sort rows for order_st BY/GROUP BY clause, if the optimiser

2468

chose FILESORT to be faster than INDEX SCAN or there is no

2469

suitable index present.

2470

Note, that create_sort_index calls test_if_skip_sort_order and may

2471

finally replace sorting with index scan if there is a LIMIT clause in

2472

the query. XXX: it's never shown in EXPLAIN!

2473

OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.

2474

2475

if (create_sort_index(thd, curr_join,

2476

curr_join->group_list ?

2477

curr_join->group_list : curr_join->order,

2478

curr_join->select_limit,

2479

(select_options & OPTION_FOUND_ROWS ?

2480

HA_POS_ERROR : unit->select_limit_cnt),

2481

curr_join->group_list ? true : false))

2482

return;

2483

sortorder= curr_join->sortorder;

2484

if (curr_join->const_tables != curr_join->tables &&

2485

!curr_join->join_tab[curr_join->const_tables].table->sort.io_cache)

2486

{

2487

2488

If no IO cache exists for the first table then we are using an

2489

INDEX SCAN and no filesort. Thus we should not remove the sorted

2490

attribute on the INDEX SCAN.

2491

2492

skip_sort_order= 1;

2493

}

2494

}

2495

}

2496

/* XXX: When can we have here thd->is_error() not zero? */

2497

if (thd->is_error())

2498

{

2499

error= thd->is_error();

2500

return;

2501

}

2502

curr_join->having= curr_join->tmp_having;

2503

curr_join->fields= curr_fields_list;

2504

2505

{

2506

thd_proc_info(thd, "Sending data");

2507

result->send_fields(*curr_fields_list,

2508

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);

2509

error= do_select(curr_join, curr_fields_list, NULL);

2510

thd->limit_found_rows= curr_join->send_records;

2511

}

2512

2513

/* Accumulate the counts from all join iterations of all join parts. */

2514

thd->examined_row_count+= curr_join->examined_rows;

2515

2516

2517

With EXPLAIN EXTENDED we have to restore original ref_array

2518

for a derived table which is always materialized.

2519

Otherwise we would not be able to print the query correctly.

2520

2521

if (items0 &&

2522

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

2523

select_lex->linkage == DERIVED_TABLE_TYPE)

2524

set_items_ref_array(items0);

2525

2526

return;

2527

}

2528

2529

2530

/**

2531

Clean up join.

2532

2533

@return

2534

Return error that hold JOIN.

2535

2536

2537

int

2538

JOIN::destroy()

2539

{

2540

select_lex->join= 0;

2541

2542

if (tmp_join)

2543

{

2544

if (join_tab != tmp_join->join_tab)

2545

{

2546

JOIN_TAB *tab, *end;

2547

for (tab= join_tab, end= tab+tables ; tab != end ; tab++)

2548

tab->cleanup();

2549

}

2550

tmp_join->tmp_join= 0;

2551

tmp_table_param.copy_field=0;

2552

return(tmp_join->destroy());

2553

}

2554

cond_equal= 0;

2555

2556

cleanup(1);

2557

if (exec_tmp_table1)

2558

exec_tmp_table1->free_tmp_table(thd);

2559

if (exec_tmp_table2)

2560

exec_tmp_table2->free_tmp_table(thd);

2561

delete select;

2562

delete_dynamic(&keyuse);

2563

return(error);

2564

}

2565

2566

2567

312

2568

/**

313

2569

An entry point to single-unit select (a select without UNION).

314

2570

315

@param session thread Cursor

2571

@param thd thread handler

316

2572

@param rref_pointer_array a reference to ref_pointer_array of

317

2573

the top-level select_lex for this query

318

2574

@param tables list of all tables used in this query.

319

2575

The tables have been pre-opened.

320

@param wild_num number of wildcards used in the top level

2576

@param wild_num number of wildcards used in the top level

321

2577

select of this query.

322

2578

For example statement

323

2579

SELECT *, t1.*, catalog.t2.* FROM t0, t1, t2;

328

2584

for a, b and c in this list.

329

2585

@param conds top level item of an expression representing

330

2586

WHERE clause of the top level select

331

@param og_num total number of ORDER BY and GROUP BY clauses

2587

@param og_num total number of order_st BY and GROUP BY clauses

332

2588

arguments

333

@param order linked list of ORDER BY agruments

2589

@param order linked list of order_st BY agruments

334

2590

@param group linked list of GROUP BY arguments

335

2591

@param having top level item of HAVING expression

2592

@param proc_param list of PROCEDUREs

336

2593

@param select_options select options (BIG_RESULT, etc)

337

2594

@param result an instance of result set handling class.

338

2595

This object is responsible for send result

339

2596

set rows to the client or inserting them

340

2597

into a table.

341

@param select_lex the only Select_Lex of this query

2598

@param select_lex the only SELECT_LEX of this query

342

2599

@param unit top-level UNIT of this query

343

2600

UNIT is an artificial object created by the

344

2601

parser for every SELECT clause.

351

2608

@retval

352

2609

true an error

353

2610

354

bool select_query(Session *session,

355

Item ***rref_pointer_array,

356

TableList *tables,

357

uint32_t wild_num,

358

List<Item> &fields,

359

COND *conds,

360

uint32_t og_num,

361

Order *order,

362

Order *group,

363

Item *having,

364

uint64_t select_options,

365

select_result *result,

366

Select_Lex_Unit *unit,

367

Select_Lex *select_lex)

2611

2612

bool

2613

mysql_select(THD *thd, Item ***rref_pointer_array,

2614

TableList *tables, uint wild_num, List<Item> &fields,

2615

COND *conds, uint og_num, order_st *order, order_st *group,

2616

Item *having, order_st *proc_param, uint64_t select_options,

2617

select_result *result, SELECT_LEX_UNIT *unit,

2618

SELECT_LEX *select_lex)

368

2619

{

369

2620

bool err;

370

2621

bool free_join= 1;

371

2622

372

2623

select_lex->context.resolve_in_select_list= true;

373

Join *join;

2624

JOIN *join;

374

2625

if (select_lex->join != 0)

375

2626

{

376

2627

join= select_lex->join;

379

2630

creation

380

2631

381

2632

if (select_lex->linkage != DERIVED_TABLE_TYPE ||

382

(select_options & SELECT_DESCRIBE))

2633

(select_options & SELECT_DESCRIBE))

383

2634

{

384

2635

if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)

385

2636

{

386

//here is EXPLAIN of subselect or derived table

387

if (join->change_result(result))

388

{

389

return(true);

390

}

2637

//here is EXPLAIN of subselect or derived table

2638

if (join->change_result(result))

2639

{

2640

return(true);

2641

}

391

2642

}

392

2643

else

393

2644

{

394

2645

if ((err= join->prepare(rref_pointer_array, tables, wild_num,

395

conds, og_num, order, group, having, select_lex, unit)))

396

{

397

goto err;

398

}

2646

conds, og_num, order, group, having, proc_param,

2647

select_lex, unit)))

2648

{

2649

goto err;

2650

}

399

2651

}

400

2652

}

401

2653

free_join= 0;

403

2655

}

404

2656

else

405

2657

{

406

if (!(join= new Join(session, fields, select_options, result)))

407

return(true);

408

session->set_proc_info("init");

409

session->used_tables=0; // Updated by setup_fields

2658

if (!(join= new JOIN(thd, fields, select_options, result)))

2659

return(true);

2660

thd_proc_info(thd, "init");

2661

thd->used_tables=0; // Updated by setup_fields

410

2662

if ((err= join->prepare(rref_pointer_array, tables, wild_num,

411

conds, og_num, order, group, having,

2663

conds, og_num, order, group, having, proc_param,

412

2664

select_lex, unit)) == true)

413

2665

{

414

2666

goto err;

415

2667

}

416

2668

}

417

2669

418

err= join->optimize();

419

if (err)

420

{

421

goto err; // 1

422

}

423

424

if (session->lex->describe & DESCRIBE_EXTENDED)

2670

/* dump_TableList_graph(select_lex, select_lex->leaf_tables); */

2671

if (join->flatten_subqueries())

2672

{

2673

err= 1;

2674

goto err;

2675

}

2676

/* dump_TableList_struct(select_lex, select_lex->leaf_tables); */

2677

2678

if ((err= join->optimize()))

2679

{

2680

goto err; // 1

2681

}

2682

2683

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

425

2684

{

426

2685

join->conds_history= join->conds;

427

2686

join->having_history= (join->having?join->having:join->tmp_having);

428

2687

}

429

2688

430

if (session->is_error())

2689

if (thd->is_error())

431

2690

goto err;

432

2691

433

2692

join->exec();

434

2693

435

if (session->lex->describe & DESCRIBE_EXTENDED)

2694

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

436

2695

{

437

2696

select_lex->where= join->conds_history;

438

2697

select_lex->having= join->having_history;

441

2700

err:

442

2701

if (free_join)

443

2702

{

444

session->set_proc_info("end");

2703

thd_proc_info(thd, "end");

445

2704

err|= select_lex->cleanup();

446

return(err || session->is_error());

2705

return(err || thd->is_error());

447

2706

}

448

2707

return(join->error);

449

2708

}

450

2709

451

inline Item *and_items(Item* cond, Item *item)

2710

2711

int subq_sj_candidate_cmp(Item_in_subselect* const *el1,

2712

Item_in_subselect* const *el2)

2713

{

2714

return ((*el1)->sj_convert_priority < (*el2)->sj_convert_priority) ? 1 :

2715

( ((*el1)->sj_convert_priority == (*el2)->sj_convert_priority)? 0 : -1);

2716

}

2717

2718

2719

inline Item * and_items(Item* cond, Item *item)

452

2720

{

453

2721

return (cond? (new Item_cond_and(cond, item)) : item);

454

2722

}

455

2723

2724

2725

static TableList *alloc_join_nest(THD *thd)

2726

{

2727

TableList *tbl;

2728

if (!(tbl= (TableList*) thd->calloc(ALIGN_SIZE(sizeof(TableList))+

2729

sizeof(nested_join_st))))

2730

return NULL;

2731

tbl->nested_join= (nested_join_st*) ((uchar*)tbl +

2732

ALIGN_SIZE(sizeof(TableList)));

2733

return tbl;

2734

}

2735

2736

2737

void fix_list_after_tbl_changes(SELECT_LEX *new_parent, List<TableList> *tlist)

2738

{

2739

List_iterator<TableList> it(*tlist);

2740

TableList *table;

2741

while ((table= it++))

2742

{

2743

if (table->on_expr)

2744

table->on_expr->fix_after_pullout(new_parent, &table->on_expr);

2745

if (table->nested_join)

2746

fix_list_after_tbl_changes(new_parent, &table->nested_join->join_list);

2747

}

2748

}

2749

2750

2751

2752

Convert a subquery predicate into a TableList semi-join nest

2753

2754

SYNOPSIS

2755

convert_subq_to_sj()

2756

parent_join Parent join, the one that has subq_pred in its WHERE/ON

2757

clause

2758

subq_pred Subquery predicate to be converted

2759

2760

DESCRIPTION

2761

Convert a subquery predicate into a TableList semi-join nest. All the

2762

prerequisites are already checked, so the conversion is always successfull.

2763

2764

Prepared Statements: the transformation is permanent:

2765

- Changes in TableList structures are naturally permanent

2766

- Item tree changes are performed on statement MEM_ROOT:

2767

= we activate statement MEM_ROOT

2768

= this function is called before the first fix_prepare_information

2769

call.

2770

2771

This is intended because the criteria for subquery-to-sj conversion remain

2772

constant for the lifetime of the Prepared Statement.

2773

2774

RETURN

2775

false OK

2776

true Out of memory error

2777

2778

2779

bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)

2780

{

2781

SELECT_LEX *parent_lex= parent_join->select_lex;

2782

TableList *emb_tbl_nest= NULL;

2783

List<TableList> *emb_join_list= &parent_lex->top_join_list;

2784

THD *thd= parent_join->thd;

2785

2786

2787

1. Find out where to put the predicate into.

2788

Note: for "t1 LEFT JOIN t2" this will be t2, a leaf.

2789

2790

if ((void*)subq_pred->expr_join_nest != (void*)1)

2791

{

2792

if (subq_pred->expr_join_nest->nested_join)

2793

{

2794

2795

We're dealing with

2796

2797

... [LEFT] JOIN ( ... ) ON (subquery AND whatever) ...

2798

2799

The sj-nest will be inserted into the brackets nest.

2800

2801

emb_tbl_nest= subq_pred->expr_join_nest;

2802

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2803

}

2804

else if (!subq_pred->expr_join_nest->outer_join)

2805

{

2806

2807

We're dealing with

2808

2809

... INNER JOIN tblX ON (subquery AND whatever) ...

2810

2811

The sj-nest will be tblX's "sibling", i.e. another child of its

2812

parent. This is ok because tblX is joined as an inner join.

2813

2814

emb_tbl_nest= subq_pred->expr_join_nest->embedding;

2815

if (emb_tbl_nest)

2816

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2817

}

2818

else if (!subq_pred->expr_join_nest->nested_join)

2819

{

2820

TableList *outer_tbl= subq_pred->expr_join_nest;

2821

TableList *wrap_nest;

2822

2823

We're dealing with

2824

2825

... LEFT JOIN tbl ON (on_expr AND subq_pred) ...

2826

2827

we'll need to convert it into:

2828

2829

... LEFT JOIN ( tbl SJ (subq_tables) ) ON (on_expr AND subq_pred) ...

2830

| |

2831

|<----- wrap_nest ---->|

2832

2833

Q: other subqueries may be pointing to this element. What to do?

2834

A1: simple solution: copy *subq_pred->expr_join_nest= *parent_nest.

2835

But we'll need to fix other pointers.

2836

A2: Another way: have TableList::next_ptr so the following

2837

subqueries know the table has been nested.

2838

A3: changes in the TableList::outer_join will make everything work

2839

automatically.

2840

2841

if (!(wrap_nest= alloc_join_nest(parent_join->thd)))

2842

{

2843

return(true);

2844

}

2845

wrap_nest->embedding= outer_tbl->embedding;

2846

wrap_nest->join_list= outer_tbl->join_list;

2847

wrap_nest->alias= (char*) "(sj-wrap)";

2848

2849

wrap_nest->nested_join->join_list.empty();

2850

wrap_nest->nested_join->join_list.push_back(outer_tbl);

2851

2852

outer_tbl->embedding= wrap_nest;

2853

outer_tbl->join_list= &wrap_nest->nested_join->join_list;

2854

2855

2856

wrap_nest will take place of outer_tbl, so move the outer join flag

2857

and on_expr

2858

2859

wrap_nest->outer_join= outer_tbl->outer_join;

2860

outer_tbl->outer_join= 0;

2861

2862

wrap_nest->on_expr= outer_tbl->on_expr;

2863

outer_tbl->on_expr= NULL;

2864

2865

List_iterator<TableList> li(*wrap_nest->join_list);

2866

TableList *tbl;

2867

while ((tbl= li++))

2868

{

2869

if (tbl == outer_tbl)

2870

{

2871

li.replace(wrap_nest);

2872

break;

2873

}

2874

}

2875

2876

Ok now wrap_nest 'contains' outer_tbl and we're ready to add the

2877

semi-join nest into it

2878

2879

emb_join_list= &wrap_nest->nested_join->join_list;

2880

emb_tbl_nest= wrap_nest;

2881

}

2882

}

2883

2884

TableList *sj_nest;

2885

nested_join_st *nested_join;

2886

if (!(sj_nest= alloc_join_nest(parent_join->thd)))

2887

{

2888

return(true);

2889

}

2890

nested_join= sj_nest->nested_join;

2891

2892

sj_nest->join_list= emb_join_list;

2893

sj_nest->embedding= emb_tbl_nest;

2894

sj_nest->alias= (char*) "(sj-nest)";

2895

/* Nests do not participate in those 'chains', so: */

2896

/* sj_nest->next_leaf= sj_nest->next_local= sj_nest->next_global == NULL*/

2897

emb_join_list->push_back(sj_nest);

2898

2899

2900

nested_join->used_tables and nested_join->not_null_tables are

2901

initialized in simplify_joins().

2902

2903

2904

2905

2. Walk through subquery's top list and set 'embedding' to point to the

2906

sj-nest.

2907

2908

st_select_lex *subq_lex= subq_pred->unit->first_select();

2909

nested_join->join_list.empty();

2910

List_iterator_fast<TableList> li(subq_lex->top_join_list);

2911

TableList *tl, *last_leaf;

2912

while ((tl= li++))

2913

{

2914

tl->embedding= sj_nest;

2915

tl->join_list= &nested_join->join_list;

2916

nested_join->join_list.push_back(tl);

2917

}

2918

2919

2920

Reconnect the next_leaf chain.

2921

TODO: Do we have to put subquery's tables at the end of the chain?

2922

Inserting them at the beginning would be a bit faster.

2923

NOTE: We actually insert them at the front! That's because the order is

2924

reversed in this list.

2925

2926

for (tl= parent_lex->leaf_tables; tl->next_leaf; tl= tl->next_leaf) {};

2927

tl->next_leaf= subq_lex->leaf_tables;

2928

last_leaf= tl;

2929

2930

2931

Same as above for next_local chain

2932

(a theory: a next_local chain always starts with ::leaf_tables

2933

because view's tables are inserted after the view)

2934

2935

for (tl= parent_lex->leaf_tables; tl->next_local; tl= tl->next_local) {};

2936

tl->next_local= subq_lex->leaf_tables;

2937

2938

/* A theory: no need to re-connect the next_global chain */

2939

2940

/* 3. Remove the original subquery predicate from the WHERE/ON */

2941

2942

// The subqueries were replaced for Item_int(1) earlier

2943

subq_pred->exec_method= Item_in_subselect::SEMI_JOIN; // for subsequent executions

2944

/*TODO: also reset the 'with_subselect' there. */

2945

2946

/* n. Adjust the parent_join->tables counter */

2947

uint table_no= parent_join->tables;

2948

/* n. Walk through child's tables and adjust table->map */

2949

for (tl= subq_lex->leaf_tables; tl; tl= tl->next_leaf, table_no++)

2950

{

2951

tl->table->tablenr= table_no;

2952

tl->table->map= ((table_map)1) << table_no;

2953

SELECT_LEX *old_sl= tl->select_lex;

2954

tl->select_lex= parent_join->select_lex;

2955

for(TableList *emb= tl->embedding; emb && emb->select_lex == old_sl; emb= emb->embedding)

2956

emb->select_lex= parent_join->select_lex;

2957

}

2958

parent_join->tables += subq_lex->join->tables;

2959

2960

2961

Put the subquery's WHERE into semi-join's sj_on_expr

2962

Add the subquery-induced equalities too.

2963

2964

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

2965

thd->lex->current_select=subq_lex;

2966

if (!subq_pred->left_expr->fixed &&

2967

subq_pred->left_expr->fix_fields(thd, &subq_pred->left_expr))

2968

return(true);

2969

thd->lex->current_select=save_lex;

2970

2971

sj_nest->nested_join->sj_corr_tables= subq_pred->used_tables();

2972

sj_nest->nested_join->sj_depends_on= subq_pred->used_tables() |

2973

subq_pred->left_expr->used_tables();

2974

sj_nest->sj_on_expr= subq_lex->where;

2975

2976

2977

Create the IN-equalities and inject them into semi-join's ON expression.

2978

Additionally, for InsideOut strategy

2979

- Record the number of IN-equalities.

2980

- Create list of pointers to (oe1, ..., ieN). We'll need the list to

2981

see which of the expressions are bound and which are not (for those

2982

we'll produce a distinct stream of (ie_i1,...ie_ik).

2983

2984

(TODO: can we just create a list of pointers and hope the expressions

2985

will not substitute themselves on fix_fields()? or we need to wrap

2986

them into Item_direct_view_refs and store pointers to those. The

2987

pointers to Item_direct_view_refs are guaranteed to be stable as

2988

Item_direct_view_refs doesn't substitute itself with anything in

2989

Item_direct_view_ref::fix_fields.

2990

2991

sj_nest->sj_in_exprs= subq_pred->left_expr->cols();

2992

sj_nest->nested_join->sj_outer_expr_list.empty();

2993

2994

if (subq_pred->left_expr->cols() == 1)

2995

{

2996

nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr);

2997

2998

Item *item_eq= new Item_func_eq(subq_pred->left_expr,

2999

subq_lex->ref_pointer_array[0]);

3000

item_eq->name= (char*)subq_sj_cond_name;

3001

sj_nest->sj_on_expr= and_items(sj_nest->sj_on_expr, item_eq);

3002

}

3003

else

3004

{

3005

for (uint i= 0; i < subq_pred->left_expr->cols(); i++)

3006

{

3007

nested_join->sj_outer_expr_list.push_back(subq_pred->left_expr->

3008

element_index(i));

3009

Item *item_eq=

3010

new Item_func_eq(subq_pred->left_expr->element_index(i),

3011

subq_lex->ref_pointer_array[i]);

3012

item_eq->name= (char*)subq_sj_cond_name + (i % 64);

3013

sj_nest->sj_on_expr= and_items(sj_nest->sj_on_expr, item_eq);

3014

}

3015

}

3016

/* Fix the created equality and AND */

3017

sj_nest->sj_on_expr->fix_fields(parent_join->thd, &sj_nest->sj_on_expr);

3018

3019

3020

Walk through sj nest's WHERE and ON expressions and call

3021

item->fix_table_changes() for all items.

3022

3023

sj_nest->sj_on_expr->fix_after_pullout(parent_lex, &sj_nest->sj_on_expr);

3024

fix_list_after_tbl_changes(parent_lex, &sj_nest->nested_join->join_list);

3025

3026

3027

/* Unlink the child select_lex so it doesn't show up in EXPLAIN: */

3028

subq_lex->master_unit()->exclude_level();

3029

3030

/* Inject sj_on_expr into the parent's WHERE or ON */

3031

if (emb_tbl_nest)

3032

{

3033

emb_tbl_nest->on_expr= and_items(emb_tbl_nest->on_expr,

3034

sj_nest->sj_on_expr);

3035

emb_tbl_nest->on_expr->fix_fields(parent_join->thd, &emb_tbl_nest->on_expr);

3036

}

3037

else

3038

{

3039

/* Inject into the WHERE */

3040

parent_join->conds= and_items(parent_join->conds, sj_nest->sj_on_expr);

3041

parent_join->conds->fix_fields(parent_join->thd, &parent_join->conds);

3042

parent_join->select_lex->where= parent_join->conds;

3043

}

3044

3045

return(false);

3046

}

3047

3048

3049

3050

Convert candidate subquery predicates to semi-joins

3051

3052

SYNOPSIS

3053

JOIN::flatten_subqueries()

3054

3055

DESCRIPTION

3056

Convert candidate subquery predicates to semi-joins.

3057

3058

RETURN

3059

false OK

3060

true Error

3061

3062

3063

bool JOIN::flatten_subqueries()

3064

{

3065

Item_in_subselect **in_subq;

3066

Item_in_subselect **in_subq_end;

3067

3068

if (sj_subselects.elements() == 0)

3069

return(false);

3070

3071

/* 1. Fix children subqueries */

3072

for (in_subq= sj_subselects.front(), in_subq_end= sj_subselects.back();

3073

in_subq != in_subq_end; in_subq++)

3074

{

3075

JOIN *child_join= (*in_subq)->unit->first_select()->join;

3076

child_join->outer_tables = child_join->tables;

3077

if (child_join->flatten_subqueries())

3078

return(true);

3079

(*in_subq)->sj_convert_priority=

3080

(*in_subq)->is_correlated * MAX_TABLES + child_join->outer_tables;

3081

}

3082

3083

//dump_TableList_struct(select_lex, select_lex->leaf_tables);

3084

3085

2. Pick which subqueries to convert:

3086

sort the subquery array

3087

- prefer correlated subqueries over uncorrelated;

3088

- prefer subqueries that have greater number of outer tables;

3089

3090

sj_subselects.sort(subq_sj_candidate_cmp);

3091

// #tables-in-parent-query + #tables-in-subquery < MAX_TABLES

3092

/* Replace all subqueries to be flattened with Item_int(1) */

3093

for (in_subq= sj_subselects.front();

3094

in_subq != in_subq_end &&

3095

tables + ((*in_subq)->sj_convert_priority % MAX_TABLES) < MAX_TABLES;

3096

in_subq++)

3097

{

3098

if (replace_where_subcondition(this, *in_subq, new Item_int(1), false))

3099

return(true);

3100

}

3101

3102

for (in_subq= sj_subselects.front();

3103

in_subq != in_subq_end &&

3104

tables + ((*in_subq)->sj_convert_priority % MAX_TABLES) < MAX_TABLES;

3105

in_subq++)

3106

{

3107

if (convert_subq_to_sj(this, *in_subq))

3108

return(true);

3109

}

3110

3111

/* 3. Finalize those we didn't convert */

3112

for (; in_subq!= in_subq_end; in_subq++)

3113

{

3114

JOIN *child_join= (*in_subq)->unit->first_select()->join;

3115

Item_subselect::trans_res res;

3116

(*in_subq)->changed= 0;

3117

(*in_subq)->fixed= 0;

3118

res= (*in_subq)->select_transformer(child_join);

3119

if (res == Item_subselect::RES_ERROR)

3120

return(true);

3121

3122

(*in_subq)->changed= 1;

3123

(*in_subq)->fixed= 1;

3124

3125

Item *substitute= (*in_subq)->substitution;

3126

bool do_fix_fields= !(*in_subq)->substitution->fixed;

3127

if (replace_where_subcondition(this, *in_subq, substitute, do_fix_fields))

3128

return(true);

3129

3130

//if ((*in_subq)->fix_fields(thd, (*in_subq)->ref_ptr))

3131

// return(true);

3132

}

3133

sj_subselects.clear();

3134

return(false);

3135

}

3136

3137

3138

/**

3139

Setup for execution all subqueries of a query, for which the optimizer

3140

chose hash semi-join.

3141

3142

@details Iterate over all subqueries of the query, and if they are under an

3143

IN predicate, and the optimizer chose to compute it via hash semi-join:

3144

- try to initialize all data structures needed for the materialized execution

3145

of the IN predicate,

3146

- if this fails, then perform the IN=>EXISTS transformation which was

3147

previously blocked during JOIN::prepare.

3148

3149

This method is part of the "code generation" query processing phase.

3150

3151

This phase must be called after substitute_for_best_equal_field() because

3152

that function may replace items with other items from a multiple equality,

3153

and we need to reference the correct items in the index access method of the

3154

IN predicate.

3155

3156

@return Operation status

3157

@retval false success.

3158

@retval true error occurred.

3159

3160

3161

bool JOIN::setup_subquery_materialization()

3162

{

3163

for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit(); un;

3164

un= un->next_unit())

3165

{

3166

for (SELECT_LEX *sl= un->first_select(); sl; sl= sl->next_select())

3167

{

3168

Item_subselect *subquery_predicate= sl->master_unit()->item;

3169

if (subquery_predicate &&

3170

subquery_predicate->substype() == Item_subselect::IN_SUBS)

3171

{

3172

Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;

3173

if (in_subs->exec_method == Item_in_subselect::MATERIALIZATION &&

3174

in_subs->setup_engine())

3175

return true;

3176

}

3177

}

3178

}

3179

return false;

3180

}

3181

3182

3183

3184

Check if table's KEYUSE elements have an eq_ref(outer_tables) candidate

3185

3186

SYNOPSIS

3187

find_eq_ref_candidate()

3188

table Table to be checked

3189

sj_inner_tables Bitmap of inner tables. eq_ref(inner_table) doesn't

3190

count.

3191

3192

DESCRIPTION

3193

Check if table's KEYUSE elements have an eq_ref(outer_tables) candidate

3194

3195

TODO

3196

Check again if it is feasible to factor common parts with constant table

3197

3198

3199

RETURN

3200

true - There exists an eq_ref(outer-tables) candidate

3201

false - Otherwise

3202

3203

3204

bool find_eq_ref_candidate(Table *table, table_map sj_inner_tables)

3205

{

3206

KEYUSE *keyuse= table->reginfo.join_tab->keyuse;

3207

uint key;

3208

3209

if (keyuse)

3210

{

3211

while (1) /* For each key */

3212

{

3213

key= keyuse->key;

3214

KEY *keyinfo= table->key_info + key;

3215

key_part_map bound_parts= 0;

3216

if ((keyinfo->flags & HA_NOSAME) == HA_NOSAME)

3217

{

3218

do /* For all equalities on all key parts */

3219

{

3220

/* Check if this is "t.keypart = expr(outer_tables) */

3221

if (!(keyuse->used_tables & sj_inner_tables) &&

3222

!(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))

3223

{

3224

bound_parts |= 1 << keyuse->keypart;

3225

}

3226

keyuse++;

3227

} while (keyuse->key == key && keyuse->table == table);

3228

3229

if (bound_parts == PREV_BITS(uint, keyinfo->key_parts))

3230

return true;

3231

if (keyuse->table != table)

3232

return false;

3233

}

3234

else

3235

{

3236

3237

{

3238

keyuse++;

3239

if (keyuse->table != table)

3240

return false;

3241

}

3242

while (keyuse->key == key);

3243

}

3244

}

3245

}

3246

return false;

3247

}

3248

3249

3250

3251

Pull tables out of semi-join nests, if possible

3252

3253

SYNOPSIS

3254

pull_out_semijoin_tables()

3255

join The join where to do the semi-join flattening

3256

3257

DESCRIPTION

3258

Try to pull tables out of semi-join nests.

3259

3260

PRECONDITIONS

3261

When this function is called, the join may have several semi-join nests

3262

(possibly within different semi-join nests), but it is guaranteed that

3263

one semi-join nest does not contain another.

3264

3265

ACTION

3266

A table can be pulled out of the semi-join nest if

3267

- It is a constant table

3268

- It is accessed

3269

3270

POSTCONDITIONS

3271

* Pulled out tables have JOIN_TAB::emb_sj_nest == NULL (like the outer

3272

tables)

3273

* Tables that were not pulled out have JOIN_TAB::emb_sj_nest.

3274

* Semi-join nests TableList::sj_inner_tables

3275

3276

This operation is (and should be) performed at each PS execution since

3277

tables may become/cease to be constant across PS reexecutions.

3278

3279

RETURN

3280

0 - OK

3281

1 - Out of memory error

3282

3283

3284

int pull_out_semijoin_tables(JOIN *join)

3285

{

3286

TableList *sj_nest;

3287

List_iterator<TableList> sj_list_it(join->select_lex->sj_nests);

3288

3289

/* Try pulling out of the each of the semi-joins */

3290

while ((sj_nest= sj_list_it++))

3291

{

3292

/* Action #1: Mark the constant tables to be pulled out */

3293

table_map pulled_tables= 0;

3294

3295

List_iterator<TableList> child_li(sj_nest->nested_join->join_list);

3296

TableList *tbl;

3297

while ((tbl= child_li++))

3298

{

3299

if (tbl->table)

3300

{

3301

tbl->table->reginfo.join_tab->emb_sj_nest= sj_nest;

3302

if (tbl->table->map & join->const_table_map)

3303

{

3304

pulled_tables |= tbl->table->map;

3305

}

3306

}

3307

}

3308

3309

3310

Action #2: Find which tables we can pull out based on

3311

update_ref_and_keys() data. Note that pulling one table out can allow

3312

us to pull out some other tables too.

3313

3314

bool pulled_a_table;

3315

3316

{

3317

pulled_a_table= false;

3318

child_li.rewind();

3319

while ((tbl= child_li++))

3320

{

3321

if (tbl->table && !(pulled_tables & tbl->table->map))

3322

{

3323

if (find_eq_ref_candidate(tbl->table,

3324

sj_nest->nested_join->used_tables &

3325

~pulled_tables))

3326

{

3327

pulled_a_table= true;

3328

pulled_tables |= tbl->table->map;

3329

}

3330

}

3331

}

3332

} while (pulled_a_table);

3333

3334

child_li.rewind();

3335

if ((sj_nest)->nested_join->used_tables == pulled_tables)

3336

{

3337

(sj_nest)->sj_inner_tables= 0;

3338

while ((tbl= child_li++))

3339

{

3340

if (tbl->table)

3341

tbl->table->reginfo.join_tab->emb_sj_nest= NULL;

3342

}

3343

}

3344

else

3345

{

3346

/* Record the bitmap of inner tables, mark the inner tables */

3347

table_map inner_tables=(sj_nest)->nested_join->used_tables &

3348

~pulled_tables;

3349

(sj_nest)->sj_inner_tables= inner_tables;

3350

while ((tbl= child_li++))

3351

{

3352

if (tbl->table)

3353

{

3354

if (inner_tables & tbl->table->map)

3355

tbl->table->reginfo.join_tab->emb_sj_nest= (sj_nest);

3356

else

3357

tbl->table->reginfo.join_tab->emb_sj_nest= NULL;

3358

}

3359

}

3360

}

3361

}

3362

return(0);

3363

}

3364

456

3365

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

457

Create JoinTableS, make a guess about the table types,

3366

Create JOIN_TABS, make a guess about the table types,

458

3367

Approximate how many records will be used in each table

459

3368

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

460

ha_rows get_quick_record_count(Session *session, optimizer::SqlSelect *select, Table *table, const key_map *keys,ha_rows limit)

3369

3370

3371

static ha_rows get_quick_record_count(THD *thd, SQL_SELECT *select,

3372

Table *table,

3373

const key_map *keys,ha_rows limit)

461

3374

{

462

3375

int error;

463

if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))

3376

if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))

464

3377

return(0); // Fatal error flag is set

465

3378

if (select)

466

3379

{

467

3380

select->head=table;

468

3381

table->reginfo.impossible_range=0;

469

if ((error= select->test_quick_select(session, *(key_map *)keys,(table_map) 0,

3382

if ((error= select->test_quick_select(thd, *(key_map *)keys,(table_map) 0,

470

3383

limit, 0, false)) == 1)

471

3384

return(select->quick->records);

472

3385

if (error == -1)

478

3391

return(HA_POS_ERROR); /* This shouldn't happend */

479

3392

}

480

3393

3394

3395

This structure is used to collect info on potentially sargable

3396

predicates in order to check whether they become sargable after

3397

reading const tables.

3398

We form a bitmap of indexes that can be used for sargable predicates.

3399

Only such indexes are involved in range analysis.

3400

3401

typedef struct st_sargable_param

3402

{

3403

Field *field; /* field against which to check sargability */

3404

Item **arg_value; /* values of potential keys for lookups */

3405

uint num_values; /* number of values in the above array */

3406

} SARGABLE_PARAM;

3407

3408

/**

3409

Calculate the best possible join and initialize the join structure.

3410

3411

@retval

3412

0 ok

3413

@retval

3414

1 Fatal error

3415

3416

3417

static bool

3418

make_join_statistics(JOIN *join, TableList *tables, COND *conds,

3419

DYNAMIC_ARRAY *keyuse_array)

3420

{

3421

int error;

3422

Table *table;

3423

uint i,table_count,const_count,key;

3424

table_map found_const_table_map, all_table_map, found_ref, refs;

3425

key_map const_ref, eq_part;

3426

Table **table_vector;

3427

JOIN_TAB *stat,*stat_end,*s,**stat_ref;

3428

KEYUSE *keyuse,*start_keyuse;

3429

table_map outer_join=0;

3430

SARGABLE_PARAM *sargables= 0;

3431

JOIN_TAB *stat_vector[MAX_TABLES+1];

3432

3433

table_count=join->tables;

3434

stat=(JOIN_TAB*) join->thd->calloc(sizeof(JOIN_TAB)*table_count);

3435

stat_ref=(JOIN_TAB**) join->thd->alloc(sizeof(JOIN_TAB*)*MAX_TABLES);

3436

table_vector=(Table**) join->thd->alloc(sizeof(Table*)*(table_count*2));

3437

if (!stat || !stat_ref || !table_vector)

3438

return(1); // Eom /* purecov: inspected */

3439

3440

join->best_ref=stat_vector;

3441

3442

stat_end=stat+table_count;

3443

found_const_table_map= all_table_map=0;

3444

const_count=0;

3445

3446

for (s= stat, i= 0;

3447

tables;

3448

s++, tables= tables->next_leaf, i++)

3449

{

3450

TableList *embedding= tables->embedding;

3451

stat_vector[i]=s;

3452

s->keys.init();

3453

s->const_keys.init();

3454

s->checked_keys.init();

3455

s->needed_reg.init();

3456

table_vector[i]=s->table=table=tables->table;

3457

table->pos_in_table_list= tables;

3458

error= table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);

3459

if(error)

3460

{

3461

table->file->print_error(error, MYF(0));

3462

return(1);

3463

}

3464

table->quick_keys.clear_all();

3465

table->reginfo.join_tab=s;

3466

table->reginfo.not_exists_optimize=0;

3467

memset(table->const_key_parts, 0,

3468

sizeof(key_part_map)*table->s->keys);

3469

all_table_map|= table->map;

3470

s->join=join;

3471

s->info=0; // For describe

3472

3473

s->dependent= tables->dep_tables;

3474

s->key_dependent= 0;

3475

if (tables->schema_table)

3476

table->file->stats.records= 2;

3477

table->quick_condition_rows= table->file->stats.records;

3478

3479

s->on_expr_ref= &tables->on_expr;

3480

if (*s->on_expr_ref)

3481

{

3482

/* s is the only inner table of an outer join */

3483

if (!table->file->stats.records && !embedding)

3484

{ // Empty table

3485

s->dependent= 0; // Ignore LEFT JOIN depend.

3486

set_position(join,const_count++,s,(KEYUSE*) 0);

3487

continue;

3488

}

3489

outer_join|= table->map;

3490

s->embedding_map= 0;

3491

for (;embedding; embedding= embedding->embedding)

3492

s->embedding_map|= embedding->nested_join->nj_map;

3493

continue;

3494

}

3495

if (embedding && !(embedding->sj_on_expr && ! embedding->embedding))

3496

{

3497

/* s belongs to a nested join, maybe to several embedded joins */

3498

s->embedding_map= 0;

3499

3500

{

3501

nested_join_st *nested_join= embedding->nested_join;

3502

s->embedding_map|=nested_join->nj_map;

3503

s->dependent|= embedding->dep_tables;

3504

embedding= embedding->embedding;

3505

outer_join|= nested_join->used_tables;

3506

}

3507

while (embedding);

3508

continue;

3509

}

3510

if ((table->file->stats.records <= 1) &&

3511

!s->dependent &&

3512

(table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) && !join->no_const_tables)

3513

{

3514

set_position(join,const_count++,s,(KEYUSE*) 0);

3515

}

3516

}

3517

stat_vector[i]=0;

3518

join->outer_join=outer_join;

3519

3520

if (join->outer_join)

3521

{

3522

3523

Build transitive closure for relation 'to be dependent on'.

3524

This will speed up the plan search for many cases with outer joins,

3525

as well as allow us to catch illegal cross references/

3526

Warshall's algorithm is used to build the transitive closure.

3527

As we use bitmaps to represent the relation the complexity

3528

of the algorithm is O((number of tables)^2).

3529

3530

for (i= 0, s= stat ; i < table_count ; i++, s++)

3531

{

3532

for (uint j= 0 ; j < table_count ; j++)

3533

{

3534

table= stat[j].table;

3535

if (s->dependent & table->map)

3536

s->dependent |= table->reginfo.join_tab->dependent;

3537

}

3538

if (s->dependent)

3539

s->table->maybe_null= 1;

3540

}

3541

/* Catch illegal cross references for outer joins */

3542

for (i= 0, s= stat ; i < table_count ; i++, s++)

3543

{

3544

if (s->dependent & s->table->map)

3545

{

3546

join->tables=0; // Don't use join->table

3547

my_message(ER_WRONG_OUTER_JOIN, ER(ER_WRONG_OUTER_JOIN), MYF(0));

3548

return(1);

3549

}

3550

s->key_dependent= s->dependent;

3551

}

3552

}

3553

3554

if (conds || outer_join)

3555

if (update_ref_and_keys(join->thd, keyuse_array, stat, join->tables,

3556

conds, join->cond_equal,

3557

~outer_join, join->select_lex, &sargables))

3558

return(1);

3559

3560

/* Read tables with 0 or 1 rows (system tables) */

3561

join->const_table_map= 0;

3562

3563

for (POSITION *p_pos=join->positions, *p_end=p_pos+const_count;

3564

p_pos < p_end ;

3565

p_pos++)

3566

{

3567

int tmp;

3568

s= p_pos->table;

3569

s->type=JT_SYSTEM;

3570

join->const_table_map|=s->table->map;

3571

if ((tmp=join_read_const_table(s, p_pos)))

3572

{

3573

if (tmp > 0)

3574

return(1); // Fatal error

3575

}

3576

else

3577

found_const_table_map|= s->table->map;

3578

}

3579

3580

/* loop until no more const tables are found */

3581

int ref_changed;

3582

3583

{

3584

more_const_tables_found:

3585

ref_changed = 0;

3586

found_ref=0;

3587

3588

3589

We only have to loop from stat_vector + const_count as

3590

set_position() will move all const_tables first in stat_vector

3591

3592

3593

for (JOIN_TAB **pos=stat_vector+const_count ; (s= *pos) ; pos++)

3594

{

3595

table=s->table;

3596

3597

3598

If equi-join condition by a key is null rejecting and after a

3599

substitution of a const table the key value happens to be null

3600

then we can state that there are no matches for this equi-join.

3601

3602

if ((keyuse= s->keyuse) && *s->on_expr_ref && !s->embedding_map)

3603

{

3604

3605

When performing an outer join operation if there are no matching rows

3606

for the single row of the outer table all the inner tables are to be

3607

null complemented and thus considered as constant tables.

3608

Here we apply this consideration to the case of outer join operations

3609

with a single inner table only because the case with nested tables

3610

would require a more thorough analysis.

3611

TODO. Apply single row substitution to null complemented inner tables

3612

for nested outer join operations.

3613

3614

while (keyuse->table == table)

3615

{

3616

if (!(keyuse->val->used_tables() & ~join->const_table_map) &&

3617

keyuse->val->is_null() && keyuse->null_rejecting)

3618

{

3619

s->type= JT_CONST;

3620

mark_as_null_row(table);

3621

found_const_table_map|= table->map;

3622

join->const_table_map|= table->map;

3623

set_position(join,const_count++,s,(KEYUSE*) 0);

3624

goto more_const_tables_found;

3625

}

3626

keyuse++;

3627

}

3628

}

3629

3630

if (s->dependent) // If dependent on some table

3631

{

3632

// All dep. must be constants

3633

if (s->dependent & ~(found_const_table_map))

3634

continue;

3635

if (table->file->stats.records <= 1L &&

3636

(table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&

3637

!table->pos_in_table_list->embedding)

3638

{ // system table

3639

int tmp= 0;

3640

s->type=JT_SYSTEM;

3641

join->const_table_map|=table->map;

3642

set_position(join,const_count++,s,(KEYUSE*) 0);

3643

if ((tmp= join_read_const_table(s, join->positions+const_count-1)))

3644

{

3645

if (tmp > 0)

3646

return(1); // Fatal error

3647

}

3648

else

3649

found_const_table_map|= table->map;

3650

continue;

3651

}

3652

}

3653

/* check if table can be read by key or table only uses const refs */

3654

if ((keyuse=s->keyuse))

3655

{

3656

s->type= JT_REF;

3657

while (keyuse->table == table)

3658

{

3659

start_keyuse=keyuse;

3660

key=keyuse->key;

3661

s->keys.set_bit(key); // QQ: remove this ?

3662

3663

refs=0;

3664

const_ref.clear_all();

3665

eq_part.clear_all();

3666

3667

{

3668

if (keyuse->val->type() != Item::NULL_ITEM && !keyuse->optimize)

3669

{

3670

if (!((~found_const_table_map) & keyuse->used_tables))

3671

const_ref.set_bit(keyuse->keypart);

3672

else

3673

refs|=keyuse->used_tables;

3674

eq_part.set_bit(keyuse->keypart);

3675

}

3676

keyuse++;

3677

} while (keyuse->table == table && keyuse->key == key);

3678

3679

if (eq_part.is_prefix(table->key_info[key].key_parts) &&

3680

!table->pos_in_table_list->embedding)

3681

{

3682

if ((table->key_info[key].flags & (HA_NOSAME))

3683

== HA_NOSAME)

3684

{

3685

if (const_ref == eq_part)

3686

{ // Found everything for ref.

3687

int tmp;

3688

ref_changed = 1;

3689

s->type= JT_CONST;

3690

join->const_table_map|=table->map;

3691

set_position(join,const_count++,s,start_keyuse);

3692

if (create_ref_for_key(join, s, start_keyuse,

3693

found_const_table_map))

3694

return(1);

3695

if ((tmp=join_read_const_table(s,

3696

join->positions+const_count-1)))

3697

{

3698

if (tmp > 0)

3699

return(1); // Fatal error

3700

}

3701

else

3702

found_const_table_map|= table->map;

3703

break;

3704

}

3705

else

3706

found_ref|= refs; // Table is const if all refs are const

3707

}

3708

else if (const_ref == eq_part)

3709

s->const_keys.set_bit(key);

3710

}

3711

}

3712

}

3713

}

3714

} while (join->const_table_map & found_ref && ref_changed);

3715

3716

3717

Update info on indexes that can be used for search lookups as

3718

reading const tables may has added new sargable predicates.

3719

3720

if (const_count && sargables)

3721

{

3722

for( ; sargables->field ; sargables++)

3723

{

3724

Field *field= sargables->field;

3725

JOIN_TAB *join_tab= field->table->reginfo.join_tab;

3726

key_map possible_keys= field->key_start;

3727

possible_keys.intersect(field->table->keys_in_use_for_query);

3728

bool is_const= 1;

3729

for (uint j=0; j < sargables->num_values; j++)

3730

is_const&= sargables->arg_value[j]->const_item();

3731

if (is_const)

3732

join_tab[0].const_keys.merge(possible_keys);

3733

}

3734

}

3735

3736

if (pull_out_semijoin_tables(join))

3737

return(true);

3738

3739

/* Calc how many (possible) matched records in each table */

3740

3741

for (s=stat ; s < stat_end ; s++)

3742

{

3743

if (s->type == JT_SYSTEM || s->type == JT_CONST)

3744

{

3745

/* Only one matching row */

3746

s->found_records=s->records=s->read_time=1; s->worst_seeks=1.0;

3747

continue;

3748

}

3749

/* Approximate found rows and time to read them */

3750

s->found_records=s->records=s->table->file->stats.records;

3751

s->read_time=(ha_rows) s->table->file->scan_time();

3752

3753

3754

Set a max range of how many seeks we can expect when using keys

3755

This is can't be to high as otherwise we are likely to use

3756

table scan.

3757

3758

s->worst_seeks= min((double) s->found_records / 10,

3759

(double) s->read_time*3);

3760

if (s->worst_seeks < 2.0) // Fix for small tables

3761

s->worst_seeks=2.0;

3762

3763

3764

Add to stat->const_keys those indexes for which all group fields or

3765

all select distinct fields participate in one index.

3766

3767

add_group_and_distinct_keys(join, s);

3768

3769

if (!s->const_keys.is_clear_all() &&

3770

!s->table->pos_in_table_list->embedding)

3771

{

3772

ha_rows records;

3773

SQL_SELECT *select;

3774

select= make_select(s->table, found_const_table_map,

3775

found_const_table_map,

3776

*s->on_expr_ref ? *s->on_expr_ref : conds,

3777

1, &error);

3778

if (!select)

3779

return(1);

3780

records= get_quick_record_count(join->thd, select, s->table,

3781

&s->const_keys, join->row_limit);

3782

s->quick=select->quick;

3783

s->needed_reg=select->needed_reg;

3784

select->quick=0;

3785

if (records == 0 && s->table->reginfo.impossible_range)

3786

{

3787

3788

Impossible WHERE or ON expression

3789

In case of ON, we mark that the we match one empty NULL row.

3790

In case of WHERE, don't set found_const_table_map to get the

3791

caller to abort with a zero row result.

3792

3793

join->const_table_map|= s->table->map;

3794

set_position(join,const_count++,s,(KEYUSE*) 0);

3795

s->type= JT_CONST;

3796

if (*s->on_expr_ref)

3797

{

3798

/* Generate empty row */

3799

s->info= "Impossible ON condition";

3800

found_const_table_map|= s->table->map;

3801

s->type= JT_CONST;

3802

mark_as_null_row(s->table); // All fields are NULL

3803

}

3804

}

3805

if (records != HA_POS_ERROR)

3806

{

3807

s->found_records=records;

3808

s->read_time= (ha_rows) (s->quick ? s->quick->read_time : 0.0);

3809

}

3810

delete select;

3811

}

3812

}

3813

3814

join->join_tab=stat;

3815

join->map2table=stat_ref;

3816

join->table= join->all_tables=table_vector;

3817

join->const_tables=const_count;

3818

join->found_const_table_map=found_const_table_map;

3819

3820

/* Find an optimal join order of the non-constant tables. */

3821

if (join->const_tables != join->tables)

3822

{

3823

optimize_keyuse(join, keyuse_array);

3824

if (choose_plan(join, all_table_map & ~join->const_table_map))

3825

return(true);

3826

}

3827

else

3828

{

3829

memcpy(join->best_positions, join->positions,

3830

sizeof(POSITION)*join->const_tables);

3831

join->best_read=1.0;

3832

}

3833

/* Generate an execution plan from the found optimal join order. */

3834

return(join->thd->killed || get_best_combination(join));

3835

}

3836

3837

481

3838

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

482

3839

Check with keys are used and with tables references with tables

483

3840

Updates in stat:

486

3843

keyuse Pointer to possible keys

487

3844

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

488

3845

3846

/// Used when finding key fields

3847

typedef struct key_field_t {

3848

Field *field;

3849

Item *val; ///< May be empty if diff constant

3850

uint level;

3851

uint optimize; // KEY_OPTIMIZE_*

3852

bool eq_func;

3853

/**

3854

If true, the condition this struct represents will not be satisfied

3855

when val IS NULL.

3856

3857

bool null_rejecting;

3858

bool *cond_guard; /* See KEYUSE::cond_guard */

3859

uint sj_pred_no; /* See KEYUSE::sj_pred_no */

3860

} KEY_FIELD;

3861

3862

/**

3863

Merge new key definitions to old ones, remove those not used in both.

3864

3865

This is called for OR between different levels.

3866

3867

To be able to do 'ref_or_null' we merge a comparison of a column

3868

and 'column IS NULL' to one test. This is useful for sub select queries

3869

that are internally transformed to something like:.

3870

3871

@code

3872

SELECT * FROM t1 WHERE t1.key=outer_ref_field or t1.key IS NULL

3873

@endcode

3874

3875

KEY_FIELD::null_rejecting is processed as follows: @n

3876

result has null_rejecting=true if it is set for both ORed references.

3877

for example:

3878

- (t2.key = t1.field OR t2.key = t1.field) -> null_rejecting=true

3879

- (t2.key = t1.field OR t2.key <=> t1.field) -> null_rejecting=false

3880

3881

@todo

3882

The result of this is that we're missing some 'ref' accesses.

3883

OptimizerTeam: Fix this

3884

3885

3886

static KEY_FIELD *

3887

merge_key_fields(KEY_FIELD *start,KEY_FIELD *new_fields,KEY_FIELD *end,

3888

uint and_level)

3889

{

3890

if (start == new_fields)

3891

return start; // Impossible or

3892

if (new_fields == end)

3893

return start; // No new fields, skip all

3894

3895

KEY_FIELD *first_free=new_fields;

3896

3897

/* Mark all found fields in old array */

3898

for (; new_fields != end ; new_fields++)

3899

{

3900

for (KEY_FIELD *old=start ; old != first_free ; old++)

3901

{

3902

if (old->field == new_fields->field)

3903

{

3904

3905

NOTE: below const_item() call really works as "!used_tables()", i.e.

3906

it can return false where it is feasible to make it return true.

3907

3908

The cause is as follows: Some of the tables are already known to be

3909

const tables (the detection code is in make_join_statistics(),

3910

above the update_ref_and_keys() call), but we didn't propagate

3911

information about this: Table::const_table is not set to true, and

3912

Item::update_used_tables() hasn't been called for each item.

3913

The result of this is that we're missing some 'ref' accesses.

3914

TODO: OptimizerTeam: Fix this

3915

3916

if (!new_fields->val->const_item())

3917

{

3918

3919

If the value matches, we can use the key reference.

3920

If not, we keep it until we have examined all new values

3921

3922

if (old->val->eq(new_fields->val, old->field->binary()))

3923

{

3924

old->level= and_level;

3925

old->optimize= ((old->optimize & new_fields->optimize &

3926

KEY_OPTIMIZE_EXISTS) |

3927

((old->optimize | new_fields->optimize) &

3928

KEY_OPTIMIZE_REF_OR_NULL));

3929

old->null_rejecting= (old->null_rejecting &&

3930

new_fields->null_rejecting);

3931

}

3932

}

3933

else if (old->eq_func && new_fields->eq_func &&

3934

old->val->eq_by_collation(new_fields->val,

3935

old->field->binary(),

3936

old->field->charset()))

3937

3938

{

3939

old->level= and_level;

3940

old->optimize= ((old->optimize & new_fields->optimize &

3941

KEY_OPTIMIZE_EXISTS) |

3942

((old->optimize | new_fields->optimize) &

3943

KEY_OPTIMIZE_REF_OR_NULL));

3944

old->null_rejecting= (old->null_rejecting &&

3945

new_fields->null_rejecting);

3946

}

3947

else if (old->eq_func && new_fields->eq_func &&

3948

((old->val->const_item() && old->val->is_null()) ||

3949

new_fields->val->is_null()))

3950

{

3951

/* field = expression OR field IS NULL */

3952

old->level= and_level;

3953

old->optimize= KEY_OPTIMIZE_REF_OR_NULL;

3954

3955

Remember the NOT NULL value unless the value does not depend

3956

on other tables.

3957

3958

if (!old->val->used_tables() && old->val->is_null())

3959

old->val= new_fields->val;

3960

/* The referred expression can be NULL: */

3961

old->null_rejecting= 0;

3962

}

3963

else

3964

{

3965

3966

We are comparing two different const. In this case we can't

3967

use a key-lookup on this so it's better to remove the value

3968

and let the range optimzier handle it

3969

3970

if (old == --first_free) // If last item

3971

break;

3972

*old= *first_free; // Remove old value

3973

old--; // Retry this value

3974

}

3975

}

3976

}

3977

}

3978

/* Remove all not used items */

3979

for (KEY_FIELD *old=start ; old != first_free ;)

3980

{

3981

if (old->level != and_level)

3982

{ // Not used in all levels

3983

if (old == --first_free)

3984

break;

3985

*old= *first_free; // Remove old value

3986

continue;

3987

}

3988

old++;

3989

}

3990

return first_free;

3991

}

3992

3993

3994

/**

3995

Add a possible key to array of possible keys if it's usable as a key

3996

3997

@param key_fields Pointer to add key, if usable

3998

@param and_level And level, to be stored in KEY_FIELD

3999

@param cond Condition predicate

4000

@param field Field used in comparision

4001

@param eq_func True if we used =, <=> or IS NULL

4002

@param value Value used for comparison with field

4003

@param usable_tables Tables which can be used for key optimization

4004

@param sargables IN/OUT Array of found sargable candidates

4005

4006

@note

4007

If we are doing a NOT NULL comparison on a NOT NULL field in a outer join

4008

table, we store this to be able to do not exists optimization later.

4009

4010

@returns

4011

*key_fields is incremented if we stored a key in the array

4012

4013

4014

static void

4015

add_key_field(KEY_FIELD **key_fields,uint and_level, Item_func *cond,

4016

Field *field, bool eq_func, Item **value, uint num_values,

4017

table_map usable_tables, SARGABLE_PARAM **sargables)

4018

{

4019

uint exists_optimize= 0;

4020

if (!(field->flags & PART_KEY_FLAG))

4021

{

4022

// Don't remove column IS NULL on a LEFT JOIN table

4023

if (!eq_func || (*value)->type() != Item::NULL_ITEM ||

4024

!field->table->maybe_null || field->null_ptr)

4025

return; // Not a key. Skip it

4026

exists_optimize= KEY_OPTIMIZE_EXISTS;

4027

assert(num_values == 1);

4028

}

4029

else

4030

{

4031

table_map used_tables=0;

4032

bool optimizable=0;

4033

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

4034

{

4035

used_tables|=(value[i])->used_tables();

4036

if (!((value[i])->used_tables() & (field->table->map | RAND_TABLE_BIT)))

4037

optimizable=1;

4038

}

4039

if (!optimizable)

4040

return;

4041

if (!(usable_tables & field->table->map))

4042

{

4043

if (!eq_func || (*value)->type() != Item::NULL_ITEM ||

4044

!field->table->maybe_null || field->null_ptr)

4045

return; // Can't use left join optimize

4046

exists_optimize= KEY_OPTIMIZE_EXISTS;

4047

}

4048

else

4049

{

4050

JOIN_TAB *stat=field->table->reginfo.join_tab;

4051

key_map possible_keys=field->key_start;

4052

possible_keys.intersect(field->table->keys_in_use_for_query);

4053

stat[0].keys.merge(possible_keys); // Add possible keys

4054

4055

4056

Save the following cases:

4057

Field op constant

4058

Field LIKE constant where constant doesn't start with a wildcard

4059

Field = field2 where field2 is in a different table

4060

Field op formula

4061

Field IS NULL

4062

Field IS NOT NULL

4063

Field BETWEEN ...

4064

Field IN ...

4065

4066

stat[0].key_dependent|=used_tables;

4067

4068

bool is_const=1;

4069

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

4070

{

4071

if (!(is_const&= value[i]->const_item()))

4072

break;

4073

}

4074

if (is_const)

4075

stat[0].const_keys.merge(possible_keys);

4076

else if (!eq_func)

4077

{

4078

4079

Save info to be able check whether this predicate can be

4080

considered as sargable for range analisis after reading const tables.

4081

We do not save info about equalities as update_const_equal_items

4082

will take care of updating info on keys from sargable equalities.

4083

4084

(*sargables)--;

4085

(*sargables)->field= field;

4086

(*sargables)->arg_value= value;

4087

(*sargables)->num_values= num_values;

4088

}

4089

4090

We can't always use indexes when comparing a string index to a

4091

number. cmp_type() is checked to allow compare of dates to numbers.

4092

eq_func is NEVER true when num_values > 1

4093

4094

if (!eq_func)

4095

{

4096

4097

Additional optimization: if we're processing

4098

"t.key BETWEEN c1 AND c1" then proceed as if we were processing

4099

"t.key = c1".

4100

TODO: This is a very limited fix. A more generic fix is possible.

4101

There are 2 options:

4102

A) Make equality propagation code be able to handle BETWEEN

4103

(including cases like t1.key BETWEEN t2.key AND t3.key)

4104

B) Make range optimizer to infer additional "t.key = c" equalities

4105

and use them in equality propagation process (see details in

4106

OptimizerKBAndTodo)

4107

4108

if ((cond->functype() != Item_func::BETWEEN) ||

4109

((Item_func_between*) cond)->negated ||

4110

!value[0]->eq(value[1], field->binary()))

4111

return;

4112

eq_func= true;

4113

}

4114

4115

if (field->result_type() == STRING_RESULT)

4116

{

4117

if ((*value)->result_type() != STRING_RESULT)

4118

{

4119

if (field->cmp_type() != (*value)->result_type())

4120

return;

4121

}

4122

else

4123

{

4124

4125

We can't use indexes if the effective collation

4126

of the operation differ from the field collation.

4127

4128

if (field->cmp_type() == STRING_RESULT &&

4129

((Field_str*)field)->charset() != cond->compare_collation())

4130

return;

4131

}

4132

}

4133

}

4134

}

4135

4136

For the moment eq_func is always true. This slot is reserved for future

4137

extensions where we want to remembers other things than just eq comparisons

4138

4139

assert(eq_func);

4140

/* Store possible eq field */

4141

(*key_fields)->field= field;

4142

(*key_fields)->eq_func= eq_func;

4143

(*key_fields)->val= *value;

4144

(*key_fields)->level= and_level;

4145

(*key_fields)->optimize= exists_optimize;

4146

4147

If the condition has form "tbl.keypart = othertbl.field" and

4148

othertbl.field can be NULL, there will be no matches if othertbl.field

4149

has NULL value.

4150

We use null_rejecting in add_not_null_conds() to add

4151

'othertbl.field IS NOT NULL' to tab->select_cond.

4152

4153

(*key_fields)->null_rejecting= ((cond->functype() == Item_func::EQ_FUNC ||

4154

cond->functype() == Item_func::MULT_EQUAL_FUNC) &&

4155

((*value)->type() == Item::FIELD_ITEM) &&

4156

((Item_field*)*value)->field->maybe_null());

4157

(*key_fields)->cond_guard= NULL;

4158

(*key_fields)->sj_pred_no= (cond->name >= subq_sj_cond_name &&

4159

cond->name < subq_sj_cond_name + 64)?

4160

cond->name - subq_sj_cond_name: UINT_MAX;

4161

(*key_fields)++;

4162

}

4163

4164

/**

4165

Add possible keys to array of possible keys originated from a simple

4166

predicate.

4167

4168

@param key_fields Pointer to add key, if usable

4169

@param and_level And level, to be stored in KEY_FIELD

4170

@param cond Condition predicate

4171

@param field Field used in comparision

4172

@param eq_func True if we used =, <=> or IS NULL

4173

@param value Value used for comparison with field

4174

Is NULL for BETWEEN and IN

4175

@param usable_tables Tables which can be used for key optimization

4176

@param sargables IN/OUT Array of found sargable candidates

4177

4178

@note

4179

If field items f1 and f2 belong to the same multiple equality and

4180

a key is added for f1, the the same key is added for f2.

4181

4182

@returns

4183

*key_fields is incremented if we stored a key in the array

4184

4185

4186

static void

4187

add_key_equal_fields(KEY_FIELD **key_fields, uint and_level,

4188

Item_func *cond, Item_field *field_item,

4189

bool eq_func, Item **val,

4190

uint num_values, table_map usable_tables,

4191

SARGABLE_PARAM **sargables)

4192

{

4193

Field *field= field_item->field;

4194

add_key_field(key_fields, and_level, cond, field,

4195

eq_func, val, num_values, usable_tables, sargables);

4196

Item_equal *item_equal= field_item->item_equal;

4197

if (item_equal)

4198

{

4199

4200

Add to the set of possible key values every substitution of

4201

the field for an equal field included into item_equal

4202

4203

Item_equal_iterator it(*item_equal);

4204

Item_field *item;

4205

while ((item= it++))

4206

{

4207

if (!field->eq(item->field))

4208

{

4209

add_key_field(key_fields, and_level, cond, item->field,

4210

eq_func, val, num_values, usable_tables,

4211

sargables);

4212

}

4213

}

4214

}

4215

}

4216

4217

static void

4218

add_key_fields(JOIN *join, KEY_FIELD **key_fields, uint *and_level,

4219

COND *cond, table_map usable_tables,

4220

SARGABLE_PARAM **sargables)

4221

{

4222

if (cond->type() == Item_func::COND_ITEM)

4223

{

4224

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

4225

KEY_FIELD *org_key_fields= *key_fields;

4226

4227

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

4228

{

4229

Item *item;

4230

while ((item=li++))

4231

add_key_fields(join, key_fields, and_level, item, usable_tables,

4232

sargables);

4233

for (; org_key_fields != *key_fields ; org_key_fields++)

4234

org_key_fields->level= *and_level;

4235

}

4236

else

4237

{

4238

(*and_level)++;

4239

add_key_fields(join, key_fields, and_level, li++, usable_tables,

4240

sargables);

4241

Item *item;

4242

while ((item=li++))

4243

{

4244

KEY_FIELD *start_key_fields= *key_fields;

4245

(*and_level)++;

4246

add_key_fields(join, key_fields, and_level, item, usable_tables,

4247

sargables);

4248

*key_fields=merge_key_fields(org_key_fields,start_key_fields,

4249

*key_fields,++(*and_level));

4250

}

4251

}

4252

return;

4253

}

4254

4255

4256

Subquery optimization: Conditions that are pushed down into subqueries

4257

are wrapped into Item_func_trig_cond. We process the wrapped condition

4258

but need to set cond_guard for KEYUSE elements generated from it.

4259

4260

{

4261

if (cond->type() == Item::FUNC_ITEM &&

4262

((Item_func*)cond)->functype() == Item_func::TRIG_COND_FUNC)

4263

{

4264

Item *cond_arg= ((Item_func*)cond)->arguments()[0];

4265

if (!join->group_list && !join->order &&

4266

join->unit->item &&

4267

join->unit->item->substype() == Item_subselect::IN_SUBS &&

4268

!join->unit->is_union())

4269

{

4270

KEY_FIELD *save= *key_fields;

4271

add_key_fields(join, key_fields, and_level, cond_arg, usable_tables,

4272

sargables);

4273

// Indicate that this ref access candidate is for subquery lookup:

4274

for (; save != *key_fields; save++)

4275

save->cond_guard= ((Item_func_trig_cond*)cond)->get_trig_var();

4276

}

4277

return;

4278

}

4279

}

4280

4281

/* If item is of type 'field op field/constant' add it to key_fields */

4282

if (cond->type() != Item::FUNC_ITEM)

4283

return;

4284

Item_func *cond_func= (Item_func*) cond;

4285

switch (cond_func->select_optimize()) {

4286

case Item_func::OPTIMIZE_NONE:

4287

break;

4288

case Item_func::OPTIMIZE_KEY:

4289

{

4290

Item **values;

4291

// BETWEEN, IN, NE

4292

if (cond_func->key_item()->real_item()->type() == Item::FIELD_ITEM &&

4293

!(cond_func->used_tables() & OUTER_REF_TABLE_BIT))

4294

{

4295

values= cond_func->arguments()+1;

4296

if (cond_func->functype() == Item_func::NE_FUNC &&

4297

cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&

4298

!(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))

4299

values--;

4300

assert(cond_func->functype() != Item_func::IN_FUNC ||

4301

cond_func->argument_count() != 2);

4302

add_key_equal_fields(key_fields, *and_level, cond_func,

4303

(Item_field*) (cond_func->key_item()->real_item()),

4304

0, values,

4305

cond_func->argument_count()-1,

4306

usable_tables, sargables);

4307

}

4308

if (cond_func->functype() == Item_func::BETWEEN)

4309

{

4310

values= cond_func->arguments();

4311

for (uint i= 1 ; i < cond_func->argument_count() ; i++)

4312

{

4313

Item_field *field_item;

4314

if (cond_func->arguments()[i]->real_item()->type() == Item::FIELD_ITEM

4315

4316

!(cond_func->arguments()[i]->used_tables() & OUTER_REF_TABLE_BIT))

4317

{

4318

field_item= (Item_field *) (cond_func->arguments()[i]->real_item());

4319

add_key_equal_fields(key_fields, *and_level, cond_func,

4320

field_item, 0, values, 1, usable_tables,

4321

sargables);

4322

}

4323

}

4324

}

4325

break;

4326

}

4327

case Item_func::OPTIMIZE_OP:

4328

{

4329

bool equal_func=(cond_func->functype() == Item_func::EQ_FUNC ||

4330

cond_func->functype() == Item_func::EQUAL_FUNC);

4331

4332

if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&

4333

!(cond_func->arguments()[0]->used_tables() & OUTER_REF_TABLE_BIT))

4334

{

4335

add_key_equal_fields(key_fields, *and_level, cond_func,

4336

(Item_field*) (cond_func->arguments()[0])->real_item(),

4337

equal_func,

4338

cond_func->arguments()+1, 1, usable_tables,

4339

sargables);

4340

}

4341

if (cond_func->arguments()[1]->real_item()->type() == Item::FIELD_ITEM &&

4342

cond_func->functype() != Item_func::LIKE_FUNC &&

4343

!(cond_func->arguments()[1]->used_tables() & OUTER_REF_TABLE_BIT))

4344

{

4345

add_key_equal_fields(key_fields, *and_level, cond_func,

4346

(Item_field*) (cond_func->arguments()[1])->real_item(),

4347

equal_func,

4348

cond_func->arguments(),1,usable_tables,

4349

sargables);

4350

}

4351

break;

4352

}

4353

case Item_func::OPTIMIZE_NULL:

4354

/* column_name IS [NOT] NULL */

4355

if (cond_func->arguments()[0]->real_item()->type() == Item::FIELD_ITEM &&

4356

!(cond_func->used_tables() & OUTER_REF_TABLE_BIT))

4357

{

4358

Item *tmp=new Item_null;

4359

if (unlikely(!tmp)) // Should never be true

4360

return;

4361

add_key_equal_fields(key_fields, *and_level, cond_func,

4362

(Item_field*) (cond_func->arguments()[0])->real_item(),

4363

cond_func->functype() == Item_func::ISNULL_FUNC,

4364

&tmp, 1, usable_tables, sargables);

4365

}

4366

break;

4367

case Item_func::OPTIMIZE_EQUAL:

4368

Item_equal *item_equal= (Item_equal *) cond;

4369

Item *const_item= item_equal->get_const();

4370

Item_equal_iterator it(*item_equal);

4371

Item_field *item;

4372

if (const_item)

4373

{

4374

4375

For each field field1 from item_equal consider the equality

4376

field1=const_item as a condition allowing an index access of the table

4377

with field1 by the keys value of field1.

4378

4379

while ((item= it++))

4380

{

4381

add_key_field(key_fields, *and_level, cond_func, item->field,

4382

true, &const_item, 1, usable_tables, sargables);

4383

}

4384

}

4385

else

4386

{

4387

4388

Consider all pairs of different fields included into item_equal.

4389

For each of them (field1, field1) consider the equality

4390

field1=field2 as a condition allowing an index access of the table

4391

with field1 by the keys value of field2.

4392

4393

Item_equal_iterator fi(*item_equal);

4394

while ((item= fi++))

4395

{

4396

Field *field= item->field;

4397

while ((item= it++))

4398

{

4399

if (!field->eq(item->field))

4400

{

4401

add_key_field(key_fields, *and_level, cond_func, field,

4402

true, (Item **) &item, 1, usable_tables,

4403

sargables);

4404

}

4405

}

4406

it.rewind();

4407

}

4408

}

4409

break;

4410

}

4411

}

489

4412

490

4413

/**

491

4414

Add all keys with uses 'field' for some keypart.

492

4415

493

4416

If field->and_level != and_level then only mark key_part as const_part.

494

4417

495

uint32_t max_part_bit(key_part_map bits)

4418

4419

static uint

4420

max_part_bit(key_part_map bits)

496

4421

{

497

uint32_t found;

4422

uint found;

498

4423

for (found=0; bits & 1 ; found++,bits>>=1) ;

499

4424

return found;

500

4425

}

501

4426

502

static int sort_keyuse(optimizer::KeyUse *a, optimizer::KeyUse *b)

4427

static void

4428

add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)

4429

{

4430

Field *field=key_field->field;

4431

Table *form= field->table;

4432

KEYUSE keyuse;

4433

4434

if (key_field->eq_func && !(key_field->optimize & KEY_OPTIMIZE_EXISTS))

4435

{

4436

for (uint key= 0 ; key < form->sizeKeys() ; key++)

4437

{

4438

if (!(form->keys_in_use_for_query.is_set(key)))

4439

continue;

4440

4441

uint key_parts= (uint) form->key_info[key].key_parts;

4442

for (uint part=0 ; part < key_parts ; part++)

4443

{

4444

if (field->eq(form->key_info[key].key_part[part].field))

4445

{

4446

keyuse.table= field->table;

4447

keyuse.val = key_field->val;

4448

keyuse.key = key;

4449

keyuse.keypart=part;

4450

keyuse.keypart_map= (key_part_map) 1 << part;

4451

keyuse.used_tables=key_field->val->used_tables();

4452

keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;

4453

keyuse.null_rejecting= key_field->null_rejecting;

4454

keyuse.cond_guard= key_field->cond_guard;

4455

keyuse.sj_pred_no= key_field->sj_pred_no;

4456

VOID(insert_dynamic(keyuse_array,(uchar*) &keyuse));

4457

}

4458

}

4459

}

4460

}

4461

}

4462

4463

static int

4464

sort_keyuse(KEYUSE *a,KEYUSE *b)

503

4465

{

504

4466

int res;

505

if (a->getTable()->tablenr != b->getTable()->tablenr)

506

return static_cast<int>((a->getTable()->tablenr - b->getTable()->tablenr));

507

if (a->getKey() != b->getKey())

508

return static_cast<int>((a->getKey() - b->getKey()));

509

if (a->getKeypart() != b->getKeypart())

510

return static_cast<int>((a->getKeypart() - b->getKeypart()));

4467

if (a->table->tablenr != b->table->tablenr)

4468

return (int) (a->table->tablenr - b->table->tablenr);

4469

if (a->key != b->key)

4470

return (int) (a->key - b->key);

4471

if (a->keypart != b->keypart)

4472

return (int) (a->keypart - b->keypart);

511

4473

// Place const values before other ones

512

if ((res= test((a->getUsedTables() & ~OUTER_REF_TABLE_BIT)) -

513

test((b->getUsedTables() & ~OUTER_REF_TABLE_BIT))))

4474

if ((res= test((a->used_tables & ~OUTER_REF_TABLE_BIT)) -

4475

test((b->used_tables & ~OUTER_REF_TABLE_BIT))))

514

4476

return res;

515

4477

/* Place rows that are not 'OPTIMIZE_REF_OR_NULL' first */

516

return static_cast<int>(((a->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) -

517

(b->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL)));

4478

return (int) ((a->optimize & KEY_OPTIMIZE_REF_OR_NULL) -

4479

(b->optimize & KEY_OPTIMIZE_REF_OR_NULL));

4480

}

4481

4482

4483

4484

Add to KEY_FIELD array all 'ref' access candidates within nested join.

4485

4486

This function populates KEY_FIELD array with entries generated from the

4487

ON condition of the given nested join, and does the same for nested joins

4488

contained within this nested join.

4489

4490

@param[in] nested_join_table Nested join pseudo-table to process

4491

@param[in,out] end End of the key field array

4492

@param[in,out] and_level And-level

4493

@param[in,out] sargables Array of found sargable candidates

4494

4495

4496

@note

4497

We can add accesses to the tables that are direct children of this nested

4498

join (1), and are not inner tables w.r.t their neighbours (2).

4499

4500

Example for #1 (outer brackets pair denotes nested join this function is

4501

invoked for):

4502

@code

4503

... LEFT JOIN (t1 LEFT JOIN (t2 ... ) ) ON cond

4504

@endcode

4505

Example for #2:

4506

@code

4507

... LEFT JOIN (t1 LEFT JOIN t2 ) ON cond

4508

@endcode

4509

In examples 1-2 for condition cond, we can add 'ref' access candidates to

4510

t1 only.

4511

Example #3:

4512

@code

4513

... LEFT JOIN (t1, t2 LEFT JOIN t3 ON inner_cond) ON cond

4514

@endcode

4515

Here we can add 'ref' access candidates for t1 and t2, but not for t3.

4516

4517

4518

static void add_key_fields_for_nj(JOIN *join, TableList *nested_join_table,

4519

KEY_FIELD **end, uint *and_level,

4520

SARGABLE_PARAM **sargables)

4521

{

4522

List_iterator<TableList> li(nested_join_table->nested_join->join_list);

4523

List_iterator<TableList> li2(nested_join_table->nested_join->join_list);

4524

bool have_another = false;

4525

table_map tables= 0;

4526

TableList *table;

4527

assert(nested_join_table->nested_join);

4528

4529

while ((table= li++) || (have_another && (li=li2, have_another=false,

4530

(table= li++))))

4531

{

4532

if (table->nested_join)

4533

{

4534

if (!table->on_expr)

4535

{

4536

/* It's a semi-join nest. Walk into it as if it wasn't a nest */

4537

have_another= true;

4538

li2= li;

4539

li= List_iterator<TableList>(table->nested_join->join_list);

4540

}

4541

else

4542

add_key_fields_for_nj(join, table, end, and_level, sargables);

4543

}

4544

else

4545

if (!table->on_expr)

4546

tables |= table->table->map;

4547

}

4548

if (nested_join_table->on_expr)

4549

add_key_fields(join, end, and_level, nested_join_table->on_expr, tables,

4550

sargables);

518

4551

}

519

4552

520

4553

521

4554

/**

522

4555

Update keyuse array with all possible keys we can use to fetch rows.

523

524

@param session

525

@param[out] keyuse Put here ordered array of KeyUse structures

4556

4557

@param thd

4558

@param[out] keyuse Put here ordered array of KEYUSE structures

526

4559

@param join_tab Array in tablenr_order

527

4560

@param tables Number of tables in join

528

4561

@param cond WHERE condition (note that the function analyzes

531

4564

for which we can make ref access based the WHERE

532

4565

clause)

533

4566

@param select_lex current SELECT

534

@param[out] sargables std::vector of found sargable candidates

535

4567

@param[out] sargables Array of found sargable candidates

4568

536

4569

@retval

537

4570

0 OK

538

4571

@retval

539

4572

1 Out of memory.

540

4573

541

bool update_ref_and_keys(Session *session,

542

DYNAMIC_ARRAY *keyuse,

543

JoinTable *join_tab,

544

uint32_t tables,

545

COND *cond,

546

COND_EQUAL *,

547

table_map normal_tables,

548

Select_Lex *select_lex,

549

vector<optimizer::SargableParam> &sargables)

4574

4575

static bool

4576

update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,

4577

uint tables, COND *cond,

4578

COND_EQUAL *cond_equal __attribute__((unused)),

4579

table_map normal_tables, SELECT_LEX *select_lex,

4580

SARGABLE_PARAM **sargables)

550

4581

{

551

uint and_level,found_eq_constant;

552

optimizer::KeyField *key_fields, *end, *field;

553

uint32_t sz;

554

uint32_t m= max(select_lex->max_equal_elems,(uint32_t)1);

555

556

557

All predicates that are used to fill arrays of KeyField

558

and SargableParam classes have at most 2 arguments

559

except BETWEEN predicates that have 3 arguments and

4582

uint and_level,i,found_eq_constant;

4583

KEY_FIELD *key_fields, *end, *field;

4584

uint sz;

4585

uint m= max(select_lex->max_equal_elems,(uint32_t)1);

4586

4587

4588

We use the same piece of memory to store both KEY_FIELD

4589

and SARGABLE_PARAM structure.

4590

KEY_FIELD values are placed at the beginning this memory

4591

while SARGABLE_PARAM values are put at the end.

4592

All predicates that are used to fill arrays of KEY_FIELD

4593

and SARGABLE_PARAM structures have at most 2 arguments

4594

except BETWEEN predicates that have 3 arguments and

560

4595

IN predicates.

561

This any predicate if it's not BETWEEN/IN can be used

562

directly to fill at most 2 array elements, either of KeyField

563

or SargableParam type. For a BETWEEN predicate 3 elements

4596

This any predicate if it's not BETWEEN/IN can be used

4597

directly to fill at most 2 array elements, either of KEY_FIELD

4598

or SARGABLE_PARAM type. For a BETWEEN predicate 3 elements

564

4599

can be filled as this predicate is considered as

565

4600

saragable with respect to each of its argument.

566

4601

An IN predicate can require at most 1 element as currently

567

4602

it is considered as sargable only for its first argument.

568

4603

Multiple equality can add elements that are filled after

569

4604

substitution of field arguments by equal fields. There

570

can be not more than select_lex->max_equal_elems such

4605

can be not more than select_lex->max_equal_elems such

571

4606

substitutions.

572

573

sz= sizeof(optimizer::KeyField) *

574

(((session->lex->current_select->cond_count+1)*2 +

575

session->lex->current_select->between_count)*m+1);

576

if (! (key_fields= (optimizer::KeyField*) session->getMemRoot()->allocate(sz)))

577

return true;

4607

4608

sz= max(sizeof(KEY_FIELD),sizeof(SARGABLE_PARAM))*

4609

(((thd->lex->current_select->cond_count+1)*2 +

4610

thd->lex->current_select->between_count)*m+1);

4611

if (!(key_fields=(KEY_FIELD*) thd->alloc(sz)))

4612

return true; /* purecov: inspected */

578

4613

and_level= 0;

579

4614

field= end= key_fields;

4615

*sargables= (SARGABLE_PARAM *) key_fields +

4616

(sz - sizeof((*sargables)[0].field))/sizeof(SARGABLE_PARAM);

4617

/* set a barrier for the array of SARGABLE_PARAM */

4618

(*sargables)[0].field= 0;

580

4619

581

if (my_init_dynamic_array(keyuse, sizeof(optimizer::KeyUse), 20, 64))

4620

if (my_init_dynamic_array(keyuse,sizeof(KEYUSE),20,64))

582

4621

return true;

583

4622

if (cond)

584

4623

{

585

4624

add_key_fields(join_tab->join, &end, &and_level, cond, normal_tables,

586

4625

sargables);

587

for (; field != end; field++)

4626

for (; field != end ; field++)

588

4627

{

589

add_key_part(keyuse, field);

4628

add_key_part(keyuse,field);

590

4629

/* Mark that we can optimize LEFT JOIN */

591

if (field->getValue()->type() == Item::NULL_ITEM &&

592

! field->getField()->real_maybe_null())

593

{

594

field->getField()->getTable()->reginfo.not_exists_optimize= 1;

595

}

4630

if (field->val->type() == Item::NULL_ITEM &&

4631

!field->field->real_maybe_null())

4632

field->field->table->reginfo.not_exists_optimize=1;

596

4633

}

597

4634

}

598

for (uint32_t i= 0; i < tables; i++)

4635

for (i=0 ; i < tables ; i++)

599

4636

{

600

4637

601

4638

Block the creation of keys for inner tables of outer joins.

605

4642

In the future when we introduce conditional accesses

606

4643

for inner tables in outer joins these keys will be taken

607

4644

into account as well.

608

4645

609

4646

if (*join_tab[i].on_expr_ref)

610

add_key_fields(join_tab->join, &end, &and_level,

4647

add_key_fields(join_tab->join, &end, &and_level,

611

4648

*join_tab[i].on_expr_ref,

612

4649

join_tab[i].table->map, sargables);

613

4650

}

618

4655

TableList *table;

619

4656

while ((table= li++))

620

4657

{

621

if (table->getNestedJoin())

622

add_key_fields_for_nj(join_tab->join, table, &end, &and_level,

4658

if (table->nested_join)

4659

add_key_fields_for_nj(join_tab->join, table, &end, &and_level,

623

4660

sargables);

624

4661

}

625

4662

}

639

4676

640

4677

if (keyuse->elements)

641

4678

{

642

optimizer::KeyUse key_end,*prev,*save_pos,*use;

4679

KEYUSE key_end,*prev,*save_pos,*use;

643

4680

644

internal::my_qsort(keyuse->buffer,keyuse->elements,sizeof(optimizer::KeyUse),

645

(qsort_cmp) sort_keyuse);

4681

my_qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),

4682

(qsort_cmp) sort_keyuse);

646

4683

647

4684

memset(&key_end, 0, sizeof(key_end)); /* Add for easy testing */

648

insert_dynamic(keyuse,(unsigned char*) &key_end);

4685

VOID(insert_dynamic(keyuse,(uchar*) &key_end));

649

4686

650

use= save_pos= dynamic_element(keyuse, 0, optimizer::KeyUse*);

4687

use=save_pos=dynamic_element(keyuse,0,KEYUSE*);

651

4688

prev= &key_end;

652

found_eq_constant= 0;

4689

found_eq_constant=0;

4690

for (i=0 ; i < keyuse->elements-1 ; i++,use++)

653

4691

{

654

uint32_t i;

655

656

for (i= 0; i < keyuse->elements-1; i++, use++)

4692

if (!use->used_tables && use->optimize != KEY_OPTIMIZE_REF_OR_NULL)

4693

use->table->const_key_parts[use->key]|= use->keypart_map;

657

4694

{

658

if (! use->getUsedTables() && use->getOptimizeFlags() != KEY_OPTIMIZE_REF_OR_NULL)

659

use->getTable()->const_key_parts[use->getKey()]|= use->getKeypartMap();

660

if (use->getKey() == prev->getKey() && use->getTable() == prev->getTable())

661

{

662

if (prev->getKeypart() + 1 < use->getKeypart() ||

663

((prev->getKeypart() == use->getKeypart()) && found_eq_constant))

664

continue; /* remove */

665

}

666

else if (use->getKeypart() != 0) // First found must be 0

667

continue;

4695

if (use->key == prev->key && use->table == prev->table)

4696

{

4697

if (prev->keypart+1 < use->keypart || ((prev->keypart == use->keypart) && found_eq_constant))

4698

continue; /* remove */

4699

}

4700

else if (use->keypart != 0) // First found must be 0

4701

continue;

4702

}

668

4703

669

#ifdef HAVE_VALGRIND

670

/* Valgrind complains about overlapped memcpy when save_pos==use. */

671

if (save_pos != use)

4704

#ifdef HAVE_purify

4705

/* Valgrind complains about overlapped memcpy when save_pos==use. */

4706

if (save_pos != use)

672

4707

#endif

673

*save_pos= *use;

674

prev=use;

675

found_eq_constant= ! use->getUsedTables();

676

/* Save ptr to first use */

677

if (! use->getTable()->reginfo.join_tab->keyuse)

678

use->getTable()->reginfo.join_tab->keyuse= save_pos;

679

use->getTable()->reginfo.join_tab->checked_keys.set(use->getKey());

680

save_pos++;

681

}

682

i= (uint32_t) (save_pos - (optimizer::KeyUse*) keyuse->buffer);

683

set_dynamic(keyuse, (unsigned char*) &key_end, i);

684

keyuse->elements= i;

4708

*save_pos= *use;

4709

prev=use;

4710

found_eq_constant= !use->used_tables;

4711

/* Save ptr to first use */

4712

if (!use->table->reginfo.join_tab->keyuse)

4713

use->table->reginfo.join_tab->keyuse=save_pos;

4714

use->table->reginfo.join_tab->checked_keys.set_bit(use->key);

4715

save_pos++;

685

4716

}

4717

i=(uint) (save_pos-(KEYUSE*) keyuse->buffer);

4718

VOID(set_dynamic(keyuse,(uchar*) &key_end,i));

4719

keyuse->elements=i;

686

4720

}

687

4721

return false;

688

4722

}

690

4724

/**

691

4725

Update some values in keyuse for faster choose_plan() loop.

692

4726

693

void optimize_keyuse(Join *join, DYNAMIC_ARRAY *keyuse_array)

4727

4728

static void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)

694

4729

{

695

optimizer::KeyUse *end,*keyuse= dynamic_element(keyuse_array,

696

697

optimizer::KeyUse*);

4730

KEYUSE *end,*keyuse= dynamic_element(keyuse_array, 0, KEYUSE*);

698

4731

699

4732

for (end= keyuse+ keyuse_array->elements ; keyuse < end ; keyuse++)

700

4733

{

707

4740

Constant tables are ignored.

708

4741

To avoid bad matches, we don't make ref_table_rows less than 100.

709

4742

710

keyuse->setTableRows(~(ha_rows) 0); // If no ref

711

if (keyuse->getUsedTables() & (map= (keyuse->getUsedTables() & ~join->const_table_map & ~OUTER_REF_TABLE_BIT)))

4743

keyuse->ref_table_rows= ~(ha_rows) 0; // If no ref

4744

if (keyuse->used_tables &

4745

(map= (keyuse->used_tables & ~join->const_table_map &

4746

~OUTER_REF_TABLE_BIT)))

712

4747

{

713

uint32_t tablenr;

4748

uint tablenr;

714

4749

for (tablenr=0 ; ! (map & 1) ; map>>=1, tablenr++) ;

715

4750

if (map == 1) // Only one table

716

4751

{

717

Table *tmp_table=join->all_tables[tablenr];

718

keyuse->setTableRows(max(tmp_table->cursor->stats.records, (ha_rows)100));

4752

Table *tmp_table=join->all_tables[tablenr];

4753

keyuse->ref_table_rows= max(tmp_table->file->stats.records, (ha_rows)100);

719

4754

}

720

4755

}

721

4756

722

4757

Outer reference (external field) is constant for single executing

723

4758

of subquery

724

4759

725

if (keyuse->getUsedTables() == OUTER_REF_TABLE_BIT)

726

keyuse->setTableRows(1);

4760

if (keyuse->used_tables == OUTER_REF_TABLE_BIT)

4761

keyuse->ref_table_rows= 1;

727

4762

}

728

4763

}

729

4764

745

4780

@return

746

4781

None

747

4782

748

void add_group_and_distinct_keys(Join *join, JoinTable *join_tab)

4783

4784

static void

4785

add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab)

749

4786

{

750

4787

List<Item_field> indexed_fields;

751

4788

List_iterator<Item_field> indexed_fields_it(indexed_fields);

752

Order *cur_group;

4789

order_st *cur_group;

753

4790

Item_field *cur_item;

754

4791

key_map possible_keys(0);

755

4792

757

4794

{ /* Collect all query fields referenced in the GROUP clause. */

758

4795

for (cur_group= join->group_list; cur_group; cur_group= cur_group->next)

759

4796

(*cur_group->item)->walk(&Item::collect_item_field_processor, 0,

760

(unsigned char*) &indexed_fields);

4797

(uchar*) &indexed_fields);

761

4798

}

762

4799

else if (join->select_distinct)

763

4800

{ /* Collect all query fields referenced in the SELECT clause. */

766

4803

Item *item;

767

4804

while ((item= select_items_it++))

768

4805

item->walk(&Item::collect_item_field_processor, 0,

769

(unsigned char*) &indexed_fields);

4806

(uchar*) &indexed_fields);

770

4807

}

771

4808

else

772

4809

return;

776

4813

777

4814

/* Intersect the keys of all group fields. */

778

4815

cur_item= indexed_fields_it++;

779

possible_keys|= cur_item->field->part_of_key;

4816

possible_keys.merge(cur_item->field->part_of_key);

780

4817

while ((cur_item= indexed_fields_it++))

781

4818

{

782

possible_keys&= cur_item->field->part_of_key;

783

}

784

785

if (possible_keys.any())

786

join_tab->const_keys|= possible_keys;

787

}

788

789

/**

790

Compare two JoinTable objects based on the number of accessed records.

791

792

@param ptr1 pointer to first JoinTable object

793

@param ptr2 pointer to second JoinTable object

4819

possible_keys.intersect(cur_item->field->part_of_key);

4820

}

4821

4822

if (!possible_keys.is_clear_all())

4823

join_tab->const_keys.merge(possible_keys);

4824

}

4825

4826

4827

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

4828

Go through all combinations of not marked tables and find the one

4829

which uses least records

4830

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

4831

4832

/** Save const tables first as used tables. */

4833

4834

static void

4835

set_position(JOIN *join,uint idx,JOIN_TAB *table,KEYUSE *key)

4836

{

4837

join->positions[idx].table= table;

4838

join->positions[idx].key=key;

4839

join->positions[idx].records_read=1.0; /* This is a const table */

4840

join->positions[idx].ref_depend_map= 0;

4841

4842

/* Move the const table as down as possible in best_ref */

4843

JOIN_TAB **pos=join->best_ref+idx+1;

4844

JOIN_TAB *next=join->best_ref[idx];

4845

for (;next != table ; pos++)

4846

{

4847

JOIN_TAB *tmp=pos[0];

4848

pos[0]=next;

4849

next=tmp;

4850

}

4851

join->best_ref[idx]=table;

4852

}

4853

4854

4855

4856

Given a semi-join nest, find out which of the IN-equalities are bound

4857

4858

SYNOPSIS

4859

get_bound_sj_equalities()

4860

sj_nest Semi-join nest

4861

remaining_tables Tables that are not yet bound

4862

4863

DESCRIPTION

4864

Given a semi-join nest, find out which of the IN-equalities have their

4865

left part expression bound (i.e. the said expression doesn't refer to

4866

any of remaining_tables and can be evaluated).

4867

4868

RETURN

4869

Bitmap of bound IN-equalities.

4870

4871

4872

uint64_t get_bound_sj_equalities(TableList *sj_nest,

4873

table_map remaining_tables)

4874

{

4875

List_iterator<Item> li(sj_nest->nested_join->sj_outer_expr_list);

4876

Item *item;

4877

uint i= 0;

4878

uint64_t res= 0;

4879

while ((item= li++))

4880

{

4881

4882

Q: should this take into account equality propagation and how?

4883

A: If e->outer_side is an Item_field, walk over the equality

4884

class and see if there is an element that is bound?

4885

(this is an optional feature)

4886

4887

if (!(item->used_tables() & remaining_tables))

4888

{

4889

res |= 1ULL < i;

4890

}

4891

}

4892

return res;

4893

}

4894

4895

4896

/**

4897

Find the best access path for an extension of a partial execution

4898

plan and add this path to the plan.

4899

4900

The function finds the best access path to table 's' from the passed

4901

partial plan where an access path is the general term for any means to

4902

access the data in 's'. An access path may use either an index or a scan,

4903

whichever is cheaper. The input partial plan is passed via the array

4904

'join->positions' of length 'idx'. The chosen access method for 's' and its

4905

cost are stored in 'join->positions[idx]'.

4906

4907

@param join pointer to the structure providing all context info

4908

for the query

4909

@param s the table to be joined by the function

4910

@param thd thread for the connection that submitted the query

4911

@param remaining_tables set of tables not included into the partial plan yet

4912

@param idx the length of the partial plan

4913

@param record_count estimate for the number of records returned by the

4914

partial plan

4915

@param read_time the cost of the partial plan

4916

4917

@return

4918

None

4919

4920

4921

static void

4922

best_access_path(JOIN *join,

4923

JOIN_TAB *s,

4924

THD *thd,

4925

table_map remaining_tables,

4926

uint idx,

4927

double record_count,

4928

double read_time __attribute__((unused)))

4929

{

4930

KEYUSE *best_key= 0;

4931

uint best_max_key_part= 0;

4932

bool found_constraint= 0;

4933

double best= DBL_MAX;

4934

double best_time= DBL_MAX;

4935

double records= DBL_MAX;

4936

table_map best_ref_depends_map= 0;

4937

double tmp;

4938

ha_rows rec;

4939

uint best_is_sj_inside_out= 0;

4940

4941

if (s->keyuse)

4942

{ /* Use key if possible */

4943

Table *table= s->table;

4944

KEYUSE *keyuse,*start_key=0;

4945

double best_records= DBL_MAX;

4946

uint32_t max_key_part=0;

4947

uint64_t bound_sj_equalities= 0;

4948

bool try_sj_inside_out= false;

4949

4950

Discover the bound equalites. We need to do this, if

4951

1. The next table is an SJ-inner table, and

4952

2. It is the first table from that semijoin, and

4953

3. We're not within a semi-join range (i.e. all semi-joins either have

4954

all or none of their tables in join_table_map), except

4955

s->emb_sj_nest (which we've just entered).

4956

3. All correlation references from this sj-nest are bound

4957

4958

if (s->emb_sj_nest && // (1)

4959

s->emb_sj_nest->sj_in_exprs < 64 &&

4960

((remaining_tables & s->emb_sj_nest->sj_inner_tables) == // (2)

4961

s->emb_sj_nest->sj_inner_tables) && // (2)

4962

join->cur_emb_sj_nests == s->emb_sj_nest->sj_inner_tables && // (3)

4963

!(remaining_tables & s->emb_sj_nest->nested_join->sj_corr_tables)) // (4)

4964

{

4965

/* This table is an InsideOut scan candidate */

4966

bound_sj_equalities= get_bound_sj_equalities(s->emb_sj_nest,

4967

remaining_tables);

4968

try_sj_inside_out= true;

4969

}

4970

4971

/* Test how we can use keys */

4972

rec= s->records/MATCHING_ROWS_IN_OTHER_TABLE; // Assumed records/key

4973

for (keyuse=s->keyuse ; keyuse->table == table ;)

4974

{

4975

key_part_map found_part= 0;

4976

table_map found_ref= 0;

4977

uint key= keyuse->key;

4978

KEY *keyinfo= table->key_info+key;

4979

/* Bitmap of keyparts where the ref access is over 'keypart=const': */

4980

key_part_map const_part= 0;

4981

/* The or-null keypart in ref-or-null access: */

4982

key_part_map ref_or_null_part= 0;

4983

4984

/* Calculate how many key segments of the current key we can use */

4985

start_key= keyuse;

4986

uint64_t handled_sj_equalities=0;

4987

key_part_map sj_insideout_map= 0;

4988

4989

do /* For each keypart */

4990

{

4991

uint keypart= keyuse->keypart;

4992

table_map best_part_found_ref= 0;

4993

double best_prev_record_reads= DBL_MAX;

4994

4995

do /* For each way to access the keypart */

4996

{

4997

4998

4999

if 1. expression doesn't refer to forward tables

5000

2. we won't get two ref-or-null's

5001

5002

if (!(remaining_tables & keyuse->used_tables) &&

5003

!(ref_or_null_part && (keyuse->optimize &

5004

KEY_OPTIMIZE_REF_OR_NULL)))

5005

{

5006

found_part|= keyuse->keypart_map;

5007

if (!(keyuse->used_tables & ~join->const_table_map))

5008

const_part|= keyuse->keypart_map;

5009

5010

double tmp2= prev_record_reads(join, idx, (found_ref |

5011

keyuse->used_tables));

5012

if (tmp2 < best_prev_record_reads)

5013

{

5014

best_part_found_ref= keyuse->used_tables & ~join->const_table_map;

5015

best_prev_record_reads= tmp2;

5016

}

5017

if (rec > keyuse->ref_table_rows)

5018

rec= keyuse->ref_table_rows;

5019

5020

If there is one 'key_column IS NULL' expression, we can

5021

use this ref_or_null optimisation of this field

5022

5023

if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)

5024

ref_or_null_part |= keyuse->keypart_map;

5025

}

5026

5027

if (try_sj_inside_out && keyuse->sj_pred_no != UINT_MAX)

5028

{

5029

if (!(remaining_tables & keyuse->used_tables))

5030

bound_sj_equalities |= 1ULL << keyuse->sj_pred_no;

5031

else

5032

{

5033

handled_sj_equalities |= 1ULL << keyuse->sj_pred_no;

5034

sj_insideout_map |= ((key_part_map)1) << keyuse->keypart;

5035

}

5036

}

5037

5038

keyuse++;

5039

} while (keyuse->table == table && keyuse->key == key &&

5040

keyuse->keypart == keypart);

5041

found_ref|= best_part_found_ref;

5042

} while (keyuse->table == table && keyuse->key == key);

5043

5044

5045

Assume that that each key matches a proportional part of table.

5046

5047

if (!found_part && !handled_sj_equalities)

5048

continue; // Nothing usable found

5049

5050

if (rec < MATCHING_ROWS_IN_OTHER_TABLE)

5051

rec= MATCHING_ROWS_IN_OTHER_TABLE; // Fix for small tables

5052

5053

bool sj_inside_out_scan= false;

5054

{

5055

found_constraint= 1;

5056

5057

Check if InsideOut scan is applicable:

5058

1. All IN-equalities are either "bound" or "handled"

5059

2. Index keyparts are

5060

...

5061

5062

if (try_sj_inside_out &&

5063

table->covering_keys.is_set(key) &&

5064

(handled_sj_equalities | bound_sj_equalities) == // (1)

5065

PREV_BITS(uint64_t, s->emb_sj_nest->sj_in_exprs)) // (1)

5066

{

5067

uint n_fixed_parts= max_part_bit(found_part);

5068

if (n_fixed_parts != keyinfo->key_parts &&

5069

(PREV_BITS(uint, n_fixed_parts) | sj_insideout_map) ==

5070

PREV_BITS(uint, keyinfo->key_parts))

5071

{

5072

5073

Not all parts are fixed. Produce bitmap of remaining bits and

5074

check if all of them are covered.

5075

5076

sj_inside_out_scan= true;

5077

if (!n_fixed_parts)

5078

{

5079

5080

It's a confluent ref scan.

5081

5082

That is, all found KEYUSE elements refer to IN-equalities,

5083

and there is really no ref access because there is no

5084

t.keypart0 = {bound expression}

5085

5086

Calculate the cost of complete loose index scan.

5087

5088

records= (double)s->table->file->stats.records;

5089

5090

/* The cost is entire index scan cost (divided by 2) */

5091

best_time= s->table->file->index_only_read_time(key, records);

5092

5093

/* Now figure how many different keys we will get */

5094

ulong rpc;

5095

if ((rpc= keyinfo->rec_per_key[keyinfo->key_parts-1]))

5096

records= records / rpc;

5097

start_key= NULL;

5098

}

5099

}

5100

}

5101

5102

5103

Check if we found full key

5104

5105

if (found_part == PREV_BITS(uint,keyinfo->key_parts) &&

5106

!ref_or_null_part)

5107

{ /* use eq key */

5108

max_key_part= UINT32_MAX;

5109

if ((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) == HA_NOSAME)

5110

{

5111

tmp = prev_record_reads(join, idx, found_ref);

5112

records=1.0;

5113

}

5114

else

5115

{

5116

if (!found_ref)

5117

{ /* We found a const key */

5118

5119

ReuseRangeEstimateForRef-1:

5120

We get here if we've found a ref(const) (c_i are constants):

5121

"(keypart1=c1) AND ... AND (keypartN=cN)" [ref_const_cond]

5122

5123

If range optimizer was able to construct a "range"

5124

access on this index, then its condition "quick_cond" was

5125

eqivalent to ref_const_cond (*), and we can re-use E(#rows)

5126

from the range optimizer.

5127

5128

Proof of (*): By properties of range and ref optimizers

5129

quick_cond will be equal or tighther than ref_const_cond.

5130

ref_const_cond already covers "smallest" possible interval -

5131

a singlepoint interval over all keyparts. Therefore,

5132

quick_cond is equivalent to ref_const_cond (if it was an

5133

empty interval we wouldn't have got here).

5134

5135

if (table->quick_keys.is_set(key))

5136

records= (double) table->quick_rows[key];

5137

else

5138

{

5139

/* quick_range couldn't use key! */

5140

records= (double) s->records/rec;

5141

}

5142

}

5143

else

5144

{

5145

if (!(records=keyinfo->rec_per_key[keyinfo->key_parts-1]))

5146

{ /* Prefer longer keys */

5147

records=

5148

((double) s->records / (double) rec *

5149

(1.0 +

5150

((double) (table->s->max_key_length-keyinfo->key_length) /

5151

(double) table->s->max_key_length)));

5152

if (records < 2.0)

5153

records=2.0; /* Can't be as good as a unique */

5154

}

5155

5156

ReuseRangeEstimateForRef-2: We get here if we could not reuse

5157

E(#rows) from range optimizer. Make another try:

5158

5159

If range optimizer produced E(#rows) for a prefix of the ref

5160

access we're considering, and that E(#rows) is lower then our

5161

current estimate, make an adjustment. The criteria of when we

5162

can make an adjustment is a special case of the criteria used

5163

in ReuseRangeEstimateForRef-3.

5164

5165

if (table->quick_keys.is_set(key) &&

5166

const_part & (1 << table->quick_key_parts[key]) &&

5167

table->quick_n_ranges[key] == 1 &&

5168

records > (double) table->quick_rows[key])

5169

{

5170

records= (double) table->quick_rows[key];

5171

}

5172

}

5173

/* Limit the number of matched rows */

5174

tmp= records;

5175

set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);

5176

if (table->covering_keys.is_set(key))

5177

{

5178

/* we can use only index tree */

5179

tmp= record_count * table->file->index_only_read_time(key, tmp);

5180

}

5181

else

5182

tmp= record_count*min(tmp,s->worst_seeks);

5183

}

5184

}

5185

else

5186

{

5187

5188

Use as much key-parts as possible and a uniq key is better

5189

than a not unique key

5190

Set tmp to (previous record count) * (records / combination)

5191

5192

if ((found_part & 1) &&

5193

(!(table->file->index_flags(key, 0, 0) & HA_ONLY_WHOLE_INDEX) ||

5194

found_part == PREV_BITS(uint,keyinfo->key_parts)))

5195

{

5196

max_key_part= max_part_bit(found_part);

5197

5198

ReuseRangeEstimateForRef-3:

5199

We're now considering a ref[or_null] access via

5200

(t.keypart1=e1 AND ... AND t.keypartK=eK) [ OR

5201

(same-as-above but with one cond replaced

5202

with "t.keypart_i IS NULL")] (**)

5203

5204

Try re-using E(#rows) from "range" optimizer:

5205

We can do so if "range" optimizer used the same intervals as

5206

in (**). The intervals used by range optimizer may be not

5207

available at this point (as "range" access might have choosen to

5208

create quick select over another index), so we can't compare

5209

them to (**). We'll make indirect judgements instead.

5210

The sufficient conditions for re-use are:

5211

(C1) All e_i in (**) are constants, i.e. found_ref==false. (if

5212

this is not satisfied we have no way to know which ranges

5213

will be actually scanned by 'ref' until we execute the

5214

join)

5215

(C2) max #key parts in 'range' access == K == max_key_part (this

5216

is apparently a necessary requirement)

5217

5218

We also have a property that "range optimizer produces equal or

5219

tighter set of scan intervals than ref(const) optimizer". Each

5220

of the intervals in (**) are "tightest possible" intervals when

5221

one limits itself to using keyparts 1..K (which we do in #2).

5222

From here it follows that range access used either one, or

5223

both of the (I1) and (I2) intervals:

5224

5225

(t.keypart1=c1 AND ... AND t.keypartK=eK) (I1)

5226

(same-as-above but with one cond replaced

5227

with "t.keypart_i IS NULL") (I2)

5228

5229

The remaining part is to exclude the situation where range

5230

optimizer used one interval while we're considering

5231

ref-or-null and looking for estimate for two intervals. This

5232

is done by last limitation:

5233

5234

(C3) "range optimizer used (have ref_or_null?2:1) intervals"

5235

5236

if (table->quick_keys.is_set(key) && !found_ref && //(C1)

5237

table->quick_key_parts[key] == max_key_part && //(C2)

5238

table->quick_n_ranges[key] == 1+test(ref_or_null_part)) //(C3)

5239

{

5240

tmp= records= (double) table->quick_rows[key];

5241

}

5242

else

5243

{

5244

/* Check if we have statistic about the distribution */

5245

if ((records= keyinfo->rec_per_key[max_key_part-1]))

5246

{

5247

5248

Fix for the case where the index statistics is too

5249

optimistic: If

5250

(1) We're considering ref(const) and there is quick select

5251

on the same index,

5252

(2) and that quick select uses more keyparts (i.e. it will

5253

scan equal/smaller interval then this ref(const))

5254

(3) and E(#rows) for quick select is higher then our

5255

estimate,

5256

Then

5257

We'll use E(#rows) from quick select.

5258

5259

Q: Why do we choose to use 'ref'? Won't quick select be

5260

cheaper in some cases ?

5261

TODO: figure this out and adjust the plan choice if needed.

5262

5263

if (!found_ref && table->quick_keys.is_set(key) && // (1)

5264

table->quick_key_parts[key] > max_key_part && // (2)

5265

records < (double)table->quick_rows[key]) // (3)

5266

records= (double)table->quick_rows[key];

5267

5268

tmp= records;

5269

}

5270

else

5271

{

5272

5273

Assume that the first key part matches 1% of the file

5274

and that the whole key matches 10 (duplicates) or 1

5275

(unique) records.

5276

Assume also that more key matches proportionally more

5277

records

5278

This gives the formula:

5279

records = (x * (b-a) + a*c-b)/(c-1)

5280

5281

b = records matched by whole key

5282

a = records matched by first key part (1% of all records?)

5283

c = number of key parts in key

5284

x = used key parts (1 <= x <= c)

5285

5286

double rec_per_key;

5287

if (!(rec_per_key=(double)

5288

keyinfo->rec_per_key[keyinfo->key_parts-1]))

5289

rec_per_key=(double) s->records/rec+1;

5290

5291

if (!s->records)

5292

tmp = 0;

5293

else if (rec_per_key/(double) s->records >= 0.01)

5294

tmp = rec_per_key;

5295

else

5296

{

5297

double a=s->records*0.01;

5298

if (keyinfo->key_parts > 1)

5299

tmp= (max_key_part * (rec_per_key - a) +

5300

a*keyinfo->key_parts - rec_per_key)/

5301

(keyinfo->key_parts-1);

5302

else

5303

tmp= a;

5304

set_if_bigger(tmp,1.0);

5305

}

5306

records = (ulong) tmp;

5307

}

5308

5309

if (ref_or_null_part)

5310

{

5311

/* We need to do two key searches to find key */

5312

tmp *= 2.0;

5313

records *= 2.0;

5314

}

5315

5316

5317

ReuseRangeEstimateForRef-4: We get here if we could not reuse

5318

E(#rows) from range optimizer. Make another try:

5319

5320

If range optimizer produced E(#rows) for a prefix of the ref

5321

access we're considering, and that E(#rows) is lower then our

5322

current estimate, make the adjustment.

5323

5324

The decision whether we can re-use the estimate from the range

5325

optimizer is the same as in ReuseRangeEstimateForRef-3,

5326

applied to first table->quick_key_parts[key] key parts.

5327

5328

if (table->quick_keys.is_set(key) &&

5329

table->quick_key_parts[key] <= max_key_part &&

5330

const_part & (1 << table->quick_key_parts[key]) &&

5331

table->quick_n_ranges[key] == 1 + test(ref_or_null_part &

5332

const_part) &&

5333

records > (double) table->quick_rows[key])

5334

{

5335

tmp= records= (double) table->quick_rows[key];

5336

}

5337

}

5338

5339

/* Limit the number of matched rows */

5340

set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);

5341

if (table->covering_keys.is_set(key))

5342

{

5343

/* we can use only index tree */

5344

tmp= record_count * table->file->index_only_read_time(key, tmp);

5345

}

5346

else

5347

tmp= record_count * min(tmp,s->worst_seeks);

5348

}

5349

else

5350

tmp= best_time; // Do nothing

5351

}

5352

5353

if (sj_inside_out_scan && !start_key)

5354

{

5355

tmp= tmp/2;

5356

if (records)

5357

records= records/2;

5358

}

5359

5360

}

5361

if (tmp < best_time - records/(double) TIME_FOR_COMPARE)

5362

{

5363

best_time= tmp + records/(double) TIME_FOR_COMPARE;

5364

best= tmp;

5365

best_records= records;

5366

best_key= start_key;

5367

best_max_key_part= max_key_part;

5368

best_ref_depends_map= found_ref;

5369

best_is_sj_inside_out= sj_inside_out_scan;

5370

}

5371

}

5372

records= best_records;

5373

}

5374

5375

5376

Don't test table scan if it can't be better.

5377

Prefer key lookup if we would use the same key for scanning.

5378

5379

Don't do a table scan on InnoDB tables, if we can read the used

5380

parts of the row from any of the used index.

5381

This is because table scans uses index and we would not win

5382

anything by using a table scan.

5383

5384

A word for word translation of the below if-statement in sergefp's

5385

understanding: we check if we should use table scan if:

5386

(1) The found 'ref' access produces more records than a table scan

5387

(or index scan, or quick select), or 'ref' is more expensive than

5388

any of them.

5389

(2) This doesn't hold: the best way to perform table scan is to to perform

5390

'range' access using index IDX, and the best way to perform 'ref'

5391

access is to use the same index IDX, with the same or more key parts.

5392

(note: it is not clear how this rule is/should be extended to

5393

index_merge quick selects)

5394

(3) See above note about InnoDB.

5395

(4) NOT ("FORCE INDEX(...)" is used for table and there is 'ref' access

5396

path, but there is no quick select)

5397

If the condition in the above brackets holds, then the only possible

5398

"table scan" access method is ALL/index (there is no quick select).

5399

Since we have a 'ref' access path, and FORCE INDEX instructs us to

5400

choose it over ALL/index, there is no need to consider a full table

5401

scan.

5402

5403

if ((records >= s->found_records || best > s->read_time) && // (1)

5404

!(s->quick && best_key && s->quick->index == best_key->key && // (2)

5405

best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)

5406

!((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) && // (3)

5407

! s->table->covering_keys.is_clear_all() && best_key && !s->quick) &&// (3)

5408

!(s->table->force_index && best_key && !s->quick)) // (4)

5409

{ // Check full join

5410

ha_rows rnd_records= s->found_records;

5411

5412

If there is a filtering condition on the table (i.e. ref analyzer found

5413

at least one "table.keyXpartY= exprZ", where exprZ refers only to tables

5414

preceding this table in the join order we're now considering), then

5415

assume that 25% of the rows will be filtered out by this condition.

5416

5417

This heuristic is supposed to force tables used in exprZ to be before

5418

this table in join order.

5419

5420

if (found_constraint)

5421

rnd_records-= rnd_records/4;

5422

5423

5424

If applicable, get a more accurate estimate. Don't use the two

5425

heuristics at once.

5426

5427

if (s->table->quick_condition_rows != s->found_records)

5428

rnd_records= s->table->quick_condition_rows;

5429

5430

5431

Range optimizer never proposes a RANGE if it isn't better

5432

than FULL: so if RANGE is present, it's always preferred to FULL.

5433

Here we estimate its cost.

5434

5435

if (s->quick)

5436

{

5437

5438

For each record we:

5439

- read record range through 'quick'

5440

- skip rows which does not satisfy WHERE constraints

5441

TODO:

5442

We take into account possible use of join cache for ALL/index

5443

access (see first else-branch below), but we don't take it into

5444

account here for range/index_merge access. Find out why this is so.

5445

5446

tmp= record_count *

5447

(s->quick->read_time +

5448

(s->found_records - rnd_records)/(double) TIME_FOR_COMPARE);

5449

}

5450

else

5451

{

5452

/* Estimate cost of reading table. */

5453

tmp= s->table->file->scan_time();

5454

if (s->table->map & join->outer_join) // Can't use join cache

5455

{

5456

5457

For each record we have to:

5458

- read the whole table record

5459

- skip rows which does not satisfy join condition

5460

5461

tmp= record_count *

5462

(tmp +

5463

(s->records - rnd_records)/(double) TIME_FOR_COMPARE);

5464

}

5465

else

5466

{

5467

/* We read the table as many times as join buffer becomes full. */

5468

tmp*= (1.0 + floor((double) cache_record_length(join,idx) *

5469

record_count /

5470

(double) thd->variables.join_buff_size));

5471

5472

We don't make full cartesian product between rows in the scanned

5473

table and existing records because we skip all rows from the

5474

scanned table, which does not satisfy join condition when

5475

we read the table (see flush_cached_records for details). Here we

5476

take into account cost to read and skip these records.

5477

5478

tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE;

5479

}

5480

}

5481

5482

5483

We estimate the cost of evaluating WHERE clause for found records

5484

as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus

5485

tmp give us total cost of using Table SCAN

5486

5487

if (best == DBL_MAX ||

5488

(tmp + record_count/(double) TIME_FOR_COMPARE*rnd_records <

5489

best + record_count/(double) TIME_FOR_COMPARE*records))

5490

{

5491

5492

If the table has a range (s->quick is set) make_join_select()

5493

will ensure that this will be used

5494

5495

best= tmp;

5496

records= rows2double(rnd_records);

5497

best_key= 0;

5498

/* range/index_merge/ALL/index access method are "independent", so: */

5499

best_ref_depends_map= 0;

5500

best_is_sj_inside_out= false;

5501

}

5502

}

5503

5504

/* Update the cost information for the current partial plan */

5505

join->positions[idx].records_read= records;

5506

join->positions[idx].read_time= best;

5507

join->positions[idx].key= best_key;

5508

join->positions[idx].table= s;

5509

join->positions[idx].ref_depend_map= best_ref_depends_map;

5510

join->positions[idx].use_insideout_scan= best_is_sj_inside_out;

5511

5512

if (!best_key &&

5513

idx == join->const_tables &&

5514

s->table == join->sort_by_table &&

5515

join->unit->select_limit_cnt >= records)

5516

join->sort_by_table= (Table*) 1; // Must use temporary table

5517

5518

return;

5519

}

5520

5521

5522

/**

5523

Selects and invokes a search strategy for an optimal query plan.

5524

5525

The function checks user-configurable parameters that control the search

5526

strategy for an optimal plan, selects the search method and then invokes

5527

it. Each specific optimization procedure stores the final optimal plan in

5528

the array 'join->best_positions', and the cost of the plan in

5529

'join->best_read'.

5530

5531

@param join pointer to the structure providing all context info for

5532

the query

5533

@param join_tables set of the tables in the query

5534

5535

@todo

5536

'MAX_TABLES+2' denotes the old implementation of find_best before

5537

the greedy version. Will be removed when greedy_search is approved.

5538

5539

@retval

5540

false ok

5541

@retval

5542

true Fatal error

5543

5544

5545

static bool

5546

choose_plan(JOIN *join, table_map join_tables)

5547

{

5548

uint search_depth= join->thd->variables.optimizer_search_depth;

5549

uint prune_level= join->thd->variables.optimizer_prune_level;

5550

bool straight_join= test(join->select_options & SELECT_STRAIGHT_JOIN);

5551

5552

join->cur_embedding_map= 0;

5553

reset_nj_counters(join->join_list);

5554

5555

if (SELECT_STRAIGHT_JOIN option is set)

5556

reorder tables so dependent tables come after tables they depend

5557

on, otherwise keep tables in the order they were specified in the query

5558

else

5559

Apply heuristic: pre-sort all access plans with respect to the number of

5560

records accessed.

5561

5562

my_qsort(join->best_ref + join->const_tables,

5563

join->tables - join->const_tables, sizeof(JOIN_TAB*),

5564

straight_join ? join_tab_cmp_straight : join_tab_cmp);

5565

join->cur_emb_sj_nests= 0;

5566

if (straight_join)

5567

{

5568

optimize_straight_join(join, join_tables);

5569

}

5570

else

5571

{

5572

if (search_depth == MAX_TABLES+2)

5573

{ /*

5574

TODO: 'MAX_TABLES+2' denotes the old implementation of find_best before

5575

the greedy version. Will be removed when greedy_search is approved.

5576

5577

join->best_read= DBL_MAX;

5578

if (find_best(join, join_tables, join->const_tables, 1.0, 0.0))

5579

return(true);

5580

}

5581

else

5582

{

5583

if (search_depth == 0)

5584

/* Automatically determine a reasonable value for 'search_depth' */

5585

search_depth= determine_search_depth(join);

5586

if (greedy_search(join, join_tables, search_depth, prune_level))

5587

return(true);

5588

}

5589

}

5590

5591

5592

Store the cost of this query into a user variable

5593

Don't update last_query_cost for statements that are not "flat joins" :

5594

i.e. they have subqueries, unions or call stored procedures.

5595

TODO: calculate a correct cost for a query with subqueries and UNIONs.

5596

5597

if (join->thd->lex->is_single_level_stmt())

5598

join->thd->status_var.last_query_cost= join->best_read;

5599

return(false);

5600

}

5601

5602

5603

/**

5604

Compare two JOIN_TAB objects based on the number of accessed records.

5605

5606

@param ptr1 pointer to first JOIN_TAB object

5607

@param ptr2 pointer to second JOIN_TAB object

794

5608

795

5609

NOTES

796

5610

The order relation implemented by join_tab_cmp() is not transitive,

802

5616

a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0

803

5617

b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838

804

5618

c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0

805

5619

806

5620

@retval

807

5621

1 if first is bigger

808

5622

@retval

810

5624

@retval

811

5625

0 if equal

812

5626

813

int join_tab_cmp(const void* ptr1, const void* ptr2)

5627

5628

static int

5629

join_tab_cmp(const void* ptr1, const void* ptr2)

814

5630

{

815

JoinTable *jt1= *(JoinTable**) ptr1;

816

JoinTable *jt2= *(JoinTable**) ptr2;

5631

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5632

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

817

5633

818

5634

if (jt1->dependent & jt2->table->map)

819

5635

return 1;

820

5636

if (jt2->dependent & jt1->table->map)

821

return -1;

5637

return -1;

822

5638

if (jt1->found_records > jt2->found_records)

823

5639

return 1;

824

5640

if (jt1->found_records < jt2->found_records)

825

return -1;

5641

return -1;

826

5642

return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);

827

5643

}

828

5644

5645

829

5646

/**

830

5647

Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.

831

5648

832

int join_tab_cmp_straight(const void* ptr1, const void* ptr2)

5649

5650

static int

5651

join_tab_cmp_straight(const void* ptr1, const void* ptr2)

833

5652

{

834

JoinTable *jt1= *(JoinTable**) ptr1;

835

JoinTable *jt2= *(JoinTable**) ptr2;

5653

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5654

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

836

5655

837

5656

if (jt1->dependent & jt2->table->map)

838

5657

return 1;

842

5661

}

843

5662

844

5663

/**

5664

Heuristic procedure to automatically guess a reasonable degree of

5665

exhaustiveness for the greedy search procedure.

5666

5667

The procedure estimates the optimization time and selects a search depth

5668

big enough to result in a near-optimal QEP, that doesn't take too long to

5669

find. If the number of tables in the query exceeds some constant, then

5670

search_depth is set to this constant.

5671

5672

@param join pointer to the structure providing all context info for

5673

the query

5674

5675

@note

5676

This is an extremely simplistic implementation that serves as a stub for a

5677

more advanced analysis of the join. Ideally the search depth should be

5678

determined by learning from previous query optimizations, because it will

5679

depend on the CPU power (and other factors).

5680

5681

@todo

5682

this value should be determined dynamically, based on statistics:

5683

uint max_tables_for_exhaustive_opt= 7;

5684

5685

@todo

5686

this value could be determined by some mapping of the form:

5687

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5688

5689

@return

5690

A positive integer that specifies the search depth (and thus the

5691

exhaustiveness) of the depth-first search algorithm used by

5692

'greedy_search'.

5693

5694

5695

static uint

5696

determine_search_depth(JOIN *join)

5697

{

5698

uint table_count= join->tables - join->const_tables;

5699

uint search_depth;

5700

/* TODO: this value should be determined dynamically, based on statistics: */

5701

uint max_tables_for_exhaustive_opt= 7;

5702

5703

if (table_count <= max_tables_for_exhaustive_opt)

5704

search_depth= table_count+1; // use exhaustive for small number of tables

5705

else

5706

5707

TODO: this value could be determined by some mapping of the form:

5708

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5709

5710

search_depth= max_tables_for_exhaustive_opt; // use greedy search

5711

5712

return search_depth;

5713

}

5714

5715

5716

/**

5717

Select the best ways to access the tables in a query without reordering them.

5718

5719

Find the best access paths for each query table and compute their costs

5720

according to their order in the array 'join->best_ref' (thus without

5721

reordering the join tables). The function calls sequentially

5722

'best_access_path' for each table in the query to select the best table

5723

access method. The final optimal plan is stored in the array

5724

'join->best_positions', and the corresponding cost in 'join->best_read'.

5725

5726

@param join pointer to the structure providing all context info for

5727

the query

5728

@param join_tables set of the tables in the query

5729

5730

@note

5731

This function can be applied to:

5732

- queries with STRAIGHT_JOIN

5733

- internally to compute the cost of an arbitrary QEP

5734

@par

5735

Thus 'optimize_straight_join' can be used at any stage of the query

5736

optimization process to finalize a QEP as it is.

5737

5738

5739

static void

5740

optimize_straight_join(JOIN *join, table_map join_tables)

5741

{

5742

JOIN_TAB *s;

5743

uint idx= join->const_tables;

5744

double record_count= 1.0;

5745

double read_time= 0.0;

5746

5747

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

5748

{

5749

/* Find the best access method from 's' to the current partial plan */

5750

advance_sj_state(join_tables, s);

5751

best_access_path(join, s, join->thd, join_tables, idx,

5752

record_count, read_time);

5753

/* compute the cost of the new plan extended with 's' */

5754

record_count*= join->positions[idx].records_read;

5755

read_time+= join->positions[idx].read_time;

5756

join_tables&= ~(s->table->map);

5757

++idx;

5758

}

5759

5760

read_time+= record_count / (double) TIME_FOR_COMPARE;

5761

if (join->sort_by_table &&

5762

join->sort_by_table != join->positions[join->const_tables].table->table)

5763

read_time+= record_count; // We have to make a temp table

5764

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

5765

join->best_read= read_time;

5766

}

5767

5768

5769

/**

5770

Find a good, possibly optimal, query execution plan (QEP) by a greedy search.

5771

5772

The search procedure uses a hybrid greedy/exhaustive search with controlled

5773

exhaustiveness. The search is performed in N = card(remaining_tables)

5774

steps. Each step evaluates how promising is each of the unoptimized tables,

5775

selects the most promising table, and extends the current partial QEP with

5776

that table. Currenly the most 'promising' table is the one with least

5777

expensive extension.\

5778

5779

There are two extreme cases:

5780

-# When (card(remaining_tables) < search_depth), the estimate finds the

5781

best complete continuation of the partial QEP. This continuation can be

5782

used directly as a result of the search.

5783

-# When (search_depth == 1) the 'best_extension_by_limited_search'

5784

consideres the extension of the current QEP with each of the remaining

5785

unoptimized tables.

5786

5787

All other cases are in-between these two extremes. Thus the parameter

5788

'search_depth' controlls the exhaustiveness of the search. The higher the

5789

value, the longer the optimizaton time and possibly the better the

5790

resulting plan. The lower the value, the fewer alternative plans are

5791

estimated, but the more likely to get a bad QEP.

5792

5793

All intermediate and final results of the procedure are stored in 'join':

5794

- join->positions : modified for every partial QEP that is explored

5795

- join->best_positions: modified for the current best complete QEP

5796

- join->best_read : modified for the current best complete QEP

5797

- join->best_ref : might be partially reordered

5798

5799

The final optimal plan is stored in 'join->best_positions', and its

5800

corresponding cost in 'join->best_read'.

5801

5802

@note

5803

The following pseudocode describes the algorithm of 'greedy_search':

5804

5805

@code

5806

procedure greedy_search

5807

input: remaining_tables

5808

output: pplan;

5809

{

5810

pplan = <>;

5811

do {

5812

(t, a) = best_extension(pplan, remaining_tables);

5813

pplan = concat(pplan, (t, a));

5814

remaining_tables = remaining_tables - t;

5815

} while (remaining_tables != {})

5816

return pplan;

5817

}

5818

5819

@endcode

5820

where 'best_extension' is a placeholder for a procedure that selects the

5821

most "promising" of all tables in 'remaining_tables'.

5822

Currently this estimate is performed by calling

5823

'best_extension_by_limited_search' to evaluate all extensions of the

5824

current QEP of size 'search_depth', thus the complexity of 'greedy_search'

5825

mainly depends on that of 'best_extension_by_limited_search'.

5826

5827

@par

5828

If 'best_extension()' == 'best_extension_by_limited_search()', then the

5829

worst-case complexity of this algorithm is <=

5830

O(N*N^search_depth/search_depth). When serch_depth >= N, then the

5831

complexity of greedy_search is O(N!).

5832

5833

@par

5834

In the future, 'greedy_search' might be extended to support other

5835

implementations of 'best_extension', e.g. some simpler quadratic procedure.

5836

5837

@param join pointer to the structure providing all context info

5838

for the query

5839

@param remaining_tables set of tables not included into the partial plan yet

5840

@param search_depth controlls the exhaustiveness of the search

5841

@param prune_level the pruning heuristics that should be applied during

5842

5843

5844

@retval

5845

false ok

5846

@retval

5847

true Fatal error

5848

5849

5850

static bool

5851

greedy_search(JOIN *join,

5852

table_map remaining_tables,

5853

uint search_depth,

5854

uint prune_level)

5855

{

5856

double record_count= 1.0;

5857

double read_time= 0.0;

5858

uint idx= join->const_tables; // index into 'join->best_ref'

5859

uint best_idx;

5860

uint size_remain; // cardinality of remaining_tables

5861

POSITION best_pos;

5862

JOIN_TAB *best_table; // the next plan node to be added to the curr QEP

5863

5864

/* number of tables that remain to be optimized */

5865

size_remain= my_count_bits(remaining_tables);

5866

5867

do {

5868

/* Find the extension of the current QEP with the lowest cost */

5869

join->best_read= DBL_MAX;

5870

if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,

5871

read_time, search_depth, prune_level))

5872

return(true);

5873

5874

if (size_remain <= search_depth)

5875

{

5876

5877

'join->best_positions' contains a complete optimal extension of the

5878

current partial QEP.

5879

5880

return(false);

5881

}

5882

5883

/* select the first table in the optimal extension as most promising */

5884

best_pos= join->best_positions[idx];

5885

best_table= best_pos.table;

5886

5887

Each subsequent loop of 'best_extension_by_limited_search' uses

5888

'join->positions' for cost estimates, therefore we have to update its

5889

value.

5890

5891

join->positions[idx]= best_pos;

5892

5893

/* find the position of 'best_table' in 'join->best_ref' */

5894

best_idx= idx;

5895

JOIN_TAB *pos= join->best_ref[best_idx];

5896

while (pos && best_table != pos)

5897

pos= join->best_ref[++best_idx];

5898

assert((pos != NULL)); // should always find 'best_table'

5899

/* move 'best_table' at the first free position in the array of joins */

5900

swap_variables(JOIN_TAB*, join->best_ref[idx], join->best_ref[best_idx]);

5901

5902

/* compute the cost of the new plan extended with 'best_table' */

5903

record_count*= join->positions[idx].records_read;

5904

read_time+= join->positions[idx].read_time;

5905

5906

remaining_tables&= ~(best_table->table->map);

5907

--size_remain;

5908

++idx;

5909

} while (true);

5910

}

5911

5912

5913

/**

5914

Find a good, possibly optimal, query execution plan (QEP) by a possibly

5915

exhaustive search.

5916

5917

The procedure searches for the optimal ordering of the query tables in set

5918

'remaining_tables' of size N, and the corresponding optimal access paths to

5919

each table. The choice of a table order and an access path for each table

5920

constitutes a query execution plan (QEP) that fully specifies how to

5921

execute the query.

5922

5923

The maximal size of the found plan is controlled by the parameter

5924

'search_depth'. When search_depth == N, the resulting plan is complete and

5925

can be used directly as a QEP. If search_depth < N, the found plan consists

5926

of only some of the query tables. Such "partial" optimal plans are useful

5927

only as input to query optimization procedures, and cannot be used directly

5928

to execute a query.

5929

5930

The algorithm begins with an empty partial plan stored in 'join->positions'

5931

and a set of N tables - 'remaining_tables'. Each step of the algorithm

5932

evaluates the cost of the partial plan extended by all access plans for

5933

each of the relations in 'remaining_tables', expands the current partial

5934

plan with the access plan that results in lowest cost of the expanded

5935

partial plan, and removes the corresponding relation from

5936

'remaining_tables'. The algorithm continues until it either constructs a

5937

complete optimal plan, or constructs an optimal plartial plan with size =

5938

search_depth.

5939

5940

The final optimal plan is stored in 'join->best_positions'. The

5941

corresponding cost of the optimal plan is in 'join->best_read'.

5942

5943

@note

5944

The procedure uses a recursive depth-first search where the depth of the

5945

recursion (and thus the exhaustiveness of the search) is controlled by the

5946

parameter 'search_depth'.

5947

5948

@note

5949

The pseudocode below describes the algorithm of

5950

'best_extension_by_limited_search'. The worst-case complexity of this

5951

algorithm is O(N*N^search_depth/search_depth). When serch_depth >= N, then

5952

the complexity of greedy_search is O(N!).

5953

5954

@code

5955

procedure best_extension_by_limited_search(

5956

pplan in, // in, partial plan of tables-joined-so-far

5957

pplan_cost, // in, cost of pplan

5958

remaining_tables, // in, set of tables not referenced in pplan

5959

best_plan_so_far, // in/out, best plan found so far

5960

best_plan_so_far_cost,// in/out, cost of best_plan_so_far

5961

search_depth) // in, maximum size of the plans being considered

5962

{

5963

for each table T from remaining_tables

5964

{

5965

// Calculate the cost of using table T as above

5966

cost = complex-series-of-calculations;

5967

5968

// Add the cost to the cost so far.

5969

pplan_cost+= cost;

5970

5971

if (pplan_cost >= best_plan_so_far_cost)

5972

// pplan_cost already too great, stop search

5973

continue;

5974

5975

pplan= expand pplan by best_access_method;

5976

remaining_tables= remaining_tables - table T;

5977

if (remaining_tables is not an empty set

5978

and

5979

search_depth > 1)

5980

{

5981

best_extension_by_limited_search(pplan, pplan_cost,

5982

remaining_tables,

5983

best_plan_so_far,

5984

best_plan_so_far_cost,

5985

search_depth - 1);

5986

}

5987

else

5988

{

5989

best_plan_so_far_cost= pplan_cost;

5990

best_plan_so_far= pplan;

5991

}

5992

}

5993

}

5994

@endcode

5995

5996

@note

5997

When 'best_extension_by_limited_search' is called for the first time,

5998

'join->best_read' must be set to the largest possible value (e.g. DBL_MAX).

5999

The actual implementation provides a way to optionally use pruning

6000

heuristic (controlled by the parameter 'prune_level') to reduce the search

6001

space by skipping some partial plans.

6002

6003

@note

6004

The parameter 'search_depth' provides control over the recursion

6005

depth, and thus the size of the resulting optimal plan.

6006

6007

@param join pointer to the structure providing all context info

6008

for the query

6009

@param remaining_tables set of tables not included into the partial plan yet

6010

@param idx length of the partial QEP in 'join->positions';

6011

since a depth-first search is used, also corresponds

6012

to the current depth of the search tree;

6013

also an index in the array 'join->best_ref';

6014

@param record_count estimate for the number of records returned by the

6015

best partial plan

6016

@param read_time the cost of the best partial plan

6017

@param search_depth maximum depth of the recursion and thus size of the

6018

found optimal plan

6019

(0 < search_depth <= join->tables+1).

6020

@param prune_level pruning heuristics that should be applied during

6021

optimization

6022

(values: 0 = EXHAUSTIVE, 1 = PRUNE_BY_TIME_OR_ROWS)

6023

6024

@retval

6025

false ok

6026

@retval

6027

true Fatal error

6028

6029

6030

static bool

6031

best_extension_by_limited_search(JOIN *join,

6032

table_map remaining_tables,

6033

uint idx,

6034

double record_count,

6035

double read_time,

6036

uint search_depth,

6037

uint prune_level)

6038

{

6039

THD *thd= join->thd;

6040

if (thd->killed) // Abort

6041

return(true);

6042

6043

6044

'join' is a partial plan with lower cost than the best plan so far,

6045

so continue expanding it further with the tables in 'remaining_tables'.

6046

6047

JOIN_TAB *s;

6048

double best_record_count= DBL_MAX;

6049

double best_read_time= DBL_MAX;

6050

6051

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

6052

{

6053

table_map real_table_bit= s->table->map;

6054

if ((remaining_tables & real_table_bit) &&

6055

!(remaining_tables & s->dependent) &&

6056

(!idx || !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6057

{

6058

double current_record_count, current_read_time;

6059

advance_sj_state(remaining_tables, s);

6060

6061

6062

psergey-insideout-todo:

6063

when best_access_path() detects it could do an InsideOut scan or

6064

some other scan, have it return an insideout scan and a flag that

6065

requests to "fork" this loop iteration. (Q: how does that behave

6066

when the depth is insufficient??)

6067

6068

/* Find the best access method from 's' to the current partial plan */

6069

best_access_path(join, s, thd, remaining_tables, idx,

6070

record_count, read_time);

6071

/* Compute the cost of extending the plan with 's' */

6072

current_record_count= record_count * join->positions[idx].records_read;

6073

current_read_time= read_time + join->positions[idx].read_time;

6074

6075

/* Expand only partial plans with lower cost than the best QEP so far */

6076

if ((current_read_time +

6077

current_record_count / (double) TIME_FOR_COMPARE) >= join->best_read)

6078

{

6079

restore_prev_nj_state(s);

6080

restore_prev_sj_state(remaining_tables, s);

6081

continue;

6082

}

6083

6084

6085

Prune some less promising partial plans. This heuristic may miss

6086

the optimal QEPs, thus it results in a non-exhaustive search.

6087

6088

if (prune_level == 1)

6089

{

6090

if (best_record_count > current_record_count ||

6091

best_read_time > current_read_time ||

6092

(idx == join->const_tables && s->table == join->sort_by_table)) // 's' is the first table in the QEP

6093

{

6094

if (best_record_count >= current_record_count &&

6095

best_read_time >= current_read_time &&

6096

/* TODO: What is the reasoning behind this condition? */

6097

(!(s->key_dependent & remaining_tables) ||

6098

join->positions[idx].records_read < 2.0))

6099

{

6100

best_record_count= current_record_count;

6101

best_read_time= current_read_time;

6102

}

6103

}

6104

else

6105

{

6106

restore_prev_nj_state(s);

6107

restore_prev_sj_state(remaining_tables, s);

6108

continue;

6109

}

6110

}

6111

6112

if ( (search_depth > 1) && (remaining_tables & ~real_table_bit) )

6113

{ /* Recursively expand the current partial plan */

6114

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6115

if (best_extension_by_limited_search(join,

6116

remaining_tables & ~real_table_bit,

6117

idx + 1,

6118

current_record_count,

6119

current_read_time,

6120

search_depth - 1,

6121

prune_level))

6122

return(true);

6123

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6124

}

6125

else

6126

{ /*

6127

'join' is either the best partial QEP with 'search_depth' relations,

6128

or the best complete QEP so far, whichever is smaller.

6129

6130

current_read_time+= current_record_count / (double) TIME_FOR_COMPARE;

6131

if (join->sort_by_table &&

6132

join->sort_by_table !=

6133

join->positions[join->const_tables].table->table)

6134

/* We have to make a temp table */

6135

current_read_time+= current_record_count;

6136

if ((search_depth == 1) || (current_read_time < join->best_read))

6137

{

6138

memcpy(join->best_positions, join->positions,

6139

sizeof(POSITION) * (idx + 1));

6140

join->best_read= current_read_time - 0.001;

6141

}

6142

}

6143

restore_prev_nj_state(s);

6144

restore_prev_sj_state(remaining_tables, s);

6145

}

6146

}

6147

return(false);

6148

}

6149

6150

6151

/**

6152

@todo

6153

- TODO: this function is here only temporarily until 'greedy_search' is

6154

tested and accepted.

6155

6156

RETURN VALUES

6157

false ok

6158

true Fatal error

6159

6160

static bool

6161

find_best(JOIN *join,table_map rest_tables,uint idx,double record_count,

6162

double read_time)

6163

{

6164

THD *thd= join->thd;

6165

if (thd->killed)

6166

return(true);

6167

if (!rest_tables)

6168

{

6169

read_time+=record_count/(double) TIME_FOR_COMPARE;

6170

if (join->sort_by_table &&

6171

join->sort_by_table !=

6172

join->positions[join->const_tables].table->table)

6173

read_time+=record_count; // We have to make a temp table

6174

if (read_time < join->best_read)

6175

{

6176

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

6177

join->best_read= read_time - 0.001;

6178

}

6179

return(false);

6180

}

6181

if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)

6182

return(false); /* Found better before */

6183

6184

JOIN_TAB *s;

6185

double best_record_count=DBL_MAX,best_read_time=DBL_MAX;

6186

for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)

6187

{

6188

table_map real_table_bit=s->table->map;

6189

if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent) &&

6190

(!idx|| !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6191

{

6192

double records, best;

6193

advance_sj_state(rest_tables, s);

6194

best_access_path(join, s, thd, rest_tables, idx, record_count,

6195

read_time);

6196

records= join->positions[idx].records_read;

6197

best= join->positions[idx].read_time;

6198

6199

Go to the next level only if there hasn't been a better key on

6200

this level! This will cut down the search for a lot simple cases!

6201

6202

double current_record_count=record_count*records;

6203

double current_read_time=read_time+best;

6204

if (best_record_count > current_record_count ||

6205

best_read_time > current_read_time ||

6206

(idx == join->const_tables && s->table == join->sort_by_table))

6207

{

6208

if (best_record_count >= current_record_count &&

6209

best_read_time >= current_read_time &&

6210

(!(s->key_dependent & rest_tables) || records < 2.0))

6211

{

6212

best_record_count=current_record_count;

6213

best_read_time=current_read_time;

6214

}

6215

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6216

if (find_best(join,rest_tables & ~real_table_bit,idx+1,

6217

current_record_count,current_read_time))

6218

return(true);

6219

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6220

}

6221

restore_prev_nj_state(s);

6222

restore_prev_sj_state(rest_tables, s);

6223

if (join->select_options & SELECT_STRAIGHT_JOIN)

6224

break; // Don't test all combinations

6225

}

6226

}

6227

return(false);

6228

}

6229

6230

6231

/**

845

6232

Find how much space the prevous read not const tables takes in cache.

846

6233

847

void calc_used_field_length(Session *, JoinTable *join_tab)

6234

6235

static void calc_used_field_length(THD *thd __attribute__((unused)),

6236

JOIN_TAB *join_tab)

848

6237

{

849

uint32_t null_fields,blobs,fields,rec_length;

6238

uint null_fields,blobs,fields,rec_length;

850

6239

Field **f_ptr,*field;

6240

MY_BITMAP *read_set= join_tab->table->read_set;;

851

6241

852

6242

null_fields= blobs= fields= rec_length=0;

853

for (f_ptr=join_tab->table->getFields() ; (field= *f_ptr) ; f_ptr++)

6243

for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)

854

6244

{

855

if (field->isReadSet())

6245

if (bitmap_is_set(read_set, field->field_index))

856

6246

{

857

uint32_t flags=field->flags;

6247

uint flags=field->flags;

858

6248

fields++;

859

6249

rec_length+=field->pack_length();

860

6250

if (flags & BLOB_FLAG)

861

blobs++;

6251

blobs++;

862

6252

if (!(flags & NOT_NULL_FLAG))

863

null_fields++;

6253

null_fields++;

864

6254

}

865

6255

}

866

6256

if (null_fields)

869

6259

rec_length+=sizeof(bool);

870

6260

if (blobs)

871

6261

{

872

uint32_t blob_length=(uint32_t) (join_tab->table->cursor->stats.mean_rec_length-

873

(join_tab->table->getRecordLength()- rec_length));

874

rec_length+= max((uint32_t)4,blob_length);

875

}

876

join_tab->used_fields= fields;

877

join_tab->used_fieldlength= rec_length;

878

join_tab->used_blobs= blobs;

879

}

880

881

StoredKey *get_store_key(Session *session,

882

optimizer::KeyUse *keyuse,

883

table_map used_tables,

884

KeyPartInfo *key_part,

885

unsigned char *key_buff,

886

uint32_t maybe_null)

887

{

888

Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());

889

if (! ((~used_tables) & keyuse->getUsedTables())) // if const item

890

{

891

return new store_key_const_item(session,

892

key_part->field,

893

key_buff + maybe_null,

894

maybe_null ? key_buff : 0,

895

key_part->length,

896

key_use_val);

897

}

898

else if (key_use_val->type() == Item::FIELD_ITEM ||

899

(key_use_val->type() == Item::REF_ITEM &&

900

key_use_val->ref_type() == Item_ref::OUTER_REF &&

901

(*(Item_ref**)((Item_ref*)key_use_val)->ref)->ref_type() == Item_ref::DIRECT_REF &&

902

key_use_val->real_item()->type() == Item::FIELD_ITEM))

903

{

904

return new store_key_field(session,

905

key_part->field,

906

key_buff + maybe_null,

907

maybe_null ? key_buff : 0,

908

key_part->length,

909

((Item_field*) key_use_val->real_item())->field,

910

key_use_val->full_name());

911

}

912

return new store_key_item(session,

913

key_part->field,

914

key_buff + maybe_null,

915

maybe_null ? key_buff : 0,

916

key_part->length,

917

key_use_val);

918

}

6262

uint blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-

6263

(join_tab->table->getRecordLength()- rec_length));

6264

rec_length+=(uint) max((uint)4,blob_length);

6265

}

6266

join_tab->used_fields=fields;

6267

join_tab->used_fieldlength=rec_length;

6268

join_tab->used_blobs=blobs;

6269

}

6270

6271

6272

static uint

6273

cache_record_length(JOIN *join,uint idx)

6274

{

6275

uint length=0;

6276

JOIN_TAB **pos,**end;

6277

THD *thd=join->thd;

6278

6279

for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;

6280

pos != end ;

6281

pos++)

6282

{

6283

JOIN_TAB *join_tab= *pos;

6284

if (!join_tab->used_fieldlength) /* Not calced yet */

6285

calc_used_field_length(thd, join_tab);

6286

length+=join_tab->used_fieldlength;

6287

}

6288

return length;

6289

}

6290

6291

6292

6293

Get the number of different row combinations for subset of partial join

6294

6295

SYNOPSIS

6296

prev_record_reads()

6297

join The join structure

6298

idx Number of tables in the partial join order (i.e. the

6299

partial join order is in join->positions[0..idx-1])

6300

found_ref Bitmap of tables for which we need to find # of distinct

6301

row combinations.

6302

6303

DESCRIPTION

6304

Given a partial join order (in join->positions[0..idx-1]) and a subset of

6305

tables within that join order (specified in found_ref), find out how many

6306

distinct row combinations of subset tables will be in the result of the

6307

partial join order.

6308

6309

This is used as follows: Suppose we have a table accessed with a ref-based

6310

method. The ref access depends on current rows of tables in found_ref.

6311

We want to count # of different ref accesses. We assume two ref accesses

6312

will be different if at least one of access parameters is different.

6313

Example: consider a query

6314

6315

SELECT * FROM t1, t2, t3 WHERE t1.key=c1 AND t2.key=c2 AND t3.key=t1.field

6316

6317

and a join order:

6318

t1, ref access on t1.key=c1

6319

t2, ref access on t2.key=c2

6320

t3, ref access on t3.key=t1.field

6321

6322

For t1: n_ref_scans = 1, n_distinct_ref_scans = 1

6323

For t2: n_ref_scans = records_read(t1), n_distinct_ref_scans=1

6324

For t3: n_ref_scans = records_read(t1)*records_read(t2)

6325

n_distinct_ref_scans = #records_read(t1)

6326

6327

The reason for having this function (at least the latest version of it)

6328

is that we need to account for buffering in join execution.

6329

6330

An edge-case example: if we have a non-first table in join accessed via

6331

ref(const) or ref(param) where there is a small number of different

6332

values of param, then the access will likely hit the disk cache and will

6333

not require any disk seeks.

6334

6335

The proper solution would be to assume an LRU disk cache of some size,

6336

calculate probability of cache hits, etc. For now we just count

6337

identical ref accesses as one.

6338

6339

RETURN

6340

Expected number of row combinations

6341

6342

6343

static double

6344

prev_record_reads(JOIN *join, uint idx, table_map found_ref)

6345

{

6346

double found=1.0;

6347

POSITION *pos_end= join->positions - 1;

6348

for (POSITION *pos= join->positions + idx - 1; pos != pos_end; pos--)

6349

{

6350

if (pos->table->table->map & found_ref)

6351

{

6352

found_ref|= pos->ref_depend_map;

6353

6354

For the case of "t1 LEFT JOIN t2 ON ..." where t2 is a const table

6355

with no matching row we will get position[t2].records_read==0.

6356

Actually the size of output is one null-complemented row, therefore

6357

we will use value of 1 whenever we get records_read==0.

6358

6359

Note

6360

- the above case can't occur if inner part of outer join has more

6361

than one table: table with no matches will not be marked as const.

6362

6363

- Ideally we should add 1 to records_read for every possible null-

6364

complemented row. We're not doing it because: 1. it will require

6365

non-trivial code and add overhead. 2. The value of records_read

6366

is an inprecise estimate and adding 1 (or, in the worst case,

6367

#max_nested_outer_joins=64-1) will not make it any more precise.

6368

6369

if (pos->records_read > DBL_EPSILON)

6370

found*= pos->records_read;

6371

}

6372

}

6373

return found;

6374

}

6375

919

6376

920

6377

/**

921

This function is only called for const items on fields which are keys.

922

923

@return

924

returns 1 if there was some conversion made when the field was stored.

6378

Set up join struct according to best position.

925

6379

926

bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

927

{

928

bool error;

929

Table *table= field->getTable();

930

Session *session= table->in_use;

931

ha_rows cuted_fields=session->cuted_fields;

932

933

934

we should restore old value of count_cuted_fields because

935

store_val_in_field can be called from insert_query

936

with select_insert, which make count_cuted_fields= 1

937

938

enum_check_fields old_count_cuted_fields= session->count_cuted_fields;

939

session->count_cuted_fields= check_flag;

940

error= item->save_in_field(field, 1);

941

session->count_cuted_fields= old_count_cuted_fields;

942

return error || cuted_fields != session->cuted_fields;

943

}

944

945

inline void add_cond_and_fix(Item **e1, Item *e2)

946

{

947

if (*e1)

6380

6381

static bool

6382

get_best_combination(JOIN *join)

6383

{

6384

uint i,tablenr;

6385

table_map used_tables;

6386

JOIN_TAB *join_tab,*j;

6387

KEYUSE *keyuse;

6388

uint table_count;

6389

THD *thd=join->thd;

6390

6391

table_count=join->tables;

6392

if (!(join->join_tab=join_tab=

6393

(JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))

6394

return(true);

6395

6396

join->full_join=0;

6397

6398

used_tables= OUTER_REF_TABLE_BIT; // Outer row is already read

6399

for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)

948

6400

{

949

Item *res;

950

if ((res= new Item_cond_and(*e1, e2)))

6401

Table *form;

6402

*j= *join->best_positions[tablenr].table;

6403

form=join->table[tablenr]=j->table;

6404

used_tables|= form->map;

6405

form->reginfo.join_tab=j;

6406

if (!*j->on_expr_ref)

6407

form->reginfo.not_exists_optimize=0; // Only with LEFT JOIN

6408

if (j->type == JT_CONST)

6409

continue; // Handled in make_join_stat..

6410

6411

j->ref.key = -1;

6412

j->ref.key_parts=0;

6413

6414

if (j->type == JT_SYSTEM)

6415

continue;

6416

if (j->keys.is_clear_all() || !(keyuse= join->best_positions[tablenr].key))

951

6417

{

952

*e1= res;

953

res->quick_fix_field();

6418

j->type=JT_ALL;

6419

if (tablenr != join->const_tables)

6420

join->full_join=1;

954

6421

}

6422

else if (create_ref_for_key(join, j, keyuse, used_tables))

6423

return(true); // Something went wrong

955

6424

}

956

else

957

*e1= e2;

6425

6426

for (i=0 ; i < table_count ; i++)

6427

join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;

6428

update_depend_map(join);

6429

return(0);

958

6430

}

959

6431

960

bool create_ref_for_key(Join *join,

961

JoinTable *j,

962

optimizer::KeyUse *org_keyuse,

963

table_map used_tables)

6432

6433

static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,

6434

table_map used_tables)

964

6435

{

965

optimizer::KeyUse *keyuse= org_keyuse;

966

Session *session= join->session;

967

uint32_t keyparts;

968

uint32_t length;

969

uint32_t key;

970

Table *table= NULL;

971

KeyInfo *keyinfo= NULL;

6436

KEYUSE *keyuse=org_keyuse;

6437

THD *thd= join->thd;

6438

uint keyparts,length,key;

6439

Table *table;

6440

KEY *keyinfo;

972

6441

973

6442

/* Use best key from find_best */

974

table= j->table;

975

key= keyuse->getKey();

976

keyinfo= table->key_info + key;

6443

table=j->table;

6444

key=keyuse->key;

6445

keyinfo=table->key_info+key;

977

6446

978

6447

{

979

keyparts= length= 0;

980

uint32_t found_part_ref_or_null= 0;

6448

keyparts=length=0;

6449

uint found_part_ref_or_null= 0;

981

6450

982

6451

Calculate length for the used key

983

6452

Stop if there is a missing key part or when we find second key_part

985

6454

986

6455

987

6456

{

988

if (! (~used_tables & keyuse->getUsedTables()))

6457

if (!(~used_tables & keyuse->used_tables))

989

6458

{

990

if (keyparts == keyuse->getKeypart() &&

991

! (found_part_ref_or_null & keyuse->getOptimizeFlags()))

992

{

993

keyparts++;

994

length+= keyinfo->key_part[keyuse->getKeypart()].store_length;

995

found_part_ref_or_null|= keyuse->getOptimizeFlags();

996

}

6459

if (keyparts == keyuse->keypart &&

6460

!(found_part_ref_or_null & keyuse->optimize))

6461

{

6462

keyparts++;

6463

length+= keyinfo->key_part[keyuse->keypart].store_length;

6464

found_part_ref_or_null|= keyuse->optimize;

6465

}

997

6466

}

998

6467

keyuse++;

999

} while (keyuse->getTable() == table && keyuse->getKey() == key);

6468

} while (keyuse->table == table && keyuse->key == key);

1000

6469

}

1001

6470

1002

6471

/* set up fieldref */

1004

6473

j->ref.key_parts=keyparts;

1005

6474

j->ref.key_length=length;

1006

6475

j->ref.key=(int) key;

1007

if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

1008

!(j->ref.key_copy= (StoredKey**) session->getMemRoot()->allocate((sizeof(StoredKey*) *

1009

(keyparts+1)))) ||

1010

!(j->ref.items= (Item**) session->getMemRoot()->allocate(sizeof(Item*)*keyparts)) ||

1011

!(j->ref.cond_guards= (bool**) session->getMemRoot()->allocate(sizeof(uint*)*keyparts)))

6476

if (!(j->ref.key_buff= (uchar*) thd->calloc(ALIGN_SIZE(length)*2)) ||

6477

!(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *

6478

(keyparts+1)))) ||

6479

!(j->ref.items= (Item**) thd->alloc(sizeof(Item*)*keyparts)) ||

6480

!(j->ref.cond_guards= (bool**) thd->alloc(sizeof(uint*)*keyparts)))

1012

6481

{

1013

6482

return(true);

1014

6483

}

1018

6487

j->ref.disable_cache= false;

1019

6488

keyuse=org_keyuse;

1020

6489

1021

StoredKey **ref_key= j->ref.key_copy;

1022

unsigned char *key_buff= j->ref.key_buff, *null_ref_key= 0;

6490

store_key **ref_key= j->ref.key_copy;

6491

uchar *key_buff=j->ref.key_buff, *null_ref_key= 0;

1023

6492

bool keyuse_uses_no_tables= true;

1024

6493

{

1025

for (uint32_t i= 0; i < keyparts; keyuse++, i++)

6494

uint i;

6495

for (i=0 ; i < keyparts ; keyuse++,i++)

1026

6496

{

1027

while (keyuse->getKeypart() != i ||

1028

((~used_tables) & keyuse->getUsedTables()))

1029

keyuse++; /* Skip other parts */

6497

while (keyuse->keypart != i ||

6498

((~used_tables) & keyuse->used_tables))

6499

keyuse++; /* Skip other parts */

1030

6500

1031

uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);

1032

j->ref.items[i]= keyuse->getVal(); // Save for cond removal

1033

j->ref.cond_guards[i]= keyuse->getConditionalGuard();

1034

if (keyuse->isNullRejected())

6501

uint maybe_null= test(keyinfo->key_part[i].null_bit);

6502

j->ref.items[i]=keyuse->val; // Save for cond removal

6503

j->ref.cond_guards[i]= keyuse->cond_guard;

6504

if (keyuse->null_rejecting)

1035

6505

j->ref.null_rejecting |= 1 << i;

1036

keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();

1037

if (! keyuse->getUsedTables() && !(join->select_options & SELECT_DESCRIBE))

1038

{ // Compare against constant

1039

store_key_item tmp(session, keyinfo->key_part[i].field,

6506

keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;

6507

if (!keyuse->used_tables &&

6508

!(join->select_options & SELECT_DESCRIBE))

6509

{ // Compare against constant

6510

store_key_item tmp(thd, keyinfo->key_part[i].field,

1040

6511

key_buff + maybe_null,

1041

6512

maybe_null ? key_buff : 0,

1042

keyinfo->key_part[i].length, keyuse->getVal());

1043

if (session->is_fatal_error)

1044

return(true);

1045

tmp.copy();

6513

keyinfo->key_part[i].length, keyuse->val);

6514

if (thd->is_fatal_error)

6515

return(true);

6516

tmp.copy();

1046

6517

}

1047

6518

else

1048

*ref_key++= get_store_key(session,

1049

keyuse,join->const_table_map,

1050

&keyinfo->key_part[i],

1051

key_buff, maybe_null);

6519

*ref_key++= get_store_key(thd,

6520

keyuse,join->const_table_map,

6521

&keyinfo->key_part[i],

6522

key_buff, maybe_null);

1052

6523

1053

Remember if we are going to use REF_OR_NULL

1054

But only if field _really_ can be null i.e. we force AM_REF

1055

instead of AM_REF_OR_NULL in case if field can't be null

6524

Remember if we are going to use REF_OR_NULL

6525

But only if field _really_ can be null i.e. we force JT_REF

6526

instead of JT_REF_OR_NULL in case if field can't be null

1056

6527

1057

if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

1058

null_ref_key= key_buff;

6528

if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

6529

null_ref_key= key_buff;

1059

6530

key_buff+=keyinfo->key_part[i].store_length;

1060

6531

}

1061

6532

}

1062

*ref_key= 0; // end_marker

1063

if (j->type == AM_CONST)

6533

*ref_key=0; // end_marker

6534

if (j->type == JT_CONST)

1064

6535

j->table->const_table= 1;

1065

6536

else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||

1066

6537

keyparts != keyinfo->key_parts || null_ref_key)

1067

6538

{

1068

6539

/* Must read with repeat */

1069

j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;

6540

j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;

1070

6541

j->ref.null_ref_key= null_ref_key;

1071

6542

}

1072

6543

else if (keyuse_uses_no_tables)

1078

6549

Here we should not mark the table as a 'const' as a field may

1079

6550

have a 'normal' value or a NULL value.

1080

6551

1081

j->type= AM_CONST;

1082

}

1083

else

1084

j->type= AM_EQ_REF;

1085

return 0;

1086

}

6552

j->type=JT_CONST;

6553

}

6554

else

6555

j->type=JT_EQ_REF;

6556

return(0);

6557

}

6558

6559

6560

6561

static store_key *

6562

get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,

6563

KEY_PART_INFO *key_part, uchar *key_buff, uint maybe_null)

6564

{

6565

if (!((~used_tables) & keyuse->used_tables)) // if const item

6566

{

6567

return new store_key_const_item(thd,

6568

key_part->field,

6569

key_buff + maybe_null,

6570

maybe_null ? key_buff : 0,

6571

key_part->length,

6572

keyuse->val);

6573

}

6574

else if (keyuse->val->type() == Item::FIELD_ITEM ||

6575

(keyuse->val->type() == Item::REF_ITEM &&

6576

((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&

6577

(*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==

6578

Item_ref::DIRECT_REF &&

6579

keyuse->val->real_item()->type() == Item::FIELD_ITEM))

6580

return new store_key_field(thd,

6581

key_part->field,

6582

key_buff + maybe_null,

6583

maybe_null ? key_buff : 0,

6584

key_part->length,

6585

((Item_field*) keyuse->val->real_item())->field,

6586

keyuse->val->full_name());

6587

return new store_key_item(thd,

6588

key_part->field,

6589

key_buff + maybe_null,

6590

maybe_null ? key_buff : 0,

6591

key_part->length,

6592

keyuse->val);

6593

}

6594

6595

/**

6596

This function is only called for const items on fields which are keys.

6597

6598

@return

6599

returns 1 if there was some conversion made when the field was stored.

6600

6601

6602

bool

6603

store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

6604

{

6605

bool error;

6606

Table *table= field->table;

6607

THD *thd= table->in_use;

6608

ha_rows cuted_fields=thd->cuted_fields;

6609

6610

6611

we should restore old value of count_cuted_fields because

6612

store_val_in_field can be called from mysql_insert

6613

with select_insert, which make count_cuted_fields= 1

6614

6615

enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;

6616

thd->count_cuted_fields= check_flag;

6617

error= item->save_in_field(field, 1);

6618

thd->count_cuted_fields= old_count_cuted_fields;

6619

return error || cuted_fields != thd->cuted_fields;

6620

}

6621

6622

6623

static bool

6624

make_simple_join(JOIN *join,Table *tmp_table)

6625

{

6626

Table **tableptr;

6627

JOIN_TAB *join_tab;

6628

6629

6630

Reuse Table * and JOIN_TAB if already allocated by a previous call

6631

to this function through JOIN::exec (may happen for sub-queries).

6632

6633

if (!join->table_reexec)

6634

{

6635

if (!(join->table_reexec= (Table**) join->thd->alloc(sizeof(Table*))))

6636

return(true); /* purecov: inspected */

6637

if (join->tmp_join)

6638

join->tmp_join->table_reexec= join->table_reexec;

6639

}

6640

if (!join->join_tab_reexec)

6641

{

6642

if (!(join->join_tab_reexec=

6643

(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))

6644

return(true); /* purecov: inspected */

6645

if (join->tmp_join)

6646

join->tmp_join->join_tab_reexec= join->join_tab_reexec;

6647

}

6648

tableptr= join->table_reexec;

6649

join_tab= join->join_tab_reexec;

6650

6651

join->join_tab=join_tab;

6652

join->table=tableptr; tableptr[0]=tmp_table;

6653

join->tables=1;

6654

join->const_tables=0;

6655

join->const_table_map=0;

6656

join->tmp_table_param.field_count= join->tmp_table_param.sum_func_count=

6657

join->tmp_table_param.func_count=0;

6658

join->tmp_table_param.copy_field=join->tmp_table_param.copy_field_end=0;

6659

join->first_record=join->sort_and_group=0;

6660

join->send_records=(ha_rows) 0;

6661

join->group=0;

6662

join->row_limit=join->unit->select_limit_cnt;

6663

join->do_send_rows = (join->row_limit) ? 1 : 0;

6664

6665

join_tab->cache.buff=0; /* No caching */

6666

join_tab->table=tmp_table;

6667

join_tab->select=0;

6668

join_tab->select_cond=0;

6669

join_tab->quick=0;

6670

join_tab->type= JT_ALL; /* Map through all records */

6671

join_tab->keys.init();

6672

join_tab->keys.set_all(); /* test everything in quick */

6673

join_tab->info=0;

6674

join_tab->on_expr_ref=0;

6675

join_tab->last_inner= 0;

6676

join_tab->first_unmatched= 0;

6677

join_tab->ref.key = -1;

6678

join_tab->not_used_in_distinct=0;

6679

join_tab->read_first_record= join_init_read_record;

6680

join_tab->join=join;

6681

join_tab->ref.key_parts= 0;

6682

join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;

6683

join_tab->do_firstmatch= NULL;

6684

memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));

6685

tmp_table->status=0;

6686

tmp_table->null_row=0;

6687

return(false);

6688

}

6689

6690

6691

inline void add_cond_and_fix(Item **e1, Item *e2)

6692

{

6693

if (*e1)

6694

{

6695

Item *res;

6696

if ((res= new Item_cond_and(*e1, e2)))

6697

{

6698

*e1= res;

6699

res->quick_fix_field();

6700

}

6701

}

6702

else

6703

*e1= e2;

6704

}

6705

1087

6706

1088

6707

/**

1089

6708

Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions

1098

6717

add "t1.field IS NOT NULL" to t1's table condition. @n

1099

6718

1100

6719

Description of the optimization:

1101

6720

1102

6721

We look through equalities choosen to perform ref/eq_ref access,

1103

6722

pick equalities that have form "tbl.part_of_key = othertbl.field"

1104

6723

(where othertbl is a non-const table and othertbl.field may be NULL)

1126

6745

This optimization doesn't affect the choices that ref, range, or join

1127

6746

optimizer make. This was intentional because this was added after 4.1

1128

6747

was GA.

1129

6748

1130

6749

Implementation overview

1131

6750

1. update_ref_and_keys() accumulates info about null-rejecting

1132

predicates in in KeyField::null_rejecting

1133

1.1 add_key_part saves these to KeyUse.

1134

2. create_ref_for_key copies them to table_reference_st.

6751

predicates in in KEY_FIELD::null_rejecting

6752

1.1 add_key_part saves these to KEYUSE.

6753

2. create_ref_for_key copies them to TABLE_REF.

1135

6754

3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of

1136

appropiate JoinTable members.

6755

appropiate JOIN_TAB members.

1137

6756

1138

void add_not_null_conds(Join *join)

6757

6758

static void add_not_null_conds(JOIN *join)

1139

6759

{

1140

for (uint32_t i= join->const_tables; i < join->tables; i++)

6760

for (uint i=join->const_tables ; i < join->tables ; i++)

1141

6761

{

1142

JoinTable *tab=join->join_tab+i;

1143

if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||

1144

tab->type == AM_REF_OR_NULL) &&

6762

JOIN_TAB *tab=join->join_tab+i;

6763

if ((tab->type == JT_REF || tab->type == JT_EQ_REF ||

6764

tab->type == JT_REF_OR_NULL) &&

1145

6765

!tab->table->maybe_null)

1146

6766

{

1147

for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)

6767

for (uint keypart= 0; keypart < tab->ref.key_parts; keypart++)

1148

6768

{

1149

6769

if (tab->ref.null_rejecting & (1 << keypart))

1150

6770

{

1152

6772

Item *notnull;

1153

6773

assert(item->type() == Item::FIELD_ITEM);

1154

6774

Item_field *not_null_item= (Item_field*)item;

1155

JoinTable *referred_tab= not_null_item->field->getTable()->reginfo.join_tab;

6775

JOIN_TAB *referred_tab= not_null_item->field->table->reginfo.join_tab;

1156

6776

1157

6777

For UPDATE queries such as:

1158

6778

UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);

1164

6784

return;

1165

6785

1166

6786

We need to do full fix_fields() call here in order to have correct

1167

notnull->const_item(). This is needed e.g. by test_quick_select

1168

when it is called from make_join_select after this function is

6787

notnull->const_item(). This is needed e.g. by test_quick_select

6788

when it is called from make_join_select after this function is

1169

6789

called.

1170

6790

1171

if (notnull->fix_fields(join->session, &notnull))

6791

if (notnull->fix_fields(join->thd, &notnull))

1172

6792

return;

1173

6793

add_cond_and_fix(&referred_tab->select_cond, notnull);

1174

6794

}

1193

6813

- pointer to the guarded predicate, if success

1194

6814

- 0, otherwise

1195

6815

1196

COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab)

6816

6817

static COND*

6818

add_found_match_trig_cond(JOIN_TAB *tab, COND *cond, JOIN_TAB *root_tab)

1197

6819

{

1198

6820

COND *tmp;

1199

6821

assert(cond != 0);

1209

6831

return tmp;

1210

6832

}

1211

6833

6834

6835

/**

6836

Fill in outer join related info for the execution plan structure.

6837

6838

For each outer join operation left after simplification of the

6839

original query the function set up the following pointers in the linear

6840

structure join->join_tab representing the selected execution plan.

6841

The first inner table t0 for the operation is set to refer to the last

6842

inner table tk through the field t0->last_inner.

6843

Any inner table ti for the operation are set to refer to the first

6844

inner table ti->first_inner.

6845

The first inner table t0 for the operation is set to refer to the

6846

first inner table of the embedding outer join operation, if there is any,

6847

through the field t0->first_upper.

6848

The on expression for the outer join operation is attached to the

6849

corresponding first inner table through the field t0->on_expr_ref.

6850

Here ti are structures of the JOIN_TAB type.

6851

6852

EXAMPLE. For the query:

6853

@code

6854

SELECT * FROM t1

6855

LEFT JOIN

6856

(t2, t3 LEFT JOIN t4 ON t3.a=t4.a)

6857

ON (t1.a=t2.a AND t1.b=t3.b)

6858

WHERE t1.c > 5,

6859

@endcode

6860

6861

given the execution plan with the table order t1,t2,t3,t4

6862

is selected, the following references will be set;

6863

t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]

6864

t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],

6865

on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to

6866

*t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.

6867

6868

@param join reference to the info fully describing the query

6869

6870

@note

6871

The function assumes that the simplification procedure has been

6872

already applied to the join query (see simplify_joins).

6873

This function can be called only after the execution plan

6874

has been chosen.

6875

6876

6877

static void

6878

make_outerjoin_info(JOIN *join)

6879

{

6880

for (uint i=join->const_tables ; i < join->tables ; i++)

6881

{

6882

JOIN_TAB *tab=join->join_tab+i;

6883

Table *table=tab->table;

6884

TableList *tbl= table->pos_in_table_list;

6885

TableList *embedding= tbl->embedding;

6886

6887

if (tbl->outer_join)

6888

{

6889

6890

Table tab is the only one inner table for outer join.

6891

(Like table t4 for the table reference t3 LEFT JOIN t4 ON t3.a=t4.a

6892

is in the query above.)

6893

6894

tab->last_inner= tab->first_inner= tab;

6895

tab->on_expr_ref= &tbl->on_expr;

6896

tab->cond_equal= tbl->cond_equal;

6897

if (embedding)

6898

tab->first_upper= embedding->nested_join->first_nested;

6899

}

6900

for ( ; embedding ; embedding= embedding->embedding)

6901

{

6902

/* Ignore sj-nests: */

6903

if (!embedding->on_expr)

6904

continue;

6905

nested_join_st *nested_join= embedding->nested_join;

6906

if (!nested_join->counter_)

6907

{

6908

6909

Table tab is the first inner table for nested_join.

6910

Save reference to it in the nested join structure.

6911

6912

nested_join->first_nested= tab;

6913

tab->on_expr_ref= &embedding->on_expr;

6914

tab->cond_equal= tbl->cond_equal;

6915

if (embedding->embedding)

6916

tab->first_upper= embedding->embedding->nested_join->first_nested;

6917

}

6918

if (!tab->first_inner)

6919

tab->first_inner= nested_join->first_nested;

6920

if (++nested_join->counter_ < nested_join->join_list.elements)

6921

break;

6922

/* Table tab is the last inner table for nested join. */

6923

nested_join->first_nested->last_inner= tab;

6924

}

6925

}

6926

return;

6927

}

6928

6929

6930

static bool

6931

make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)

6932

{

6933

THD *thd= join->thd;

6934

if (select)

6935

{

6936

add_not_null_conds(join);

6937

table_map used_tables;

6938

if (cond) /* Because of QUICK_GROUP_MIN_MAX_SELECT */

6939

{ /* there may be a select without a cond. */

6940

if (join->tables > 1)

6941

cond->update_used_tables(); // Tablenr may have changed

6942

if (join->const_tables == join->tables &&

6943

thd->lex->current_select->master_unit() ==

6944

&thd->lex->unit) // not upper level SELECT

6945

join->const_table_map|=RAND_TABLE_BIT;

6946

{ // Check const tables

6947

COND *const_cond=

6948

make_cond_for_table(cond,

6949

join->const_table_map,

6950

(table_map) 0, 1);

6951

for (JOIN_TAB *tab= join->join_tab+join->const_tables;

6952

tab < join->join_tab+join->tables ; tab++)

6953

{

6954

if (*tab->on_expr_ref)

6955

{

6956

JOIN_TAB *cond_tab= tab->first_inner;

6957

COND *tmp= make_cond_for_table(*tab->on_expr_ref,

6958

join->const_table_map,

6959

( table_map) 0, 0);

6960

if (!tmp)

6961

continue;

6962

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

6963

if (!tmp)

6964

return(1);

6965

tmp->quick_fix_field();

6966

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

6967

new Item_cond_and(cond_tab->select_cond,

6968

tmp);

6969

if (!cond_tab->select_cond)

6970

return(1);

6971

cond_tab->select_cond->quick_fix_field();

6972

}

6973

}

6974

if (const_cond && !const_cond->val_int())

6975

{

6976

return(1); // Impossible const condition

6977

}

6978

}

6979

}

6980

used_tables=((select->const_tables=join->const_table_map) |

6981

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

6982

for (uint i=join->const_tables ; i < join->tables ; i++)

6983

{

6984

JOIN_TAB *tab=join->join_tab+i;

6985

6986

first_inner is the X in queries like:

6987

SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X

6988

6989

JOIN_TAB *first_inner_tab= tab->first_inner;

6990

table_map current_map= tab->table->map;

6991

bool use_quick_range=0;

6992

COND *tmp;

6993

6994

6995

Following force including random expression in last table condition.

6996

It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5

6997

6998

if (i == join->tables-1)

6999

current_map|= OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;

7000

used_tables|=current_map;

7001

7002

if (tab->type == JT_REF && tab->quick &&

7003

(uint) tab->ref.key == tab->quick->index &&

7004

tab->ref.key_length < tab->quick->max_used_key_length)

7005

{

7006

/* Range uses longer key; Use this instead of ref on key */

7007

tab->type=JT_ALL;

7008

use_quick_range=1;

7009

tab->use_quick=1;

7010

tab->ref.key= -1;

7011

tab->ref.key_parts=0; // Don't use ref key.

7012

join->best_positions[i].records_read= rows2double(tab->quick->records);

7013

7014

We will use join cache here : prevent sorting of the first

7015

table only and sort at the end.

7016

7017

if (i != join->const_tables && join->tables > join->const_tables + 1)

7018

join->full_join= 1;

7019

}

7020

7021

tmp= NULL;

7022

if (cond)

7023

tmp= make_cond_for_table(cond,used_tables,current_map, 0);

7024

if (cond && !tmp && tab->quick)

7025

{ // Outer join

7026

if (tab->type != JT_ALL)

7027

{

7028

7029

Don't use the quick method

7030

We come here in the case where we have 'key=constant' and

7031

the test is removed by make_cond_for_table()

7032

7033

delete tab->quick;

7034

tab->quick= 0;

7035

}

7036

else

7037

{

7038

7039

Hack to handle the case where we only refer to a table

7040

in the ON part of an OUTER JOIN. In this case we want the code

7041

below to check if we should use 'quick' instead.

7042

7043

tmp= new Item_int((int64_t) 1,1); // Always true

7044

}

7045

7046

}

7047

if (tmp || !cond || tab->type == JT_REF || tab->type == JT_REF_OR_NULL ||

7048

tab->type == JT_EQ_REF)

7049

{

7050

SQL_SELECT *sel= tab->select= ((SQL_SELECT*)

7051

thd->memdup((uchar*) select,

7052

sizeof(*select)));

7053

if (!sel)

7054

return(1); // End of memory

7055

7056

If tab is an inner table of an outer join operation,

7057

add a match guard to the pushed down predicate.

7058

The guard will turn the predicate on only after

7059

the first match for outer tables is encountered.

7060

7061

if (cond && tmp)

7062

{

7063

7064

Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without

7065

a cond, so neutralize the hack above.

7066

7067

if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))

7068

return(1);

7069

tab->select_cond=sel->cond=tmp;

7070

/* Push condition to storage engine if this is enabled

7071

and the condition is not guarded */

7072

tab->table->file->pushed_cond= NULL;

7073

if (thd->variables.engine_condition_pushdown)

7074

{

7075

COND *push_cond=

7076

make_cond_for_table(tmp, current_map, current_map, 0);

7077

if (push_cond)

7078

{

7079

/* Push condition to handler */

7080

if (!tab->table->file->cond_push(push_cond))

7081

tab->table->file->pushed_cond= push_cond;

7082

}

7083

}

7084

}

7085

else

7086

tab->select_cond= sel->cond= NULL;

7087

7088

sel->head=tab->table;

7089

if (tab->quick)

7090

{

7091

/* Use quick key read if it's a constant and it's not used

7092

with key reading */

7093

if (tab->needed_reg.is_clear_all() && tab->type != JT_EQ_REF

7094

&& (tab->type != JT_REF || (uint) tab->ref.key == tab->quick->index))

7095

{

7096

sel->quick=tab->quick; // Use value from get_quick_...

7097

sel->quick_keys.clear_all();

7098

sel->needed_reg.clear_all();

7099

}

7100

else

7101

{

7102

delete tab->quick;

7103

}

7104

tab->quick=0;

7105

}

7106

uint ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;

7107

if (i == join->const_tables && ref_key)

7108

{

7109

if (!tab->const_keys.is_clear_all() &&

7110

tab->table->reginfo.impossible_range)

7111

return(1);

7112

}

7113

else if (tab->type == JT_ALL && ! use_quick_range)

7114

{

7115

if (!tab->const_keys.is_clear_all() &&

7116

tab->table->reginfo.impossible_range)

7117

return(1); // Impossible range

7118

7119

We plan to scan all rows.

7120

Check again if we should use an index.

7121

We could have used an column from a previous table in

7122

the index if we are using limit and this is the first table

7123

7124

7125

if ((cond && (!tab->keys.is_subset(tab->const_keys) && i > 0)) ||

7126

(!tab->const_keys.is_clear_all() && (i == join->const_tables) && (join->unit->select_limit_cnt < join->best_positions[i].records_read) && ((join->select_options & OPTION_FOUND_ROWS) == false)))

7127

{

7128

/* Join with outer join condition */

7129

COND *orig_cond=sel->cond;

7130

sel->cond= and_conds(sel->cond, *tab->on_expr_ref);

7131

7132

7133

We can't call sel->cond->fix_fields,

7134

as it will break tab->on_expr if it's AND condition

7135

(fix_fields currently removes extra AND/OR levels).

7136

Yet attributes of the just built condition are not needed.

7137

Thus we call sel->cond->quick_fix_field for safety.

7138

7139

if (sel->cond && !sel->cond->fixed)

7140

sel->cond->quick_fix_field();

7141

7142

if (sel->test_quick_select(thd, tab->keys,

7143

used_tables & ~ current_map,

7144

(join->select_options &

7145

OPTION_FOUND_ROWS ?

7146

HA_POS_ERROR :

7147

join->unit->select_limit_cnt), 0,

7148

false) < 0)

7149

{

7150

7151

Before reporting "Impossible WHERE" for the whole query

7152

we have to check isn't it only "impossible ON" instead

7153

7154

sel->cond=orig_cond;

7155

if (!*tab->on_expr_ref ||

7156

sel->test_quick_select(thd, tab->keys,

7157

used_tables & ~ current_map,

7158

(join->select_options &

7159

OPTION_FOUND_ROWS ?

7160

HA_POS_ERROR :

7161

join->unit->select_limit_cnt),0,

7162

false) < 0)

7163

return(1); // Impossible WHERE

7164

}

7165

else

7166

sel->cond=orig_cond;

7167

7168

/* Fix for EXPLAIN */

7169

if (sel->quick)

7170

join->best_positions[i].records_read= (double)sel->quick->records;

7171

}

7172

else

7173

{

7174

sel->needed_reg=tab->needed_reg;

7175

sel->quick_keys.clear_all();

7176

}

7177

if (!sel->quick_keys.is_subset(tab->checked_keys) ||

7178

!sel->needed_reg.is_subset(tab->checked_keys))

7179

{

7180

tab->keys=sel->quick_keys;

7181

tab->keys.merge(sel->needed_reg);

7182

tab->use_quick= (!sel->needed_reg.is_clear_all() &&

7183

(select->quick_keys.is_clear_all() ||

7184

(select->quick &&

7185

(select->quick->records >= 100L)))) ?

7186

2 : 1;

7187

sel->read_tables= used_tables & ~current_map;

7188

}

7189

if (i != join->const_tables && tab->use_quick != 2)

7190

{ /* Read with cache */

7191

if (cond &&

7192

(tmp=make_cond_for_table(cond,

7193

join->const_table_map |

7194

current_map,

7195

current_map, 0)))

7196

{

7197

tab->cache.select=(SQL_SELECT*)

7198

thd->memdup((uchar*) sel, sizeof(SQL_SELECT));

7199

tab->cache.select->cond=tmp;

7200

tab->cache.select->read_tables=join->const_table_map;

7201

}

7202

}

7203

}

7204

}

7205

7206

7207

Push down conditions from all on expressions.

7208

Each of these conditions are guarded by a variable

7209

that turns if off just before null complemented row for

7210

outer joins is formed. Thus, the condition from an

7211

'on expression' are guaranteed not to be checked for

7212

the null complemented row.

7213

7214

7215

/* First push down constant conditions from on expressions */

7216

for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;

7217

join_tab < join->join_tab+join->tables ; join_tab++)

7218

{

7219

if (*join_tab->on_expr_ref)

7220

{

7221

JOIN_TAB *cond_tab= join_tab->first_inner;

7222

COND *tmp= make_cond_for_table(*join_tab->on_expr_ref,

7223

join->const_table_map,

7224

(table_map) 0, 0);

7225

if (!tmp)

7226

continue;

7227

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

7228

if (!tmp)

7229

return(1);

7230

tmp->quick_fix_field();

7231

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

7232

new Item_cond_and(cond_tab->select_cond,tmp);

7233

if (!cond_tab->select_cond)

7234

return(1);

7235

cond_tab->select_cond->quick_fix_field();

7236

}

7237

}

7238

7239

/* Push down non-constant conditions from on expressions */

7240

JOIN_TAB *last_tab= tab;

7241

while (first_inner_tab && first_inner_tab->last_inner == last_tab)

7242

{

7243

7244

Table tab is the last inner table of an outer join.

7245

An on expression is always attached to it.

7246

7247

COND *on_expr= *first_inner_tab->on_expr_ref;

7248

7249

table_map used_tables2= (join->const_table_map |

7250

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

7251

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

7252

{

7253

current_map= tab->table->map;

7254

used_tables2|= current_map;

7255

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

7256

current_map, 0);

7257

if (tmp_cond)

7258

{

7259

JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

7260

7261

First add the guards for match variables of

7262

all embedding outer join operations.

7263

7264

if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,

7265

tmp_cond,

7266

first_inner_tab)))

7267

return(1);

7268

7269

Now add the guard turning the predicate off for

7270

the null complemented row.

7271

7272

tmp_cond= new Item_func_trig_cond(tmp_cond,

7273

&first_inner_tab->

7274

not_null_compl);

7275

if (tmp_cond)

7276

tmp_cond->quick_fix_field();

7277

/* Add the predicate to other pushed down predicates */

7278

cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :

7279

new Item_cond_and(cond_tab->select_cond,

7280

tmp_cond);

7281

if (!cond_tab->select_cond)

7282

return(1);

7283

cond_tab->select_cond->quick_fix_field();

7284

}

7285

}

7286

first_inner_tab= first_inner_tab->first_upper;

7287

}

7288

}

7289

}

7290

return(0);

7291

}

7292

7293

7294

7295

Check if given expression uses only table fields covered by the given index

7296

7297

SYNOPSIS

7298

uses_index_fields_only()

7299

item Expression to check

7300

tbl The table having the index

7301

keyno The index number

7302

other_tbls_ok true <=> Fields of other non-const tables are allowed

7303

7304

DESCRIPTION

7305

Check if given expression only uses fields covered by index #keyno in the

7306

table tbl. The expression can use any fields in any other tables.

7307

7308

The expression is guaranteed not to be AND or OR - those constructs are

7309

handled outside of this function.

7310

7311

RETURN

7312

true Yes

7313

false No

7314

7315

7316

bool uses_index_fields_only(Item *item, Table *tbl, uint keyno,

7317

bool other_tbls_ok)

7318

{

7319

if (item->const_item())

7320

return true;

7321

7322

7323

Don't push down the triggered conditions. Nested outer joins execution

7324

code may need to evaluate a condition several times (both triggered and

7325

untriggered), and there is no way to put thi

7326

TODO: Consider cloning the triggered condition and using the copies for:

7327

1. push the first copy down, to have most restrictive index condition

7328

possible

7329

2. Put the second copy into tab->select_cond.

7330

7331

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

7332

((Item_func*)item)->functype() == Item_func::TRIG_COND_FUNC)

7333

return false;

7334

7335

if (!(item->used_tables() & tbl->map))

7336

return other_tbls_ok;

7337

7338

Item::Type item_type= item->type();

7339

switch (item_type) {

7340

case Item::FUNC_ITEM:

7341

{

7342

/* This is a function, apply condition recursively to arguments */

7343

Item_func *item_func= (Item_func*)item;

7344

Item **child;

7345

Item **item_end= (item_func->arguments()) + item_func->argument_count();

7346

for (child= item_func->arguments(); child != item_end; child++)

7347

{

7348

if (!uses_index_fields_only(*child, tbl, keyno, other_tbls_ok))

7349

return false;

7350

}

7351

return true;

7352

}

7353

case Item::COND_ITEM:

7354

{

7355

/* This is a function, apply condition recursively to arguments */

7356

List_iterator<Item> li(*((Item_cond*)item)->argument_list());

7357

Item *item;

7358

while ((item=li++))

7359

{

7360

if (!uses_index_fields_only(item, tbl, keyno, other_tbls_ok))

7361

return false;

7362

}

7363

return true;

7364

}

7365

case Item::FIELD_ITEM:

7366

{

7367

Item_field *item_field= (Item_field*)item;

7368

if (item_field->field->table != tbl)

7369

return true;

7370

return item_field->field->part_of_key.is_set(keyno);

7371

}

7372

case Item::REF_ITEM:

7373

return uses_index_fields_only(item->real_item(), tbl, keyno,

7374

other_tbls_ok);

7375

default:

7376

return false; /* Play it safe, don't push unknown non-const items */

7377

}

7378

}

7379

7380

1212

7381

#define ICP_COND_USES_INDEX_ONLY 10

1213

7382

1214

1215

/**

1216

cleanup JoinTable.

1217

1218

void JoinTable::cleanup()

7383

7384

Get a part of the condition that can be checked using only index fields

7385

7386

SYNOPSIS

7387

make_cond_for_index()

7388

cond The source condition

7389

table The table that is partially available

7390

keyno The index in the above table. Only fields covered by the index

7391

are available

7392

other_tbls_ok true <=> Fields of other non-const tables are allowed

7393

7394

DESCRIPTION

7395

Get a part of the condition that can be checked when for the given table

7396

we have values only of fields covered by some index. The condition may

7397

refer to other tables, it is assumed that we have values of all of their

7398

fields.

7399

7400

Example:

7401

make_cond_for_index(

7402

"cond(t1.field) AND cond(t2.key1) AND cond(t2.non_key) AND cond(t2.key2)",

7403

t2, keyno(t2.key1))

7404

will return

7405

"cond(t1.field) AND cond(t2.key2)"

7406

7407

RETURN

7408

Index condition, or NULL if no condition could be inferred.

7409

7410

7411

Item *make_cond_for_index(Item *cond, Table *table, uint keyno,

7412

bool other_tbls_ok)

7413

{

7414

if (!cond)

7415

return NULL;

7416

if (cond->type() == Item::COND_ITEM)

7417

{

7418

uint n_marked= 0;

7419

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

7420

{

7421

Item_cond_and *new_cond=new Item_cond_and;

7422

if (!new_cond)

7423

return (COND*) 0;

7424

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7425

Item *item;

7426

while ((item=li++))

7427

{

7428

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7429

if (fix)

7430

new_cond->argument_list()->push_back(fix);

7431

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7432

}

7433

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7434

cond->marker= ICP_COND_USES_INDEX_ONLY;

7435

switch (new_cond->argument_list()->elements) {

7436

case 0:

7437

return (COND*) 0;

7438

case 1:

7439

return new_cond->argument_list()->head();

7440

default:

7441

new_cond->quick_fix_field();

7442

return new_cond;

7443

}

7444

}

7445

else /* It's OR */

7446

{

7447

Item_cond_or *new_cond=new Item_cond_or;

7448

if (!new_cond)

7449

return (COND*) 0;

7450

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7451

Item *item;

7452

while ((item=li++))

7453

{

7454

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7455

if (!fix)

7456

return (COND*) 0;

7457

new_cond->argument_list()->push_back(fix);

7458

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7459

}

7460

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7461

cond->marker= ICP_COND_USES_INDEX_ONLY;

7462

new_cond->quick_fix_field();

7463

new_cond->top_level_item();

7464

return new_cond;

7465

}

7466

}

7467

7468

if (!uses_index_fields_only(cond, table, keyno, other_tbls_ok))

7469

return (COND*) 0;

7470

cond->marker= ICP_COND_USES_INDEX_ONLY;

7471

return cond;

7472

}

7473

7474

7475

Item *make_cond_remainder(Item *cond, bool exclude_index)

7476

{

7477

if (exclude_index && cond->marker == ICP_COND_USES_INDEX_ONLY)

7478

return 0; /* Already checked */

7479

7480

if (cond->type() == Item::COND_ITEM)

7481

{

7482

table_map tbl_map= 0;

7483

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

7484

{

7485

/* Create new top level AND item */

7486

Item_cond_and *new_cond=new Item_cond_and;

7487

if (!new_cond)

7488

return (COND*) 0;

7489

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7490

Item *item;

7491

while ((item=li++))

7492

{

7493

Item *fix= make_cond_remainder(item, exclude_index);

7494

if (fix)

7495

{

7496

new_cond->argument_list()->push_back(fix);

7497

tbl_map |= fix->used_tables();

7498

}

7499

}

7500

switch (new_cond->argument_list()->elements) {

7501

case 0:

7502

return (COND*) 0;

7503

case 1:

7504

return new_cond->argument_list()->head();

7505

default:

7506

new_cond->quick_fix_field();

7507

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7508

return new_cond;

7509

}

7510

}

7511

else /* It's OR */

7512

{

7513

Item_cond_or *new_cond=new Item_cond_or;

7514

if (!new_cond)

7515

return (COND*) 0;

7516

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7517

Item *item;

7518

while ((item=li++))

7519

{

7520

Item *fix= make_cond_remainder(item, false);

7521

if (!fix)

7522

return (COND*) 0;

7523

new_cond->argument_list()->push_back(fix);

7524

tbl_map |= fix->used_tables();

7525

}

7526

new_cond->quick_fix_field();

7527

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7528

new_cond->top_level_item();

7529

return new_cond;

7530

}

7531

}

7532

return cond;

7533

}

7534

7535

7536

7537

Try to extract and push the index condition

7538

7539

SYNOPSIS

7540

push_index_cond()

7541

tab A join tab that has tab->table->file and its condition

7542

in tab->select_cond

7543

keyno Index for which extract and push the condition

7544

other_tbls_ok true <=> Fields of other non-const tables are allowed

7545

7546

DESCRIPTION

7547

Try to extract and push the index condition down to table handler

7548

7549

7550

static void push_index_cond(JOIN_TAB *tab, uint keyno, bool other_tbls_ok)

7551

{

7552

Item *idx_cond;

7553

if (tab->table->file->index_flags(keyno, 0, 1) & HA_DO_INDEX_COND_PUSHDOWN &&

7554

tab->join->thd->variables.engine_condition_pushdown)

7555

{

7556

idx_cond= make_cond_for_index(tab->select_cond, tab->table, keyno,

7557

other_tbls_ok);

7558

7559

if (idx_cond)

7560

{

7561

tab->pre_idx_push_select_cond= tab->select_cond;

7562

Item *idx_remainder_cond=

7563

tab->table->file->idx_cond_push(keyno, idx_cond);

7564

7565

7566

Disable eq_ref's "lookup cache" if we've pushed down an index

7567

condition.

7568

TODO: This check happens to work on current ICP implementations, but

7569

there may exist a compliant implementation that will not work

7570

correctly with it. Sort this out when we stabilize the condition

7571

pushdown APIs.

7572

7573

if (idx_remainder_cond != idx_cond)

7574

tab->ref.disable_cache= true;

7575

7576

Item *row_cond= make_cond_remainder(tab->select_cond, true);

7577

7578

if (row_cond)

7579

{

7580

if (!idx_remainder_cond)

7581

tab->select_cond= row_cond;

7582

else

7583

{

7584

tab->select_cond= new Item_cond_and(row_cond, idx_remainder_cond);

7585

tab->select_cond->quick_fix_field();

7586

((Item_cond_and*)tab->select_cond)->used_tables_cache=

7587

row_cond->used_tables() | idx_remainder_cond->used_tables();

7588

}

7589

}

7590

else

7591

tab->select_cond= idx_remainder_cond;

7592

if (tab->select)

7593

{

7594

tab->select->cond= tab->select_cond;

7595

}

7596

}

7597

}

7598

return;

7599

}

7600

7601

7602

7603

7604

Determine if the set is already ordered for order_st BY, so it can

7605

disable join cache because it will change the ordering of the results.

7606

Code handles sort table that is at any location (not only first after

7607

the const tables) despite the fact that it's currently prohibited.

7608

We must disable join cache if the first non-const table alone is

7609

ordered. If there is a temp table the ordering is done as a last

7610

operation and doesn't prevent join cache usage.

7611

7612

uint make_join_orderinfo(JOIN *join)

7613

{

7614

uint i;

7615

if (join->need_tmp)

7616

return join->tables;

7617

7618

for (i=join->const_tables ; i < join->tables ; i++)

7619

{

7620

JOIN_TAB *tab=join->join_tab+i;

7621

Table *table=tab->table;

7622

if ((table == join->sort_by_table &&

7623

(!join->order || join->skip_sort_order)) ||

7624

(join->sort_by_table == (Table *) 1 && i != join->const_tables))

7625

{

7626

break;

7627

}

7628

}

7629

return i;

7630

}

7631

7632

7633

7634

Plan refinement stage: do various set ups for the executioner

7635

7636

SYNOPSIS

7637

make_join_readinfo()

7638

join Join being processed

7639

options Join's options (checking for SELECT_DESCRIBE,

7640

SELECT_NO_JOIN_CACHE)

7641

no_jbuf_after Don't use join buffering after table with this number.

7642

7643

DESCRIPTION

7644

Plan refinement stage: do various set ups for the executioner

7645

- set up use of join buffering

7646

- push index conditions

7647

- increment counters

7648

- etc

7649

7650

RETURN

7651

false - OK

7652

true - Out of memory

7653

7654

7655

static bool

7656

make_join_readinfo(JOIN *join, uint64_t options, uint no_jbuf_after)

7657

{

7658

uint i;

7659

bool statistics= test(!(join->select_options & SELECT_DESCRIBE));

7660

bool sorted= 1;

7661

7662

for (i=join->const_tables ; i < join->tables ; i++)

7663

{

7664

JOIN_TAB *tab=join->join_tab+i;

7665

Table *table=tab->table;

7666

bool using_join_cache;

7667

tab->read_record.table= table;

7668

tab->read_record.file=table->file;

7669

tab->next_select=sub_select; /* normal select */

7670

7671

TODO: don't always instruct first table's ref/range access method to

7672

produce sorted output.

7673

7674

tab->sorted= sorted;

7675

sorted= 0; // only first must be sorted

7676

if (tab->insideout_match_tab)

7677

{

7678

if (!(tab->insideout_buf= (uchar*)join->thd->alloc(tab->table->key_info

7679

[tab->index].

7680

key_length)))

7681

return true;

7682

}

7683

switch (tab->type) {

7684

case JT_SYSTEM: // Only happens with left join

7685

table->status=STATUS_NO_RECORD;

7686

tab->read_first_record= join_read_system;

7687

tab->read_record.read_record= join_no_more_records;

7688

break;

7689

case JT_CONST: // Only happens with left join

7690

table->status=STATUS_NO_RECORD;

7691

tab->read_first_record= join_read_const;

7692

tab->read_record.read_record= join_no_more_records;

7693

if (table->covering_keys.is_set(tab->ref.key) &&

7694

!table->no_keyread)

7695

{

7696

table->key_read=1;

7697

table->file->extra(HA_EXTRA_KEYREAD);

7698

}

7699

break;

7700

case JT_EQ_REF:

7701

table->status=STATUS_NO_RECORD;

7702

if (tab->select)

7703

{

7704

delete tab->select->quick;

7705

tab->select->quick=0;

7706

}

7707

delete tab->quick;

7708

tab->quick=0;

7709

tab->read_first_record= join_read_key;

7710

tab->read_record.read_record= join_no_more_records;

7711

if (table->covering_keys.is_set(tab->ref.key) &&

7712

!table->no_keyread)

7713

{

7714

table->key_read=1;

7715

table->file->extra(HA_EXTRA_KEYREAD);

7716

}

7717

else

7718

push_index_cond(tab, tab->ref.key, true);

7719

break;

7720

case JT_REF_OR_NULL:

7721

case JT_REF:

7722

table->status=STATUS_NO_RECORD;

7723

if (tab->select)

7724

{

7725

delete tab->select->quick;

7726

tab->select->quick=0;

7727

}

7728

delete tab->quick;

7729

tab->quick=0;

7730

if (table->covering_keys.is_set(tab->ref.key) &&

7731

!table->no_keyread)

7732

{

7733

table->key_read=1;

7734

table->file->extra(HA_EXTRA_KEYREAD);

7735

}

7736

else

7737

push_index_cond(tab, tab->ref.key, true);

7738

if (tab->type == JT_REF)

7739

{

7740

tab->read_first_record= join_read_always_key;

7741

tab->read_record.read_record= tab->insideout_match_tab?

7742

join_read_next_same_diff : join_read_next_same;

7743

}

7744

else

7745

{

7746

tab->read_first_record= join_read_always_key_or_null;

7747

tab->read_record.read_record= join_read_next_same_or_null;

7748

}

7749

break;

7750

case JT_ALL:

7751

7752

If previous table use cache

7753

If the incoming data set is already sorted don't use cache.

7754

7755

table->status=STATUS_NO_RECORD;

7756

using_join_cache= false;

7757

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

7758

tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&

7759

!tab->insideout_match_tab)

7760

{

7761

if ((options & SELECT_DESCRIBE) ||

7762

!join_init_cache(join->thd,join->join_tab+join->const_tables,

7763

i-join->const_tables))

7764

{

7765

using_join_cache= true;

7766

tab[-1].next_select=sub_select_cache; /* Patch previous */

7767

}

7768

}

7769

/* These init changes read_record */

7770

if (tab->use_quick == 2)

7771

{

7772

join->thd->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

7773

tab->read_first_record= join_init_quick_read_record;

7774

if (statistics)

7775

status_var_increment(join->thd->status_var.select_range_check_count);

7776

}

7777

else

7778

{

7779

tab->read_first_record= join_init_read_record;

7780

if (i == join->const_tables)

7781

{

7782

if (tab->select && tab->select->quick)

7783

{

7784

if (statistics)

7785

status_var_increment(join->thd->status_var.select_range_count);

7786

}

7787

else

7788

{

7789

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7790

if (statistics)

7791

status_var_increment(join->thd->status_var.select_scan_count);

7792

}

7793

}

7794

else

7795

{

7796

if (tab->select && tab->select->quick)

7797

{

7798

if (statistics)

7799

status_var_increment(join->thd->status_var.select_full_range_join_count);

7800

}

7801

else

7802

{

7803

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7804

if (statistics)

7805

status_var_increment(join->thd->status_var.select_full_join_count);

7806

}

7807

}

7808

if (!table->no_keyread)

7809

{

7810

if (tab->select && tab->select->quick &&

7811

tab->select->quick->index != MAX_KEY && //not index_merge

7812

table->covering_keys.is_set(tab->select->quick->index))

7813

{

7814

table->key_read=1;

7815

table->file->extra(HA_EXTRA_KEYREAD);

7816

}

7817

else if (!table->covering_keys.is_clear_all() &&

7818

!(tab->select && tab->select->quick))

7819

{ // Only read index tree

7820

if (!tab->insideout_match_tab)

7821

{

7822

7823

See bug #26447: "Using the clustered index for a table scan

7824

is always faster than using a secondary index".

7825

7826

if (table->s->primary_key != MAX_KEY &&

7827

table->file->primary_key_is_clustered())

7828

tab->index= table->s->primary_key;

7829

else

7830

tab->index= table->find_shortest_key(&table->covering_keys);

7831

}

7832

tab->read_first_record= join_read_first;

7833

tab->type=JT_NEXT; // Read with index_first / index_next

7834

}

7835

}

7836

if (tab->select && tab->select->quick &&

7837

tab->select->quick->index != MAX_KEY && ! tab->table->key_read)

7838

push_index_cond(tab, tab->select->quick->index, !using_join_cache);

7839

}

7840

break;

7841

default:

7842

break; /* purecov: deadcode */

7843

case JT_UNKNOWN:

7844

case JT_MAYBE_REF:

7845

abort(); /* purecov: deadcode */

7846

}

7847

}

7848

join->join_tab[join->tables-1].next_select=0; /* Set by do_select */

7849

return(false);

7850

}

7851

7852

7853

/**

7854

Give error if we some tables are done with a full join.

7855

7856

This is used by multi_table_update and multi_table_delete when running

7857

in safe mode.

7858

7859

@param join Join condition

7860

7861

@retval

7862

0 ok

7863

@retval

7864

1 Error (full join used)

7865

7866

7867

bool error_if_full_join(JOIN *join)

7868

{

7869

for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;

7870

tab < end;

7871

tab++)

7872

{

7873

if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))

7874

{

7875

my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,

7876

ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));

7877

return(1);

7878

}

7879

}

7880

return(0);

7881

}

7882

7883

7884

/**

7885

cleanup JOIN_TAB.

7886

7887

7888

void JOIN_TAB::cleanup()

1219

7889

{

1220

7890

delete select;

1221

7891

select= 0;

1222

7892

delete quick;

1223

7893

quick= 0;

1224

if (cache.buff)

1225

{

1226

size_t size= cache.end - cache.buff;

1227

global_join_buffer.sub(size);

1228

free(cache.buff);

1229

}

7894

x_free(cache.buff);

1230

7895

cache.buff= 0;

1231

7896

limit= 0;

1232

7897

if (table)

1234

7899

if (table->key_read)

1235

7900

{

1236

7901

table->key_read= 0;

1237

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

7902

table->file->extra(HA_EXTRA_NO_KEYREAD);

1238

7903

}

1239

table->cursor->ha_index_or_rnd_end();

7904

table->file->ha_index_or_rnd_end();

1240

7905

1241

7906

We need to reset this for next select

1242

7907

(Tested in part_of_refkey)

1243

7908

1244

7909

table->reginfo.join_tab= 0;

1245

7910

}

1246

read_record.end_read_record();

1247

}

1248

1249

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

1250

{

1251

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

1252

{

1253

if (tables & 1 && !eq_ref_table(join, order, *tab))

1254

return 0;

1255

}

1256

return 1;

1257

}

1258

1259

/**

1260

Remove the following expressions from ORDER BY and GROUP BY:

7911

end_read_record(&read_record);

7912

}

7913

7914

7915

/**

7916

Partially cleanup JOIN after it has executed: close index or rnd read

7917

(table cursors), free quick selects.

7918

7919

This function is called in the end of execution of a JOIN, before the used

7920

tables are unlocked and closed.

7921

7922

For a join that is resolved using a temporary table, the first sweep is

7923

performed against actual tables and an intermediate result is inserted

7924

into the temprorary table.

7925

The last sweep is performed against the temporary table. Therefore,

7926

the base tables and associated buffers used to fill the temporary table

7927

are no longer needed, and this function is called to free them.

7928

7929

For a join that is performed without a temporary table, this function

7930

is called after all rows are sent, but before EOF packet is sent.

7931

7932

For a simple SELECT with no subqueries this function performs a full

7933

cleanup of the JOIN and calls mysql_unlock_read_tables to free used base

7934

tables.

7935

7936

If a JOIN is executed for a subquery or if it has a subquery, we can't

7937

do the full cleanup and need to do a partial cleanup only.

7938

- If a JOIN is not the top level join, we must not unlock the tables

7939

because the outer select may not have been evaluated yet, and we

7940

can't unlock only selected tables of a query.

7941

- Additionally, if this JOIN corresponds to a correlated subquery, we

7942

should not free quick selects and join buffers because they will be

7943

needed for the next execution of the correlated subquery.

7944

- However, if this is a JOIN for a [sub]select, which is not

7945

a correlated subquery itself, but has subqueries, we can free it

7946

fully and also free JOINs of all its subqueries. The exception

7947

is a subquery in SELECT list, e.g: @n

7948

SELECT a, (select max(b) from t1) group by c @n

7949

This subquery will not be evaluated at first sweep and its value will

7950

not be inserted into the temporary table. Instead, it's evaluated

7951

when selecting from the temporary table. Therefore, it can't be freed

7952

here even though it's not correlated.

7953

7954

@todo

7955

Unlock tables even if the join isn't top level select in the tree

7956

7957

7958

void JOIN::join_free()

7959

{

7960

SELECT_LEX_UNIT *tmp_unit;

7961

SELECT_LEX *sl;

7962

7963

Optimization: if not EXPLAIN and we are done with the JOIN,

7964

free all tables.

7965

7966

bool full= (!select_lex->uncacheable && !thd->lex->describe);

7967

bool can_unlock= full;

7968

7969

cleanup(full);

7970

7971

for (tmp_unit= select_lex->first_inner_unit();

7972

tmp_unit;

7973

tmp_unit= tmp_unit->next_unit())

7974

for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())

7975

{

7976

Item_subselect *subselect= sl->master_unit()->item;

7977

bool full_local= full && (!subselect || subselect->is_evaluated());

7978

7979

If this join is evaluated, we can fully clean it up and clean up all

7980

its underlying joins even if they are correlated -- they will not be

7981

used any more anyway.

7982

If this join is not yet evaluated, we still must clean it up to

7983

close its table cursors -- it may never get evaluated, as in case of

7984

... HAVING false OR a IN (SELECT ...))

7985

but all table cursors must be closed before the unlock.

7986

7987

sl->cleanup_all_joins(full_local);

7988

/* Can't unlock if at least one JOIN is still needed */

7989

can_unlock= can_unlock && full_local;

7990

}

7991

7992

7993

We are not using tables anymore

7994

Unlock all tables. We may be in an INSERT .... SELECT statement.

7995

7996

if (can_unlock && lock && thd->lock &&

7997

!(select_options & SELECT_NO_UNLOCK) &&

7998

!select_lex->subquery_in_having &&

7999

(select_lex == (thd->lex->unit.fake_select_lex ?

8000

thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))

8001

{

8002

8003

TODO: unlock tables even if the join isn't top level select in the

8004

tree.

8005

8006

mysql_unlock_read_tables(thd, lock); // Don't free join->lock

8007

lock= 0;

8008

}

8009

8010

return;

8011

}

8012

8013

8014

/**

8015

Free resources of given join.

8016

8017

@param fill true if we should free all resources, call with full==1

8018

should be last, before it this function can be called with

8019

full==0

8020

8021

@note

8022

With subquery this function definitely will be called several times,

8023

but even for simple query it can be called several times.

8024

8025

8026

void JOIN::cleanup(bool full)

8027

{

8028

if (table)

8029

{

8030

JOIN_TAB *tab,*end;

8031

8032

Only a sorted table may be cached. This sorted table is always the

8033

first non const table in join->table

8034

8035

if (tables > const_tables) // Test for not-const tables

8036

{

8037

free_io_cache(table[const_tables]);

8038

filesort_free_buffers(table[const_tables],full);

8039

}

8040

8041

if (full)

8042

{

8043

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8044

tab->cleanup();

8045

table= 0;

8046

}

8047

else

8048

{

8049

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8050

{

8051

if (tab->table)

8052

tab->table->file->ha_index_or_rnd_end();

8053

}

8054

}

8055

cleanup_sj_tmp_tables(this);//

8056

}

8057

8058

We are not using tables anymore

8059

Unlock all tables. We may be in an INSERT .... SELECT statement.

8060

8061

if (full)

8062

{

8063

if (tmp_join)

8064

tmp_table_param.copy_field= 0;

8065

group_fields.delete_elements();

8066

8067

We can't call delete_elements() on copy_funcs as this will cause

8068

problems in free_elements() as some of the elements are then deleted.

8069

8070

tmp_table_param.copy_funcs.empty();

8071

8072

If we have tmp_join and 'this' JOIN is not tmp_join and

8073

tmp_table_param.copy_field's of them are equal then we have to remove

8074

pointer to tmp_table_param.copy_field from tmp_join, because it qill

8075

be removed in tmp_table_param.cleanup().

8076

8077

if (tmp_join &&

8078

tmp_join != this &&

8079

tmp_join->tmp_table_param.copy_field ==

8080

tmp_table_param.copy_field)

8081

{

8082

tmp_join->tmp_table_param.copy_field=

8083

tmp_join->tmp_table_param.save_copy_field= 0;

8084

}

8085

tmp_table_param.cleanup();

8086

}

8087

return;

8088

}

8089

8090

8091

/**

8092

Remove the following expressions from order_st BY and GROUP BY:

1261

8093

Constant expressions @n

1262

8094

Expression that only uses tables that are of type EQ_REF and the reference

1263

8095

is in the order_st list or if all refereed tables are of the above type.

1264

8096

1265

8097

In the following, the X field can be removed:

1266

8098

@code

1267

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

1268

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

8099

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t1.a,t2.X

8100

SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b order_st BY t1.a,t3.X

1269

8101

@endcode

1270

8102

1271

8103

These can't be optimized:

1272

8104

@code

1273

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

1274

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

1275

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

8105

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.X,t1.a

8106

SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b order_st BY t1.a,t2.c

8107

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

1276

8108

@endcode

1277

8109

1278

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

8110

8111

static bool

8112

eq_ref_table(JOIN *join, order_st *start_order, JOIN_TAB *tab)

1279

8113

{

1280

8114

if (tab->cached_eq_ref_table) // If cached

1281

8115

return tab->eq_ref_table;

1282

8116

tab->cached_eq_ref_table=1;

1283

8117

/* We can skip const tables only if not an outer table */

1284

if (tab->type == AM_CONST && !tab->first_inner)

1285

return (tab->eq_ref_table=1);

1286

if (tab->type != AM_EQ_REF || tab->table->maybe_null)

8118

if (tab->type == JT_CONST && !tab->first_inner)

8119

return (tab->eq_ref_table=1); /* purecov: inspected */

8120

if (tab->type != JT_EQ_REF || tab->table->maybe_null)

1287

8121

return (tab->eq_ref_table=0); // We must use this

1288

8122

Item **ref_item=tab->ref.items;

1289

8123

Item **end=ref_item+tab->ref.key_parts;

1290

uint32_t found=0;

8124

uint found=0;

1291

8125

table_map map=tab->table->map;

1292

8126

1293

8127

for (; ref_item != end ; ref_item++)

1294

8128

{

1295

8129

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

1296

8130

{ // Not a const ref

1297

Order *order;

8131

order_st *order;

1298

8132

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

1299

8133

{

1300

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

1301

break;

8134

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

8135

break;

1302

8136

}

1303

8137

if (order)

1304

8138

{

1305

found++;

1306

assert(!(order->used & map));

1307

order->used|=map;

1308

continue; // Used in order_st BY

8139

found++;

8140

assert(!(order->used & map));

8141

order->used|=map;

8142

continue; // Used in order_st BY

1309

8143

}

1310

8144

if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))

1311

return (tab->eq_ref_table= 0);

8145

return (tab->eq_ref_table=0);

1312

8146

}

1313

8147

}

1314

8148

/* Check that there was no reference to table before sort order */

1320

8154

continue;

1321

8155

}

1322

8156

if (start_order->depend_map & map)

1323

return (tab->eq_ref_table= 0);

1324

}

1325

return tab->eq_ref_table= 1;

1326

}

8157

return (tab->eq_ref_table=0);

8158

}

8159

return tab->eq_ref_table=1;

8160

}

8161

8162

8163

static bool

8164

only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)

8165

{

8166

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

8167

{

8168

if (tables & 1 && !eq_ref_table(join, order, *tab))

8169

return 0;

8170

}

8171

return 1;

8172

}

8173

8174

8175

/** Update the dependency map for the tables. */

8176

8177

static void update_depend_map(JOIN *join)

8178

{

8179

JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;

8180

8181

for (; join_tab != end ; join_tab++)

8182

{

8183

TABLE_REF *ref= &join_tab->ref;

8184

table_map depend_map=0;

8185

Item **item=ref->items;

8186

uint i;

8187

for (i=0 ; i < ref->key_parts ; i++,item++)

8188

depend_map|=(*item)->used_tables();

8189

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

8190

depend_map&= ~OUTER_REF_TABLE_BIT;

8191

for (JOIN_TAB **tab=join->map2table;

8192

depend_map ;

8193

tab++,depend_map>>=1 )

8194

{

8195

if (depend_map & 1)

8196

ref->depend_map|=(*tab)->ref.depend_map;

8197

}

8198

}

8199

}

8200

8201

8202

/** Update the dependency map for the sort order. */

8203

8204

static void update_depend_map(JOIN *join, order_st *order)

8205

{

8206

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

8207

{

8208

table_map depend_map;

8209

order->item[0]->update_used_tables();

8210

order->depend_map=depend_map=order->item[0]->used_tables();

8211

// Not item_sum(), RAND() and no reference to table outside of sub select

8212

if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))

8213

&& !order->item[0]->with_sum_func)

8214

{

8215

for (JOIN_TAB **tab=join->map2table;

8216

depend_map ;

8217

tab++, depend_map>>=1)

8218

{

8219

if (depend_map & 1)

8220

order->depend_map|=(*tab)->ref.depend_map;

8221

}

8222

}

8223

}

8224

}

8225

8226

8227

/**

8228

Remove all constants and check if order_st only contains simple

8229

expressions.

8230

8231

simple_order is set to 1 if sort_order only uses fields from head table

8232

and the head table is not a LEFT JOIN table.

8233

8234

@param join Join handler

8235

@param first_order List of SORT or GROUP order

8236

@param cond WHERE statement

8237

@param change_list Set to 1 if we should remove things from list.

8238

If this is not set, then only simple_order is

8239

calculated.

8240

@param simple_order Set to 1 if we are only using simple expressions

8241

8242

@return

8243

Returns new sort order

8244

8245

8246

static order_st *

8247

remove_const(JOIN *join,order_st *first_order, COND *cond,

8248

bool change_list, bool *simple_order)

8249

{

8250

if (join->tables == join->const_tables)

8251

return change_list ? 0 : first_order; // No need to sort

8252

8253

order_st *order,**prev_ptr;

8254

table_map first_table= join->join_tab[join->const_tables].table->map;

8255

table_map not_const_tables= ~join->const_table_map;

8256

table_map ref;

8257

8258

prev_ptr= &first_order;

8259

*simple_order= *join->join_tab[join->const_tables].on_expr_ref ? 0 : 1;

8260

8261

/* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */

8262

8263

update_depend_map(join, first_order);

8264

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

8265

{

8266

table_map order_tables=order->item[0]->used_tables();

8267

if (order->item[0]->with_sum_func)

8268

*simple_order=0; // Must do a temp table to sort

8269

else if (!(order_tables & not_const_tables))

8270

{

8271

if (order->item[0]->with_subselect)

8272

order->item[0]->val_str(&order->item[0]->str_value);

8273

continue; // skip const item

8274

}

8275

else

8276

{

8277

if (order_tables & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT))

8278

*simple_order=0;

8279

else

8280

{

8281

Item *comp_item=0;

8282

if (cond && const_expression_in_where(cond,order->item[0], &comp_item))

8283

{

8284

continue;

8285

}

8286

if ((ref=order_tables & (not_const_tables ^ first_table)))

8287

{

8288

if (!(order_tables & first_table) &&

8289

only_eq_ref_tables(join,first_order, ref))

8290

{

8291

continue;

8292

}

8293

*simple_order=0; // Must do a temp table to sort

8294

}

8295

}

8296

}

8297

if (change_list)

8298

*prev_ptr= order; // use this entry

8299

prev_ptr= &order->next;

8300

}

8301

if (change_list)

8302

*prev_ptr=0;

8303

if (prev_ptr == &first_order) // Nothing to sort/group

8304

*simple_order=1;

8305

return(first_order);

8306

}

8307

8308

8309

static int

8310

return_zero_rows(JOIN *join, select_result *result,TableList *tables,

8311

List<Item> &fields, bool send_row, uint64_t select_options,

8312

const char *info, Item *having)

8313

{

8314

if (select_options & SELECT_DESCRIBE)

8315

{

8316

select_describe(join, false, false, false, info);

8317

return(0);

8318

}

8319

8320

join->join_free();

8321

8322

if (send_row)

8323

{

8324

for (TableList *table= tables; table; table= table->next_leaf)

8325

mark_as_null_row(table->table); // All fields are NULL

8326

if (having && having->val_int() == 0)

8327

send_row=0;

8328

}

8329

if (!(result->send_fields(fields,

8330

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))

8331

{

8332

if (send_row)

8333

{

8334

List_iterator_fast<Item> it(fields);

8335

Item *item;

8336

while ((item= it++))

8337

item->no_rows_in_result();

8338

result->send_data(fields);

8339

}

8340

result->send_eof(); // Should be safe

8341

}

8342

/* Update results for FOUND_ROWS */

8343

join->thd->limit_found_rows= join->thd->examined_row_count= 0;

8344

return(0);

8345

}

8346

8347

8348

used only in JOIN::clear

8349

8350

static void clear_tables(JOIN *join)

8351

{

8352

8353

must clear only the non-const tables, as const tables

8354

are not re-calculated.

8355

8356

for (uint i=join->const_tables ; i < join->tables ; i++)

8357

mark_as_null_row(join->table[i]); // All fields are NULL

8358

}

8359

8360

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

8361

Make som simple condition optimization:

8362

If there is a test 'field = const' change all refs to 'field' to 'const'

8363

Remove all dummy tests 'item = item', 'const op const'.

8364

Remove all 'item is NULL', when item can never be null!

8365

item->marker should be 0 for all items on entry

8366

Return in cond_value false if condition is impossible (1 = 2)

8367

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

8368

8369

class COND_CMP :public ilink {

8370

public:

8371

static void *operator new(size_t size)

8372

{

8373

return (void*) sql_alloc((uint) size);

8374

}

8375

static void operator delete(void *ptr __attribute__((unused)),

8376

size_t size __attribute__((unused)))

8377

{ TRASH(ptr, size); }

8378

8379

Item *and_level;

8380

Item_func *cmp_func;

8381

COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}

8382

};

8383

8384

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

8385

template class I_List<COND_CMP>;

8386

template class I_List_iterator<COND_CMP>;

8387

#endif

8388

1327

8389

1328

8390

/**

1329

8391

Find the multiple equality predicate containing a field.

1343

8405

- Item_equal for the found multiple equality predicate if a success;

1344

8406

- NULL otherwise.

1345

8407

1346

static Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field, bool *inherited_fl)

8408

8409

Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field,

8410

bool *inherited_fl)

1347

8411

{

1348

8412

Item_equal *item= 0;

1349

8413

bool in_upper_level= false;

1364

8428

return item;

1365

8429

}

1366

8430

8431

1367

8432

/**

1368

8433

Check whether an equality can be used to build multiple equalities.

1369

8434

1390

8455

the check_equality will be called for the following equality

1391

8456

predicates a=b, b=c, b=2 and f=e.

1392

8457

- For a=b it will be called with *cond_equal=(0,[]) and will transform

1393

*cond_equal into (0,[Item_equal(a,b)]).

8458

*cond_equal into (0,[Item_equal(a,b)]).

1394

8459

- For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])

1395

8460

and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).

1396

8461

- For b=2 it will be called with *cond_equal=(ptr(CE),[])

1403

8468

the Field::eq_def method) are placed to the same multiple equalities.

1404

8469

Because of this some equality predicates are not eliminated and

1405

8470

can be used in the constant propagation procedure.

1406

We could weeken the equlity test as soon as at least one of the

1407

equal fields is to be equal to a constant. It would require a

8471

We could weeken the equlity test as soon as at least one of the

8472

equal fields is to be equal to a constant. It would require a

1408

8473

more complicated implementation: we would have to store, in

1409

8474

general case, its own constant for each fields from the multiple

1410

8475

equality. But at the same time it would allow us to get rid

1422

8487

containing just field1 and field2 is added to the existing

1423

8488

multiple equalities.

1424

8489

If the function processes the predicate of the form field1=const,

1425

it looks for a multiple equality containing field1. If found, the

8490

it looks for a multiple equality containing field1. If found, the

1426

8491

function checks the constant of the multiple equality. If the value

1427

8492

is unknown, it is setup to const. Otherwise the value is compared with

1428

8493

const and the evaluation of the equality predicate is performed.

1445

8510

@retval

1446

8511

false otherwise

1447

8512

1448

static bool check_simple_equality(Item *left_item,

1449

Item *right_item,

1450

Item *item,

1451

COND_EQUAL *cond_equal)

8513

8514

static bool check_simple_equality(Item *left_item, Item *right_item,

8515

Item *item, COND_EQUAL *cond_equal)

1452

8516

{

8517

if (left_item->type() == Item::REF_ITEM &&

8518

((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)

8519

{

8520

if (((Item_ref*)left_item)->depended_from)

8521

return false;

8522

left_item= left_item->real_item();

8523

}

8524

if (right_item->type() == Item::REF_ITEM &&

8525

((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)

8526

{

8527

if (((Item_ref*)right_item)->depended_from)

8528

return false;

8529

right_item= right_item->real_item();

8530

}

1453

8531

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

1454

8532

right_item->type() == Item::FIELD_ITEM &&

1455

8533

!((Item_field*)left_item)->depended_from &&

1467

8545

bool left_copyfl, right_copyfl;

1468

8546

Item_equal *left_item_equal=

1469

8547

find_item_equal(cond_equal, left_field, &left_copyfl);

1470

Item_equal *right_item_equal=

8548

Item_equal *right_item_equal=

1471

8549

find_item_equal(cond_equal, right_field, &right_copyfl);

1472

8550

1473

8551

/* As (NULL=NULL) != true we can't just remove the predicate f=f */

1474

8552

if (left_field->eq(right_field)) /* f = f */

1475

return (!(left_field->maybe_null() && !left_item_equal));

8553

return (!(left_field->maybe_null() && !left_item_equal));

1476

8554

1477

8555

if (left_item_equal && left_item_equal == right_item_equal)

1478

8556

{

1479

8557

1480

8558

The equality predicate is inference of one of the existing

1481

8559

multiple equalities, i.e the condition is already covered

1482

8560

by upper level equalities

1483

8561

1484

8562

return true;

1485

8563

}

1486

1487

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

8564

8565

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

1488

8566

item->name < subq_sj_cond_name + 64);

1489

8567

/* Copy the found multiple equalities at the current level if needed */

1490

8568

if (left_copyfl)

1505

8583

}

1506

8584

1507

8585

if (left_item_equal)

1508

{

8586

{

1509

8587

/* left item was found in the current or one of the upper levels */

1510

8588

if (! right_item_equal)

1511

8589

left_item_equal->add((Item_field *) right_item);

1520

8598

}

1521

8599

}

1522

8600

else

1523

{

8601

{

1524

8602

/* left item was not found neither the current nor in upper levels */

1525

8603

if (right_item_equal)

1526

8604

{

1528

8606

if (copy_item_name)

1529

8607

right_item_equal->name = item->name;

1530

8608

}

1531

else

8609

else

1532

8610

{

1533

8611

/* None of the fields was found in multiple equalities */

1534

8612

Item_equal *item_equal= new Item_equal((Item_field *) left_item,

1576

8654

eq_item->set_cmp_func();

1577

8655

eq_item->quick_fix_field();

1578

8656

item= eq_item;

1579

}

8657

}

1580

8658

if ((cs != ((Item_func *) item)->compare_collation()) ||

1581

8659

!cs->coll->propagate(cs, 0, 0))

1582

8660

return false;

1591

8669

}

1592

8670

if (item_equal)

1593

8671

{

1594

8672

1595

8673

The flag cond_false will be set to 1 after this, if item_equal

1596

8674

already contains a constant and its value is not equal to

1597

8675

the value of const_item.

1609

8687

return false;

1610

8688

}

1611

8689

8690

1612

8691

/**

1613

8692

Convert row equalities into a conjunction of regular equalities.

1614

8693

1621

8700

simple equality nor a row equality the item for this predicate is added

1622

8701

to eq_list.

1623

8702

1624

@param session thread handle

8703

@param thd thread handle

1625

8704

@param left_row left term of the row equality to be processed

1626

8705

@param right_row right term of the row equality to be processed

1627

8706

@param cond_equal multiple equalities that must hold together with the

1634

8713

@retval

1635

8714

false otherwise

1636

8715

1637

static bool check_row_equality(Session *session,

1638

Item *left_row,

1639

Item_row *right_row,

1640

COND_EQUAL *cond_equal,

1641

List<Item>* eq_list)

1642

{

1643

uint32_t n= left_row->cols();

1644

for (uint32_t i= 0 ; i < n; i++)

8716

8717

static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,

8718

COND_EQUAL *cond_equal, List<Item>* eq_list)

8719

{

8720

uint n= left_row->cols();

8721

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

1645

8722

{

1646

8723

bool is_converted;

1647

8724

Item *left_item= left_row->element_index(i);

1649

8726

if (left_item->type() == Item::ROW_ITEM &&

1650

8727

right_item->type() == Item::ROW_ITEM)

1651

8728

{

1652

is_converted= check_row_equality(session,

8729

is_converted= check_row_equality(thd,

1653

8730

(Item_row *) left_item,

1654

8731

(Item_row *) right_item,

1655

8732

cond_equal, eq_list);

1656

8733

if (!is_converted)

1657

session->lex->current_select->cond_count++;

8734

thd->lex->current_select->cond_count++;

1658

8735

}

1659

8736

else

1660

{

8737

{

1661

8738

is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

1662

session->lex->current_select->cond_count++;

1663

}

1664

8739

thd->lex->current_select->cond_count++;

8740

}

8741

1665

8742

if (!is_converted)

1666

8743

{

1667

8744

Item_func_eq *eq_item;

1675

8752

return true;

1676

8753

}

1677

8754

8755

1678

8756

/**

1679

8757

Eliminate row equalities and form multiple equalities predicates.

1680

8758

1689

8767

equalities which are treated in the same way as original equality

1690

8768

predicates.

1691

8769

1692

@param session thread handle

8770

@param thd thread handle

1693

8771

@param item predicate to process

1694

8772

@param cond_equal multiple equalities that must hold together with the

1695

8773

predicate

1704

8782

or, if the equality is neither a simple one nor a row equality,

1705

8783

or, if the procedure fails by a fatal error.

1706

8784

1707

static bool check_equality(Session *session, Item *item, COND_EQUAL *cond_equal, List<Item> *eq_list)

8785

8786

static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,

8787

List<Item> *eq_list)

1708

8788

{

1709

8789

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

1710

8790

((Item_func*) item)->functype() == Item_func::EQ_FUNC)

1715

8795

if (left_item->type() == Item::ROW_ITEM &&

1716

8796

right_item->type() == Item::ROW_ITEM)

1717

8797

{

1718

session->lex->current_select->cond_count--;

1719

return check_row_equality(session,

8798

thd->lex->current_select->cond_count--;

8799

return check_row_equality(thd,

1720

8800

(Item_row *) left_item,

1721

8801

(Item_row *) right_item,

1722

8802

cond_equal, eq_list);

1723

8803

}

1724

else

8804

else

1725

8805

return check_simple_equality(left_item, right_item, item, cond_equal);

1726

}

8806

}

1727

8807

return false;

1728

8808

}

1729

8809

8810

1730

8811

/**

1731

8812

Replace all equality predicates in a condition by multiple equality items.

1732

8813

1733

8814

At each 'and' level the function detects items for equality predicates

1734

8815

and replaced them by a set of multiple equality items of class Item_equal,

1735

taking into account inherited equalities from upper levels.

8816

taking into account inherited equalities from upper levels.

1736

8817

If an equality predicate is used not in a conjunction it's just

1737

8818

replaced by a multiple equality predicate.

1738

8819

For each 'and' level the function set a pointer to the inherited

1739

8820

multiple equalities in the cond_equal field of the associated

1740

object of the type Item_cond_and.

8821

object of the type Item_cond_and.

1741

8822

The function also traverses the cond tree and and for each field reference

1742

8823

sets a pointer to the multiple equality item containing the field, if there

1743

8824

is any. If this multiple equality equates fields to a constant the

1744

function replaces the field reference by the constant in the cases

8825

function replaces the field reference by the constant in the cases

1745

8826

when the field is not of a string type or when the field reference is

1746

8827

just an argument of a comparison predicate.

1747

The function also determines the maximum number of members in

8828

The function also determines the maximum number of members in

1748

8829

equality lists of each Item_cond_and object assigning it to

1749

session->lex->current_select->max_equal_elems.

8830

thd->lex->current_select->max_equal_elems.

1750

8831

1751

8832

@note

1752

8833

Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

1758

8839

in a conjuction for a minimal set of multiple equality predicates.

1759

8840

This set can be considered as a canonical representation of the

1760

8841

sub-conjunction of the equality predicates.

1761

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

8842

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

1762

8843

(=(t1.a,t2.b,t3.c) AND t2.b>5), not by

1763

8844

(=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);

1764

8845

while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by

1769

8850

The function performs the substitution in a recursive descent by

1770

8851

the condtion tree, passing to the next AND level a chain of multiple

1771

8852

equality predicates which have been built at the upper levels.

1772

The Item_equal items built at the level are attached to other

8853

The Item_equal items built at the level are attached to other

1773

8854

non-equality conjucts as a sublist. The pointer to the inherited

1774

8855

multiple equalities is saved in the and condition object (Item_cond_and).

1775

This chain allows us for any field reference occurence easyly to find a

8856

This chain allows us for any field reference occurence easyly to find a

1776

8857

multiple equality that must be held for this occurence.

1777

8858

For each AND level we do the following:

1778

8859

- scan it for all equality predicate (=) items

1779

8860

- join them into disjoint Item_equal() groups

1780

- process the included OR conditions recursively to do the same for

1781

lower AND levels.

8861

- process the included OR conditions recursively to do the same for

8862

lower AND levels.

1782

8863

1783

8864

We need to do things in this order as lower AND levels need to know about

1784

8865

all possible Item_equal objects in upper levels.

1785

8866

1786

@param session thread handle

8867

@param thd thread handle

1787

8868

@param cond condition(expression) where to make replacement

1788

8869

@param inherited path to all inherited multiple equality items

1789

8870

1790

8871

@return

1791

8872

pointer to the transformed condition

1792

8873

1793

static COND *build_equal_items_for_cond(Session *session, COND *cond, COND_EQUAL *inherited)

8874

8875

static COND *build_equal_items_for_cond(THD *thd, COND *cond,

8876

COND_EQUAL *inherited)

1794

8877

{

1795

8878

Item_equal *item_equal;

1796

8879

COND_EQUAL cond_equal;

1802

8885

bool and_level= ((Item_cond*) cond)->functype() ==

1803

8886

Item_func::COND_AND_FUNC;

1804

8887

List<Item> *args= ((Item_cond*) cond)->argument_list();

1805

8888

1806

8889

List_iterator<Item> li(*args);

1807

8890

Item *item;

1808

8891

1811

8894

1812

8895

Retrieve all conjucts of this level detecting the equality

1813

8896

that are subject to substitution by multiple equality items and

1814

removing each such predicate from the conjunction after having

8897

removing each such predicate from the conjunction after having

1815

8898

found/created a multiple equality whose inference the predicate is.

1816

8899

1817

8900

while ((item= li++))

1818

8901

{

1819

8902

1821

8904

structure here because it's restored before each

1822

8905

re-execution of any prepared statement/stored procedure.

1823

8906

1824

if (check_equality(session, item, &cond_equal, &eq_list))

8907

if (check_equality(thd, item, &cond_equal, &eq_list))

1825

8908

li.remove();

1826

8909

}

1827

8910

1830

8913

{

1831

8914

item_equal->fix_length_and_dec();

1832

8915

item_equal->update_used_tables();

1833

set_if_bigger(session->lex->current_select->max_equal_elems,

1834

item_equal->members());

8916

set_if_bigger(thd->lex->current_select->max_equal_elems,

8917

item_equal->members());

1835

8918

}

1836

8919

1837

8920

((Item_cond_and*)cond)->cond_equal= cond_equal;

1843

8926

1844

8927

li.rewind();

1845

8928

while ((item= li++))

1846

{

8929

{

1847

8930

Item *new_item;

1848

if ((new_item= build_equal_items_for_cond(session, item, inherited)) != item)

8931

if ((new_item= build_equal_items_for_cond(thd, item, inherited)) != item)

1849

8932

{

1850

8933

/* This replacement happens only for standalone equalities */

1851

8934

1873

8956

(b=5) and (a=c) are standalone equalities.

1874

8957

In general we can't leave alone standalone eqalities:

1875

8958

for WHERE a=b AND c=d AND (b=c OR d=5)

1876

b=c is replaced by =(a,b,c,d).

8959

b=c is replaced by =(a,b,c,d).

1877

8960

1878

if (check_equality(session, cond, &cond_equal, &eq_list))

8961

if (check_equality(thd, cond, &cond_equal, &eq_list))

1879

8962

{

1880

8963

int n= cond_equal.current_level.elements + eq_list.elements;

1881

8964

if (n == 0)

1886

8969

{

1887

8970

item_equal->fix_length_and_dec();

1888

8971

item_equal->update_used_tables();

1889

}

8972

}

1890

8973

else

1891

8974

item_equal= (Item_equal *) eq_list.pop();

1892

set_if_bigger(session->lex->current_select->max_equal_elems,

1893

item_equal->members());

8975

set_if_bigger(thd->lex->current_select->max_equal_elems,

8976

item_equal->members());

1894

8977

return item_equal;

1895

8978

}

1896

8979

else

1897

8980

{

1898

8981

1899

8982

Here a new AND level must be created. It can happen only

1900

8983

when a row equality is processed as a standalone predicate.

1901

8984

1902

8985

Item_cond_and *and_cond= new Item_cond_and(eq_list);

1903

8986

and_cond->quick_fix_field();

1904

8987

List<Item> *args= and_cond->argument_list();

1907

8990

{

1908

8991

item_equal->fix_length_and_dec();

1909

8992

item_equal->update_used_tables();

1910

set_if_bigger(session->lex->current_select->max_equal_elems,

1911

item_equal->members());

8993

set_if_bigger(thd->lex->current_select->max_equal_elems,

8994

item_equal->members());

1912

8995

}

1913

8996

and_cond->cond_equal= cond_equal;

1914

8997

args->concat((List<Item> *)&cond_equal.current_level);

1915

8998

1916

8999

return and_cond;

1917

9000

}

1918

9001

}

1919

9002

1920

9003

For each field reference in cond, not from equal item predicates,

1921

9004

set a pointer to the multiple equality it belongs to (if there is any)

1922

9005

as soon the field is not of a string type or the field reference is

1923

an argument of a comparison predicate.

1924

1925

unsigned char *is_subst_valid= (unsigned char *) 1;

9006

an argument of a comparison predicate.

9007

9008

uchar *is_subst_valid= (uchar *) 1;

1926

9009

cond= cond->compile(&Item::subst_argument_checker,

1927

&is_subst_valid,

9010

&is_subst_valid,

1928

9011

&Item::equal_fields_propagator,

1929

(unsigned char *) inherited);

9012

(uchar *) inherited);

1930

9013

cond->update_used_tables();

1931

9014

}

1932

9015

return cond;

1933

9016

}

1934

9017

9018

1935

9019

/**

1936

9020

Build multiple equalities for a condition and all on expressions that

1937

9021

inherit these multiple equalities.

1977

9061

SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a

1978

9062

WHERE t1.a=t2.a

1979

9063

@endcode

1980

that is equivalent to:

9064

that is equivalent to:

1981

9065

@code

1982

9066

SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1

1983

9067

WHERE t1.a=t2.a

1984

9068

@endcode

1985

9069

Thus, applying equalities from the where condition we basically

1986

9070

can get more freedom in performing join operations.

1987

Althogh we don't use this property now, it probably makes sense to use

1988

it in the future.

1989

@param session Thread Cursor

9071

Althogh we don't use this property now, it probably makes sense to use

9072

it in the future.

9073

@param thd Thread handler

1990

9074

@param cond condition to build the multiple equalities for

1991

9075

@param inherited path to all inherited multiple equality items

1992

9076

@param join_list list of join tables to which the condition

1997

9081

@return

1998

9082

pointer to the transformed condition containing multiple equalities

1999

9083

2000

static COND *build_equal_items(Session *session, COND *cond,

9084

9085

static COND *build_equal_items(THD *thd, COND *cond,

2001

9086

COND_EQUAL *inherited,

2002

9087

List<TableList> *join_list,

2003

9088

COND_EQUAL **cond_equal_ref)

2004

9089

{

2005

9090

COND_EQUAL *cond_equal= 0;

2006

9091

2007

if (cond)

9092

if (cond)

2008

9093

{

2009

cond= build_equal_items_for_cond(session, cond, inherited);

9094

cond= build_equal_items_for_cond(thd, cond, inherited);

2010

9095

cond->update_used_tables();

2011

9096

if (cond->type() == Item::COND_ITEM &&

2012

9097

((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

2034

9119

{

2035

9120

if (table->on_expr)

2036

9121

{

2037

List<TableList> *nested_join_list= table->getNestedJoin() ?

2038

&table->getNestedJoin()->join_list : NULL;

9122

List<TableList> *nested_join_list= table->nested_join ?

9123

&table->nested_join->join_list : NULL;

2039

9124

2040

9125

We can modify table->on_expr because its old value will

2041

9126

be restored before re-execution of PS/SP.

2042

9127

2043

table->on_expr= build_equal_items(session, table->on_expr, inherited,

9128

table->on_expr= build_equal_items(thd, table->on_expr, inherited,

2044

9129

nested_join_list,

2045

9130

&table->cond_equal);

2046

9131

}

2048

9133

}

2049

9134

2050

9135

return cond;

2051

}

9136

}

9137

2052

9138

2053

9139

/**

2054

9140

Compare field items by table order in the execution plan.

2055

9141

2056

9142

field1 considered as better than field2 if the table containing

2057

field1 is accessed earlier than the table containing field2.

9143

field1 is accessed earlier than the table containing field2.

2058

9144

The function finds out what of two fields is better according

2059

9145

this criteria.

2060

9146

2069

9155

@retval

2070

9156

0 otherwise

2071

9157

9158

2072

9159

static int compare_fields_by_table_order(Item_field *field1,

2073

Item_field *field2,

2074

void *table_join_idx)

9160

Item_field *field2,

9161

void *table_join_idx)

2075

9162

{

2076

9163

int cmp= 0;

2077

9164

bool outer_ref= 0;

2078

9165

if (field2->used_tables() & OUTER_REF_TABLE_BIT)

2079

{

9166

{

2080

9167

outer_ref= 1;

2081

9168

cmp= -1;

2082

9169

}

2087

9174

}

2088

9175

if (outer_ref)

2089

9176

return cmp;

2090

JoinTable **idx= (JoinTable **) table_join_idx;

2091

cmp= idx[field2->field->getTable()->tablenr]-idx[field1->field->getTable()->tablenr];

9177

JOIN_TAB **idx= (JOIN_TAB **) table_join_idx;

9178

cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];

2092

9179

return cmp < 0 ? -1 : (cmp ? 1 : 0);

2093

9180

}

2094

9181

9182

2095

9183

/**

2096

9184

Generate minimal set of simple equalities equivalent to a multiple equality.

2097

9185

2131

9219

a pointer to the simple generated equality, if success.

2132

9220

- 0, otherwise.

2133

9221

2134

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels, Item_equal *item_equal)

9222

9223

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,

9224

Item_equal *item_equal)

2135

9225

{

2136

9226

List<Item> eq_list;

2137

9227

Item_func_eq *eq_item= 0;

2138

9228

if (((Item *) item_equal)->const_item() && !item_equal->val_int())

2139

return new Item_int((int64_t) 0,1);

9229

return new Item_int((int64_t) 0,1);

2140

9230

Item *item_const= item_equal->get_const();

2141

9231

Item_equal_iterator it(*item_equal);

2142

9232

Item *head;

2153

9243

Item_equal *upper= item_field->find_item_equal(upper_levels);

2154

9244

Item_field *item= item_field;

2155

9245

if (upper)

2156

{

9246

{

2157

9247

if (item_const && upper->get_const())

2158

9248

item= 0;

2159

9249

else

2197

9287

2198

9288

cond->quick_fix_field();

2199

9289

cond->update_used_tables();

2200

9290

2201

9291

return cond;

2202

9292

}

2203

9293

9294

2204

9295

/**

2205

9296

Substitute every field reference in a condition by the best equal field

2206

9297

and eliminate all multiple equality predicates.

2209

9300

multiple equality predicate it sorts the field references in it

2210

9301

according to the order of tables specified by the table_join_idx

2211

9302

parameter. Then it eliminates the multiple equality predicate it

2212

replacing it by the conjunction of simple equality predicates

9303

replacing it by the conjunction of simple equality predicates

2213

9304

equating every field from the multiple equality to the first

2214

9305

field in it, or to the constant, if there is any.

2215

9306

After this the function retrieves all other conjuncted

2228

9319

@return

2229

9320

The transformed condition

2230

9321

2231

COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx)

9322

9323

static COND* substitute_for_best_equal_field(COND *cond,

9324

COND_EQUAL *cond_equal,

9325

void *table_join_idx)

2232

9326

{

2233

9327

Item_equal *item_equal;

2234

9328

2243

9337

cond_equal= &((Item_cond_and *) cond)->cond_equal;

2244

9338

cond_list->disjoin((List<Item> *) &cond_equal->current_level);

2245

9339

2246

List_iterator_fast<Item_equal> it(cond_equal->current_level);

9340

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2247

9341

while ((item_equal= it++))

2248

9342

{

2249

9343

item_equal->sort(&compare_fields_by_table_order, table_join_idx);

2250

9344

}

2251

9345

}

2252

9346

2253

9347

List_iterator<Item> li(*cond_list);

2254

9348

Item *item;

2255

9349

while ((item= li++))

2282

9376

cond= new Item_int((int32_t)cond->val_bool());

2283

9377

2284

9378

}

2285

else if (cond->type() == Item::FUNC_ITEM &&

9379

else if (cond->type() == Item::FUNC_ITEM &&

2286

9380

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2287

9381

{

2288

9382

item_equal= (Item_equal *) cond;

2296

9390

return cond;

2297

9391

}

2298

9392

9393

2299

9394

/**

2300

9395

Check appearance of new constant items in multiple equalities

2301

9396

of a condition after reading a constant table.

2308

9403

@param cond condition whose multiple equalities are to be checked

2309

9404

@param table constant table that has been read

2310

9405

2311

void update_const_equal_items(COND *cond, JoinTable *tab)

9406

9407

static void update_const_equal_items(COND *cond, JOIN_TAB *tab)

2312

9408

{

2313

9409

if (!(cond->used_tables() & tab->table->map))

2314

9410

return;

2315

9411

2316

9412

if (cond->type() == Item::COND_ITEM)

2317

9413

{

2318

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

9414

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

2319

9415

List_iterator_fast<Item> li(*cond_list);

2320

9416

Item *item;

2321

9417

while ((item= li++))

2322

9418

update_const_equal_items(item, tab);

2323

9419

}

2324

else if (cond->type() == Item::FUNC_ITEM &&

9420

else if (cond->type() == Item::FUNC_ITEM &&

2325

9421

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2326

9422

{

2327

9423

Item_equal *item_equal= (Item_equal *) cond;

2335

9431

while ((item_field= it++))

2336

9432

{

2337

9433

Field *field= item_field->field;

2338

JoinTable *stat= field->getTable()->reginfo.join_tab;

9434

JOIN_TAB *stat= field->table->reginfo.join_tab;

2339

9435

key_map possible_keys= field->key_start;

2340

possible_keys&= field->getTable()->keys_in_use_for_query;

2341

stat[0].const_keys|= possible_keys;

9436

possible_keys.intersect(field->table->keys_in_use_for_query);

9437

stat[0].const_keys.merge(possible_keys);

2342

9438

2343

9439

2344

For each field in the multiple equality (for which we know that it

2345

is a constant) we have to find its corresponding key part, and set

9440

For each field in the multiple equality (for which we know that it

9441

is a constant) we have to find its corresponding key part, and set

2346

9442

that key part in const_key_parts.

2347

2348

if (possible_keys.any())

9443

9444

if (!possible_keys.is_clear_all())

2349

9445

{

2350

Table *field_tab= field->getTable();

2351

optimizer::KeyUse *use;

2352

for (use= stat->keyuse; use && use->getTable() == field_tab; use++)

2353

if (possible_keys.test(use->getKey()) &&

2354

field_tab->key_info[use->getKey()].key_part[use->getKeypart()].field ==

9446

Table *tab= field->table;

9447

KEYUSE *use;

9448

for (use= stat->keyuse; use && use->table == tab; use++)

9449

if (possible_keys.is_set(use->key) &&

9450

tab->key_info[use->key].key_part[use->keypart].field ==

2355

9451

field)

2356

field_tab->const_key_parts[use->getKey()]|= use->getKeypartMap();

9452

tab->const_key_parts[use->key]|= use->keypart_map;

2357

9453

}

2358

9454

}

2359

9455

}

2360

9456

}

2361

9457

}

2362

9458

9459

2363

9460

2364

9461

change field = field to field = const for each found field = const in the

2365

9462

and_level

2366

9463

2367

static void change_cond_ref_to_const(Session *session,

2368

list<COND_CMP>& save_list,

2369

Item *and_father,

2370

Item *cond,

2371

Item *field,

2372

Item *value)

9464

9465

static void

9466

change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,

9467

Item *and_father, Item *cond,

9468

Item *field, Item *value)

2373

9469

{

2374

9470

if (cond->type() == Item::COND_ITEM)

2375

9471

{

2376

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9472

bool and_level= ((Item_cond*) cond)->functype() ==

9473

Item_func::COND_AND_FUNC;

2377

9474

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

2378

9475

Item *item;

2379

9476

while ((item=li++))

2380

change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

2381

9477

change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,

9478

field, value);

2382

9479

return;

2383

9480

}

2384

9481

if (cond->eq_cmp_result() == Item::COND_OK)

2397

9494

left_item->collation.collation == value->collation.collation))

2398

9495

{

2399

9496

Item *tmp=value->clone_item();

9497

tmp->collation.set(right_item->collation);

9498

2400

9499

if (tmp)

2401

9500

{

2402

tmp->collation.set(right_item->collation);

2403

session->change_item_tree(args + 1, tmp);

9501

thd->change_item_tree(args + 1, tmp);

2404

9502

func->update_used_tables();

2405

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2406

and_father != cond &&

2407

! left_item->const_item())

9503

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9504

&& and_father != cond && !left_item->const_item())

2408

9505

{

2409

cond->marker=1;

2410

save_list.push_back( COND_CMP(and_father, func) );

9506

cond->marker=1;

9507

COND_CMP *tmp2;

9508

if ((tmp2=new COND_CMP(and_father,func)))

9509

save_list->push_back(tmp2);

2411

9510

}

2412

9511

func->set_cmp_func();

2413

9512

}

2419

9518

right_item->collation.collation == value->collation.collation))

2420

9519

{

2421

9520

Item *tmp= value->clone_item();

9521

tmp->collation.set(left_item->collation);

9522

2422

9523

if (tmp)

2423

9524

{

2424

tmp->collation.set(left_item->collation);

2425

session->change_item_tree(args, tmp);

9525

thd->change_item_tree(args, tmp);

2426

9526

value= tmp;

2427

9527

func->update_used_tables();

2428

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2429

and_father != cond &&

2430

! right_item->const_item())

9528

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9529

&& and_father != cond && !right_item->const_item())

2431

9530

{

2432

9531

args[0]= args[1]; // For easy check

2433

session->change_item_tree(args + 1, value);

2434

cond->marker=1;

2435

save_list.push_back( COND_CMP(and_father, func) );

9532

thd->change_item_tree(args + 1, value);

9533

cond->marker=1;

9534

COND_CMP *tmp2;

9535

if ((tmp2=new COND_CMP(and_father,func)))

9536

save_list->push_back(tmp2);

2436

9537

}

2437

9538

func->set_cmp_func();

2438

9539

}

2447

9548

@return

2448

9549

new conditions

2449

9550

2450

Item *remove_additional_cond(Item* conds)

9551

9552

static Item *remove_additional_cond(Item* conds)

2451

9553

{

2452

9554

if (conds->name == in_additional_cond)

2453

9555

return 0;

2470

9572

return conds;

2471

9573

}

2472

9574

2473

static void propagate_cond_constants(Session *session,

2474

list<COND_CMP>& save_list,

2475

COND *and_father,

2476

COND *cond)

9575

static void

9576

propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,

9577

COND *and_father, COND *cond)

2477

9578

{

2478

9579

if (cond->type() == Item::COND_ITEM)

2479

9580

{

2480

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9581

bool and_level= ((Item_cond*) cond)->functype() ==

9582

Item_func::COND_AND_FUNC;

2481

9583

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

2482

9584

Item *item;

2483

list<COND_CMP> save;

9585

I_List<COND_CMP> save;

2484

9586

while ((item=li++))

2485

9587

{

2486

propagate_cond_constants(session, save, and_level ? cond : item, item);

9588

propagate_cond_constants(thd, &save,and_level ? cond : item, item);

2487

9589

}

2488

9590

if (and_level)

2489

{

2490

// Handle other found items

2491

for (list<COND_CMP>::iterator iter= save.begin(); iter != save.end(); ++iter)

9591

{ // Handle other found items

9592

I_List_iterator<COND_CMP> cond_itr(save);

9593

COND_CMP *cond_cmp;

9594

while ((cond_cmp=cond_itr++))

2492

9595

{

2493

Item **args= iter->second->arguments();

2494

if (not args[0]->const_item())

2495

{

2496

change_cond_ref_to_const(session, save, iter->first,

2497

iter->first, args[0], args[1] );

2498

}

9596

Item **args= cond_cmp->cmp_func->arguments();

9597

if (!args[0]->const_item())

9598

change_cond_ref_to_const(thd, &save,cond_cmp->and_level,

9599

cond_cmp->and_level, args[0], args[1]);

2499

9600

}

2500

9601

}

2501

9602

}

2502

9603

else if (and_father != cond && !cond->marker) // In a AND group

2503

9604

{

2504

9605

if (cond->type() == Item::FUNC_ITEM &&

2505

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

2506

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

9606

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

9607

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

2507

9608

{

2508

9609

Item_func_eq *func=(Item_func_eq*) cond;

2509

9610

Item **args= func->arguments();

2512

9613

if (!(left_const && right_const) &&

2513

9614

args[0]->result_type() == args[1]->result_type())

2514

9615

{

2515

if (right_const)

2516

{

2517

resolve_const_item(session, &args[1], args[0]);

2518

func->update_used_tables();

2519

change_cond_ref_to_const(session, save_list, and_father, and_father,

2520

args[0], args[1]);

2521

}

2522

else if (left_const)

2523

{

2524

resolve_const_item(session, &args[0], args[1]);

2525

func->update_used_tables();

2526

change_cond_ref_to_const(session, save_list, and_father, and_father,

2527

args[1], args[0]);

2528

}

2529

}

2530

}

2531

}

2532

}

9616

if (right_const)

9617

{

9618

resolve_const_item(thd, &args[1], args[0]);

9619

func->update_used_tables();

9620

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9621

args[0], args[1]);

9622

}

9623

else if (left_const)

9624

{

9625

resolve_const_item(thd, &args[0], args[1]);

9626

func->update_used_tables();

9627

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9628

args[1], args[0]);

9629

}

9630

}

9631

}

9632

}

9633

}

9634

9635

9636

/**

9637

Simplify joins replacing outer joins by inner joins whenever it's

9638

possible.

9639

9640

The function, during a retrieval of join_list, eliminates those

9641

outer joins that can be converted into inner join, possibly nested.

9642

It also moves the on expressions for the converted outer joins

9643

and from inner joins to conds.

9644

The function also calculates some attributes for nested joins:

9645

- used_tables

9646

- not_null_tables

9647

- dep_tables.

9648

- on_expr_dep_tables

9649

The first two attributes are used to test whether an outer join can

9650

be substituted for an inner join. The third attribute represents the

9651

relation 'to be dependent on' for tables. If table t2 is dependent

9652

on table t1, then in any evaluated execution plan table access to

9653

table t2 must precede access to table t2. This relation is used also

9654

to check whether the query contains invalid cross-references.

9655

The forth attribute is an auxiliary one and is used to calculate

9656

dep_tables.

9657

As the attribute dep_tables qualifies possibles orders of tables in the

9658

execution plan, the dependencies required by the straight join

9659

modifiers are reflected in this attribute as well.

9660

The function also removes all braces that can be removed from the join

9661

expression without changing its meaning.

9662

9663

@note

9664

An outer join can be replaced by an inner join if the where condition

9665

or the on expression for an embedding nested join contains a conjunctive

9666

predicate rejecting null values for some attribute of the inner tables.

9667

9668

E.g. in the query:

9669

@code

9670

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9671

@endcode

9672

the predicate t2.b < 5 rejects nulls.

9673

The query is converted first to:

9674

@code

9675

SELECT * FROM t1 INNER JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9676

@endcode

9677

then to the equivalent form:

9678

@code

9679

SELECT * FROM t1, t2 ON t2.a=t1.a WHERE t2.b < 5 AND t2.a=t1.a

9680

@endcode

9681

9682

9683

Similarly the following query:

9684

@code

9685

SELECT * from t1 LEFT JOIN (t2, t3) ON t2.a=t1.a t3.b=t1.b

9686

WHERE t2.c < 5

9687

@endcode

9688

is converted to:

9689

@code

9690

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a t3.b=t1.b

9691

9692

@endcode

9693

9694

One conversion might trigger another:

9695

@code

9696

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a

9697

LEFT JOIN t3 ON t3.b=t2.b

9698

WHERE t3 IS NOT NULL =>

9699

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a, t3

9700

WHERE t3 IS NOT NULL AND t3.b=t2.b =>

9701

SELECT * FROM t1, t2, t3

9702

WHERE t3 IS NOT NULL AND t3.b=t2.b AND t2.a=t1.a

9703

@endcode

9704

9705

The function removes all unnecessary braces from the expression

9706

produced by the conversions.

9707

E.g.

9708

@code

9709

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9710

@endcode

9711

finally is converted to:

9712

@code

9713

SELECT * FROM t1, t2, t3 WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9714

9715

@endcode

9716

9717

9718

It also will remove braces from the following queries:

9719

@code

9720

SELECT * from (t1 LEFT JOIN t2 ON t2.a=t1.a) LEFT JOIN t3 ON t3.b=t2.b

9721

SELECT * from (t1, (t2,t3)) WHERE t1.a=t2.a AND t2.b=t3.b.

9722

@endcode

9723

9724

The benefit of this simplification procedure is that it might return

9725

a query for which the optimizer can evaluate execution plan with more

9726

join orders. With a left join operation the optimizer does not

9727

consider any plan where one of the inner tables is before some of outer

9728

tables.

9729

9730

IMPLEMENTATION

9731

The function is implemented by a recursive procedure. On the recursive

9732

ascent all attributes are calculated, all outer joins that can be

9733

converted are replaced and then all unnecessary braces are removed.

9734

As join list contains join tables in the reverse order sequential

9735

elimination of outer joins does not require extra recursive calls.

9736

9737

SEMI-JOIN NOTES

9738

Remove all semi-joins that have are within another semi-join (i.e. have

9739

an "ancestor" semi-join nest)

9740

9741

EXAMPLES

9742

Here is an example of a join query with invalid cross references:

9743

@code

9744

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t3.a LEFT JOIN t3 ON t3.b=t1.b

9745

@endcode

9746

9747

@param join reference to the query info

9748

@param join_list list representation of the join to be converted

9749

@param conds conditions to add on expressions for converted joins

9750

@param top true <=> conds is the where condition

9751

9752

@return

9753

- The new condition, if success

9754

- 0, otherwise

9755

9756

9757

static COND *

9758

simplify_joins(JOIN *join, List<TableList> *join_list, COND *conds, bool top,

9759

bool in_sj)

9760

{

9761

TableList *table;

9762

nested_join_st *nested_join;

9763

TableList *prev_table= 0;

9764

List_iterator<TableList> li(*join_list);

9765

9766

9767

Try to simplify join operations from join_list.

9768

The most outer join operation is checked for conversion first.

9769

9770

while ((table= li++))

9771

{

9772

table_map used_tables;

9773

table_map not_null_tables= (table_map) 0;

9774

9775

if ((nested_join= table->nested_join))

9776

{

9777

9778

If the element of join_list is a nested join apply

9779

the procedure to its nested join list first.

9780

9781

if (table->on_expr)

9782

{

9783

Item *expr= table->on_expr;

9784

9785

If an on expression E is attached to the table,

9786

check all null rejected predicates in this expression.

9787

If such a predicate over an attribute belonging to

9788

an inner table of an embedded outer join is found,

9789

the outer join is converted to an inner join and

9790

the corresponding on expression is added to E.

9791

9792

expr= simplify_joins(join, &nested_join->join_list,

9793

expr, false, in_sj || table->sj_on_expr);

9794

9795

if (!table->prep_on_expr || expr != table->on_expr)

9796

{

9797

assert(expr);

9798

9799

table->on_expr= expr;

9800

table->prep_on_expr= expr->copy_andor_structure(join->thd);

9801

}

9802

}

9803

nested_join->used_tables= (table_map) 0;

9804

nested_join->not_null_tables=(table_map) 0;

9805

conds= simplify_joins(join, &nested_join->join_list, conds, top,

9806

in_sj || table->sj_on_expr);

9807

used_tables= nested_join->used_tables;

9808

not_null_tables= nested_join->not_null_tables;

9809

}

9810

else

9811

{

9812

if (!table->prep_on_expr)

9813

table->prep_on_expr= table->on_expr;

9814

used_tables= table->table->map;

9815

if (conds)

9816

not_null_tables= conds->not_null_tables();

9817

}

9818

9819

if (table->embedding)

9820

{

9821

table->embedding->nested_join->used_tables|= used_tables;

9822

table->embedding->nested_join->not_null_tables|= not_null_tables;

9823

}

9824

9825

if (!table->outer_join || (used_tables & not_null_tables))

9826

{

9827

9828

For some of the inner tables there are conjunctive predicates

9829

that reject nulls => the outer join can be replaced by an inner join.

9830

9831

table->outer_join= 0;

9832

if (table->on_expr)

9833

{

9834

/* Add ON expression to the WHERE or upper-level ON condition. */

9835

if (conds)

9836

{

9837

conds= and_conds(conds, table->on_expr);

9838

conds->top_level_item();

9839

/* conds is always a new item as both cond and on_expr existed */

9840

assert(!conds->fixed);

9841

conds->fix_fields(join->thd, &conds);

9842

}

9843

else

9844

conds= table->on_expr;

9845

table->prep_on_expr= table->on_expr= 0;

9846

}

9847

}

9848

9849

if (!top)

9850

continue;

9851

9852

9853

Only inner tables of non-convertible outer joins

9854

remain with on_expr.

9855

9856

if (table->on_expr)

9857

{

9858

table->dep_tables|= table->on_expr->used_tables();

9859

if (table->embedding)

9860

{

9861

table->dep_tables&= ~table->embedding->nested_join->used_tables;

9862

9863

Embedding table depends on tables used

9864

in embedded on expressions.

9865

9866

table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();

9867

}

9868

else

9869

table->dep_tables&= ~table->table->map;

9870

}

9871

9872

if (prev_table)

9873

{

9874

/* The order of tables is reverse: prev_table follows table */

9875

if (prev_table->straight)

9876

prev_table->dep_tables|= used_tables;

9877

if (prev_table->on_expr)

9878

{

9879

prev_table->dep_tables|= table->on_expr_dep_tables;

9880

table_map prev_used_tables= prev_table->nested_join ?

9881

prev_table->nested_join->used_tables :

9882

prev_table->table->map;

9883

9884

If on expression contains only references to inner tables

9885

we still make the inner tables dependent on the outer tables.

9886

It would be enough to set dependency only on one outer table

9887

for them. Yet this is really a rare case.

9888

9889

if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))

9890

prev_table->dep_tables|= used_tables;

9891

}

9892

}

9893

prev_table= table;

9894

}

9895

9896

9897

Flatten nested joins that can be flattened.

9898

no ON expression and not a semi-join => can be flattened.

9899

9900

li.rewind();

9901

while ((table= li++))

9902

{

9903

nested_join= table->nested_join;

9904

if (table->sj_on_expr && !in_sj)

9905

{

9906

9907

If this is a semi-join that is not contained within another semi-join,

9908

leave it intact (otherwise it is flattened)

9909

9910

join->select_lex->sj_nests.push_back(table);

9911

}

9912

else if (nested_join && !table->on_expr)

9913

{

9914

TableList *tbl;

9915

List_iterator<TableList> it(nested_join->join_list);

9916

while ((tbl= it++))

9917

{

9918

tbl->embedding= table->embedding;

9919

tbl->join_list= table->join_list;

9920

}

9921

li.replace(nested_join->join_list);

9922

}

9923

}

9924

return(conds);

9925

}

9926

9927

9928

/**

9929

Assign each nested join structure a bit in nested_join_map.

9930

9931

Assign each nested join structure (except "confluent" ones - those that

9932

embed only one element) a bit in nested_join_map.

9933

9934

@param join Join being processed

9935

@param join_list List of tables

9936

@param first_unused Number of first unused bit in nested_join_map before the

9937

call

9938

9939

@note

9940

This function is called after simplify_joins(), when there are no

9941

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

9942

we will not run out of bits in nested_join_map.

9943

9944

@return

9945

First unused bit in nested_join_map after the call.

9946

9947

9948

static uint build_bitmap_for_nested_joins(List<TableList> *join_list,

9949

uint first_unused)

9950

{

9951

List_iterator<TableList> li(*join_list);

9952

TableList *table;

9953

while ((table= li++))

9954

{

9955

nested_join_st *nested_join;

9956

if ((nested_join= table->nested_join))

9957

{

9958

9959

It is guaranteed by simplify_joins() function that a nested join

9960

that has only one child is either

9961

- a single-table view (the child is the underlying table), or

9962

- a single-table semi-join nest

9963

9964

We don't assign bits to such sj-nests because

9965

1. it is redundant (a "sequence" of one table cannot be interleaved

9966

with anything)

9967

2. we could run out bits in nested_join_map otherwise.

9968

9969

if (nested_join->join_list.elements != 1)

9970

{

9971

/* Don't assign bits to sj-nests */

9972

if (table->on_expr)

9973

nested_join->nj_map= (nested_join_map) 1 << first_unused++;

9974

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

9975

first_unused);

9976

}

9977

}

9978

}

9979

return(first_unused);

9980

}

9981

9982

9983

/**

9984

Set nested_join_st::counter=0 in all nested joins in passed list.

9985

9986

Recursively set nested_join_st::counter=0 for all nested joins contained in

9987

the passed join_list.

9988

9989

@param join_list List of nested joins to process. It may also contain base

9990

tables which will be ignored.

9991

9992

9993

static void reset_nj_counters(List<TableList> *join_list)

9994

{

9995

List_iterator<TableList> li(*join_list);

9996

TableList *table;

9997

while ((table= li++))

9998

{

9999

nested_join_st *nested_join;

10000

if ((nested_join= table->nested_join))

10001

{

10002

nested_join->counter_= 0;

10003

reset_nj_counters(&nested_join->join_list);

10004

}

10005

}

10006

return;

10007

}

10008

2533

10009

2534

10010

/**

2535

10011

Check interleaving with an inner tables of an outer join for

2536

10012

extension table.

2537

10013

2538

Check if table next_tab can be added to current partial join order, and

10014

Check if table next_tab can be added to current partial join order, and

2539

10015

if yes, record that it has been added.

2540

10016

2541

10017

The function assumes that both current partial join order and its

2542

10018

extension with next_tab are valid wrt table dependencies.

2543

10019

2544

10020

@verbatim

2545

IMPLEMENTATION

10021

IMPLEMENTATION

2546

10022

LIMITATIONS ON JOIN order_st

2547

10023

The nested [outer] joins executioner algorithm imposes these limitations

2548

10024

on join order:

2549

1. "Outer tables first" - any "outer" table must be before any

10025

1. "Outer tables first" - any "outer" table must be before any

2550

10026

corresponding "inner" table.

2551

10027

2. "No interleaving" - tables inside a nested join must form a continuous

2552

sequence in join order (i.e. the sequence must not be interrupted by

10028

sequence in join order (i.e. the sequence must not be interrupted by

2553

10029

tables that are outside of this nested join).

2554

10030

2555

10031

#1 is checked elsewhere, this function checks #2 provided that #1 has

2556

10032

been already checked.

2557

10033

2558

10034

WHY NEED NON-INTERLEAVING

2559

Consider an example:

10035

Consider an example:

2560

10036

2561

10037

select * from t0 join t1 left join (t2 join t3) on cond1

2562

10038

2580

10056

The limitations on join order can be rephrased as follows: for valid

2581

10057

join order one must be able to:

2582

10058

1. write down the used tables in the join order on one line.

2583

2. for each nested join, put one '(' and one ')' on the said line

10059

2. for each nested join, put one '(' and one ')' on the said line

2584

10060

3. write "LEFT JOIN" and "ON (...)" where appropriate

2585

10061

4. get a query equivalent to the query we're trying to execute.

2586

10062

2587

10063

Calls to check_interleaving_with_nj() are equivalent to writing the

2588

above described line from left to right.

2589

A single check_interleaving_with_nj(A,B) call is equivalent to writing

10064

above described line from left to right.

10065

A single check_interleaving_with_nj(A,B) call is equivalent to writing

2590

10066

table B and appropriate brackets on condition that table A and

2591

10067

appropriate brackets is the last what was written. Graphically the

2592

10068

transition is as follows:

2599

10075

position.

2600

10076

2601

10077

Notes about the position:

2602

The caller guarantees that there is no more then one X-bracket by

2603

checking "!(remaining_tables & s->dependent)" before calling this

10078

The caller guarantees that there is no more then one X-bracket by

10079

checking "!(remaining_tables & s->dependent)" before calling this

2604

10080

function. X-bracket may have a pair in Y-bracket.

2605

10081

2606

10082

When "writing" we store/update this auxilary info about the current

2607

10083

position:

2608

10084

1. join->cur_embedding_map - bitmap of pairs of brackets (aka nested

2609

10085

joins) we've opened but didn't close.

2610

2. {each NestedJoin class not simplified away}->counter - number

10086

2. {each nested_join_st structure not simplified away}->counter - number

2611

10087

of this nested join's children that have already been added to to

2612

10088

the partial join order.

2613

10089

@endverbatim

2614

10090

2615

10091

@param join Join being processed

10092

@param last_tab Last table in current partial join order (this function is

10093

not called for empty partial join orders)

2616

10094

@param next_tab Table we're going to extend the current partial join with

2617

10095

2618

10096

@retval

2621

10099

@retval

2622

10100

true Requested join order extension not allowed.

2623

10101

2624

bool check_interleaving_with_nj(JoinTable *next_tab)

10102

10103

static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)

2625

10104

{

2626

TableList *next_emb= next_tab->table->pos_in_table_list->getEmbedding();

2627

Join *join= next_tab->join;

10105

TableList *next_emb= next_tab->table->pos_in_table_list->embedding;

10106

JOIN *join= last_tab->join;

2628

10107

2629

if ((join->cur_embedding_map & ~next_tab->embedding_map).any())

10108

if (join->cur_embedding_map & ~next_tab->embedding_map)

2630

10109

{

2631

10110

2632

10111

next_tab is outside of the "pair of brackets" we're currently in.

2633

10112

Cannot add it.

2634

10113

2635

10114

return true;

2636

10115

}

2637

10116

2638

10117

2639

10118

Do update counters for "pairs of brackets" that we've left (marked as

2640

10119

X,Y,Z in the above picture)

2641

10120

2642

for (;next_emb; next_emb= next_emb->getEmbedding())

10121

for (;next_emb; next_emb= next_emb->embedding)

2643

10122

{

2644

next_emb->getNestedJoin()->counter_++;

2645

if (next_emb->getNestedJoin()->counter_ == 1)

10123

next_emb->nested_join->counter_++;

10124

if (next_emb->nested_join->counter_ == 1)

2646

10125

{

2647

10126

2648

10127

next_emb is the first table inside a nested join we've "entered". In

2649

10128

the picture above, we're looking at the 'X' bracket. Don't exit yet as

2650

10129

X bracket might have Y pair bracket.

2651

10130

2652

join->cur_embedding_map |= next_emb->getNestedJoin()->nj_map;

10131

join->cur_embedding_map |= next_emb->nested_join->nj_map;

2653

10132

}

2654

2655

if (next_emb->getNestedJoin()->join_list.elements !=

2656

next_emb->getNestedJoin()->counter_)

10133

10134

if (next_emb->nested_join->join_list.elements !=

10135

next_emb->nested_join->counter_)

2657

10136

break;

2658

10137

2659

10138

2660

10139

We're currently at Y or Z-bracket as depicted in the above picture.

2661

10140

Mark that we've left it and continue walking up the brackets hierarchy.

2662

10141

2663

join->cur_embedding_map &= ~next_emb->getNestedJoin()->nj_map;

10142

join->cur_embedding_map &= ~next_emb->nested_join->nj_map;

2664

10143

}

2665

10144

return false;

2666

10145

}

2667

10146

2668

COND *optimize_cond(Join *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)

2669

{

2670

Session *session= join->session;

10147

10148

/**

10149

Nested joins perspective: Remove the last table from the join order.

10150

10151

Remove the last table from the partial join order and update the nested

10152

joins counters and join->cur_embedding_map. It is ok to call this

10153

function for the first table in join order (for which

10154

check_interleaving_with_nj has not been called)

10155

10156

@param last join table to remove, it is assumed to be the last in current

10157

partial join order.

10158

10159

10160

static void restore_prev_nj_state(JOIN_TAB *last)

10161

{

10162

TableList *last_emb= last->table->pos_in_table_list->embedding;

10163

JOIN *join= last->join;

10164

while (last_emb)

10165

{

10166

if (last_emb->on_expr)

10167

{

10168

if (!(--last_emb->nested_join->counter_))

10169

join->cur_embedding_map&= ~last_emb->nested_join->nj_map;

10170

else if (last_emb->nested_join->join_list.elements-1 ==

10171

last_emb->nested_join->counter_)

10172

join->cur_embedding_map|= last_emb->nested_join->nj_map;

10173

else

10174

break;

10175

}

10176

last_emb= last_emb->embedding;

10177

}

10178

}

10179

10180

10181

10182

static

10183

void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab)

10184

{

10185

TableList *emb_sj_nest;

10186

if ((emb_sj_nest= tab->emb_sj_nest))

10187

{

10188

tab->join->cur_emb_sj_nests |= emb_sj_nest->sj_inner_tables;

10189

/* Remove the sj_nest if all of its SJ-inner tables are in cur_table_map */

10190

if (!(remaining_tables & emb_sj_nest->sj_inner_tables))

10191

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10192

}

10193

}

10194

10195

10196

10197

we assume remaining_tables doesnt contain @tab.

10198

10199

10200

static void restore_prev_sj_state(const table_map remaining_tables,

10201

const JOIN_TAB *tab)

10202

{

10203

TableList *emb_sj_nest;

10204

if ((emb_sj_nest= tab->emb_sj_nest))

10205

{

10206

/* If we're removing the last SJ-inner table, remove the sj-nest */

10207

if ((remaining_tables & emb_sj_nest->sj_inner_tables) ==

10208

(emb_sj_nest->sj_inner_tables & ~tab->table->map))

10209

{

10210

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10211

}

10212

}

10213

}

10214

10215

10216

static COND *

10217

optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list,

10218

Item::cond_result *cond_value)

10219

{

10220

THD *thd= join->thd;

2671

10221

2672

10222

if (!conds)

2673

10223

*cond_value= Item::COND_TRUE;

2674

10224

else

2675

10225

{

2676

10226

2677

10227

Build all multiple equality predicates and eliminate equality

2678

10228

predicates that can be inferred from these multiple equalities.

2679

10229

For each reference of a field included into a multiple equality

2680

10230

that occurs in a function set a pointer to the multiple equality

2681

10231

predicate. Substitute a constant instead of this field if the

2682

10232

multiple equality contains a constant.

2683

2684

conds= build_equal_items(join->session, conds, NULL, join_list,

10233

10234

conds= build_equal_items(join->thd, conds, NULL, join_list,

2685

10235

&join->cond_equal);

2686

10236

2687

10237

/* change field = field to field = const for each found field = const */

2688

list<COND_CMP> temp;

2689

propagate_cond_constants(session, temp, conds, conds);

10238

propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);

2690

10239

2691

10240

Remove all instances of item == item

2692

10241

Remove all and-levels where CONST item != CONST item

2693

10242

2694

conds= remove_eq_conds(session, conds, cond_value) ;

10243

conds= remove_eq_conds(thd, conds, cond_value) ;

2695

10244

}

2696

10245

return(conds);

2697

10246

}

2698

10247

10248

2699

10249

/**

2700

10250

Remove const and eq items.

2701

10251

2706

10256

- COND_TRUE : always true ( 1 = 1 )

2707

10257

- COND_FALSE : always false ( 1 = 2 )

2708

10258

2709

COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value)

10259

10260

COND *

10261

remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)

2710

10262

{

2711

10263

if (cond->type() == Item::COND_ITEM)

2712

10264

{

2713

bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

2714

10265

bool and_level= ((Item_cond*) cond)->functype()

10266

== Item_func::COND_AND_FUNC;

2715

10267

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

2716

10268

Item::cond_result tmp_cond_value;

2717

bool should_fix_fields= false;

10269

bool should_fix_fields=0;

2718

10270

2719

*cond_value= Item::COND_UNDEF;

10271

*cond_value=Item::COND_UNDEF;

2720

10272

Item *item;

2721

while ((item= li++))

10273

while ((item=li++))

2722

10274

{

2723

Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);

2724

if (! new_item)

2725

li.remove();

10275

Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);

10276

if (!new_item)

10277

li.remove();

2726

10278

else if (item != new_item)

2727

10279

{

2728

li.replace(new_item);

2729

should_fix_fields= true;

10280

VOID(li.replace(new_item));

10281

should_fix_fields=1;

2730

10282

}

2731

10283

if (*cond_value == Item::COND_UNDEF)

2732

*cond_value= tmp_cond_value;

2733

2734

switch (tmp_cond_value)

2735

{

2736

case Item::COND_OK: /* Not true or false */

2737

if (and_level || (*cond_value == Item::COND_FALSE))

2738

*cond_value= tmp_cond_value;

2739

break;

2740

case Item::COND_FALSE:

2741

if (and_level)

2742

{

2743

*cond_value= tmp_cond_value;

2744

return (COND *) NULL; /* Always false */

2745

}

2746

break;

2747

case Item::COND_TRUE:

2748

if (! and_level)

2749

{

2750

*cond_value= tmp_cond_value;

2751

return (COND *) NULL; /* Always true */

2752

}

2753

break;

2754

case Item::COND_UNDEF: /* Impossible */

2755

break;

10284

*cond_value=tmp_cond_value;

10285

switch (tmp_cond_value) {

10286

case Item::COND_OK: // Not true or false

10287

if (and_level || *cond_value == Item::COND_FALSE)

10288

*cond_value=tmp_cond_value;

10289

break;

10290

case Item::COND_FALSE:

10291

if (and_level)

10292

{

10293

*cond_value=tmp_cond_value;

10294

return (COND*) 0; // Always false

10295

}

10296

break;

10297

case Item::COND_TRUE:

10298

if (!and_level)

10299

{

10300

*cond_value= tmp_cond_value;

10301

return (COND*) 0; // Always true

10302

}

10303

break;

10304

case Item::COND_UNDEF: // Impossible

10305

break; /* purecov: deadcode */

2756

10306

}

2757

10307

}

2758

2759

10308

if (should_fix_fields)

2760

10309

cond->update_used_tables();

2761

10310

2762

if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)

2763

return (COND*) NULL;

2764

10311

if (!((Item_cond*) cond)->argument_list()->elements ||

10312

*cond_value != Item::COND_OK)

10313

return (COND*) 0;

2765

10314

if (((Item_cond*) cond)->argument_list()->elements == 1)

2766

{

2767

/* Argument list contains only one element, so reduce it so a single item, then remove list */

10315

{ // Remove list

2768

10316

item= ((Item_cond*) cond)->argument_list()->head();

2769

10317

((Item_cond*) cond)->argument_list()->empty();

2770

10318

return item;

2771

10319

}

2772

10320

}

2773

else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

10321

else if (cond->type() == Item::FUNC_ITEM &&

10322

((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

2774

10323

{

2775

10324

2776

10325

Handles this special case for some ODBC applications:

2782

10331

SELECT * from table_name where auto_increment_column = LAST_INSERT_ID

2783

10332

2784

10333

2785

Item_func_isnull *func= (Item_func_isnull*) cond;

10334

Item_func_isnull *func=(Item_func_isnull*) cond;

2786

10335

Item **args= func->arguments();

2787

10336

if (args[0]->type() == Item::FIELD_ITEM)

2788

10337

{

2789

Field *field= ((Item_field*) args[0])->field;

2790

if (field->flags & AUTO_INCREMENT_FLAG

2791

&& ! field->getTable()->maybe_null

2792

&& session->options & OPTION_AUTO_IS_NULL

2793

&& (

2794

session->first_successful_insert_id_in_prev_stmt > 0

2795

&& session->substitute_null_with_insert_id

2796

)

2797

)

10338

Field *field=((Item_field*) args[0])->field;

10339

if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&

10340

(thd->options & OPTION_AUTO_IS_NULL) &&

10341

(thd->first_successful_insert_id_in_prev_stmt > 0 &&

10342

thd->substitute_null_with_insert_id))

2798

10343

{

2799

COND *new_cond;

2800

if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",

2801

session->read_first_successful_insert_id_in_prev_stmt(),

2802

MY_INT64_NUM_DECIMAL_DIGITS))))

2803

{

2804

cond= new_cond;

10344

COND *new_cond;

10345

if ((new_cond= new Item_func_eq(args[0],

10346

new Item_int("last_insert_id()",

10347

thd->read_first_successful_insert_id_in_prev_stmt(),

10348

MY_INT64_NUM_DECIMAL_DIGITS))))

10349

{

10350

cond=new_cond;

2805

10351

2806

10352

Item_func_eq can't be fixed after creation so we do not check

2807

10353

cond->fixed, also it do not need tables so we use 0 as second

2808

10354

argument.

2809

10355

2810

cond->fix_fields(session, &cond);

2811

}

10356

cond->fix_fields(thd, &cond);

10357

}

2812

10358

2813

10359

IS NULL should be mapped to LAST_INSERT_ID only for first row, so

2814

10360

clear for next row

2815

10361

2816

session->substitute_null_with_insert_id= false;

10362

thd->substitute_null_with_insert_id= false;

2817

10363

}

2818

#ifdef NOTDEFINED

2819

10364

/* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */

2820

else if (

2821

((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME))

2822

&& (field->flags & NOT_NULL_FLAG)

2823

&& ! field->table->maybe_null)

10365

else if (((field->type() == DRIZZLE_TYPE_NEWDATE) ||

10366

(field->type() == DRIZZLE_TYPE_DATETIME)) &&

10367

(field->flags & NOT_NULL_FLAG) &&

10368

!field->table->maybe_null)

2824

10369

{

2825

COND *new_cond;

2826

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

2827

{

2828

cond= new_cond;

10370

COND *new_cond;

10371

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

10372

{

10373

cond=new_cond;

2829

10374

2830

10375

Item_func_eq can't be fixed after creation so we do not check

2831

10376

cond->fixed, also it do not need tables so we use 0 as second

2832

10377

argument.

2833

10378

2834

cond->fix_fields(session, &cond);

2835

}

10379

cond->fix_fields(thd, &cond);

10380

}

2836

10381

}

2837

#endif /* NOTDEFINED */

2838

10382

}

2839

10383

if (cond->const_item())

2840

10384

{

2841

10385

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2842

return (COND *) NULL;

10386

return (COND*) 0;

2843

10387

}

2844

10388

}

2845

10389

else if (cond->const_item() && !cond->is_expensive())

2846

10390

2847

10391

TODO:

2848

10392

Excluding all expensive functions is too restritive we should exclude only

2849

materialized IN subquery predicates because they can't yet be evaluated

2850

here (they need additional initialization that is done later on).

2851

2852

The proper way to exclude the subqueries would be to walk the cond tree and

2853

check for materialized subqueries there.

2854

10393

materialized IN because it is created later than this phase, and cannot be

10394

evaluated at this point.

10395

The condition should be something as (need to fix member access):

10396

!(cond->type() == Item::FUNC_ITEM &&

10397

((Item_func*)cond)->func_name() == "<in_optimizer>" &&

10398

((Item_in_optimizer*)cond)->is_expensive()))

2855

10399

2856

10400

{

2857

10401

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2858

return (COND *) NULL;

10402

return (COND*) 0;

2859

10403

}

2860

10404

else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)

2861

{

2862

/* boolan compare function */

10405

{ // boolan compare function

2863

10406

Item *left_item= ((Item_func*) cond)->arguments()[0];

2864

10407

Item *right_item= ((Item_func*) cond)->arguments()[1];

2865

10408

if (left_item->eq(right_item,1))

2866

10409

{

2867

if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

2868

return (COND*) NULL; /* Comparison of identical items */

10410

if (!left_item->maybe_null ||

10411

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

10412

return (COND*) 0; // Compare of identical items

2869

10413

}

2870

10414

}

2871

*cond_value= Item::COND_OK;

2872

return cond; /* Point at next and return into recursion */

10415

*cond_value=Item::COND_OK;

10416

return cond; // Point at next and level

2873

10417

}

2874

10418

2875

10419

2876

10420

Check if equality can be used in removing components of GROUP BY/DISTINCT

2877

10421

2878

10422

SYNOPSIS

2879

10423

test_if_equality_guarantees_uniqueness()

2880

10424

l the left comparison argument (a field if any)

2881

10425

r the right comparison argument (a const of any)

2882

2883

DESCRIPTION

2884

Checks if an equality predicate can be used to take away

2885

DISTINCT/GROUP BY because it is known to be true for exactly one

10426

10427

DESCRIPTION

10428

Checks if an equality predicate can be used to take away

10429

DISTINCT/GROUP BY because it is known to be true for exactly one

2886

10430

distinct value (e.g. <expr> == <const>).

2887

Arguments must be of the same type because e.g.

2888

<string_field> = <int_const> may match more than 1 distinct value from

2889

the column.

2890

We must take into consideration and the optimization done for various

10431

Arguments must be of the same type because e.g.

10432

<string_field> = <int_const> may match more than 1 distinct value from

10433

the column.

10434

We must take into consideration and the optimization done for various

2891

10435

string constants when compared to dates etc (see Item_int_with_ref) as

2892

10436

well as the collation of the arguments.

2893

2894

RETURN VALUE

10437

10438

RETURN VALUE

2895

10439

true can be used

2896

10440

false cannot be used

2897

10441

2898

static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)

10442

static bool

10443

test_if_equality_guarantees_uniqueness(Item *l, Item *r)

2899

10444

{

2900

10445

return r->const_item() &&

2901

10446

/* elements must be compared as dates */

2910

10455

/**

2911

10456

Return true if the item is a const value in all the WHERE clause.

2912

10457

2913

bool const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

10458

10459

static bool

10460

const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

2914

10461

{

2915

10462

if (cond->type() == Item::COND_ITEM)

2916

10463

{

2923

10470

bool res=const_expression_in_where(item, comp_item, const_item);

2924

10471

if (res) // Is a const value

2925

10472

{

2926

if (and_level)

2927

return 1;

10473

if (and_level)

10474

return 1;

2928

10475

}

2929

10476

else if (!and_level)

2930

return 0;

10477

return 0;

2931

10478

}

2932

10479

return and_level ? 0 : 1;

2933

10480

}

2935

10482

{ // boolan compare function

2936

10483

Item_func* func= (Item_func*) cond;

2937

10484

if (func->functype() != Item_func::EQUAL_FUNC &&

2938

func->functype() != Item_func::EQ_FUNC)

10485

func->functype() != Item_func::EQ_FUNC)

2939

10486

return 0;

2940

10487

Item *left_item= ((Item_func*) cond)->arguments()[0];

2941

10488

Item *right_item= ((Item_func*) cond)->arguments()[1];

2943

10490

{

2944

10491

if (test_if_equality_guarantees_uniqueness (left_item, right_item))

2945

10492

{

2946

if (*const_item)

2947

return right_item->eq(*const_item, 1);

2948

*const_item=right_item;

2949

return 1;

10493

if (*const_item)

10494

return right_item->eq(*const_item, 1);

10495

*const_item=right_item;

10496

return 1;

2950

10497

}

2951

10498

}

2952

10499

else if (right_item->eq(comp_item,1))

2953

10500

{

2954

10501

if (test_if_equality_guarantees_uniqueness (right_item, left_item))

2955

10502

{

2956

if (*const_item)

2957

return left_item->eq(*const_item, 1);

2958

*const_item=left_item;

2959

return 1;

10503

if (*const_item)

10504

return left_item->eq(*const_item, 1);

10505

*const_item=left_item;

10506

return 1;

2960

10507

}

2961

10508

}

2962

10509

}

2963

10510

return 0;

2964

10511

}

2965

10512

10513

2966

10514

/**

2967

10515

@details

2968

10516

Rows produced by a join sweep may end up in a temporary table or be sent

2974

10522

@return

2975

10523

end_select function to use. This function can't fail.

2976

10524

2977

Next_select_func setup_end_select_func(Join *join)

10525

10526

Next_select_func setup_end_select_func(JOIN *join)

2978

10527

{

2979

10528

Table *table= join->tmp_table;

2980

Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;

10529

TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;

2981

10530

Next_select_func end_select;

2982

10531

2983

10532

/* Set up select_end */

2984

10533

if (table)

2985

10534

{

2986

if (table->group && tmp_tbl->sum_func_count &&

10535

if (table->group && tmp_tbl->sum_func_count &&

2987

10536

!tmp_tbl->precomputed_group_by)

2988

10537

{

2989

if (table->getShare()->sizeKeys())

10538

if (table->s->keys)

2990

10539

{

2991

end_select= end_update;

10540

end_select=end_update;

2992

10541

}

2993

10542

else

2994

10543

{

2995

end_select= end_unique_update;

10544

end_select=end_unique_update;

2996

10545

}

2997

10546

}

2998

10547

else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)

2999

10548

{

3000

end_select= end_write_group;

10549

end_select=end_write_group;

3001

10550

}

3002

10551

else

3003

10552

{

3004

end_select= end_write;

10553

end_select=end_write;

3005

10554

if (tmp_tbl->precomputed_group_by)

3006

10555

{

3007

10556

3008

10557

A preceding call to create_tmp_table in the case when loose

3009

10558

index scan is used guarantees that

3010

Tmp_Table_Param::items_to_copy has enough space for the group

10559

TMP_TABLE_PARAM::items_to_copy has enough space for the group

3011

10560

by functions. It is OK here to use memcpy since we copy

3012

10561

Item_sum pointers into an array of Item pointers.

3013

10562

3029

10578

return end_select;

3030

10579

}

3031

10580

10581

3032

10582

/**

3033

10583

Make a join of all tables and write it on socket or to table.

3034

10584

3039

10589

@retval

3040

10590

-1 if error should be sent

3041

10591

3042

int do_select(Join *join, List<Item> *fields, Table *table)

10592

10593

static int

10594

do_select(JOIN *join,List<Item> *fields,Table *table)

3043

10595

{

3044

10596

int rc= 0;

3045

10597

enum_nested_loop_state error= NESTED_LOOP_OK;

3046

JoinTable *join_tab= NULL;

3047

10598

JOIN_TAB *join_tab= NULL;

10599

3048

10600

join->tmp_table= table; /* Save for easy recursion */

3049

10601

join->fields= fields;

3050

10602

3051

10603

if (table)

3052

10604

{

3053

table->cursor->extra(HA_EXTRA_WRITE_CACHE);

3054

table->emptyRecord();

10605

VOID(table->file->extra(HA_EXTRA_WRITE_CACHE));

10606

empty_record(table);

3055

10607

if (table->group && join->tmp_table_param.sum_func_count &&

3056

table->getShare()->sizeKeys() && !table->cursor->inited)

3057

{

3058

int tmp_error;

3059

tmp_error= table->cursor->startIndexScan(0, 0);

3060

if (tmp_error != 0)

3061

{

3062

table->print_error(tmp_error, MYF(0));

3063

return -1;

3064

}

3065

}

10608

table->s->keys && !table->file->inited)

10609

table->file->ha_index_init(0, 0);

3066

10610

}

3067

10611

/* Set up select_end */

3068

10612

Next_select_func end_select= setup_end_select_func(join);

3083

10627

{

3084

10628

error= (*end_select)(join, 0, 0);

3085

10629

if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)

3086

error= (*end_select)(join, 0, 1);

10630

error= (*end_select)(join, 0, 1);

3087

10631

3088

10632

3089

10633

If we don't go through evaluate_join_record(), do the counting

3091

10635

so we don't touch it here.

3092

10636

3093

10637

join->examined_rows++;

3094

join->session->row_count++;

10638

join->thd->row_count++;

3095

10639

assert(join->examined_rows <= 1);

3096

10640

}

3097

10641

else if (join->send_row_on_empty_set())

3121

10665

if (!table) // If sending data to client

3122

10666

{

3123

10667

3124

The following will unlock all cursors if the command wasn't an

3125

update command

10668

The following will unlock all cursors if the command wasn't an

10669

update command

3126

10670

3127

10671

join->join_free(); // Unlock all cursors

3128

10672

if (join->result->send_eof())

3129

rc= 1; // Don't send error

10673

rc= 1; // Don't send error

3130

10674

}

3131

10675

}

3132

10676

else

3134

10678

if (table)

3135

10679

{

3136

10680

int tmp, new_errno= 0;

3137

if ((tmp=table->cursor->extra(HA_EXTRA_NO_CACHE)))

10681

if ((tmp=table->file->extra(HA_EXTRA_NO_CACHE)))

3138

10682

{

3139

10683

new_errno= tmp;

3140

10684

}

3141

if ((tmp=table->cursor->ha_index_or_rnd_end()))

10685

if ((tmp=table->file->ha_index_or_rnd_end()))

3142

10686

{

3143

10687

new_errno= tmp;

3144

10688

}

3145

10689

if (new_errno)

3146

table->print_error(new_errno,MYF(0));

10690

table->file->print_error(new_errno,MYF(0));

3147

10691

}

3148

return(join->session->is_error() ? -1 : rc);

10692

return(join->thd->is_error() ? -1 : rc);

3149

10693

}

3150

10694

3151

enum_nested_loop_state sub_select_cache(Join *join, JoinTable *join_tab, bool end_of_records)

10695

10696

enum_nested_loop_state

10697

sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3152

10698

{

3153

10699

enum_nested_loop_state rc;

3154

10700

3159

10705

rc= sub_select(join,join_tab,end_of_records);

3160

10706

return rc;

3161

10707

}

3162

if (join->session->getKilled()) // If aborted by user

10708

if (join->thd->killed) // If aborted by user

3163

10709

{

3164

join->session->send_kill_message();

3165

return NESTED_LOOP_KILLED;

10710

join->thd->send_kill_message();

10711

return NESTED_LOOP_KILLED; /* purecov: inspected */

3166

10712

}

3167

10713

if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)

3168

10714

{

3169

if (! join_tab->cache.store_record_in_cache())

10715

if (!store_record_in_cache(&join_tab->cache))

3170

10716

return NESTED_LOOP_OK; // There is more room in cache

3171

10717

return flush_cached_records(join,join_tab,false);

3172

10718

}

3179

10725

/**

3180

10726

Retrieve records ends with a given beginning from the result of a join.

3181

10727

3182

For a given partial join record consisting of records from the tables

10728

For a given partial join record consisting of records from the tables

3183

10729

preceding the table join_tab in the execution plan, the function

3184

10730

retrieves all matching full records from the result set and

3185

send them to the result set stream.

10731

send them to the result set stream.

3186

10732

3187

10733

@note

3188

10734

The function effectively implements the final (n-k) nested loops

3222

10768

first row with t3.a=t1.a has been encountered.

3223

10769

Thus, the second predicate P2 is supplied with a guarded value that are

3224

10770

stored in the field 'found' of the first inner table for the outer join

3225

(table t2). When the first row with t3.a=t1.a for the current row

10771

(table t2). When the first row with t3.a=t1.a for the current row

3226

10772

of table t1 appears, the value becomes true. For now on the predicate

3227

10773

is evaluated immediately after the row of table t2 has been read.

3228

10774

When the first row with t3.a=t1.a has been encountered all

3230

10776

Only when all of them are true the row is sent to the output stream.

3231

10777

If not, the function returns to the lowest nest level that has a false

3232

10778

attached condition.

3233

The predicates from on expressions are also pushed down. If in the

10779

The predicates from on expressions are also pushed down. If in the

3234

10780

the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),

3235

10781

then t1.a=t2.a would be pushed down to table t2, and without any

3236

10782

guard.

3240

10786

is complemented by nulls for t2 and t3. Then the pushed down predicates

3241

10787

are checked for the composed row almost in the same way as it had

3242

10788

been done for the first row with a match. The only difference is

3243

the predicates from on expressions are not checked.

10789

the predicates from on expressions are not checked.

3244

10790

3245

10791

@par

3246

10792

@b IMPLEMENTATION

3256

10802

and a pointer to a guarding boolean variable.

3257

10803

When the value of the guard variable is true the value of the object

3258

10804

is the same as the value of the predicate, otherwise it's just returns

3259

true.

3260

To carry out a return to a nested loop level of join table t the pointer

10805

true.

10806

To carry out a return to a nested loop level of join table t the pointer

3261

10807

to t is remembered in the field 'return_tab' of the join structure.

3262

10808

Consider the following query:

3263

10809

@code

3274

10820

t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL

3275

10821

becomes 'activated', as well the predicate t4.a=t2.a. But

3276

10822

the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until

3277

t4.a=t2.a becomes true.

10823

t4.a=t2.a becomes true.

3278

10824

In order not to re-evaluate the predicates that were already evaluated

3279

10825

as attached pushed down predicates, a pointer to the the first

3280

10826

most inner unmatched table is maintained in join_tab->first_unmatched.

3281

10827

Thus, when the first row from t5 with t5.a=t3.a is found

3282

this pointer for t5 is changed from t4 to t2.

10828

this pointer for t5 is changed from t4 to t2.

3283

10829

3284

10830

@par

3285

10831

@b STRUCTURE @b NOTES

3290

10836

@param join pointer to the structure providing all context info for

3291

10837

the query

3292

10838

@param join_tab the first next table of the execution plan to be retrieved

3293

@param end_records true when we need to perform final steps of retrival

10839

@param end_records true when we need to perform final steps of retrival

3294

10840

3295

10841

@return

3296

10842

return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.

3297

10843

3298

enum_nested_loop_state sub_select(Join *join, JoinTable *join_tab, bool end_of_records)

10844

int do_sj_reset(SJ_TMP_TABLE *sj_tbl);

10845

10846

enum_nested_loop_state

10847

sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3299

10848

{

3300

10849

join_tab->table->null_row=0;

3301

10850

if (end_of_records)

3303

10852

3304

10853

int error;

3305

10854

enum_nested_loop_state rc;

3306

ReadRecord *info= &join_tab->read_record;

10855

READ_RECORD *info= &join_tab->read_record;

10856

10857

if (join_tab->flush_weedout_table)

10858

{

10859

do_sj_reset(join_tab->flush_weedout_table);

10860

}

3307

10861

3308

10862

if (join->resume_nested_loop)

3309

10863

{

3331

10885

/* Set first_unmatched for the last inner table of this group */

3332

10886

join_tab->last_inner->first_unmatched= join_tab;

3333

10887

}

3334

join->session->row_count= 0;

10888

join->thd->row_count= 0;

3335

10889

3336

10890

error= (*join_tab->read_first_record)(join_tab);

3337

10891

rc= evaluate_join_record(join, join_tab, error);

3338

10892

}

3339

3340

3341

Note: psergey has added the 2nd part of the following condition; the

10893

10894

10895

Note: psergey has added the 2nd part of the following condition; the

3342

10896

change should probably be made in 5.1, too.

3343

10897

3344

10898

while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)

3356

10910

return rc;

3357

10911

}

3358

10912

3359

int safe_index_read(JoinTable *tab)

10913

10914

10915

10916

10917

SemiJoinDuplicateElimination: Weed out duplicate row combinations

10918

10919

SYNPOSIS

10920

do_sj_dups_weedout()

10921

10922

RETURN

10923

-1 Error

10924

1 The row combination is a duplicate (discard it)

10925

0 The row combination is not a duplicate (continue)

10926

10927

10928

int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl)

10929

{

10930

int error;

10931

SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;

10932

SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;

10933

uchar *ptr= sjtbl->tmp_table->record[0] + 1;

10934

uchar *nulls_ptr= ptr;

10935

10936

/* Put the the rowids tuple into table->record[0]: */

10937

10938

// 1. Store the length

10939

if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)

10940

{

10941

*ptr= (uchar)(sjtbl->rowid_len + sjtbl->null_bytes);

10942

ptr++;

10943

}

10944

else

10945

{

10946

int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);

10947

ptr += 2;

10948

}

10949

10950

// 2. Zero the null bytes

10951

if (sjtbl->null_bytes)

10952

{

10953

memset(ptr, 0, sjtbl->null_bytes);

10954

ptr += sjtbl->null_bytes;

10955

}

10956

10957

// 3. Put the rowids

10958

for (uint i=0; tab != tab_end; tab++, i++)

10959

{

10960

handler *h= tab->join_tab->table->file;

10961

if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)

10962

{

10963

/* It's a NULL-complemented row */

10964

*(nulls_ptr + tab->null_byte) |= tab->null_bit;

10965

memset(ptr + tab->rowid_offset, 0, h->ref_length);

10966

}

10967

else

10968

{

10969

/* Copy the rowid value */

10970

if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)

10971

h->position(tab->join_tab->table->record[0]);

10972

memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);

10973

}

10974

}

10975

10976

error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);

10977

if (error)

10978

{

10979

/* create_myisam_from_heap will generate error if needed */

10980

if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&

10981

create_myisam_from_heap(thd, sjtbl->tmp_table, sjtbl->start_recinfo,

10982

&sjtbl->recinfo, error, 1))

10983

return -1;

10984

//return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;

10985

return 1;

10986

}

10987

return 0;

10988

}

10989

10990

10991

10992

SemiJoinDuplicateElimination: Reset the temporary table

10993

10994

10995

int do_sj_reset(SJ_TMP_TABLE *sj_tbl)

10996

{

10997

if (sj_tbl->tmp_table)

10998

return sj_tbl->tmp_table->file->ha_delete_all_rows();

10999

return 0;

11000

}

11001

11002

11003

Process one record of the nested loop join.

11004

11005

This function will evaluate parts of WHERE/ON clauses that are

11006

applicable to the partial record on hand and in case of success

11007

submit this record to the next level of the nested loop.

11008

11009

11010

static enum_nested_loop_state

11011

evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,

11012

int error)

11013

{

11014

bool not_used_in_distinct=join_tab->not_used_in_distinct;

11015

ha_rows found_records=join->found_records;

11016

COND *select_cond= join_tab->select_cond;

11017

11018

if (error > 0 || (join->thd->is_error())) // Fatal error

11019

return NESTED_LOOP_ERROR;

11020

if (error < 0)

11021

return NESTED_LOOP_NO_MORE_ROWS;

11022

if (join->thd->killed) // Aborted by user

11023

{

11024

join->thd->send_kill_message();

11025

return NESTED_LOOP_KILLED; /* purecov: inspected */

11026

}

11027

if (!select_cond || select_cond->val_int())

11028

{

11029

11030

There is no select condition or the attached pushed down

11031

condition is true => a match is found.

11032

11033

bool found= 1;

11034

while (join_tab->first_unmatched && found)

11035

{

11036

11037

The while condition is always false if join_tab is not

11038

the last inner join table of an outer join operation.

11039

11040

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11041

11042

Mark that a match for current outer table is found.

11043

This activates push down conditional predicates attached

11044

to the all inner tables of the outer join.

11045

11046

first_unmatched->found= 1;

11047

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11048

{

11049

if (tab->table->reginfo.not_exists_optimize)

11050

return NESTED_LOOP_NO_MORE_ROWS;

11051

/* Check all predicates that has just been activated. */

11052

11053

Actually all predicates non-guarded by first_unmatched->found

11054

will be re-evaluated again. It could be fixed, but, probably,

11055

it's not worth doing now.

11056

11057

if (tab->select_cond && !tab->select_cond->val_int())

11058

{

11059

/* The condition attached to table tab is false */

11060

if (tab == join_tab)

11061

found= 0;

11062

else

11063

{

11064

11065

Set a return point if rejected predicate is attached

11066

not to the last table of the current nest level.

11067

11068

join->return_tab= tab;

11069

return NESTED_LOOP_OK;

11070

}

11071

}

11072

}

11073

11074

Check whether join_tab is not the last inner table

11075

for another embedding outer join.

11076

11077

if ((first_unmatched= first_unmatched->first_upper) &&

11078

first_unmatched->last_inner != join_tab)

11079

first_unmatched= 0;

11080

join_tab->first_unmatched= first_unmatched;

11081

}

11082

11083

JOIN_TAB *return_tab= join->return_tab;

11084

join_tab->found_match= true;

11085

if (join_tab->check_weed_out_table)

11086

{

11087

int res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table);

11088

if (res == -1)

11089

return NESTED_LOOP_ERROR;

11090

if (res == 1)

11091

return NESTED_LOOP_OK;

11092

}

11093

else if (join_tab->do_firstmatch)

11094

{

11095

11096

We should return to the join_tab->do_firstmatch after we have

11097

enumerated all the suffixes for current prefix row combination

11098

11099

return_tab= join_tab->do_firstmatch;

11100

}

11101

11102

11103

It was not just a return to lower loop level when one

11104

of the newly activated predicates is evaluated as false

11105

(See above join->return_tab= tab).

11106

11107

join->examined_rows++;

11108

join->thd->row_count++;

11109

11110

if (found)

11111

{

11112

enum enum_nested_loop_state rc;

11113

/* A match from join_tab is found for the current partial join. */

11114

rc= (*join_tab->next_select)(join, join_tab+1, 0);

11115

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11116

return rc;

11117

if (return_tab < join->return_tab)

11118

join->return_tab= return_tab;

11119

11120

if (join->return_tab < join_tab)

11121

return NESTED_LOOP_OK;

11122

11123

Test if this was a SELECT DISTINCT query on a table that

11124

was not in the field list; In this case we can abort if

11125

we found a row, as no new rows can be added to the result.

11126

11127

if (not_used_in_distinct && found_records != join->found_records)

11128

return NESTED_LOOP_NO_MORE_ROWS;

11129

}

11130

else

11131

join_tab->read_record.file->unlock_row();

11132

}

11133

else

11134

{

11135

11136

The condition pushed down to the table join_tab rejects all rows

11137

with the beginning coinciding with the current partial join.

11138

11139

join->examined_rows++;

11140

join->thd->row_count++;

11141

join_tab->read_record.file->unlock_row();

11142

}

11143

return NESTED_LOOP_OK;

11144

}

11145

11146

11147

/**

11148

11149

@details

11150

Construct a NULL complimented partial join record and feed it to the next

11151

level of the nested loop. This function is used in case we have

11152

an OUTER join and no matching record was found.

11153

11154

11155

static enum_nested_loop_state

11156

evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab)

11157

{

11158

11159

The table join_tab is the first inner table of a outer join operation

11160

and no matches has been found for the current outer row.

11161

11162

JOIN_TAB *last_inner_tab= join_tab->last_inner;

11163

/* Cache variables for faster loop */

11164

COND *select_cond;

11165

for ( ; join_tab <= last_inner_tab ; join_tab++)

11166

{

11167

/* Change the the values of guard predicate variables. */

11168

join_tab->found= 1;

11169

join_tab->not_null_compl= 0;

11170

/* The outer row is complemented by nulls for each inner tables */

11171

restore_record(join_tab->table,s->default_values); // Make empty record

11172

mark_as_null_row(join_tab->table); // For group by without error

11173

select_cond= join_tab->select_cond;

11174

/* Check all attached conditions for inner table rows. */

11175

if (select_cond && !select_cond->val_int())

11176

return NESTED_LOOP_OK;

11177

}

11178

join_tab--;

11179

11180

The row complemented by nulls might be the first row

11181

of embedding outer joins.

11182

If so, perform the same actions as in the code

11183

for the first regular outer join row above.

11184

11185

for ( ; ; )

11186

{

11187

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11188

if ((first_unmatched= first_unmatched->first_upper) &&

11189

first_unmatched->last_inner != join_tab)

11190

first_unmatched= 0;

11191

join_tab->first_unmatched= first_unmatched;

11192

if (!first_unmatched)

11193

break;

11194

first_unmatched->found= 1;

11195

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11196

{

11197

if (tab->select_cond && !tab->select_cond->val_int())

11198

{

11199

join->return_tab= tab;

11200

return NESTED_LOOP_OK;

11201

}

11202

}

11203

}

11204

11205

The row complemented by nulls satisfies all conditions

11206

attached to inner tables.

11207

Send the row complemented by nulls to be joined with the

11208

remaining tables.

11209

11210

return (*join_tab->next_select)(join, join_tab+1, 0);

11211

}

11212

11213

11214

static enum_nested_loop_state

11215

flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skip_last)

11216

{

11217

enum_nested_loop_state rc= NESTED_LOOP_OK;

11218

int error;

11219

READ_RECORD *info;

11220

11221

join_tab->table->null_row= 0;

11222

if (!join_tab->cache.records)

11223

return NESTED_LOOP_OK; /* Nothing to do */

11224

if (skip_last)

11225

(void) store_record_in_cache(&join_tab->cache); // Must save this for later

11226

if (join_tab->use_quick == 2)

11227

{

11228

if (join_tab->select->quick)

11229

{ /* Used quick select last. reset it */

11230

delete join_tab->select->quick;

11231

join_tab->select->quick=0;

11232

}

11233

}

11234

/* read through all records */

11235

if ((error=join_init_read_record(join_tab)))

11236

{

11237

reset_cache_write(&join_tab->cache);

11238

return error < 0 ? NESTED_LOOP_NO_MORE_ROWS: NESTED_LOOP_ERROR;

11239

}

11240

11241

for (JOIN_TAB *tmp=join->join_tab; tmp != join_tab ; tmp++)

11242

{

11243

tmp->status=tmp->table->status;

11244

tmp->table->status=0;

11245

}

11246

11247

info= &join_tab->read_record;

11248

11249

{

11250

if (join->thd->killed)

11251

{

11252

join->thd->send_kill_message();

11253

return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */

11254

}

11255

SQL_SELECT *select=join_tab->select;

11256

if (rc == NESTED_LOOP_OK &&

11257

(!join_tab->cache.select || !join_tab->cache.select->skip_record()))

11258

{

11259

uint i;

11260

reset_cache_read(&join_tab->cache);

11261

for (i=(join_tab->cache.records- (skip_last ? 1 : 0)) ; i-- > 0 ;)

11262

{

11263

read_cached_record(join_tab);

11264

if (!select || !select->skip_record())

11265

{

11266

int res= 0;

11267

if (!join_tab->check_weed_out_table ||

11268

!(res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table)))

11269

{

11270

rc= (join_tab->next_select)(join,join_tab+1,0);

11271

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11272

{

11273

reset_cache_write(&join_tab->cache);

11274

return rc;

11275

}

11276

}

11277

if (res == -1)

11278

return NESTED_LOOP_ERROR;

11279

}

11280

}

11281

}

11282

} while (!(error=info->read_record(info)));

11283

11284

if (skip_last)

11285

read_cached_record(join_tab); // Restore current record

11286

reset_cache_write(&join_tab->cache);

11287

if (error > 0) // Fatal error

11288

return NESTED_LOOP_ERROR; /* purecov: inspected */

11289

for (JOIN_TAB *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)

11290

tmp2->table->status=tmp2->status;

11291

return NESTED_LOOP_OK;

11292

}

11293

11294

int safe_index_read(JOIN_TAB *tab)

3360

11295

{

3361

11296

int error;

3362

11297

Table *table= tab->table;

3363

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11298

if ((error=table->file->index_read_map(table->record[0],

3364

11299

tab->ref.key_buff,

3365

11300

make_prev_keypart_map(tab->ref.key_parts),

3366

11301

HA_READ_KEY_EXACT)))

3368

11303

return 0;

3369

11304

}

3370

11305

11306

11307

static int

11308

join_read_const_table(JOIN_TAB *tab, POSITION *pos)

11309

{

11310

int error;

11311

Table *table=tab->table;

11312

table->const_table=1;

11313

table->null_row=0;

11314

table->status=STATUS_NO_RECORD;

11315

11316

if (tab->type == JT_SYSTEM)

11317

{

11318

if ((error=join_read_system(tab)))

11319

{ // Info for DESCRIBE

11320

tab->info="const row not found";

11321

/* Mark for EXPLAIN that the row was not found */

11322

pos->records_read=0.0;

11323

pos->ref_depend_map= 0;

11324

if (!table->maybe_null || error > 0)

11325

return(error);

11326

}

11327

}

11328

else

11329

{

11330

if (!table->key_read && table->covering_keys.is_set(tab->ref.key) &&

11331

!table->no_keyread &&

11332

(int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY)

11333

{

11334

table->key_read=1;

11335

table->file->extra(HA_EXTRA_KEYREAD);

11336

tab->index= tab->ref.key;

11337

}

11338

error=join_read_const(tab);

11339

if (table->key_read)

11340

{

11341

table->key_read=0;

11342

table->file->extra(HA_EXTRA_NO_KEYREAD);

11343

}

11344

if (error)

11345

{

11346

tab->info="unique row not found";

11347

/* Mark for EXPLAIN that the row was not found */

11348

pos->records_read=0.0;

11349

pos->ref_depend_map= 0;

11350

if (!table->maybe_null || error > 0)

11351

return(error);

11352

}

11353

}

11354

if (*tab->on_expr_ref && !table->null_row)

11355

{

11356

if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))

11357

mark_as_null_row(table);

11358

}

11359

if (!table->null_row)

11360

table->maybe_null=0;

11361

11362

/* Check appearance of new constant items in Item_equal objects */

11363

JOIN *join= tab->join;

11364

if (join->conds)

11365

update_const_equal_items(join->conds, tab);

11366

TableList *tbl;

11367

for (tbl= join->select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)

11368

{

11369

TableList *embedded;

11370

TableList *embedding= tbl;

11371

11372

{

11373

embedded= embedding;

11374

if (embedded->on_expr)

11375

update_const_equal_items(embedded->on_expr, tab);

11376

embedding= embedded->embedding;

11377

}

11378

while (embedding &&

11379

embedding->nested_join->join_list.head() == embedded);

11380

}

11381

11382

return(0);

11383

}

11384

11385

11386

static int

11387

join_read_system(JOIN_TAB *tab)

11388

{

11389

Table *table= tab->table;

11390

int error;

11391

if (table->status & STATUS_GARBAGE) // If first read

11392

{

11393

if ((error=table->file->read_first_row(table->record[0],

11394

table->s->primary_key)))

11395

{

11396

if (error != HA_ERR_END_OF_FILE)

11397

return table->report_error(error);

11398

mark_as_null_row(tab->table);

11399

empty_record(table); // Make empty record

11400

return -1;

11401

}

11402

store_record(table,record[1]);

11403

}

11404

else if (!table->status) // Only happens with left join

11405

restore_record(table,record[1]); // restore old record

11406

table->null_row=0;

11407

return table->status ? -1 : 0;

11408

}

11409

11410

3371

11411

/**

3372

11412

Read a (constant) table when there is at most one matching row.

3373

11413

3380

11420

@retval

3381

11421

1 Got an error (other than row not found) during read

3382

11422

3383

int join_read_const(JoinTable *tab)

11423

11424

static int

11425

join_read_const(JOIN_TAB *tab)

3384

11426

{

3385

11427

int error;

3386

11428

Table *table= tab->table;

3387

11429

if (table->status & STATUS_GARBAGE) // If first read

3388

11430

{

3389

11431

table->status= 0;

3390

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

3391

error= HA_ERR_KEY_NOT_FOUND;

11432

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

11433

error=HA_ERR_KEY_NOT_FOUND;

3392

11434

else

3393

11435

{

3394

error=table->cursor->index_read_idx_map(table->getInsertRecord(),tab->ref.key,

3395

(unsigned char*) tab->ref.key_buff,

11436

error=table->file->index_read_idx_map(table->record[0],tab->ref.key,

11437

(uchar*) tab->ref.key_buff,

3396

11438

make_prev_keypart_map(tab->ref.key_parts),

3397

11439

HA_READ_KEY_EXACT);

3398

11440

}

3399

11441

if (error)

3400

11442

{

3401

11443

table->status= STATUS_NOT_FOUND;

3402

tab->table->mark_as_null_row();

3403

table->emptyRecord();

11444

mark_as_null_row(tab->table);

11445

empty_record(table);

3404

11446

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3405

return table->report_error(error);

11447

return table->report_error(error);

3406

11448

return -1;

3407

11449

}

3408

table->storeRecord();

11450

store_record(table,record[1]);

3409

11451

}

3410

11452

else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join

3411

11453

{

3412

11454

table->status=0;

3413

table->restoreRecord(); // restore old record

11455

restore_record(table,record[1]); // restore old record

3414

11456

}

3415

11457

table->null_row=0;

3416

11458

return table->status ? -1 : 0;

3417

11459

}

3418

11460

11461

3419

11462

3420

11463

eq_ref access method implementation: "read_first" function

3421

11464

3422

11465

SYNOPSIS

3423

11466

join_read_key()

3424

tab JoinTable of the accessed table

11467

tab JOIN_TAB of the accessed table

3425

11468

3426

11469

DESCRIPTION

3427

11470

This is "read_fist" function for the "ref" access method. The difference

3429

11472

3430

11473

RETURN

3431

11474

0 - Ok

3432

-1 - Row not found

11475

-1 - Row not found

3433

11476

1 - Error

3434

11477

3435

int join_read_key(JoinTable *tab)

11478

11479

static int

11480

join_read_key(JOIN_TAB *tab)

3436

11481

{

3437

11482

int error;

3438

11483

Table *table= tab->table;

3439

11484

3440

if (!table->cursor->inited)

11485

if (!table->file->inited)

3441

11486

{

3442

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3443

if (error != 0)

3444

{

3445

table->print_error(error, MYF(0));

3446

}

11487

table->file->ha_index_init(tab->ref.key, tab->sorted);

3447

11488

}

3448

11489

3449

11490

/* TODO: Why don't we do "Late NULLs Filtering" here? */

3455

11496

table->status=STATUS_NOT_FOUND;

3456

11497

return -1;

3457

11498

}

3458

error=table->cursor->index_read_map(table->getInsertRecord(),

11499

error=table->file->index_read_map(table->record[0],

3459

11500

tab->ref.key_buff,

3460

11501

make_prev_keypart_map(tab->ref.key_parts),

3461

11502

HA_READ_KEY_EXACT);

3466

11507

return table->status ? -1 : 0;

3467

11508

}

3468

11509

11510

3469

11511

3470

11512

ref access method implementation: "read_first" function

3471

11513

3472

11514

SYNOPSIS

3473

11515

join_read_always_key()

3474

tab JoinTable of the accessed table

11516

tab JOIN_TAB of the accessed table

3475

11517

3476

11518

DESCRIPTION

3477

This is "read_first" function for the "ref" access method.

3478

11519

This is "read_fist" function for the "ref" access method.

11520

3479

11521

The functon must leave the index initialized when it returns.

3480

11522

ref_or_null access implementation depends on that.

3481

11523

3482

11524

RETURN

3483

11525

0 - Ok

3484

-1 - Row not found

11526

-1 - Row not found

3485

11527

1 - Error

3486

11528

3487

int join_read_always_key(JoinTable *tab)

11529

11530

static int

11531

join_read_always_key(JOIN_TAB *tab)

3488

11532

{

3489

11533

int error;

3490

11534

Table *table= tab->table;

3491

11535

3492

11536

/* Initialize the index first */

3493

if (!table->cursor->inited)

3494

{

3495

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3496

if (error != 0)

3497

return table->report_error(error);

3498

}

3499

11537

if (!table->file->inited)

11538

table->file->ha_index_init(tab->ref.key, tab->sorted);

11539

3500

11540

/* Perform "Late NULLs Filtering" (see internals manual for explanations) */

3501

for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)

11541

for (uint i= 0 ; i < tab->ref.key_parts ; i++)

3502

11542

{

3503

11543

if ((tab->ref.null_rejecting & 1 << i) && tab->ref.items[i]->is_null())

3504

11544

return -1;

3505

11545

}

3506

11546

3507

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11547

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3508

11548

return -1;

3509

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11549

if ((error=table->file->index_read_map(table->record[0],

3510

11550

tab->ref.key_buff,

3511

11551

make_prev_keypart_map(tab->ref.key_parts),

3512

11552

HA_READ_KEY_EXACT)))

3513

11553

{

3514

11554

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3515

11555

return table->report_error(error);

3516

return -1;

11556

return -1; /* purecov: inspected */

3517

11557

}

3518

3519

11558

return 0;

3520

11559

}

3521

11560

11561

3522

11562

/**

3523

This function is used when optimizing away ORDER BY in

3524

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

11563

This function is used when optimizing away order_st BY in

11564

SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.

3525

11565

3526

int join_read_last_key(JoinTable *tab)

11566

11567

static int

11568

join_read_last_key(JOIN_TAB *tab)

3527

11569

{

3528

11570

int error;

3529

11571

Table *table= tab->table;

3530

11572

3531

if (!table->cursor->inited)

3532

{

3533

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3534

if (error != 0)

3535

return table->report_error(error);

3536

}

3537

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11573

if (!table->file->inited)

11574

table->file->ha_index_init(tab->ref.key, tab->sorted);

11575

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3538

11576

return -1;

3539

if ((error=table->cursor->index_read_last_map(table->getInsertRecord(),

11577

if ((error=table->file->index_read_last_map(table->record[0],

3540

11578

tab->ref.key_buff,

3541

11579

make_prev_keypart_map(tab->ref.key_parts))))

3542

11580

{

3543

11581

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3544

11582

return table->report_error(error);

3545

return -1;

11583

return -1; /* purecov: inspected */

3546

11584

}

3547

11585

return 0;

3548

11586

}

3549

11587

3550

int join_no_more_records(ReadRecord *)

11588

11589

/* ARGSUSED */

11590

static int

11591

join_no_more_records(READ_RECORD *info __attribute__((unused)))

3551

11592

{

3552

11593

return -1;

3553

11594

}

3554

11595

3555

int join_read_next_same_diff(ReadRecord *info)

11596

static int

11597

join_read_next_same_diff(READ_RECORD *info)

3556

11598

{

3557

11599

Table *table= info->table;

3558

JoinTable *tab=table->reginfo.join_tab;

11600

JOIN_TAB *tab=table->reginfo.join_tab;

3559

11601

if (tab->insideout_match_tab->found_match)

3560

11602

{

3561

KeyInfo *key= tab->table->key_info + tab->index;

3562

11603

KEY *key= tab->table->key_info + tab->index;

11604

3563

11605

{

3564

11606

int error;

3565

11607

/* Save index tuple from record to the buffer */

3566

11608

key_copy(tab->insideout_buf, info->record, key, 0);

3567

11609

3568

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11610

if ((error=table->file->index_next_same(table->record[0],

3569

11611

tab->ref.key_buff,

3570

11612

tab->ref.key_length)))

3571

11613

{

3574

11616

table->status= STATUS_GARBAGE;

3575

11617

return -1;

3576

11618

}

3577

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11619

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3578

11620

tab->insideout_buf, key->key_length));

3579

11621

tab->insideout_match_tab->found_match= 0;

3580

11622

return 0;

3583

11625

return join_read_next_same(info);

3584

11626

}

3585

11627

3586

int join_read_next_same(ReadRecord *info)

11628

static int

11629

join_read_next_same(READ_RECORD *info)

3587

11630

{

3588

11631

int error;

3589

11632

Table *table= info->table;

3590

JoinTable *tab=table->reginfo.join_tab;

11633

JOIN_TAB *tab=table->reginfo.join_tab;

3591

11634

3592

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11635

if ((error=table->file->index_next_same(table->record[0],

3593

11636

tab->ref.key_buff,

3594

11637

tab->ref.key_length)))

3595

11638

{

3598

11641

table->status= STATUS_GARBAGE;

3599

11642

return -1;

3600

11643

}

3601

3602

11644

return 0;

3603

11645

}

3604

11646

3605

int join_read_prev_same(ReadRecord *info)

11647

11648

static int

11649

join_read_prev_same(READ_RECORD *info)

3606

11650

{

3607

11651

int error;

3608

11652

Table *table= info->table;

3609

JoinTable *tab=table->reginfo.join_tab;

11653

JOIN_TAB *tab=table->reginfo.join_tab;

3610

11654

3611

if ((error=table->cursor->index_prev(table->getInsertRecord())))

11655

if ((error=table->file->index_prev(table->record[0])))

3612

11656

return table->report_error(error);

3613

11657

if (key_cmp_if_same(table, tab->ref.key_buff, tab->ref.key,

3614

11658

tab->ref.key_length))

3619

11663

return error;

3620

11664

}

3621

11665

3622

int join_init_quick_read_record(JoinTable *tab)

11666

11667

static int

11668

join_init_quick_read_record(JOIN_TAB *tab)

3623

11669

{

3624

11670

if (test_if_quick_select(tab) == -1)

3625

11671

return -1; /* No possible records */

3626

11672

return join_init_read_record(tab);

3627

11673

}

3628

11674

3629

int init_read_record_seq(JoinTable *tab)

11675

11676

int rr_sequential(READ_RECORD *info);

11677

int init_read_record_seq(JOIN_TAB *tab)

3630

11678

{

3631

tab->read_record.init_reard_record_sequential();

3632

3633

if (tab->read_record.cursor->startTableScan(1))

11679

tab->read_record.read_record= rr_sequential;

11680

if (tab->read_record.file->ha_rnd_init(1))

3634

11681

return 1;

3635

11682

return (*tab->read_record.read_record)(&tab->read_record);

3636

11683

}

3637

11684

3638

int test_if_quick_select(JoinTable *tab)

11685

static int

11686

test_if_quick_select(JOIN_TAB *tab)

3639

11687

{

3640

11688

delete tab->select->quick;

3641

tab->select->quick= 0;

3642

return tab->select->test_quick_select(tab->join->session, tab->keys,

3643

(table_map) 0, HA_POS_ERROR, 0, false);

11689

tab->select->quick=0;

11690

return tab->select->test_quick_select(tab->join->thd, tab->keys,

11691

(table_map) 0, HA_POS_ERROR, 0,

11692

false);

3644

11693

}

3645

11694

3646

int join_init_read_record(JoinTable *tab)

11695

11696

static int

11697

join_init_read_record(JOIN_TAB *tab)

3647

11698

{

3648

11699

if (tab->select && tab->select->quick && tab->select->quick->reset())

3649

11700

return 1;

3650

3651

if (tab->read_record.init_read_record(tab->join->session, tab->table, tab->select, 1, true))

3652

return 1;

3653

11701

init_read_record(&tab->read_record, tab->join->thd, tab->table,

11702

tab->select,1,1);

3654

11703

return (*tab->read_record.read_record)(&tab->read_record);

3655

11704

}

3656

11705

3657

int join_read_first(JoinTable *tab)

11706

11707

static int

11708

join_read_first(JOIN_TAB *tab)

3658

11709

{

3659

11710

int error;

3660

11711

Table *table=tab->table;

3661

if (!table->key_read && table->covering_keys.test(tab->index) &&

11712

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3662

11713

!table->no_keyread)

3663

11714

{

3664

table->key_read= 1;

3665

table->cursor->extra(HA_EXTRA_KEYREAD);

11715

table->key_read=1;

11716

table->file->extra(HA_EXTRA_KEYREAD);

3666

11717

}

3667

tab->table->status= 0;

11718

tab->table->status=0;

3668

11719

tab->read_record.table=table;

3669

tab->read_record.cursor=table->cursor;

11720

tab->read_record.file=table->file;

3670

11721

tab->read_record.index=tab->index;

3671

tab->read_record.record=table->getInsertRecord();

11722

tab->read_record.record=table->record[0];

3672

11723

if (tab->insideout_match_tab)

3673

11724

{

3674

11725

tab->read_record.do_insideout_scan= tab;

3681

11732

tab->read_record.do_insideout_scan= 0;

3682

11733

}

3683

11734

3684

if (!table->cursor->inited)

3685

{

3686

error= table->cursor->startIndexScan(tab->index, tab->sorted);

3687

if (error != 0)

3688

{

3689

table->report_error(error);

3690

return -1;

3691

}

3692

}

3693

if ((error=tab->table->cursor->index_first(tab->table->getInsertRecord())))

11735

if (!table->file->inited)

11736

table->file->ha_index_init(tab->index, tab->sorted);

11737

if ((error=tab->table->file->index_first(tab->table->record[0])))

3694

11738

{

3695

11739

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3696

11740

table->report_error(error);

3697

11741

return -1;

3698

11742

}

3699

3700

11743

return 0;

3701

11744

}

3702

11745

3703

int join_read_next_different(ReadRecord *info)

11746

11747

static int

11748

join_read_next_different(READ_RECORD *info)

3704

11749

{

3705

JoinTable *tab= info->do_insideout_scan;

11750

JOIN_TAB *tab= info->do_insideout_scan;

3706

11751

if (tab->insideout_match_tab->found_match)

3707

11752

{

3708

KeyInfo *key= tab->table->key_info + tab->index;

3709

11753

KEY *key= tab->table->key_info + tab->index;

11754

3710

11755

{

3711

11756

int error;

3712

11757

/* Save index tuple from record to the buffer */

3713

11758

key_copy(tab->insideout_buf, info->record, key, 0);

3714

11759

3715

if ((error=info->cursor->index_next(info->record)))

11760

if ((error=info->file->index_next(info->record)))

3716

11761

return info->table->report_error(error);

3717

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11762

11763

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3718

11764

tab->insideout_buf, key->key_length));

3719

11765

tab->insideout_match_tab->found_match= 0;

3720

11766

return 0;

3723

11769

return join_read_next(info);

3724

11770

}

3725

11771

3726

int join_read_next(ReadRecord *info)

11772

11773

static int

11774

join_read_next(READ_RECORD *info)

3727

11775

{

3728

11776

int error;

3729

if ((error=info->cursor->index_next(info->record)))

11777

if ((error=info->file->index_next(info->record)))

3730

11778

return info->table->report_error(error);

3731

11779

return 0;

3732

11780

}

3733

11781

3734

int join_read_last(JoinTable *tab)

11782

11783

static int

11784

join_read_last(JOIN_TAB *tab)

3735

11785

{

3736

11786

Table *table=tab->table;

3737

11787

int error;

3738

if (!table->key_read && table->covering_keys.test(tab->index) &&

11788

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3739

11789

!table->no_keyread)

3740

11790

{

3741

11791

table->key_read=1;

3742

table->cursor->extra(HA_EXTRA_KEYREAD);

11792

table->file->extra(HA_EXTRA_KEYREAD);

3743

11793

}

3744

11794

tab->table->status=0;

3745

11795

tab->read_record.read_record=join_read_prev;

3746

11796

tab->read_record.table=table;

3747

tab->read_record.cursor=table->cursor;

11797

tab->read_record.file=table->file;

3748

11798

tab->read_record.index=tab->index;

3749

tab->read_record.record=table->getInsertRecord();

3750

if (!table->cursor->inited)

3751

{

3752

error= table->cursor->startIndexScan(tab->index, 1);

3753

if (error != 0)

3754

return table->report_error(error);

3755

}

3756

if ((error= tab->table->cursor->index_last(tab->table->getInsertRecord())))

11799

tab->read_record.record=table->record[0];

11800

if (!table->file->inited)

11801

table->file->ha_index_init(tab->index, 1);

11802

if ((error= tab->table->file->index_last(tab->table->record[0])))

3757

11803

return table->report_error(error);

3758

3759

11804

return 0;

3760

11805

}

3761

11806

3762

int join_read_prev(ReadRecord *info)

11807

11808

static int

11809

join_read_prev(READ_RECORD *info)

3763

11810

{

3764

11811

int error;

3765

if ((error= info->cursor->index_prev(info->record)))

11812

if ((error= info->file->index_prev(info->record)))

3766

11813

return info->table->report_error(error);

3767

3768

11814

return 0;

3769

11815

}

3770

11816

3771

11817

/**

3772

11818

Reading of key with key reference and one part that may be NULL.

3773

11819

3774

int join_read_always_key_or_null(JoinTable *tab)

11820

11821

int

11822

join_read_always_key_or_null(JOIN_TAB *tab)

3775

11823

{

3776

11824

int res;

3777

11825

3785

11833

return safe_index_read(tab);

3786

11834

}

3787

11835

3788

int join_read_next_same_or_null(ReadRecord *info)

11836

11837

int

11838

join_read_next_same_or_null(READ_RECORD *info)

3789

11839

{

3790

11840

int error;

3791

11841

if ((error= join_read_next_same(info)) >= 0)

3792

11842

return error;

3793

JoinTable *tab= info->table->reginfo.join_tab;

11843

JOIN_TAB *tab= info->table->reginfo.join_tab;

3794

11844

3795

11845

/* Test if we have already done a read after null key */

3796

11846

if (*tab->ref.null_ref_key)

3799

11849

return safe_index_read(tab); // then read null keys

3800

11850

}

3801

11851

3802

enum_nested_loop_state end_send_group(Join *join, JoinTable *, bool end_of_records)

11852

11853

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

11854

DESCRIPTION

11855

Functions that end one nested loop iteration. Different functions

11856

are used to support GROUP BY clause and to redirect records

11857

to a table (e.g. in case of SELECT into a temporary table) or to the

11858

network client.

11859

11860

RETURN VALUES

11861

NESTED_LOOP_OK - the record has been successfully handled

11862

NESTED_LOOP_ERROR - a fatal error (like table corruption)

11863

was detected

11864

NESTED_LOOP_KILLED - thread shutdown was requested while processing

11865

the record

11866

NESTED_LOOP_QUERY_LIMIT - the record has been successfully handled;

11867

additionally, the nested loop produced the

11868

number of rows specified in the LIMIT clause

11869

for the query

11870

NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;

11871

additionally, there is a cursor and the nested

11872

loop algorithm produced the number of rows

11873

that is specified for current cursor fetch

11874

operation.

11875

All return values except NESTED_LOOP_OK abort the nested loop.

11876

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

11877

11878

/* ARGSUSED */

11879

static enum_nested_loop_state

11880

end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11881

bool end_of_records)

11882

{

11883

if (!end_of_records)

11884

{

11885

int error;

11886

if (join->having && join->having->val_int() == 0)

11887

return(NESTED_LOOP_OK); // Didn't match having

11888

error=0;

11889

if (join->do_send_rows)

11890

error=join->result->send_data(*join->fields);

11891

if (error)

11892

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11893

if (++join->send_records >= join->unit->select_limit_cnt &&

11894

join->do_send_rows)

11895

{

11896

if (join->select_options & OPTION_FOUND_ROWS)

11897

{

11898

JOIN_TAB *jt=join->join_tab;

11899

if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group

11900

&& !join->send_group_parts && !join->having && !jt->select_cond &&

11901

!(jt->select && jt->select->quick) &&

11902

(jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&

11903

(jt->ref.key < 0))

11904

{

11905

/* Join over all rows in table; Return number of found rows */

11906

Table *table=jt->table;

11907

11908

join->select_options ^= OPTION_FOUND_ROWS;

11909

if (table->sort.record_pointers ||

11910

(table->sort.io_cache && my_b_inited(table->sort.io_cache)))

11911

{

11912

/* Using filesort */

11913

join->send_records= table->sort.found_records;

11914

}

11915

else

11916

{

11917

table->file->info(HA_STATUS_VARIABLE);

11918

join->send_records= table->file->stats.records;

11919

}

11920

}

11921

else

11922

{

11923

join->do_send_rows= 0;

11924

if (join->unit->fake_select_lex)

11925

join->unit->fake_select_lex->select_limit= 0;

11926

return(NESTED_LOOP_OK);

11927

}

11928

}

11929

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11930

}

11931

else if (join->send_records >= join->fetch_limit)

11932

{

11933

11934

There is a server side cursor and all rows for

11935

this fetch request are sent.

11936

11937

return(NESTED_LOOP_CURSOR_LIMIT);

11938

}

11939

}

11940

11941

return(NESTED_LOOP_OK);

11942

}

11943

11944

11945

/* ARGSUSED */

11946

enum_nested_loop_state

11947

end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11948

bool end_of_records)

3803

11949

{

3804

11950

int idx= -1;

3805

11951

enum_nested_loop_state ok_code= NESTED_LOOP_OK;

3807

11953

if (!join->first_record || end_of_records ||

3808

11954

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3809

11955

{

3810

if (join->first_record ||

11956

if (join->first_record ||

3811

11957

(end_of_records && !join->group && !join->group_optimized_away))

3812

11958

{

3813

11959

if (idx < (int) join->send_group_parts)

3814

11960

{

3815

int error=0;

3816

{

3817

if (!join->first_record)

3818

{

3819

List_iterator_fast<Item> it(*join->fields);

3820

Item *item;

3821

/* No matching rows for group function */

3822

join->clear();

11961

int error=0;

11962

{

11963

if (!join->first_record)

11964

{

11965

List_iterator_fast<Item> it(*join->fields);

11966

Item *item;

11967

/* No matching rows for group function */

11968

join->clear();

3823

11969

3824

11970

while ((item= it++))

3825

11971

item->no_rows_in_result();

3826

}

3827

if (join->having && join->having->val_int() == 0)

3828

error= -1; // Didn't satisfy having

3829

else

3830

{

3831

if (join->do_send_rows)

3832

error=join->result->send_data(*join->fields) ? 1 : 0;

3833

join->send_records++;

3834

}

3835

if (join->rollup.getState() != Rollup::STATE_NONE && error <= 0)

3836

{

3837

if (join->rollup_send_data((uint32_t) (idx+1)))

3838

error= 1;

3839

}

3840

}

3841

if (error > 0)

3842

return(NESTED_LOOP_ERROR);

3843

if (end_of_records)

3844

return(NESTED_LOOP_OK);

3845

if (join->send_records >= join->unit->select_limit_cnt &&

3846

join->do_send_rows)

3847

{

3848

if (!(join->select_options & OPTION_FOUND_ROWS))

3849

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

3850

join->do_send_rows=0;

3851

join->unit->select_limit_cnt = HA_POS_ERROR;

11972

}

11973

if (join->having && join->having->val_int() == 0)

11974

error= -1; // Didn't satisfy having

11975

else

11976

{

11977

if (join->do_send_rows)

11978

error=join->result->send_data(*join->fields) ? 1 : 0;

11979

join->send_records++;

11980

}

11981

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

11982

{

11983

if (join->rollup_send_data((uint) (idx+1)))

11984

error= 1;

11985

}

11986

}

11987

if (error > 0)

11988

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11989

if (end_of_records)

11990

return(NESTED_LOOP_OK);

11991

if (join->send_records >= join->unit->select_limit_cnt &&

11992

join->do_send_rows)

11993

{

11994

if (!(join->select_options & OPTION_FOUND_ROWS))

11995

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11996

join->do_send_rows=0;

11997

join->unit->select_limit_cnt = HA_POS_ERROR;

3852

11998

}

3853

11999

else if (join->send_records >= join->fetch_limit)

3854

12000

{

3867

12013

else

3868

12014

{

3869

12015

if (end_of_records)

3870

return(NESTED_LOOP_OK);

12016

return(NESTED_LOOP_OK);

3871

12017

join->first_record=1;

3872

test_if_item_cache_changed(join->group_fields);

12018

VOID(test_if_item_cache_changed(join->group_fields));

3873

12019

}

3874

12020

if (idx < (int) join->send_group_parts)

3875

12021

{

3879

12025

3880

12026

copy_fields(&join->tmp_table_param);

3881

12027

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

3882

return(NESTED_LOOP_ERROR);

12028

return(NESTED_LOOP_ERROR);

3883

12029

return(ok_code);

3884

12030

}

3885

12031

}

3888

12034

return(NESTED_LOOP_OK);

3889

12035

}

3890

12036

3891

enum_nested_loop_state end_write_group(Join *join, JoinTable *, bool end_of_records)

12037

12038

/* ARGSUSED */

12039

enum_nested_loop_state

12040

end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12041

bool end_of_records)

12042

{

12043

Table *table=join->tmp_table;

12044

12045

if (join->thd->killed) // Aborted by user

12046

{

12047

join->thd->send_kill_message();

12048

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12049

}

12050

if (!end_of_records)

12051

{

12052

copy_fields(&join->tmp_table_param);

12053

copy_funcs(join->tmp_table_param.items_to_copy);

12054

#ifdef TO_BE_DELETED

12055

if (!table->uniques) // If not unique handling

12056

{

12057

/* Copy null values from group to row */

12058

order_st *group;

12059

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

12060

{

12061

Item *item= *group->item;

12062

if (item->maybe_null)

12063

{

12064

Field *field=item->get_tmp_table_field();

12065

field->ptr[-1]= (uchar) (field->is_null() ? 1 : 0);

12066

}

12067

}

12068

}

12069

#endif

12070

if (!join->having || join->having->val_int())

12071

{

12072

int error;

12073

join->found_records++;

12074

if ((error=table->file->ha_write_row(table->record[0])))

12075

{

12076

if (!table->file->is_fatal_error(error, HA_CHECK_DUP))

12077

goto end;

12078

if (create_myisam_from_heap(join->thd, table,

12079

join->tmp_table_param.start_recinfo,

12080

&join->tmp_table_param.recinfo,

12081

error, 1))

12082

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12083

table->s->uniques=0; // To ensure rows are the same

12084

}

12085

if (++join->send_records >= join->tmp_table_param.end_write_records &&

12086

join->do_send_rows)

12087

{

12088

if (!(join->select_options & OPTION_FOUND_ROWS))

12089

return(NESTED_LOOP_QUERY_LIMIT);

12090

join->do_send_rows=0;

12091

join->unit->select_limit_cnt = HA_POS_ERROR;

12092

return(NESTED_LOOP_OK);

12093

}

12094

}

12095

}

12096

end:

12097

return(NESTED_LOOP_OK);

12098

}

12099

12100

/* ARGSUSED */

12101

/** Group by searching after group record and updating it if possible. */

12102

12103

static enum_nested_loop_state

12104

end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12105

bool end_of_records)

12106

{

12107

Table *table=join->tmp_table;

12108

order_st *group;

12109

int error;

12110

12111

if (end_of_records)

12112

return(NESTED_LOOP_OK);

12113

if (join->thd->killed) // Aborted by user

12114

{

12115

join->thd->send_kill_message();

12116

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12117

}

12118

12119

join->found_records++;

12120

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12121

/* Make a key of group index */

12122

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

12123

{

12124

Item *item= *group->item;

12125

item->save_org_in_field(group->field);

12126

/* Store in the used key if the field was 0 */

12127

if (item->maybe_null)

12128

group->buff[-1]= (char) group->field->is_null();

12129

}

12130

if (!table->file->index_read_map(table->record[1],

12131

join->tmp_table_param.group_buff,

12132

HA_WHOLE_KEY,

12133

HA_READ_KEY_EXACT))

12134

{ /* Update old record */

12135

restore_record(table,record[1]);

12136

update_tmptable_sum_func(join->sum_funcs,table);

12137

if ((error=table->file->ha_update_row(table->record[1],

12138

table->record[0])))

12139

{

12140

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12141

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12142

}

12143

return(NESTED_LOOP_OK);

12144

}

12145

12146

12147

Copy null bits from group key to table

12148

We can't copy all data as the key may have different format

12149

as the row data (for example as with VARCHAR keys)

12150

12151

KEY_PART_INFO *key_part;

12152

for (group=table->group,key_part=table->key_info[0].key_part;

12153

group ;

12154

group=group->next,key_part++)

12155

{

12156

if (key_part->null_bit)

12157

memcpy(table->record[0]+key_part->offset, group->buff, 1);

12158

}

12159

init_tmptable_sum_functions(join->sum_funcs);

12160

copy_funcs(join->tmp_table_param.items_to_copy);

12161

if ((error=table->file->ha_write_row(table->record[0])))

12162

{

12163

if (create_myisam_from_heap(join->thd, table,

12164

join->tmp_table_param.start_recinfo,

12165

&join->tmp_table_param.recinfo,

12166

error, 0))

12167

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12168

/* Change method to update rows */

12169

table->file->ha_index_init(0, 0);

12170

join->join_tab[join->tables-1].next_select=end_unique_update;

12171

}

12172

join->send_records++;

12173

return(NESTED_LOOP_OK);

12174

}

12175

12176

12177

/** Like end_update, but this is done with unique constraints instead of keys. */

12178

12179

static enum_nested_loop_state

12180

end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12181

bool end_of_records)

12182

{

12183

Table *table=join->tmp_table;

12184

int error;

12185

12186

if (end_of_records)

12187

return(NESTED_LOOP_OK);

12188

if (join->thd->killed) // Aborted by user

12189

{

12190

join->thd->send_kill_message();

12191

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12192

}

12193

12194

init_tmptable_sum_functions(join->sum_funcs);

12195

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12196

copy_funcs(join->tmp_table_param.items_to_copy);

12197

12198

if (!(error=table->file->ha_write_row(table->record[0])))

12199

join->send_records++; // New group

12200

else

12201

{

12202

if ((int) table->file->get_dup_key(error) < 0)

12203

{

12204

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12205

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12206

}

12207

if (table->file->rnd_pos(table->record[1],table->file->dup_ref))

12208

{

12209

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12210

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12211

}

12212

restore_record(table,record[1]);

12213

update_tmptable_sum_func(join->sum_funcs,table);

12214

if ((error=table->file->ha_update_row(table->record[1],

12215

table->record[0])))

12216

{

12217

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12218

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12219

}

12220

}

12221

return(NESTED_LOOP_OK);

12222

}

12223

12224

12225

/* ARGSUSED */

12226

enum_nested_loop_state

12227

end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12228

bool end_of_records)

3892

12229

{

3893

12230

Table *table=join->tmp_table;

3894

12231

int idx= -1;

3895

12232

3896

if (join->session->getKilled())

12233

if (join->thd->killed)

3897

12234

{ // Aborted by user

3898

join->session->send_kill_message();

3899

return NESTED_LOOP_KILLED;

12235

join->thd->send_kill_message();

12236

return(NESTED_LOOP_KILLED); /* purecov: inspected */

3900

12237

}

3901

12238

if (!join->first_record || end_of_records ||

3902

12239

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3906

12243

int send_group_parts= join->send_group_parts;

3907

12244

if (idx < send_group_parts)

3908

12245

{

3909

if (!join->first_record)

3910

{

3911

/* No matching rows for group function */

3912

join->clear();

3913

}

3914

copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);

3915

if (!join->having || join->having->val_int())

3916

{

3917

int error= table->cursor->insertRecord(table->getInsertRecord());

3918

3919

if (error)

3920

{

3921

my_error(ER_USE_SQL_BIG_RESULT, MYF(0));

3922

return NESTED_LOOP_ERROR;

3923

}

3924

}

3925

if (join->rollup.getState() != Rollup::STATE_NONE)

3926

{

3927

if (join->rollup_write_data((uint32_t) (idx+1), table))

3928

return NESTED_LOOP_ERROR;

3929

}

3930

if (end_of_records)

3931

return NESTED_LOOP_OK;

12246

if (!join->first_record)

12247

{

12248

/* No matching rows for group function */

12249

join->clear();

12250

}

12251

copy_sum_funcs(join->sum_funcs,

12252

join->sum_funcs_end[send_group_parts]);

12253

if (!join->having || join->having->val_int())

12254

{

12255

int error= table->file->ha_write_row(table->record[0]);

12256

if (error && create_myisam_from_heap(join->thd, table,

12257

join->tmp_table_param.start_recinfo,

12258

&join->tmp_table_param.recinfo,

12259

error, 0))

12260

return(NESTED_LOOP_ERROR);

12261

}

12262

if (join->rollup.state != ROLLUP::STATE_NONE)

12263

{

12264

if (join->rollup_write_data((uint) (idx+1), table))

12265

return(NESTED_LOOP_ERROR);

12266

}

12267

if (end_of_records)

12268

return(NESTED_LOOP_OK);

3932

12269

}

3933

12270

}

3934

12271

else

3935

12272

{

3936

12273

if (end_of_records)

3937

return NESTED_LOOP_OK;

12274

return(NESTED_LOOP_OK);

3938

12275

join->first_record=1;

3939

test_if_item_cache_changed(join->group_fields);

12276

VOID(test_if_item_cache_changed(join->group_fields));

3940

12277

}

3941

12278

if (idx < (int) join->send_group_parts)

3942

12279

{

3943

12280

copy_fields(&join->tmp_table_param);

3944

if (copy_funcs(join->tmp_table_param.items_to_copy, join->session))

3945

return NESTED_LOOP_ERROR;

12281

copy_funcs(join->tmp_table_param.items_to_copy);

3946

12282

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

3947

return NESTED_LOOP_ERROR;

3948

return NESTED_LOOP_OK;

12283

return(NESTED_LOOP_ERROR);

12284

return(NESTED_LOOP_OK);

3949

12285

}

3950

12286

}

3951

12287

if (update_sum_func(join->sum_funcs))

3952

return NESTED_LOOP_ERROR;

3953

return NESTED_LOOP_OK;

12288

return(NESTED_LOOP_ERROR);

12289

return(NESTED_LOOP_OK);

3954

12290

}

3955

12291

12292

3956

12293

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

3957

12294

Remove calculation with tables that aren't yet read. Remove also tests

3958

12295

against fields that are read through key where the table is not a

3959

12296

outer join table.

3960

12297

We can't remove tests that are made against columns which are stored

3961

12298

in sorted order.

12299

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

12300

12301

/**

3962

12302

@return

3963

1 if right_item used is a removable reference key on left_item

3964

0 otherwise.

3965

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

3966

bool test_if_ref(Item_field *left_item,Item *right_item)

12303

1 if right_item is used removable reference key on left_item

12304

12305

12306

static bool test_if_ref(Item_field *left_item,Item *right_item)

3967

12307

{

3968

12308

Field *field=left_item->field;

3969

12309

// No need to change const test. We also have to keep tests on LEFT JOIN

3970

if (not field->getTable()->const_table && !field->getTable()->maybe_null)

12310

if (!field->table->const_table && !field->table->maybe_null)

3971

12311

{

3972

Item *ref_item=part_of_refkey(field->getTable(),field);

12312

Item *ref_item=part_of_refkey(field->table,field);

3973

12313

if (ref_item && ref_item->eq(right_item,1))

3974

12314

{

3975

12315

right_item= right_item->real_item();

3976

12316

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

3977

return (field->eq_def(((Item_field *) right_item)->field));

12317

return (field->eq_def(((Item_field *) right_item)->field));

3978

12318

/* remove equalities injected by IN->EXISTS transformation */

3979

12319

else if (right_item->type() == Item::CACHE_ITEM)

3980

12320

return ((Item_cache *)right_item)->eq_def (field);

3981

12321

if (right_item->const_item() && !(right_item->is_null()))

3982

12322

{

3983

3984

We can remove binary fields and numerical fields except float,

3985

as float comparison isn't 100 % secure

3986

We have to keep normal strings to be able to check for end spaces

12323

12324

We can remove binary fields and numerical fields except float,

12325

as float comparison isn't 100 % secure

12326

We have to keep normal strings to be able to check for end spaces

3987

12327

3988

sergefp: the above seems to be too restrictive. Counterexample:

3989

create table t100 (v varchar(10), key(v)) default charset=latin1;

3990

insert into t100 values ('a'),('a ');

3991

explain select * from t100 where v='a';

3992

The EXPLAIN shows 'using Where'. Running the query returns both

3993

rows, so it seems there are no problems with endspace in the most

3994

frequent case?

3995

3996

if (field->binary() &&

3997

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

3998

field->decimals() == 0)

3999

{

4000

return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);

4001

}

12328

sergefp: the above seems to be too restrictive. Counterexample:

12329

create table t100 (v varchar(10), key(v)) default charset=latin1;

12330

insert into t100 values ('a'),('a ');

12331

explain select * from t100 where v='a';

12332

The EXPLAIN shows 'using Where'. Running the query returns both

12333

rows, so it seems there are no problems with endspace in the most

12334

frequent case?

12335

12336

if (field->binary() &&

12337

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

12338

field->decimals() == 0)

12339

{

12340

return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);

12341

}

4002

12342

}

4003

12343

}

4004

12344

}

4005

return 0;

12345

return 0; // keep test

12346

}

12347

12348

/**

12349

@brief Replaces an expression destructively inside the expression tree of

12350

the WHERE clase.

12351

12352

@note Because of current requirements for semijoin flattening, we do not

12353

need to recurse here, hence this function will only examine the top-level

12354

AND conditions. (see JOIN::prepare, comment above the line

12355

'if (do_materialize)'

12356

12357

@param join The top-level query.

12358

@param old_cond The expression to be replaced.

12359

@param new_cond The expression to be substituted.

12360

@param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for

12361

the new expression.

12362

@return <code>true</code> if there was an error, <code>false</code> if

12363

successful.

12364

12365

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

12366

Item *new_cond, bool do_fix_fields)

12367

{

12368

if (join->conds == old_cond) {

12369

join->conds= new_cond;

12370

if (do_fix_fields)

12371

new_cond->fix_fields(join->thd, &join->conds);

12372

return false;

12373

}

12374

12375

if (join->conds->type() == Item::COND_ITEM) {

12376

List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());

12377

Item *item;

12378

while ((item= li++))

12379

if (item == old_cond)

12380

{

12381

li.replace(new_cond);

12382

if (do_fix_fields)

12383

new_cond->fix_fields(join->thd, li.ref());

12384

return false;

12385

}

12386

}

12387

12388

return true;

4006

12389

}

4007

12390

4008

12391

4009

12392

Extract a condition that can be checked after reading given table

4010

12393

4011

12394

SYNOPSIS

4012

12395

make_cond_for_table()

4013

12396

cond Condition to analyze

4014

12397

tables Tables for which "current field values" are available

4015

used_table Table that we're extracting the condition for (may

12398

used_table Table that we're extracting the condition for (may

4016

12399

also include PSEUDO_TABLE_BITS

4017

12400

4018

12401

DESCRIPTION

4022

12405

4023

12406

The function assumes that

4024

12407

- Constant parts of the condition has already been checked.

4025

- Condition that could be checked for tables in 'tables' has already

12408

- Condition that could be checked for tables in 'tables' has already

4026

12409

been checked.

4027

12410

4028

12411

The function takes into account that some parts of the condition are

4029

12412

guaranteed to be true by employed 'ref' access methods (the code that

4030

12413

does this is located at the end, search down for "EQ_FUNC").

4031

12414

4032

12415

4033