~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))

2216

{ /* Must copy to another table */

2217

/* Free first data from old join */

2218

curr_join->join_free();

2219

if (make_simple_join(curr_join, curr_tmp_table))

2220

return;

2221

calc_group_buffer(curr_join, group_list);

2222

count_field_types(select_lex, &curr_join->tmp_table_param,

2223

curr_join->tmp_all_fields1,

2224

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

2225

curr_join->tmp_table_param.hidden_field_count=

2226

(curr_join->tmp_all_fields1.elements-

2227

curr_join->tmp_fields_list1.elements);

2228

2229

2230

if (exec_tmp_table2)

2231

curr_tmp_table= exec_tmp_table2;

2232

else

2233

{

2234

/* group data to new table */

2235

2236

2237

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

2238

functions are precomputed, and should be treated as regular

2239

functions. See extended comment in JOIN::exec.

2240

2241

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

2242

curr_join->tmp_table_param.precomputed_group_by= true;

2243

2244

if (!(curr_tmp_table=

2245

exec_tmp_table2= create_tmp_table(thd,

2246

&curr_join->tmp_table_param,

2247

*curr_all_fields,

2248

(order_st*) 0,

2249

curr_join->select_distinct &&

2250

!curr_join->group_list,

2251

1, curr_join->select_options,

2252

HA_POS_ERROR,

2253

(char *) "")))

2254

return;

2255

curr_join->exec_tmp_table2= exec_tmp_table2;

2256

}

2257

if (curr_join->group_list)

2258

{

2259

thd->set_proc_info("Creating sort index");

2260

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

2261

{

2262

return;

2263

}

2264

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

2265

HA_POS_ERROR, HA_POS_ERROR, false) ||

2266

make_group_fields(this, curr_join))

2267

{

2268

return;

2269

}

2270

sortorder= curr_join->sortorder;

2271

}

2272

2273

thd->set_proc_info("Copying to group table");

2274

tmp_error= -1;

2275

if (curr_join != this)

2276

{

2277

if (sum_funcs2)

2278

{

2279

curr_join->sum_funcs= sum_funcs2;

2280

curr_join->sum_funcs_end= sum_funcs_end2;

2281

}

2282

else

2283

{

2284

curr_join->alloc_func_list();

2285

sum_funcs2= curr_join->sum_funcs;

2286

sum_funcs_end2= curr_join->sum_funcs_end;

2287

}

2288

}

2289

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

2290

1, true))

2291

return;

2292

curr_join->group_list= 0;

2293

if (!curr_join->sort_and_group &&

2294

curr_join->const_tables != curr_join->tables)

2295

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

2296

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

2297

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

2298

{

2299

error= tmp_error;

2300

return;

2301

}

2302

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

2303

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

2304

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

2305

2306

// No sum funcs anymore

2307

if (!items2)

2308

{

2309

items2= items1 + all_fields.elements;

2310

if (change_to_use_tmp_fields(thd, items2,

2311

tmp_fields_list2, tmp_all_fields2,

2312

fields_list.elements, tmp_all_fields1))

2313

return;

2314

curr_join->tmp_fields_list2= tmp_fields_list2;

2315

curr_join->tmp_all_fields2= tmp_all_fields2;

2316

}

2317

curr_fields_list= &curr_join->tmp_fields_list2;

2318

curr_all_fields= &curr_join->tmp_all_fields2;

2319

curr_join->set_items_ref_array(items2);

2320

curr_join->tmp_table_param.field_count+=

2321

curr_join->tmp_table_param.sum_func_count;

2322

curr_join->tmp_table_param.sum_func_count= 0;

2323

}

2324

if (curr_tmp_table->distinct)

2325

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

2326

2327

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

2328

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

2329

{

2330

thd->set_proc_info("Removing duplicates");

2331

if (curr_join->tmp_having)

2332

curr_join->tmp_having->update_used_tables();

2333

if (remove_duplicates(curr_join, curr_tmp_table,

2334

*curr_fields_list, curr_join->tmp_having))

2335

return;

2336

curr_join->tmp_having=0;

2337

curr_join->select_distinct=0;

2338

}

2339

curr_tmp_table->reginfo.lock_type= TL_UNLOCK;

2340

if (make_simple_join(curr_join, curr_tmp_table))

2341

return;

2342

calc_group_buffer(curr_join, curr_join->group_list);

2343

count_field_types(select_lex, &curr_join->tmp_table_param,

2344

*curr_all_fields, 0);

2345

2346

}

2347

2348

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

2349

{

2350

if (make_group_fields(this, curr_join))

2351

{

2352

return;

2353

}

2354

if (!items3)

2355

{

2356

if (!items0)

2357

init_items_ref_array();

2358

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

2359

setup_copy_fields(thd, &curr_join->tmp_table_param,

2360

items3, tmp_fields_list3, tmp_all_fields3,

2361

curr_fields_list->elements, *curr_all_fields);

2362

tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;

2363

tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;

2364

tmp_table_param.save_copy_field_end=

2365

curr_join->tmp_table_param.copy_field_end;

2366

curr_join->tmp_all_fields3= tmp_all_fields3;

2367

curr_join->tmp_fields_list3= tmp_fields_list3;

2368

}

2369

else

2370

{

2371

curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;

2372

curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;

2373

curr_join->tmp_table_param.copy_field_end=

2374

tmp_table_param.save_copy_field_end;

2375

}

2376

curr_fields_list= &tmp_fields_list3;

2377

curr_all_fields= &tmp_all_fields3;

2378

curr_join->set_items_ref_array(items3);

2379

2380

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

2381

1, true) ||

2382

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

2383

thd->is_fatal_error)

2384

return;

2385

}

2386

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

2387

{

2388

thd->set_proc_info("Sorting result");

2389

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

2390

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

2391

! curr_join->sort_and_group)

2392

{

2393

// Some tables may have been const

2394

curr_join->tmp_having->update_used_tables();

2395

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

2396

table_map used_tables= (curr_join->const_table_map |

2397

curr_table->table->map);

2398

2399

Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,

2400

used_tables,

2401

used_tables, 0);

2402

if (sort_table_cond)

2403

{

2404

if (!curr_table->select)

2405

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

2406

return;

2407

if (!curr_table->select->cond)

2408

curr_table->select->cond= sort_table_cond;

2409

else // This should never happen

2410

{

2411

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

2412

new Item_cond_and(curr_table->select->cond,

2413

sort_table_cond)))

2414

return;

2415

2416

Item_cond_and do not need fix_fields for execution, its parameters

2417

are fixed or do not need fix_fields, too

2418

2419

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

2420

}

2421

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

2422

curr_table->select_cond->top_level_item();

2423

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

2424

~ (table_map) 0,

2425

~used_tables, 0);

2426

}

2427

}

2428

{

2429

if (group)

2430

curr_join->select_limit= HA_POS_ERROR;

2431

else

2432

{

2433

2434

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

2435

WHERE clause for any tables after the sorted one.

2436

2437

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

2438

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

2439

for (; curr_table < end_table ; curr_table++)

2440

{

2441

2442

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

2443

on the table that was optimized away.

2444

2445

if (curr_table->select_cond ||

2446

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

2447

{

2448

/* We have to sort all rows */

2449

curr_join->select_limit= HA_POS_ERROR;

2450

break;

2451

}

2452

}

2453

}

2454

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

2455

{

2456

return;

2457

}

2458

2459

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

2460

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

2461

suitable index present.

2462

Note, that create_sort_index calls test_if_skip_sort_order and may

2463

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

2464

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

2465

OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.

2466

2467

if (create_sort_index(thd, curr_join,

2468

curr_join->group_list ?

2469

curr_join->group_list : curr_join->order,

2470

curr_join->select_limit,

2471

(select_options & OPTION_FOUND_ROWS ?

2472

HA_POS_ERROR : unit->select_limit_cnt),

2473

curr_join->group_list ? true : false))

2474

return;

2475

sortorder= curr_join->sortorder;

2476

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

2477

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

2478

{

2479

2480

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

2481

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

2482

attribute on the INDEX SCAN.

2483

2484

skip_sort_order= 1;

2485

}

2486

}

2487

}

2488

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

2489

if (thd->is_error())

2490

{

2491

error= thd->is_error();

2492

return;

2493

}

2494

curr_join->having= curr_join->tmp_having;

2495

curr_join->fields= curr_fields_list;

2496

2497

{

2498

thd->set_proc_info("Sending data");

2499

result->send_fields(*curr_fields_list,

2500

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);

2501

error= do_select(curr_join, curr_fields_list, NULL);

2502

thd->limit_found_rows= curr_join->send_records;

2503

}

2504

2505

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

2506

thd->examined_row_count+= curr_join->examined_rows;

2507

2508

2509

With EXPLAIN EXTENDED we have to restore original ref_array

2510

for a derived table which is always materialized.

2511

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

2512

2513

if (items0 &&

2514

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

2515

select_lex->linkage == DERIVED_TABLE_TYPE)

2516

set_items_ref_array(items0);

2517

2518

return;

2519

}

2520

2521

2522

/**

2523

Clean up join.

2524

2525

@return

2526

Return error that hold JOIN.

2527

2528

2529

int

2530

JOIN::destroy()

2531

{

2532

select_lex->join= 0;

2533

2534

if (tmp_join)

2535

{

2536

if (join_tab != tmp_join->join_tab)

2537

{

2538

JOIN_TAB *tab, *end;

2539

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

2540

tab->cleanup();

2541

}

2542

tmp_join->tmp_join= 0;

2543

tmp_table_param.copy_field=0;

2544

return(tmp_join->destroy());

2545

}

2546

cond_equal= 0;

2547

2548

cleanup(1);

2549

if (exec_tmp_table1)

2550

exec_tmp_table1->free_tmp_table(thd);

2551

if (exec_tmp_table2)

2552

exec_tmp_table2->free_tmp_table(thd);

2553

delete select;

2554

delete_dynamic(&keyuse);

2555

return(error);

2556

}

2557

2558

2559

316

2560

/**

317

2561

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

318

2562

319

@param session thread Cursor

2563

@param thd thread handler

320

2564

@param rref_pointer_array a reference to ref_pointer_array of

321

2565

the top-level select_lex for this query

322

2566

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

323

2567

The tables have been pre-opened.

324

@param wild_num number of wildcards used in the top level

2568

@param wild_num number of wildcards used in the top level

325

2569

select of this query.

326

2570

For example statement

327

2571

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

332

2576

for a, b and c in this list.

333

2577

@param conds top level item of an expression representing

334

2578

WHERE clause of the top level select

335

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

2579

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

336

2580

arguments

337

@param order linked list of ORDER BY agruments

2581

@param order linked list of order_st BY agruments

338

2582

@param group linked list of GROUP BY arguments

339

2583

@param having top level item of HAVING expression

2584

@param proc_param list of PROCEDUREs

340

2585

@param select_options select options (BIG_RESULT, etc)

341

2586

@param result an instance of result set handling class.

342

2587

This object is responsible for send result

343

2588

set rows to the client or inserting them

344

2589

into a table.

345

@param select_lex the only Select_Lex of this query

2590

@param select_lex the only SELECT_LEX of this query

346

2591

@param unit top-level UNIT of this query

347

2592

UNIT is an artificial object created by the

348

2593

parser for every SELECT clause.

355

2600

@retval

356

2601

true an error

357

2602

358

bool select_query(Session *session,

359

Item ***rref_pointer_array,

360

TableList *tables,

361

uint32_t wild_num,

362

List<Item> &fields,

363

COND *conds,

364

uint32_t og_num,

365

Order *order,

366

Order *group,

367

Item *having,

368

uint64_t select_options,

369

select_result *result,

370

Select_Lex_Unit *unit,

371

Select_Lex *select_lex)

2603

2604

bool

2605

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

2606

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

2607

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

2608

Item *having, order_st *proc_param, uint64_t select_options,

2609

select_result *result, SELECT_LEX_UNIT *unit,

2610

SELECT_LEX *select_lex)

372

2611

{

373

2612

bool err;

374

2613

bool free_join= 1;

375

2614

376

2615

select_lex->context.resolve_in_select_list= true;

377

Join *join;

2616

JOIN *join;

378

2617

if (select_lex->join != 0)

379

2618

{

380

2619

join= select_lex->join;

383

2622

creation

384

2623

385

2624

if (select_lex->linkage != DERIVED_TABLE_TYPE ||

386

(select_options & SELECT_DESCRIBE))

2625

(select_options & SELECT_DESCRIBE))

387

2626

{

388

2627

if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)

389

2628

{

390

//here is EXPLAIN of subselect or derived table

391

if (join->change_result(result))

392

{

393

return(true);

394

}

2629

//here is EXPLAIN of subselect or derived table

2630

if (join->change_result(result))

2631

{

2632

return(true);

2633

}

395

2634

}

396

2635

else

397

2636

{

398

2637

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

399

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

400

{

401

goto err;

402

}

2638

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

2639

select_lex, unit)))

2640

{

2641

goto err;

2642

}

403

2643

}

404

2644

}

405

2645

free_join= 0;

407

2647

}

408

2648

else

409

2649

{

410

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

411

return(true);

412

session->set_proc_info("init");

413

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

2650

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

2651

return(true);

2652

thd->set_proc_info("init");

2653

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

414

2654

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

415

conds, og_num, order, group, having,

2655

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

416

2656

select_lex, unit)) == true)

417

2657

{

418

2658

goto err;

419

2659

}

420

2660

}

421

2661

422

err= join->optimize();

423

if (err)

424

{

425

goto err; // 1

426

}

427

428

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

2662

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

2663

if (join->flatten_subqueries())

2664

{

2665

err= 1;

2666

goto err;

2667

}

2668

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

2669

2670

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

2671

{

2672

goto err; // 1

2673

}

2674

2675

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

429

2676

{

430

2677

join->conds_history= join->conds;

431

2678

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

432

2679

}

433

2680

434

if (session->is_error())

2681

if (thd->is_error())

435

2682

goto err;

436

2683

437

2684

join->exec();

438

2685

439

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

2686

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

440

2687

{

441

2688

select_lex->where= join->conds_history;

442

2689

select_lex->having= join->having_history;

445

2692

err:

446

2693

if (free_join)

447

2694

{

448

session->set_proc_info("end");

2695

thd->set_proc_info("end");

449

2696

err|= select_lex->cleanup();

450

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

2697

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

451

2698

}

452

2699

return(join->error);

453

2700

}

454

2701

455

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

2702

2703

int subq_sj_candidate_cmp(Item_in_subselect* const *el1,

2704

Item_in_subselect* const *el2)

2705

{

2706

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

2707

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

2708

}

2709

2710

2711

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

456

2712

{

457

2713

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

458

2714

}

459

2715

2716

2717

static TableList *alloc_join_nest(THD *thd)

2718

{

2719

TableList *tbl;

2720

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

2721

sizeof(nested_join_st))))

2722

return NULL;

2723

tbl->nested_join= (nested_join_st*) ((unsigned char*)tbl +

2724

ALIGN_SIZE(sizeof(TableList)));

2725

return tbl;

2726

}

2727

2728

2729

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

2730

{

2731

List_iterator<TableList> it(*tlist);

2732

TableList *table;

2733

while ((table= it++))

2734

{

2735

if (table->on_expr)

2736

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

2737

if (table->nested_join)

2738

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

2739

}

2740

}

2741

2742

2743

2744

Convert a subquery predicate into a TableList semi-join nest

2745

2746

SYNOPSIS

2747

convert_subq_to_sj()

2748

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

2749

clause

2750

subq_pred Subquery predicate to be converted

2751

2752

DESCRIPTION

2753

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

2754

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

2755

2756

Prepared Statements: the transformation is permanent:

2757

- Changes in TableList structures are naturally permanent

2758

- Item tree changes are performed on statement MEM_ROOT:

2759

= we activate statement MEM_ROOT

2760

= this function is called before the first fix_prepare_information

2761

call.

2762

2763

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

2764

constant for the lifetime of the Prepared Statement.

2765

2766

RETURN

2767

false OK

2768

true Out of memory error

2769

2770

2771

bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)

2772

{

2773

SELECT_LEX *parent_lex= parent_join->select_lex;

2774

TableList *emb_tbl_nest= NULL;

2775

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

2776

THD *thd= parent_join->thd;

2777

2778

2779

1. Find out where to put the predicate into.

2780

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

2781

2782

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

2783

{

2784

if (subq_pred->expr_join_nest->nested_join)

2785

{

2786

2787

We're dealing with

2788

2789

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

2790

2791

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

2792

2793

emb_tbl_nest= subq_pred->expr_join_nest;

2794

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2795

}

2796

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

2797

{

2798

2799

We're dealing with

2800

2801

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

2802

2803

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

2804

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

2805

2806

emb_tbl_nest= subq_pred->expr_join_nest->embedding;

2807

if (emb_tbl_nest)

2808

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2809

}

2810

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

2811

{

2812

TableList *outer_tbl= subq_pred->expr_join_nest;

2813

TableList *wrap_nest;

2814

2815

We're dealing with

2816

2817

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

2818

2819

we'll need to convert it into:

2820

2821

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

2822

| |

2823

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

2824

2825

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

2826

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

2827

But we'll need to fix other pointers.

2828

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

2829

subqueries know the table has been nested.

2830

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

2831

automatically.

2832

2833

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

2834

{

2835

return(true);

2836

}

2837

wrap_nest->embedding= outer_tbl->embedding;

2838

wrap_nest->join_list= outer_tbl->join_list;

2839

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

2840

2841

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

2842

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

2843

2844

outer_tbl->embedding= wrap_nest;

2845

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

2846

2847

2848

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

2849

and on_expr

2850

2851

wrap_nest->outer_join= outer_tbl->outer_join;

2852

outer_tbl->outer_join= 0;

2853

2854

wrap_nest->on_expr= outer_tbl->on_expr;

2855

outer_tbl->on_expr= NULL;

2856

2857

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

2858

TableList *tbl;

2859

while ((tbl= li++))

2860

{

2861

if (tbl == outer_tbl)

2862

{

2863

li.replace(wrap_nest);

2864

break;

2865

}

2866

}

2867

2868

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

2869

semi-join nest into it

2870

2871

emb_join_list= &wrap_nest->nested_join->join_list;

2872

emb_tbl_nest= wrap_nest;

2873

}

2874

}

2875

2876

TableList *sj_nest;

2877

nested_join_st *nested_join;

2878

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

2879

{

2880

return(true);

2881

}

2882

nested_join= sj_nest->nested_join;

2883

2884

sj_nest->join_list= emb_join_list;

2885

sj_nest->embedding= emb_tbl_nest;

2886

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

2887

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

2888

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

2889

emb_join_list->push_back(sj_nest);

2890

2891

2892

nested_join->used_tables and nested_join->not_null_tables are

2893

initialized in simplify_joins().

2894

2895

2896

2897

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

2898

sj-nest.

2899

2900

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

2901

nested_join->join_list.empty();

2902

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

2903

TableList *tl, *last_leaf;

2904

while ((tl= li++))

2905

{

2906

tl->embedding= sj_nest;

2907

tl->join_list= &nested_join->join_list;

2908

nested_join->join_list.push_back(tl);

2909

}

2910

2911

2912

Reconnect the next_leaf chain.

2913

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

2914

Inserting them at the beginning would be a bit faster.

2915

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

2916

reversed in this list.

2917

2918

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

2919

tl->next_leaf= subq_lex->leaf_tables;

2920

last_leaf= tl;

2921

2922

2923

Same as above for next_local chain

2924

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

2925

because view's tables are inserted after the view)

2926

2927

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

2928

tl->next_local= subq_lex->leaf_tables;

2929

2930

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

2931

2932

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

2933

2934

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

2935

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

2936

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

2937

2938

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

2939

uint32_t table_no= parent_join->tables;

2940

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

2941

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

2942

{

2943

tl->table->tablenr= table_no;

2944

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

2945

SELECT_LEX *old_sl= tl->select_lex;

2946

tl->select_lex= parent_join->select_lex;

2947

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

2948

emb->select_lex= parent_join->select_lex;

2949

}

2950

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

2951

2952

2953

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

2954

Add the subquery-induced equalities too.

2955

2956

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

2957

thd->lex->current_select=subq_lex;

2958

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

2959

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

2960

return(true);

2961

thd->lex->current_select=save_lex;

2962

2963

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

2964

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

2965

subq_pred->left_expr->used_tables();

2966

sj_nest->sj_on_expr= subq_lex->where;

2967

2968

2969

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

2970

Additionally, for InsideOut strategy

2971

- Record the number of IN-equalities.

2972

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

2973

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

2974

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

2975

2976

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

2977

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

2978

them into Item_direct_view_refs and store pointers to those. The

2979

pointers to Item_direct_view_refs are guaranteed to be stable as

2980

Item_direct_view_refs doesn't substitute itself with anything in

2981

Item_direct_view_ref::fix_fields.

2982

2983

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

2984

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

2985

2986

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

2987

{

2988

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

2989

2990

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

2991

subq_lex->ref_pointer_array[0]);

2992

item_eq->name= (char*)subq_sj_cond_name;

2993

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

2994

}

2995

else

2996

{

2997

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

2998

{

2999

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

3000

element_index(i));

3001

Item *item_eq=

3002

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

3003

subq_lex->ref_pointer_array[i]);

3004

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

3005

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

3006

}

3007

}

3008

/* Fix the created equality and AND */

3009

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

3010

3011

3012

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

3013

item->fix_table_changes() for all items.

3014

3015

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

3016

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

3017

3018

3019

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

3020

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

3021

3022

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

3023

if (emb_tbl_nest)

3024

{

3025

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

3026

sj_nest->sj_on_expr);

3027

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

3028

}

3029

else

3030

{

3031

/* Inject into the WHERE */

3032

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

3033

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

3034

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

3035

}

3036

3037

return(false);

3038

}

3039

3040

3041

3042

Convert candidate subquery predicates to semi-joins

3043

3044

SYNOPSIS

3045

JOIN::flatten_subqueries()

3046

3047

DESCRIPTION

3048

Convert candidate subquery predicates to semi-joins.

3049

3050

RETURN

3051

false OK

3052

true Error

3053

3054

3055

bool JOIN::flatten_subqueries()

3056

{

3057

Item_in_subselect **in_subq;

3058

Item_in_subselect **in_subq_end;

3059

3060

if (sj_subselects.elements() == 0)

3061

return(false);

3062

3063

/* 1. Fix children subqueries */

3064

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

3065

in_subq != in_subq_end; in_subq++)

3066

{

3067

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

3068

child_join->outer_tables = child_join->tables;

3069

if (child_join->flatten_subqueries())

3070

return(true);

3071

(*in_subq)->sj_convert_priority=

3072

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

3073

}

3074

3075

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

3076

3077

2. Pick which subqueries to convert:

3078

sort the subquery array

3079

- prefer correlated subqueries over uncorrelated;

3080

- prefer subqueries that have greater number of outer tables;

3081

3082

sj_subselects.sort(subq_sj_candidate_cmp);

3083

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

3084

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

3085

for (in_subq= sj_subselects.front();

3086

in_subq != in_subq_end &&

3087

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

3088

in_subq++)

3089

{

3090

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

3091

return(true);

3092

}

3093

3094

for (in_subq= sj_subselects.front();

3095

in_subq != in_subq_end &&

3096

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

3097

in_subq++)

3098

{

3099

if (convert_subq_to_sj(this, *in_subq))

3100

return(true);

3101

}

3102

3103

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

3104

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

3105

{

3106

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

3107

Item_subselect::trans_res res;

3108

(*in_subq)->changed= 0;

3109

(*in_subq)->fixed= 0;

3110

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

3111

if (res == Item_subselect::RES_ERROR)

3112

return(true);

3113

3114

(*in_subq)->changed= 1;

3115

(*in_subq)->fixed= 1;

3116

3117

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

3118

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

3119

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

3120

return(true);

3121

3122

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

3123

// return(true);

3124

}

3125

sj_subselects.clear();

3126

return(false);

3127

}

3128

3129

3130

/**

3131

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

3132

chose hash semi-join.

3133

3134

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

3135

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

3136

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

3137

of the IN predicate,

3138

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

3139

previously blocked during JOIN::prepare.

3140

3141

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

3142

3143

This phase must be called after substitute_for_best_equal_field() because

3144

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

3145

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

3146

IN predicate.

3147

3148

@return Operation status

3149

@retval false success.

3150

@retval true error occurred.

3151

3152

3153

bool JOIN::setup_subquery_materialization()

3154

{

3155

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

3156

un= un->next_unit())

3157

{

3158

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

3159

{

3160

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

3161

if (subquery_predicate &&

3162

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

3163

{

3164

Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;

3165

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

3166

in_subs->setup_engine())

3167

return true;

3168

}

3169

}

3170

}

3171

return false;

3172

}

3173

3174

3175

3176

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

3177

3178

SYNOPSIS

3179

find_eq_ref_candidate()

3180

table Table to be checked

3181

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

3182

count.

3183

3184

DESCRIPTION

3185

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

3186

3187

TODO

3188

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

3189

3190

3191

RETURN

3192

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

3193

false - Otherwise

3194

3195

3196

bool find_eq_ref_candidate(Table *table, table_map sj_inner_tables)

3197

{

3198

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

3199

uint32_t key;

3200

3201

if (keyuse)

3202

{

3203

while (1) /* For each key */

3204

{

3205

key= keyuse->key;

3206

KEY *keyinfo= table->key_info + key;

3207

key_part_map bound_parts= 0;

3208

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

3209

{

3210

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

3211

{

3212

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

3213

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

3214

!(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))

3215

{

3216

bound_parts |= 1 << keyuse->keypart;

3217

}

3218

keyuse++;

3219

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

3220

3221

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

3222

return true;

3223

if (keyuse->table != table)

3224

return false;

3225

}

3226

else

3227

{

3228

3229

{

3230

keyuse++;

3231

if (keyuse->table != table)

3232

return false;

3233

}

3234

while (keyuse->key == key);

3235

}

3236

}

3237

}

3238

return false;

3239

}

3240

3241

3242

3243

Pull tables out of semi-join nests, if possible

3244

3245

SYNOPSIS

3246

pull_out_semijoin_tables()

3247

join The join where to do the semi-join flattening

3248

3249

DESCRIPTION

3250

Try to pull tables out of semi-join nests.

3251

3252

PRECONDITIONS

3253

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

3254

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

3255

one semi-join nest does not contain another.

3256

3257

ACTION

3258

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

3259

- It is a constant table

3260

- It is accessed

3261

3262

POSTCONDITIONS

3263

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

3264

tables)

3265

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

3266

* Semi-join nests TableList::sj_inner_tables

3267

3268

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

3269

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

3270

3271

RETURN

3272

0 - OK

3273

1 - Out of memory error

3274

3275

3276

int pull_out_semijoin_tables(JOIN *join)

3277

{

3278

TableList *sj_nest;

3279

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

3280

3281

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

3282

while ((sj_nest= sj_list_it++))

3283

{

3284

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

3285

table_map pulled_tables= 0;

3286

3287

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

3288

TableList *tbl;

3289

while ((tbl= child_li++))

3290

{

3291

if (tbl->table)

3292

{

3293

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

3294

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

3295

{

3296

pulled_tables |= tbl->table->map;

3297

}

3298

}

3299

}

3300

3301

3302

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

3303

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

3304

us to pull out some other tables too.

3305

3306

bool pulled_a_table;

3307

3308

{

3309

pulled_a_table= false;

3310

child_li.rewind();

3311

while ((tbl= child_li++))

3312

{

3313

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

3314

{

3315

if (find_eq_ref_candidate(tbl->table,

3316

sj_nest->nested_join->used_tables &

3317

~pulled_tables))

3318

{

3319

pulled_a_table= true;

3320

pulled_tables |= tbl->table->map;

3321

}

3322

}

3323

}

3324

} while (pulled_a_table);

3325

3326

child_li.rewind();

3327

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

3328

{

3329

(sj_nest)->sj_inner_tables= 0;

3330

while ((tbl= child_li++))

3331

{

3332

if (tbl->table)

3333

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

3334

}

3335

}

3336

else

3337

{

3338

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

3339

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

3340

~pulled_tables;

3341

(sj_nest)->sj_inner_tables= inner_tables;

3342

while ((tbl= child_li++))

3343

{

3344

if (tbl->table)

3345

{

3346

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

3347

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

3348

else

3349

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

3350

}

3351

}

3352

}

3353

}

3354

return(0);

3355

}

3356

460

3357

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

461

Create JoinTableS, make a guess about the table types,

3358

Create JOIN_TABS, make a guess about the table types,

462

3359

Approximate how many records will be used in each table

463

3360

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

464

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

3361

3362

3363

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

3364

Table *table,

3365

const key_map *keys,ha_rows limit)

465

3366

{

466

3367

int error;

467

if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))

3368

if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))

468

3369

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

469

3370

if (select)

470

3371

{

471

3372

select->head=table;

472

3373

table->reginfo.impossible_range=0;

473

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

3374

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

474

3375

limit, 0, false)) == 1)

475

3376

return(select->quick->records);

476

3377

if (error == -1)

482

3383

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

483

3384

}

484

3385

3386

3387

This structure is used to collect info on potentially sargable

3388

predicates in order to check whether they become sargable after

3389

reading const tables.

3390

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

3391

Only such indexes are involved in range analysis.

3392

3393

typedef struct st_sargable_param

3394

{

3395

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

3396

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

3397

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

3398

} SARGABLE_PARAM;

3399

3400

/**

3401

Calculate the best possible join and initialize the join structure.

3402

3403

@retval

3404

0 ok

3405

@retval

3406

1 Fatal error

3407

3408

3409

static bool

3410

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

3411

DYNAMIC_ARRAY *keyuse_array)

3412

{

3413

int error;

3414

Table *table;

3415

uint32_t i,table_count,const_count,key;

3416

table_map found_const_table_map, all_table_map, found_ref, refs;

3417

key_map const_ref, eq_part;

3418

Table **table_vector;

3419

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

3420

KEYUSE *keyuse,*start_keyuse;

3421

table_map outer_join=0;

3422

SARGABLE_PARAM *sargables= 0;

3423

JOIN_TAB *stat_vector[MAX_TABLES+1];

3424

3425

table_count=join->tables;

3426

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

3427

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

3428

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

3429

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

3430

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

3431

3432

join->best_ref=stat_vector;

3433

3434

stat_end=stat+table_count;

3435

found_const_table_map= all_table_map=0;

3436

const_count=0;

3437

3438

for (s= stat, i= 0;

3439

tables;

3440

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

3441

{

3442

TableList *embedding= tables->embedding;

3443

stat_vector[i]=s;

3444

s->keys.init();

3445

s->const_keys.init();

3446

s->checked_keys.init();

3447

s->needed_reg.init();

3448

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

3449

table->pos_in_table_list= tables;

3450

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

3451

if(error)

3452

{

3453

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

3454

return(1);

3455

}

3456

table->quick_keys.clear_all();

3457

table->reginfo.join_tab=s;

3458

table->reginfo.not_exists_optimize=0;

3459

memset(table->const_key_parts, 0,

3460

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

3461

all_table_map|= table->map;

3462

s->join=join;

3463

s->info=0; // For describe

3464

3465

s->dependent= tables->dep_tables;

3466

s->key_dependent= 0;

3467

if (tables->schema_table)

3468

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

3469

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

3470

3471

s->on_expr_ref= &tables->on_expr;

3472

if (*s->on_expr_ref)

3473

{

3474

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

3475

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

3476

{ // Empty table

3477

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

3478

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

3479

continue;

3480

}

3481

outer_join|= table->map;

3482

s->embedding_map= 0;

3483

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

3484

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

3485

continue;

3486

}

3487

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

3488

{

3489

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

3490

s->embedding_map= 0;

3491

3492

{

3493

nested_join_st *nested_join= embedding->nested_join;

3494

s->embedding_map|=nested_join->nj_map;

3495

s->dependent|= embedding->dep_tables;

3496

embedding= embedding->embedding;

3497

outer_join|= nested_join->used_tables;

3498

}

3499

while (embedding);

3500

continue;

3501

}

3502

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

3503

!s->dependent &&

3504

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

3505

{

3506

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

3507

}

3508

}

3509

stat_vector[i]=0;

3510

join->outer_join=outer_join;

3511

3512

if (join->outer_join)

3513

{

3514

3515

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

3516

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

3517

as well as allow us to catch illegal cross references/

3518

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

3519

As we use bitmaps to represent the relation the complexity

3520

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

3521

3522

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

3523

{

3524

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

3525

{

3526

table= stat[j].table;

3527

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

3528

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

3529

}

3530

if (s->dependent)

3531

s->table->maybe_null= 1;

3532

}

3533

/* Catch illegal cross references for outer joins */

3534

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

3535

{

3536

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

3537

{

3538

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

3539

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

3540

return(1);

3541

}

3542

s->key_dependent= s->dependent;

3543

}

3544

}

3545

3546

if (conds || outer_join)

3547

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

3548

conds, join->cond_equal,

3549

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

3550

return(1);

3551

3552

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

3553

join->const_table_map= 0;

3554

3555

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

3556

p_pos < p_end ;

3557

p_pos++)

3558

{

3559

int tmp;

3560

s= p_pos->table;

3561

s->type=JT_SYSTEM;

3562

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

3563

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

3564

{

3565

if (tmp > 0)

3566

return(1); // Fatal error

3567

}

3568

else

3569

found_const_table_map|= s->table->map;

3570

}

3571

3572

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

3573

int ref_changed;

3574

3575

{

3576

more_const_tables_found:

3577

ref_changed = 0;

3578

found_ref=0;

3579

3580

3581

We only have to loop from stat_vector + const_count as

3582

set_position() will move all const_tables first in stat_vector

3583

3584

3585

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

3586

{

3587

table=s->table;

3588

3589

3590

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

3591

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

3592

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

3593

3594

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

3595

{

3596

3597

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

3598

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

3599

null complemented and thus considered as constant tables.

3600

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

3601

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

3602

would require a more thorough analysis.

3603

TODO. Apply single row substitution to null complemented inner tables

3604

for nested outer join operations.

3605

3606

while (keyuse->table == table)

3607

{

3608

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

3609

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

3610

{

3611

s->type= JT_CONST;

3612

mark_as_null_row(table);

3613

found_const_table_map|= table->map;

3614

join->const_table_map|= table->map;

3615

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

3616

goto more_const_tables_found;

3617

}

3618

keyuse++;

3619

}

3620

}

3621

3622

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

3623

{

3624

// All dep. must be constants

3625

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

3626

continue;

3627

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

3628

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

3629

!table->pos_in_table_list->embedding)

3630

{ // system table

3631

int tmp= 0;

3632

s->type=JT_SYSTEM;

3633

join->const_table_map|=table->map;

3634

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

3635

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

3636

{

3637

if (tmp > 0)

3638

return(1); // Fatal error

3639

}

3640

else

3641

found_const_table_map|= table->map;

3642

continue;

3643

}

3644

}

3645

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

3646

if ((keyuse=s->keyuse))

3647

{

3648

s->type= JT_REF;

3649

while (keyuse->table == table)

3650

{

3651

start_keyuse=keyuse;

3652

key=keyuse->key;

3653

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

3654

3655

refs=0;

3656

const_ref.clear_all();

3657

eq_part.clear_all();

3658

3659

{

3660

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

3661

{

3662

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

3663

const_ref.set_bit(keyuse->keypart);

3664

else

3665

refs|=keyuse->used_tables;

3666

eq_part.set_bit(keyuse->keypart);

3667

}

3668

keyuse++;

3669

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

3670

3671

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

3672

!table->pos_in_table_list->embedding)

3673

{

3674

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

3675

== HA_NOSAME)

3676

{

3677

if (const_ref == eq_part)

3678

{ // Found everything for ref.

3679

int tmp;

3680

ref_changed = 1;

3681

s->type= JT_CONST;

3682

join->const_table_map|=table->map;

3683

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

3684

if (create_ref_for_key(join, s, start_keyuse,

3685

found_const_table_map))

3686

return(1);

3687

if ((tmp=join_read_const_table(s,

3688

join->positions+const_count-1)))

3689

{

3690

if (tmp > 0)

3691

return(1); // Fatal error

3692

}

3693

else

3694

found_const_table_map|= table->map;

3695

break;

3696

}

3697

else

3698

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

3699

}

3700

else if (const_ref == eq_part)

3701

s->const_keys.set_bit(key);

3702

}

3703

}

3704

}

3705

}

3706

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

3707

3708

3709

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

3710

reading const tables may has added new sargable predicates.

3711

3712

if (const_count && sargables)

3713

{

3714

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

3715

{

3716

Field *field= sargables->field;

3717

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

3718

key_map possible_keys= field->key_start;

3719

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

3720

bool is_const= 1;

3721

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

3722

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

3723

if (is_const)

3724

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

3725

}

3726

}

3727

3728

if (pull_out_semijoin_tables(join))

3729

return(true);

3730

3731

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

3732

3733

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

3734

{

3735

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

3736

{

3737

/* Only one matching row */

3738

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

3739

continue;

3740

}

3741

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

3742

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

3743

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

3744

3745

3746

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

3747

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

3748

table scan.

3749

3750

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

3751

(double) s->read_time*3);

3752

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

3753

s->worst_seeks=2.0;

3754

3755

3756

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

3757

all select distinct fields participate in one index.

3758

3759

add_group_and_distinct_keys(join, s);

3760

3761

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

3762

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

3763

{

3764

ha_rows records;

3765

SQL_SELECT *select;

3766

select= make_select(s->table, found_const_table_map,

3767

found_const_table_map,

3768

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

3769

1, &error);

3770

if (!select)

3771

return(1);

3772

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

3773

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

3774

s->quick=select->quick;

3775

s->needed_reg=select->needed_reg;

3776

select->quick=0;

3777

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

3778

{

3779

3780

Impossible WHERE or ON expression

3781

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

3782

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

3783

caller to abort with a zero row result.

3784

3785

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

3786

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

3787

s->type= JT_CONST;

3788

if (*s->on_expr_ref)

3789

{

3790

/* Generate empty row */

3791

s->info= "Impossible ON condition";

3792

found_const_table_map|= s->table->map;

3793

s->type= JT_CONST;

3794

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

3795

}

3796

}

3797

if (records != HA_POS_ERROR)

3798

{

3799

s->found_records=records;

3800

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

3801

}

3802

delete select;

3803

}

3804

}

3805

3806

join->join_tab=stat;

3807

join->map2table=stat_ref;

3808

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

3809

join->const_tables=const_count;

3810

join->found_const_table_map=found_const_table_map;

3811

3812

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

3813

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

3814

{

3815

optimize_keyuse(join, keyuse_array);

3816

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

3817

return(true);

3818

}

3819

else

3820

{

3821

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

3822

sizeof(POSITION)*join->const_tables);

3823

join->best_read=1.0;

3824

}

3825

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

3826

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

3827

}

3828

3829

485

3830

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

486

3831

Check with keys are used and with tables references with tables

487

3832

Updates in stat:

490

3835

keyuse Pointer to possible keys

491

3836

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

492

3837

3838

/// Used when finding key fields

3839

typedef struct key_field_t {

3840

Field *field;

3841

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

3842

uint level;

3843

uint optimize; // KEY_OPTIMIZE_*

3844

bool eq_func;

3845

/**

3846

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

3847

when val IS NULL.

3848

3849

bool null_rejecting;

3850

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

3851

uint32_t sj_pred_no; /* See KEYUSE::sj_pred_no */

3852

} KEY_FIELD;

3853

3854

/**

3855

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

3856

3857

This is called for OR between different levels.

3858

3859

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

3860

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

3861

that are internally transformed to something like:.

3862

3863

@code

3864

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

3865

@endcode

3866

3867

KEY_FIELD::null_rejecting is processed as follows: @n

3868

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

3869

for example:

3870

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

3871

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

3872

3873

@todo

3874

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

3875

OptimizerTeam: Fix this

3876

3877

3878

static KEY_FIELD *

3879

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

3880

uint32_t and_level)

3881

{

3882

if (start == new_fields)

3883

return start; // Impossible or

3884

if (new_fields == end)

3885

return start; // No new fields, skip all

3886

3887

KEY_FIELD *first_free=new_fields;

3888

3889

/* Mark all found fields in old array */

3890

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

3891

{

3892

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

3893

{

3894

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

3895

{

3896

3897

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

3898

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

3899

3900

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

3901

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

3902

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

3903

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

3904

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

3905

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

3906

TODO: OptimizerTeam: Fix this

3907

3908

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

3909

{

3910

3911

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

3912

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

3913

3914

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

3915

{

3916

old->level= and_level;

3917

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

3918

KEY_OPTIMIZE_EXISTS) |

3919

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

3920

KEY_OPTIMIZE_REF_OR_NULL));

3921

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

3922

new_fields->null_rejecting);

3923

}

3924

}

3925

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

3926

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

3927

old->field->binary(),

3928

old->field->charset()))

3929

3930

{

3931

old->level= and_level;

3932

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

3933

KEY_OPTIMIZE_EXISTS) |

3934

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

3935

KEY_OPTIMIZE_REF_OR_NULL));

3936

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

3937

new_fields->null_rejecting);

3938

}

3939

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

3940

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

3941

new_fields->val->is_null()))

3942

{

3943

/* field = expression OR field IS NULL */

3944

old->level= and_level;

3945

old->optimize= KEY_OPTIMIZE_REF_OR_NULL;

3946

3947

Remember the NOT NULL value unless the value does not depend

3948

on other tables.

3949

3950

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

3951

old->val= new_fields->val;

3952

/* The referred expression can be NULL: */

3953

old->null_rejecting= 0;

3954

}

3955

else

3956

{

3957

3958

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

3959

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

3960

and let the range optimzier handle it

3961

3962

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

3963

break;

3964

*old= *first_free; // Remove old value

3965

old--; // Retry this value

3966

}

3967

}

3968

}

3969

}

3970

/* Remove all not used items */

3971

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

3972

{

3973

if (old->level != and_level)

3974

{ // Not used in all levels

3975

if (old == --first_free)

3976

break;

3977

*old= *first_free; // Remove old value

3978

continue;

3979

}

3980

old++;

3981

}

3982

return first_free;

3983

}

3984

3985

3986

/**

3987

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

3988

3989

@param key_fields Pointer to add key, if usable

3990

@param and_level And level, to be stored in KEY_FIELD

3991

@param cond Condition predicate

3992

@param field Field used in comparision

3993

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

3994

@param value Value used for comparison with field

3995

@param usable_tables Tables which can be used for key optimization

3996

@param sargables IN/OUT Array of found sargable candidates

3997

3998

@note

3999

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

4000

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

4001

4002

@returns

4003

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

4004

4005

4006

static void

4007

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

4008

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

4009

table_map usable_tables, SARGABLE_PARAM **sargables)

4010

{

4011

uint32_t exists_optimize= 0;

4012

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

4013

{

4014

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

4015

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

4016

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

4017

return; // Not a key. Skip it

4018

exists_optimize= KEY_OPTIMIZE_EXISTS;

4019

assert(num_values == 1);

4020

}

4021

else

4022

{

4023

table_map used_tables=0;

4024

bool optimizable=0;

4025

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

4026

{

4027

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

4028

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

4029

optimizable=1;

4030

}

4031

if (!optimizable)

4032

return;

4033

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

4034

{

4035

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

4036

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

4037

return; // Can't use left join optimize

4038

exists_optimize= KEY_OPTIMIZE_EXISTS;

4039

}

4040

else

4041

{

4042

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

4043

key_map possible_keys=field->key_start;

4044

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

4045

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

4046

4047

4048

Save the following cases:

4049

Field op constant

4050

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

4051

Field = field2 where field2 is in a different table

4052

Field op formula

4053

Field IS NULL

4054

Field IS NOT NULL

4055

Field BETWEEN ...

4056

Field IN ...

4057

4058

stat[0].key_dependent|=used_tables;

4059

4060

bool is_const=1;

4061

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

4062

{

4063

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

4064

break;

4065

}

4066

if (is_const)

4067

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

4068

else if (!eq_func)

4069

{

4070

4071

Save info to be able check whether this predicate can be

4072

considered as sargable for range analisis after reading const tables.

4073

We do not save info about equalities as update_const_equal_items

4074

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

4075

4076

(*sargables)--;

4077

(*sargables)->field= field;

4078

(*sargables)->arg_value= value;

4079

(*sargables)->num_values= num_values;

4080

}

4081

4082

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

4083

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

4084

eq_func is NEVER true when num_values > 1

4085

4086

if (!eq_func)

4087

{

4088

4089

Additional optimization: if we're processing

4090

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

4091

"t.key = c1".

4092

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

4093

There are 2 options:

4094

A) Make equality propagation code be able to handle BETWEEN

4095

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

4096

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

4097

and use them in equality propagation process (see details in

4098

OptimizerKBAndTodo)

4099

4100

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

4101

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

4102

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

4103

return;

4104

eq_func= true;

4105

}

4106

4107

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

4108

{

4109

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

4110

{

4111

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

4112

return;

4113

}

4114

else

4115

{

4116

4117

We can't use indexes if the effective collation

4118

of the operation differ from the field collation.

4119

4120

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

4121

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

4122

return;

4123

}

4124

}

4125

}

4126

}

4127

4128

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

4129

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

4130

4131

assert(eq_func);

4132

/* Store possible eq field */

4133

(*key_fields)->field= field;

4134

(*key_fields)->eq_func= eq_func;

4135

(*key_fields)->val= *value;

4136

(*key_fields)->level= and_level;

4137

(*key_fields)->optimize= exists_optimize;

4138

4139

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

4140

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

4141

has NULL value.

4142

We use null_rejecting in add_not_null_conds() to add

4143

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

4144

4145

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

4146

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

4147

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

4148

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

4149

(*key_fields)->cond_guard= NULL;

4150

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

4151

cond->name < subq_sj_cond_name + 64)?

4152

cond->name - subq_sj_cond_name: UINT_MAX;

4153

(*key_fields)++;

4154

}

4155

4156

/**

4157

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

4158

predicate.

4159

4160

@param key_fields Pointer to add key, if usable

4161

@param and_level And level, to be stored in KEY_FIELD

4162

@param cond Condition predicate

4163

@param field Field used in comparision

4164

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

4165

@param value Value used for comparison with field

4166

Is NULL for BETWEEN and IN

4167

@param usable_tables Tables which can be used for key optimization

4168

@param sargables IN/OUT Array of found sargable candidates

4169

4170

@note

4171

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

4172

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

4173

4174

@returns

4175

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

4176

4177

4178

static void

4179

add_key_equal_fields(KEY_FIELD **key_fields, uint32_t and_level,

4180

Item_func *cond, Item_field *field_item,

4181

bool eq_func, Item **val,

4182

uint32_t num_values, table_map usable_tables,

4183

SARGABLE_PARAM **sargables)

4184

{

4185

Field *field= field_item->field;

4186

add_key_field(key_fields, and_level, cond, field,

4187

eq_func, val, num_values, usable_tables, sargables);

4188

Item_equal *item_equal= field_item->item_equal;

4189

if (item_equal)

4190

{

4191

4192

Add to the set of possible key values every substitution of

4193

the field for an equal field included into item_equal

4194

4195

Item_equal_iterator it(*item_equal);

4196

Item_field *item;

4197

while ((item= it++))

4198

{

4199

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

4200

{

4201

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

4202

eq_func, val, num_values, usable_tables,

4203

sargables);

4204

}

4205

}

4206

}

4207

}

4208

4209

static void

4210

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

4211

COND *cond, table_map usable_tables,

4212

SARGABLE_PARAM **sargables)

4213

{

4214

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

4215

{

4216

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

4217

KEY_FIELD *org_key_fields= *key_fields;

4218

4219

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

4220

{

4221

Item *item;

4222

while ((item=li++))

4223

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

4224

sargables);

4225

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

4226

org_key_fields->level= *and_level;

4227

}

4228

else

4229

{

4230

(*and_level)++;

4231

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

4232

sargables);

4233

Item *item;

4234

while ((item=li++))

4235

{

4236

KEY_FIELD *start_key_fields= *key_fields;

4237

(*and_level)++;

4238

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

4239

sargables);

4240

*key_fields=merge_key_fields(org_key_fields,start_key_fields,

4241

*key_fields,++(*and_level));

4242

}

4243

}

4244

return;

4245

}

4246

4247

4248

Subquery optimization: Conditions that are pushed down into subqueries

4249

are wrapped into Item_func_trig_cond. We process the wrapped condition

4250

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

4251

4252

{

4253

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

4254

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

4255

{

4256

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

4257

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

4258

join->unit->item &&

4259

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

4260

!join->unit->is_union())

4261

{

4262

KEY_FIELD *save= *key_fields;

4263

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

4264

sargables);

4265

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

4266

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

4267

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

4268

}

4269

return;

4270

}

4271

}

4272

4273

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

4274

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

4275

return;

4276

Item_func *cond_func= (Item_func*) cond;

4277

switch (cond_func->select_optimize()) {

4278

case Item_func::OPTIMIZE_NONE:

4279

break;

4280

case Item_func::OPTIMIZE_KEY:

4281

{

4282

Item **values;

4283

// BETWEEN, IN, NE

4284

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

4285

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

4286

{

4287

values= cond_func->arguments()+1;

4288

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

4289

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

4290

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

4291

values--;

4292

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

4293

cond_func->argument_count() != 2);

4294

add_key_equal_fields(key_fields, *and_level, cond_func,

4295

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

4296

0, values,

4297

cond_func->argument_count()-1,

4298

usable_tables, sargables);

4299

}

4300

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

4301

{

4302

values= cond_func->arguments();

4303

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

4304

{

4305

Item_field *field_item;

4306

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

4307

4308

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

4309

{

4310

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

4311

add_key_equal_fields(key_fields, *and_level, cond_func,

4312

field_item, 0, values, 1, usable_tables,

4313

sargables);

4314

}

4315

}

4316

}

4317

break;

4318

}

4319

case Item_func::OPTIMIZE_OP:

4320

{

4321

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

4322

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

4323

4324

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

4325

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

4326

{

4327

add_key_equal_fields(key_fields, *and_level, cond_func,

4328

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

4329

equal_func,

4330

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

4331

sargables);

4332

}

4333

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

4334

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

4335

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

4336

{

4337

add_key_equal_fields(key_fields, *and_level, cond_func,

4338

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

4339

equal_func,

4340

cond_func->arguments(),1,usable_tables,

4341

sargables);

4342

}

4343

break;

4344

}

4345

case Item_func::OPTIMIZE_NULL:

4346

/* column_name IS [NOT] NULL */

4347

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

4348

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

4349

{

4350

Item *tmp=new Item_null;

4351

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

4352

return;

4353

add_key_equal_fields(key_fields, *and_level, cond_func,

4354

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

4355

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

4356

&tmp, 1, usable_tables, sargables);

4357

}

4358

break;

4359

case Item_func::OPTIMIZE_EQUAL:

4360

Item_equal *item_equal= (Item_equal *) cond;

4361

Item *const_item= item_equal->get_const();

4362

Item_equal_iterator it(*item_equal);

4363

Item_field *item;

4364

if (const_item)

4365

{

4366

4367

For each field field1 from item_equal consider the equality

4368

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

4369

with field1 by the keys value of field1.

4370

4371

while ((item= it++))

4372

{

4373

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

4374

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

4375

}

4376

}

4377

else

4378

{

4379

4380

Consider all pairs of different fields included into item_equal.

4381

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

4382

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

4383

with field1 by the keys value of field2.

4384

4385

Item_equal_iterator fi(*item_equal);

4386

while ((item= fi++))

4387

{

4388

Field *field= item->field;

4389

while ((item= it++))

4390

{

4391

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

4392

{

4393

add_key_field(key_fields, *and_level, cond_func, field,

4394

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

4395

sargables);

4396

}

4397

}

4398

it.rewind();

4399

}

4400

}

4401

break;

4402

}

4403

}

493

4404

494

4405

/**

495

4406

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

496

4407

497

4408

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

498

4409

499

uint32_t max_part_bit(key_part_map bits)

4410

4411

static uint

4412

max_part_bit(key_part_map bits)

500

4413

{

501

4414

uint32_t found;

502

4415

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

503

4416

return found;

504

4417

}

505

4418

506

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

4419

static void

4420

add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)

4421

{

4422

Field *field=key_field->field;

4423

Table *form= field->table;

4424

KEYUSE keyuse;

4425

4426

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

4427

{

4428

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

4429

{

4430

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

4431

continue;

4432

4433

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

4434

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

4435

{

4436

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

4437

{

4438

keyuse.table= field->table;

4439

keyuse.val = key_field->val;

4440

keyuse.key = key;

4441

keyuse.keypart=part;

4442

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

4443

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

4444

keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;

4445

keyuse.null_rejecting= key_field->null_rejecting;

4446

keyuse.cond_guard= key_field->cond_guard;

4447

keyuse.sj_pred_no= key_field->sj_pred_no;

4448

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

4449

}

4450

}

4451

}

4452

}

4453

}

4454

4455

static int

4456

sort_keyuse(KEYUSE *a,KEYUSE *b)

507

4457

{

508

4458

int res;

509

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

510

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

511

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

512

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

513

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

514

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

4459

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

4460

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

4461

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

4462

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

4463

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

4464

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

515

4465

// Place const values before other ones

516

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

517

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

4466

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

4467

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

518

4468

return res;

519

4469

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

520

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

521

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

4470

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

4471

(b->optimize & KEY_OPTIMIZE_REF_OR_NULL));

4472

}

4473

4474

4475

4476

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

4477

4478

This function populates KEY_FIELD array with entries generated from the

4479

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

4480

contained within this nested join.

4481

4482

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

4483

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

4484

@param[in,out] and_level And-level

4485

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

4486

4487

4488

@note

4489

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

4490

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

4491

4492

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

4493

invoked for):

4494

@code

4495

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

4496

@endcode

4497

Example for #2:

4498

@code

4499

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

4500

@endcode

4501

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

4502

t1 only.

4503

Example #3:

4504

@code

4505

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

4506

@endcode

4507

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

4508

4509

4510

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

4511

KEY_FIELD **end, uint32_t *and_level,

4512

SARGABLE_PARAM **sargables)

4513

{

4514

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

4515

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

4516

bool have_another = false;

4517

table_map tables= 0;

4518

TableList *table;

4519

assert(nested_join_table->nested_join);

4520

4521

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

4522

(table= li++))))

4523

{

4524

if (table->nested_join)

4525

{

4526

if (!table->on_expr)

4527

{

4528

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

4529

have_another= true;

4530

li2= li;

4531

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

4532

}

4533

else

4534

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

4535

}

4536

else

4537

if (!table->on_expr)

4538

tables |= table->table->map;

4539

}

4540

if (nested_join_table->on_expr)

4541

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

4542

sargables);

522

4543

}

523

4544

524

4545

525

4546

/**

526

4547

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

527

528

@param session

529

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

4548

4549

@param thd

4550

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

530

4551

@param join_tab Array in tablenr_order

531

4552

@param tables Number of tables in join

532

4553

@param cond WHERE condition (note that the function analyzes

535

4556

for which we can make ref access based the WHERE

536

4557

clause)

537

4558

@param select_lex current SELECT

538

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

539

4559

@param[out] sargables Array of found sargable candidates

4560

540

4561

@retval

541

4562

0 OK

542

4563

@retval

543

4564

1 Out of memory.

544

4565

545

bool update_ref_and_keys(Session *session,

546

DYNAMIC_ARRAY *keyuse,

547

JoinTable *join_tab,

548

uint32_t tables,

549

COND *cond,

550

COND_EQUAL *,

551

table_map normal_tables,

552

Select_Lex *select_lex,

553

vector<optimizer::SargableParam> &sargables)

4566

4567

static bool

4568

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

4569

uint32_t tables, COND *cond,

4570

COND_EQUAL *cond_equal __attribute__((unused)),

4571

table_map normal_tables, SELECT_LEX *select_lex,

4572

SARGABLE_PARAM **sargables)

554

4573

{

555

uint and_level,found_eq_constant;

556

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

4574

uint and_level,i,found_eq_constant;

4575

KEY_FIELD *key_fields, *end, *field;

557

4576

uint32_t sz;

558

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

559

560

561

All predicates that are used to fill arrays of KeyField

562

and SargableParam classes have at most 2 arguments

563

except BETWEEN predicates that have 3 arguments and

4577

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

4578

4579

4580

We use the same piece of memory to store both KEY_FIELD

4581

and SARGABLE_PARAM structure.

4582

KEY_FIELD values are placed at the beginning this memory

4583

while SARGABLE_PARAM values are put at the end.

4584

All predicates that are used to fill arrays of KEY_FIELD

4585

and SARGABLE_PARAM structures have at most 2 arguments

4586

except BETWEEN predicates that have 3 arguments and

564

4587

IN predicates.

565

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

566

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

567

or SargableParam type. For a BETWEEN predicate 3 elements

4588

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

4589

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

4590

or SARGABLE_PARAM type. For a BETWEEN predicate 3 elements

568

4591

can be filled as this predicate is considered as

569

4592

saragable with respect to each of its argument.

570

4593

An IN predicate can require at most 1 element as currently

571

4594

it is considered as sargable only for its first argument.

572

4595

Multiple equality can add elements that are filled after

573

4596

substitution of field arguments by equal fields. There

574

can be not more than select_lex->max_equal_elems such

4597

can be not more than select_lex->max_equal_elems such

575

4598

substitutions.

576

577

sz= sizeof(optimizer::KeyField) *

578

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

579

session->getLex()->current_select->between_count)*m+1);

580

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

581

return true;

4599

4600

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

4601

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

4602

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

4603

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

4604

return true; /* purecov: inspected */

582

4605

and_level= 0;

583

4606

field= end= key_fields;

4607

*sargables= (SARGABLE_PARAM *) key_fields +

4608

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

4609

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

4610

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

584

4611

585

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

4612

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

586

4613

return true;

587

4614

if (cond)

588

4615

{

589

4616

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

590

4617

sargables);

591

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

4618

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

592

4619

{

593

add_key_part(keyuse, field);

4620

add_key_part(keyuse,field);

594

4621

/* Mark that we can optimize LEFT JOIN */

595

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

596

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

597

{

598

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

599

}

4622

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

4623

!field->field->real_maybe_null())

4624

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

600

4625

}

601

4626

}

602

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

4627

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

603

4628

{

604

4629

605

4630

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

609

4634

In the future when we introduce conditional accesses

610

4635

for inner tables in outer joins these keys will be taken

611

4636

into account as well.

612

4637

613

4638

if (*join_tab[i].on_expr_ref)

614

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

4639

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

615

4640

*join_tab[i].on_expr_ref,

616

4641

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

617

4642

}

618

4643

619

4644

/* Process ON conditions for the nested joins */

620

4645

{

621

List<TableList>::iterator li(join_tab->join->join_list->begin());

4646

List_iterator<TableList> li(*join_tab->join->join_list);

622

4647

TableList *table;

623

4648

while ((table= li++))

624

4649

{

625

if (table->getNestedJoin())

626

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

4650

if (table->nested_join)

4651

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

627

4652

sargables);

628

4653

}

629

4654

}

643

4668

644

4669

if (keyuse->elements)

645

4670

{

646

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

4671

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

647

4672

648

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

649

(qsort_cmp) sort_keyuse);

4673

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

4674

(qsort_cmp) sort_keyuse);

650

4675

651

4676

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

652

4677

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

653

4678

654

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

4679

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

655

4680

prev= &key_end;

656

found_eq_constant= 0;

4681

found_eq_constant=0;

4682

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

657

4683

{

658

uint32_t i;

659

660

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

4684

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

4685

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

661

4686

{

662

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

663

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

664

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

665

{

666

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

667

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

668

continue; /* remove */

669

}

670

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

671

continue;

4687

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

4688

{

4689

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

4690

continue; /* remove */

4691

}

4692

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

4693

continue;

4694

}

672

4695

673

#ifdef HAVE_VALGRIND

674

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

675

if (save_pos != use)

4696

#ifdef HAVE_purify

4697

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

4698

if (save_pos != use)

676

4699

#endif

677

*save_pos= *use;

678

prev=use;

679

found_eq_constant= ! use->getUsedTables();

680

/* Save ptr to first use */

681

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

682

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

683

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

684

save_pos++;

685

}

686

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

687

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

688

keyuse->elements= i;

4700

*save_pos= *use;

4701

prev=use;

4702

found_eq_constant= !use->used_tables;

4703

/* Save ptr to first use */

4704

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

4705

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

4706

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

4707

save_pos++;

689

4708

}

4709

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

4710

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

4711

keyuse->elements=i;

690

4712

}

691

4713

return false;

692

4714

}

694

4716

/**

695

4717

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

696

4718

697

void optimize_keyuse(Join *join, DYNAMIC_ARRAY *keyuse_array)

4719

4720

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

698

4721

{

699

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

700

701

optimizer::KeyUse*);

4722

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

702

4723

703

4724

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

704

4725

{

711

4732

Constant tables are ignored.

712

4733

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

713

4734

714

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

715

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

4735

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

4736

if (keyuse->used_tables &

4737

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

4738

~OUTER_REF_TABLE_BIT)))

716

4739

{

717

4740

uint32_t tablenr;

718

4741

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

719

4742

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

720

4743

{

721

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

722

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

4744

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

4745

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

723

4746

}

724

4747

}

725

4748

726

4749

Outer reference (external field) is constant for single executing

727

4750

of subquery

728

4751

729

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

730

keyuse->setTableRows(1);

4752

if (keyuse->used_tables == OUTER_REF_TABLE_BIT)

4753

keyuse->ref_table_rows= 1;

731

4754

}

732

4755

}

733

4756

749

4772

@return

750

4773

None

751

4774

752

void add_group_and_distinct_keys(Join *join, JoinTable *join_tab)

4775

4776

static void

4777

add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab)

753

4778

{

754

4779

List<Item_field> indexed_fields;

755

List<Item_field>::iterator indexed_fields_it(indexed_fields.begin());

756

Order *cur_group;

4780

List_iterator<Item_field> indexed_fields_it(indexed_fields);

4781

order_st *cur_group;

757

4782

Item_field *cur_item;

758

4783

key_map possible_keys(0);

759

4784

766

4791

else if (join->select_distinct)

767

4792

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

768

4793

List<Item> &select_items= join->fields_list;

769

List<Item>::iterator select_items_it(select_items.begin());

4794

List_iterator<Item> select_items_it(select_items);

770

4795

Item *item;

771

4796

while ((item= select_items_it++))

772

4797

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

780

4805

781

4806

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

782

4807

cur_item= indexed_fields_it++;

783

possible_keys|= cur_item->field->part_of_key;

4808

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

784

4809

while ((cur_item= indexed_fields_it++))

785

4810

{

786

possible_keys&= cur_item->field->part_of_key;

787

}

788

789

if (possible_keys.any())

790

join_tab->const_keys|= possible_keys;

791

}

792

793

/**

794

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

795

796

@param ptr1 pointer to first JoinTable object

797

@param ptr2 pointer to second JoinTable object

4811

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

4812

}

4813

4814

if (!possible_keys.is_clear_all())

4815

join_tab->const_keys.merge(possible_keys);

4816

}

4817

4818

4819

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

4820

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

4821

which uses least records

4822

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

4823

4824

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

4825

4826

static void

4827

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

4828

{

4829

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

4830

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

4831

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

4832

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

4833

4834

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

4835

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

4836

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

4837

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

4838

{

4839

JOIN_TAB *tmp=pos[0];

4840

pos[0]=next;

4841

next=tmp;

4842

}

4843

join->best_ref[idx]=table;

4844

}

4845

4846

4847

4848

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

4849

4850

SYNOPSIS

4851

get_bound_sj_equalities()

4852

sj_nest Semi-join nest

4853

remaining_tables Tables that are not yet bound

4854

4855

DESCRIPTION

4856

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

4857

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

4858

any of remaining_tables and can be evaluated).

4859

4860

RETURN

4861

Bitmap of bound IN-equalities.

4862

4863

4864

uint64_t get_bound_sj_equalities(TableList *sj_nest,

4865

table_map remaining_tables)

4866

{

4867

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

4868

Item *item;

4869

uint32_t i= 0;

4870

uint64_t res= 0;

4871

while ((item= li++))

4872

{

4873

4874

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

4875

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

4876

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

4877

(this is an optional feature)

4878

4879

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

4880

{

4881

res |= 1UL < i;

4882

}

4883

}

4884

return res;

4885

}

4886

4887

4888

/**

4889

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

4890

plan and add this path to the plan.

4891

4892

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

4893

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

4894

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

4895

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

4896

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

4897

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

4898

4899

@param join pointer to the structure providing all context info

4900

for the query

4901

@param s the table to be joined by the function

4902

@param thd thread for the connection that submitted the query

4903

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

4904

@param idx the length of the partial plan

4905

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

4906

partial plan

4907

@param read_time the cost of the partial plan

4908

4909

@return

4910

None

4911

4912

4913

static void

4914

best_access_path(JOIN *join,

4915

JOIN_TAB *s,

4916

THD *thd,

4917

table_map remaining_tables,

4918

uint32_t idx,

4919

double record_count,

4920

double read_time __attribute__((unused)))

4921

{

4922

KEYUSE *best_key= 0;

4923

uint32_t best_max_key_part= 0;

4924

bool found_constraint= 0;

4925

double best= DBL_MAX;

4926

double best_time= DBL_MAX;

4927

double records= DBL_MAX;

4928

table_map best_ref_depends_map= 0;

4929

double tmp;

4930

ha_rows rec;

4931

uint32_t best_is_sj_inside_out= 0;

4932

4933

if (s->keyuse)

4934

{ /* Use key if possible */

4935

Table *table= s->table;

4936

KEYUSE *keyuse,*start_key=0;

4937

double best_records= DBL_MAX;

4938

uint32_t max_key_part=0;

4939

uint64_t bound_sj_equalities= 0;

4940

bool try_sj_inside_out= false;

4941

4942

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

4943

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

4944

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

4945

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

4946

all or none of their tables in join_table_map), except

4947

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

4948

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

4949

4950

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

4951

s->emb_sj_nest->sj_in_exprs < 64 &&

4952

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

4953

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

4954

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

4955

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

4956

{

4957

/* This table is an InsideOut scan candidate */

4958

bound_sj_equalities= get_bound_sj_equalities(s->emb_sj_nest,

4959

remaining_tables);

4960

try_sj_inside_out= true;

4961

}

4962

4963

/* Test how we can use keys */

4964

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

4965

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

4966

{

4967

key_part_map found_part= 0;

4968

table_map found_ref= 0;

4969

uint32_t key= keyuse->key;

4970

KEY *keyinfo= table->key_info+key;

4971

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

4972

key_part_map const_part= 0;

4973

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

4974

key_part_map ref_or_null_part= 0;

4975

4976

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

4977

start_key= keyuse;

4978

uint64_t handled_sj_equalities=0;

4979

key_part_map sj_insideout_map= 0;

4980

4981

do /* For each keypart */

4982

{

4983

uint32_t keypart= keyuse->keypart;

4984

table_map best_part_found_ref= 0;

4985

double best_prev_record_reads= DBL_MAX;

4986

4987

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

4988

{

4989

4990

4991

if 1. expression doesn't refer to forward tables

4992

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

4993

4994

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

4995

!(ref_or_null_part && (keyuse->optimize &

4996

KEY_OPTIMIZE_REF_OR_NULL)))

4997

{

4998

found_part|= keyuse->keypart_map;

4999

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

5000

const_part|= keyuse->keypart_map;

5001

5002

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

5003

keyuse->used_tables));

5004

if (tmp2 < best_prev_record_reads)

5005

{

5006

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

5007

best_prev_record_reads= tmp2;

5008

}

5009

if (rec > keyuse->ref_table_rows)

5010

rec= keyuse->ref_table_rows;

5011

5012

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

5013

use this ref_or_null optimisation of this field

5014

5015

if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)

5016

ref_or_null_part |= keyuse->keypart_map;

5017

}

5018

5019

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

5020

{

5021

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

5022

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

5023

else

5024

{

5025

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

5026

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

5027

}

5028

}

5029

5030

keyuse++;

5031

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

5032

keyuse->keypart == keypart);

5033

found_ref|= best_part_found_ref;

5034

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

5035

5036

5037

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

5038

5039

if (!found_part && !handled_sj_equalities)

5040

continue; // Nothing usable found

5041

5042

if (rec < MATCHING_ROWS_IN_OTHER_TABLE)

5043

rec= MATCHING_ROWS_IN_OTHER_TABLE; // Fix for small tables

5044

5045

bool sj_inside_out_scan= false;

5046

{

5047

found_constraint= 1;

5048

5049

Check if InsideOut scan is applicable:

5050

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

5051

2. Index keyparts are

5052

...

5053

5054

if (try_sj_inside_out &&

5055

table->covering_keys.is_set(key) &&

5056

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

5057

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

5058

{

5059

uint32_t n_fixed_parts= max_part_bit(found_part);

5060

if (n_fixed_parts != keyinfo->key_parts &&

5061

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

5062

PREV_BITS(uint, keyinfo->key_parts))

5063

{

5064

5065

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

5066

check if all of them are covered.

5067

5068

sj_inside_out_scan= true;

5069

if (!n_fixed_parts)

5070

{

5071

5072

It's a confluent ref scan.

5073

5074

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

5075

and there is really no ref access because there is no

5076

t.keypart0 = {bound expression}

5077

5078

Calculate the cost of complete loose index scan.

5079

5080

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

5081

5082

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

5083

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

5084

5085

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

5086

ulong rpc;

5087

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

5088

records= records / rpc;

5089

start_key= NULL;

5090

}

5091

}

5092

}

5093

5094

5095

Check if we found full key

5096

5097

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

5098

!ref_or_null_part)

5099

{ /* use eq key */

5100

max_key_part= UINT32_MAX;

5101

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

5102

{

5103

tmp = prev_record_reads(join, idx, found_ref);

5104

records=1.0;

5105

}

5106

else

5107

{

5108

if (!found_ref)

5109

{ /* We found a const key */

5110

5111

ReuseRangeEstimateForRef-1:

5112

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

5113

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

5114

5115

If range optimizer was able to construct a "range"

5116

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

5117

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

5118

from the range optimizer.

5119

5120

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

5121

quick_cond will be equal or tighther than ref_const_cond.

5122

ref_const_cond already covers "smallest" possible interval -

5123

a singlepoint interval over all keyparts. Therefore,

5124

quick_cond is equivalent to ref_const_cond (if it was an

5125

empty interval we wouldn't have got here).

5126

5127

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

5128

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

5129

else

5130

{

5131

/* quick_range couldn't use key! */

5132

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

5133

}

5134

}

5135

else

5136

{

5137

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

5138

{ /* Prefer longer keys */

5139

records=

5140

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

5141

(1.0 +

5142

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

5143

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

5144

if (records < 2.0)

5145

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

5146

}

5147

5148

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

5149

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

5150

5151

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

5152

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

5153

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

5154

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

5155

in ReuseRangeEstimateForRef-3.

5156

5157

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

5158

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

5159

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

5160

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

5161

{

5162

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

5163

}

5164

}

5165

/* Limit the number of matched rows */

5166

tmp= records;

5167

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

5168

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

5169

{

5170

/* we can use only index tree */

5171

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

5172

}

5173

else

5174

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

5175

}

5176

}

5177

else

5178

{

5179

5180

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

5181

than a not unique key

5182

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

5183

5184

if ((found_part & 1) &&

5185

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

5186

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

5187

{

5188

max_key_part= max_part_bit(found_part);

5189

5190

ReuseRangeEstimateForRef-3:

5191

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

5192

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

5193

(same-as-above but with one cond replaced

5194

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

5195

5196

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

5197

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

5198

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

5199

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

5200

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

5201

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

5202

The sufficient conditions for re-use are:

5203

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

5204

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

5205

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

5206

join)

5207

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

5208

is apparently a necessary requirement)

5209

5210

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

5211

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

5212

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

5213

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

5214

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

5215

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

5216

5217

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

5218

(same-as-above but with one cond replaced

5219

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

5220

5221

The remaining part is to exclude the situation where range

5222

optimizer used one interval while we're considering

5223

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

5224

is done by last limitation:

5225

5226

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

5227

5228

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

5229

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

5230

table->quick_n_ranges[key] == 1+((ref_or_null_part)?1:0)) //(C3)

5231

{

5232

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

5233

}

5234

else

5235

{

5236

/* Check if we have statistic about the distribution */

5237

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

5238

{

5239

5240

Fix for the case where the index statistics is too

5241

optimistic: If

5242

(1) We're considering ref(const) and there is quick select

5243

on the same index,

5244

(2) and that quick select uses more keyparts (i.e. it will

5245

scan equal/smaller interval then this ref(const))

5246

(3) and E(#rows) for quick select is higher then our

5247

estimate,

5248

Then

5249

We'll use E(#rows) from quick select.

5250

5251

Q: Why do we choose to use 'ref'? Won't quick select be

5252

cheaper in some cases ?

5253

TODO: figure this out and adjust the plan choice if needed.

5254

5255

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

5256

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

5257

records < (double)table->quick_rows[key]) // (3)

5258

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

5259

5260

tmp= records;

5261

}

5262

else

5263

{

5264

5265

Assume that the first key part matches 1% of the file

5266

and that the whole key matches 10 (duplicates) or 1

5267

(unique) records.

5268

Assume also that more key matches proportionally more

5269

records

5270

This gives the formula:

5271

records = (x * (b-a) + a*c-b)/(c-1)

5272

5273

b = records matched by whole key

5274

a = records matched by first key part (1% of all records?)

5275

c = number of key parts in key

5276

x = used key parts (1 <= x <= c)

5277

5278

double rec_per_key;

5279

if (!(rec_per_key=(double)

5280

keyinfo->rec_per_key[keyinfo->key_parts-1]))

5281

rec_per_key=(double) s->records/rec+1;

5282

5283

if (!s->records)

5284

tmp = 0;

5285

else if (rec_per_key/(double) s->records >= 0.01)

5286

tmp = rec_per_key;

5287

else

5288

{

5289

double a=s->records*0.01;

5290

if (keyinfo->key_parts > 1)

5291

tmp= (max_key_part * (rec_per_key - a) +

5292

a*keyinfo->key_parts - rec_per_key)/

5293

(keyinfo->key_parts-1);

5294

else

5295

tmp= a;

5296

set_if_bigger(tmp,1.0);

5297

}

5298

records = (ulong) tmp;

5299

}

5300

5301

if (ref_or_null_part)

5302

{

5303

/* We need to do two key searches to find key */

5304

tmp *= 2.0;

5305

records *= 2.0;

5306

}

5307

5308

5309

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

5310

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

5311

5312

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

5313

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

5314

current estimate, make the adjustment.

5315

5316

The decision whether we can re-use the estimate from the range

5317

optimizer is the same as in ReuseRangeEstimateForRef-3,

5318

applied to first table->quick_key_parts[key] key parts.

5319

5320

if (table->quick_keys.is_set(key) &&

5321

table->quick_key_parts[key] <= max_key_part &&

5322

const_part & (1 << table->quick_key_parts[key]) &&

5323

table->quick_n_ranges[key] == 1 + ((ref_or_null_part &

5324

const_part) ? 1 : 0) &&

5325

records > (double) table->quick_rows[key])

5326

{

5327

tmp= records= (double) table->quick_rows[key];

5328

}

5329

}

5330

5331

/* Limit the number of matched rows */

5332

set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);

5333

if (table->covering_keys.is_set(key))

5334

{

5335

/* we can use only index tree */

5336

tmp= record_count * table->file->index_only_read_time(key, tmp);

5337

}

5338

else

5339

tmp= record_count * cmin(tmp,s->worst_seeks);

5340

}

5341

else

5342

tmp= best_time; // Do nothing

5343

}

5344

5345

if (sj_inside_out_scan && !start_key)

5346

{

5347

tmp= tmp/2;

5348

if (records)

5349

records= records/2;

5350

}

5351

5352

}

5353

if (tmp < best_time - records/(double) TIME_FOR_COMPARE)

5354

{

5355

best_time= tmp + records/(double) TIME_FOR_COMPARE;

5356

best= tmp;

5357

best_records= records;

5358

best_key= start_key;

5359

best_max_key_part= max_key_part;

5360

best_ref_depends_map= found_ref;

5361

best_is_sj_inside_out= sj_inside_out_scan;

5362

}

5363

}

5364

records= best_records;

5365

}

5366

5367

5368

Don't test table scan if it can't be better.

5369

Prefer key lookup if we would use the same key for scanning.

5370

5371

Don't do a table scan on InnoDB tables, if we can read the used

5372

parts of the row from any of the used index.

5373

This is because table scans uses index and we would not win

5374

anything by using a table scan.

5375

5376

A word for word translation of the below if-statement in sergefp's

5377

understanding: we check if we should use table scan if:

5378

(1) The found 'ref' access produces more records than a table scan

5379

(or index scan, or quick select), or 'ref' is more expensive than

5380

any of them.

5381

(2) This doesn't hold: the best way to perform table scan is to to perform

5382

'range' access using index IDX, and the best way to perform 'ref'

5383

access is to use the same index IDX, with the same or more key parts.

5384

(note: it is not clear how this rule is/should be extended to

5385

index_merge quick selects)

5386

(3) See above note about InnoDB.

5387

(4) NOT ("FORCE INDEX(...)" is used for table and there is 'ref' access

5388

path, but there is no quick select)

5389

If the condition in the above brackets holds, then the only possible

5390

"table scan" access method is ALL/index (there is no quick select).

5391

Since we have a 'ref' access path, and FORCE INDEX instructs us to

5392

choose it over ALL/index, there is no need to consider a full table

5393

scan.

5394

5395

if ((records >= s->found_records || best > s->read_time) && // (1)

5396

!(s->quick && best_key && s->quick->index == best_key->key && // (2)

5397

best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)

5398

!((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) && // (3)

5399

! s->table->covering_keys.is_clear_all() && best_key && !s->quick) &&// (3)

5400

!(s->table->force_index && best_key && !s->quick)) // (4)

5401

{ // Check full join

5402

ha_rows rnd_records= s->found_records;

5403

5404

If there is a filtering condition on the table (i.e. ref analyzer found

5405

at least one "table.keyXpartY= exprZ", where exprZ refers only to tables

5406

preceding this table in the join order we're now considering), then

5407

assume that 25% of the rows will be filtered out by this condition.

5408

5409

This heuristic is supposed to force tables used in exprZ to be before

5410

this table in join order.

5411

5412

if (found_constraint)

5413

rnd_records-= rnd_records/4;

5414

5415

5416

If applicable, get a more accurate estimate. Don't use the two

5417

heuristics at once.

5418

5419

if (s->table->quick_condition_rows != s->found_records)

5420

rnd_records= s->table->quick_condition_rows;

5421

5422

5423

Range optimizer never proposes a RANGE if it isn't better

5424

than FULL: so if RANGE is present, it's always preferred to FULL.

5425

Here we estimate its cost.

5426

5427

if (s->quick)

5428

{

5429

5430

For each record we:

5431

- read record range through 'quick'

5432

- skip rows which does not satisfy WHERE constraints

5433

TODO:

5434

We take into account possible use of join cache for ALL/index

5435

access (see first else-branch below), but we don't take it into

5436

account here for range/index_merge access. Find out why this is so.

5437

5438

tmp= record_count *

5439

(s->quick->read_time +

5440

(s->found_records - rnd_records)/(double) TIME_FOR_COMPARE);

5441

}

5442

else

5443

{

5444

/* Estimate cost of reading table. */

5445

tmp= s->table->file->scan_time();

5446

if (s->table->map & join->outer_join) // Can't use join cache

5447

{

5448

5449

For each record we have to:

5450

- read the whole table record

5451

- skip rows which does not satisfy join condition

5452

5453

tmp= record_count *

5454

(tmp +

5455

(s->records - rnd_records)/(double) TIME_FOR_COMPARE);

5456

}

5457

else

5458

{

5459

/* We read the table as many times as join buffer becomes full. */

5460

tmp*= (1.0 + floor((double) cache_record_length(join,idx) *

5461

record_count /

5462

(double) thd->variables.join_buff_size));

5463

5464

We don't make full cartesian product between rows in the scanned

5465

table and existing records because we skip all rows from the

5466

scanned table, which does not satisfy join condition when

5467

we read the table (see flush_cached_records for details). Here we

5468

take into account cost to read and skip these records.

5469

5470

tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE;

5471

}

5472

}

5473

5474

5475

We estimate the cost of evaluating WHERE clause for found records

5476

as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus

5477

tmp give us total cost of using Table SCAN

5478

5479

if (best == DBL_MAX ||

5480

(tmp + record_count/(double) TIME_FOR_COMPARE*rnd_records <

5481

best + record_count/(double) TIME_FOR_COMPARE*records))

5482

{

5483

5484

If the table has a range (s->quick is set) make_join_select()

5485

will ensure that this will be used

5486

5487

best= tmp;

5488

records= rows2double(rnd_records);

5489

best_key= 0;

5490

/* range/index_merge/ALL/index access method are "independent", so: */

5491

best_ref_depends_map= 0;

5492

best_is_sj_inside_out= false;

5493

}

5494

}

5495

5496

/* Update the cost information for the current partial plan */

5497

join->positions[idx].records_read= records;

5498

join->positions[idx].read_time= best;

5499

join->positions[idx].key= best_key;

5500

join->positions[idx].table= s;

5501

join->positions[idx].ref_depend_map= best_ref_depends_map;

5502

join->positions[idx].use_insideout_scan= best_is_sj_inside_out;

5503

5504

if (!best_key &&

5505

idx == join->const_tables &&

5506

s->table == join->sort_by_table &&

5507

join->unit->select_limit_cnt >= records)

5508

join->sort_by_table= (Table*) 1; // Must use temporary table

5509

5510

return;

5511

}

5512

5513

5514

/**

5515

Selects and invokes a search strategy for an optimal query plan.

5516

5517

The function checks user-configurable parameters that control the search

5518

strategy for an optimal plan, selects the search method and then invokes

5519

it. Each specific optimization procedure stores the final optimal plan in

5520

the array 'join->best_positions', and the cost of the plan in

5521

'join->best_read'.

5522

5523

@param join pointer to the structure providing all context info for

5524

the query

5525

@param join_tables set of the tables in the query

5526

5527

@todo

5528

'MAX_TABLES+2' denotes the old implementation of find_best before

5529

the greedy version. Will be removed when greedy_search is approved.

5530

5531

@retval

5532

false ok

5533

@retval

5534

true Fatal error

5535

5536

5537

static bool

5538

choose_plan(JOIN *join, table_map join_tables)

5539

{

5540

uint32_t search_depth= join->thd->variables.optimizer_search_depth;

5541

uint32_t prune_level= join->thd->variables.optimizer_prune_level;

5542

bool straight_join= test(join->select_options & SELECT_STRAIGHT_JOIN);

5543

5544

join->cur_embedding_map= 0;

5545

reset_nj_counters(join->join_list);

5546

5547

if (SELECT_STRAIGHT_JOIN option is set)

5548

reorder tables so dependent tables come after tables they depend

5549

on, otherwise keep tables in the order they were specified in the query

5550

else

5551

Apply heuristic: pre-sort all access plans with respect to the number of

5552

records accessed.

5553

5554

my_qsort(join->best_ref + join->const_tables,

5555

join->tables - join->const_tables, sizeof(JOIN_TAB*),

5556

straight_join ? join_tab_cmp_straight : join_tab_cmp);

5557

join->cur_emb_sj_nests= 0;

5558

if (straight_join)

5559

{

5560

optimize_straight_join(join, join_tables);

5561

}

5562

else

5563

{

5564

if (search_depth == MAX_TABLES+2)

5565

{ /*

5566

TODO: 'MAX_TABLES+2' denotes the old implementation of find_best before

5567

the greedy version. Will be removed when greedy_search is approved.

5568

5569

join->best_read= DBL_MAX;

5570

if (find_best(join, join_tables, join->const_tables, 1.0, 0.0))

5571

return(true);

5572

}

5573

else

5574

{

5575

if (search_depth == 0)

5576

/* Automatically determine a reasonable value for 'search_depth' */

5577

search_depth= determine_search_depth(join);

5578

if (greedy_search(join, join_tables, search_depth, prune_level))

5579

return(true);

5580

}

5581

}

5582

5583

5584

Store the cost of this query into a user variable

5585

Don't update last_query_cost for statements that are not "flat joins" :

5586

i.e. they have subqueries, unions or call stored procedures.

5587

TODO: calculate a correct cost for a query with subqueries and UNIONs.

5588

5589

if (join->thd->lex->is_single_level_stmt())

5590

join->thd->status_var.last_query_cost= join->best_read;

5591

return(false);

5592

}

5593

5594

5595

/**

5596

Compare two JOIN_TAB objects based on the number of accessed records.

5597

5598

@param ptr1 pointer to first JOIN_TAB object

5599

@param ptr2 pointer to second JOIN_TAB object

798

5600

799

5601

NOTES

800

5602

The order relation implemented by join_tab_cmp() is not transitive,

806

5608

a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0

807

5609

b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838

808

5610

c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0

809

5611

810

5612

@retval

811

5613

1 if first is bigger

812

5614

@retval

814

5616

@retval

815

5617

0 if equal

816

5618

817

int join_tab_cmp(const void* ptr1, const void* ptr2)

5619

5620

static int

5621

join_tab_cmp(const void* ptr1, const void* ptr2)

818

5622

{

819

JoinTable *jt1= *(JoinTable**) ptr1;

820

JoinTable *jt2= *(JoinTable**) ptr2;

5623

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5624

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

821

5625

822

5626

if (jt1->dependent & jt2->table->map)

823

5627

return 1;

824

5628

if (jt2->dependent & jt1->table->map)

825

return -1;

5629

return -1;

826

5630

if (jt1->found_records > jt2->found_records)

827

5631

return 1;

828

5632

if (jt1->found_records < jt2->found_records)

829

return -1;

5633

return -1;

830

5634

return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);

831

5635

}

832

5636

5637

833

5638

/**

834

5639

Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.

835

5640

836

int join_tab_cmp_straight(const void* ptr1, const void* ptr2)

5641

5642

static int

5643

join_tab_cmp_straight(const void* ptr1, const void* ptr2)

837

5644

{

838

JoinTable *jt1= *(JoinTable**) ptr1;

839

JoinTable *jt2= *(JoinTable**) ptr2;

5645

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5646

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

840

5647

841

5648

if (jt1->dependent & jt2->table->map)

842

5649

return 1;

846

5653

}

847

5654

848

5655

/**

5656

Heuristic procedure to automatically guess a reasonable degree of

5657

exhaustiveness for the greedy search procedure.

5658

5659

The procedure estimates the optimization time and selects a search depth

5660

big enough to result in a near-optimal QEP, that doesn't take too long to

5661

find. If the number of tables in the query exceeds some constant, then

5662

search_depth is set to this constant.

5663

5664

@param join pointer to the structure providing all context info for

5665

the query

5666

5667

@note

5668

This is an extremely simplistic implementation that serves as a stub for a

5669

more advanced analysis of the join. Ideally the search depth should be

5670

determined by learning from previous query optimizations, because it will

5671

depend on the CPU power (and other factors).

5672

5673

@todo

5674

this value should be determined dynamically, based on statistics:

5675

uint32_t max_tables_for_exhaustive_opt= 7;

5676

5677

@todo

5678

this value could be determined by some mapping of the form:

5679

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5680

5681

@return

5682

A positive integer that specifies the search depth (and thus the

5683

exhaustiveness) of the depth-first search algorithm used by

5684

'greedy_search'.

5685

5686

5687

static uint

5688

determine_search_depth(JOIN *join)

5689

{

5690

uint32_t table_count= join->tables - join->const_tables;

5691

uint32_t search_depth;

5692

/* TODO: this value should be determined dynamically, based on statistics: */

5693

uint32_t max_tables_for_exhaustive_opt= 7;

5694

5695

if (table_count <= max_tables_for_exhaustive_opt)

5696

search_depth= table_count+1; // use exhaustive for small number of tables

5697

else

5698

5699

TODO: this value could be determined by some mapping of the form:

5700

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5701

5702

search_depth= max_tables_for_exhaustive_opt; // use greedy search

5703

5704

return search_depth;

5705

}

5706

5707

5708

/**

5709

Select the best ways to access the tables in a query without reordering them.

5710

5711

Find the best access paths for each query table and compute their costs

5712

according to their order in the array 'join->best_ref' (thus without

5713

reordering the join tables). The function calls sequentially

5714

'best_access_path' for each table in the query to select the best table

5715

access method. The final optimal plan is stored in the array

5716

'join->best_positions', and the corresponding cost in 'join->best_read'.

5717

5718

@param join pointer to the structure providing all context info for

5719

the query

5720

@param join_tables set of the tables in the query

5721

5722

@note

5723

This function can be applied to:

5724

- queries with STRAIGHT_JOIN

5725

- internally to compute the cost of an arbitrary QEP

5726

@par

5727

Thus 'optimize_straight_join' can be used at any stage of the query

5728

optimization process to finalize a QEP as it is.

5729

5730

5731

static void

5732

optimize_straight_join(JOIN *join, table_map join_tables)

5733

{

5734

JOIN_TAB *s;

5735

uint32_t idx= join->const_tables;

5736

double record_count= 1.0;

5737

double read_time= 0.0;

5738

5739

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

5740

{

5741

/* Find the best access method from 's' to the current partial plan */

5742

advance_sj_state(join_tables, s);

5743

best_access_path(join, s, join->thd, join_tables, idx,

5744

record_count, read_time);

5745

/* compute the cost of the new plan extended with 's' */

5746

record_count*= join->positions[idx].records_read;

5747

read_time+= join->positions[idx].read_time;

5748

join_tables&= ~(s->table->map);

5749

++idx;

5750

}

5751

5752

read_time+= record_count / (double) TIME_FOR_COMPARE;

5753

if (join->sort_by_table &&

5754

join->sort_by_table != join->positions[join->const_tables].table->table)

5755

read_time+= record_count; // We have to make a temp table

5756

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

5757

join->best_read= read_time;

5758

}

5759

5760

5761

/**

5762

Find a good, possibly optimal, query execution plan (QEP) by a greedy search.

5763

5764

The search procedure uses a hybrid greedy/exhaustive search with controlled

5765

exhaustiveness. The search is performed in N = card(remaining_tables)

5766

steps. Each step evaluates how promising is each of the unoptimized tables,

5767

selects the most promising table, and extends the current partial QEP with

5768

that table. Currenly the most 'promising' table is the one with least

5769

expensive extension.\

5770

5771

There are two extreme cases:

5772

-# When (card(remaining_tables) < search_depth), the estimate finds the

5773

best complete continuation of the partial QEP. This continuation can be

5774

used directly as a result of the search.

5775

-# When (search_depth == 1) the 'best_extension_by_limited_search'

5776

consideres the extension of the current QEP with each of the remaining

5777

unoptimized tables.

5778

5779

All other cases are in-between these two extremes. Thus the parameter

5780

'search_depth' controlls the exhaustiveness of the search. The higher the

5781

value, the longer the optimizaton time and possibly the better the

5782

resulting plan. The lower the value, the fewer alternative plans are

5783

estimated, but the more likely to get a bad QEP.

5784

5785

All intermediate and final results of the procedure are stored in 'join':

5786

- join->positions : modified for every partial QEP that is explored

5787

- join->best_positions: modified for the current best complete QEP

5788

- join->best_read : modified for the current best complete QEP

5789

- join->best_ref : might be partially reordered

5790

5791

The final optimal plan is stored in 'join->best_positions', and its

5792

corresponding cost in 'join->best_read'.

5793

5794

@note

5795

The following pseudocode describes the algorithm of 'greedy_search':

5796

5797

@code

5798

procedure greedy_search

5799

input: remaining_tables

5800

output: pplan;

5801

{

5802

pplan = <>;

5803

do {

5804

(t, a) = best_extension(pplan, remaining_tables);

5805

pplan = concat(pplan, (t, a));

5806

remaining_tables = remaining_tables - t;

5807

} while (remaining_tables != {})

5808

return pplan;

5809

}

5810

5811

@endcode

5812

where 'best_extension' is a placeholder for a procedure that selects the

5813

most "promising" of all tables in 'remaining_tables'.

5814

Currently this estimate is performed by calling

5815

'best_extension_by_limited_search' to evaluate all extensions of the

5816

current QEP of size 'search_depth', thus the complexity of 'greedy_search'

5817

mainly depends on that of 'best_extension_by_limited_search'.

5818

5819

@par

5820

If 'best_extension()' == 'best_extension_by_limited_search()', then the

5821

worst-case complexity of this algorithm is <=

5822

O(N*N^search_depth/search_depth). When serch_depth >= N, then the

5823

complexity of greedy_search is O(N!).

5824

5825

@par

5826

In the future, 'greedy_search' might be extended to support other

5827

implementations of 'best_extension', e.g. some simpler quadratic procedure.

5828

5829

@param join pointer to the structure providing all context info

5830

for the query

5831

@param remaining_tables set of tables not included into the partial plan yet

5832

@param search_depth controlls the exhaustiveness of the search

5833

@param prune_level the pruning heuristics that should be applied during

5834

5835

5836

@retval

5837

false ok

5838

@retval

5839

true Fatal error

5840

5841

5842

static bool

5843

greedy_search(JOIN *join,

5844

table_map remaining_tables,

5845

uint32_t search_depth,

5846

uint32_t prune_level)

5847

{

5848

double record_count= 1.0;

5849

double read_time= 0.0;

5850

uint32_t idx= join->const_tables; // index into 'join->best_ref'

5851

uint32_t best_idx;

5852

uint32_t size_remain; // cardinality of remaining_tables

5853

POSITION best_pos;

5854

JOIN_TAB *best_table; // the next plan node to be added to the curr QEP

5855

5856

/* number of tables that remain to be optimized */

5857

size_remain= my_count_bits(remaining_tables);

5858

5859

do {

5860

/* Find the extension of the current QEP with the lowest cost */

5861

join->best_read= DBL_MAX;

5862

if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,

5863

read_time, search_depth, prune_level))

5864

return(true);

5865

5866

if (size_remain <= search_depth)

5867

{

5868

5869

'join->best_positions' contains a complete optimal extension of the

5870

current partial QEP.

5871

5872

return(false);

5873

}

5874

5875

/* select the first table in the optimal extension as most promising */

5876

best_pos= join->best_positions[idx];

5877

best_table= best_pos.table;

5878

5879

Each subsequent loop of 'best_extension_by_limited_search' uses

5880

'join->positions' for cost estimates, therefore we have to update its

5881

value.

5882

5883

join->positions[idx]= best_pos;

5884

5885

/* find the position of 'best_table' in 'join->best_ref' */

5886

best_idx= idx;

5887

JOIN_TAB *pos= join->best_ref[best_idx];

5888

while (pos && best_table != pos)

5889

pos= join->best_ref[++best_idx];

5890

assert((pos != NULL)); // should always find 'best_table'

5891

/* move 'best_table' at the first free position in the array of joins */

5892

std::swap(join->best_ref[idx], join->best_ref[best_idx]);

5893

5894

/* compute the cost of the new plan extended with 'best_table' */

5895

record_count*= join->positions[idx].records_read;

5896

read_time+= join->positions[idx].read_time;

5897

5898

remaining_tables&= ~(best_table->table->map);

5899

--size_remain;

5900

++idx;

5901

} while (true);

5902

}

5903

5904

5905

/**

5906

Find a good, possibly optimal, query execution plan (QEP) by a possibly

5907

exhaustive search.

5908

5909

The procedure searches for the optimal ordering of the query tables in set

5910

'remaining_tables' of size N, and the corresponding optimal access paths to

5911

each table. The choice of a table order and an access path for each table

5912

constitutes a query execution plan (QEP) that fully specifies how to

5913

execute the query.

5914

5915

The maximal size of the found plan is controlled by the parameter

5916

'search_depth'. When search_depth == N, the resulting plan is complete and

5917

can be used directly as a QEP. If search_depth < N, the found plan consists

5918

of only some of the query tables. Such "partial" optimal plans are useful

5919

only as input to query optimization procedures, and cannot be used directly

5920

to execute a query.

5921

5922

The algorithm begins with an empty partial plan stored in 'join->positions'

5923

and a set of N tables - 'remaining_tables'. Each step of the algorithm

5924

evaluates the cost of the partial plan extended by all access plans for

5925

each of the relations in 'remaining_tables', expands the current partial

5926

plan with the access plan that results in lowest cost of the expanded

5927

partial plan, and removes the corresponding relation from

5928

'remaining_tables'. The algorithm continues until it either constructs a

5929

complete optimal plan, or constructs an optimal plartial plan with size =

5930

search_depth.

5931

5932

The final optimal plan is stored in 'join->best_positions'. The

5933

corresponding cost of the optimal plan is in 'join->best_read'.

5934

5935

@note

5936

The procedure uses a recursive depth-first search where the depth of the

5937

recursion (and thus the exhaustiveness of the search) is controlled by the

5938

parameter 'search_depth'.

5939

5940

@note

5941

The pseudocode below describes the algorithm of

5942

'best_extension_by_limited_search'. The worst-case complexity of this

5943

algorithm is O(N*N^search_depth/search_depth). When serch_depth >= N, then

5944

the complexity of greedy_search is O(N!).

5945

5946

@code

5947

procedure best_extension_by_limited_search(

5948

pplan in, // in, partial plan of tables-joined-so-far

5949

pplan_cost, // in, cost of pplan

5950

remaining_tables, // in, set of tables not referenced in pplan

5951

best_plan_so_far, // in/out, best plan found so far

5952

best_plan_so_far_cost,// in/out, cost of best_plan_so_far

5953

search_depth) // in, maximum size of the plans being considered

5954

{

5955

for each table T from remaining_tables

5956

{

5957

// Calculate the cost of using table T as above

5958

cost = complex-series-of-calculations;

5959

5960

// Add the cost to the cost so far.

5961

pplan_cost+= cost;

5962

5963

if (pplan_cost >= best_plan_so_far_cost)

5964

// pplan_cost already too great, stop search

5965

continue;

5966

5967

pplan= expand pplan by best_access_method;

5968

remaining_tables= remaining_tables - table T;

5969

if (remaining_tables is not an empty set

5970

and

5971

search_depth > 1)

5972

{

5973

best_extension_by_limited_search(pplan, pplan_cost,

5974

remaining_tables,

5975

best_plan_so_far,

5976

best_plan_so_far_cost,

5977

search_depth - 1);

5978

}

5979

else

5980

{

5981

best_plan_so_far_cost= pplan_cost;

5982

best_plan_so_far= pplan;

5983

}

5984

}

5985

}

5986

@endcode

5987

5988

@note

5989

When 'best_extension_by_limited_search' is called for the first time,

5990

'join->best_read' must be set to the largest possible value (e.g. DBL_MAX).

5991

The actual implementation provides a way to optionally use pruning

5992

heuristic (controlled by the parameter 'prune_level') to reduce the search

5993

space by skipping some partial plans.

5994

5995

@note

5996

The parameter 'search_depth' provides control over the recursion

5997

depth, and thus the size of the resulting optimal plan.

5998

5999

@param join pointer to the structure providing all context info

6000

for the query

6001

@param remaining_tables set of tables not included into the partial plan yet

6002

@param idx length of the partial QEP in 'join->positions';

6003

since a depth-first search is used, also corresponds

6004

to the current depth of the search tree;

6005

also an index in the array 'join->best_ref';

6006

@param record_count estimate for the number of records returned by the

6007

best partial plan

6008

@param read_time the cost of the best partial plan

6009

@param search_depth maximum depth of the recursion and thus size of the

6010

found optimal plan

6011

(0 < search_depth <= join->tables+1).

6012

@param prune_level pruning heuristics that should be applied during

6013

optimization

6014

(values: 0 = EXHAUSTIVE, 1 = PRUNE_BY_TIME_OR_ROWS)

6015

6016

@retval

6017

false ok

6018

@retval

6019

true Fatal error

6020

6021

6022

static bool

6023

best_extension_by_limited_search(JOIN *join,

6024

table_map remaining_tables,

6025

uint32_t idx,

6026

double record_count,

6027

double read_time,

6028

uint32_t search_depth,

6029

uint32_t prune_level)

6030

{

6031

THD *thd= join->thd;

6032

if (thd->killed) // Abort

6033

return(true);

6034

6035

6036

'join' is a partial plan with lower cost than the best plan so far,

6037

so continue expanding it further with the tables in 'remaining_tables'.

6038

6039

JOIN_TAB *s;

6040

double best_record_count= DBL_MAX;

6041

double best_read_time= DBL_MAX;

6042

6043

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

6044

{

6045

table_map real_table_bit= s->table->map;

6046

if ((remaining_tables & real_table_bit) &&

6047

!(remaining_tables & s->dependent) &&

6048

(!idx || !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6049

{

6050

double current_record_count, current_read_time;

6051

advance_sj_state(remaining_tables, s);

6052

6053

6054

psergey-insideout-todo:

6055

when best_access_path() detects it could do an InsideOut scan or

6056

some other scan, have it return an insideout scan and a flag that

6057

requests to "fork" this loop iteration. (Q: how does that behave

6058

when the depth is insufficient??)

6059

6060

/* Find the best access method from 's' to the current partial plan */

6061

best_access_path(join, s, thd, remaining_tables, idx,

6062

record_count, read_time);

6063

/* Compute the cost of extending the plan with 's' */

6064

current_record_count= record_count * join->positions[idx].records_read;

6065

current_read_time= read_time + join->positions[idx].read_time;

6066

6067

/* Expand only partial plans with lower cost than the best QEP so far */

6068

if ((current_read_time +

6069

current_record_count / (double) TIME_FOR_COMPARE) >= join->best_read)

6070

{

6071

restore_prev_nj_state(s);

6072

restore_prev_sj_state(remaining_tables, s);

6073

continue;

6074

}

6075

6076

6077

Prune some less promising partial plans. This heuristic may miss

6078

the optimal QEPs, thus it results in a non-exhaustive search.

6079

6080

if (prune_level == 1)

6081

{

6082

if (best_record_count > current_record_count ||

6083

best_read_time > current_read_time ||

6084

(idx == join->const_tables && s->table == join->sort_by_table)) // 's' is the first table in the QEP

6085

{

6086

if (best_record_count >= current_record_count &&

6087

best_read_time >= current_read_time &&

6088

/* TODO: What is the reasoning behind this condition? */

6089

(!(s->key_dependent & remaining_tables) ||

6090

join->positions[idx].records_read < 2.0))

6091

{

6092

best_record_count= current_record_count;

6093

best_read_time= current_read_time;

6094

}

6095

}

6096

else

6097

{

6098

restore_prev_nj_state(s);

6099

restore_prev_sj_state(remaining_tables, s);

6100

continue;

6101

}

6102

}

6103

6104

if ( (search_depth > 1) && (remaining_tables & ~real_table_bit) )

6105

{ /* Recursively expand the current partial plan */

6106

std::swap(join->best_ref[idx], *pos);

6107

if (best_extension_by_limited_search(join,

6108

remaining_tables & ~real_table_bit,

6109

idx + 1,

6110

current_record_count,

6111

current_read_time,

6112

search_depth - 1,

6113

prune_level))

6114

return(true);

6115

std::swap(join->best_ref[idx], *pos);

6116

}

6117

else

6118

{ /*

6119

'join' is either the best partial QEP with 'search_depth' relations,

6120

or the best complete QEP so far, whichever is smaller.

6121

6122

current_read_time+= current_record_count / (double) TIME_FOR_COMPARE;

6123

if (join->sort_by_table &&

6124

join->sort_by_table !=

6125

join->positions[join->const_tables].table->table)

6126

/* We have to make a temp table */

6127

current_read_time+= current_record_count;

6128

if ((search_depth == 1) || (current_read_time < join->best_read))

6129

{

6130

memcpy(join->best_positions, join->positions,

6131

sizeof(POSITION) * (idx + 1));

6132

join->best_read= current_read_time - 0.001;

6133

}

6134

}

6135

restore_prev_nj_state(s);

6136

restore_prev_sj_state(remaining_tables, s);

6137

}

6138

}

6139

return(false);

6140

}

6141

6142

6143

/**

6144

@todo

6145

- TODO: this function is here only temporarily until 'greedy_search' is

6146

tested and accepted.

6147

6148

RETURN VALUES

6149

false ok

6150

true Fatal error

6151

6152

static bool

6153

find_best(JOIN *join,table_map rest_tables,uint32_t idx,double record_count,

6154

double read_time)

6155

{

6156

THD *thd= join->thd;

6157

if (thd->killed)

6158

return(true);

6159

if (!rest_tables)

6160

{

6161

read_time+=record_count/(double) TIME_FOR_COMPARE;

6162

if (join->sort_by_table &&

6163

join->sort_by_table !=

6164

join->positions[join->const_tables].table->table)

6165

read_time+=record_count; // We have to make a temp table

6166

if (read_time < join->best_read)

6167

{

6168

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

6169

join->best_read= read_time - 0.001;

6170

}

6171

return(false);

6172

}

6173

if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)

6174

return(false); /* Found better before */

6175

6176

JOIN_TAB *s;

6177

double best_record_count=DBL_MAX,best_read_time=DBL_MAX;

6178

for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)

6179

{

6180

table_map real_table_bit=s->table->map;

6181

if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent) &&

6182

(!idx|| !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6183

{

6184

double records, best;

6185

advance_sj_state(rest_tables, s);

6186

best_access_path(join, s, thd, rest_tables, idx, record_count,

6187

read_time);

6188

records= join->positions[idx].records_read;

6189

best= join->positions[idx].read_time;

6190

6191

Go to the next level only if there hasn't been a better key on

6192

this level! This will cut down the search for a lot simple cases!

6193

6194

double current_record_count=record_count*records;

6195

double current_read_time=read_time+best;

6196

if (best_record_count > current_record_count ||

6197

best_read_time > current_read_time ||

6198

(idx == join->const_tables && s->table == join->sort_by_table))

6199

{

6200

if (best_record_count >= current_record_count &&

6201

best_read_time >= current_read_time &&

6202

(!(s->key_dependent & rest_tables) || records < 2.0))

6203

{

6204

best_record_count=current_record_count;

6205

best_read_time=current_read_time;

6206

}

6207

std::swap(join->best_ref[idx], *pos);

6208

if (find_best(join,rest_tables & ~real_table_bit,idx+1,

6209

current_record_count,current_read_time))

6210

return(true);

6211

std::swap(join->best_ref[idx], *pos);

6212

}

6213

restore_prev_nj_state(s);

6214

restore_prev_sj_state(rest_tables, s);

6215

if (join->select_options & SELECT_STRAIGHT_JOIN)

6216

break; // Don't test all combinations

6217

}

6218

}

6219

return(false);

6220

}

6221

6222

6223

/**

849

6224

Find how much space the prevous read not const tables takes in cache.

850

6225

851

void calc_used_field_length(Session *, JoinTable *join_tab)

6226

6227

static void calc_used_field_length(THD *thd __attribute__((unused)),

6228

JOIN_TAB *join_tab)

852

6229

{

853

6230

uint32_t null_fields,blobs,fields,rec_length;

854

6231

Field **f_ptr,*field;

6232

MY_BITMAP *read_set= join_tab->table->read_set;;

855

6233

856

6234

null_fields= blobs= fields= rec_length=0;

857

for (f_ptr=join_tab->table->getFields() ; (field= *f_ptr) ; f_ptr++)

6235

for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)

858

6236

{

859

if (field->isReadSet())

6237

if (bitmap_is_set(read_set, field->field_index))

860

6238

{

861

6239

uint32_t flags=field->flags;

862

6240

fields++;

863

6241

rec_length+=field->pack_length();

864

6242

if (flags & BLOB_FLAG)

865

blobs++;

6243

blobs++;

866

6244

if (!(flags & NOT_NULL_FLAG))

867

null_fields++;

6245

null_fields++;

868

6246

}

869

6247

}

870

6248

if (null_fields)

873

6251

rec_length+=sizeof(bool);

874

6252

if (blobs)

875

6253

{

876

uint32_t blob_length=(uint32_t) (join_tab->table->cursor->stats.mean_rec_length-

877

(join_tab->table->getRecordLength()- rec_length));

878

rec_length+= max((uint32_t)4,blob_length);

879

}

880

join_tab->used_fields= fields;

881

join_tab->used_fieldlength= rec_length;

882

join_tab->used_blobs= blobs;

883

}

884

885

StoredKey *get_store_key(Session *session,

886

optimizer::KeyUse *keyuse,

887

table_map used_tables,

888

KeyPartInfo *key_part,

889

unsigned char *key_buff,

890

uint32_t maybe_null)

891

{

892

Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());

893

if (! ((~used_tables) & keyuse->getUsedTables())) // if const item

894

{

895

return new store_key_const_item(session,

896

key_part->field,

897

key_buff + maybe_null,

898

maybe_null ? key_buff : 0,

899

key_part->length,

900

key_use_val);

901

}

902

else if (key_use_val->type() == Item::FIELD_ITEM ||

903

(key_use_val->type() == Item::REF_ITEM &&

904

key_use_val->ref_type() == Item_ref::OUTER_REF &&

905

(*(Item_ref**)((Item_ref*)key_use_val)->ref)->ref_type() == Item_ref::DIRECT_REF &&

906

key_use_val->real_item()->type() == Item::FIELD_ITEM))

907

{

908

return new store_key_field(session,

909

key_part->field,

910

key_buff + maybe_null,

911

maybe_null ? key_buff : 0,

912

key_part->length,

913

((Item_field*) key_use_val->real_item())->field,

914

key_use_val->full_name());

915

}

916

return new store_key_item(session,

917

key_part->field,

918

key_buff + maybe_null,

919

maybe_null ? key_buff : 0,

920

key_part->length,

921

key_use_val);

922

}

6254

uint32_t blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-

6255

(join_tab->table->getRecordLength()- rec_length));

6256

rec_length+=(uint) cmax((uint)4,blob_length);

6257

}

6258

join_tab->used_fields=fields;

6259

join_tab->used_fieldlength=rec_length;

6260

join_tab->used_blobs=blobs;

6261

}

6262

6263

6264

static uint

6265

cache_record_length(JOIN *join,uint32_t idx)

6266

{

6267

uint32_t length=0;

6268

JOIN_TAB **pos,**end;

6269

THD *thd=join->thd;

6270

6271

for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;

6272

pos != end ;

6273

pos++)

6274

{

6275

JOIN_TAB *join_tab= *pos;

6276

if (!join_tab->used_fieldlength) /* Not calced yet */

6277

calc_used_field_length(thd, join_tab);

6278

length+=join_tab->used_fieldlength;

6279

}

6280

return length;

6281

}

6282

6283

6284

6285

Get the number of different row combinations for subset of partial join

6286

6287

SYNOPSIS

6288

prev_record_reads()

6289

join The join structure

6290

idx Number of tables in the partial join order (i.e. the

6291

partial join order is in join->positions[0..idx-1])

6292

found_ref Bitmap of tables for which we need to find # of distinct

6293

row combinations.

6294

6295

DESCRIPTION

6296

Given a partial join order (in join->positions[0..idx-1]) and a subset of

6297

tables within that join order (specified in found_ref), find out how many

6298

distinct row combinations of subset tables will be in the result of the

6299

partial join order.

6300

6301

This is used as follows: Suppose we have a table accessed with a ref-based

6302

method. The ref access depends on current rows of tables in found_ref.

6303

We want to count # of different ref accesses. We assume two ref accesses

6304

will be different if at least one of access parameters is different.

6305

Example: consider a query

6306

6307

SELECT * FROM t1, t2, t3 WHERE t1.key=c1 AND t2.key=c2 AND t3.key=t1.field

6308

6309

and a join order:

6310

t1, ref access on t1.key=c1

6311

t2, ref access on t2.key=c2

6312

t3, ref access on t3.key=t1.field

6313

6314

For t1: n_ref_scans = 1, n_distinct_ref_scans = 1

6315

For t2: n_ref_scans = records_read(t1), n_distinct_ref_scans=1

6316

For t3: n_ref_scans = records_read(t1)*records_read(t2)

6317

n_distinct_ref_scans = #records_read(t1)

6318

6319

The reason for having this function (at least the latest version of it)

6320

is that we need to account for buffering in join execution.

6321

6322

An edge-case example: if we have a non-first table in join accessed via

6323

ref(const) or ref(param) where there is a small number of different

6324

values of param, then the access will likely hit the disk cache and will

6325

not require any disk seeks.

6326

6327

The proper solution would be to assume an LRU disk cache of some size,

6328

calculate probability of cache hits, etc. For now we just count

6329

identical ref accesses as one.

6330

6331

RETURN

6332

Expected number of row combinations

6333

6334

6335

static double

6336

prev_record_reads(JOIN *join, uint32_t idx, table_map found_ref)

6337

{

6338

double found=1.0;

6339

POSITION *pos_end= join->positions - 1;

6340

for (POSITION *pos= join->positions + idx - 1; pos != pos_end; pos--)

6341

{

6342

if (pos->table->table->map & found_ref)

6343

{

6344

found_ref|= pos->ref_depend_map;

6345

6346

For the case of "t1 LEFT JOIN t2 ON ..." where t2 is a const table

6347

with no matching row we will get position[t2].records_read==0.

6348

Actually the size of output is one null-complemented row, therefore

6349

we will use value of 1 whenever we get records_read==0.

6350

6351

Note

6352

- the above case can't occur if inner part of outer join has more

6353

than one table: table with no matches will not be marked as const.

6354

6355

- Ideally we should add 1 to records_read for every possible null-

6356

complemented row. We're not doing it because: 1. it will require

6357

non-trivial code and add overhead. 2. The value of records_read

6358

is an inprecise estimate and adding 1 (or, in the worst case,

6359

#max_nested_outer_joins=64-1) will not make it any more precise.

6360

6361

if (pos->records_read > DBL_EPSILON)

6362

found*= pos->records_read;

6363

}

6364

}

6365

return found;

6366

}

6367

923

6368

924

6369

/**

925

This function is only called for const items on fields which are keys.

926

927

@return

928

returns 1 if there was some conversion made when the field was stored.

6370

Set up join struct according to best position.

929

6371

930

bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

931

{

932

bool error;

933

Table *table= field->getTable();

934

Session *session= table->in_use;

935

ha_rows cuted_fields=session->cuted_fields;

936

937

938

we should restore old value of count_cuted_fields because

939

store_val_in_field can be called from insert_query

940

with select_insert, which make count_cuted_fields= 1

941

942

enum_check_fields old_count_cuted_fields= session->count_cuted_fields;

943

session->count_cuted_fields= check_flag;

944

error= item->save_in_field(field, 1);

945

session->count_cuted_fields= old_count_cuted_fields;

946

return error || cuted_fields != session->cuted_fields;

947

}

948

949

inline void add_cond_and_fix(Item **e1, Item *e2)

950

{

951

if (*e1)

6372

6373

static bool

6374

get_best_combination(JOIN *join)

6375

{

6376

uint32_t i,tablenr;

6377

table_map used_tables;

6378

JOIN_TAB *join_tab,*j;

6379

KEYUSE *keyuse;

6380

uint32_t table_count;

6381

THD *thd=join->thd;

6382

6383

table_count=join->tables;

6384

if (!(join->join_tab=join_tab=

6385

(JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))

6386

return(true);

6387

6388

join->full_join=0;

6389

6390

used_tables= OUTER_REF_TABLE_BIT; // Outer row is already read

6391

for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)

952

6392

{

953

Item *res;

954

if ((res= new Item_cond_and(*e1, e2)))

6393

Table *form;

6394

*j= *join->best_positions[tablenr].table;

6395

form=join->table[tablenr]=j->table;

6396

used_tables|= form->map;

6397

form->reginfo.join_tab=j;

6398

if (!*j->on_expr_ref)

6399

form->reginfo.not_exists_optimize=0; // Only with LEFT JOIN

6400

if (j->type == JT_CONST)

6401

continue; // Handled in make_join_stat..

6402

6403

j->ref.key = -1;

6404

j->ref.key_parts=0;

6405

6406

if (j->type == JT_SYSTEM)

6407

continue;

6408

if (j->keys.is_clear_all() || !(keyuse= join->best_positions[tablenr].key))

955

6409

{

956

*e1= res;

957

res->quick_fix_field();

6410

j->type=JT_ALL;

6411

if (tablenr != join->const_tables)

6412

join->full_join=1;

958

6413

}

6414

else if (create_ref_for_key(join, j, keyuse, used_tables))

6415

return(true); // Something went wrong

959

6416

}

960

else

961

*e1= e2;

6417

6418

for (i=0 ; i < table_count ; i++)

6419

join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;

6420

update_depend_map(join);

6421

return(0);

962

6422

}

963

6423

964

bool create_ref_for_key(Join *join,

965

JoinTable *j,

966

optimizer::KeyUse *org_keyuse,

967

table_map used_tables)

6424

6425

static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,

6426

table_map used_tables)

968

6427

{

969

optimizer::KeyUse *keyuse= org_keyuse;

970

Session *session= join->session;

971

uint32_t keyparts;

972

uint32_t length;

973

uint32_t key;

974

Table *table= NULL;

975

KeyInfo *keyinfo= NULL;

6428

KEYUSE *keyuse=org_keyuse;

6429

THD *thd= join->thd;

6430

uint32_t keyparts,length,key;

6431

Table *table;

6432

KEY *keyinfo;

976

6433

977

6434

/* Use best key from find_best */

978

table= j->table;

979

key= keyuse->getKey();

980

keyinfo= table->key_info + key;

6435

table=j->table;

6436

key=keyuse->key;

6437

keyinfo=table->key_info+key;

981

6438

982

6439

{

983

keyparts= length= 0;

6440

keyparts=length=0;

984

6441

uint32_t found_part_ref_or_null= 0;

985

6442

986

6443

Calculate length for the used key

989

6446

990

6447

991

6448

{

992

if (! (~used_tables & keyuse->getUsedTables()))

6449

if (!(~used_tables & keyuse->used_tables))

993

6450

{

994

if (keyparts == keyuse->getKeypart() &&

995

! (found_part_ref_or_null & keyuse->getOptimizeFlags()))

996

{

997

keyparts++;

998

length+= keyinfo->key_part[keyuse->getKeypart()].store_length;

999

found_part_ref_or_null|= keyuse->getOptimizeFlags();

1000

}

6451

if (keyparts == keyuse->keypart &&

6452

!(found_part_ref_or_null & keyuse->optimize))

6453

{

6454

keyparts++;

6455

length+= keyinfo->key_part[keyuse->keypart].store_length;

6456

found_part_ref_or_null|= keyuse->optimize;

6457

}

1001

6458

}

1002

6459

keyuse++;

1003

} while (keyuse->getTable() == table && keyuse->getKey() == key);

6460

} while (keyuse->table == table && keyuse->key == key);

1004

6461

}

1005

6462

1006

6463

/* set up fieldref */

1008

6465

j->ref.key_parts=keyparts;

1009

6466

j->ref.key_length=length;

1010

6467

j->ref.key=(int) key;

1011

if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

1012

!(j->ref.key_copy= (StoredKey**) session->getMemRoot()->allocate((sizeof(StoredKey*) *

1013

(keyparts+1)))) ||

1014

!(j->ref.items= (Item**) session->getMemRoot()->allocate(sizeof(Item*)*keyparts)) ||

1015

!(j->ref.cond_guards= (bool**) session->getMemRoot()->allocate(sizeof(uint*)*keyparts)))

6468

if (!(j->ref.key_buff= (unsigned char*) thd->calloc(ALIGN_SIZE(length)*2)) ||

6469

!(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *

6470

(keyparts+1)))) ||

6471

!(j->ref.items= (Item**) thd->alloc(sizeof(Item*)*keyparts)) ||

6472

!(j->ref.cond_guards= (bool**) thd->alloc(sizeof(uint*)*keyparts)))

1016

6473

{

1017

6474

return(true);

1018

6475

}

1022

6479

j->ref.disable_cache= false;

1023

6480

keyuse=org_keyuse;

1024

6481

1025

StoredKey **ref_key= j->ref.key_copy;

1026

unsigned char *key_buff= j->ref.key_buff, *null_ref_key= 0;

6482

store_key **ref_key= j->ref.key_copy;

6483

unsigned char *key_buff=j->ref.key_buff, *null_ref_key= 0;

1027

6484

bool keyuse_uses_no_tables= true;

1028

6485

{

1029

for (uint32_t i= 0; i < keyparts; keyuse++, i++)

6486

uint32_t i;

6487

for (i=0 ; i < keyparts ; keyuse++,i++)

1030

6488

{

1031

while (keyuse->getKeypart() != i ||

1032

((~used_tables) & keyuse->getUsedTables()))

1033

keyuse++; /* Skip other parts */

6489

while (keyuse->keypart != i ||

6490

((~used_tables) & keyuse->used_tables))

6491

keyuse++; /* Skip other parts */

1034

6492

1035

6493

uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);

1036

j->ref.items[i]= keyuse->getVal(); // Save for cond removal

1037

j->ref.cond_guards[i]= keyuse->getConditionalGuard();

1038

if (keyuse->isNullRejected())

6494

j->ref.items[i]=keyuse->val; // Save for cond removal

6495

j->ref.cond_guards[i]= keyuse->cond_guard;

6496

if (keyuse->null_rejecting)

1039

6497

j->ref.null_rejecting |= 1 << i;

1040

keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();

1041

if (! keyuse->getUsedTables() && !(join->select_options & SELECT_DESCRIBE))

1042

{ // Compare against constant

1043

store_key_item tmp(session, keyinfo->key_part[i].field,

6498

keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;

6499

if (!keyuse->used_tables &&

6500

!(join->select_options & SELECT_DESCRIBE))

6501

{ // Compare against constant

6502

store_key_item tmp(thd, keyinfo->key_part[i].field,

1044

6503

key_buff + maybe_null,

1045

6504

maybe_null ? key_buff : 0,

1046

keyinfo->key_part[i].length, keyuse->getVal());

1047

if (session->is_fatal_error)

1048

return(true);

1049

tmp.copy();

6505

keyinfo->key_part[i].length, keyuse->val);

6506

if (thd->is_fatal_error)

6507

return(true);

6508

tmp.copy();

1050

6509

}

1051

6510

else

1052

*ref_key++= get_store_key(session,

1053

keyuse,join->const_table_map,

1054

&keyinfo->key_part[i],

1055

key_buff, maybe_null);

6511

*ref_key++= get_store_key(thd,

6512

keyuse,join->const_table_map,

6513

&keyinfo->key_part[i],

6514

key_buff, maybe_null);

1056

6515

1057

Remember if we are going to use REF_OR_NULL

1058

But only if field _really_ can be null i.e. we force AM_REF

1059

instead of AM_REF_OR_NULL in case if field can't be null

6516

Remember if we are going to use REF_OR_NULL

6517

But only if field _really_ can be null i.e. we force JT_REF

6518

instead of JT_REF_OR_NULL in case if field can't be null

1060

6519

1061

if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

1062

null_ref_key= key_buff;

6520

if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

6521

null_ref_key= key_buff;

1063

6522

key_buff+=keyinfo->key_part[i].store_length;

1064

6523

}

1065

6524

}

1066

*ref_key= 0; // end_marker

1067

if (j->type == AM_CONST)

6525

*ref_key=0; // end_marker

6526

if (j->type == JT_CONST)

1068

6527

j->table->const_table= 1;

1069

6528

else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||

1070

6529

keyparts != keyinfo->key_parts || null_ref_key)

1071

6530

{

1072

6531

/* Must read with repeat */

1073

j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;

6532

j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;

1074

6533

j->ref.null_ref_key= null_ref_key;

1075

6534

}

1076

6535

else if (keyuse_uses_no_tables)

1082

6541

Here we should not mark the table as a 'const' as a field may

1083

6542

have a 'normal' value or a NULL value.

1084

6543

1085

j->type= AM_CONST;

1086

}

1087

else

1088

j->type= AM_EQ_REF;

1089

return 0;

1090

}

6544

j->type=JT_CONST;

6545

}

6546

else

6547

j->type=JT_EQ_REF;

6548

return(0);

6549

}

6550

6551

6552

6553

static store_key *

6554

get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,

6555

KEY_PART_INFO *key_part, unsigned char *key_buff, uint32_t maybe_null)

6556

{

6557

if (!((~used_tables) & keyuse->used_tables)) // if const item

6558

{

6559

return new store_key_const_item(thd,

6560

key_part->field,

6561

key_buff + maybe_null,

6562

maybe_null ? key_buff : 0,

6563

key_part->length,

6564

keyuse->val);

6565

}

6566

else if (keyuse->val->type() == Item::FIELD_ITEM ||

6567

(keyuse->val->type() == Item::REF_ITEM &&

6568

((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&

6569

(*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==

6570

Item_ref::DIRECT_REF &&

6571

keyuse->val->real_item()->type() == Item::FIELD_ITEM))

6572

return new store_key_field(thd,

6573

key_part->field,

6574

key_buff + maybe_null,

6575

maybe_null ? key_buff : 0,

6576

key_part->length,

6577

((Item_field*) keyuse->val->real_item())->field,

6578

keyuse->val->full_name());

6579

return new store_key_item(thd,

6580

key_part->field,

6581

key_buff + maybe_null,

6582

maybe_null ? key_buff : 0,

6583

key_part->length,

6584

keyuse->val);

6585

}

6586

6587

/**

6588

This function is only called for const items on fields which are keys.

6589

6590

@return

6591

returns 1 if there was some conversion made when the field was stored.

6592

6593

6594

bool

6595

store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

6596

{

6597

bool error;

6598

Table *table= field->table;

6599

THD *thd= table->in_use;

6600

ha_rows cuted_fields=thd->cuted_fields;

6601

6602

6603

we should restore old value of count_cuted_fields because

6604

store_val_in_field can be called from mysql_insert

6605

with select_insert, which make count_cuted_fields= 1

6606

6607

enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;

6608

thd->count_cuted_fields= check_flag;

6609

error= item->save_in_field(field, 1);

6610

thd->count_cuted_fields= old_count_cuted_fields;

6611

return error || cuted_fields != thd->cuted_fields;

6612

}

6613

6614

6615

static bool

6616

make_simple_join(JOIN *join,Table *tmp_table)

6617

{

6618

Table **tableptr;

6619

JOIN_TAB *join_tab;

6620

6621

6622

Reuse Table * and JOIN_TAB if already allocated by a previous call

6623

to this function through JOIN::exec (may happen for sub-queries).

6624

6625

if (!join->table_reexec)

6626

{

6627

if (!(join->table_reexec= (Table**) join->thd->alloc(sizeof(Table*))))

6628

return(true); /* purecov: inspected */

6629

if (join->tmp_join)

6630

join->tmp_join->table_reexec= join->table_reexec;

6631

}

6632

if (!join->join_tab_reexec)

6633

{

6634

if (!(join->join_tab_reexec=

6635

(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))

6636

return(true); /* purecov: inspected */

6637

if (join->tmp_join)

6638

join->tmp_join->join_tab_reexec= join->join_tab_reexec;

6639

}

6640

tableptr= join->table_reexec;

6641

join_tab= join->join_tab_reexec;

6642

6643

join->join_tab=join_tab;

6644

join->table=tableptr; tableptr[0]=tmp_table;

6645

join->tables=1;

6646

join->const_tables=0;

6647

join->const_table_map=0;

6648

join->tmp_table_param.field_count= join->tmp_table_param.sum_func_count=

6649

join->tmp_table_param.func_count=0;

6650

join->tmp_table_param.copy_field=join->tmp_table_param.copy_field_end=0;

6651

join->first_record=join->sort_and_group=0;

6652

join->send_records=(ha_rows) 0;

6653

join->group=0;

6654

join->row_limit=join->unit->select_limit_cnt;

6655

join->do_send_rows = (join->row_limit) ? 1 : 0;

6656

6657

join_tab->cache.buff=0; /* No caching */

6658

join_tab->table=tmp_table;

6659

join_tab->select=0;

6660

join_tab->select_cond=0;

6661

join_tab->quick=0;

6662

join_tab->type= JT_ALL; /* Map through all records */

6663

join_tab->keys.init();

6664

join_tab->keys.set_all(); /* test everything in quick */

6665

join_tab->info=0;

6666

join_tab->on_expr_ref=0;

6667

join_tab->last_inner= 0;

6668

join_tab->first_unmatched= 0;

6669

join_tab->ref.key = -1;

6670

join_tab->not_used_in_distinct=0;

6671

join_tab->read_first_record= join_init_read_record;

6672

join_tab->join=join;

6673

join_tab->ref.key_parts= 0;

6674

join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;

6675

join_tab->do_firstmatch= NULL;

6676

memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));

6677

tmp_table->status=0;

6678

tmp_table->null_row=0;

6679

return(false);

6680

}

6681

6682

6683

inline void add_cond_and_fix(Item **e1, Item *e2)

6684

{

6685

if (*e1)

6686

{

6687

Item *res;

6688

if ((res= new Item_cond_and(*e1, e2)))

6689

{

6690

*e1= res;

6691

res->quick_fix_field();

6692

}

6693

}

6694

else

6695

*e1= e2;

6696

}

6697

1091

6698

1092

6699

/**

1093

6700

Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions

1102

6709

add "t1.field IS NOT NULL" to t1's table condition. @n

1103

6710

1104

6711

Description of the optimization:

1105

6712

1106

6713

We look through equalities choosen to perform ref/eq_ref access,

1107

6714

pick equalities that have form "tbl.part_of_key = othertbl.field"

1108

6715

(where othertbl is a non-const table and othertbl.field may be NULL)

1130

6737

This optimization doesn't affect the choices that ref, range, or join

1131

6738

optimizer make. This was intentional because this was added after 4.1

1132

6739

was GA.

1133

6740

1134

6741

Implementation overview

1135

6742

1. update_ref_and_keys() accumulates info about null-rejecting

1136

predicates in in KeyField::null_rejecting

1137

1.1 add_key_part saves these to KeyUse.

1138

2. create_ref_for_key copies them to table_reference_st.

6743

predicates in in KEY_FIELD::null_rejecting

6744

1.1 add_key_part saves these to KEYUSE.

6745

2. create_ref_for_key copies them to TABLE_REF.

1139

6746

3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of

1140

appropiate JoinTable members.

6747

appropiate JOIN_TAB members.

1141

6748

1142

void add_not_null_conds(Join *join)

6749

6750

static void add_not_null_conds(JOIN *join)

1143

6751

{

1144

for (uint32_t i= join->const_tables; i < join->tables; i++)

6752

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

1145

6753

{

1146

JoinTable *tab=join->join_tab+i;

1147

if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||

1148

tab->type == AM_REF_OR_NULL) &&

6754

JOIN_TAB *tab=join->join_tab+i;

6755

if ((tab->type == JT_REF || tab->type == JT_EQ_REF ||

6756

tab->type == JT_REF_OR_NULL) &&

1149

6757

!tab->table->maybe_null)

1150

6758

{

1151

6759

for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)

1156

6764

Item *notnull;

1157

6765

assert(item->type() == Item::FIELD_ITEM);

1158

6766

Item_field *not_null_item= (Item_field*)item;

1159

JoinTable *referred_tab= not_null_item->field->getTable()->reginfo.join_tab;

6767

JOIN_TAB *referred_tab= not_null_item->field->table->reginfo.join_tab;

1160

6768

1161

6769

For UPDATE queries such as:

1162

6770

UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);

1168

6776

return;

1169

6777

1170

6778

We need to do full fix_fields() call here in order to have correct

1171

notnull->const_item(). This is needed e.g. by test_quick_select

1172

when it is called from make_join_select after this function is

6779

notnull->const_item(). This is needed e.g. by test_quick_select

6780

when it is called from make_join_select after this function is

1173

6781

called.

1174

6782

1175

if (notnull->fix_fields(join->session, &notnull))

6783

if (notnull->fix_fields(join->thd, &notnull))

1176

6784

return;

1177

6785

add_cond_and_fix(&referred_tab->select_cond, notnull);

1178

6786

}

1197

6805

- pointer to the guarded predicate, if success

1198

6806

- 0, otherwise

1199

6807

1200

COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab)

6808

6809

static COND*

6810

add_found_match_trig_cond(JOIN_TAB *tab, COND *cond, JOIN_TAB *root_tab)

1201

6811

{

1202

6812

COND *tmp;

1203

6813

assert(cond != 0);

1213

6823

return tmp;

1214

6824

}

1215

6825

6826

6827

/**

6828

Fill in outer join related info for the execution plan structure.

6829

6830

For each outer join operation left after simplification of the

6831

original query the function set up the following pointers in the linear

6832

structure join->join_tab representing the selected execution plan.

6833

The first inner table t0 for the operation is set to refer to the last

6834

inner table tk through the field t0->last_inner.

6835

Any inner table ti for the operation are set to refer to the first

6836

inner table ti->first_inner.

6837

The first inner table t0 for the operation is set to refer to the

6838

first inner table of the embedding outer join operation, if there is any,

6839

through the field t0->first_upper.

6840

The on expression for the outer join operation is attached to the

6841

corresponding first inner table through the field t0->on_expr_ref.

6842

Here ti are structures of the JOIN_TAB type.

6843

6844

EXAMPLE. For the query:

6845

@code

6846

SELECT * FROM t1

6847

LEFT JOIN

6848

(t2, t3 LEFT JOIN t4 ON t3.a=t4.a)

6849

ON (t1.a=t2.a AND t1.b=t3.b)

6850

WHERE t1.c > 5,

6851

@endcode

6852

6853

given the execution plan with the table order t1,t2,t3,t4

6854

is selected, the following references will be set;

6855

t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]

6856

t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],

6857

on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to

6858

*t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.

6859

6860

@param join reference to the info fully describing the query

6861

6862

@note

6863

The function assumes that the simplification procedure has been

6864

already applied to the join query (see simplify_joins).

6865

This function can be called only after the execution plan

6866

has been chosen.

6867

6868

6869

static void

6870

make_outerjoin_info(JOIN *join)

6871

{

6872

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

6873

{

6874

JOIN_TAB *tab=join->join_tab+i;

6875

Table *table=tab->table;

6876

TableList *tbl= table->pos_in_table_list;

6877

TableList *embedding= tbl->embedding;

6878

6879

if (tbl->outer_join)

6880

{

6881

6882

Table tab is the only one inner table for outer join.

6883

(Like table t4 for the table reference t3 LEFT JOIN t4 ON t3.a=t4.a

6884

is in the query above.)

6885

6886

tab->last_inner= tab->first_inner= tab;

6887

tab->on_expr_ref= &tbl->on_expr;

6888

tab->cond_equal= tbl->cond_equal;

6889

if (embedding)

6890

tab->first_upper= embedding->nested_join->first_nested;

6891

}

6892

for ( ; embedding ; embedding= embedding->embedding)

6893

{

6894

/* Ignore sj-nests: */

6895

if (!embedding->on_expr)

6896

continue;

6897

nested_join_st *nested_join= embedding->nested_join;

6898

if (!nested_join->counter_)

6899

{

6900

6901

Table tab is the first inner table for nested_join.

6902

Save reference to it in the nested join structure.

6903

6904

nested_join->first_nested= tab;

6905

tab->on_expr_ref= &embedding->on_expr;

6906

tab->cond_equal= tbl->cond_equal;

6907

if (embedding->embedding)

6908

tab->first_upper= embedding->embedding->nested_join->first_nested;

6909

}

6910

if (!tab->first_inner)

6911

tab->first_inner= nested_join->first_nested;

6912

if (++nested_join->counter_ < nested_join->join_list.elements)

6913

break;

6914

/* Table tab is the last inner table for nested join. */

6915

nested_join->first_nested->last_inner= tab;

6916

}

6917

}

6918

return;

6919

}

6920

6921

6922

static bool

6923

make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)

6924

{

6925

THD *thd= join->thd;

6926

if (select)

6927

{

6928

add_not_null_conds(join);

6929

table_map used_tables;

6930

if (cond) /* Because of QUICK_GROUP_MIN_MAX_SELECT */

6931

{ /* there may be a select without a cond. */

6932

if (join->tables > 1)

6933

cond->update_used_tables(); // Tablenr may have changed

6934

if (join->const_tables == join->tables &&

6935

thd->lex->current_select->master_unit() ==

6936

&thd->lex->unit) // not upper level SELECT

6937

join->const_table_map|=RAND_TABLE_BIT;

6938

{ // Check const tables

6939

COND *const_cond=

6940

make_cond_for_table(cond,

6941

join->const_table_map,

6942

(table_map) 0, 1);

6943

for (JOIN_TAB *tab= join->join_tab+join->const_tables;

6944

tab < join->join_tab+join->tables ; tab++)

6945

{

6946

if (*tab->on_expr_ref)

6947

{

6948

JOIN_TAB *cond_tab= tab->first_inner;

6949

COND *tmp= make_cond_for_table(*tab->on_expr_ref,

6950

join->const_table_map,

6951

( table_map) 0, 0);

6952

if (!tmp)

6953

continue;

6954

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

6955

if (!tmp)

6956

return(1);

6957

tmp->quick_fix_field();

6958

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

6959

new Item_cond_and(cond_tab->select_cond,

6960

tmp);

6961

if (!cond_tab->select_cond)

6962

return(1);

6963

cond_tab->select_cond->quick_fix_field();

6964

}

6965

}

6966

if (const_cond && !const_cond->val_int())

6967

{

6968

return(1); // Impossible const condition

6969

}

6970

}

6971

}

6972

used_tables=((select->const_tables=join->const_table_map) |

6973

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

6974

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

6975

{

6976

JOIN_TAB *tab=join->join_tab+i;

6977

6978

first_inner is the X in queries like:

6979

SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X

6980

6981

JOIN_TAB *first_inner_tab= tab->first_inner;

6982

table_map current_map= tab->table->map;

6983

bool use_quick_range=0;

6984

COND *tmp;

6985

6986

6987

Following force including random expression in last table condition.

6988

It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5

6989

6990

if (i == join->tables-1)

6991

current_map|= OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;

6992

used_tables|=current_map;

6993

6994

if (tab->type == JT_REF && tab->quick &&

6995

(uint) tab->ref.key == tab->quick->index &&

6996

tab->ref.key_length < tab->quick->max_used_key_length)

6997

{

6998

/* Range uses longer key; Use this instead of ref on key */

6999

tab->type=JT_ALL;

7000

use_quick_range=1;

7001

tab->use_quick=1;

7002

tab->ref.key= -1;

7003

tab->ref.key_parts=0; // Don't use ref key.

7004

join->best_positions[i].records_read= rows2double(tab->quick->records);

7005

7006

We will use join cache here : prevent sorting of the first

7007

table only and sort at the end.

7008

7009

if (i != join->const_tables && join->tables > join->const_tables + 1)

7010

join->full_join= 1;

7011

}

7012

7013

tmp= NULL;

7014

if (cond)

7015

tmp= make_cond_for_table(cond,used_tables,current_map, 0);

7016

if (cond && !tmp && tab->quick)

7017

{ // Outer join

7018

if (tab->type != JT_ALL)

7019

{

7020

7021

Don't use the quick method

7022

We come here in the case where we have 'key=constant' and

7023

the test is removed by make_cond_for_table()

7024

7025

delete tab->quick;

7026

tab->quick= 0;

7027

}

7028

else

7029

{

7030

7031

Hack to handle the case where we only refer to a table

7032

in the ON part of an OUTER JOIN. In this case we want the code

7033

below to check if we should use 'quick' instead.

7034

7035

tmp= new Item_int((int64_t) 1,1); // Always true

7036

}

7037

7038

}

7039

if (tmp || !cond || tab->type == JT_REF || tab->type == JT_REF_OR_NULL ||

7040

tab->type == JT_EQ_REF)

7041

{

7042

SQL_SELECT *sel= tab->select= ((SQL_SELECT*)

7043

thd->memdup((unsigned char*) select,

7044

sizeof(*select)));

7045

if (!sel)

7046

return(1); // End of memory

7047

7048

If tab is an inner table of an outer join operation,

7049

add a match guard to the pushed down predicate.

7050

The guard will turn the predicate on only after

7051

the first match for outer tables is encountered.

7052

7053

if (cond && tmp)

7054

{

7055

7056

Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without

7057

a cond, so neutralize the hack above.

7058

7059

if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))

7060

return(1);

7061

tab->select_cond=sel->cond=tmp;

7062

/* Push condition to storage engine if this is enabled

7063

and the condition is not guarded */

7064

tab->table->file->pushed_cond= NULL;

7065

if (thd->variables.engine_condition_pushdown)

7066

{

7067

COND *push_cond=

7068

make_cond_for_table(tmp, current_map, current_map, 0);

7069

if (push_cond)

7070

{

7071

/* Push condition to handler */

7072

if (!tab->table->file->cond_push(push_cond))

7073

tab->table->file->pushed_cond= push_cond;

7074

}

7075

}

7076

}

7077

else

7078

tab->select_cond= sel->cond= NULL;

7079

7080

sel->head=tab->table;

7081

if (tab->quick)

7082

{

7083

/* Use quick key read if it's a constant and it's not used

7084

with key reading */

7085

if (tab->needed_reg.is_clear_all() && tab->type != JT_EQ_REF

7086

&& (tab->type != JT_REF || (uint) tab->ref.key == tab->quick->index))

7087

{

7088

sel->quick=tab->quick; // Use value from get_quick_...

7089

sel->quick_keys.clear_all();

7090

sel->needed_reg.clear_all();

7091

}

7092

else

7093

{

7094

delete tab->quick;

7095

}

7096

tab->quick=0;

7097

}

7098

uint32_t ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;

7099

if (i == join->const_tables && ref_key)

7100

{

7101

if (!tab->const_keys.is_clear_all() &&

7102

tab->table->reginfo.impossible_range)

7103

return(1);

7104

}

7105

else if (tab->type == JT_ALL && ! use_quick_range)

7106

{

7107

if (!tab->const_keys.is_clear_all() &&

7108

tab->table->reginfo.impossible_range)

7109

return(1); // Impossible range

7110

7111

We plan to scan all rows.

7112

Check again if we should use an index.

7113

We could have used an column from a previous table in

7114

the index if we are using limit and this is the first table

7115

7116

7117

if ((cond && (!tab->keys.is_subset(tab->const_keys) && i > 0)) ||

7118

(!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)))

7119

{

7120

/* Join with outer join condition */

7121

COND *orig_cond=sel->cond;

7122

sel->cond= and_conds(sel->cond, *tab->on_expr_ref);

7123

7124

7125

We can't call sel->cond->fix_fields,

7126

as it will break tab->on_expr if it's AND condition

7127

(fix_fields currently removes extra AND/OR levels).

7128

Yet attributes of the just built condition are not needed.

7129

Thus we call sel->cond->quick_fix_field for safety.

7130

7131

if (sel->cond && !sel->cond->fixed)

7132

sel->cond->quick_fix_field();

7133

7134

if (sel->test_quick_select(thd, tab->keys,

7135

used_tables & ~ current_map,

7136

(join->select_options &

7137

OPTION_FOUND_ROWS ?

7138

HA_POS_ERROR :

7139

join->unit->select_limit_cnt), 0,

7140

false) < 0)

7141

{

7142

7143

Before reporting "Impossible WHERE" for the whole query

7144

we have to check isn't it only "impossible ON" instead

7145

7146

sel->cond=orig_cond;

7147

if (!*tab->on_expr_ref ||

7148

sel->test_quick_select(thd, tab->keys,

7149

used_tables & ~ current_map,

7150

(join->select_options &

7151

OPTION_FOUND_ROWS ?

7152

HA_POS_ERROR :

7153

join->unit->select_limit_cnt),0,

7154

false) < 0)

7155

return(1); // Impossible WHERE

7156

}

7157

else

7158

sel->cond=orig_cond;

7159

7160

/* Fix for EXPLAIN */

7161

if (sel->quick)

7162

join->best_positions[i].records_read= (double)sel->quick->records;

7163

}

7164

else

7165

{

7166

sel->needed_reg=tab->needed_reg;

7167

sel->quick_keys.clear_all();

7168

}

7169

if (!sel->quick_keys.is_subset(tab->checked_keys) ||

7170

!sel->needed_reg.is_subset(tab->checked_keys))

7171

{

7172

tab->keys=sel->quick_keys;

7173

tab->keys.merge(sel->needed_reg);

7174

tab->use_quick= (!sel->needed_reg.is_clear_all() &&

7175

(select->quick_keys.is_clear_all() ||

7176

(select->quick &&

7177

(select->quick->records >= 100L)))) ?

7178

2 : 1;

7179

sel->read_tables= used_tables & ~current_map;

7180

}

7181

if (i != join->const_tables && tab->use_quick != 2)

7182

{ /* Read with cache */

7183

if (cond &&

7184

(tmp=make_cond_for_table(cond,

7185

join->const_table_map |

7186

current_map,

7187

current_map, 0)))

7188

{

7189

tab->cache.select=(SQL_SELECT*)

7190

thd->memdup((unsigned char*) sel, sizeof(SQL_SELECT));

7191

tab->cache.select->cond=tmp;

7192

tab->cache.select->read_tables=join->const_table_map;

7193

}

7194

}

7195

}

7196

}

7197

7198

7199

Push down conditions from all on expressions.

7200

Each of these conditions are guarded by a variable

7201

that turns if off just before null complemented row for

7202

outer joins is formed. Thus, the condition from an

7203

'on expression' are guaranteed not to be checked for

7204

the null complemented row.

7205

7206

7207

/* First push down constant conditions from on expressions */

7208

for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;

7209

join_tab < join->join_tab+join->tables ; join_tab++)

7210

{

7211

if (*join_tab->on_expr_ref)

7212

{

7213

JOIN_TAB *cond_tab= join_tab->first_inner;

7214

COND *tmp= make_cond_for_table(*join_tab->on_expr_ref,

7215

join->const_table_map,

7216

(table_map) 0, 0);

7217

if (!tmp)

7218

continue;

7219

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

7220

if (!tmp)

7221

return(1);

7222

tmp->quick_fix_field();

7223

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

7224

new Item_cond_and(cond_tab->select_cond,tmp);

7225

if (!cond_tab->select_cond)

7226

return(1);

7227

cond_tab->select_cond->quick_fix_field();

7228

}

7229

}

7230

7231

/* Push down non-constant conditions from on expressions */

7232

JOIN_TAB *last_tab= tab;

7233

while (first_inner_tab && first_inner_tab->last_inner == last_tab)

7234

{

7235

7236

Table tab is the last inner table of an outer join.

7237

An on expression is always attached to it.

7238

7239

COND *on_expr= *first_inner_tab->on_expr_ref;

7240

7241

table_map used_tables2= (join->const_table_map |

7242

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

7243

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

7244

{

7245

current_map= tab->table->map;

7246

used_tables2|= current_map;

7247

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

7248

current_map, 0);

7249

if (tmp_cond)

7250

{

7251

JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

7252

7253

First add the guards for match variables of

7254

all embedding outer join operations.

7255

7256

if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,

7257

tmp_cond,

7258

first_inner_tab)))

7259

return(1);

7260

7261

Now add the guard turning the predicate off for

7262

the null complemented row.

7263

7264

tmp_cond= new Item_func_trig_cond(tmp_cond,

7265

&first_inner_tab->

7266

not_null_compl);

7267

if (tmp_cond)

7268

tmp_cond->quick_fix_field();

7269

/* Add the predicate to other pushed down predicates */

7270

cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :

7271

new Item_cond_and(cond_tab->select_cond,

7272

tmp_cond);

7273

if (!cond_tab->select_cond)

7274

return(1);

7275

cond_tab->select_cond->quick_fix_field();

7276

}

7277

}

7278

first_inner_tab= first_inner_tab->first_upper;

7279

}

7280

}

7281

}

7282

return(0);

7283

}

7284

7285

7286

7287

Check if given expression uses only table fields covered by the given index

7288

7289

SYNOPSIS

7290

uses_index_fields_only()

7291

item Expression to check

7292

tbl The table having the index

7293

keyno The index number

7294

other_tbls_ok true <=> Fields of other non-const tables are allowed

7295

7296

DESCRIPTION

7297

Check if given expression only uses fields covered by index #keyno in the

7298

table tbl. The expression can use any fields in any other tables.

7299

7300

The expression is guaranteed not to be AND or OR - those constructs are

7301

handled outside of this function.

7302

7303

RETURN

7304

true Yes

7305

false No

7306

7307

7308

bool uses_index_fields_only(Item *item, Table *tbl, uint32_t keyno,

7309

bool other_tbls_ok)

7310

{

7311

if (item->const_item())

7312

return true;

7313

7314

7315

Don't push down the triggered conditions. Nested outer joins execution

7316

code may need to evaluate a condition several times (both triggered and

7317

untriggered), and there is no way to put thi

7318

TODO: Consider cloning the triggered condition and using the copies for:

7319

1. push the first copy down, to have most restrictive index condition

7320

possible

7321

2. Put the second copy into tab->select_cond.

7322

7323

if (item->type() == Item::FUNC_ITEM &&

7324

((Item_func*)item)->functype() == Item_func::TRIG_COND_FUNC)

7325

return false;

7326

7327

if (!(item->used_tables() & tbl->map))

7328

return other_tbls_ok;

7329

7330

Item::Type item_type= item->type();

7331

switch (item_type) {

7332

case Item::FUNC_ITEM:

7333

{

7334

/* This is a function, apply condition recursively to arguments */

7335

Item_func *item_func= (Item_func*)item;

7336

Item **child;

7337

Item **item_end= (item_func->arguments()) + item_func->argument_count();

7338

for (child= item_func->arguments(); child != item_end; child++)

7339

{

7340

if (!uses_index_fields_only(*child, tbl, keyno, other_tbls_ok))

7341

return false;

7342

}

7343

return true;

7344

}

7345

case Item::COND_ITEM:

7346

{

7347

/* This is a function, apply condition recursively to arguments */

7348

List_iterator<Item> li(*((Item_cond*)item)->argument_list());

7349

Item *item;

7350

while ((item=li++))

7351

{

7352

if (!uses_index_fields_only(item, tbl, keyno, other_tbls_ok))

7353

return false;

7354

}

7355

return true;

7356

}

7357

case Item::FIELD_ITEM:

7358

{

7359

Item_field *item_field= (Item_field*)item;

7360

if (item_field->field->table != tbl)

7361

return true;

7362

return item_field->field->part_of_key.is_set(keyno);

7363

}

7364

case Item::REF_ITEM:

7365

return uses_index_fields_only(item->real_item(), tbl, keyno,

7366

other_tbls_ok);

7367

default:

7368

return false; /* Play it safe, don't push unknown non-const items */

7369

}

7370

}

7371

7372

1216

7373

#define ICP_COND_USES_INDEX_ONLY 10

1217

7374

1218

1219

/**

1220

cleanup JoinTable.

1221

1222

void JoinTable::cleanup()

1223

{

1224

safe_delete(select);

1225

safe_delete(quick);

1226

7375

7376

Get a part of the condition that can be checked using only index fields

7377

7378

SYNOPSIS

7379

make_cond_for_index()

7380

cond The source condition

7381

table The table that is partially available

7382

keyno The index in the above table. Only fields covered by the index

7383

are available

7384

other_tbls_ok true <=> Fields of other non-const tables are allowed

7385

7386

DESCRIPTION

7387

Get a part of the condition that can be checked when for the given table

7388

we have values only of fields covered by some index. The condition may

7389

refer to other tables, it is assumed that we have values of all of their

7390

fields.

7391

7392

Example:

7393

make_cond_for_index(

7394

"cond(t1.field) AND cond(t2.key1) AND cond(t2.non_key) AND cond(t2.key2)",

7395

t2, keyno(t2.key1))

7396

will return

7397

"cond(t1.field) AND cond(t2.key2)"

7398

7399

RETURN

7400

Index condition, or NULL if no condition could be inferred.

7401

7402

7403

Item *make_cond_for_index(Item *cond, Table *table, uint32_t keyno,

7404

bool other_tbls_ok)

7405

{

7406

if (!cond)

7407

return NULL;

7408

if (cond->type() == Item::COND_ITEM)

7409

{

7410

uint32_t n_marked= 0;

7411

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

7412

{

7413

Item_cond_and *new_cond=new Item_cond_and;

7414

if (!new_cond)

7415

return (COND*) 0;

7416

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7417

Item *item;

7418

while ((item=li++))

7419

{

7420

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7421

if (fix)

7422

new_cond->argument_list()->push_back(fix);

7423

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7424

}

7425

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7426

cond->marker= ICP_COND_USES_INDEX_ONLY;

7427

switch (new_cond->argument_list()->elements) {

7428

case 0:

7429

return (COND*) 0;

7430

case 1:

7431

return new_cond->argument_list()->head();

7432

default:

7433

new_cond->quick_fix_field();

7434

return new_cond;

7435

}

7436

}

7437

else /* It's OR */

7438

{

7439

Item_cond_or *new_cond=new Item_cond_or;

7440

if (!new_cond)

7441

return (COND*) 0;

7442

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7443

Item *item;

7444

while ((item=li++))

7445

{

7446

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7447

if (!fix)

7448

return (COND*) 0;

7449

new_cond->argument_list()->push_back(fix);

7450

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7451

}

7452

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7453

cond->marker= ICP_COND_USES_INDEX_ONLY;

7454

new_cond->quick_fix_field();

7455

new_cond->top_level_item();

7456

return new_cond;

7457

}

7458

}

7459

7460

if (!uses_index_fields_only(cond, table, keyno, other_tbls_ok))

7461

return (COND*) 0;

7462

cond->marker= ICP_COND_USES_INDEX_ONLY;

7463

return cond;

7464

}

7465

7466

7467

Item *make_cond_remainder(Item *cond, bool exclude_index)

7468

{

7469

if (exclude_index && cond->marker == ICP_COND_USES_INDEX_ONLY)

7470

return 0; /* Already checked */

7471

7472

if (cond->type() == Item::COND_ITEM)

7473

{

7474

table_map tbl_map= 0;

7475

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

7476

{

7477

/* Create new top level AND item */

7478

Item_cond_and *new_cond=new Item_cond_and;

7479

if (!new_cond)

7480

return (COND*) 0;

7481

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7482

Item *item;

7483

while ((item=li++))

7484

{

7485

Item *fix= make_cond_remainder(item, exclude_index);

7486

if (fix)

7487

{

7488

new_cond->argument_list()->push_back(fix);

7489

tbl_map |= fix->used_tables();

7490

}

7491

}

7492

switch (new_cond->argument_list()->elements) {

7493

case 0:

7494

return (COND*) 0;

7495

case 1:

7496

return new_cond->argument_list()->head();

7497

default:

7498

new_cond->quick_fix_field();

7499

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7500

return new_cond;

7501

}

7502

}

7503

else /* It's OR */

7504

{

7505

Item_cond_or *new_cond=new Item_cond_or;

7506

if (!new_cond)

7507

return (COND*) 0;

7508

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7509

Item *item;

7510

while ((item=li++))

7511

{

7512

Item *fix= make_cond_remainder(item, false);

7513

if (!fix)

7514

return (COND*) 0;

7515

new_cond->argument_list()->push_back(fix);

7516

tbl_map |= fix->used_tables();

7517

}

7518

new_cond->quick_fix_field();

7519

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7520

new_cond->top_level_item();

7521

return new_cond;

7522

}

7523

}

7524

return cond;

7525

}

7526

7527

7528

7529

Try to extract and push the index condition

7530

7531

SYNOPSIS

7532

push_index_cond()

7533

tab A join tab that has tab->table->file and its condition

7534

in tab->select_cond

7535

keyno Index for which extract and push the condition

7536

other_tbls_ok true <=> Fields of other non-const tables are allowed

7537

7538

DESCRIPTION

7539

Try to extract and push the index condition down to table handler

7540

7541

7542

static void push_index_cond(JOIN_TAB *tab, uint32_t keyno, bool other_tbls_ok)

7543

{

7544

Item *idx_cond;

7545

if (tab->table->file->index_flags(keyno, 0, 1) & HA_DO_INDEX_COND_PUSHDOWN &&

7546

tab->join->thd->variables.engine_condition_pushdown)

7547

{

7548

idx_cond= make_cond_for_index(tab->select_cond, tab->table, keyno,

7549

other_tbls_ok);

7550

7551

if (idx_cond)

7552

{

7553

tab->pre_idx_push_select_cond= tab->select_cond;

7554

Item *idx_remainder_cond=

7555

tab->table->file->idx_cond_push(keyno, idx_cond);

7556

7557

7558

Disable eq_ref's "lookup cache" if we've pushed down an index

7559

condition.

7560

TODO: This check happens to work on current ICP implementations, but

7561

there may exist a compliant implementation that will not work

7562

correctly with it. Sort this out when we stabilize the condition

7563

pushdown APIs.

7564

7565

if (idx_remainder_cond != idx_cond)

7566

tab->ref.disable_cache= true;

7567

7568

Item *row_cond= make_cond_remainder(tab->select_cond, true);

7569

7570

if (row_cond)

7571

{

7572

if (!idx_remainder_cond)

7573

tab->select_cond= row_cond;

7574

else

7575

{

7576

tab->select_cond= new Item_cond_and(row_cond, idx_remainder_cond);

7577

tab->select_cond->quick_fix_field();

7578

((Item_cond_and*)tab->select_cond)->used_tables_cache=

7579

row_cond->used_tables() | idx_remainder_cond->used_tables();

7580

}

7581

}

7582

else

7583

tab->select_cond= idx_remainder_cond;

7584

if (tab->select)

7585

{

7586

tab->select->cond= tab->select_cond;

7587

}

7588

}

7589

}

7590

return;

7591

}

7592

7593

7594

7595

7596

Determine if the set is already ordered for order_st BY, so it can

7597

disable join cache because it will change the ordering of the results.

7598

Code handles sort table that is at any location (not only first after

7599

the const tables) despite the fact that it's currently prohibited.

7600

We must disable join cache if the first non-const table alone is

7601

ordered. If there is a temp table the ordering is done as a last

7602

operation and doesn't prevent join cache usage.

7603

7604

uint32_t make_join_orderinfo(JOIN *join)

7605

{

7606

uint32_t i;

7607

if (join->need_tmp)

7608

return join->tables;

7609

7610

for (i=join->const_tables ; i < join->tables ; i++)

7611

{

7612

JOIN_TAB *tab=join->join_tab+i;

7613

Table *table=tab->table;

7614

if ((table == join->sort_by_table &&

7615

(!join->order || join->skip_sort_order)) ||

7616

(join->sort_by_table == (Table *) 1 && i != join->const_tables))

7617

{

7618

break;

7619

}

7620

}

7621

return i;

7622

}

7623

7624

7625

7626

Plan refinement stage: do various set ups for the executioner

7627

7628

SYNOPSIS

7629

make_join_readinfo()

7630

join Join being processed

7631

options Join's options (checking for SELECT_DESCRIBE,

7632

SELECT_NO_JOIN_CACHE)

7633

no_jbuf_after Don't use join buffering after table with this number.

7634

7635

DESCRIPTION

7636

Plan refinement stage: do various set ups for the executioner

7637

- set up use of join buffering

7638

- push index conditions

7639

- increment counters

7640

- etc

7641

7642

RETURN

7643

false - OK

7644

true - Out of memory

7645

7646

7647

static bool

7648

make_join_readinfo(JOIN *join, uint64_t options, uint32_t no_jbuf_after)

7649

{

7650

uint32_t i;

7651

bool statistics= test(!(join->select_options & SELECT_DESCRIBE));

7652

bool sorted= 1;

7653

7654

for (i=join->const_tables ; i < join->tables ; i++)

7655

{

7656

JOIN_TAB *tab=join->join_tab+i;

7657

Table *table=tab->table;

7658

bool using_join_cache;

7659

tab->read_record.table= table;

7660

tab->read_record.file=table->file;

7661

tab->next_select=sub_select; /* normal select */

7662

7663

TODO: don't always instruct first table's ref/range access method to

7664

produce sorted output.

7665

7666

tab->sorted= sorted;

7667

sorted= 0; // only first must be sorted

7668

if (tab->insideout_match_tab)

7669

{

7670

if (!(tab->insideout_buf= (unsigned char*)join->thd->alloc(tab->table->key_info

7671

[tab->index].

7672

key_length)))

7673

return true;

7674

}

7675

switch (tab->type) {

7676

case JT_SYSTEM: // Only happens with left join

7677

table->status=STATUS_NO_RECORD;

7678

tab->read_first_record= join_read_system;

7679

tab->read_record.read_record= join_no_more_records;

7680

break;

7681

case JT_CONST: // Only happens with left join

7682

table->status=STATUS_NO_RECORD;

7683

tab->read_first_record= join_read_const;

7684

tab->read_record.read_record= join_no_more_records;

7685

if (table->covering_keys.is_set(tab->ref.key) &&

7686

!table->no_keyread)

7687

{

7688

table->key_read=1;

7689

table->file->extra(HA_EXTRA_KEYREAD);

7690

}

7691

break;

7692

case JT_EQ_REF:

7693

table->status=STATUS_NO_RECORD;

7694

if (tab->select)

7695

{

7696

delete tab->select->quick;

7697

tab->select->quick=0;

7698

}

7699

delete tab->quick;

7700

tab->quick=0;

7701

tab->read_first_record= join_read_key;

7702

tab->read_record.read_record= join_no_more_records;

7703

if (table->covering_keys.is_set(tab->ref.key) &&

7704

!table->no_keyread)

7705

{

7706

table->key_read=1;

7707

table->file->extra(HA_EXTRA_KEYREAD);

7708

}

7709

else

7710

push_index_cond(tab, tab->ref.key, true);

7711

break;

7712

case JT_REF_OR_NULL:

7713

case JT_REF:

7714

table->status=STATUS_NO_RECORD;

7715

if (tab->select)

7716

{

7717

delete tab->select->quick;

7718

tab->select->quick=0;

7719

}

7720

delete tab->quick;

7721

tab->quick=0;

7722

if (table->covering_keys.is_set(tab->ref.key) &&

7723

!table->no_keyread)

7724

{

7725

table->key_read=1;

7726

table->file->extra(HA_EXTRA_KEYREAD);

7727

}

7728

else

7729

push_index_cond(tab, tab->ref.key, true);

7730

if (tab->type == JT_REF)

7731

{

7732

tab->read_first_record= join_read_always_key;

7733

tab->read_record.read_record= tab->insideout_match_tab?

7734

join_read_next_same_diff : join_read_next_same;

7735

}

7736

else

7737

{

7738

tab->read_first_record= join_read_always_key_or_null;

7739

tab->read_record.read_record= join_read_next_same_or_null;

7740

}

7741

break;

7742

case JT_ALL:

7743

7744

If previous table use cache

7745

If the incoming data set is already sorted don't use cache.

7746

7747

table->status=STATUS_NO_RECORD;

7748

using_join_cache= false;

7749

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

7750

tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&

7751

!tab->insideout_match_tab)

7752

{

7753

if ((options & SELECT_DESCRIBE) ||

7754

!join_init_cache(join->thd,join->join_tab+join->const_tables,

7755

i-join->const_tables))

7756

{

7757

using_join_cache= true;

7758

tab[-1].next_select=sub_select_cache; /* Patch previous */

7759

}

7760

}

7761

/* These init changes read_record */

7762

if (tab->use_quick == 2)

7763

{

7764

join->thd->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

7765

tab->read_first_record= join_init_quick_read_record;

7766

if (statistics)

7767

status_var_increment(join->thd->status_var.select_range_check_count);

7768

}

7769

else

7770

{

7771

tab->read_first_record= join_init_read_record;

7772

if (i == join->const_tables)

7773

{

7774

if (tab->select && tab->select->quick)

7775

{

7776

if (statistics)

7777

status_var_increment(join->thd->status_var.select_range_count);

7778

}

7779

else

7780

{

7781

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7782

if (statistics)

7783

status_var_increment(join->thd->status_var.select_scan_count);

7784

}

7785

}

7786

else

7787

{

7788

if (tab->select && tab->select->quick)

7789

{

7790

if (statistics)

7791

status_var_increment(join->thd->status_var.select_full_range_join_count);

7792

}

7793

else

7794

{

7795

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7796

if (statistics)

7797

status_var_increment(join->thd->status_var.select_full_join_count);

7798

}

7799

}

7800

if (!table->no_keyread)

7801

{

7802

if (tab->select && tab->select->quick &&

7803

tab->select->quick->index != MAX_KEY && //not index_merge

7804

table->covering_keys.is_set(tab->select->quick->index))

7805

{

7806

table->key_read=1;

7807

table->file->extra(HA_EXTRA_KEYREAD);

7808

}

7809

else if (!table->covering_keys.is_clear_all() &&

7810

!(tab->select && tab->select->quick))

7811

{ // Only read index tree

7812

if (!tab->insideout_match_tab)

7813

{

7814

7815

See bug #26447: "Using the clustered index for a table scan

7816

is always faster than using a secondary index".

7817

7818

if (table->s->primary_key != MAX_KEY &&

7819

table->file->primary_key_is_clustered())

7820

tab->index= table->s->primary_key;

7821

else

7822

tab->index= table->find_shortest_key(&table->covering_keys);

7823

}

7824

tab->read_first_record= join_read_first;

7825

tab->type=JT_NEXT; // Read with index_first / index_next

7826

}

7827

}

7828

if (tab->select && tab->select->quick &&

7829

tab->select->quick->index != MAX_KEY && ! tab->table->key_read)

7830

push_index_cond(tab, tab->select->quick->index, !using_join_cache);

7831

}

7832

break;

7833

default:

7834

break; /* purecov: deadcode */

7835

case JT_UNKNOWN:

7836

case JT_MAYBE_REF:

7837

abort(); /* purecov: deadcode */

7838

}

7839

}

7840

join->join_tab[join->tables-1].next_select=0; /* Set by do_select */

7841

return(false);

7842

}

7843

7844

7845

/**

7846

Give error if we some tables are done with a full join.

7847

7848

This is used by multi_table_update and multi_table_delete when running

7849

in safe mode.

7850

7851

@param join Join condition

7852

7853

@retval

7854

0 ok

7855

@retval

7856

1 Error (full join used)

7857

7858

7859

bool error_if_full_join(JOIN *join)

7860

{

7861

for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;

7862

tab < end;

7863

tab++)

7864

{

7865

if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))

7866

{

7867

my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,

7868

ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));

7869

return(1);

7870

}

7871

}

7872

return(0);

7873

}

7874

7875

7876

/**

7877

cleanup JOIN_TAB.

7878

7879

7880

void JOIN_TAB::cleanup()

7881

{

7882

delete select;

7883

select= 0;

7884

delete quick;

7885

quick= 0;

1227

7886

if (cache.buff)

1228

{

1229

size_t size= cache.end - cache.buff;

1230

global_join_buffer.sub(size);

1231

7887

free(cache.buff);

1232

}

1233

7888

cache.buff= 0;

1234

7889

limit= 0;

1235

7890

if (table)

1237

7892

if (table->key_read)

1238

7893

{

1239

7894

table->key_read= 0;

1240

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

7895

table->file->extra(HA_EXTRA_NO_KEYREAD);

1241

7896

}

1242

table->cursor->ha_index_or_rnd_end();

7897

table->file->ha_index_or_rnd_end();

1243

7898

1244

7899

We need to reset this for next select

1245

7900

(Tested in part_of_refkey)

1246

7901

1247

7902

table->reginfo.join_tab= 0;

1248

7903

}

1249

read_record.end_read_record();

1250

}

1251

1252

bool only_eq_ref_tables(Join *join,Order *order,table_map tables)

1253

{

1254

for (JoinTable **tab=join->map2table ; tables ; tab++, tables>>=1)

1255

{

1256

if (tables & 1 && !eq_ref_table(join, order, *tab))

1257

return 0;

1258

}

1259

return 1;

1260

}

1261

1262

/**

1263

Remove the following expressions from ORDER BY and GROUP BY:

7904

end_read_record(&read_record);

7905

}

7906

7907

7908

/**

7909

Partially cleanup JOIN after it has executed: close index or rnd read

7910

(table cursors), free quick selects.

7911

7912

This function is called in the end of execution of a JOIN, before the used

7913

tables are unlocked and closed.

7914

7915

For a join that is resolved using a temporary table, the first sweep is

7916

performed against actual tables and an intermediate result is inserted

7917

into the temprorary table.

7918

The last sweep is performed against the temporary table. Therefore,

7919

the base tables and associated buffers used to fill the temporary table

7920

are no longer needed, and this function is called to free them.

7921

7922

For a join that is performed without a temporary table, this function

7923

is called after all rows are sent, but before EOF packet is sent.

7924

7925

For a simple SELECT with no subqueries this function performs a full

7926

cleanup of the JOIN and calls mysql_unlock_read_tables to free used base

7927

tables.

7928

7929

If a JOIN is executed for a subquery or if it has a subquery, we can't

7930

do the full cleanup and need to do a partial cleanup only.

7931

- If a JOIN is not the top level join, we must not unlock the tables

7932

because the outer select may not have been evaluated yet, and we

7933

can't unlock only selected tables of a query.

7934

- Additionally, if this JOIN corresponds to a correlated subquery, we

7935

should not free quick selects and join buffers because they will be

7936

needed for the next execution of the correlated subquery.

7937

- However, if this is a JOIN for a [sub]select, which is not

7938

a correlated subquery itself, but has subqueries, we can free it

7939

fully and also free JOINs of all its subqueries. The exception

7940

is a subquery in SELECT list, e.g: @n

7941

SELECT a, (select cmax(b) from t1) group by c @n

7942

This subquery will not be evaluated at first sweep and its value will

7943

not be inserted into the temporary table. Instead, it's evaluated

7944

when selecting from the temporary table. Therefore, it can't be freed

7945

here even though it's not correlated.

7946

7947

@todo

7948

Unlock tables even if the join isn't top level select in the tree

7949

7950

7951

void JOIN::join_free()

7952

{

7953

SELECT_LEX_UNIT *tmp_unit;

7954

SELECT_LEX *sl;

7955

7956

Optimization: if not EXPLAIN and we are done with the JOIN,

7957

free all tables.

7958

7959

bool full= (!select_lex->uncacheable && !thd->lex->describe);

7960

bool can_unlock= full;

7961

7962

cleanup(full);

7963

7964

for (tmp_unit= select_lex->first_inner_unit();

7965

tmp_unit;

7966

tmp_unit= tmp_unit->next_unit())

7967

for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())

7968

{

7969

Item_subselect *subselect= sl->master_unit()->item;

7970

bool full_local= full && (!subselect || subselect->is_evaluated());

7971

7972

If this join is evaluated, we can fully clean it up and clean up all

7973

its underlying joins even if they are correlated -- they will not be

7974

used any more anyway.

7975

If this join is not yet evaluated, we still must clean it up to

7976

close its table cursors -- it may never get evaluated, as in case of

7977

... HAVING false OR a IN (SELECT ...))

7978

but all table cursors must be closed before the unlock.

7979

7980

sl->cleanup_all_joins(full_local);

7981

/* Can't unlock if at least one JOIN is still needed */

7982

can_unlock= can_unlock && full_local;

7983

}

7984

7985

7986

We are not using tables anymore

7987

Unlock all tables. We may be in an INSERT .... SELECT statement.

7988

7989

if (can_unlock && lock && thd->lock &&

7990

!(select_options & SELECT_NO_UNLOCK) &&

7991

!select_lex->subquery_in_having &&

7992

(select_lex == (thd->lex->unit.fake_select_lex ?

7993

thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))

7994

{

7995

7996

TODO: unlock tables even if the join isn't top level select in the

7997

tree.

7998

7999

mysql_unlock_read_tables(thd, lock); // Don't free join->lock

8000

lock= 0;

8001

}

8002

8003

return;

8004

}

8005

8006

8007

/**

8008

Free resources of given join.

8009

8010

@param fill true if we should free all resources, call with full==1

8011

should be last, before it this function can be called with

8012

full==0

8013

8014

@note

8015

With subquery this function definitely will be called several times,

8016

but even for simple query it can be called several times.

8017

8018

8019

void JOIN::cleanup(bool full)

8020

{

8021

if (table)

8022

{

8023

JOIN_TAB *tab,*end;

8024

8025

Only a sorted table may be cached. This sorted table is always the

8026

first non const table in join->table

8027

8028

if (tables > const_tables) // Test for not-const tables

8029

{

8030

free_io_cache(table[const_tables]);

8031

filesort_free_buffers(table[const_tables],full);

8032

}

8033

8034

if (full)

8035

{

8036

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8037

tab->cleanup();

8038

table= 0;

8039

}

8040

else

8041

{

8042

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8043

{

8044

if (tab->table)

8045

tab->table->file->ha_index_or_rnd_end();

8046

}

8047

}

8048

cleanup_sj_tmp_tables(this);//

8049

}

8050

8051

We are not using tables anymore

8052

Unlock all tables. We may be in an INSERT .... SELECT statement.

8053

8054

if (full)

8055

{

8056

if (tmp_join)

8057

tmp_table_param.copy_field= 0;

8058

group_fields.delete_elements();

8059

8060

We can't call delete_elements() on copy_funcs as this will cause

8061

problems in free_elements() as some of the elements are then deleted.

8062

8063

tmp_table_param.copy_funcs.empty();

8064

8065

If we have tmp_join and 'this' JOIN is not tmp_join and

8066

tmp_table_param.copy_field's of them are equal then we have to remove

8067

pointer to tmp_table_param.copy_field from tmp_join, because it qill

8068

be removed in tmp_table_param.cleanup().

8069

8070

if (tmp_join &&

8071

tmp_join != this &&

8072

tmp_join->tmp_table_param.copy_field ==

8073

tmp_table_param.copy_field)

8074

{

8075

tmp_join->tmp_table_param.copy_field=

8076

tmp_join->tmp_table_param.save_copy_field= 0;

8077

}

8078

tmp_table_param.cleanup();

8079

}

8080

return;

8081

}

8082

8083

8084

/**

8085

Remove the following expressions from order_st BY and GROUP BY:

1264

8086

Constant expressions @n

1265

8087

Expression that only uses tables that are of type EQ_REF and the reference

1266

8088

is in the order_st list or if all refereed tables are of the above type.

1267

8089

1268

8090

In the following, the X field can be removed:

1269

8091

@code

1270

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t1.a,t2.X

1271

SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b ORDER BY t1.a,t3.X

8092

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t1.a,t2.X

8093

SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b order_st BY t1.a,t3.X

1272

8094

@endcode

1273

8095

1274

8096

These can't be optimized:

1275

8097

@code

1276

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.X,t1.a

1277

SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b ORDER BY t1.a,t2.c

1278

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.b,t1.a

8098

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.X,t1.a

8099

SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b order_st BY t1.a,t2.c

8100

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.b,t1.a

1279

8101

@endcode

1280

8102

1281

bool eq_ref_table(Join *join, Order *start_order, JoinTable *tab)

8103

8104

static bool

8105

eq_ref_table(JOIN *join, order_st *start_order, JOIN_TAB *tab)

1282

8106

{

1283

8107

if (tab->cached_eq_ref_table) // If cached

1284

8108

return tab->eq_ref_table;

1285

8109

tab->cached_eq_ref_table=1;

1286

8110

/* We can skip const tables only if not an outer table */

1287

if (tab->type == AM_CONST && !tab->first_inner)

1288

return (tab->eq_ref_table=1);

1289

if (tab->type != AM_EQ_REF || tab->table->maybe_null)

8111

if (tab->type == JT_CONST && !tab->first_inner)

8112

return (tab->eq_ref_table=1); /* purecov: inspected */

8113

if (tab->type != JT_EQ_REF || tab->table->maybe_null)

1290

8114

return (tab->eq_ref_table=0); // We must use this

1291

8115

Item **ref_item=tab->ref.items;

1292

8116

Item **end=ref_item+tab->ref.key_parts;

1297

8121

{

1298

8122

if (! (*ref_item)->const_item())

1299

8123

{ // Not a const ref

1300

Order *order;

8124

order_st *order;

1301

8125

for (order=start_order ; order ; order=order->next)

1302

8126

{

1303

if ((*ref_item)->eq(order->item[0],0))

1304

break;

8127

if ((*ref_item)->eq(order->item[0],0))

8128

break;

1305

8129

}

1306

8130

if (order)

1307

8131

{

1308

found++;

1309

assert(!(order->used & map));

1310

order->used|=map;

1311

continue; // Used in order_st BY

8132

found++;

8133

assert(!(order->used & map));

8134

order->used|=map;

8135

continue; // Used in order_st BY

1312

8136

}

1313

8137

if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))

1314

return (tab->eq_ref_table= 0);

8138

return (tab->eq_ref_table=0);

1315

8139

}

1316

8140

}

1317

8141

/* Check that there was no reference to table before sort order */

1323

8147

continue;

1324

8148

}

1325

8149

if (start_order->depend_map & map)

1326

return (tab->eq_ref_table= 0);

1327

}

1328

return tab->eq_ref_table= 1;

1329

}

8150

return (tab->eq_ref_table=0);

8151

}

8152

return tab->eq_ref_table=1;

8153

}

8154

8155

8156

static bool

8157

only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)

8158

{

8159

for (JOIN_TAB **tab=join->map2table ; tables ; tab++, tables>>=1)

8160

{

8161

if (tables & 1 && !eq_ref_table(join, order, *tab))

8162

return 0;

8163

}

8164

return 1;

8165

}

8166

8167

8168

/** Update the dependency map for the tables. */

8169

8170

static void update_depend_map(JOIN *join)

8171

{

8172

JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;

8173

8174

for (; join_tab != end ; join_tab++)

8175

{

8176

TABLE_REF *ref= &join_tab->ref;

8177

table_map depend_map=0;

8178

Item **item=ref->items;

8179

uint32_t i;

8180

for (i=0 ; i < ref->key_parts ; i++,item++)

8181

depend_map|=(*item)->used_tables();

8182

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

8183

depend_map&= ~OUTER_REF_TABLE_BIT;

8184

for (JOIN_TAB **tab=join->map2table;

8185

depend_map ;

8186

tab++,depend_map>>=1 )

8187

{

8188

if (depend_map & 1)

8189

ref->depend_map|=(*tab)->ref.depend_map;

8190

}

8191

}

8192

}

8193

8194

8195

/** Update the dependency map for the sort order. */

8196

8197

static void update_depend_map(JOIN *join, order_st *order)

8198

{

8199

for (; order ; order=order->next)

8200

{

8201

table_map depend_map;

8202

order->item[0]->update_used_tables();

8203

order->depend_map=depend_map=order->item[0]->used_tables();

8204

// Not item_sum(), RAND() and no reference to table outside of sub select

8205

if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))

8206

&& !order->item[0]->with_sum_func)

8207

{

8208

for (JOIN_TAB **tab=join->map2table;

8209

depend_map ;

8210

tab++, depend_map>>=1)

8211

{

8212

if (depend_map & 1)

8213

order->depend_map|=(*tab)->ref.depend_map;

8214

}

8215

}

8216

}

8217

}

8218

8219

8220

/**

8221

Remove all constants and check if order_st only contains simple

8222

expressions.

8223

8224

simple_order is set to 1 if sort_order only uses fields from head table

8225

and the head table is not a LEFT JOIN table.

8226

8227

@param join Join handler

8228

@param first_order List of SORT or GROUP order

8229

@param cond WHERE statement

8230

@param change_list Set to 1 if we should remove things from list.

8231

If this is not set, then only simple_order is

8232

calculated.

8233

@param simple_order Set to 1 if we are only using simple expressions

8234

8235

@return

8236

Returns new sort order

8237

8238

8239

static order_st *

8240

remove_const(JOIN *join,order_st *first_order, COND *cond,

8241

bool change_list, bool *simple_order)

8242

{

8243

if (join->tables == join->const_tables)

8244

return change_list ? 0 : first_order; // No need to sort

8245

8246

order_st *order,**prev_ptr;

8247

table_map first_table= join->join_tab[join->const_tables].table->map;

8248

table_map not_const_tables= ~join->const_table_map;

8249

table_map ref;

8250

8251

prev_ptr= &first_order;

8252

*simple_order= *join->join_tab[join->const_tables].on_expr_ref ? 0 : 1;

8253

8254

/* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */

8255

8256

update_depend_map(join, first_order);

8257

for (order=first_order; order ; order=order->next)

8258

{

8259

table_map order_tables=order->item[0]->used_tables();

8260

if (order->item[0]->with_sum_func)

8261

*simple_order=0; // Must do a temp table to sort

8262

else if (!(order_tables & not_const_tables))

8263

{

8264

if (order->item[0]->with_subselect)

8265

order->item[0]->val_str(&order->item[0]->str_value);

8266

continue; // skip const item

8267

}

8268

else

8269

{

8270

if (order_tables & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT))

8271

*simple_order=0;

8272

else

8273

{

8274

Item *comp_item=0;

8275

if (cond && const_expression_in_where(cond,order->item[0], &comp_item))

8276

{

8277

continue;

8278

}

8279

if ((ref=order_tables & (not_const_tables ^ first_table)))

8280

{

8281

if (!(order_tables & first_table) &&

8282

only_eq_ref_tables(join,first_order, ref))

8283

{

8284

continue;

8285

}

8286

*simple_order=0; // Must do a temp table to sort

8287

}

8288

}

8289

}

8290

if (change_list)

8291

*prev_ptr= order; // use this entry

8292

prev_ptr= &order->next;

8293

}

8294

if (change_list)

8295

*prev_ptr=0;

8296

if (prev_ptr == &first_order) // Nothing to sort/group

8297

*simple_order=1;

8298

return(first_order);

8299

}

8300

8301

8302

static int

8303

return_zero_rows(JOIN *join, select_result *result,TableList *tables,

8304

List<Item> &fields, bool send_row, uint64_t select_options,

8305

const char *info, Item *having)

8306

{

8307

if (select_options & SELECT_DESCRIBE)

8308

{

8309

select_describe(join, false, false, false, info);

8310

return(0);

8311

}

8312

8313

join->join_free();

8314

8315

if (send_row)

8316

{

8317

for (TableList *table= tables; table; table= table->next_leaf)

8318

mark_as_null_row(table->table); // All fields are NULL

8319

if (having && having->val_int() == 0)

8320

send_row=0;

8321

}

8322

if (!(result->send_fields(fields,

8323

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))

8324

{

8325

if (send_row)

8326

{

8327

List_iterator_fast<Item> it(fields);

8328

Item *item;

8329

while ((item= it++))

8330

item->no_rows_in_result();

8331

result->send_data(fields);

8332

}

8333

result->send_eof(); // Should be safe

8334

}

8335

/* Update results for FOUND_ROWS */

8336

join->thd->limit_found_rows= join->thd->examined_row_count= 0;

8337

return(0);

8338

}

8339

8340

8341

used only in JOIN::clear

8342

8343

static void clear_tables(JOIN *join)

8344

{

8345

8346

must clear only the non-const tables, as const tables

8347

are not re-calculated.

8348

8349

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

8350

mark_as_null_row(join->table[i]); // All fields are NULL

8351

}

8352

8353

/*****************************************************************************

8354

Make som simple condition optimization:

8355

If there is a test 'field = const' change all refs to 'field' to 'const'

8356

Remove all dummy tests 'item = item', 'const op const'.

8357

Remove all 'item is NULL', when item can never be null!

8358

item->marker should be 0 for all items on entry

8359

Return in cond_value false if condition is impossible (1 = 2)

8360

*****************************************************************************/

8361

8362

class COND_CMP :public ilink {

8363

public:

8364

static void *operator new(size_t size)

8365

{

8366

return (void*) sql_alloc((uint) size);

8367

}

8368

static void operator delete(void *ptr __attribute__((unused)),

8369

size_t size __attribute__((unused)))

8370

{ TRASH(ptr, size); }

8371

8372

Item *and_level;

8373

Item_func *cmp_func;

8374

COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}

8375

};

8376

8377

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

8378

template class I_List<COND_CMP>;

8379

template class I_List_iterator<COND_CMP>;

8380

#endif

8381

1330

8382

1331

8383

/**

1332

8384

Find the multiple equality predicate containing a field.

1346

8398

- Item_equal for the found multiple equality predicate if a success;

1347

8399

- NULL otherwise.

1348

8400

1349

static Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field, bool *inherited_fl)

8401

8402

Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field,

8403

bool *inherited_fl)

1350

8404

{

1351

8405

Item_equal *item= 0;

1352

8406

bool in_upper_level= false;

1353

8407

while (cond_equal)

1354

8408

{

1355

List<Item_equal>::iterator li(cond_equal->current_level.begin());

8409

List_iterator_fast<Item_equal> li(cond_equal->current_level);

1356

8410

while ((item= li++))

1357

8411

{

1358

8412

if (item->contains(field))

1367

8421

return item;

1368

8422

}

1369

8423

8424

1370

8425

/**

1371

8426

Check whether an equality can be used to build multiple equalities.

1372

8427

1393

8448

the check_equality will be called for the following equality

1394

8449

predicates a=b, b=c, b=2 and f=e.

1395

8450

- For a=b it will be called with *cond_equal=(0,[]) and will transform

1396

*cond_equal into (0,[Item_equal(a,b)]).

8451

*cond_equal into (0,[Item_equal(a,b)]).

1397

8452

- For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])

1398

8453

and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).

1399

8454

- For b=2 it will be called with *cond_equal=(ptr(CE),[])

1406

8461

the Field::eq_def method) are placed to the same multiple equalities.

1407

8462

Because of this some equality predicates are not eliminated and

1408

8463

can be used in the constant propagation procedure.

1409

We could weeken the equlity test as soon as at least one of the

1410

equal fields is to be equal to a constant. It would require a

8464

We could weeken the equlity test as soon as at least one of the

8465

equal fields is to be equal to a constant. It would require a

1411

8466

more complicated implementation: we would have to store, in

1412

8467

general case, its own constant for each fields from the multiple

1413

8468

equality. But at the same time it would allow us to get rid

1425

8480

containing just field1 and field2 is added to the existing

1426

8481

multiple equalities.

1427

8482

If the function processes the predicate of the form field1=const,

1428

it looks for a multiple equality containing field1. If found, the

8483

it looks for a multiple equality containing field1. If found, the

1429

8484

function checks the constant of the multiple equality. If the value

1430

8485

is unknown, it is setup to const. Otherwise the value is compared with

1431

8486

const and the evaluation of the equality predicate is performed.

1448

8503

@retval

1449

8504

false otherwise

1450

8505

1451

static bool check_simple_equality(Item *left_item,

1452

Item *right_item,

1453

Item *item,

1454

COND_EQUAL *cond_equal)

8506

8507

static bool check_simple_equality(Item *left_item, Item *right_item,

8508

Item *item, COND_EQUAL *cond_equal)

1455

8509

{

8510

if (left_item->type() == Item::REF_ITEM &&

8511

((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)

8512

{

8513

if (((Item_ref*)left_item)->depended_from)

8514

return false;

8515

left_item= left_item->real_item();

8516

}

8517

if (right_item->type() == Item::REF_ITEM &&

8518

((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)

8519

{

8520

if (((Item_ref*)right_item)->depended_from)

8521

return false;

8522

right_item= right_item->real_item();

8523

}

1456

8524

if (left_item->type() == Item::FIELD_ITEM &&

1457

8525

right_item->type() == Item::FIELD_ITEM &&

1458

8526

!((Item_field*)left_item)->depended_from &&

1470

8538

bool left_copyfl, right_copyfl;

1471

8539

Item_equal *left_item_equal=

1472

8540

find_item_equal(cond_equal, left_field, &left_copyfl);

1473

Item_equal *right_item_equal=

8541

Item_equal *right_item_equal=

1474

8542

find_item_equal(cond_equal, right_field, &right_copyfl);

1475

8543

1476

8544

/* As (NULL=NULL) != true we can't just remove the predicate f=f */

1477

8545

if (left_field->eq(right_field)) /* f = f */

1478

return (!(left_field->maybe_null() && !left_item_equal));

8546

return (!(left_field->maybe_null() && !left_item_equal));

1479

8547

1480

8548

if (left_item_equal && left_item_equal == right_item_equal)

1481

8549

{

1482

8550

1483

8551

The equality predicate is inference of one of the existing

1484

8552

multiple equalities, i.e the condition is already covered

1485

8553

by upper level equalities

1486

8554

1487

8555

return true;

1488

8556

}

1489

1490

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

8557

8558

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

1491

8559

item->name < subq_sj_cond_name + 64);

1492

8560

/* Copy the found multiple equalities at the current level if needed */

1493

8561

if (left_copyfl)

1508

8576

}

1509

8577

1510

8578

if (left_item_equal)

1511

{

8579

{

1512

8580

/* left item was found in the current or one of the upper levels */

1513

8581

if (! right_item_equal)

1514

8582

left_item_equal->add((Item_field *) right_item);

1517

8585

/* Merge two multiple equalities forming a new one */

1518

8586

left_item_equal->merge(right_item_equal);

1519

8587

/* Remove the merged multiple equality from the list */

1520

List<Item_equal>::iterator li(cond_equal->current_level.begin());

8588

List_iterator<Item_equal> li(cond_equal->current_level);

1521

8589

while ((li++) != right_item_equal) {};

1522

8590

li.remove();

1523

8591

}

1524

8592

}

1525

8593

else

1526

{

8594

{

1527

8595

/* left item was not found neither the current nor in upper levels */

1528

8596

if (right_item_equal)

1529

8597

{

1531

8599

if (copy_item_name)

1532

8600

right_item_equal->name = item->name;

1533

8601

}

1534

else

8602

else

1535

8603

{

1536

8604

/* None of the fields was found in multiple equalities */

1537

8605

Item_equal *item_equal= new Item_equal((Item_field *) left_item,

1579

8647

eq_item->set_cmp_func();

1580

8648

eq_item->quick_fix_field();

1581

8649

item= eq_item;

1582

}

8650

}

1583

8651

if ((cs != ((Item_func *) item)->compare_collation()) ||

1584

8652

!cs->coll->propagate(cs, 0, 0))

1585

8653

return false;

1594

8662

}

1595

8663

if (item_equal)

1596

8664

{

1597

8665

1598

8666

The flag cond_false will be set to 1 after this, if item_equal

1599

8667

already contains a constant and its value is not equal to

1600

8668

the value of const_item.

1612

8680

return false;

1613

8681

}

1614

8682

8683

1615

8684

/**

1616

8685

Convert row equalities into a conjunction of regular equalities.

1617

8686

1624

8693

simple equality nor a row equality the item for this predicate is added

1625

8694

to eq_list.

1626

8695

1627

@param session thread handle

8696

@param thd thread handle

1628

8697

@param left_row left term of the row equality to be processed

1629

8698

@param right_row right term of the row equality to be processed

1630

8699

@param cond_equal multiple equalities that must hold together with the

1637

8706

@retval

1638

8707

false otherwise

1639

8708

1640

static bool check_row_equality(Session *session,

1641

Item *left_row,

1642

Item_row *right_row,

1643

COND_EQUAL *cond_equal,

1644

List<Item>* eq_list)

1645

{

8709

8710

static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,

8711

COND_EQUAL *cond_equal, List<Item>* eq_list)

8712

{

1646

8713

uint32_t n= left_row->cols();

1647

8714

for (uint32_t i= 0 ; i < n; i++)

1648

8715

{

1652

8719

if (left_item->type() == Item::ROW_ITEM &&

1653

8720

right_item->type() == Item::ROW_ITEM)

1654

8721

{

1655

is_converted= check_row_equality(session,

8722

is_converted= check_row_equality(thd,

1656

8723

(Item_row *) left_item,

1657

8724

(Item_row *) right_item,

1658

8725

cond_equal, eq_list);

1659

8726

if (!is_converted)

1660

session->getLex()->current_select->cond_count++;

8727

thd->lex->current_select->cond_count++;

1661

8728

}

1662

8729

else

1663

{

8730

{

1664

8731

is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

1665

session->getLex()->current_select->cond_count++;

1666

}

1667

8732

thd->lex->current_select->cond_count++;

8733

}

8734

1668

8735

if (!is_converted)

1669

8736

{

1670

8737

Item_func_eq *eq_item;

1678

8745

return true;

1679

8746

}

1680

8747

8748

1681

8749

/**

1682

8750

Eliminate row equalities and form multiple equalities predicates.

1683

8751

1692

8760

equalities which are treated in the same way as original equality

1693

8761

predicates.

1694

8762

1695

@param session thread handle

8763

@param thd thread handle

1696

8764

@param item predicate to process

1697

8765

@param cond_equal multiple equalities that must hold together with the

1698

8766

predicate

1707

8775

or, if the equality is neither a simple one nor a row equality,

1708

8776

or, if the procedure fails by a fatal error.

1709

8777

1710

static bool check_equality(Session *session, Item *item, COND_EQUAL *cond_equal, List<Item> *eq_list)

8778

8779

static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,

8780

List<Item> *eq_list)

1711

8781

{

1712

8782

if (item->type() == Item::FUNC_ITEM &&

1713

8783

((Item_func*) item)->functype() == Item_func::EQ_FUNC)

1718

8788

if (left_item->type() == Item::ROW_ITEM &&

1719

8789

right_item->type() == Item::ROW_ITEM)

1720

8790

{

1721

session->getLex()->current_select->cond_count--;

1722

return check_row_equality(session,

8791

thd->lex->current_select->cond_count--;

8792

return check_row_equality(thd,

1723

8793

(Item_row *) left_item,

1724

8794

(Item_row *) right_item,

1725

8795

cond_equal, eq_list);

1726

8796

}

1727

else

8797

else

1728

8798

return check_simple_equality(left_item, right_item, item, cond_equal);

1729

}

8799

}

1730

8800

return false;

1731

8801

}

1732

8802

8803

1733

8804

/**

1734

8805

Replace all equality predicates in a condition by multiple equality items.

1735

8806

1736

8807

At each 'and' level the function detects items for equality predicates

1737

8808

and replaced them by a set of multiple equality items of class Item_equal,

1738

taking into account inherited equalities from upper levels.

8809

taking into account inherited equalities from upper levels.

1739

8810

If an equality predicate is used not in a conjunction it's just

1740

8811

replaced by a multiple equality predicate.

1741

8812

For each 'and' level the function set a pointer to the inherited

1742

8813

multiple equalities in the cond_equal field of the associated

1743

object of the type Item_cond_and.

8814

object of the type Item_cond_and.

1744

8815

The function also traverses the cond tree and and for each field reference

1745

8816

sets a pointer to the multiple equality item containing the field, if there

1746

8817

is any. If this multiple equality equates fields to a constant the

1747

function replaces the field reference by the constant in the cases

8818

function replaces the field reference by the constant in the cases

1748

8819

when the field is not of a string type or when the field reference is

1749

8820

just an argument of a comparison predicate.

1750

The function also determines the maximum number of members in

8821

The function also determines the maximum number of members in

1751

8822

equality lists of each Item_cond_and object assigning it to

1752

session->getLex()->current_select->max_equal_elems.

8823

thd->lex->current_select->max_equal_elems.

1753

8824

1754

8825

@note

1755

8826

Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

1761

8832

in a conjuction for a minimal set of multiple equality predicates.

1762

8833

This set can be considered as a canonical representation of the

1763

8834

sub-conjunction of the equality predicates.

1764

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

8835

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

1765

8836

(=(t1.a,t2.b,t3.c) AND t2.b>5), not by

1766

8837

(=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);

1767

8838

while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by

1772

8843

The function performs the substitution in a recursive descent by

1773

8844

the condtion tree, passing to the next AND level a chain of multiple

1774

8845

equality predicates which have been built at the upper levels.

1775

The Item_equal items built at the level are attached to other

8846

The Item_equal items built at the level are attached to other

1776

8847

non-equality conjucts as a sublist. The pointer to the inherited

1777

8848

multiple equalities is saved in the and condition object (Item_cond_and).

1778

This chain allows us for any field reference occurence easyly to find a

8849

This chain allows us for any field reference occurence easyly to find a

1779

8850

multiple equality that must be held for this occurence.

1780

8851

For each AND level we do the following:

1781

8852

- scan it for all equality predicate (=) items

1782

8853

- join them into disjoint Item_equal() groups

1783

- process the included OR conditions recursively to do the same for

1784

lower AND levels.

8854

- process the included OR conditions recursively to do the same for

8855

lower AND levels.

1785

8856

1786

8857

We need to do things in this order as lower AND levels need to know about

1787

8858

all possible Item_equal objects in upper levels.

1788

8859

1789

@param session thread handle

8860

@param thd thread handle

1790

8861

@param cond condition(expression) where to make replacement

1791

8862

@param inherited path to all inherited multiple equality items

1792

8863

1793

8864

@return

1794

8865

pointer to the transformed condition

1795

8866

1796

static COND *build_equal_items_for_cond(Session *session, COND *cond, COND_EQUAL *inherited)

8867

8868

static COND *build_equal_items_for_cond(THD *thd, COND *cond,

8869

COND_EQUAL *inherited)

1797

8870

{

1798

8871

Item_equal *item_equal;

1799

8872

COND_EQUAL cond_equal;

1805

8878

bool and_level= ((Item_cond*) cond)->functype() ==

1806

8879

Item_func::COND_AND_FUNC;

1807

8880

List<Item> *args= ((Item_cond*) cond)->argument_list();

1808

1809

List<Item>::iterator li(args->begin());

8881

8882

List_iterator<Item> li(*args);

1810

8883

Item *item;

1811

8884

1812

8885

if (and_level)

1814

8887

1815

8888

Retrieve all conjucts of this level detecting the equality

1816

8889

that are subject to substitution by multiple equality items and

1817

removing each such predicate from the conjunction after having

8890

removing each such predicate from the conjunction after having

1818

8891

found/created a multiple equality whose inference the predicate is.

1819

8892

1820

8893

while ((item= li++))

1821

8894

{

1822

8895

1824

8897

structure here because it's restored before each

1825

8898

re-execution of any prepared statement/stored procedure.

1826

8899

1827

if (check_equality(session, item, &cond_equal, &eq_list))

8900

if (check_equality(thd, item, &cond_equal, &eq_list))

1828

8901

li.remove();

1829

8902

}

1830

8903

1831

List<Item_equal>::iterator it(cond_equal.current_level.begin());

8904

List_iterator_fast<Item_equal> it(cond_equal.current_level);

1832

8905

while ((item_equal= it++))

1833

8906

{

1834

8907

item_equal->fix_length_and_dec();

1835

8908

item_equal->update_used_tables();

1836

set_if_bigger(session->getLex()->current_select->max_equal_elems,

1837

item_equal->members());

8909

set_if_bigger(thd->lex->current_select->max_equal_elems,

8910

item_equal->members());

1838

8911

}

1839

8912

1840

8913

((Item_cond_and*)cond)->cond_equal= cond_equal;

1844

8917

Make replacement of equality predicates for lower levels

1845

8918

of the condition expression.

1846

8919

1847

li= args->begin();

8920

li.rewind();

1848

8921

while ((item= li++))

1849

{

8922

{

1850

8923

Item *new_item;

1851

if ((new_item= build_equal_items_for_cond(session, item, inherited)) != item)

8924

if ((new_item= build_equal_items_for_cond(thd, item, inherited)) != item)

1852

8925

{

1853

8926

/* This replacement happens only for standalone equalities */

1854

8927

1876

8949

(b=5) and (a=c) are standalone equalities.

1877

8950

In general we can't leave alone standalone eqalities:

1878

8951

for WHERE a=b AND c=d AND (b=c OR d=5)

1879

b=c is replaced by =(a,b,c,d).

8952

b=c is replaced by =(a,b,c,d).

1880

8953

1881

if (check_equality(session, cond, &cond_equal, &eq_list))

8954

if (check_equality(thd, cond, &cond_equal, &eq_list))

1882

8955

{

1883

8956

int n= cond_equal.current_level.elements + eq_list.elements;

1884

8957

if (n == 0)

1889

8962

{

1890

8963

item_equal->fix_length_and_dec();

1891

8964

item_equal->update_used_tables();

1892

}

8965

}

1893

8966

else

1894

8967

item_equal= (Item_equal *) eq_list.pop();

1895

set_if_bigger(session->getLex()->current_select->max_equal_elems,

1896

item_equal->members());

8968

set_if_bigger(thd->lex->current_select->max_equal_elems,

8969

item_equal->members());

1897

8970

return item_equal;

1898

8971

}

1899

8972

else

1900

8973

{

1901

8974

1902

8975

Here a new AND level must be created. It can happen only

1903

8976

when a row equality is processed as a standalone predicate.

1904

8977

1905

8978

Item_cond_and *and_cond= new Item_cond_and(eq_list);

1906

8979

and_cond->quick_fix_field();

1907

8980

List<Item> *args= and_cond->argument_list();

1908

List<Item_equal>::iterator it(cond_equal.current_level.begin());

8981

List_iterator_fast<Item_equal> it(cond_equal.current_level);

1909

8982

while ((item_equal= it++))

1910

8983

{

1911

8984

item_equal->fix_length_and_dec();

1912

8985

item_equal->update_used_tables();

1913

set_if_bigger(session->getLex()->current_select->max_equal_elems,

1914

item_equal->members());

8986

set_if_bigger(thd->lex->current_select->max_equal_elems,

8987

item_equal->members());

1915

8988

}

1916

8989

and_cond->cond_equal= cond_equal;

1917

8990

args->concat((List<Item> *)&cond_equal.current_level);

1918

8991

1919

8992

return and_cond;

1920

8993

}

1921

8994

}

1922

8995

1923

8996

For each field reference in cond, not from equal item predicates,

1924

8997

set a pointer to the multiple equality it belongs to (if there is any)

1925

8998

as soon the field is not of a string type or the field reference is

1926

an argument of a comparison predicate.

1927

8999

an argument of a comparison predicate.

9000

1928

9001

unsigned char *is_subst_valid= (unsigned char *) 1;

1929

9002

cond= cond->compile(&Item::subst_argument_checker,

1930

&is_subst_valid,

9003

&is_subst_valid,

1931

9004

&Item::equal_fields_propagator,

1932

9005

(unsigned char *) inherited);

1933

9006

cond->update_used_tables();

1935

9008

return cond;

1936

9009

}

1937

9010

9011

1938

9012

/**

1939

9013

Build multiple equalities for a condition and all on expressions that

1940

9014

inherit these multiple equalities.

1980

9054

SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a

1981

9055

WHERE t1.a=t2.a

1982

9056

@endcode

1983

that is equivalent to:

9057

that is equivalent to:

1984

9058

@code

1985

9059

SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1

1986

9060

WHERE t1.a=t2.a

1987

9061

@endcode

1988

9062

Thus, applying equalities from the where condition we basically

1989

9063

can get more freedom in performing join operations.

1990

Althogh we don't use this property now, it probably makes sense to use

1991

it in the future.

1992

@param session Thread Cursor

9064

Althogh we don't use this property now, it probably makes sense to use

9065

it in the future.

9066

@param thd Thread handler

1993

9067

@param cond condition to build the multiple equalities for

1994

9068

@param inherited path to all inherited multiple equality items

1995

9069

@param join_list list of join tables to which the condition

2000

9074

@return

2001

9075

pointer to the transformed condition containing multiple equalities

2002

9076

2003

static COND *build_equal_items(Session *session, COND *cond,

9077

9078

static COND *build_equal_items(THD *thd, COND *cond,

2004

9079

COND_EQUAL *inherited,

2005

9080

List<TableList> *join_list,

2006

9081

COND_EQUAL **cond_equal_ref)

2007

9082

{

2008

9083

COND_EQUAL *cond_equal= 0;

2009

9084

2010

if (cond)

9085

if (cond)

2011

9086

{

2012

cond= build_equal_items_for_cond(session, cond, inherited);

9087

cond= build_equal_items_for_cond(thd, cond, inherited);

2013

9088

cond->update_used_tables();

2014

9089

if (cond->type() == Item::COND_ITEM &&

2015

9090

((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

2031

9106

if (join_list)

2032

9107

{

2033

9108

TableList *table;

2034

List<TableList>::iterator li(join_list->begin());

9109

List_iterator<TableList> li(*join_list);

2035

9110

2036

9111

while ((table= li++))

2037

9112

{

2038

9113

if (table->on_expr)

2039

9114

{

2040

List<TableList> *nested_join_list= table->getNestedJoin() ?

2041

&table->getNestedJoin()->join_list : NULL;

9115

List<TableList> *nested_join_list= table->nested_join ?

9116

&table->nested_join->join_list : NULL;

2042

9117

2043

9118

We can modify table->on_expr because its old value will

2044

9119

be restored before re-execution of PS/SP.

2045

9120

2046

table->on_expr= build_equal_items(session, table->on_expr, inherited,

9121

table->on_expr= build_equal_items(thd, table->on_expr, inherited,

2047

9122

nested_join_list,

2048

9123

&table->cond_equal);

2049

9124

}

2051

9126

}

2052

9127

2053

9128

return cond;

2054

}

9129

}

9130

2055

9131

2056

9132

/**

2057

9133

Compare field items by table order in the execution plan.

2058

9134

2059

9135

field1 considered as better than field2 if the table containing

2060

field1 is accessed earlier than the table containing field2.

9136

field1 is accessed earlier than the table containing field2.

2061

9137

The function finds out what of two fields is better according

2062

9138

this criteria.

2063

9139

2072

9148

@retval

2073

9149

0 otherwise

2074

9150

9151

2075

9152

static int compare_fields_by_table_order(Item_field *field1,

2076

Item_field *field2,

2077

void *table_join_idx)

9153

Item_field *field2,

9154

void *table_join_idx)

2078

9155

{

2079

9156

int cmp= 0;

2080

9157

bool outer_ref= 0;

2081

9158

if (field2->used_tables() & OUTER_REF_TABLE_BIT)

2082

{

9159

{

2083

9160

outer_ref= 1;

2084

9161

cmp= -1;

2085

9162

}

2090

9167

}

2091

9168

if (outer_ref)

2092

9169

return cmp;

2093

JoinTable **idx= (JoinTable **) table_join_idx;

2094

cmp= idx[field2->field->getTable()->tablenr]-idx[field1->field->getTable()->tablenr];

9170

JOIN_TAB **idx= (JOIN_TAB **) table_join_idx;

9171

cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];

2095

9172

return cmp < 0 ? -1 : (cmp ? 1 : 0);

2096

9173

}

2097

9174

9175

2098

9176

/**

2099

9177

Generate minimal set of simple equalities equivalent to a multiple equality.

2100

9178

2134

9212

a pointer to the simple generated equality, if success.

2135

9213

- 0, otherwise.

2136

9214

2137

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels, Item_equal *item_equal)

9215

9216

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,

9217

Item_equal *item_equal)

2138

9218

{

2139

9219

List<Item> eq_list;

2140

9220

Item_func_eq *eq_item= 0;

2141

9221

if (((Item *) item_equal)->const_item() && !item_equal->val_int())

2142

return new Item_int((int64_t) 0,1);

9222

return new Item_int((int64_t) 0,1);

2143

9223

Item *item_const= item_equal->get_const();

2144

9224

Item_equal_iterator it(*item_equal);

2145

9225

Item *head;

2156

9236

Item_equal *upper= item_field->find_item_equal(upper_levels);

2157

9237

Item_field *item= item_field;

2158

9238

if (upper)

2159

{

9239

{

2160

9240

if (item_const && upper->get_const())

2161

9241

item= 0;

2162

9242

else

2200

9280

2201

9281

cond->quick_fix_field();

2202

9282

cond->update_used_tables();

2203

9283

2204

9284

return cond;

2205

9285

}

2206

9286

9287

2207

9288

/**

2208

9289

Substitute every field reference in a condition by the best equal field

2209

9290

and eliminate all multiple equality predicates.

2212

9293

multiple equality predicate it sorts the field references in it

2213

9294

according to the order of tables specified by the table_join_idx

2214

9295

parameter. Then it eliminates the multiple equality predicate it

2215

replacing it by the conjunction of simple equality predicates

9296

replacing it by the conjunction of simple equality predicates

2216

9297

equating every field from the multiple equality to the first

2217

9298

field in it, or to the constant, if there is any.

2218

9299

After this the function retrieves all other conjuncted

2231

9312

@return

2232

9313

The transformed condition

2233

9314

2234

COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx)

9315

9316

static COND* substitute_for_best_equal_field(COND *cond,

9317

COND_EQUAL *cond_equal,

9318

void *table_join_idx)

2235

9319

{

2236

9320

Item_equal *item_equal;

2237

9321

2246

9330

cond_equal= &((Item_cond_and *) cond)->cond_equal;

2247

9331

cond_list->disjoin((List<Item> *) &cond_equal->current_level);

2248

9332

2249

List<Item_equal>::iterator it(cond_equal->current_level.begin());

9333

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2250

9334

while ((item_equal= it++))

2251

9335

{

2252

9336

item_equal->sort(&compare_fields_by_table_order, table_join_idx);

2253

9337

}

2254

9338

}

2255

2256

List<Item>::iterator li(cond_list->begin());

9339

9340

List_iterator<Item> li(*cond_list);

2257

9341

Item *item;

2258

9342

while ((item= li++))

2259

9343

{

2269

9353

2270

9354

if (and_level)

2271

9355

{

2272

List<Item_equal>::iterator it(cond_equal->current_level.begin());

9356

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2273

9357

while ((item_equal= it++))

2274

9358

{

2275

9359

cond= eliminate_item_equal(cond, cond_equal->upper_levels, item_equal);

2285

9369

cond= new Item_int((int32_t)cond->val_bool());

2286

9370

2287

9371

}

2288

else if (cond->type() == Item::FUNC_ITEM &&

9372

else if (cond->type() == Item::FUNC_ITEM &&

2289

9373

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2290

9374

{

2291

9375

item_equal= (Item_equal *) cond;

2299

9383

return cond;

2300

9384

}

2301

9385

9386

2302

9387

/**

2303

9388

Check appearance of new constant items in multiple equalities

2304

9389

of a condition after reading a constant table.

2311

9396

@param cond condition whose multiple equalities are to be checked

2312

9397

@param table constant table that has been read

2313

9398

2314

void update_const_equal_items(COND *cond, JoinTable *tab)

9399

9400

static void update_const_equal_items(COND *cond, JOIN_TAB *tab)

2315

9401

{

2316

9402

if (!(cond->used_tables() & tab->table->map))

2317

9403

return;

2318

9404

2319

9405

if (cond->type() == Item::COND_ITEM)

2320

9406

{

2321

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

2322

List<Item>::iterator li(cond_list->begin());

9407

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

9408

List_iterator_fast<Item> li(*cond_list);

2323

9409

Item *item;

2324

9410

while ((item= li++))

2325

9411

update_const_equal_items(item, tab);

2326

9412

}

2327

else if (cond->type() == Item::FUNC_ITEM &&

9413

else if (cond->type() == Item::FUNC_ITEM &&

2328

9414

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2329

9415

{

2330

9416

Item_equal *item_equal= (Item_equal *) cond;

2338

9424

while ((item_field= it++))

2339

9425

{

2340

9426

Field *field= item_field->field;

2341

JoinTable *stat= field->getTable()->reginfo.join_tab;

9427

JOIN_TAB *stat= field->table->reginfo.join_tab;

2342

9428

key_map possible_keys= field->key_start;

2343

possible_keys&= field->getTable()->keys_in_use_for_query;

2344

stat[0].const_keys|= possible_keys;

9429

possible_keys.intersect(field->table->keys_in_use_for_query);

9430

stat[0].const_keys.merge(possible_keys);

2345

9431

2346

9432

2347

For each field in the multiple equality (for which we know that it

2348

is a constant) we have to find its corresponding key part, and set

9433

For each field in the multiple equality (for which we know that it

9434

is a constant) we have to find its corresponding key part, and set

2349

9435

that key part in const_key_parts.

2350

2351

if (possible_keys.any())

9436

9437

if (!possible_keys.is_clear_all())

2352

9438

{

2353

Table *field_tab= field->getTable();

2354

optimizer::KeyUse *use;

2355

for (use= stat->keyuse; use && use->getTable() == field_tab; use++)

2356

if (possible_keys.test(use->getKey()) &&

2357

field_tab->key_info[use->getKey()].key_part[use->getKeypart()].field ==

9439

Table *tab= field->table;

9440

KEYUSE *use;

9441

for (use= stat->keyuse; use && use->table == tab; use++)

9442

if (possible_keys.is_set(use->key) &&

9443

tab->key_info[use->key].key_part[use->keypart].field ==

2358

9444

field)

2359

field_tab->const_key_parts[use->getKey()]|= use->getKeypartMap();

9445

tab->const_key_parts[use->key]|= use->keypart_map;

2360

9446

}

2361

9447

}

2362

9448

}

2363

9449

}

2364

9450

}

2365

9451

9452

2366

9453

2367

9454

change field = field to field = const for each found field = const in the

2368

9455

and_level

2369

9456

2370

static void change_cond_ref_to_const(Session *session,

2371

list<COND_CMP>& save_list,

2372

Item *and_father,

2373

Item *cond,

2374

Item *field,

2375

Item *value)

9457

9458

static void

9459

change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,

9460

Item *and_father, Item *cond,

9461

Item *field, Item *value)

2376

9462

{

2377

9463

if (cond->type() == Item::COND_ITEM)

2378

9464

{

2379

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

2380

List<Item>::iterator li(((Item_cond*) cond)->argument_list()->begin());

9465

bool and_level= ((Item_cond*) cond)->functype() ==

9466

Item_func::COND_AND_FUNC;

9467

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

2381

9468

Item *item;

2382

9469

while ((item=li++))

2383

change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

2384

9470

change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,

9471

field, value);

2385

9472

return;

2386

9473

}

2387

9474

if (cond->eq_cmp_result() == Item::COND_OK)

2400

9487

left_item->collation.collation == value->collation.collation))

2401

9488

{

2402

9489

Item *tmp=value->clone_item();

9490

tmp->collation.set(right_item->collation);

9491

2403

9492

if (tmp)

2404

9493

{

2405

tmp->collation.set(right_item->collation);

2406

session->change_item_tree(args + 1, tmp);

9494

thd->change_item_tree(args + 1, tmp);

2407

9495

func->update_used_tables();

2408

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2409

and_father != cond &&

2410

! left_item->const_item())

9496

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9497

&& and_father != cond && !left_item->const_item())

2411

9498

{

2412

cond->marker=1;

2413

save_list.push_back( COND_CMP(and_father, func) );

9499

cond->marker=1;

9500

COND_CMP *tmp2;

9501

if ((tmp2=new COND_CMP(and_father,func)))

9502

save_list->push_back(tmp2);

2414

9503

}

2415

9504

func->set_cmp_func();

2416

9505

}

2422

9511

right_item->collation.collation == value->collation.collation))

2423

9512

{

2424

9513

Item *tmp= value->clone_item();

9514

tmp->collation.set(left_item->collation);

9515

2425

9516

if (tmp)

2426

9517

{

2427

tmp->collation.set(left_item->collation);

2428

session->change_item_tree(args, tmp);

9518

thd->change_item_tree(args, tmp);

2429

9519

value= tmp;

2430

9520

func->update_used_tables();

2431

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2432

and_father != cond &&

2433

! right_item->const_item())

9521

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9522

&& and_father != cond && !right_item->const_item())

2434

9523

{

2435

9524

args[0]= args[1]; // For easy check

2436

session->change_item_tree(args + 1, value);

2437

cond->marker=1;

2438

save_list.push_back( COND_CMP(and_father, func) );

9525

thd->change_item_tree(args + 1, value);

9526

cond->marker=1;

9527

COND_CMP *tmp2;

9528

if ((tmp2=new COND_CMP(and_father,func)))

9529

save_list->push_back(tmp2);

2439

9530

}

2440

9531

func->set_cmp_func();

2441

9532

}

2450

9541

@return

2451

9542

new conditions

2452

9543

2453

Item *remove_additional_cond(Item* conds)

9544

9545

static Item *remove_additional_cond(Item* conds)

2454

9546

{

2455

9547

if (conds->name == in_additional_cond)

2456

9548

return 0;

2457

9549

if (conds->type() == Item::COND_ITEM)

2458

9550

{

2459

9551

Item_cond *cnd= (Item_cond*) conds;

2460

List<Item>::iterator li(cnd->argument_list()->begin());

9552

List_iterator<Item> li(*(cnd->argument_list()));

2461

9553

Item *item;

2462

9554

while ((item= li++))

2463

9555

{

2473

9565

return conds;

2474

9566

}

2475

9567

2476

static void propagate_cond_constants(Session *session,

2477

list<COND_CMP>& save_list,

2478

COND *and_father,

2479

COND *cond)

9568

static void

9569

propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,

9570

COND *and_father, COND *cond)

2480

9571

{

2481

9572

if (cond->type() == Item::COND_ITEM)

2482

9573

{

2483

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

2484

List<Item>::iterator li(((Item_cond*) cond)->argument_list()->begin());

9574

bool and_level= ((Item_cond*) cond)->functype() ==

9575

Item_func::COND_AND_FUNC;

9576

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

2485

9577

Item *item;

2486

list<COND_CMP> save;

9578

I_List<COND_CMP> save;

2487

9579

while ((item=li++))

2488

9580

{

2489

propagate_cond_constants(session, save, and_level ? cond : item, item);

9581

propagate_cond_constants(thd, &save,and_level ? cond : item, item);

2490

9582

}

2491

9583

if (and_level)

2492

{

2493

// Handle other found items

2494

for (list<COND_CMP>::iterator iter= save.begin(); iter != save.end(); ++iter)

9584

{ // Handle other found items

9585

I_List_iterator<COND_CMP> cond_itr(save);

9586

COND_CMP *cond_cmp;

9587

while ((cond_cmp=cond_itr++))

2495

9588

{

2496

Item **args= iter->second->arguments();

2497

if (not args[0]->const_item())

2498

{

2499

change_cond_ref_to_const(session, save, iter->first,

2500

iter->first, args[0], args[1] );

2501

}

9589

Item **args= cond_cmp->cmp_func->arguments();

9590

if (!args[0]->const_item())

9591

change_cond_ref_to_const(thd, &save,cond_cmp->and_level,

9592

cond_cmp->and_level, args[0], args[1]);

2502

9593

}

2503

9594

}

2504

9595

}

2505

9596

else if (and_father != cond && !cond->marker) // In a AND group

2506

9597

{

2507

9598

if (cond->type() == Item::FUNC_ITEM &&

2508

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

2509

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

9599

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

9600

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

2510

9601

{

2511

9602

Item_func_eq *func=(Item_func_eq*) cond;

2512

9603

Item **args= func->arguments();

2515

9606

if (!(left_const && right_const) &&

2516

9607

args[0]->result_type() == args[1]->result_type())

2517

9608

{

2518

if (right_const)

2519

{

2520

resolve_const_item(session, &args[1], args[0]);

2521

func->update_used_tables();

2522

change_cond_ref_to_const(session, save_list, and_father, and_father,

2523

args[0], args[1]);

2524

}

2525

else if (left_const)

2526

{

2527

resolve_const_item(session, &args[0], args[1]);

2528

func->update_used_tables();

2529

change_cond_ref_to_const(session, save_list, and_father, and_father,

2530

args[1], args[0]);

2531

}

2532

}

2533

}

2534

}

2535

}

9609

if (right_const)

9610

{

9611

resolve_const_item(thd, &args[1], args[0]);

9612

func->update_used_tables();

9613

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9614

args[0], args[1]);

9615

}

9616

else if (left_const)

9617

{

9618

resolve_const_item(thd, &args[0], args[1]);

9619

func->update_used_tables();

9620

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9621

args[1], args[0]);

9622

}

9623

}

9624

}

9625

}

9626

}

9627

9628

9629

/**

9630

Simplify joins replacing outer joins by inner joins whenever it's

9631

possible.

9632

9633

The function, during a retrieval of join_list, eliminates those

9634

outer joins that can be converted into inner join, possibly nested.

9635

It also moves the on expressions for the converted outer joins

9636

and from inner joins to conds.

9637

The function also calculates some attributes for nested joins:

9638

- used_tables

9639

- not_null_tables

9640

- dep_tables.

9641

- on_expr_dep_tables

9642

The first two attributes are used to test whether an outer join can

9643

be substituted for an inner join. The third attribute represents the

9644

relation 'to be dependent on' for tables. If table t2 is dependent

9645

on table t1, then in any evaluated execution plan table access to

9646

table t2 must precede access to table t2. This relation is used also

9647

to check whether the query contains invalid cross-references.

9648

The forth attribute is an auxiliary one and is used to calculate

9649

dep_tables.

9650

As the attribute dep_tables qualifies possibles orders of tables in the

9651

execution plan, the dependencies required by the straight join

9652

modifiers are reflected in this attribute as well.

9653

The function also removes all braces that can be removed from the join

9654

expression without changing its meaning.

9655

9656

@note

9657

An outer join can be replaced by an inner join if the where condition

9658

or the on expression for an embedding nested join contains a conjunctive

9659

predicate rejecting null values for some attribute of the inner tables.

9660

9661

E.g. in the query:

9662

@code

9663

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9664

@endcode

9665

the predicate t2.b < 5 rejects nulls.

9666

The query is converted first to:

9667

@code

9668

SELECT * FROM t1 INNER JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9669

@endcode

9670

then to the equivalent form:

9671

@code

9672

SELECT * FROM t1, t2 ON t2.a=t1.a WHERE t2.b < 5 AND t2.a=t1.a

9673

@endcode

9674

9675

9676

Similarly the following query:

9677

@code

9678

SELECT * from t1 LEFT JOIN (t2, t3) ON t2.a=t1.a t3.b=t1.b

9679

WHERE t2.c < 5

9680

@endcode

9681

is converted to:

9682

@code

9683

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a t3.b=t1.b

9684

9685

@endcode

9686

9687

One conversion might trigger another:

9688

@code

9689

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a

9690

LEFT JOIN t3 ON t3.b=t2.b

9691

WHERE t3 IS NOT NULL =>

9692

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a, t3

9693

WHERE t3 IS NOT NULL AND t3.b=t2.b =>

9694

SELECT * FROM t1, t2, t3

9695

WHERE t3 IS NOT NULL AND t3.b=t2.b AND t2.a=t1.a

9696

@endcode

9697

9698

The function removes all unnecessary braces from the expression

9699

produced by the conversions.

9700

E.g.

9701

@code

9702

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9703

@endcode

9704

finally is converted to:

9705

@code

9706

SELECT * FROM t1, t2, t3 WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9707

9708

@endcode

9709

9710

9711

It also will remove braces from the following queries:

9712

@code

9713

SELECT * from (t1 LEFT JOIN t2 ON t2.a=t1.a) LEFT JOIN t3 ON t3.b=t2.b

9714

SELECT * from (t1, (t2,t3)) WHERE t1.a=t2.a AND t2.b=t3.b.

9715

@endcode

9716

9717

The benefit of this simplification procedure is that it might return

9718

a query for which the optimizer can evaluate execution plan with more

9719

join orders. With a left join operation the optimizer does not

9720

consider any plan where one of the inner tables is before some of outer

9721

tables.

9722

9723

IMPLEMENTATION

9724

The function is implemented by a recursive procedure. On the recursive

9725

ascent all attributes are calculated, all outer joins that can be

9726

converted are replaced and then all unnecessary braces are removed.

9727

As join list contains join tables in the reverse order sequential

9728

elimination of outer joins does not require extra recursive calls.

9729

9730

SEMI-JOIN NOTES

9731

Remove all semi-joins that have are within another semi-join (i.e. have

9732

an "ancestor" semi-join nest)

9733

9734

EXAMPLES

9735

Here is an example of a join query with invalid cross references:

9736

@code

9737

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t3.a LEFT JOIN t3 ON t3.b=t1.b

9738

@endcode

9739

9740

@param join reference to the query info

9741

@param join_list list representation of the join to be converted

9742

@param conds conditions to add on expressions for converted joins

9743

@param top true <=> conds is the where condition

9744

9745

@return

9746

- The new condition, if success

9747

- 0, otherwise

9748

9749

9750

static COND *

9751

simplify_joins(JOIN *join, List<TableList> *join_list, COND *conds, bool top,

9752

bool in_sj)

9753

{

9754

TableList *table;

9755

nested_join_st *nested_join;

9756

TableList *prev_table= 0;

9757

List_iterator<TableList> li(*join_list);

9758

9759

9760

Try to simplify join operations from join_list.

9761

The most outer join operation is checked for conversion first.

9762

9763

while ((table= li++))

9764

{

9765

table_map used_tables;

9766

table_map not_null_tables= (table_map) 0;

9767

9768

if ((nested_join= table->nested_join))

9769

{

9770

9771

If the element of join_list is a nested join apply

9772

the procedure to its nested join list first.

9773

9774

if (table->on_expr)

9775

{

9776

Item *expr= table->on_expr;

9777

9778

If an on expression E is attached to the table,

9779

check all null rejected predicates in this expression.

9780

If such a predicate over an attribute belonging to

9781

an inner table of an embedded outer join is found,

9782

the outer join is converted to an inner join and

9783

the corresponding on expression is added to E.

9784

9785

expr= simplify_joins(join, &nested_join->join_list,

9786

expr, false, in_sj || table->sj_on_expr);

9787

9788

if (!table->prep_on_expr || expr != table->on_expr)

9789

{

9790

assert(expr);

9791

9792

table->on_expr= expr;

9793

table->prep_on_expr= expr->copy_andor_structure(join->thd);

9794

}

9795

}

9796

nested_join->used_tables= (table_map) 0;

9797

nested_join->not_null_tables=(table_map) 0;

9798

conds= simplify_joins(join, &nested_join->join_list, conds, top,

9799

in_sj || table->sj_on_expr);

9800

used_tables= nested_join->used_tables;

9801

not_null_tables= nested_join->not_null_tables;

9802

}

9803

else

9804

{

9805

if (!table->prep_on_expr)

9806

table->prep_on_expr= table->on_expr;

9807

used_tables= table->table->map;

9808

if (conds)

9809

not_null_tables= conds->not_null_tables();

9810

}

9811

9812

if (table->embedding)

9813

{

9814

table->embedding->nested_join->used_tables|= used_tables;

9815

table->embedding->nested_join->not_null_tables|= not_null_tables;

9816

}

9817

9818

if (!table->outer_join || (used_tables & not_null_tables))

9819

{

9820

9821

For some of the inner tables there are conjunctive predicates

9822

that reject nulls => the outer join can be replaced by an inner join.

9823

9824

table->outer_join= 0;

9825

if (table->on_expr)

9826

{

9827

/* Add ON expression to the WHERE or upper-level ON condition. */

9828

if (conds)

9829

{

9830

conds= and_conds(conds, table->on_expr);

9831

conds->top_level_item();

9832

/* conds is always a new item as both cond and on_expr existed */

9833

assert(!conds->fixed);

9834

conds->fix_fields(join->thd, &conds);

9835

}

9836

else

9837

conds= table->on_expr;

9838

table->prep_on_expr= table->on_expr= 0;

9839

}

9840

}

9841

9842

if (!top)

9843

continue;

9844

9845

9846

Only inner tables of non-convertible outer joins

9847

remain with on_expr.

9848

9849

if (table->on_expr)

9850

{

9851

table->dep_tables|= table->on_expr->used_tables();

9852

if (table->embedding)

9853

{

9854

table->dep_tables&= ~table->embedding->nested_join->used_tables;

9855

9856

Embedding table depends on tables used

9857

in embedded on expressions.

9858

9859

table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();

9860

}

9861

else

9862

table->dep_tables&= ~table->table->map;

9863

}

9864

9865

if (prev_table)

9866

{

9867

/* The order of tables is reverse: prev_table follows table */

9868

if (prev_table->straight)

9869

prev_table->dep_tables|= used_tables;

9870

if (prev_table->on_expr)

9871

{

9872

prev_table->dep_tables|= table->on_expr_dep_tables;

9873

table_map prev_used_tables= prev_table->nested_join ?

9874

prev_table->nested_join->used_tables :

9875

prev_table->table->map;

9876

9877

If on expression contains only references to inner tables

9878

we still make the inner tables dependent on the outer tables.

9879

It would be enough to set dependency only on one outer table

9880

for them. Yet this is really a rare case.

9881

9882

if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))

9883

prev_table->dep_tables|= used_tables;

9884

}

9885

}

9886

prev_table= table;

9887

}

9888

9889

9890

Flatten nested joins that can be flattened.

9891

no ON expression and not a semi-join => can be flattened.

9892

9893

li.rewind();

9894

while ((table= li++))

9895

{

9896

nested_join= table->nested_join;

9897

if (table->sj_on_expr && !in_sj)

9898

{

9899

9900

If this is a semi-join that is not contained within another semi-join,

9901

leave it intact (otherwise it is flattened)

9902

9903

join->select_lex->sj_nests.push_back(table);

9904

}

9905

else if (nested_join && !table->on_expr)

9906

{

9907

TableList *tbl;

9908

List_iterator<TableList> it(nested_join->join_list);

9909

while ((tbl= it++))

9910

{

9911

tbl->embedding= table->embedding;

9912

tbl->join_list= table->join_list;

9913

}

9914

li.replace(nested_join->join_list);

9915

}

9916

}

9917

return(conds);

9918

}

9919

9920

9921

/**

9922

Assign each nested join structure a bit in nested_join_map.

9923

9924

Assign each nested join structure (except "confluent" ones - those that

9925

embed only one element) a bit in nested_join_map.

9926

9927

@param join Join being processed

9928

@param join_list List of tables

9929

@param first_unused Number of first unused bit in nested_join_map before the

9930

call

9931

9932

@note

9933

This function is called after simplify_joins(), when there are no

9934

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

9935

we will not run out of bits in nested_join_map.

9936

9937

@return

9938

First unused bit in nested_join_map after the call.

9939

9940

9941

static uint32_t build_bitmap_for_nested_joins(List<TableList> *join_list,

9942

uint32_t first_unused)

9943

{

9944

List_iterator<TableList> li(*join_list);

9945

TableList *table;

9946

while ((table= li++))

9947

{

9948

nested_join_st *nested_join;

9949

if ((nested_join= table->nested_join))

9950

{

9951

9952

It is guaranteed by simplify_joins() function that a nested join

9953

that has only one child is either

9954

- a single-table view (the child is the underlying table), or

9955

- a single-table semi-join nest

9956

9957

We don't assign bits to such sj-nests because

9958

1. it is redundant (a "sequence" of one table cannot be interleaved

9959

with anything)

9960

2. we could run out bits in nested_join_map otherwise.

9961

9962

if (nested_join->join_list.elements != 1)

9963

{

9964

/* Don't assign bits to sj-nests */

9965

if (table->on_expr)

9966

nested_join->nj_map= (nested_join_map) 1 << first_unused++;

9967

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

9968

first_unused);

9969

}

9970

}

9971

}

9972

return(first_unused);

9973

}

9974

9975

9976

/**

9977

Set nested_join_st::counter=0 in all nested joins in passed list.

9978

9979

Recursively set nested_join_st::counter=0 for all nested joins contained in

9980

the passed join_list.

9981

9982

@param join_list List of nested joins to process. It may also contain base

9983

tables which will be ignored.

9984

9985

9986

static void reset_nj_counters(List<TableList> *join_list)

9987

{

9988

List_iterator<TableList> li(*join_list);

9989

TableList *table;

9990

while ((table= li++))

9991

{

9992

nested_join_st *nested_join;

9993

if ((nested_join= table->nested_join))

9994

{

9995

nested_join->counter_= 0;

9996

reset_nj_counters(&nested_join->join_list);

9997

}

9998

}

9999

return;

10000

}

10001

2536

10002

2537

10003

/**

2538

10004

Check interleaving with an inner tables of an outer join for

2539

10005

extension table.

2540

10006

2541

Check if table next_tab can be added to current partial join order, and

10007

Check if table next_tab can be added to current partial join order, and

2542

10008

if yes, record that it has been added.

2543

10009

2544

10010

The function assumes that both current partial join order and its

2545

10011

extension with next_tab are valid wrt table dependencies.

2546

10012

2547

10013

@verbatim

2548

IMPLEMENTATION

10014

IMPLEMENTATION

2549

10015

LIMITATIONS ON JOIN order_st

2550

10016

The nested [outer] joins executioner algorithm imposes these limitations

2551

10017

on join order:

2552

1. "Outer tables first" - any "outer" table must be before any

10018

1. "Outer tables first" - any "outer" table must be before any

2553

10019

corresponding "inner" table.

2554

10020

2. "No interleaving" - tables inside a nested join must form a continuous

2555

sequence in join order (i.e. the sequence must not be interrupted by

10021

sequence in join order (i.e. the sequence must not be interrupted by

2556

10022

tables that are outside of this nested join).

2557

10023

2558

10024

#1 is checked elsewhere, this function checks #2 provided that #1 has

2559

10025

been already checked.

2560

10026

2561

10027

WHY NEED NON-INTERLEAVING

2562

Consider an example:

10028

Consider an example:

2563

10029

2564

10030

select * from t0 join t1 left join (t2 join t3) on cond1

2565

10031

2583

10049

The limitations on join order can be rephrased as follows: for valid

2584

10050

join order one must be able to:

2585

10051

1. write down the used tables in the join order on one line.

2586

2. for each nested join, put one '(' and one ')' on the said line

10052

2. for each nested join, put one '(' and one ')' on the said line

2587

10053

3. write "LEFT JOIN" and "ON (...)" where appropriate

2588

10054

4. get a query equivalent to the query we're trying to execute.

2589

10055

2590

10056

Calls to check_interleaving_with_nj() are equivalent to writing the

2591

above described line from left to right.

2592

A single check_interleaving_with_nj(A,B) call is equivalent to writing

10057

above described line from left to right.

10058

A single check_interleaving_with_nj(A,B) call is equivalent to writing

2593

10059

table B and appropriate brackets on condition that table A and

2594

10060

appropriate brackets is the last what was written. Graphically the

2595

10061

transition is as follows:

2602

10068

position.

2603

10069

2604

10070

Notes about the position:

2605

The caller guarantees that there is no more then one X-bracket by

2606

checking "!(remaining_tables & s->dependent)" before calling this

10071

The caller guarantees that there is no more then one X-bracket by

10072

checking "!(remaining_tables & s->dependent)" before calling this

2607

10073

function. X-bracket may have a pair in Y-bracket.

2608

10074

2609

10075

When "writing" we store/update this auxilary info about the current

2610

10076

position:

2611

10077

1. join->cur_embedding_map - bitmap of pairs of brackets (aka nested

2612

10078

joins) we've opened but didn't close.

2613

2. {each NestedJoin class not simplified away}->counter - number

10079

2. {each nested_join_st structure not simplified away}->counter - number

2614

10080

of this nested join's children that have already been added to to

2615

10081

the partial join order.

2616

10082

@endverbatim

2617

10083

2618

10084

@param join Join being processed

10085

@param last_tab Last table in current partial join order (this function is

10086

not called for empty partial join orders)

2619

10087

@param next_tab Table we're going to extend the current partial join with

2620

10088

2621

10089

@retval

2624

10092

@retval

2625

10093

true Requested join order extension not allowed.

2626

10094

2627

bool check_interleaving_with_nj(JoinTable *next_tab)

10095

10096

static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)

2628

10097

{

2629

TableList *next_emb= next_tab->table->pos_in_table_list->getEmbedding();

2630

Join *join= next_tab->join;

10098

TableList *next_emb= next_tab->table->pos_in_table_list->embedding;

10099

JOIN *join= last_tab->join;

2631

10100

2632

if ((join->cur_embedding_map & ~next_tab->embedding_map).any())

10101

if (join->cur_embedding_map & ~next_tab->embedding_map)

2633

10102

{

2634

10103

2635

10104

next_tab is outside of the "pair of brackets" we're currently in.

2636

10105

Cannot add it.

2637

10106

2638

10107

return true;

2639

10108

}

2640

10109

2641

10110

2642

10111

Do update counters for "pairs of brackets" that we've left (marked as

2643

10112

X,Y,Z in the above picture)

2644

10113

2645

for (;next_emb; next_emb= next_emb->getEmbedding())

10114

for (;next_emb; next_emb= next_emb->embedding)

2646

10115

{

2647

next_emb->getNestedJoin()->counter_++;

2648

if (next_emb->getNestedJoin()->counter_ == 1)

10116

next_emb->nested_join->counter_++;

10117

if (next_emb->nested_join->counter_ == 1)

2649

10118

{

2650

10119

2651

10120

next_emb is the first table inside a nested join we've "entered". In

2652

10121

the picture above, we're looking at the 'X' bracket. Don't exit yet as

2653

10122

X bracket might have Y pair bracket.

2654

10123

2655

join->cur_embedding_map |= next_emb->getNestedJoin()->nj_map;

10124

join->cur_embedding_map |= next_emb->nested_join->nj_map;

2656

10125

}

2657

2658

if (next_emb->getNestedJoin()->join_list.elements !=

2659

next_emb->getNestedJoin()->counter_)

10126

10127

if (next_emb->nested_join->join_list.elements !=

10128

next_emb->nested_join->counter_)

2660

10129

break;

2661

10130

2662

10131

2663

10132

We're currently at Y or Z-bracket as depicted in the above picture.

2664

10133

Mark that we've left it and continue walking up the brackets hierarchy.

2665

10134

2666

join->cur_embedding_map &= ~next_emb->getNestedJoin()->nj_map;

10135

join->cur_embedding_map &= ~next_emb->nested_join->nj_map;

2667

10136

}

2668

10137

return false;

2669

10138

}

2670

10139

2671

COND *optimize_cond(Join *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)

2672

{

2673

Session *session= join->session;

10140

10141

/**

10142

Nested joins perspective: Remove the last table from the join order.

10143

10144

Remove the last table from the partial join order and update the nested

10145

joins counters and join->cur_embedding_map. It is ok to call this

10146

function for the first table in join order (for which

10147

check_interleaving_with_nj has not been called)

10148

10149

@param last join table to remove, it is assumed to be the last in current

10150

partial join order.

10151

10152

10153

static void restore_prev_nj_state(JOIN_TAB *last)

10154

{

10155

TableList *last_emb= last->table->pos_in_table_list->embedding;

10156

JOIN *join= last->join;

10157

while (last_emb)

10158

{

10159

if (last_emb->on_expr)

10160

{

10161

if (!(--last_emb->nested_join->counter_))

10162

join->cur_embedding_map&= ~last_emb->nested_join->nj_map;

10163

else if (last_emb->nested_join->join_list.elements-1 ==

10164

last_emb->nested_join->counter_)

10165

join->cur_embedding_map|= last_emb->nested_join->nj_map;

10166

else

10167

break;

10168

}

10169

last_emb= last_emb->embedding;

10170

}

10171

}

10172

10173

10174

10175

static

10176

void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab)

10177

{

10178

TableList *emb_sj_nest;

10179

if ((emb_sj_nest= tab->emb_sj_nest))

10180

{

10181

tab->join->cur_emb_sj_nests |= emb_sj_nest->sj_inner_tables;

10182

/* Remove the sj_nest if all of its SJ-inner tables are in cur_table_map */

10183

if (!(remaining_tables & emb_sj_nest->sj_inner_tables))

10184

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10185

}

10186

}

10187

10188

10189

10190

we assume remaining_tables doesnt contain @tab.

10191

10192

10193

static void restore_prev_sj_state(const table_map remaining_tables,

10194

const JOIN_TAB *tab)

10195

{

10196

TableList *emb_sj_nest;

10197

if ((emb_sj_nest= tab->emb_sj_nest))

10198

{

10199

/* If we're removing the last SJ-inner table, remove the sj-nest */

10200

if ((remaining_tables & emb_sj_nest->sj_inner_tables) ==

10201

(emb_sj_nest->sj_inner_tables & ~tab->table->map))

10202

{

10203

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10204

}

10205

}

10206

}

10207

10208

10209

static COND *

10210

optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list,

10211

Item::cond_result *cond_value)

10212

{

10213

THD *thd= join->thd;

2674

10214

2675

10215

if (!conds)

2676

10216

*cond_value= Item::COND_TRUE;

2677

10217

else

2678

10218

{

2679

10219

2680

10220

Build all multiple equality predicates and eliminate equality

2681

10221

predicates that can be inferred from these multiple equalities.

2682

10222

For each reference of a field included into a multiple equality

2683

10223

that occurs in a function set a pointer to the multiple equality

2684

10224

predicate. Substitute a constant instead of this field if the

2685

10225

multiple equality contains a constant.

2686

2687

conds= build_equal_items(join->session, conds, NULL, join_list,

10226

10227

conds= build_equal_items(join->thd, conds, NULL, join_list,

2688

10228

&join->cond_equal);

2689

10229

2690

10230

/* change field = field to field = const for each found field = const */

2691

list<COND_CMP> temp;

2692

propagate_cond_constants(session, temp, conds, conds);

10231

propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);

2693

10232

2694

10233

Remove all instances of item == item

2695

10234

Remove all and-levels where CONST item != CONST item

2696

10235

2697

conds= remove_eq_conds(session, conds, cond_value) ;

10236

conds= remove_eq_conds(thd, conds, cond_value) ;

2698

10237

}

2699

10238

return(conds);

2700

10239

}

2701

10240

10241

2702

10242

/**

2703

10243

Remove const and eq items.

2704

10244

2709

10249

- COND_TRUE : always true ( 1 = 1 )

2710

10250

- COND_FALSE : always false ( 1 = 2 )

2711

10251

2712

COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value)

10252

10253

COND *

10254

remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)

2713

10255

{

2714

10256

if (cond->type() == Item::COND_ITEM)

2715

10257

{

2716

bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

2717

2718

List<Item>::iterator li(((Item_cond*) cond)->argument_list()->begin());

10258

bool and_level= ((Item_cond*) cond)->functype()

10259

== Item_func::COND_AND_FUNC;

10260

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

2719

10261

Item::cond_result tmp_cond_value;

2720

bool should_fix_fields= false;

10262

bool should_fix_fields=0;

2721

10263

2722

*cond_value= Item::COND_UNDEF;

10264

*cond_value=Item::COND_UNDEF;

2723

10265

Item *item;

2724

while ((item= li++))

10266

while ((item=li++))

2725

10267

{

2726

Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);

2727

if (! new_item)

2728

li.remove();

10268

Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);

10269

if (!new_item)

10270

li.remove();

2729

10271

else if (item != new_item)

2730

10272

{

2731

li.replace(new_item);

2732

should_fix_fields= true;

10273

li.replace(new_item);

10274

should_fix_fields=1;

2733

10275

}

2734

10276

if (*cond_value == Item::COND_UNDEF)

2735

*cond_value= tmp_cond_value;

2736

2737

switch (tmp_cond_value)

2738

{

2739

case Item::COND_OK: /* Not true or false */

2740

if (and_level || (*cond_value == Item::COND_FALSE))

2741

*cond_value= tmp_cond_value;

2742

break;

2743

case Item::COND_FALSE:

2744

if (and_level)

2745

{

2746

*cond_value= tmp_cond_value;

2747

return (COND *) NULL; /* Always false */

2748

}

2749

break;

2750

case Item::COND_TRUE:

2751

if (! and_level)

2752

{

2753

*cond_value= tmp_cond_value;

2754

return (COND *) NULL; /* Always true */

2755

}

2756

break;

2757

case Item::COND_UNDEF: /* Impossible */

2758

break;

10277

*cond_value=tmp_cond_value;

10278

switch (tmp_cond_value) {

10279

case Item::COND_OK: // Not true or false

10280

if (and_level || *cond_value == Item::COND_FALSE)

10281

*cond_value=tmp_cond_value;

10282

break;

10283

case Item::COND_FALSE:

10284

if (and_level)

10285

{

10286

*cond_value=tmp_cond_value;

10287

return (COND*) 0; // Always false

10288

}

10289

break;

10290

case Item::COND_TRUE:

10291

if (!and_level)

10292

{

10293

*cond_value= tmp_cond_value;

10294

return (COND*) 0; // Always true

10295

}

10296

break;

10297

case Item::COND_UNDEF: // Impossible

10298

break; /* purecov: deadcode */

2759

10299

}

2760

10300

}

2761

2762

10301

if (should_fix_fields)

2763

10302

cond->update_used_tables();

2764

10303

2765

if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)

2766

return (COND*) NULL;

2767

10304

if (!((Item_cond*) cond)->argument_list()->elements ||

10305

*cond_value != Item::COND_OK)

10306

return (COND*) 0;

2768

10307

if (((Item_cond*) cond)->argument_list()->elements == 1)

2769

{

2770

/* Argument list contains only one element, so reduce it so a single item, then remove list */

10308

{ // Remove list

2771

10309

item= ((Item_cond*) cond)->argument_list()->head();

2772

((Item_cond*) cond)->argument_list()->clear();

10310

((Item_cond*) cond)->argument_list()->empty();

2773

10311

return item;

2774

10312

}

2775

10313

}

2776

else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

10314

else if (cond->type() == Item::FUNC_ITEM &&

10315

((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

2777

10316

{

2778

10317

2779

10318

Handles this special case for some ODBC applications:

2785

10324

SELECT * from table_name where auto_increment_column = LAST_INSERT_ID

2786

10325

2787

10326

2788

Item_func_isnull *func= (Item_func_isnull*) cond;

10327

Item_func_isnull *func=(Item_func_isnull*) cond;

2789

10328

Item **args= func->arguments();

2790

10329

if (args[0]->type() == Item::FIELD_ITEM)

2791

10330

{

2792

Field *field= ((Item_field*) args[0])->field;

2793

if (field->flags & AUTO_INCREMENT_FLAG

2794

&& ! field->getTable()->maybe_null

2795

&& session->options & OPTION_AUTO_IS_NULL

2796

&& (

2797

session->first_successful_insert_id_in_prev_stmt > 0

2798

&& session->substitute_null_with_insert_id

2799

)

2800

)

10331

Field *field=((Item_field*) args[0])->field;

10332

if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&

10333

(thd->options & OPTION_AUTO_IS_NULL) &&

10334

(thd->first_successful_insert_id_in_prev_stmt > 0 &&

10335

thd->substitute_null_with_insert_id))

2801

10336

{

2802

COND *new_cond;

2803

if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",

2804

session->read_first_successful_insert_id_in_prev_stmt(),

2805

MY_INT64_NUM_DECIMAL_DIGITS))))

2806

{

2807

cond= new_cond;

10337

COND *new_cond;

10338

if ((new_cond= new Item_func_eq(args[0],

10339

new Item_int("last_insert_id()",

10340

thd->read_first_successful_insert_id_in_prev_stmt(),

10341

MY_INT64_NUM_DECIMAL_DIGITS))))

10342

{

10343

cond=new_cond;

2808

10344

2809

10345

Item_func_eq can't be fixed after creation so we do not check

2810

10346

cond->fixed, also it do not need tables so we use 0 as second

2811

10347

argument.

2812

10348

2813

cond->fix_fields(session, &cond);

2814

}

10349

cond->fix_fields(thd, &cond);

10350

}

2815

10351

2816

10352

IS NULL should be mapped to LAST_INSERT_ID only for first row, so

2817

10353

clear for next row

2818

10354

2819

session->substitute_null_with_insert_id= false;

10355

thd->substitute_null_with_insert_id= false;

2820

10356

}

2821

#ifdef NOTDEFINED

2822

10357

/* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */

2823

else if (

2824

((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME))

2825

&& (field->flags & NOT_NULL_FLAG)

2826

&& ! field->table->maybe_null)

10358

else if (((field->type() == DRIZZLE_TYPE_NEWDATE) ||

10359

(field->type() == DRIZZLE_TYPE_DATETIME)) &&

10360

(field->flags & NOT_NULL_FLAG) &&

10361

!field->table->maybe_null)

2827

10362

{

2828

COND *new_cond;

2829

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

2830

{

2831

cond= new_cond;

10363

COND *new_cond;

10364

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

10365

{

10366

cond=new_cond;

2832

10367

2833

10368

Item_func_eq can't be fixed after creation so we do not check

2834

10369

cond->fixed, also it do not need tables so we use 0 as second

2835

10370

argument.

2836

10371

2837

cond->fix_fields(session, &cond);

2838

}

10372

cond->fix_fields(thd, &cond);

10373

}

2839

10374

}

2840

#endif /* NOTDEFINED */

2841

10375

}

2842

10376

if (cond->const_item())

2843

10377

{

2844

10378

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2845

return (COND *) NULL;

10379

return (COND*) 0;

2846

10380

}

2847

10381

}

2848

10382

else if (cond->const_item() && !cond->is_expensive())

2849

10383

2850

@todo

10384

TODO:

2851

10385

Excluding all expensive functions is too restritive we should exclude only

2852

materialized IN subquery predicates because they can't yet be evaluated

2853

here (they need additional initialization that is done later on).

2854

2855

The proper way to exclude the subqueries would be to walk the cond tree and

2856

check for materialized subqueries there.

2857

10386

materialized IN because it is created later than this phase, and cannot be

10387

evaluated at this point.

10388

The condition should be something as (need to fix member access):

10389

!(cond->type() == Item::FUNC_ITEM &&

10390

((Item_func*)cond)->func_name() == "<in_optimizer>" &&

10391

((Item_in_optimizer*)cond)->is_expensive()))

2858

10392

2859

10393

{

2860

10394

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2861

return (COND *) NULL;

10395

return (COND*) 0;

2862

10396

}

2863

10397

else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)

2864

{

2865

/* boolan compare function */

10398

{ // boolan compare function

2866

10399

Item *left_item= ((Item_func*) cond)->arguments()[0];

2867

10400

Item *right_item= ((Item_func*) cond)->arguments()[1];

2868

10401

if (left_item->eq(right_item,1))

2869

10402

{

2870

if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

2871

return (COND*) NULL; /* Comparison of identical items */

10403

if (!left_item->maybe_null ||

10404

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

10405

return (COND*) 0; // Compare of identical items

2872

10406

}

2873

10407

}

2874

*cond_value= Item::COND_OK;

2875

return cond; /* Point at next and return into recursion */

10408

*cond_value=Item::COND_OK;

10409

return cond; // Point at next and level

2876

10410

}

2877

10411

2878

10412

2879

10413

Check if equality can be used in removing components of GROUP BY/DISTINCT

2880

10414

2881

10415

SYNOPSIS

2882

10416

test_if_equality_guarantees_uniqueness()

2883

10417

l the left comparison argument (a field if any)

2884

10418

r the right comparison argument (a const of any)

2885

2886

DESCRIPTION

2887

Checks if an equality predicate can be used to take away

2888

DISTINCT/GROUP BY because it is known to be true for exactly one

10419

10420

DESCRIPTION

10421

Checks if an equality predicate can be used to take away

10422

DISTINCT/GROUP BY because it is known to be true for exactly one

2889

10423

distinct value (e.g. <expr> == <const>).

2890

Arguments must be of the same type because e.g.

2891

<string_field> = <int_const> may match more than 1 distinct value from

2892

the column.

2893

We must take into consideration and the optimization done for various

10424

Arguments must be of the same type because e.g.

10425

<string_field> = <int_const> may match more than 1 distinct value from

10426

the column.

10427

We must take into consideration and the optimization done for various

2894

10428

string constants when compared to dates etc (see Item_int_with_ref) as

2895

10429

well as the collation of the arguments.

2896

2897

RETURN VALUE

10430

10431

RETURN VALUE

2898

10432

true can be used

2899

10433

false cannot be used

2900

10434

2901

static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)

10435

static bool

10436

test_if_equality_guarantees_uniqueness(Item *l, Item *r)

2902

10437

{

2903

10438

return r->const_item() &&

2904

10439

/* elements must be compared as dates */

2913

10448

/**

2914

10449

Return true if the item is a const value in all the WHERE clause.

2915

10450

2916

bool const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

10451

10452

static bool

10453

const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

2917

10454

{

2918

10455

if (cond->type() == Item::COND_ITEM)

2919

10456

{

2920

10457

bool and_level= (((Item_cond*) cond)->functype()

2921

10458

== Item_func::COND_AND_FUNC);

2922

List<Item>::iterator li(((Item_cond*) cond)->argument_list()->begin());

10459

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

2923

10460

Item *item;

2924

10461

while ((item=li++))

2925

10462

{

2926

10463

bool res=const_expression_in_where(item, comp_item, const_item);

2927

10464

if (res) // Is a const value

2928

10465

{

2929

if (and_level)

2930

return 1;

10466

if (and_level)

10467

return 1;

2931

10468

}

2932

10469

else if (!and_level)

2933

return 0;

10470

return 0;

2934

10471

}

2935

10472

return and_level ? 0 : 1;

2936

10473

}

2938

10475

{ // boolan compare function

2939

10476

Item_func* func= (Item_func*) cond;

2940

10477

if (func->functype() != Item_func::EQUAL_FUNC &&

2941

func->functype() != Item_func::EQ_FUNC)

10478

func->functype() != Item_func::EQ_FUNC)

2942

10479

return 0;

2943

10480

Item *left_item= ((Item_func*) cond)->arguments()[0];

2944

10481

Item *right_item= ((Item_func*) cond)->arguments()[1];

2946

10483

{

2947

10484

if (test_if_equality_guarantees_uniqueness (left_item, right_item))

2948

10485

{

2949

if (*const_item)

2950

return right_item->eq(*const_item, 1);

2951

*const_item=right_item;

2952

return 1;

10486

if (*const_item)

10487

return right_item->eq(*const_item, 1);

10488

*const_item=right_item;

10489

return 1;

2953

10490

}

2954

10491

}

2955

10492

else if (right_item->eq(comp_item,1))

2956

10493

{

2957

10494

if (test_if_equality_guarantees_uniqueness (right_item, left_item))

2958

10495

{

2959

if (*const_item)

2960

return left_item->eq(*const_item, 1);

2961

*const_item=left_item;

2962

return 1;

10496

if (*const_item)

10497

return left_item->eq(*const_item, 1);

10498

*const_item=left_item;

10499

return 1;

2963

10500

}

2964

10501

}

2965

10502

}

2966

10503

return 0;

2967

10504

}

2968

10505

10506

2969

10507

/**

2970

10508

@details

2971

10509

Rows produced by a join sweep may end up in a temporary table or be sent

2977

10515

@return

2978

10516

end_select function to use. This function can't fail.

2979

10517

2980

Next_select_func setup_end_select_func(Join *join)

10518

10519

Next_select_func setup_end_select_func(JOIN *join)

2981

10520

{

2982

10521

Table *table= join->tmp_table;

2983

Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;

10522

TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;

2984

10523

Next_select_func end_select;

2985

10524

2986

10525

/* Set up select_end */

2987

10526

if (table)

2988

10527

{

2989

if (table->group && tmp_tbl->sum_func_count &&

10528

if (table->group && tmp_tbl->sum_func_count &&

2990

10529

!tmp_tbl->precomputed_group_by)

2991

10530

{

2992

if (table->getShare()->sizeKeys())

10531

if (table->s->keys)

2993

10532

{

2994

end_select= end_update;

10533

end_select=end_update;

2995

10534

}

2996

10535

else

2997

10536

{

2998

end_select= end_unique_update;

10537

end_select=end_unique_update;

2999

10538

}

3000

10539

}

3001

10540

else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)

3002

10541

{

3003

end_select= end_write_group;

10542

end_select=end_write_group;

3004

10543

}

3005

10544

else

3006

10545

{

3007

end_select= end_write;

10546

end_select=end_write;

3008

10547

if (tmp_tbl->precomputed_group_by)

3009

10548

{

3010

10549

3011

10550

A preceding call to create_tmp_table in the case when loose

3012

10551

index scan is used guarantees that

3013

Tmp_Table_Param::items_to_copy has enough space for the group

10552

TMP_TABLE_PARAM::items_to_copy has enough space for the group

3014

10553

by functions. It is OK here to use memcpy since we copy

3015

10554

Item_sum pointers into an array of Item pointers.

3016

10555

3032

10571

return end_select;

3033

10572

}

3034

10573

10574

3035

10575

/**

3036

10576

Make a join of all tables and write it on socket or to table.

3037

10577

3042

10582

@retval

3043

10583

-1 if error should be sent

3044

10584

3045

int do_select(Join *join, List<Item> *fields, Table *table)

10585

10586

static int

10587

do_select(JOIN *join,List<Item> *fields,Table *table)

3046

10588

{

3047

10589

int rc= 0;

3048

10590

enum_nested_loop_state error= NESTED_LOOP_OK;

3049

JoinTable *join_tab= NULL;

3050

10591

JOIN_TAB *join_tab= NULL;

10592

3051

10593

join->tmp_table= table; /* Save for easy recursion */

3052

10594

join->fields= fields;

3053

10595

3054

10596

if (table)

3055

10597

{

3056

table->cursor->extra(HA_EXTRA_WRITE_CACHE);

3057

table->emptyRecord();

10598

table->file->extra(HA_EXTRA_WRITE_CACHE);

10599

empty_record(table);

3058

10600

if (table->group && join->tmp_table_param.sum_func_count &&

3059

table->getShare()->sizeKeys() && !table->cursor->inited)

3060

{

3061

int tmp_error;

3062

tmp_error= table->cursor->startIndexScan(0, 0);

3063

if (tmp_error != 0)

3064

{

3065

table->print_error(tmp_error, MYF(0));

3066

return -1;

3067

}

3068

}

10601

table->s->keys && !table->file->inited)

10602

table->file->ha_index_init(0, 0);

3069

10603

}

3070

10604

/* Set up select_end */

3071

10605

Next_select_func end_select= setup_end_select_func(join);

3086

10620

{

3087

10621

error= (*end_select)(join, 0, 0);

3088

10622

if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)

3089

error= (*end_select)(join, 0, 1);

10623

error= (*end_select)(join, 0, 1);

3090

10624

3091

10625

3092

10626

If we don't go through evaluate_join_record(), do the counting

3094

10628

so we don't touch it here.

3095

10629

3096

10630

join->examined_rows++;

3097

join->session->row_count++;

10631

join->thd->row_count++;

3098

10632

assert(join->examined_rows <= 1);

3099

10633

}

3100

10634

else if (join->send_row_on_empty_set())

3124

10658

if (!table) // If sending data to client

3125

10659

{

3126

10660

3127

The following will unlock all cursors if the command wasn't an

3128

update command

10661

The following will unlock all cursors if the command wasn't an

10662

update command

3129

10663

3130

10664

join->join_free(); // Unlock all cursors

3131

10665

if (join->result->send_eof())

3132

rc= 1; // Don't send error

10666

rc= 1; // Don't send error

3133

10667

}

3134

10668

}

3135

10669

else

3137

10671

if (table)

3138

10672

{

3139

10673

int tmp, new_errno= 0;

3140

if ((tmp=table->cursor->extra(HA_EXTRA_NO_CACHE)))

10674

if ((tmp=table->file->extra(HA_EXTRA_NO_CACHE)))

3141

10675

{

3142

10676

new_errno= tmp;

3143

10677

}

3144

if ((tmp=table->cursor->ha_index_or_rnd_end()))

10678

if ((tmp=table->file->ha_index_or_rnd_end()))

3145

10679

{

3146

10680

new_errno= tmp;

3147

10681

}

3148

10682

if (new_errno)

3149

table->print_error(new_errno,MYF(0));

10683

table->file->print_error(new_errno,MYF(0));

3150

10684

}

3151

return(join->session->is_error() ? -1 : rc);

10685

return(join->thd->is_error() ? -1 : rc);

3152

10686

}

3153

10687

3154

enum_nested_loop_state sub_select_cache(Join *join, JoinTable *join_tab, bool end_of_records)

10688

10689

enum_nested_loop_state

10690

sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3155

10691

{

3156

10692

enum_nested_loop_state rc;

3157

10693

3162

10698

rc= sub_select(join,join_tab,end_of_records);

3163

10699

return rc;

3164

10700

}

3165

if (join->session->getKilled()) // If aborted by user

10701

if (join->thd->killed) // If aborted by user

3166

10702

{

3167

join->session->send_kill_message();

3168

return NESTED_LOOP_KILLED;

10703

join->thd->send_kill_message();

10704

return NESTED_LOOP_KILLED; /* purecov: inspected */

3169

10705

}

3170

10706

if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)

3171

10707

{

3172

if (! join_tab->cache.store_record_in_cache())

10708

if (!store_record_in_cache(&join_tab->cache))

3173

10709

return NESTED_LOOP_OK; // There is more room in cache

3174

10710

return flush_cached_records(join,join_tab,false);

3175

10711

}

3182

10718

/**

3183

10719

Retrieve records ends with a given beginning from the result of a join.

3184

10720

3185

For a given partial join record consisting of records from the tables

10721

For a given partial join record consisting of records from the tables

3186

10722

preceding the table join_tab in the execution plan, the function

3187

10723

retrieves all matching full records from the result set and

3188

send them to the result set stream.

10724

send them to the result set stream.

3189

10725

3190

10726

@note

3191

10727

The function effectively implements the final (n-k) nested loops

3225

10761

first row with t3.a=t1.a has been encountered.

3226

10762

Thus, the second predicate P2 is supplied with a guarded value that are

3227

10763

stored in the field 'found' of the first inner table for the outer join

3228

(table t2). When the first row with t3.a=t1.a for the current row

10764

(table t2). When the first row with t3.a=t1.a for the current row

3229

10765

of table t1 appears, the value becomes true. For now on the predicate

3230

10766

is evaluated immediately after the row of table t2 has been read.

3231

10767

When the first row with t3.a=t1.a has been encountered all

3233

10769

Only when all of them are true the row is sent to the output stream.

3234

10770

If not, the function returns to the lowest nest level that has a false

3235

10771

attached condition.

3236

The predicates from on expressions are also pushed down. If in the

10772

The predicates from on expressions are also pushed down. If in the

3237

10773

the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),

3238

10774

then t1.a=t2.a would be pushed down to table t2, and without any

3239

10775

guard.

3243

10779

is complemented by nulls for t2 and t3. Then the pushed down predicates

3244

10780

are checked for the composed row almost in the same way as it had

3245

10781

been done for the first row with a match. The only difference is

3246

the predicates from on expressions are not checked.

10782

the predicates from on expressions are not checked.

3247

10783

3248

10784

@par

3249

10785

@b IMPLEMENTATION

3259

10795

and a pointer to a guarding boolean variable.

3260

10796

When the value of the guard variable is true the value of the object

3261

10797

is the same as the value of the predicate, otherwise it's just returns

3262

true.

3263

To carry out a return to a nested loop level of join table t the pointer

10798

true.

10799

To carry out a return to a nested loop level of join table t the pointer

3264

10800

to t is remembered in the field 'return_tab' of the join structure.

3265

10801

Consider the following query:

3266

10802

@code

3277

10813

t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL

3278

10814

becomes 'activated', as well the predicate t4.a=t2.a. But

3279

10815

the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until

3280

t4.a=t2.a becomes true.

10816

t4.a=t2.a becomes true.

3281

10817

In order not to re-evaluate the predicates that were already evaluated

3282

10818

as attached pushed down predicates, a pointer to the the first

3283

10819

most inner unmatched table is maintained in join_tab->first_unmatched.

3284

10820

Thus, when the first row from t5 with t5.a=t3.a is found

3285

this pointer for t5 is changed from t4 to t2.

10821

this pointer for t5 is changed from t4 to t2.

3286

10822

3287

10823

@par

3288

10824

@b STRUCTURE @b NOTES

3293

10829

@param join pointer to the structure providing all context info for

3294

10830

the query

3295

10831

@param join_tab the first next table of the execution plan to be retrieved

3296

@param end_records true when we need to perform final steps of retrival

10832

@param end_records true when we need to perform final steps of retrival

3297

10833

3298

10834

@return

3299

10835

return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.

3300

10836

3301

enum_nested_loop_state sub_select(Join *join, JoinTable *join_tab, bool end_of_records)

10837

int do_sj_reset(SJ_TMP_TABLE *sj_tbl);

10838

10839

enum_nested_loop_state

10840

sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3302

10841

{

3303

10842

join_tab->table->null_row=0;

3304

10843

if (end_of_records)

3306

10845

3307

10846

int error;

3308

10847

enum_nested_loop_state rc;

3309

ReadRecord *info= &join_tab->read_record;

10848

READ_RECORD *info= &join_tab->read_record;

10849

10850

if (join_tab->flush_weedout_table)

10851

{

10852

do_sj_reset(join_tab->flush_weedout_table);

10853

}

3310

10854

3311

10855

if (join->resume_nested_loop)

3312

10856

{

3334

10878

/* Set first_unmatched for the last inner table of this group */

3335

10879

join_tab->last_inner->first_unmatched= join_tab;

3336

10880

}

3337

join->session->row_count= 0;

10881

join->thd->row_count= 0;

3338

10882

3339

10883

error= (*join_tab->read_first_record)(join_tab);

3340

10884

rc= evaluate_join_record(join, join_tab, error);

3341

10885

}

3342

3343

3344

Note: psergey has added the 2nd part of the following condition; the

10886

10887

10888

Note: psergey has added the 2nd part of the following condition; the

3345

10889

change should probably be made in 5.1, too.

3346

10890

3347

10891

while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)

3359

10903

return rc;

3360

10904

}

3361

10905

3362

int safe_index_read(JoinTable *tab)

10906

10907

10908

10909

10910

SemiJoinDuplicateElimination: Weed out duplicate row combinations

10911

10912

SYNPOSIS

10913

do_sj_dups_weedout()

10914

10915

RETURN

10916

-1 Error

10917

1 The row combination is a duplicate (discard it)

10918

0 The row combination is not a duplicate (continue)

10919

10920

10921

int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl)

10922

{

10923

int error;

10924

SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;

10925

SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;

10926

unsigned char *ptr= sjtbl->tmp_table->record[0] + 1;

10927

unsigned char *nulls_ptr= ptr;

10928

10929

/* Put the the rowids tuple into table->record[0]: */

10930

10931

// 1. Store the length

10932

if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)

10933

{

10934

*ptr= (unsigned char)(sjtbl->rowid_len + sjtbl->null_bytes);

10935

ptr++;

10936

}

10937

else

10938

{

10939

int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);

10940

ptr += 2;

10941

}

10942

10943

// 2. Zero the null bytes

10944

if (sjtbl->null_bytes)

10945

{

10946

memset(ptr, 0, sjtbl->null_bytes);

10947

ptr += sjtbl->null_bytes;

10948

}

10949

10950

// 3. Put the rowids

10951

for (uint32_t i=0; tab != tab_end; tab++, i++)

10952

{

10953

handler *h= tab->join_tab->table->file;

10954

if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)

10955

{

10956

/* It's a NULL-complemented row */

10957

*(nulls_ptr + tab->null_byte) |= tab->null_bit;

10958

memset(ptr + tab->rowid_offset, 0, h->ref_length);

10959

}

10960

else

10961

{

10962

/* Copy the rowid value */

10963

if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)

10964

h->position(tab->join_tab->table->record[0]);

10965

memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);

10966

}

10967

}

10968

10969

error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);

10970

if (error)

10971

{

10972

/* create_myisam_from_heap will generate error if needed */

10973

if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&

10974

create_myisam_from_heap(thd, sjtbl->tmp_table, sjtbl->start_recinfo,

10975

&sjtbl->recinfo, error, 1))

10976

return -1;

10977

//return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;

10978

return 1;

10979

}

10980

return 0;

10981

}

10982

10983

10984

10985

SemiJoinDuplicateElimination: Reset the temporary table

10986

10987

10988

int do_sj_reset(SJ_TMP_TABLE *sj_tbl)

10989

{

10990

if (sj_tbl->tmp_table)

10991

return sj_tbl->tmp_table->file->ha_delete_all_rows();

10992

return 0;

10993

}

10994

10995

10996

Process one record of the nested loop join.

10997

10998

This function will evaluate parts of WHERE/ON clauses that are

10999

applicable to the partial record on hand and in case of success

11000

submit this record to the next level of the nested loop.

11001

11002

11003

static enum_nested_loop_state

11004

evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,

11005

int error)

11006

{

11007

bool not_used_in_distinct=join_tab->not_used_in_distinct;

11008

ha_rows found_records=join->found_records;

11009

COND *select_cond= join_tab->select_cond;

11010

11011

if (error > 0 || (join->thd->is_error())) // Fatal error

11012

return NESTED_LOOP_ERROR;

11013

if (error < 0)

11014

return NESTED_LOOP_NO_MORE_ROWS;

11015

if (join->thd->killed) // Aborted by user

11016

{

11017

join->thd->send_kill_message();

11018

return NESTED_LOOP_KILLED; /* purecov: inspected */

11019

}

11020

if (!select_cond || select_cond->val_int())

11021

{

11022

11023

There is no select condition or the attached pushed down

11024

condition is true => a match is found.

11025

11026

bool found= 1;

11027

while (join_tab->first_unmatched && found)

11028

{

11029

11030

The while condition is always false if join_tab is not

11031

the last inner join table of an outer join operation.

11032

11033

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11034

11035

Mark that a match for current outer table is found.

11036

This activates push down conditional predicates attached

11037

to the all inner tables of the outer join.

11038

11039

first_unmatched->found= 1;

11040

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11041

{

11042

if (tab->table->reginfo.not_exists_optimize)

11043

return NESTED_LOOP_NO_MORE_ROWS;

11044

/* Check all predicates that has just been activated. */

11045

11046

Actually all predicates non-guarded by first_unmatched->found

11047

will be re-evaluated again. It could be fixed, but, probably,

11048

it's not worth doing now.

11049

11050

if (tab->select_cond && !tab->select_cond->val_int())

11051

{

11052

/* The condition attached to table tab is false */

11053

if (tab == join_tab)

11054

found= 0;

11055

else

11056

{

11057

11058

Set a return point if rejected predicate is attached

11059

not to the last table of the current nest level.

11060

11061

join->return_tab= tab;

11062

return NESTED_LOOP_OK;

11063

}

11064

}

11065

}

11066

11067

Check whether join_tab is not the last inner table

11068

for another embedding outer join.

11069

11070

if ((first_unmatched= first_unmatched->first_upper) &&

11071

first_unmatched->last_inner != join_tab)

11072

first_unmatched= 0;

11073

join_tab->first_unmatched= first_unmatched;

11074

}

11075

11076

JOIN_TAB *return_tab= join->return_tab;

11077

join_tab->found_match= true;

11078

if (join_tab->check_weed_out_table)

11079

{

11080

int res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table);

11081

if (res == -1)

11082

return NESTED_LOOP_ERROR;

11083

if (res == 1)

11084

return NESTED_LOOP_OK;

11085

}

11086

else if (join_tab->do_firstmatch)

11087

{

11088

11089

We should return to the join_tab->do_firstmatch after we have

11090

enumerated all the suffixes for current prefix row combination

11091

11092

return_tab= join_tab->do_firstmatch;

11093

}

11094

11095

11096

It was not just a return to lower loop level when one

11097

of the newly activated predicates is evaluated as false

11098

(See above join->return_tab= tab).

11099

11100

join->examined_rows++;

11101

join->thd->row_count++;

11102

11103

if (found)

11104

{

11105

enum enum_nested_loop_state rc;

11106

/* A match from join_tab is found for the current partial join. */

11107

rc= (*join_tab->next_select)(join, join_tab+1, 0);

11108

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11109

return rc;

11110

if (return_tab < join->return_tab)

11111

join->return_tab= return_tab;

11112

11113

if (join->return_tab < join_tab)

11114

return NESTED_LOOP_OK;

11115

11116

Test if this was a SELECT DISTINCT query on a table that

11117

was not in the field list; In this case we can abort if

11118

we found a row, as no new rows can be added to the result.

11119

11120

if (not_used_in_distinct && found_records != join->found_records)

11121

return NESTED_LOOP_NO_MORE_ROWS;

11122

}

11123

else

11124

join_tab->read_record.file->unlock_row();

11125

}

11126

else

11127

{

11128

11129

The condition pushed down to the table join_tab rejects all rows

11130

with the beginning coinciding with the current partial join.

11131

11132

join->examined_rows++;

11133

join->thd->row_count++;

11134

join_tab->read_record.file->unlock_row();

11135

}

11136

return NESTED_LOOP_OK;

11137

}

11138

11139

11140

/**

11141

11142

@details

11143

Construct a NULL complimented partial join record and feed it to the next

11144

level of the nested loop. This function is used in case we have

11145

an OUTER join and no matching record was found.

11146

11147

11148

static enum_nested_loop_state

11149

evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab)

11150

{

11151

11152

The table join_tab is the first inner table of a outer join operation

11153

and no matches has been found for the current outer row.

11154

11155

JOIN_TAB *last_inner_tab= join_tab->last_inner;

11156

/* Cache variables for faster loop */

11157

COND *select_cond;

11158

for ( ; join_tab <= last_inner_tab ; join_tab++)

11159

{

11160

/* Change the the values of guard predicate variables. */

11161

join_tab->found= 1;

11162

join_tab->not_null_compl= 0;

11163

/* The outer row is complemented by nulls for each inner tables */

11164

restore_record(join_tab->table,s->default_values); // Make empty record

11165

mark_as_null_row(join_tab->table); // For group by without error

11166

select_cond= join_tab->select_cond;

11167

/* Check all attached conditions for inner table rows. */

11168

if (select_cond && !select_cond->val_int())

11169

return NESTED_LOOP_OK;

11170

}

11171

join_tab--;

11172

11173

The row complemented by nulls might be the first row

11174

of embedding outer joins.

11175

If so, perform the same actions as in the code

11176

for the first regular outer join row above.

11177

11178

for ( ; ; )

11179

{

11180

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11181

if ((first_unmatched= first_unmatched->first_upper) &&

11182

first_unmatched->last_inner != join_tab)

11183

first_unmatched= 0;

11184

join_tab->first_unmatched= first_unmatched;

11185

if (!first_unmatched)

11186

break;

11187

first_unmatched->found= 1;

11188

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11189

{

11190

if (tab->select_cond && !tab->select_cond->val_int())

11191

{

11192

join->return_tab= tab;

11193

return NESTED_LOOP_OK;

11194

}

11195

}

11196

}

11197

11198

The row complemented by nulls satisfies all conditions

11199

attached to inner tables.

11200

Send the row complemented by nulls to be joined with the

11201

remaining tables.

11202

11203

return (*join_tab->next_select)(join, join_tab+1, 0);

11204

}

11205

11206

11207

static enum_nested_loop_state

11208

flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skip_last)

11209

{

11210

enum_nested_loop_state rc= NESTED_LOOP_OK;

11211

int error;

11212

READ_RECORD *info;

11213

11214

join_tab->table->null_row= 0;

11215

if (!join_tab->cache.records)

11216

return NESTED_LOOP_OK; /* Nothing to do */

11217

if (skip_last)

11218

(void) store_record_in_cache(&join_tab->cache); // Must save this for later

11219

if (join_tab->use_quick == 2)

11220

{

11221

if (join_tab->select->quick)

11222

{ /* Used quick select last. reset it */

11223

delete join_tab->select->quick;

11224

join_tab->select->quick=0;

11225

}

11226

}

11227

/* read through all records */

11228

if ((error=join_init_read_record(join_tab)))

11229

{

11230

reset_cache_write(&join_tab->cache);

11231

return error < 0 ? NESTED_LOOP_NO_MORE_ROWS: NESTED_LOOP_ERROR;

11232

}

11233

11234

for (JOIN_TAB *tmp=join->join_tab; tmp != join_tab ; tmp++)

11235

{

11236

tmp->status=tmp->table->status;

11237

tmp->table->status=0;

11238

}

11239

11240

info= &join_tab->read_record;

11241

11242

{

11243

if (join->thd->killed)

11244

{

11245

join->thd->send_kill_message();

11246

return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */

11247

}

11248

SQL_SELECT *select=join_tab->select;

11249

if (rc == NESTED_LOOP_OK &&

11250

(!join_tab->cache.select || !join_tab->cache.select->skip_record()))

11251

{

11252

uint32_t i;

11253

reset_cache_read(&join_tab->cache);

11254

for (i=(join_tab->cache.records- (skip_last ? 1 : 0)) ; i-- > 0 ;)

11255

{

11256

read_cached_record(join_tab);

11257

if (!select || !select->skip_record())

11258

{

11259

int res= 0;

11260

if (!join_tab->check_weed_out_table ||

11261

!(res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table)))

11262

{

11263

rc= (join_tab->next_select)(join,join_tab+1,0);

11264

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11265

{

11266

reset_cache_write(&join_tab->cache);

11267

return rc;

11268

}

11269

}

11270

if (res == -1)

11271

return NESTED_LOOP_ERROR;

11272

}

11273

}

11274

}

11275

} while (!(error=info->read_record(info)));

11276

11277

if (skip_last)

11278

read_cached_record(join_tab); // Restore current record

11279

reset_cache_write(&join_tab->cache);

11280

if (error > 0) // Fatal error

11281

return NESTED_LOOP_ERROR; /* purecov: inspected */

11282

for (JOIN_TAB *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)

11283

tmp2->table->status=tmp2->status;

11284

return NESTED_LOOP_OK;

11285

}

11286

11287

int safe_index_read(JOIN_TAB *tab)

3363

11288

{

3364

11289

int error;

3365

11290

Table *table= tab->table;

3366

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11291

if ((error=table->file->index_read_map(table->record[0],

3367

11292

tab->ref.key_buff,

3368

11293

make_prev_keypart_map(tab->ref.key_parts),

3369

11294

HA_READ_KEY_EXACT)))

3371

11296

return 0;

3372

11297

}

3373

11298

11299

11300

static int

11301

join_read_const_table(JOIN_TAB *tab, POSITION *pos)

11302

{

11303

int error;

11304

Table *table=tab->table;

11305

table->const_table=1;

11306

table->null_row=0;

11307

table->status=STATUS_NO_RECORD;

11308

11309

if (tab->type == JT_SYSTEM)

11310

{

11311

if ((error=join_read_system(tab)))

11312

{ // Info for DESCRIBE

11313

tab->info="const row not found";

11314

/* Mark for EXPLAIN that the row was not found */

11315

pos->records_read=0.0;

11316

pos->ref_depend_map= 0;

11317

if (!table->maybe_null || error > 0)

11318

return(error);

11319

}

11320

}

11321

else

11322

{

11323

if (!table->key_read && table->covering_keys.is_set(tab->ref.key) &&

11324

!table->no_keyread &&

11325

(int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY)

11326

{

11327

table->key_read=1;

11328

table->file->extra(HA_EXTRA_KEYREAD);

11329

tab->index= tab->ref.key;

11330

}

11331

error=join_read_const(tab);

11332

if (table->key_read)

11333

{

11334

table->key_read=0;

11335

table->file->extra(HA_EXTRA_NO_KEYREAD);

11336

}

11337

if (error)

11338

{

11339

tab->info="unique row not found";

11340

/* Mark for EXPLAIN that the row was not found */

11341

pos->records_read=0.0;

11342

pos->ref_depend_map= 0;

11343

if (!table->maybe_null || error > 0)

11344

return(error);

11345

}

11346

}

11347

if (*tab->on_expr_ref && !table->null_row)

11348

{

11349

if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))

11350

mark_as_null_row(table);

11351

}

11352

if (!table->null_row)

11353

table->maybe_null=0;

11354

11355

/* Check appearance of new constant items in Item_equal objects */

11356

JOIN *join= tab->join;

11357

if (join->conds)

11358

update_const_equal_items(join->conds, tab);

11359

TableList *tbl;

11360

for (tbl= join->select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)

11361

{

11362

TableList *embedded;

11363

TableList *embedding= tbl;

11364

11365

{

11366

embedded= embedding;

11367

if (embedded->on_expr)

11368

update_const_equal_items(embedded->on_expr, tab);

11369

embedding= embedded->embedding;

11370

}

11371

while (embedding &&

11372

embedding->nested_join->join_list.head() == embedded);

11373

}

11374

11375

return(0);

11376

}

11377

11378

11379

static int

11380

join_read_system(JOIN_TAB *tab)

11381

{

11382

Table *table= tab->table;

11383

int error;

11384

if (table->status & STATUS_GARBAGE) // If first read

11385

{

11386

if ((error=table->file->read_first_row(table->record[0],

11387

table->s->primary_key)))

11388

{

11389

if (error != HA_ERR_END_OF_FILE)

11390

return table->report_error(error);

11391

mark_as_null_row(tab->table);

11392

empty_record(table); // Make empty record

11393

return -1;

11394

}

11395

store_record(table,record[1]);

11396

}

11397

else if (!table->status) // Only happens with left join

11398

restore_record(table,record[1]); // restore old record

11399

table->null_row=0;

11400

return table->status ? -1 : 0;

11401

}

11402

11403

3374

11404

/**

3375

11405

Read a (constant) table when there is at most one matching row.

3376

11406

3383

11413

@retval

3384

11414

1 Got an error (other than row not found) during read

3385

11415

3386

int join_read_const(JoinTable *tab)

11416

11417

static int

11418

join_read_const(JOIN_TAB *tab)

3387

11419

{

3388

11420

int error;

3389

11421

Table *table= tab->table;

3390

11422

if (table->status & STATUS_GARBAGE) // If first read

3391

11423

{

3392

11424

table->status= 0;

3393

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

3394

error= HA_ERR_KEY_NOT_FOUND;

11425

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

11426

error=HA_ERR_KEY_NOT_FOUND;

3395

11427

else

3396

11428

{

3397

error=table->cursor->index_read_idx_map(table->getInsertRecord(),tab->ref.key,

11429

error=table->file->index_read_idx_map(table->record[0],tab->ref.key,

3398

11430

(unsigned char*) tab->ref.key_buff,

3399

11431

make_prev_keypart_map(tab->ref.key_parts),

3400

11432

HA_READ_KEY_EXACT);

3402

11434

if (error)

3403

11435

{

3404

11436

table->status= STATUS_NOT_FOUND;

3405

tab->table->mark_as_null_row();

3406

table->emptyRecord();

11437

mark_as_null_row(tab->table);

11438

empty_record(table);

3407

11439

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3408

return table->report_error(error);

11440

return table->report_error(error);

3409

11441

return -1;

3410

11442

}

3411

table->storeRecord();

11443

store_record(table,record[1]);

3412

11444

}

3413

11445

else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join

3414

11446

{

3415

11447

table->status=0;

3416

table->restoreRecord(); // restore old record

11448

restore_record(table,record[1]); // restore old record

3417

11449

}

3418

11450

table->null_row=0;

3419

11451

return table->status ? -1 : 0;

3420

11452

}

3421

11453

11454

3422

11455

3423

11456

eq_ref access method implementation: "read_first" function

3424

11457

3425

11458

SYNOPSIS

3426

11459

join_read_key()

3427

tab JoinTable of the accessed table

11460

tab JOIN_TAB of the accessed table

3428

11461

3429

11462

DESCRIPTION

3430

11463

This is "read_fist" function for the "ref" access method. The difference

3432

11465

3433

11466

RETURN

3434

11467

0 - Ok

3435

-1 - Row not found

11468

-1 - Row not found

3436

11469

1 - Error

3437

11470

3438

int join_read_key(JoinTable *tab)

11471

11472

static int

11473

join_read_key(JOIN_TAB *tab)

3439

11474

{

3440

11475

int error;

3441

11476

Table *table= tab->table;

3442

11477

3443

if (!table->cursor->inited)

11478

if (!table->file->inited)

3444

11479

{

3445

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3446

if (error != 0)

3447

{

3448

table->print_error(error, MYF(0));

3449

}

11480

table->file->ha_index_init(tab->ref.key, tab->sorted);

3450

11481

}

3451

11482

3452

/* @todo Why don't we do "Late NULLs Filtering" here? */

11483

/* TODO: Why don't we do "Late NULLs Filtering" here? */

3453

11484

if (cmp_buffer_with_ref(tab) ||

3454

11485

(table->status & (STATUS_GARBAGE | STATUS_NO_PARENT | STATUS_NULL_ROW)))

3455

11486

{

3458

11489

table->status=STATUS_NOT_FOUND;

3459

11490

return -1;

3460

11491

}

3461

error=table->cursor->index_read_map(table->getInsertRecord(),

11492

error=table->file->index_read_map(table->record[0],

3462

11493

tab->ref.key_buff,

3463

11494

make_prev_keypart_map(tab->ref.key_parts),

3464

11495

HA_READ_KEY_EXACT);

3469

11500

return table->status ? -1 : 0;

3470

11501

}

3471

11502

11503

3472

11504

3473

11505

ref access method implementation: "read_first" function

3474

11506

3475

11507

SYNOPSIS

3476

11508

join_read_always_key()

3477

tab JoinTable of the accessed table

11509

tab JOIN_TAB of the accessed table

3478

11510

3479

11511

DESCRIPTION

3480

This is "read_first" function for the "ref" access method.

3481

11512

This is "read_fist" function for the "ref" access method.

11513

3482

11514

The functon must leave the index initialized when it returns.

3483

11515

ref_or_null access implementation depends on that.

3484

11516

3485

11517

RETURN

3486

11518

0 - Ok

3487

-1 - Row not found

11519

-1 - Row not found

3488

11520

1 - Error

3489

11521

3490

int join_read_always_key(JoinTable *tab)

11522

11523

static int

11524

join_read_always_key(JOIN_TAB *tab)

3491

11525

{

3492

11526

int error;

3493

11527

Table *table= tab->table;

3494

11528

3495

11529

/* Initialize the index first */

3496

if (!table->cursor->inited)

3497

{

3498

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3499

if (error != 0)

3500

return table->report_error(error);

3501

}

3502

11530

if (!table->file->inited)

11531

table->file->ha_index_init(tab->ref.key, tab->sorted);

11532

3503

11533

/* Perform "Late NULLs Filtering" (see internals manual for explanations) */

3504

11534

for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)

3505

11535

{

3507

11537

return -1;

3508

11538

}

3509

11539

3510

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11540

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3511

11541

return -1;

3512

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11542

if ((error=table->file->index_read_map(table->record[0],

3513

11543

tab->ref.key_buff,

3514

11544

make_prev_keypart_map(tab->ref.key_parts),

3515

11545

HA_READ_KEY_EXACT)))

3516

11546

{

3517

11547

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3518

11548

return table->report_error(error);

3519

return -1;

11549

return -1; /* purecov: inspected */

3520

11550

}

3521

3522

11551

return 0;

3523

11552

}

3524

11553

11554

3525

11555

/**

3526

This function is used when optimizing away ORDER BY in

3527

SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC.

11556

This function is used when optimizing away order_st BY in

11557

SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.

3528

11558

3529

int join_read_last_key(JoinTable *tab)

11559

11560

static int

11561

join_read_last_key(JOIN_TAB *tab)

3530

11562

{

3531

11563

int error;

3532

11564

Table *table= tab->table;

3533

11565

3534

if (!table->cursor->inited)

3535

{

3536

error= table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3537

if (error != 0)

3538

return table->report_error(error);

3539

}

3540

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11566

if (!table->file->inited)

11567

table->file->ha_index_init(tab->ref.key, tab->sorted);

11568

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3541

11569

return -1;

3542

if ((error=table->cursor->index_read_last_map(table->getInsertRecord(),

11570

if ((error=table->file->index_read_last_map(table->record[0],

3543

11571

tab->ref.key_buff,

3544

11572

make_prev_keypart_map(tab->ref.key_parts))))

3545

11573

{

3546

11574

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3547

11575

return table->report_error(error);

3548

return -1;

11576

return -1; /* purecov: inspected */

3549

11577

}

3550

11578

return 0;

3551

11579

}

3552

11580

3553

int join_no_more_records(ReadRecord *)

11581

11582

/* ARGSUSED */

11583

static int

11584

join_no_more_records(READ_RECORD *info __attribute__((unused)))

3554

11585

{

3555

11586

return -1;

3556

11587

}

3557

11588

3558

int join_read_next_same_diff(ReadRecord *info)

11589

static int

11590

join_read_next_same_diff(READ_RECORD *info)

3559

11591

{

3560

11592

Table *table= info->table;

3561

JoinTable *tab=table->reginfo.join_tab;

11593

JOIN_TAB *tab=table->reginfo.join_tab;

3562

11594

if (tab->insideout_match_tab->found_match)

3563

11595

{

3564

KeyInfo *key= tab->table->key_info + tab->index;

3565

11596

KEY *key= tab->table->key_info + tab->index;

11597

3566

11598

{

3567

11599

int error;

3568

11600

/* Save index tuple from record to the buffer */

3569

11601

key_copy(tab->insideout_buf, info->record, key, 0);

3570

11602

3571

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11603

if ((error=table->file->index_next_same(table->record[0],

3572

11604

tab->ref.key_buff,

3573

11605

tab->ref.key_length)))

3574

11606

{

3577

11609

table->status= STATUS_GARBAGE;

3578

11610

return -1;

3579

11611

}

3580

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11612

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3581

11613

tab->insideout_buf, key->key_length));

3582

11614

tab->insideout_match_tab->found_match= 0;

3583

11615

return 0;

3586

11618

return join_read_next_same(info);

3587

11619

}

3588

11620

3589

int join_read_next_same(ReadRecord *info)

11621

static int

11622

join_read_next_same(READ_RECORD *info)

3590

11623

{

3591

11624

int error;

3592

11625

Table *table= info->table;

3593

JoinTable *tab=table->reginfo.join_tab;

11626

JOIN_TAB *tab=table->reginfo.join_tab;

3594

11627

3595

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11628

if ((error=table->file->index_next_same(table->record[0],

3596

11629

tab->ref.key_buff,

3597

11630

tab->ref.key_length)))

3598

11631

{

3601

11634

table->status= STATUS_GARBAGE;

3602

11635

return -1;

3603

11636

}

3604

3605

11637

return 0;

3606

11638

}

3607

11639

3608

int join_read_prev_same(ReadRecord *info)

11640

11641

static int

11642

join_read_prev_same(READ_RECORD *info)

3609

11643

{

3610

11644

int error;

3611

11645

Table *table= info->table;

3612

JoinTable *tab=table->reginfo.join_tab;

11646

JOIN_TAB *tab=table->reginfo.join_tab;

3613

11647

3614

if ((error=table->cursor->index_prev(table->getInsertRecord())))

11648

if ((error=table->file->index_prev(table->record[0])))

3615

11649

return table->report_error(error);

3616

11650

if (key_cmp_if_same(table, tab->ref.key_buff, tab->ref.key,

3617

11651

tab->ref.key_length))

3622

11656

return error;

3623

11657

}

3624

11658

3625

int join_init_quick_read_record(JoinTable *tab)

11659

11660

static int

11661

join_init_quick_read_record(JOIN_TAB *tab)

3626

11662

{

3627

11663

if (test_if_quick_select(tab) == -1)

3628

11664

return -1; /* No possible records */

3629

11665

return join_init_read_record(tab);

3630

11666

}

3631

11667

3632

int init_read_record_seq(JoinTable *tab)

11668

11669

int rr_sequential(READ_RECORD *info);

11670

int init_read_record_seq(JOIN_TAB *tab)

3633

11671

{

3634

tab->read_record.init_reard_record_sequential();

3635

3636

if (tab->read_record.cursor->startTableScan(1))

11672

tab->read_record.read_record= rr_sequential;

11673

if (tab->read_record.file->ha_rnd_init(1))

3637

11674

return 1;

3638

11675

return (*tab->read_record.read_record)(&tab->read_record);

3639

11676

}

3640

11677

3641

int test_if_quick_select(JoinTable *tab)

11678

static int

11679

test_if_quick_select(JOIN_TAB *tab)

3642

11680

{

3643

safe_delete(tab->select->quick);

3644

3645

return tab->select->test_quick_select(tab->join->session, tab->keys,

3646

(table_map) 0, HA_POS_ERROR, 0, false);

11681

delete tab->select->quick;

11682

tab->select->quick=0;

11683

return tab->select->test_quick_select(tab->join->thd, tab->keys,

11684

(table_map) 0, HA_POS_ERROR, 0,

11685

false);

3647

11686

}

3648

11687

3649

int join_init_read_record(JoinTable *tab)

11688

11689

static int

11690

join_init_read_record(JOIN_TAB *tab)

3650

11691

{

3651

11692

if (tab->select && tab->select->quick && tab->select->quick->reset())

3652

11693

return 1;

3653

3654

if (tab->read_record.init_read_record(tab->join->session, tab->table, tab->select, 1, true))

3655

return 1;

3656

11694

init_read_record(&tab->read_record, tab->join->thd, tab->table,

11695

tab->select,1,1);

3657

11696

return (*tab->read_record.read_record)(&tab->read_record);

3658

11697

}

3659

11698

3660

int join_read_first(JoinTable *tab)

11699

11700

static int

11701

join_read_first(JOIN_TAB *tab)

3661

11702

{

3662

11703

int error;

3663

11704

Table *table=tab->table;

3664

if (!table->key_read && table->covering_keys.test(tab->index) &&

11705

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3665

11706

!table->no_keyread)

3666

11707

{

3667

table->key_read= 1;

3668

table->cursor->extra(HA_EXTRA_KEYREAD);

11708

table->key_read=1;

11709

table->file->extra(HA_EXTRA_KEYREAD);

3669

11710

}

3670

tab->table->status= 0;

11711

tab->table->status=0;

3671

11712

tab->read_record.table=table;

3672

tab->read_record.cursor=table->cursor;

11713

tab->read_record.file=table->file;

3673

11714

tab->read_record.index=tab->index;

3674

tab->read_record.record=table->getInsertRecord();

11715

tab->read_record.record=table->record[0];

3675

11716

if (tab->insideout_match_tab)

3676

11717

{

3677

11718

tab->read_record.do_insideout_scan= tab;

3684

11725

tab->read_record.do_insideout_scan= 0;

3685

11726

}

3686

11727

3687

if (!table->cursor->inited)

3688

{

3689

error= table->cursor->startIndexScan(tab->index, tab->sorted);

3690

if (error != 0)

3691

{

3692

table->report_error(error);

3693

return -1;

3694

}

3695

}

3696

if ((error=tab->table->cursor->index_first(tab->table->getInsertRecord())))

11728

if (!table->file->inited)

11729

table->file->ha_index_init(tab->index, tab->sorted);

11730

if ((error=tab->table->file->index_first(tab->table->record[0])))

3697

11731

{

3698

11732

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3699

11733

table->report_error(error);

3700

11734

return -1;

3701

11735

}

3702

3703

11736

return 0;

3704

11737

}

3705

11738

3706

int join_read_next_different(ReadRecord *info)

11739

11740

static int

11741

join_read_next_different(READ_RECORD *info)

3707

11742

{

3708

JoinTable *tab= info->do_insideout_scan;

11743

JOIN_TAB *tab= info->do_insideout_scan;

3709

11744

if (tab->insideout_match_tab->found_match)

3710

11745

{

3711

KeyInfo *key= tab->table->key_info + tab->index;

3712

11746

KEY *key= tab->table->key_info + tab->index;

11747

3713

11748

{

3714

11749

int error;

3715

11750

/* Save index tuple from record to the buffer */

3716

11751

key_copy(tab->insideout_buf, info->record, key, 0);

3717

11752

3718

if ((error=info->cursor->index_next(info->record)))

11753

if ((error=info->file->index_next(info->record)))

3719

11754

return info->table->report_error(error);

3720

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11755

11756

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3721

11757

tab->insideout_buf, key->key_length));

3722

11758

tab->insideout_match_tab->found_match= 0;

3723

11759

return 0;

3726

11762

return join_read_next(info);

3727

11763

}

3728

11764

3729

int join_read_next(ReadRecord *info)

11765

11766

static int

11767

join_read_next(READ_RECORD *info)

3730

11768

{

3731

11769

int error;

3732

if ((error=info->cursor->index_next(info->record)))

11770

if ((error=info->file->index_next(info->record)))

3733

11771

return info->table->report_error(error);

3734

11772

return 0;

3735

11773

}

3736

11774

3737

int join_read_last(JoinTable *tab)

11775

11776

static int

11777

join_read_last(JOIN_TAB *tab)

3738

11778

{

3739

11779

Table *table=tab->table;

3740

11780

int error;

3741

if (!table->key_read && table->covering_keys.test(tab->index) &&

11781

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3742

11782

!table->no_keyread)

3743

11783

{

3744

11784

table->key_read=1;

3745

table->cursor->extra(HA_EXTRA_KEYREAD);

11785

table->file->extra(HA_EXTRA_KEYREAD);

3746

11786

}

3747

11787

tab->table->status=0;

3748

11788

tab->read_record.read_record=join_read_prev;

3749

11789

tab->read_record.table=table;

3750

tab->read_record.cursor=table->cursor;

11790

tab->read_record.file=table->file;

3751

11791

tab->read_record.index=tab->index;

3752

tab->read_record.record=table->getInsertRecord();

3753

if (!table->cursor->inited)

3754

{

3755

error= table->cursor->startIndexScan(tab->index, 1);

3756

if (error != 0)

3757

return table->report_error(error);

3758

}

3759

if ((error= tab->table->cursor->index_last(tab->table->getInsertRecord())))

11792

tab->read_record.record=table->record[0];

11793

if (!table->file->inited)

11794

table->file->ha_index_init(tab->index, 1);

11795

if ((error= tab->table->file->index_last(tab->table->record[0])))

3760

11796

return table->report_error(error);

3761

3762

11797

return 0;

3763

11798

}

3764

11799

3765

int join_read_prev(ReadRecord *info)

11800

11801

static int

11802

join_read_prev(READ_RECORD *info)

3766

11803

{

3767

11804

int error;

3768

if ((error= info->cursor->index_prev(info->record)))

11805

if ((error= info->file->index_prev(info->record)))

3769

11806

return info->table->report_error(error);

3770

3771

11807

return 0;

3772

11808

}

3773

11809

3774

11810

/**

3775

11811

Reading of key with key reference and one part that may be NULL.

3776

11812

3777

int join_read_always_key_or_null(JoinTable *tab)

11813

11814

int

11815

join_read_always_key_or_null(JOIN_TAB *tab)

3778

11816

{

3779

11817

int res;

3780

11818

3788

11826

return safe_index_read(tab);

3789

11827

}

3790

11828

3791

int join_read_next_same_or_null(ReadRecord *info)

11829

11830

int

11831

join_read_next_same_or_null(READ_RECORD *info)

3792

11832

{

3793

11833

int error;

3794

11834

if ((error= join_read_next_same(info)) >= 0)

3795

11835

return error;

3796

JoinTable *tab= info->table->reginfo.join_tab;

11836

JOIN_TAB *tab= info->table->reginfo.join_tab;

3797

11837

3798

11838

/* Test if we have already done a read after null key */

3799

11839

if (*tab->ref.null_ref_key)

3802

11842

return safe_index_read(tab); // then read null keys

3803

11843

}

3804

11844

3805

enum_nested_loop_state end_send_group(Join *join, JoinTable *, bool end_of_records)

11845

11846

/*****************************************************************************

11847

DESCRIPTION

11848

Functions that end one nested loop iteration. Different functions

11849

are used to support GROUP BY clause and to redirect records

11850

to a table (e.g. in case of SELECT into a temporary table) or to the

11851

network client.

11852

11853

RETURN VALUES

11854

NESTED_LOOP_OK - the record has been successfully handled

11855

NESTED_LOOP_ERROR - a fatal error (like table corruption)

11856

was detected

11857

NESTED_LOOP_KILLED - thread shutdown was requested while processing

11858

the record

11859

NESTED_LOOP_QUERY_LIMIT - the record has been successfully handled;

11860

additionally, the nested loop produced the

11861

number of rows specified in the LIMIT clause

11862

for the query

11863

NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;

11864

additionally, there is a cursor and the nested

11865

loop algorithm produced the number of rows

11866

that is specified for current cursor fetch

11867

operation.

11868

All return values except NESTED_LOOP_OK abort the nested loop.

11869

*****************************************************************************/

11870

11871

/* ARGSUSED */

11872

static enum_nested_loop_state

11873

end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11874

bool end_of_records)

11875

{

11876

if (!end_of_records)

11877

{

11878

int error;

11879

if (join->having && join->having->val_int() == 0)

11880

return(NESTED_LOOP_OK); // Didn't match having

11881

error=0;

11882

if (join->do_send_rows)

11883

error=join->result->send_data(*join->fields);

11884

if (error)

11885

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11886

if (++join->send_records >= join->unit->select_limit_cnt &&

11887

join->do_send_rows)

11888

{

11889

if (join->select_options & OPTION_FOUND_ROWS)

11890

{

11891

JOIN_TAB *jt=join->join_tab;

11892

if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group

11893

&& !join->send_group_parts && !join->having && !jt->select_cond &&

11894

!(jt->select && jt->select->quick) &&

11895

(jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&

11896

(jt->ref.key < 0))

11897

{

11898

/* Join over all rows in table; Return number of found rows */

11899

Table *table=jt->table;

11900

11901

join->select_options ^= OPTION_FOUND_ROWS;

11902

if (table->sort.record_pointers ||

11903

(table->sort.io_cache && my_b_inited(table->sort.io_cache)))

11904

{

11905

/* Using filesort */

11906

join->send_records= table->sort.found_records;

11907

}

11908

else

11909

{

11910

table->file->info(HA_STATUS_VARIABLE);

11911

join->send_records= table->file->stats.records;

11912

}

11913

}

11914

else

11915

{

11916

join->do_send_rows= 0;

11917

if (join->unit->fake_select_lex)

11918

join->unit->fake_select_lex->select_limit= 0;

11919

return(NESTED_LOOP_OK);

11920

}

11921

}

11922

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11923

}

11924

else if (join->send_records >= join->fetch_limit)

11925

{

11926

11927

There is a server side cursor and all rows for

11928

this fetch request are sent.

11929

11930

return(NESTED_LOOP_CURSOR_LIMIT);

11931

}

11932

}

11933

11934

return(NESTED_LOOP_OK);

11935

}

11936

11937

11938

/* ARGSUSED */

11939

enum_nested_loop_state

11940

end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11941

bool end_of_records)

3806

11942

{

3807

11943

int idx= -1;

3808

11944

enum_nested_loop_state ok_code= NESTED_LOOP_OK;

3810

11946

if (!join->first_record || end_of_records ||

3811

11947

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3812

11948

{

3813

if (join->first_record ||

11949

if (join->first_record ||

3814

11950

(end_of_records && !join->group && !join->group_optimized_away))

3815

11951

{

3816

11952

if (idx < (int) join->send_group_parts)

3817

11953

{

3818

int error=0;

3819

{

3820

if (!join->first_record)

3821

{

3822

List<Item>::iterator it(join->fields->begin());

3823

Item *item;

3824

/* No matching rows for group function */

3825

join->clear();

11954

int error=0;

11955

{

11956

if (!join->first_record)

11957

{

11958

List_iterator_fast<Item> it(*join->fields);

11959

Item *item;

11960

/* No matching rows for group function */

11961

join->clear();

3826

11962

3827

11963

while ((item= it++))

3828

11964

item->no_rows_in_result();

3829

}

3830

if (join->having && join->having->val_int() == 0)

3831

error= -1; // Didn't satisfy having

3832

else

3833

{

3834

if (join->do_send_rows)

3835

error=join->result->send_data(*join->fields) ? 1 : 0;

3836

join->send_records++;

3837

}

3838

if (join->rollup.getState() != Rollup::STATE_NONE && error <= 0)

3839

{

3840

if (join->rollup_send_data((uint32_t) (idx+1)))

3841

error= 1;

3842

}

3843

}

3844

if (error > 0)

3845

return(NESTED_LOOP_ERROR);

3846

if (end_of_records)

3847

return(NESTED_LOOP_OK);

3848

if (join->send_records >= join->unit->select_limit_cnt &&

3849

join->do_send_rows)

3850

{

3851

if (!(join->select_options & OPTION_FOUND_ROWS))

3852

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

3853

join->do_send_rows=0;

3854

join->unit->select_limit_cnt = HA_POS_ERROR;

11965

}

11966

if (join->having && join->having->val_int() == 0)

11967

error= -1; // Didn't satisfy having

11968

else

11969

{

11970

if (join->do_send_rows)

11971

error=join->result->send_data(*join->fields) ? 1 : 0;

11972

join->send_records++;

11973

}

11974

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

11975

{

11976

if (join->rollup_send_data((uint) (idx+1)))

11977

error= 1;

11978

}

11979

}

11980

if (error > 0)

11981

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11982

if (end_of_records)

11983

return(NESTED_LOOP_OK);

11984

if (join->send_records >= join->unit->select_limit_cnt &&

11985

join->do_send_rows)

11986

{

11987

if (!(join->select_options & OPTION_FOUND_ROWS))

11988

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11989

join->do_send_rows=0;

11990

join->unit->select_limit_cnt = HA_POS_ERROR;

3855

11991

}

3856

11992

else if (join->send_records >= join->fetch_limit)

3857

11993

{

3870

12006

else

3871

12007

{

3872

12008

if (end_of_records)

3873

return(NESTED_LOOP_OK);

12009

return(NESTED_LOOP_OK);

3874

12010

join->first_record=1;

3875

12011

test_if_item_cache_changed(join->group_fields);

3876

12012

}

3882

12018

3883

12019

copy_fields(&join->tmp_table_param);

3884

12020

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

3885

return(NESTED_LOOP_ERROR);

12021

return(NESTED_LOOP_ERROR);

3886

12022

return(ok_code);

3887

12023

}

3888

12024

}

3891

12027

return(NESTED_LOOP_OK);

3892

12028

}

3893

12029

3894

enum_nested_loop_state end_write_group(Join *join, JoinTable *, bool end_of_records)

12030

12031

/* ARGSUSED */

12032

enum_nested_loop_state

12033

end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12034

bool end_of_records)

12035

{

12036

Table *table=join->tmp_table;

12037

12038

if (join->thd->killed) // Aborted by user

12039

{

12040

join->thd->send_kill_message();

12041

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12042

}

12043

if (!end_of_records)

12044

{

12045

copy_fields(&join->tmp_table_param);

12046

copy_funcs(join->tmp_table_param.items_to_copy);

12047

#ifdef TO_BE_DELETED

12048

if (!table->uniques) // If not unique handling

12049

{

12050

/* Copy null values from group to row */

12051

order_st *group;

12052

for (group=table->group ; group ; group=group->next)

12053

{

12054

Item *item= *group->item;

12055

if (item->maybe_null)

12056

{

12057

Field *field=item->get_tmp_table_field();

12058

field->ptr[-1]= (unsigned char) (field->is_null() ? 1 : 0);

12059

}

12060

}

12061

}

12062

#endif

12063

if (!join->having || join->having->val_int())

12064

{

12065

int error;

12066

join->found_records++;

12067

if ((error=table->file->ha_write_row(table->record[0])))

12068

{

12069

if (!table->file->is_fatal_error(error, HA_CHECK_DUP))

12070

goto end;

12071

if (create_myisam_from_heap(join->thd, table,

12072

join->tmp_table_param.start_recinfo,

12073

&join->tmp_table_param.recinfo,

12074

error, 1))

12075

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12076

table->s->uniques=0; // To ensure rows are the same

12077

}

12078

if (++join->send_records >= join->tmp_table_param.end_write_records &&

12079

join->do_send_rows)

12080

{

12081

if (!(join->select_options & OPTION_FOUND_ROWS))

12082

return(NESTED_LOOP_QUERY_LIMIT);

12083

join->do_send_rows=0;

12084

join->unit->select_limit_cnt = HA_POS_ERROR;

12085

return(NESTED_LOOP_OK);

12086

}

12087

}

12088

}

12089

end:

12090

return(NESTED_LOOP_OK);

12091

}

12092

12093

/* ARGSUSED */

12094

/** Group by searching after group record and updating it if possible. */

12095

12096

static enum_nested_loop_state

12097

end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12098

bool end_of_records)

12099

{

12100

Table *table=join->tmp_table;

12101

order_st *group;

12102

int error;

12103

12104

if (end_of_records)

12105

return(NESTED_LOOP_OK);

12106

if (join->thd->killed) // Aborted by user

12107

{

12108

join->thd->send_kill_message();

12109

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12110

}

12111

12112

join->found_records++;

12113

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12114

/* Make a key of group index */

12115

for (group=table->group ; group ; group=group->next)

12116

{

12117

Item *item= *group->item;

12118

item->save_org_in_field(group->field);

12119

/* Store in the used key if the field was 0 */

12120

if (item->maybe_null)

12121

group->buff[-1]= (char) group->field->is_null();

12122

}

12123

if (!table->file->index_read_map(table->record[1],

12124

join->tmp_table_param.group_buff,

12125

HA_WHOLE_KEY,

12126

HA_READ_KEY_EXACT))

12127

{ /* Update old record */

12128

restore_record(table,record[1]);

12129

update_tmptable_sum_func(join->sum_funcs,table);

12130

if ((error=table->file->ha_update_row(table->record[1],

12131

table->record[0])))

12132

{

12133

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12134

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12135

}

12136

return(NESTED_LOOP_OK);

12137

}

12138

12139

12140

Copy null bits from group key to table

12141

We can't copy all data as the key may have different format

12142

as the row data (for example as with VARCHAR keys)

12143

12144

KEY_PART_INFO *key_part;

12145

for (group=table->group,key_part=table->key_info[0].key_part;

12146

group ;

12147

group=group->next,key_part++)

12148

{

12149

if (key_part->null_bit)

12150

memcpy(table->record[0]+key_part->offset, group->buff, 1);

12151

}

12152

init_tmptable_sum_functions(join->sum_funcs);

12153

copy_funcs(join->tmp_table_param.items_to_copy);

12154

if ((error=table->file->ha_write_row(table->record[0])))

12155

{

12156

if (create_myisam_from_heap(join->thd, table,

12157

join->tmp_table_param.start_recinfo,

12158

&join->tmp_table_param.recinfo,

12159

error, 0))

12160

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12161

/* Change method to update rows */

12162

table->file->ha_index_init(0, 0);

12163

join->join_tab[join->tables-1].next_select=end_unique_update;

12164

}

12165

join->send_records++;

12166

return(NESTED_LOOP_OK);

12167

}

12168

12169

12170

/** Like end_update, but this is done with unique constraints instead of keys. */

12171

12172

static enum_nested_loop_state

12173

end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12174

bool end_of_records)

12175

{

12176

Table *table=join->tmp_table;

12177

int error;

12178

12179

if (end_of_records)

12180

return(NESTED_LOOP_OK);

12181

if (join->thd->killed) // Aborted by user

12182

{

12183

join->thd->send_kill_message();

12184

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12185

}

12186

12187

init_tmptable_sum_functions(join->sum_funcs);

12188

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12189

copy_funcs(join->tmp_table_param.items_to_copy);

12190

12191

if (!(error=table->file->ha_write_row(table->record[0])))

12192

join->send_records++; // New group

12193

else

12194

{

12195

if ((int) table->file->get_dup_key(error) < 0)

12196

{

12197

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12198

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12199

}

12200

if (table->file->rnd_pos(table->record[1],table->file->dup_ref))

12201

{

12202

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12203

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12204

}

12205

restore_record(table,record[1]);

12206

update_tmptable_sum_func(join->sum_funcs,table);

12207

if ((error=table->file->ha_update_row(table->record[1],

12208

table->record[0])))

12209

{

12210

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12211

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12212

}

12213

}

12214

return(NESTED_LOOP_OK);

12215

}

12216

12217

12218

/* ARGSUSED */

12219

enum_nested_loop_state

12220

end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12221

bool end_of_records)

3895

12222

{

3896

12223

Table *table=join->tmp_table;

3897

12224

int idx= -1;

3898

12225

3899

if (join->session->getKilled())

12226

if (join->thd->killed)

3900

12227

{ // Aborted by user

3901

join->session->send_kill_message();

3902

return NESTED_LOOP_KILLED;

12228

join->thd->send_kill_message();

12229

return(NESTED_LOOP_KILLED); /* purecov: inspected */

3903

12230

}

3904

12231

if (!join->first_record || end_of_records ||

3905

12232

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3909

12236

int send_group_parts= join->send_group_parts;

3910

12237

if (idx < send_group_parts)

3911

12238

{

3912

if (!join->first_record)

3913

{

3914

/* No matching rows for group function */

3915

join->clear();

3916

}

3917

copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);

3918

if (!join->having || join->having->val_int())

3919

{

3920

int error= table->cursor->insertRecord(table->getInsertRecord());

3921

3922

if (error)

3923

{

3924

my_error(ER_USE_SQL_BIG_RESULT, MYF(0));

3925

return NESTED_LOOP_ERROR;

3926

}

3927

}

3928

if (join->rollup.getState() != Rollup::STATE_NONE)

3929

{

3930

if (join->rollup_write_data((uint32_t) (idx+1), table))

3931

return NESTED_LOOP_ERROR;

3932

}

3933

if (end_of_records)

3934

return NESTED_LOOP_OK;

12239

if (!join->first_record)

12240

{

12241

/* No matching rows for group function */

12242

join->clear();

12243

}

12244

copy_sum_funcs(join->sum_funcs,

12245

join->sum_funcs_end[send_group_parts]);

12246

if (!join->having || join->having->val_int())

12247

{

12248

int error= table->file->ha_write_row(table->record[0]);

12249

if (error && create_myisam_from_heap(join->thd, table,

12250

join->tmp_table_param.start_recinfo,

12251

&join->tmp_table_param.recinfo,

12252

error, 0))

12253

return(NESTED_LOOP_ERROR);

12254

}

12255

if (join->rollup.state != ROLLUP::STATE_NONE)

12256

{

12257

if (join->rollup_write_data((uint) (idx+1), table))

12258

return(NESTED_LOOP_ERROR);

12259

}

12260

if (end_of_records)

12261

return(NESTED_LOOP_OK);

3935

12262

}

3936

12263

}

3937

12264

else

3938

12265

{

3939

12266

if (end_of_records)

3940

return NESTED_LOOP_OK;

12267

return(NESTED_LOOP_OK);

3941

12268

join->first_record=1;

3942

12269

test_if_item_cache_changed(join->group_fields);

3943

12270

}

3944

12271

if (idx < (int) join->send_group_parts)

3945

12272

{

3946

12273

copy_fields(&join->tmp_table_param);

3947

if (copy_funcs(join->tmp_table_param.items_to_copy, join->session))

3948

return NESTED_LOOP_ERROR;

12274

copy_funcs(join->tmp_table_param.items_to_copy);

3949

12275

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

3950

return NESTED_LOOP_ERROR;

3951

return NESTED_LOOP_OK;

12276

return(NESTED_LOOP_ERROR);

12277

return(NESTED_LOOP_OK);

3952

12278

}

3953

12279

}

3954

12280

if (update_sum_func(join->sum_funcs))

3955

return NESTED_LOOP_ERROR;

3956

return NESTED_LOOP_OK;

12281

return(NESTED_LOOP_ERROR);

12282

return(NESTED_LOOP_OK);

3957

12283

}

3958

12284

12285

3959

12286

/*****************************************************************************

3960

12287

Remove calculation with tables that aren't yet read. Remove also tests

3961

12288

against fields that are read through key where the table is not a

3962

12289

outer join table.

3963

12290

We can't remove tests that are made against columns which are stored

3964

12291

in sorted order.

12292

*****************************************************************************/

12293

12294

/**

3965

12295

@return

3966

1 if right_item used is a removable reference key on left_item

3967

0 otherwise.

3968

****************************************************************************/

3969

bool test_if_ref(Item_field *left_item,Item *right_item)

12296

1 if right_item is used removable reference key on left_item

12297

12298

12299

static bool test_if_ref(Item_field *left_item,Item *right_item)

3970

12300

{

3971

12301

Field *field=left_item->field;

3972

12302

// No need to change const test. We also have to keep tests on LEFT JOIN

3973

if (not field->getTable()->const_table && !field->getTable()->maybe_null)

12303

if (!field->table->const_table && !field->table->maybe_null)

3974

12304

{

3975

Item *ref_item=part_of_refkey(field->getTable(),field);

12305

Item *ref_item=part_of_refkey(field->table,field);

3976

12306

if (ref_item && ref_item->eq(right_item,1))

3977

12307

{

3978

12308

right_item= right_item->real_item();

3979

12309

if (right_item->type() == Item::FIELD_ITEM)

3980

return (field->eq_def(((Item_field *) right_item)->field));

12310

return (field->eq_def(((Item_field *) right_item)->field));

3981

12311

/* remove equalities injected by IN->EXISTS transformation */

3982

12312

else if (right_item->type() == Item::CACHE_ITEM)

3983

12313

return ((Item_cache *)right_item)->eq_def (field);

3984

12314

if (right_item->const_item() && !(right_item->is_null()))

3985

12315

{

3986

3987

We can remove binary fields and numerical fields except float,

3988

as float comparison isn't 100 % secure

3989

We have to keep normal strings to be able to check for end spaces

12316

12317

We can remove binary fields and numerical fields except float,

12318

as float comparison isn't 100 % secure

12319

We have to keep normal strings to be able to check for end spaces

3990

12320

3991

sergefp: the above seems to be too restrictive. Counterexample:

3992

create table t100 (v varchar(10), key(v)) default charset=latin1;

3993

insert into t100 values ('a'),('a ');

3994

explain select * from t100 where v='a';

3995

The EXPLAIN shows 'using Where'. Running the query returns both

3996

rows, so it seems there are no problems with endspace in the most

3997

frequent case?

3998

3999

if (field->binary() &&

4000

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

4001

field->decimals() == 0)

4002

{

4003

return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);

4004

}

12321

sergefp: the above seems to be too restrictive. Counterexample:

12322

create table t100 (v varchar(10), key(v)) default charset=latin1;

12323

insert into t100 values ('a'),('a ');

12324

explain select * from t100 where v='a';

12325

The EXPLAIN shows 'using Where'. Running the query returns both

12326

rows, so it seems there are no problems with endspace in the most

12327

frequent case?

12328

12329

if (field->binary() &&

12330

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

12331

field->decimals() == 0)

12332

{

12333

return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);

12334

}

4005

12335

}

4006

12336

}

4007

12337

}

4008

return 0;

12338

return 0; // keep test

12339

}

12340

12341

/**

12342

@brief Replaces an expression destructively inside the expression tree of

12343

the WHERE clase.

12344

12345

@note Because of current requirements for semijoin flattening, we do not

12346

need to recurse here, hence this function will only examine the top-level

12347

AND conditions. (see JOIN::prepare, comment above the line

12348

'if (do_materialize)'

12349

12350

@param join The top-level query.

12351

@param old_cond The expression to be replaced.

12352

@param new_cond The expression to be substituted.

12353

@param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for

12354

the new expression.

12355

@return <code>true</code> if there was an error, <code>false</code> if

12356

successful.

12357

12358

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

12359

Item *new_cond, bool do_fix_fields)

12360

{

12361

if (join->conds == old_cond) {

12362

join->conds= new_cond;

12363

if (do_fix_fields)

12364

new_cond->fix_fields(join->thd, &join->conds);

12365

return false;

12366

}

12367

12368

if (join->conds->type() == Item::COND_ITEM) {

12369

List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());

12370

Item *item;

12371

while ((item= li++))

12372

if (item == old_cond)

12373

{

12374

li.replace(new_cond);

12375

if (do_fix_fields)

12376

new_cond->fix_fields(join->thd, li.ref());

12377

return false;

12378

}

12379

}

12380

12381

return true;

4009

12382

}

4010

12383

4011

12384

4012

12385

Extract a condition that can be checked after reading given table

4013

12386

4014

12387

SYNOPSIS

4015

12388

make_cond_for_table()

4016

12389

cond Condition to analyze

4017

12390

tables Tables for which "current field values" are available

4018

used_table Table that we're extracting the condition for (may

12391

used_table Table that we're extracting the condition for (may

4019

12392

also include PSEUDO_TABLE_BITS

4020

12393

4021

12394

DESCRIPTION

4025

12398

4026

12399

The function assumes that

4027

12400

- Constant parts of the condition has already been checked.

4028

- Condition that could be checked for tables in 'tables' has already

12401

- Condition that could be checked for tables in 'tables' has already

4029

12402

been checked.

4030

12403

4031

12404

The function takes into account that some parts of the condition are

4032

12405

guaranteed to be true by employed 'ref' access methods (the code that

4033

12406

does this is located at the end, search down for "EQ_FUNC").

4034

12407

4035

12408

4036