~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

309

2560

/**

310

2561

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

311

2562

312

@param session thread Cursor

2563

@param thd thread handler

313

2564

@param rref_pointer_array a reference to ref_pointer_array of

314

2565

the top-level select_lex for this query

315

2566

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

316

2567

The tables have been pre-opened.

317

@param wild_num number of wildcards used in the top level

2568

@param wild_num number of wildcards used in the top level

318

2569

select of this query.

319

2570

For example statement

320

2571

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

325

2576

for a, b and c in this list.

326

2577

@param conds top level item of an expression representing

327

2578

WHERE clause of the top level select

328

@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

329

2580

arguments

330

@param order linked list of ORDER BY agruments

2581

@param order linked list of order_st BY agruments

331

2582

@param group linked list of GROUP BY arguments

332

2583

@param having top level item of HAVING expression

2584

@param proc_param list of PROCEDUREs

333

2585

@param select_options select options (BIG_RESULT, etc)

334

2586

@param result an instance of result set handling class.

335

2587

This object is responsible for send result

336

2588

set rows to the client or inserting them

337

2589

into a table.

338

@param select_lex the only Select_Lex of this query

2590

@param select_lex the only SELECT_LEX of this query

339

2591

@param unit top-level UNIT of this query

340

2592

UNIT is an artificial object created by the

341

2593

parser for every SELECT clause.

348

2600

@retval

349

2601

true an error

350

2602

351

bool mysql_select(Session *session,

352

Item ***rref_pointer_array,

353

TableList *tables,

354

uint32_t wild_num,

355

List<Item> &fields,

356

COND *conds,

357

uint32_t og_num,

358

Order *order,

359

Order *group,

360

Item *having,

361

uint64_t select_options,

362

select_result *result,

363

Select_Lex_Unit *unit,

364

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)

365

2611

{

366

2612

bool err;

367

2613

bool free_join= 1;

368

2614

369

2615

select_lex->context.resolve_in_select_list= true;

370

Join *join;

2616

JOIN *join;

371

2617

if (select_lex->join != 0)

372

2618

{

373

2619

join= select_lex->join;

376

2622

creation

377

2623

378

2624

if (select_lex->linkage != DERIVED_TABLE_TYPE ||

379

(select_options & SELECT_DESCRIBE))

2625

(select_options & SELECT_DESCRIBE))

380

2626

{

381

2627

if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)

382

2628

{

383

//here is EXPLAIN of subselect or derived table

384

if (join->change_result(result))

385

{

386

return(true);

387

}

2629

//here is EXPLAIN of subselect or derived table

2630

if (join->change_result(result))

2631

{

2632

return(true);

2633

}

388

2634

}

389

2635

else

390

2636

{

391

2637

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

392

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

393

{

394

goto err;

395

}

2638

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

2639

select_lex, unit)))

2640

{

2641

goto err;

2642

}

396

2643

}

397

2644

}

398

2645

free_join= 0;

400

2647

}

401

2648

else

402

2649

{

403

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

404

return(true);

405

session->set_proc_info("init");

406

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

407

2654

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

408

conds, og_num, order, group, having,

2655

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

409

2656

select_lex, unit)) == true)

410

2657

{

411

2658

goto err;

412

2659

}

413

2660

}

414

2661

415

err= join->optimize();

416

if (err)

417

{

418

goto err; // 1

419

}

420

421

if (session->lex->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)

422

2676

{

423

2677

join->conds_history= join->conds;

424

2678

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

425

2679

}

426

2680

427

if (session->is_error())

2681

if (thd->is_error())

428

2682

goto err;

429

2683

430

2684

join->exec();

431

2685

432

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

2686

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

433

2687

{

434

2688

select_lex->where= join->conds_history;

435

2689

select_lex->having= join->having_history;

438

2692

err:

439

2693

if (free_join)

440

2694

{

441

session->set_proc_info("end");

2695

thd->set_proc_info("end");

442

2696

err|= select_lex->cleanup();

443

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

2697

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

444

2698

}

445

2699

return(join->error);

446

2700

}

447

2701

448

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)

449

2712

{

450

2713

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

451

2714

}

452

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

453

3357

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

454

Create JoinTableS, make a guess about the table types,

3358

Create JOIN_TABS, make a guess about the table types,

455

3359

Approximate how many records will be used in each table

456

3360

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

457

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)

458

3366

{

459

3367

int error;

460

if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))

3368

if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))

461

3369

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

462

3370

if (select)

463

3371

{

464

3372

select->head=table;

465

3373

table->reginfo.impossible_range=0;

466

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,

467

3375

limit, 0, false)) == 1)

468

3376

return(select->quick->records);

469

3377

if (error == -1)

475

3383

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

476

3384

}

477

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

478

3830

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

479

3831

Check with keys are used and with tables references with tables

480

3832

Updates in stat:

483

3835

keyuse Pointer to possible keys

484

3836

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

485

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

}

486

4404

487

4405

/**

488

4406

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

489

4407

490

4408

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

491

4409

492

uint32_t max_part_bit(key_part_map bits)

4410

4411

static uint

4412

max_part_bit(key_part_map bits)

493

4413

{

494

4414

uint32_t found;

495

4415

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

496

4416

return found;

497

4417

}

498

4418

499

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)

500

4457

{

501

4458

int res;

502

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

503

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

504

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

505

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

506

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

507

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

508

4465

// Place const values before other ones

509

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

510

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

511

4468

return res;

512

4469

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

513

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

514

(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);

515

4543

}

516

4544

517

4545

518

4546

/**

519

4547

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

520

521

@param session

522

@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

523

4551

@param join_tab Array in tablenr_order

524

4552

@param tables Number of tables in join

525

4553

@param cond WHERE condition (note that the function analyzes

528

4556

for which we can make ref access based the WHERE

529

4557

clause)

530

4558

@param select_lex current SELECT

531

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

532

4559

@param[out] sargables Array of found sargable candidates

4560

533

4561

@retval

534

4562

0 OK

535

4563

@retval

536

4564

1 Out of memory.

537

4565

538

bool update_ref_and_keys(Session *session,

539

DYNAMIC_ARRAY *keyuse,

540

JoinTable *join_tab,

541

uint32_t tables,

542

COND *cond,

543

COND_EQUAL *,

544

table_map normal_tables,

545

Select_Lex *select_lex,

546

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)

547

4573

{

548

uint and_level,found_eq_constant;

549

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

4574

uint and_level,i,found_eq_constant;

4575

KEY_FIELD *key_fields, *end, *field;

550

4576

uint32_t sz;

551

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

552

553

554

All predicates that are used to fill arrays of KeyField

555

and SargableParam classes have at most 2 arguments

556

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

557

4587

IN predicates.

558

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

559

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

560

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

561

4591

can be filled as this predicate is considered as

562

4592

saragable with respect to each of its argument.

563

4593

An IN predicate can require at most 1 element as currently

564

4594

it is considered as sargable only for its first argument.

565

4595

Multiple equality can add elements that are filled after

566

4596

substitution of field arguments by equal fields. There

567

can be not more than select_lex->max_equal_elems such

4597

can be not more than select_lex->max_equal_elems such

568

4598

substitutions.

569

570

sz= sizeof(optimizer::KeyField) *

571

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

572

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

573

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

574

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 */

575

4605

and_level= 0;

576

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;

577

4611

578

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

4612

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

579

4613

return true;

580

4614

if (cond)

581

4615

{

582

4616

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

583

4617

sargables);

584

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

4618

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

585

4619

{

586

add_key_part(keyuse, field);

4620

add_key_part(keyuse,field);

587

4621

/* Mark that we can optimize LEFT JOIN */

588

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

589

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

590

{

591

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

592

}

4622

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

4623

!field->field->real_maybe_null())

4624

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

593

4625

}

594

4626

}

595

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

4627

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

596

4628

{

597

4629

598

4630

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

602

4634

In the future when we introduce conditional accesses

603

4635

for inner tables in outer joins these keys will be taken

604

4636

into account as well.

605

4637

606

4638

if (*join_tab[i].on_expr_ref)

607

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

4639

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

608

4640

*join_tab[i].on_expr_ref,

609

4641

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

610

4642

}

615

4647

TableList *table;

616

4648

while ((table= li++))

617

4649

{

618

if (table->getNestedJoin())

619

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,

620

4652

sargables);

621

4653

}

622

4654

}

636

4668

637

4669

if (keyuse->elements)

638

4670

{

639

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

4671

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

640

4672

641

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

642

(qsort_cmp) sort_keyuse);

4673

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

4674

(qsort_cmp) sort_keyuse);

643

4675

644

4676

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

645

4677

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

646

4678

647

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

4679

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

648

4680

prev= &key_end;

649

found_eq_constant= 0;

4681

found_eq_constant=0;

4682

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

650

4683

{

651

uint32_t i;

652

653

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;

654

4686

{

655

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

656

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

657

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

658

{

659

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

660

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

661

continue; /* remove */

662

}

663

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

664

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

}

665

4695

666

#ifdef HAVE_VALGRIND

667

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

668

if (save_pos != use)

4696

#ifdef HAVE_purify

4697

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

4698

if (save_pos != use)

669

4699

#endif

670

*save_pos= *use;

671

prev=use;

672

found_eq_constant= ! use->getUsedTables();

673

/* Save ptr to first use */

674

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

675

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

676

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

677

save_pos++;

678

}

679

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

680

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

681

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++;

682

4708

}

4709

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

4710

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

4711

keyuse->elements=i;

683

4712

}

684

4713

return false;

685

4714

}

687

4716

/**

688

4717

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

689

4718

690

void optimize_keyuse(Join *join, DYNAMIC_ARRAY *keyuse_array)

4719

4720

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

691

4721

{

692

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

693

694

optimizer::KeyUse*);

4722

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

695

4723

696

4724

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

697

4725

{

704

4732

Constant tables are ignored.

705

4733

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

706

4734

707

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

708

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

709

4739

{

710

4740

uint32_t tablenr;

711

4741

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

712

4742

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

713

4743

{

714

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

715

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

716

4746

}

717

4747

}

718

4748

719

4749

Outer reference (external field) is constant for single executing

720

4750

of subquery

721

4751

722

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

723

keyuse->setTableRows(1);

4752

if (keyuse->used_tables == OUTER_REF_TABLE_BIT)

4753

keyuse->ref_table_rows= 1;

724

4754

}

725

4755

}

726

4756

742

4772

@return

743

4773

None

744

4774

745

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)

746

4778

{

747

4779

List<Item_field> indexed_fields;

748

4780

List_iterator<Item_field> indexed_fields_it(indexed_fields);

749

Order *cur_group;

4781

order_st *cur_group;

750

4782

Item_field *cur_item;

751

4783

key_map possible_keys(0);

752

4784

773

4805

774

4806

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

775

4807

cur_item= indexed_fields_it++;

776

possible_keys|= cur_item->field->part_of_key;

4808

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

777

4809

while ((cur_item= indexed_fields_it++))

778

4810

{

779

possible_keys&= cur_item->field->part_of_key;

780

}

781

782

if (possible_keys.any())

783

join_tab->const_keys|= possible_keys;

784

}

785

786

/**

787

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

788

789

@param ptr1 pointer to first JoinTable object

790

@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

791

5600

792

5601

NOTES

793

5602

The order relation implemented by join_tab_cmp() is not transitive,

799

5608

a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0

800

5609

b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838

801

5610

c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0

802

5611

803

5612

@retval

804

5613

1 if first is bigger

805

5614

@retval

807

5616

@retval

808

5617

0 if equal

809

5618

810

int join_tab_cmp(const void* ptr1, const void* ptr2)

5619

5620

static int

5621

join_tab_cmp(const void* ptr1, const void* ptr2)

811

5622

{

812

JoinTable *jt1= *(JoinTable**) ptr1;

813

JoinTable *jt2= *(JoinTable**) ptr2;

5623

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5624

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

814

5625

815

5626

if (jt1->dependent & jt2->table->map)

816

5627

return 1;

817

5628

if (jt2->dependent & jt1->table->map)

818

return -1;

5629

return -1;

819

5630

if (jt1->found_records > jt2->found_records)

820

5631

return 1;

821

5632

if (jt1->found_records < jt2->found_records)

822

return -1;

5633

return -1;

823

5634

return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);

824

5635

}

825

5636

5637

826

5638

/**

827

5639

Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.

828

5640

829

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)

830

5644

{

831

JoinTable *jt1= *(JoinTable**) ptr1;

832

JoinTable *jt2= *(JoinTable**) ptr2;

5645

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5646

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

833

5647

834

5648

if (jt1->dependent & jt2->table->map)

835

5649

return 1;

839

5653

}

840

5654

841

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

/**

842

6224

Find how much space the prevous read not const tables takes in cache.

843

6225

844

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)

845

6229

{

846

6230

uint32_t null_fields,blobs,fields,rec_length;

847

6231

Field **f_ptr,*field;

6232

MY_BITMAP *read_set= join_tab->table->read_set;;

848

6233

849

6234

null_fields= blobs= fields= rec_length=0;

850

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

851

6236

{

852

if (field->isReadSet())

6237

if (bitmap_is_set(read_set, field->field_index))

853

6238

{

854

6239

uint32_t flags=field->flags;

855

6240

fields++;

856

6241

rec_length+=field->pack_length();

857

6242

if (flags & BLOB_FLAG)

858

blobs++;

6243

blobs++;

859

6244

if (!(flags & NOT_NULL_FLAG))

860

null_fields++;

6245

null_fields++;

861

6246

}

862

6247

}

863

6248

if (null_fields)

866

6251

rec_length+=sizeof(bool);

867

6252

if (blobs)

868

6253

{

869

uint32_t blob_length=(uint32_t) (join_tab->table->cursor->stats.mean_rec_length-

870

(join_tab->table->getRecordLength()- rec_length));

871

rec_length+= max((uint32_t)4,blob_length);

872

}

873

join_tab->used_fields= fields;

874

join_tab->used_fieldlength= rec_length;

875

join_tab->used_blobs= blobs;

876

}

877

878

StoredKey *get_store_key(Session *session,

879

optimizer::KeyUse *keyuse,

880

table_map used_tables,

881

KeyPartInfo *key_part,

882

unsigned char *key_buff,

883

uint32_t maybe_null)

884

{

885

Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());

886

if (! ((~used_tables) & keyuse->getUsedTables())) // if const item

887

{

888

return new store_key_const_item(session,

889

key_part->field,

890

key_buff + maybe_null,

891

maybe_null ? key_buff : 0,

892

key_part->length,

893

key_use_val);

894

}

895

else if (key_use_val->type() == Item::FIELD_ITEM ||

896

(key_use_val->type() == Item::REF_ITEM &&

897

key_use_val->ref_type() == Item_ref::OUTER_REF &&

898

(*(Item_ref**)((Item_ref*)key_use_val)->ref)->ref_type() == Item_ref::DIRECT_REF &&

899

key_use_val->real_item()->type() == Item::FIELD_ITEM))

900

{

901

return new store_key_field(session,

902

key_part->field,

903

key_buff + maybe_null,

904

maybe_null ? key_buff : 0,

905

key_part->length,

906

((Item_field*) key_use_val->real_item())->field,

907

key_use_val->full_name());

908

}

909

return new store_key_item(session,

910

key_part->field,

911

key_buff + maybe_null,

912

maybe_null ? key_buff : 0,

913

key_part->length,

914

key_use_val);

915

}

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

916

6368

917

6369

/**

918

This function is only called for const items on fields which are keys.

919

920

@return

921

returns 1 if there was some conversion made when the field was stored.

6370

Set up join struct according to best position.

922

6371

923

bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

924

{

925

bool error;

926

Table *table= field->getTable();

927

Session *session= table->in_use;

928

ha_rows cuted_fields=session->cuted_fields;

929

930

931

we should restore old value of count_cuted_fields because

932

store_val_in_field can be called from mysql_insert

933

with select_insert, which make count_cuted_fields= 1

934

935

enum_check_fields old_count_cuted_fields= session->count_cuted_fields;

936

session->count_cuted_fields= check_flag;

937

error= item->save_in_field(field, 1);

938

session->count_cuted_fields= old_count_cuted_fields;

939

return error || cuted_fields != session->cuted_fields;

940

}

941

942

inline void add_cond_and_fix(Item **e1, Item *e2)

943

{

944

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

945

6392

{

946

Item *res;

947

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

948

6409

{

949

*e1= res;

950

res->quick_fix_field();

6410

j->type=JT_ALL;

6411

if (tablenr != join->const_tables)

6412

join->full_join=1;

951

6413

}

6414

else if (create_ref_for_key(join, j, keyuse, used_tables))

6415

return(true); // Something went wrong

952

6416

}

953

else

954

*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);

955

6422

}

956

6423

957

bool create_ref_for_key(Join *join,

958

JoinTable *j,

959

optimizer::KeyUse *org_keyuse,

960

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)

961

6427

{

962

optimizer::KeyUse *keyuse= org_keyuse;

963

Session *session= join->session;

964

uint32_t keyparts;

965

uint32_t length;

966

uint32_t key;

967

Table *table= NULL;

968

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;

969

6433

970

6434

/* Use best key from find_best */

971

table= j->table;

972

key= keyuse->getKey();

973

keyinfo= table->key_info + key;

6435

table=j->table;

6436

key=keyuse->key;

6437

keyinfo=table->key_info+key;

974

6438

975

6439

{

976

keyparts= length= 0;

6440

keyparts=length=0;

977

6441

uint32_t found_part_ref_or_null= 0;

978

6442

979

6443

Calculate length for the used key

982

6446

983

6447

984

6448

{

985

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

6449

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

986

6450

{

987

if (keyparts == keyuse->getKeypart() &&

988

! (found_part_ref_or_null & keyuse->getOptimizeFlags()))

989

{

990

keyparts++;

991

length+= keyinfo->key_part[keyuse->getKeypart()].store_length;

992

found_part_ref_or_null|= keyuse->getOptimizeFlags();

993

}

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

}

994

6458

}

995

6459

keyuse++;

996

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

6460

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

997

6461

}

998

6462

999

6463

/* set up fieldref */

1001

6465

j->ref.key_parts=keyparts;

1002

6466

j->ref.key_length=length;

1003

6467

j->ref.key=(int) key;

1004

if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

1005

!(j->ref.key_copy= (StoredKey**) session->alloc((sizeof(StoredKey*) *

1006

(keyparts+1)))) ||

1007

!(j->ref.items= (Item**) session->alloc(sizeof(Item*)*keyparts)) ||

1008

!(j->ref.cond_guards= (bool**) session->alloc(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)))

1009

6473

{

1010

6474

return(true);

1011

6475

}

1015

6479

j->ref.disable_cache= false;

1016

6480

keyuse=org_keyuse;

1017

6481

1018

StoredKey **ref_key= j->ref.key_copy;

1019

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;

1020

6484

bool keyuse_uses_no_tables= true;

1021

6485

{

1022

for (uint32_t i= 0; i < keyparts; keyuse++, i++)

6486

uint32_t i;

6487

for (i=0 ; i < keyparts ; keyuse++,i++)

1023

6488

{

1024

while (keyuse->getKeypart() != i ||

1025

((~used_tables) & keyuse->getUsedTables()))

1026

keyuse++; /* Skip other parts */

6489

while (keyuse->keypart != i ||

6490

((~used_tables) & keyuse->used_tables))

6491

keyuse++; /* Skip other parts */

1027

6492

1028

6493

uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);

1029

j->ref.items[i]= keyuse->getVal(); // Save for cond removal

1030

j->ref.cond_guards[i]= keyuse->getConditionalGuard();

1031

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)

1032

6497

j->ref.null_rejecting |= 1 << i;

1033

keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();

1034

if (! keyuse->getUsedTables() && !(join->select_options & SELECT_DESCRIBE))

1035

{ // Compare against constant

1036

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,

1037

6503

key_buff + maybe_null,

1038

6504

maybe_null ? key_buff : 0,

1039

keyinfo->key_part[i].length, keyuse->getVal());

1040

if (session->is_fatal_error)

1041

return(true);

1042

tmp.copy();

6505

keyinfo->key_part[i].length, keyuse->val);

6506

if (thd->is_fatal_error)

6507

return(true);

6508

tmp.copy();

1043

6509

}

1044

6510

else

1045

*ref_key++= get_store_key(session,

1046

keyuse,join->const_table_map,

1047

&keyinfo->key_part[i],

1048

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

1049

6515

1050

Remember if we are going to use REF_OR_NULL

1051

But only if field _really_ can be null i.e. we force AM_REF

1052

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

1053

6519

1054

if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

1055

null_ref_key= key_buff;

6520

if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

6521

null_ref_key= key_buff;

1056

6522

key_buff+=keyinfo->key_part[i].store_length;

1057

6523

}

1058

6524

}

1059

*ref_key= 0; // end_marker

1060

if (j->type == AM_CONST)

6525

*ref_key=0; // end_marker

6526

if (j->type == JT_CONST)

1061

6527

j->table->const_table= 1;

1062

6528

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

1063

6529

keyparts != keyinfo->key_parts || null_ref_key)

1064

6530

{

1065

6531

/* Must read with repeat */

1066

j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;

6532

j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;

1067

6533

j->ref.null_ref_key= null_ref_key;

1068

6534

}

1069

6535

else if (keyuse_uses_no_tables)

1075

6541

Here we should not mark the table as a 'const' as a field may

1076

6542

have a 'normal' value or a NULL value.

1077

6543

1078

j->type= AM_CONST;

1079

}

1080

else

1081

j->type= AM_EQ_REF;

1082

return 0;

1083

}

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

1084

6698

1085

6699

/**

1086

6700

Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions

1095

6709

add "t1.field IS NOT NULL" to t1's table condition. @n

1096

6710

1097

6711

Description of the optimization:

1098

6712

1099

6713

We look through equalities choosen to perform ref/eq_ref access,

1100

6714

pick equalities that have form "tbl.part_of_key = othertbl.field"

1101

6715

(where othertbl is a non-const table and othertbl.field may be NULL)

1123

6737

This optimization doesn't affect the choices that ref, range, or join

1124

6738

optimizer make. This was intentional because this was added after 4.1

1125

6739

was GA.

1126

6740

1127

6741

Implementation overview

1128

6742

1. update_ref_and_keys() accumulates info about null-rejecting

1129

predicates in in KeyField::null_rejecting

1130

1.1 add_key_part saves these to KeyUse.

1131

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.

1132

6746

3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of

1133

appropiate JoinTable members.

6747

appropiate JOIN_TAB members.

1134

6748

1135

void add_not_null_conds(Join *join)

6749

6750

static void add_not_null_conds(JOIN *join)

1136

6751

{

1137

for (uint32_t i= join->const_tables; i < join->tables; i++)

6752

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

1138

6753

{

1139

JoinTable *tab=join->join_tab+i;

1140

if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||

1141

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

1142

6757

!tab->table->maybe_null)

1143

6758

{

1144

6759

for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)

1149

6764

Item *notnull;

1150

6765

assert(item->type() == Item::FIELD_ITEM);

1151

6766

Item_field *not_null_item= (Item_field*)item;

1152

JoinTable *referred_tab= not_null_item->field->getTable()->reginfo.join_tab;

6767

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

1153

6768

1154

6769

For UPDATE queries such as:

1155

6770

UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);

1161

6776

return;

1162

6777

1163

6778

We need to do full fix_fields() call here in order to have correct

1164

notnull->const_item(). This is needed e.g. by test_quick_select

1165

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

1166

6781

called.

1167

6782

1168

if (notnull->fix_fields(join->session, &notnull))

6783

if (notnull->fix_fields(join->thd, &notnull))

1169

6784

return;

1170

6785

add_cond_and_fix(&referred_tab->select_cond, notnull);

1171

6786

}

1190

6805

- pointer to the guarded predicate, if success

1191

6806

- 0, otherwise

1192

6807

1193

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)

1194

6811

{

1195

6812

COND *tmp;

1196

6813

assert(cond != 0);

1206

6823

return tmp;

1207

6824

}

1208

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

1209

7373

#define ICP_COND_USES_INDEX_ONLY 10

1210

7374

1211

1212

/**

1213

cleanup JoinTable.

1214

1215

void JoinTable::cleanup()

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

1216

7881

{

1217

7882

delete select;

1218

7883

select= 0;

1219

7884

delete quick;

1220

7885

quick= 0;

1221

7886

if (cache.buff)

1222

{

1223

size_t size= cache.end - cache.buff;

1224

global_join_buffer.sub(size);

1225

7887

free(cache.buff);

1226

}

1227

7888

cache.buff= 0;

1228

7889

limit= 0;

1229

7890

if (table)

1231

7892

if (table->key_read)

1232

7893

{

1233

7894

table->key_read= 0;

1234

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

7895

table->file->extra(HA_EXTRA_NO_KEYREAD);

1235

7896

}

1236

table->cursor->ha_index_or_rnd_end();

7897

table->file->ha_index_or_rnd_end();

1237

7898

1238

7899

We need to reset this for next select

1239

7900

(Tested in part_of_refkey)

1240

7901

1241

7902

table->reginfo.join_tab= 0;

1242

7903

}

1243

read_record.end_read_record();

1244

}

1245

1246

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

1247

{

1248

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

1249

{

1250

if (tables & 1 && !eq_ref_table(join, order, *tab))

1251

return 0;

1252

}

1253

return 1;

1254

}

1255

1256

/**

1257

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:

1258

8086

Constant expressions @n

1259

8087

Expression that only uses tables that are of type EQ_REF and the reference

1260

8088

is in the order_st list or if all refereed tables are of the above type.

1261

8089

1262

8090

In the following, the X field can be removed:

1263

8091

@code

1264

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

1265

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

1266

8094

@endcode

1267

8095

1268

8096

These can't be optimized:

1269

8097

@code

1270

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

1271

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

1272

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

1273

8101

@endcode

1274

8102

1275

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)

1276

8106

{

1277

8107

if (tab->cached_eq_ref_table) // If cached

1278

8108

return tab->eq_ref_table;

1279

8109

tab->cached_eq_ref_table=1;

1280

8110

/* We can skip const tables only if not an outer table */

1281

if (tab->type == AM_CONST && !tab->first_inner)

1282

return (tab->eq_ref_table=1);

1283

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)

1284

8114

return (tab->eq_ref_table=0); // We must use this

1285

8115

Item **ref_item=tab->ref.items;

1286

8116

Item **end=ref_item+tab->ref.key_parts;

1291

8121

{

1292

8122

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

1293

8123

{ // Not a const ref

1294

Order *order;

8124

order_st *order;

1295

8125

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

1296

8126

{

1297

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

1298

break;

8127

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

8128

break;

1299

8129

}

1300

8130

if (order)

1301

8131

{

1302

found++;

1303

assert(!(order->used & map));

1304

order->used|=map;

1305

continue; // Used in order_st BY

8132

found++;

8133

assert(!(order->used & map));

8134

order->used|=map;

8135

continue; // Used in order_st BY

1306

8136

}

1307

8137

if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))

1308

return (tab->eq_ref_table= 0);

8138

return (tab->eq_ref_table=0);

1309

8139

}

1310

8140

}

1311

8141

/* Check that there was no reference to table before sort order */

1317

8147

continue;

1318

8148

}

1319

8149

if (start_order->depend_map & map)

1320

return (tab->eq_ref_table= 0);

1321

}

1322

return tab->eq_ref_table= 1;

1323

}

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

1324

8382

1325

8383

/**

1326

8384

Find the multiple equality predicate containing a field.

1340

8398

- Item_equal for the found multiple equality predicate if a success;

1341

8399

- NULL otherwise.

1342

8400

1343

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)

1344

8404

{

1345

8405

Item_equal *item= 0;

1346

8406

bool in_upper_level= false;

1361

8421

return item;

1362

8422

}

1363

8423

8424

1364

8425

/**

1365

8426

Check whether an equality can be used to build multiple equalities.

1366

8427

1387

8448

the check_equality will be called for the following equality

1388

8449

predicates a=b, b=c, b=2 and f=e.

1389

8450

- For a=b it will be called with *cond_equal=(0,[]) and will transform

1390

*cond_equal into (0,[Item_equal(a,b)]).

8451

*cond_equal into (0,[Item_equal(a,b)]).

1391

8452

- For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])

1392

8453

and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).

1393

8454

- For b=2 it will be called with *cond_equal=(ptr(CE),[])

1400

8461

the Field::eq_def method) are placed to the same multiple equalities.

1401

8462

Because of this some equality predicates are not eliminated and

1402

8463

can be used in the constant propagation procedure.

1403

We could weeken the equlity test as soon as at least one of the

1404

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

1405

8466

more complicated implementation: we would have to store, in

1406

8467

general case, its own constant for each fields from the multiple

1407

8468

equality. But at the same time it would allow us to get rid

1419

8480

containing just field1 and field2 is added to the existing

1420

8481

multiple equalities.

1421

8482

If the function processes the predicate of the form field1=const,

1422

it looks for a multiple equality containing field1. If found, the

8483

it looks for a multiple equality containing field1. If found, the

1423

8484

function checks the constant of the multiple equality. If the value

1424

8485

is unknown, it is setup to const. Otherwise the value is compared with

1425

8486

const and the evaluation of the equality predicate is performed.

1442

8503

@retval

1443

8504

false otherwise

1444

8505

1445

static bool check_simple_equality(Item *left_item,

1446

Item *right_item,

1447

Item *item,

1448

COND_EQUAL *cond_equal)

8506

8507

static bool check_simple_equality(Item *left_item, Item *right_item,

8508

Item *item, COND_EQUAL *cond_equal)

1449

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

}

1450

8524

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

1451

8525

right_item->type() == Item::FIELD_ITEM &&

1452

8526

!((Item_field*)left_item)->depended_from &&

1464

8538

bool left_copyfl, right_copyfl;

1465

8539

Item_equal *left_item_equal=

1466

8540

find_item_equal(cond_equal, left_field, &left_copyfl);

1467

Item_equal *right_item_equal=

8541

Item_equal *right_item_equal=

1468

8542

find_item_equal(cond_equal, right_field, &right_copyfl);

1469

8543

1470

8544

/* As (NULL=NULL) != true we can't just remove the predicate f=f */

1471

8545

if (left_field->eq(right_field)) /* f = f */

1472

return (!(left_field->maybe_null() && !left_item_equal));

8546

return (!(left_field->maybe_null() && !left_item_equal));

1473

8547

1474

8548

if (left_item_equal && left_item_equal == right_item_equal)

1475

8549

{

1476

8550

1477

8551

The equality predicate is inference of one of the existing

1478

8552

multiple equalities, i.e the condition is already covered

1479

8553

by upper level equalities

1480

8554

1481

8555

return true;

1482

8556

}

1483

1484

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 &&

1485

8559

item->name < subq_sj_cond_name + 64);

1486

8560

/* Copy the found multiple equalities at the current level if needed */

1487

8561

if (left_copyfl)

1502

8576

}

1503

8577

1504

8578

if (left_item_equal)

1505

{

8579

{

1506

8580

/* left item was found in the current or one of the upper levels */

1507

8581

if (! right_item_equal)

1508

8582

left_item_equal->add((Item_field *) right_item);

1517

8591

}

1518

8592

}

1519

8593

else

1520

{

8594

{

1521

8595

/* left item was not found neither the current nor in upper levels */

1522

8596

if (right_item_equal)

1523

8597

{

1525

8599

if (copy_item_name)

1526

8600

right_item_equal->name = item->name;

1527

8601

}

1528

else

8602

else

1529

8603

{

1530

8604

/* None of the fields was found in multiple equalities */

1531

8605

Item_equal *item_equal= new Item_equal((Item_field *) left_item,

1573

8647

eq_item->set_cmp_func();

1574

8648

eq_item->quick_fix_field();

1575

8649

item= eq_item;

1576

}

8650

}

1577

8651

if ((cs != ((Item_func *) item)->compare_collation()) ||

1578

8652

!cs->coll->propagate(cs, 0, 0))

1579

8653

return false;

1588

8662

}

1589

8663

if (item_equal)

1590

8664

{

1591

8665

1592

8666

The flag cond_false will be set to 1 after this, if item_equal

1593

8667

already contains a constant and its value is not equal to

1594

8668

the value of const_item.

1606

8680

return false;

1607

8681

}

1608

8682

8683

1609

8684

/**

1610

8685

Convert row equalities into a conjunction of regular equalities.

1611

8686

1618

8693

simple equality nor a row equality the item for this predicate is added

1619

8694

to eq_list.

1620

8695

1621

@param session thread handle

8696

@param thd thread handle

1622

8697

@param left_row left term of the row equality to be processed

1623

8698

@param right_row right term of the row equality to be processed

1624

8699

@param cond_equal multiple equalities that must hold together with the

1631

8706

@retval

1632

8707

false otherwise

1633

8708

1634

static bool check_row_equality(Session *session,

1635

Item *left_row,

1636

Item_row *right_row,

1637

COND_EQUAL *cond_equal,

1638

List<Item>* eq_list)

1639

{

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

{

1640

8713

uint32_t n= left_row->cols();

1641

8714

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

1642

8715

{

1646

8719

if (left_item->type() == Item::ROW_ITEM &&

1647

8720

right_item->type() == Item::ROW_ITEM)

1648

8721

{

1649

is_converted= check_row_equality(session,

8722

is_converted= check_row_equality(thd,

1650

8723

(Item_row *) left_item,

1651

8724

(Item_row *) right_item,

1652

8725

cond_equal, eq_list);

1653

8726

if (!is_converted)

1654

session->lex->current_select->cond_count++;

8727

thd->lex->current_select->cond_count++;

1655

8728

}

1656

8729

else

1657

{

8730

{

1658

8731

is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

1659

session->lex->current_select->cond_count++;

1660

}

1661

8732

thd->lex->current_select->cond_count++;

8733

}

8734

1662

8735

if (!is_converted)

1663

8736

{

1664

8737

Item_func_eq *eq_item;

1672

8745

return true;

1673

8746

}

1674

8747

8748

1675

8749

/**

1676

8750

Eliminate row equalities and form multiple equalities predicates.

1677

8751

1686

8760

equalities which are treated in the same way as original equality

1687

8761

predicates.

1688

8762

1689

@param session thread handle

8763

@param thd thread handle

1690

8764

@param item predicate to process

1691

8765

@param cond_equal multiple equalities that must hold together with the

1692

8766

predicate

1701

8775

or, if the equality is neither a simple one nor a row equality,

1702

8776

or, if the procedure fails by a fatal error.

1703

8777

1704

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)

1705

8781

{

1706

8782

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

1707

8783

((Item_func*) item)->functype() == Item_func::EQ_FUNC)

1712

8788

if (left_item->type() == Item::ROW_ITEM &&

1713

8789

right_item->type() == Item::ROW_ITEM)

1714

8790

{

1715

session->lex->current_select->cond_count--;

1716

return check_row_equality(session,

8791

thd->lex->current_select->cond_count--;

8792

return check_row_equality(thd,

1717

8793

(Item_row *) left_item,

1718

8794

(Item_row *) right_item,

1719

8795

cond_equal, eq_list);

1720

8796

}

1721

else

8797

else

1722

8798

return check_simple_equality(left_item, right_item, item, cond_equal);

1723

}

8799

}

1724

8800

return false;

1725

8801

}

1726

8802

8803

1727

8804

/**

1728

8805

Replace all equality predicates in a condition by multiple equality items.

1729

8806

1730

8807

At each 'and' level the function detects items for equality predicates

1731

8808

and replaced them by a set of multiple equality items of class Item_equal,

1732

taking into account inherited equalities from upper levels.

8809

taking into account inherited equalities from upper levels.

1733

8810

If an equality predicate is used not in a conjunction it's just

1734

8811

replaced by a multiple equality predicate.

1735

8812

For each 'and' level the function set a pointer to the inherited

1736

8813

multiple equalities in the cond_equal field of the associated

1737

object of the type Item_cond_and.

8814

object of the type Item_cond_and.

1738

8815

The function also traverses the cond tree and and for each field reference

1739

8816

sets a pointer to the multiple equality item containing the field, if there

1740

8817

is any. If this multiple equality equates fields to a constant the

1741

function replaces the field reference by the constant in the cases

8818

function replaces the field reference by the constant in the cases

1742

8819

when the field is not of a string type or when the field reference is

1743

8820

just an argument of a comparison predicate.

1744

The function also determines the maximum number of members in

8821

The function also determines the maximum number of members in

1745

8822

equality lists of each Item_cond_and object assigning it to

1746

session->lex->current_select->max_equal_elems.

8823

thd->lex->current_select->max_equal_elems.

1747

8824

1748

8825

@note

1749

8826

Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

1755

8832

in a conjuction for a minimal set of multiple equality predicates.

1756

8833

This set can be considered as a canonical representation of the

1757

8834

sub-conjunction of the equality predicates.

1758

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

1759

8836

(=(t1.a,t2.b,t3.c) AND t2.b>5), not by

1760

8837

(=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);

1761

8838

while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by

1766

8843

The function performs the substitution in a recursive descent by

1767

8844

the condtion tree, passing to the next AND level a chain of multiple

1768

8845

equality predicates which have been built at the upper levels.

1769

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

1770

8847

non-equality conjucts as a sublist. The pointer to the inherited

1771

8848

multiple equalities is saved in the and condition object (Item_cond_and).

1772

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

1773

8850

multiple equality that must be held for this occurence.

1774

8851

For each AND level we do the following:

1775

8852

- scan it for all equality predicate (=) items

1776

8853

- join them into disjoint Item_equal() groups

1777

- process the included OR conditions recursively to do the same for

1778

lower AND levels.

8854

- process the included OR conditions recursively to do the same for

8855

lower AND levels.

1779

8856

1780

8857

We need to do things in this order as lower AND levels need to know about

1781

8858

all possible Item_equal objects in upper levels.

1782

8859

1783

@param session thread handle

8860

@param thd thread handle

1784

8861

@param cond condition(expression) where to make replacement

1785

8862

@param inherited path to all inherited multiple equality items

1786

8863

1787

8864

@return

1788

8865

pointer to the transformed condition

1789

8866

1790

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)

1791

8870

{

1792

8871

Item_equal *item_equal;

1793

8872

COND_EQUAL cond_equal;

1799

8878

bool and_level= ((Item_cond*) cond)->functype() ==

1800

8879

Item_func::COND_AND_FUNC;

1801

8880

List<Item> *args= ((Item_cond*) cond)->argument_list();

1802

8881

1803

8882

List_iterator<Item> li(*args);

1804

8883

Item *item;

1805

8884

1808

8887

1809

8888

Retrieve all conjucts of this level detecting the equality

1810

8889

that are subject to substitution by multiple equality items and

1811

removing each such predicate from the conjunction after having

8890

removing each such predicate from the conjunction after having

1812

8891

found/created a multiple equality whose inference the predicate is.

1813

8892

1814

8893

while ((item= li++))

1815

8894

{

1816

8895

1818

8897

structure here because it's restored before each

1819

8898

re-execution of any prepared statement/stored procedure.

1820

8899

1821

if (check_equality(session, item, &cond_equal, &eq_list))

8900

if (check_equality(thd, item, &cond_equal, &eq_list))

1822

8901

li.remove();

1823

8902

}

1824

8903

1827

8906

{

1828

8907

item_equal->fix_length_and_dec();

1829

8908

item_equal->update_used_tables();

1830

set_if_bigger(session->lex->current_select->max_equal_elems,

1831

item_equal->members());

8909

set_if_bigger(thd->lex->current_select->max_equal_elems,

8910

item_equal->members());

1832

8911

}

1833

8912

1834

8913

((Item_cond_and*)cond)->cond_equal= cond_equal;

1840

8919

1841

8920

li.rewind();

1842

8921

while ((item= li++))

1843

{

8922

{

1844

8923

Item *new_item;

1845

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)

1846

8925

{

1847

8926

/* This replacement happens only for standalone equalities */

1848

8927

1870

8949

(b=5) and (a=c) are standalone equalities.

1871

8950

In general we can't leave alone standalone eqalities:

1872

8951

for WHERE a=b AND c=d AND (b=c OR d=5)

1873

b=c is replaced by =(a,b,c,d).

8952

b=c is replaced by =(a,b,c,d).

1874

8953

1875

if (check_equality(session, cond, &cond_equal, &eq_list))

8954

if (check_equality(thd, cond, &cond_equal, &eq_list))

1876

8955

{

1877

8956

int n= cond_equal.current_level.elements + eq_list.elements;

1878

8957

if (n == 0)

1883

8962

{

1884

8963

item_equal->fix_length_and_dec();

1885

8964

item_equal->update_used_tables();

1886

}

8965

}

1887

8966

else

1888

8967

item_equal= (Item_equal *) eq_list.pop();

1889

set_if_bigger(session->lex->current_select->max_equal_elems,

1890

item_equal->members());

8968

set_if_bigger(thd->lex->current_select->max_equal_elems,

8969

item_equal->members());

1891

8970

return item_equal;

1892

8971

}

1893

8972

else

1894

8973

{

1895

8974

1896

8975

Here a new AND level must be created. It can happen only

1897

8976

when a row equality is processed as a standalone predicate.

1898

8977

1899

8978

Item_cond_and *and_cond= new Item_cond_and(eq_list);

1900

8979

and_cond->quick_fix_field();

1901

8980

List<Item> *args= and_cond->argument_list();

1904

8983

{

1905

8984

item_equal->fix_length_and_dec();

1906

8985

item_equal->update_used_tables();

1907

set_if_bigger(session->lex->current_select->max_equal_elems,

1908

item_equal->members());

8986

set_if_bigger(thd->lex->current_select->max_equal_elems,

8987

item_equal->members());

1909

8988

}

1910

8989

and_cond->cond_equal= cond_equal;

1911

8990

args->concat((List<Item> *)&cond_equal.current_level);

1912

8991

1913

8992

return and_cond;

1914

8993

}

1915

8994

}

1916

8995

1917

8996

For each field reference in cond, not from equal item predicates,

1918

8997

set a pointer to the multiple equality it belongs to (if there is any)

1919

8998

as soon the field is not of a string type or the field reference is

1920

an argument of a comparison predicate.

1921

8999

an argument of a comparison predicate.

9000

1922

9001

unsigned char *is_subst_valid= (unsigned char *) 1;

1923

9002

cond= cond->compile(&Item::subst_argument_checker,

1924

&is_subst_valid,

9003

&is_subst_valid,

1925

9004

&Item::equal_fields_propagator,

1926

9005

(unsigned char *) inherited);

1927

9006

cond->update_used_tables();

1929

9008

return cond;

1930

9009

}

1931

9010

9011

1932

9012

/**

1933

9013

Build multiple equalities for a condition and all on expressions that

1934

9014

inherit these multiple equalities.

1974

9054

SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a

1975

9055

WHERE t1.a=t2.a

1976

9056

@endcode

1977

that is equivalent to:

9057

that is equivalent to:

1978

9058

@code

1979

9059

SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1

1980

9060

WHERE t1.a=t2.a

1981

9061

@endcode

1982

9062

Thus, applying equalities from the where condition we basically

1983

9063

can get more freedom in performing join operations.

1984

Althogh we don't use this property now, it probably makes sense to use

1985

it in the future.

1986

@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

1987

9067

@param cond condition to build the multiple equalities for

1988

9068

@param inherited path to all inherited multiple equality items

1989

9069

@param join_list list of join tables to which the condition

1994

9074

@return

1995

9075

pointer to the transformed condition containing multiple equalities

1996

9076

1997

static COND *build_equal_items(Session *session, COND *cond,

9077

9078

static COND *build_equal_items(THD *thd, COND *cond,

1998

9079

COND_EQUAL *inherited,

1999

9080

List<TableList> *join_list,

2000

9081

COND_EQUAL **cond_equal_ref)

2001

9082

{

2002

9083

COND_EQUAL *cond_equal= 0;

2003

9084

2004

if (cond)

9085

if (cond)

2005

9086

{

2006

cond= build_equal_items_for_cond(session, cond, inherited);

9087

cond= build_equal_items_for_cond(thd, cond, inherited);

2007

9088

cond->update_used_tables();

2008

9089

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

2009

9090

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

2031

9112

{

2032

9113

if (table->on_expr)

2033

9114

{

2034

List<TableList> *nested_join_list= table->getNestedJoin() ?

2035

&table->getNestedJoin()->join_list : NULL;

9115

List<TableList> *nested_join_list= table->nested_join ?

9116

&table->nested_join->join_list : NULL;

2036

9117

2037

9118

We can modify table->on_expr because its old value will

2038

9119

be restored before re-execution of PS/SP.

2039

9120

2040

table->on_expr= build_equal_items(session, table->on_expr, inherited,

9121

table->on_expr= build_equal_items(thd, table->on_expr, inherited,

2041

9122

nested_join_list,

2042

9123

&table->cond_equal);

2043

9124

}

2045

9126

}

2046

9127

2047

9128

return cond;

2048

}

9129

}

9130

2049

9131

2050

9132

/**

2051

9133

Compare field items by table order in the execution plan.

2052

9134

2053

9135

field1 considered as better than field2 if the table containing

2054

field1 is accessed earlier than the table containing field2.

9136

field1 is accessed earlier than the table containing field2.

2055

9137

The function finds out what of two fields is better according

2056

9138

this criteria.

2057

9139

2066

9148

@retval

2067

9149

0 otherwise

2068

9150

9151

2069

9152

static int compare_fields_by_table_order(Item_field *field1,

2070

Item_field *field2,

2071

void *table_join_idx)

9153

Item_field *field2,

9154

void *table_join_idx)

2072

9155

{

2073

9156

int cmp= 0;

2074

9157

bool outer_ref= 0;

2075

9158

if (field2->used_tables() & OUTER_REF_TABLE_BIT)

2076

{

9159

{

2077

9160

outer_ref= 1;

2078

9161

cmp= -1;

2079

9162

}

2084

9167

}

2085

9168

if (outer_ref)

2086

9169

return cmp;

2087

JoinTable **idx= (JoinTable **) table_join_idx;

2088

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];

2089

9172

return cmp < 0 ? -1 : (cmp ? 1 : 0);

2090

9173

}

2091

9174

9175

2092

9176

/**

2093

9177

Generate minimal set of simple equalities equivalent to a multiple equality.

2094

9178

2128

9212

a pointer to the simple generated equality, if success.

2129

9213

- 0, otherwise.

2130

9214

2131

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)

2132

9218

{

2133

9219

List<Item> eq_list;

2134

9220

Item_func_eq *eq_item= 0;

2135

9221

if (((Item *) item_equal)->const_item() && !item_equal->val_int())

2136

return new Item_int((int64_t) 0,1);

9222

return new Item_int((int64_t) 0,1);

2137

9223

Item *item_const= item_equal->get_const();

2138

9224

Item_equal_iterator it(*item_equal);

2139

9225

Item *head;

2150

9236

Item_equal *upper= item_field->find_item_equal(upper_levels);

2151

9237

Item_field *item= item_field;

2152

9238

if (upper)

2153

{

9239

{

2154

9240

if (item_const && upper->get_const())

2155

9241

item= 0;

2156

9242

else

2194

9280

2195

9281

cond->quick_fix_field();

2196

9282

cond->update_used_tables();

2197

9283

2198

9284

return cond;

2199

9285

}

2200

9286

9287

2201

9288

/**

2202

9289

Substitute every field reference in a condition by the best equal field

2203

9290

and eliminate all multiple equality predicates.

2206

9293

multiple equality predicate it sorts the field references in it

2207

9294

according to the order of tables specified by the table_join_idx

2208

9295

parameter. Then it eliminates the multiple equality predicate it

2209

replacing it by the conjunction of simple equality predicates

9296

replacing it by the conjunction of simple equality predicates

2210

9297

equating every field from the multiple equality to the first

2211

9298

field in it, or to the constant, if there is any.

2212

9299

After this the function retrieves all other conjuncted

2225

9312

@return

2226

9313

The transformed condition

2227

9314

2228

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)

2229

9319

{

2230

9320

Item_equal *item_equal;

2231

9321

2240

9330

cond_equal= &((Item_cond_and *) cond)->cond_equal;

2241

9331

cond_list->disjoin((List<Item> *) &cond_equal->current_level);

2242

9332

2243

List_iterator_fast<Item_equal> it(cond_equal->current_level);

9333

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2244

9334

while ((item_equal= it++))

2245

9335

{

2246

9336

item_equal->sort(&compare_fields_by_table_order, table_join_idx);

2247

9337

}

2248

9338

}

2249

9339

2250

9340

List_iterator<Item> li(*cond_list);

2251

9341

Item *item;

2252

9342

while ((item= li++))

2279

9369

cond= new Item_int((int32_t)cond->val_bool());

2280

9370

2281

9371

}

2282

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

9372

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

2283

9373

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2284

9374

{

2285

9375

item_equal= (Item_equal *) cond;

2293

9383

return cond;

2294

9384

}

2295

9385

9386

2296

9387

/**

2297

9388

Check appearance of new constant items in multiple equalities

2298

9389

of a condition after reading a constant table.

2305

9396

@param cond condition whose multiple equalities are to be checked

2306

9397

@param table constant table that has been read

2307

9398

2308

static void update_const_equal_items(COND *cond, JoinTable *tab)

9399

9400

static void update_const_equal_items(COND *cond, JOIN_TAB *tab)

2309

9401

{

2310

9402

if (!(cond->used_tables() & tab->table->map))

2311

9403

return;

2312

9404

2313

9405

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

2314

9406

{

2315

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

9407

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

2316

9408

List_iterator_fast<Item> li(*cond_list);

2317

9409

Item *item;

2318

9410

while ((item= li++))

2319

9411

update_const_equal_items(item, tab);

2320

9412

}

2321

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

9413

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

2322

9414

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

2323

9415

{

2324

9416

Item_equal *item_equal= (Item_equal *) cond;

2332

9424

while ((item_field= it++))

2333

9425

{

2334

9426

Field *field= item_field->field;

2335

JoinTable *stat= field->getTable()->reginfo.join_tab;

9427

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

2336

9428

key_map possible_keys= field->key_start;

2337

possible_keys&= field->getTable()->keys_in_use_for_query;

2338

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

2339

9431

2340

9432

2341

For each field in the multiple equality (for which we know that it

2342

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

2343

9435

that key part in const_key_parts.

2344

2345

if (possible_keys.any())

9436

9437

if (!possible_keys.is_clear_all())

2346

9438

{

2347

Table *field_tab= field->getTable();

2348

optimizer::KeyUse *use;

2349

for (use= stat->keyuse; use && use->getTable() == field_tab; use++)

2350

if (possible_keys.test(use->getKey()) &&

2351

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 ==

2352

9444

field)

2353

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

9445

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

2354

9446

}

2355

9447

}

2356

9448

}

2357

9449

}

2358

9450

}

2359

9451

9452

2360

9453

2361

9454

change field = field to field = const for each found field = const in the

2362

9455

and_level

2363

9456

2364

static void change_cond_ref_to_const(Session *session,

2365

vector<COND_CMP>& save_list,

2366

Item *and_father,

2367

Item *cond,

2368

Item *field,

2369

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)

2370

9462

{

2371

9463

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

2372

9464

{

2373

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9465

bool and_level= ((Item_cond*) cond)->functype() ==

9466

Item_func::COND_AND_FUNC;

2374

9467

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

2375

9468

Item *item;

2376

9469

while ((item=li++))

2377

change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

9470

change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,

9471

field, value);

2378

9472

return;

2379

9473

}

2380

9474

if (cond->eq_cmp_result() == Item::COND_OK)

2393

9487

left_item->collation.collation == value->collation.collation))

2394

9488

{

2395

9489

Item *tmp=value->clone_item();

9490

tmp->collation.set(right_item->collation);

9491

2396

9492

if (tmp)

2397

9493

{

2398

tmp->collation.set(right_item->collation);

2399

session->change_item_tree(args + 1, tmp);

9494

thd->change_item_tree(args + 1, tmp);

2400

9495

func->update_used_tables();

2401

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2402

and_father != cond &&

2403

! left_item->const_item())

9496

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9497

&& and_father != cond && !left_item->const_item())

2404

9498

{

2405

cond->marker=1;

2406

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

2407

9503

}

2408

9504

func->set_cmp_func();

2409

9505

}

2415

9511

right_item->collation.collation == value->collation.collation))

2416

9512

{

2417

9513

Item *tmp= value->clone_item();

9514

tmp->collation.set(left_item->collation);

9515

2418

9516

if (tmp)

2419

9517

{

2420

tmp->collation.set(left_item->collation);

2421

session->change_item_tree(args, tmp);

9518

thd->change_item_tree(args, tmp);

2422

9519

value= tmp;

2423

9520

func->update_used_tables();

2424

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2425

and_father != cond &&

2426

! right_item->const_item())

9521

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9522

&& and_father != cond && !right_item->const_item())

2427

9523

{

2428

9524

args[0]= args[1]; // For easy check

2429

session->change_item_tree(args + 1, value);

2430

cond->marker=1;

2431

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

2432

9530

}

2433

9531

func->set_cmp_func();

2434

9532

}

2443

9541

@return

2444

9542

new conditions

2445

9543

2446

Item *remove_additional_cond(Item* conds)

9544

9545

static Item *remove_additional_cond(Item* conds)

2447

9546

{

2448

9547

if (conds->name == in_additional_cond)

2449

9548

return 0;

2466

9565

return conds;

2467

9566

}

2468

9567

2469

static void propagate_cond_constants(Session *session,

2470

vector<COND_CMP>& save_list,

2471

COND *and_father,

2472

COND *cond)

9568

static void

9569

propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,

9570

COND *and_father, COND *cond)

2473

9571

{

2474

9572

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

2475

9573

{

2476

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9574

bool and_level= ((Item_cond*) cond)->functype() ==

9575

Item_func::COND_AND_FUNC;

2477

9576

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

2478

9577

Item *item;

2479

vector<COND_CMP> save;

9578

I_List<COND_CMP> save;

2480

9579

while ((item=li++))

2481

9580

{

2482

propagate_cond_constants(session, save, and_level ? cond : item, item);

9581

propagate_cond_constants(thd, &save,and_level ? cond : item, item);

2483

9582

}

2484

9583

if (and_level)

2485

{

2486

// Handle other found items

2487

for (vector<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++))

2488

9588

{

2489

Item **args= iter->cmp_func->arguments();

9589

Item **args= cond_cmp->cmp_func->arguments();

2490

9590

if (!args[0]->const_item())

2491

{

2492

change_cond_ref_to_const( session, save, iter->and_level,

2493

iter->and_level, args[0], args[1] );

2494

}

9591

change_cond_ref_to_const(thd, &save,cond_cmp->and_level,

9592

cond_cmp->and_level, args[0], args[1]);

2495

9593

}

2496

9594

}

2497

9595

}

2498

9596

else if (and_father != cond && !cond->marker) // In a AND group

2499

9597

{

2500

9598

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

2501

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

2502

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

2503

9601

{

2504

9602

Item_func_eq *func=(Item_func_eq*) cond;

2505

9603

Item **args= func->arguments();

2508

9606

if (!(left_const && right_const) &&

2509

9607

args[0]->result_type() == args[1]->result_type())

2510

9608

{

2511

if (right_const)

2512

{

2513

resolve_const_item(session, &args[1], args[0]);

2514

func->update_used_tables();

2515

change_cond_ref_to_const(session, save_list, and_father, and_father,

2516

args[0], args[1]);

2517

}

2518

else if (left_const)

2519

{

2520

resolve_const_item(session, &args[0], args[1]);

2521

func->update_used_tables();

2522

change_cond_ref_to_const(session, save_list, and_father, and_father,

2523

args[1], args[0]);

2524

}

2525

}

2526

}

2527

}

2528

}

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

2529

10002

2530

10003

/**

2531

10004

Check interleaving with an inner tables of an outer join for

2532

10005

extension table.

2533

10006

2534

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

2535

10008

if yes, record that it has been added.

2536

10009

2537

10010

The function assumes that both current partial join order and its

2538

10011

extension with next_tab are valid wrt table dependencies.

2539

10012

2540

10013

@verbatim

2541

IMPLEMENTATION

10014

IMPLEMENTATION

2542

10015

LIMITATIONS ON JOIN order_st

2543

10016

The nested [outer] joins executioner algorithm imposes these limitations

2544

10017

on join order:

2545

1. "Outer tables first" - any "outer" table must be before any

10018

1. "Outer tables first" - any "outer" table must be before any

2546

10019

corresponding "inner" table.

2547

10020

2. "No interleaving" - tables inside a nested join must form a continuous

2548

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

2549

10022

tables that are outside of this nested join).

2550

10023

2551

10024

#1 is checked elsewhere, this function checks #2 provided that #1 has

2552

10025

been already checked.

2553

10026

2554

10027

WHY NEED NON-INTERLEAVING

2555

Consider an example:

10028

Consider an example:

2556

10029

2557

10030

select * from t0 join t1 left join (t2 join t3) on cond1

2558

10031

2576

10049

The limitations on join order can be rephrased as follows: for valid

2577

10050

join order one must be able to:

2578

10051

1. write down the used tables in the join order on one line.

2579

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

2580

10053

3. write "LEFT JOIN" and "ON (...)" where appropriate

2581

10054

4. get a query equivalent to the query we're trying to execute.

2582

10055

2583

10056

Calls to check_interleaving_with_nj() are equivalent to writing the

2584

above described line from left to right.

2585

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

2586

10059

table B and appropriate brackets on condition that table A and

2587

10060

appropriate brackets is the last what was written. Graphically the

2588

10061

transition is as follows:

2595

10068

position.

2596

10069

2597

10070

Notes about the position:

2598

The caller guarantees that there is no more then one X-bracket by

2599

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

2600

10073

function. X-bracket may have a pair in Y-bracket.

2601

10074

2602

10075

When "writing" we store/update this auxilary info about the current

2609

10082

@endverbatim

2610

10083

2611

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)

2612

10087

@param next_tab Table we're going to extend the current partial join with

2613

10088

2614

10089

@retval

2617

10092

@retval

2618

10093

true Requested join order extension not allowed.

2619

10094

2620

bool check_interleaving_with_nj(JoinTable *next_tab)

10095

10096

static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)

2621

10097

{

2622

TableList *next_emb= next_tab->table->pos_in_table_list->getEmbedding();

2623

Join *join= next_tab->join;

10098

TableList *next_emb= next_tab->table->pos_in_table_list->embedding;

10099

JOIN *join= last_tab->join;

2624

10100

2625

if ((join->cur_embedding_map & ~next_tab->embedding_map).any())

10101

if (join->cur_embedding_map & ~next_tab->embedding_map)

2626

10102

{

2627

10103

2628

10104

next_tab is outside of the "pair of brackets" we're currently in.

2629

10105

Cannot add it.

2630

10106

2631

10107

return true;

2632

10108

}

2633

10109

2634

10110

2635

10111

Do update counters for "pairs of brackets" that we've left (marked as

2636

10112

X,Y,Z in the above picture)

2637

10113

2638

for (;next_emb; next_emb= next_emb->getEmbedding())

10114

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

2639

10115

{

2640

next_emb->getNestedJoin()->counter_++;

2641

if (next_emb->getNestedJoin()->counter_ == 1)

10116

next_emb->nested_join->counter_++;

10117

if (next_emb->nested_join->counter_ == 1)

2642

10118

{

2643

10119

2644

10120

next_emb is the first table inside a nested join we've "entered". In

2645

10121

the picture above, we're looking at the 'X' bracket. Don't exit yet as

2646

10122

X bracket might have Y pair bracket.

2647

10123

2648

join->cur_embedding_map |= next_emb->getNestedJoin()->nj_map;

10124

join->cur_embedding_map |= next_emb->nested_join->nj_map;

2649

10125

}

2650

2651

if (next_emb->getNestedJoin()->join_list.elements !=

2652

next_emb->getNestedJoin()->counter_)

10126

10127

if (next_emb->nested_join->join_list.elements !=

10128

next_emb->nested_join->counter_)

2653

10129

break;

2654

10130

2655

10131

2656

10132

We're currently at Y or Z-bracket as depicted in the above picture.

2657

10133

Mark that we've left it and continue walking up the brackets hierarchy.

2658

10134

2659

join->cur_embedding_map &= ~next_emb->getNestedJoin()->nj_map;

10135

join->cur_embedding_map &= ~next_emb->nested_join->nj_map;

2660

10136

}

2661

10137

return false;

2662

10138

}

2663

10139

2664

COND *optimize_cond(Join *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)

2665

{

2666

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;

2667

10214

2668

10215

if (!conds)

2669

10216

*cond_value= Item::COND_TRUE;

2670

10217

else

2671

10218

{

2672

10219

2673

10220

Build all multiple equality predicates and eliminate equality

2674

10221

predicates that can be inferred from these multiple equalities.

2675

10222

For each reference of a field included into a multiple equality

2676

10223

that occurs in a function set a pointer to the multiple equality

2677

10224

predicate. Substitute a constant instead of this field if the

2678

10225

multiple equality contains a constant.

2679

2680

conds= build_equal_items(join->session, conds, NULL, join_list,

10226

10227

conds= build_equal_items(join->thd, conds, NULL, join_list,

2681

10228

&join->cond_equal);

2682

10229

2683

10230

/* change field = field to field = const for each found field = const */

2684

vector<COND_CMP> temp;

2685

propagate_cond_constants(session, temp, conds, conds);

10231

propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);

2686

10232

2687

10233

Remove all instances of item == item

2688

10234

Remove all and-levels where CONST item != CONST item

2689

10235

2690

conds= remove_eq_conds(session, conds, cond_value) ;

10236

conds= remove_eq_conds(thd, conds, cond_value) ;

2691

10237

}

2692

10238

return(conds);

2693

10239

}

2694

10240

10241

2695

10242

/**

2696

10243

Remove const and eq items.

2697

10244

2702

10249

- COND_TRUE : always true ( 1 = 1 )

2703

10250

- COND_FALSE : always false ( 1 = 2 )

2704

10251

2705

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)

2706

10255

{

2707

10256

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

2708

10257

{

2709

bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

2710

10258

bool and_level= ((Item_cond*) cond)->functype()

10259

== Item_func::COND_AND_FUNC;

2711

10260

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

2712

10261

Item::cond_result tmp_cond_value;

2713

bool should_fix_fields= false;

10262

bool should_fix_fields=0;

2714

10263

2715

*cond_value= Item::COND_UNDEF;

10264

*cond_value=Item::COND_UNDEF;

2716

10265

Item *item;

2717

while ((item= li++))

10266

while ((item=li++))

2718

10267

{

2719

Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);

2720

if (! new_item)

2721

li.remove();

10268

Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);

10269

if (!new_item)

10270

li.remove();

2722

10271

else if (item != new_item)

2723

10272

{

2724

li.replace(new_item);

2725

should_fix_fields= true;

10273

li.replace(new_item);

10274

should_fix_fields=1;

2726

10275

}

2727

10276

if (*cond_value == Item::COND_UNDEF)

2728

*cond_value= tmp_cond_value;

2729

2730

switch (tmp_cond_value)

2731

{

2732

case Item::COND_OK: /* Not true or false */

2733

if (and_level || (*cond_value == Item::COND_FALSE))

2734

*cond_value= tmp_cond_value;

2735

break;

2736

case Item::COND_FALSE:

2737

if (and_level)

2738

{

2739

*cond_value= tmp_cond_value;

2740

return (COND *) NULL; /* Always false */

2741

}

2742

break;

2743

case Item::COND_TRUE:

2744

if (! and_level)

2745

{

2746

*cond_value= tmp_cond_value;

2747

return (COND *) NULL; /* Always true */

2748

}

2749

break;

2750

case Item::COND_UNDEF: /* Impossible */

2751

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 */

2752

10299

}

2753

10300

}

2754

2755

10301

if (should_fix_fields)

2756

10302

cond->update_used_tables();

2757

10303

2758

if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)

2759

return (COND*) NULL;

2760

10304

if (!((Item_cond*) cond)->argument_list()->elements ||

10305

*cond_value != Item::COND_OK)

10306

return (COND*) 0;

2761

10307

if (((Item_cond*) cond)->argument_list()->elements == 1)

2762

{

2763

/* Argument list contains only one element, so reduce it so a single item, then remove list */

10308

{ // Remove list

2764

10309

item= ((Item_cond*) cond)->argument_list()->head();

2765

10310

((Item_cond*) cond)->argument_list()->empty();

2766

10311

return item;

2767

10312

}

2768

10313

}

2769

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)

2770

10316

{

2771

10317

2772

10318

Handles this special case for some ODBC applications:

2778

10324

SELECT * from table_name where auto_increment_column = LAST_INSERT_ID

2779

10325

2780

10326

2781

Item_func_isnull *func= (Item_func_isnull*) cond;

10327

Item_func_isnull *func=(Item_func_isnull*) cond;

2782

10328

Item **args= func->arguments();

2783

10329

if (args[0]->type() == Item::FIELD_ITEM)

2784

10330

{

2785

Field *field= ((Item_field*) args[0])->field;

2786

if (field->flags & AUTO_INCREMENT_FLAG

2787

&& ! field->getTable()->maybe_null

2788

&& session->options & OPTION_AUTO_IS_NULL

2789

&& (

2790

session->first_successful_insert_id_in_prev_stmt > 0

2791

&& session->substitute_null_with_insert_id

2792

)

2793

)

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

2794

10336

{

2795

COND *new_cond;

2796

if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",

2797

session->read_first_successful_insert_id_in_prev_stmt(),

2798

MY_INT64_NUM_DECIMAL_DIGITS))))

2799

{

2800

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;

2801

10344

2802

10345

Item_func_eq can't be fixed after creation so we do not check

2803

10346

cond->fixed, also it do not need tables so we use 0 as second

2804

10347

argument.

2805

10348

2806

cond->fix_fields(session, &cond);

2807

}

10349

cond->fix_fields(thd, &cond);

10350

}

2808

10351

2809

10352

IS NULL should be mapped to LAST_INSERT_ID only for first row, so

2810

10353

clear for next row

2811

10354

2812

session->substitute_null_with_insert_id= false;

10355

thd->substitute_null_with_insert_id= false;

2813

10356

}

2814

#ifdef NOTDEFINED

2815

10357

/* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */

2816

else if (

2817

((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME))

2818

&& (field->flags & NOT_NULL_FLAG)

2819

&& ! 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)

2820

10362

{

2821

COND *new_cond;

2822

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

2823

{

2824

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;

2825

10367

2826

10368

Item_func_eq can't be fixed after creation so we do not check

2827

10369

cond->fixed, also it do not need tables so we use 0 as second

2828

10370

argument.

2829

10371

2830

cond->fix_fields(session, &cond);

2831

}

10372

cond->fix_fields(thd, &cond);

10373

}

2832

10374

}

2833

#endif /* NOTDEFINED */

2834

10375

}

2835

10376

if (cond->const_item())

2836

10377

{

2837

10378

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2838

return (COND *) NULL;

10379

return (COND*) 0;

2839

10380

}

2840

10381

}

2841

10382

else if (cond->const_item() && !cond->is_expensive())

2842

10383

2843

10384

TODO:

2844

10385

Excluding all expensive functions is too restritive we should exclude only

2845

materialized IN subquery predicates because they can't yet be evaluated

2846

here (they need additional initialization that is done later on).

2847

2848

The proper way to exclude the subqueries would be to walk the cond tree and

2849

check for materialized subqueries there.

2850

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

2851

10392

2852

10393

{

2853

10394

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

2854

return (COND *) NULL;

10395

return (COND*) 0;

2855

10396

}

2856

10397

else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)

2857

{

2858

/* boolan compare function */

10398

{ // boolan compare function

2859

10399

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

2860

10400

Item *right_item= ((Item_func*) cond)->arguments()[1];

2861

10401

if (left_item->eq(right_item,1))

2862

10402

{

2863

if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

2864

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

2865

10406

}

2866

10407

}

2867

*cond_value= Item::COND_OK;

2868

return cond; /* Point at next and return into recursion */

10408

*cond_value=Item::COND_OK;

10409

return cond; // Point at next and level

2869

10410

}

2870

10411

2871

10412

2872

10413

Check if equality can be used in removing components of GROUP BY/DISTINCT

2873

10414

2874

10415

SYNOPSIS

2875

10416

test_if_equality_guarantees_uniqueness()

2876

10417

l the left comparison argument (a field if any)

2877

10418

r the right comparison argument (a const of any)

2878

2879

DESCRIPTION

2880

Checks if an equality predicate can be used to take away

2881

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

2882

10423

distinct value (e.g. <expr> == <const>).

2883

Arguments must be of the same type because e.g.

2884

<string_field> = <int_const> may match more than 1 distinct value from

2885

the column.

2886

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

2887

10428

string constants when compared to dates etc (see Item_int_with_ref) as

2888

10429

well as the collation of the arguments.

2889

2890

RETURN VALUE

10430

10431

RETURN VALUE

2891

10432

true can be used

2892

10433

false cannot be used

2893

10434

2894

static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)

10435

static bool

10436

test_if_equality_guarantees_uniqueness(Item *l, Item *r)

2895

10437

{

2896

10438

return r->const_item() &&

2897

10439

/* elements must be compared as dates */

2906

10448

/**

2907

10449

Return true if the item is a const value in all the WHERE clause.

2908

10450

2909

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)

2910

10454

{

2911

10455

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

2912

10456

{

2919

10463

bool res=const_expression_in_where(item, comp_item, const_item);

2920

10464

if (res) // Is a const value

2921

10465

{

2922

if (and_level)

2923

return 1;

10466

if (and_level)

10467

return 1;

2924

10468

}

2925

10469

else if (!and_level)

2926

return 0;

10470

return 0;

2927

10471

}

2928

10472

return and_level ? 0 : 1;

2929

10473

}

2931

10475

{ // boolan compare function

2932

10476

Item_func* func= (Item_func*) cond;

2933

10477

if (func->functype() != Item_func::EQUAL_FUNC &&

2934

func->functype() != Item_func::EQ_FUNC)

10478

func->functype() != Item_func::EQ_FUNC)

2935

10479

return 0;

2936

10480

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

2937

10481

Item *right_item= ((Item_func*) cond)->arguments()[1];

2939

10483

{

2940

10484

if (test_if_equality_guarantees_uniqueness (left_item, right_item))

2941

10485

{

2942

if (*const_item)

2943

return right_item->eq(*const_item, 1);

2944

*const_item=right_item;

2945

return 1;

10486

if (*const_item)

10487

return right_item->eq(*const_item, 1);

10488

*const_item=right_item;

10489

return 1;

2946

10490

}

2947

10491

}

2948

10492

else if (right_item->eq(comp_item,1))

2949

10493

{

2950

10494

if (test_if_equality_guarantees_uniqueness (right_item, left_item))

2951

10495

{

2952

if (*const_item)

2953

return left_item->eq(*const_item, 1);

2954

*const_item=left_item;

2955

return 1;

10496

if (*const_item)

10497

return left_item->eq(*const_item, 1);

10498

*const_item=left_item;

10499

return 1;

2956

10500

}

2957

10501

}

2958

10502

}

2959

10503

return 0;

2960

10504

}

2961

10505

10506

2962

10507

/**

2963

10508

@details

2964

10509

Rows produced by a join sweep may end up in a temporary table or be sent

2970

10515

@return

2971

10516

end_select function to use. This function can't fail.

2972

10517

2973

Next_select_func setup_end_select_func(Join *join)

10518

10519

Next_select_func setup_end_select_func(JOIN *join)

2974

10520

{

2975

10521

Table *table= join->tmp_table;

2976

Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;

10522

TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;

2977

10523

Next_select_func end_select;

2978

10524

2979

10525

/* Set up select_end */

2980

10526

if (table)

2981

10527

{

2982

if (table->group && tmp_tbl->sum_func_count &&

10528

if (table->group && tmp_tbl->sum_func_count &&

2983

10529

!tmp_tbl->precomputed_group_by)

2984

10530

{

2985

if (table->getShare()->sizeKeys())

10531

if (table->s->keys)

2986

10532

{

2987

end_select= end_update;

10533

end_select=end_update;

2988

10534

}

2989

10535

else

2990

10536

{

2991

end_select= end_unique_update;

10537

end_select=end_unique_update;

2992

10538

}

2993

10539

}

2994

10540

else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)

2995

10541

{

2996

end_select= end_write_group;

10542

end_select=end_write_group;

2997

10543

}

2998

10544

else

2999

10545

{

3000

end_select= end_write;

10546

end_select=end_write;

3001

10547

if (tmp_tbl->precomputed_group_by)

3002

10548

{

3003

10549

3004

10550

A preceding call to create_tmp_table in the case when loose

3005

10551

index scan is used guarantees that

3006

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

3007

10553

by functions. It is OK here to use memcpy since we copy

3008

10554

Item_sum pointers into an array of Item pointers.

3009

10555

3025

10571

return end_select;

3026

10572

}

3027

10573

10574

3028

10575

/**

3029

10576

Make a join of all tables and write it on socket or to table.

3030

10577

3035

10582

@retval

3036

10583

-1 if error should be sent

3037

10584

3038

int do_select(Join *join, List<Item> *fields, Table *table)

10585

10586

static int

10587

do_select(JOIN *join,List<Item> *fields,Table *table)

3039

10588

{

3040

10589

int rc= 0;

3041

10590

enum_nested_loop_state error= NESTED_LOOP_OK;

3042

JoinTable *join_tab= NULL;

3043

10591

JOIN_TAB *join_tab= NULL;

10592

3044

10593

join->tmp_table= table; /* Save for easy recursion */

3045

10594

join->fields= fields;

3046

10595

3047

10596

if (table)

3048

10597

{

3049

table->cursor->extra(HA_EXTRA_WRITE_CACHE);

3050

table->emptyRecord();

10598

table->file->extra(HA_EXTRA_WRITE_CACHE);

10599

empty_record(table);

3051

10600

if (table->group && join->tmp_table_param.sum_func_count &&

3052

table->getShare()->sizeKeys() && !table->cursor->inited)

3053

table->cursor->startIndexScan(0, 0);

10601

table->s->keys && !table->file->inited)

10602

table->file->ha_index_init(0, 0);

3054

10603

}

3055

10604

/* Set up select_end */

3056

10605

Next_select_func end_select= setup_end_select_func(join);

3071

10620

{

3072

10621

error= (*end_select)(join, 0, 0);

3073

10622

if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)

3074

error= (*end_select)(join, 0, 1);

10623

error= (*end_select)(join, 0, 1);

3075

10624

3076

10625

3077

10626

If we don't go through evaluate_join_record(), do the counting

3079

10628

so we don't touch it here.

3080

10629

3081

10630

join->examined_rows++;

3082

join->session->row_count++;

10631

join->thd->row_count++;

3083

10632

assert(join->examined_rows <= 1);

3084

10633

}

3085

10634

else if (join->send_row_on_empty_set())

3109

10658

if (!table) // If sending data to client

3110

10659

{

3111

10660

3112

The following will unlock all cursors if the command wasn't an

3113

update command

10661

The following will unlock all cursors if the command wasn't an

10662

update command

3114

10663

3115

10664

join->join_free(); // Unlock all cursors

3116

10665

if (join->result->send_eof())

3117

rc= 1; // Don't send error

10666

rc= 1; // Don't send error

3118

10667

}

3119

10668

}

3120

10669

else

3122

10671

if (table)

3123

10672

{

3124

10673

int tmp, new_errno= 0;

3125

if ((tmp=table->cursor->extra(HA_EXTRA_NO_CACHE)))

10674

if ((tmp=table->file->extra(HA_EXTRA_NO_CACHE)))

3126

10675

{

3127

10676

new_errno= tmp;

3128

10677

}

3129

if ((tmp=table->cursor->ha_index_or_rnd_end()))

10678

if ((tmp=table->file->ha_index_or_rnd_end()))

3130

10679

{

3131

10680

new_errno= tmp;

3132

10681

}

3133

10682

if (new_errno)

3134

table->print_error(new_errno,MYF(0));

10683

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

3135

10684

}

3136

return(join->session->is_error() ? -1 : rc);

10685

return(join->thd->is_error() ? -1 : rc);

3137

10686

}

3138

10687

3139

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)

3140

10691

{

3141

10692

enum_nested_loop_state rc;

3142

10693

3147

10698

rc= sub_select(join,join_tab,end_of_records);

3148

10699

return rc;

3149

10700

}

3150

if (join->session->getKilled()) // If aborted by user

10701

if (join->thd->killed) // If aborted by user

3151

10702

{

3152

join->session->send_kill_message();

3153

return NESTED_LOOP_KILLED;

10703

join->thd->send_kill_message();

10704

return NESTED_LOOP_KILLED; /* purecov: inspected */

3154

10705

}

3155

10706

if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)

3156

10707

{

3157

if (! join_tab->cache.store_record_in_cache())

10708

if (!store_record_in_cache(&join_tab->cache))

3158

10709

return NESTED_LOOP_OK; // There is more room in cache

3159

10710

return flush_cached_records(join,join_tab,false);

3160

10711

}

3167

10718

/**

3168

10719

Retrieve records ends with a given beginning from the result of a join.

3169

10720

3170

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

3171

10722

preceding the table join_tab in the execution plan, the function

3172

10723

retrieves all matching full records from the result set and

3173

send them to the result set stream.

10724

send them to the result set stream.

3174

10725

3175

10726

@note

3176

10727

The function effectively implements the final (n-k) nested loops

3210

10761

first row with t3.a=t1.a has been encountered.

3211

10762

Thus, the second predicate P2 is supplied with a guarded value that are

3212

10763

stored in the field 'found' of the first inner table for the outer join

3213

(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

3214

10765

of table t1 appears, the value becomes true. For now on the predicate

3215

10766

is evaluated immediately after the row of table t2 has been read.

3216

10767

When the first row with t3.a=t1.a has been encountered all

3218

10769

Only when all of them are true the row is sent to the output stream.

3219

10770

If not, the function returns to the lowest nest level that has a false

3220

10771

attached condition.

3221

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

3222

10773

the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),

3223

10774

then t1.a=t2.a would be pushed down to table t2, and without any

3224

10775

guard.

3228

10779

is complemented by nulls for t2 and t3. Then the pushed down predicates

3229

10780

are checked for the composed row almost in the same way as it had

3230

10781

been done for the first row with a match. The only difference is

3231

the predicates from on expressions are not checked.

10782

the predicates from on expressions are not checked.

3232

10783

3233

10784

@par

3234

10785

@b IMPLEMENTATION

3244

10795

and a pointer to a guarding boolean variable.

3245

10796

When the value of the guard variable is true the value of the object

3246

10797

is the same as the value of the predicate, otherwise it's just returns

3247

true.

3248

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

3249

10800

to t is remembered in the field 'return_tab' of the join structure.

3250

10801

Consider the following query:

3251

10802

@code

3262

10813

t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL

3263

10814

becomes 'activated', as well the predicate t4.a=t2.a. But

3264

10815

the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until

3265

t4.a=t2.a becomes true.

10816

t4.a=t2.a becomes true.

3266

10817

In order not to re-evaluate the predicates that were already evaluated

3267

10818

as attached pushed down predicates, a pointer to the the first

3268

10819

most inner unmatched table is maintained in join_tab->first_unmatched.

3269

10820

Thus, when the first row from t5 with t5.a=t3.a is found

3270

this pointer for t5 is changed from t4 to t2.

10821

this pointer for t5 is changed from t4 to t2.

3271

10822

3272

10823

@par

3273

10824

@b STRUCTURE @b NOTES

3278

10829

@param join pointer to the structure providing all context info for

3279

10830

the query

3280

10831

@param join_tab the first next table of the execution plan to be retrieved

3281

@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

3282

10833

3283

10834

@return

3284

10835

return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.

3285

10836

3286

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)

3287

10841

{

3288

10842

join_tab->table->null_row=0;

3289

10843

if (end_of_records)

3291

10845

3292

10846

int error;

3293

10847

enum_nested_loop_state rc;

3294

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

}

3295

10854

3296

10855

if (join->resume_nested_loop)

3297

10856

{

3319

10878

/* Set first_unmatched for the last inner table of this group */

3320

10879

join_tab->last_inner->first_unmatched= join_tab;

3321

10880

}

3322

join->session->row_count= 0;

10881

join->thd->row_count= 0;

3323

10882

3324

10883

error= (*join_tab->read_first_record)(join_tab);

3325

10884

rc= evaluate_join_record(join, join_tab, error);

3326

10885

}

3327

3328

3329

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

3330

10889

change should probably be made in 5.1, too.

3331

10890

3332

10891

while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)

3344

10903

return rc;

3345

10904

}

3346

10905

3347

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)

3348

11288

{

3349

11289

int error;

3350

11290

Table *table= tab->table;

3351

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11291

if ((error=table->file->index_read_map(table->record[0],

3352

11292

tab->ref.key_buff,

3353

11293

make_prev_keypart_map(tab->ref.key_parts),

3354

11294

HA_READ_KEY_EXACT)))

3356

11296

return 0;

3357

11297

}

3358

11298

3359

int join_read_const_table(JoinTable *tab, optimizer::Position *pos)

11299

11300

static int

11301

join_read_const_table(JOIN_TAB *tab, POSITION *pos)

3360

11302

{

3361

11303

int error;

3362

11304

Table *table=tab->table;

3363

11305

table->const_table=1;

3364

11306

table->null_row=0;

3365

11307

table->status=STATUS_NO_RECORD;

3366

3367

if (tab->type == AM_SYSTEM)

11308

11309

if (tab->type == JT_SYSTEM)

3368

11310

{

3369

11311

if ((error=join_read_system(tab)))

3370

11312

{ // Info for DESCRIBE

3371

11313

tab->info="const row not found";

3372

11314

/* Mark for EXPLAIN that the row was not found */

3373

pos->setFanout(0.0);

3374

pos->clearRefDependMap();

3375

if (! table->maybe_null || error > 0)

3376

return(error);

11315

pos->records_read=0.0;

11316

pos->ref_depend_map= 0;

11317

if (!table->maybe_null || error > 0)

11318

return(error);

3377

11319

}

3378

11320

}

3379

11321

else

3380

11322

{

3381

if (! table->key_read &&

3382

table->covering_keys.test(tab->ref.key) &&

3383

! table->no_keyread &&

3384

(int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS)

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)

3385

11326

{

3386

11327

table->key_read=1;

3387

table->cursor->extra(HA_EXTRA_KEYREAD);

11328

table->file->extra(HA_EXTRA_KEYREAD);

3388

11329

tab->index= tab->ref.key;

3389

11330

}

3390

11331

error=join_read_const(tab);

3391

11332

if (table->key_read)

3392

11333

{

3393

11334

table->key_read=0;

3394

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

11335

table->file->extra(HA_EXTRA_NO_KEYREAD);

3395

11336

}

3396

11337

if (error)

3397

11338

{

3398

11339

tab->info="unique row not found";

3399

11340

/* Mark for EXPLAIN that the row was not found */

3400

pos->setFanout(0.0);

3401

pos->clearRefDependMap();

11341

pos->records_read=0.0;

11342

pos->ref_depend_map= 0;

3402

11343

if (!table->maybe_null || error > 0)

3403

return(error);

11344

return(error);

3404

11345

}

3405

11346

}

3406

11347

if (*tab->on_expr_ref && !table->null_row)

3407

11348

{

3408

11349

if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))

3409

table->mark_as_null_row();

11350

mark_as_null_row(table);

3410

11351

}

3411

11352

if (!table->null_row)

3412

11353

table->maybe_null=0;

3413

11354

3414

11355

/* Check appearance of new constant items in Item_equal objects */

3415

Join *join= tab->join;

11356

JOIN *join= tab->join;

3416

11357

if (join->conds)

3417

11358

update_const_equal_items(join->conds, tab);

3418

11359

TableList *tbl;

3425

11366

embedded= embedding;

3426

11367

if (embedded->on_expr)

3427

11368

update_const_equal_items(embedded->on_expr, tab);

3428

embedding= embedded->getEmbedding();

11369

embedding= embedded->embedding;

3429

11370

}

3430

11371

while (embedding &&

3431

embedding->getNestedJoin()->join_list.head() == embedded);

11372

embedding->nested_join->join_list.head() == embedded);

3432

11373

}

3433

11374

3434

11375

return(0);

3435

11376

}

3436

11377

3437

int join_read_system(JoinTable *tab)

11378

11379

static int

11380

join_read_system(JOIN_TAB *tab)

3438

11381

{

3439

11382

Table *table= tab->table;

3440

11383

int error;

3441

11384

if (table->status & STATUS_GARBAGE) // If first read

3442

11385

{

3443

if ((error=table->cursor->read_first_row(table->getInsertRecord(),

3444

table->getShare()->getPrimaryKey())))

11386

if ((error=table->file->read_first_row(table->record[0],

11387

table->s->primary_key)))

3445

11388

{

3446

11389

if (error != HA_ERR_END_OF_FILE)

3447

return table->report_error(error);

3448

tab->table->mark_as_null_row();

3449

table->emptyRecord(); // Make empty record

11390

return table->report_error(error);

11391

mark_as_null_row(tab->table);

11392

empty_record(table); // Make empty record

3450

11393

return -1;

3451

11394

}

3452

table->storeRecord();

11395

update_virtual_fields_marked_for_write(table);

11396

store_record(table,record[1]);

3453

11397

}

3454

11398

else if (!table->status) // Only happens with left join

3455

table->restoreRecord(); // restore old record

11399

restore_record(table,record[1]); // restore old record

3456

11400

table->null_row=0;

3457

11401

return table->status ? -1 : 0;

3458

11402

}

3459

11403

11404

3460

11405

/**

3461

11406

Read a (constant) table when there is at most one matching row.

3462

11407

3469

11414

@retval

3470

11415

1 Got an error (other than row not found) during read

3471

11416

3472

int join_read_const(JoinTable *tab)

11417

11418

static int

11419

join_read_const(JOIN_TAB *tab)

3473

11420

{

3474

11421

int error;

3475

11422

Table *table= tab->table;

3476

11423

if (table->status & STATUS_GARBAGE) // If first read

3477

11424

{

3478

11425

table->status= 0;

3479

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

3480

error= HA_ERR_KEY_NOT_FOUND;

11426

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

11427

error=HA_ERR_KEY_NOT_FOUND;

3481

11428

else

3482

11429

{

3483

error=table->cursor->index_read_idx_map(table->getInsertRecord(),tab->ref.key,

11430

error=table->file->index_read_idx_map(table->record[0],tab->ref.key,

3484

11431

(unsigned char*) tab->ref.key_buff,

3485

11432

make_prev_keypart_map(tab->ref.key_parts),

3486

11433

HA_READ_KEY_EXACT);

3488

11435

if (error)

3489

11436

{

3490

11437

table->status= STATUS_NOT_FOUND;

3491

tab->table->mark_as_null_row();

3492

table->emptyRecord();

11438

mark_as_null_row(tab->table);

11439

empty_record(table);

3493

11440

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3494

return table->report_error(error);

11441

return table->report_error(error);

3495

11442

return -1;

3496

11443

}

3497

table->storeRecord();

11444

update_virtual_fields_marked_for_write(table);

11445

store_record(table,record[1]);

3498

11446

}

3499

11447

else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join

3500

11448

{

3501

11449

table->status=0;

3502

table->restoreRecord(); // restore old record

11450

restore_record(table,record[1]); // restore old record

3503

11451

}

3504

11452

table->null_row=0;

3505

11453

return table->status ? -1 : 0;

3506

11454

}

3507

11455

11456

3508

11457

3509

11458

eq_ref access method implementation: "read_first" function

3510

11459

3511

11460

SYNOPSIS

3512

11461

join_read_key()

3513

tab JoinTable of the accessed table

11462

tab JOIN_TAB of the accessed table

3514

11463

3515

11464

DESCRIPTION

3516

11465

This is "read_fist" function for the "ref" access method. The difference

3518

11467

3519

11468

RETURN

3520

11469

0 - Ok

3521

-1 - Row not found

11470

-1 - Row not found

3522

11471

1 - Error

3523

11472

3524

int join_read_key(JoinTable *tab)

11473

11474

static int

11475

join_read_key(JOIN_TAB *tab)

3525

11476

{

3526

11477

int error;

3527

11478

Table *table= tab->table;

3528

11479

3529

if (!table->cursor->inited)

11480

if (!table->file->inited)

3530

11481

{

3531

table->cursor->startIndexScan(tab->ref.key, tab->sorted);

11482

table->file->ha_index_init(tab->ref.key, tab->sorted);

3532

11483

}

3533

11484

3534

11485

/* TODO: Why don't we do "Late NULLs Filtering" here? */

3540

11491

table->status=STATUS_NOT_FOUND;

3541

11492

return -1;

3542

11493

}

3543

error=table->cursor->index_read_map(table->getInsertRecord(),

11494

error=table->file->index_read_map(table->record[0],

3544

11495

tab->ref.key_buff,

3545

11496

make_prev_keypart_map(tab->ref.key_parts),

3546

11497

HA_READ_KEY_EXACT);

3551

11502

return table->status ? -1 : 0;

3552

11503

}

3553

11504

11505

3554

11506

3555

11507

ref access method implementation: "read_first" function

3556

11508

3557

11509

SYNOPSIS

3558

11510

join_read_always_key()

3559

tab JoinTable of the accessed table

11511

tab JOIN_TAB of the accessed table

3560

11512

3561

11513

DESCRIPTION

3562

This is "read_first" function for the "ref" access method.

3563

11514

This is "read_fist" function for the "ref" access method.

11515

3564

11516

The functon must leave the index initialized when it returns.

3565

11517

ref_or_null access implementation depends on that.

3566

11518

3567

11519

RETURN

3568

11520

0 - Ok

3569

-1 - Row not found

11521

-1 - Row not found

3570

11522

1 - Error

3571

11523

3572

int join_read_always_key(JoinTable *tab)

11524

11525

static int

11526

join_read_always_key(JOIN_TAB *tab)

3573

11527

{

3574

11528

int error;

3575

11529

Table *table= tab->table;

3576

11530

3577

11531

/* Initialize the index first */

3578

if (!table->cursor->inited)

3579

table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3580

11532

if (!table->file->inited)

11533

table->file->ha_index_init(tab->ref.key, tab->sorted);

11534

3581

11535

/* Perform "Late NULLs Filtering" (see internals manual for explanations) */

3582

11536

for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)

3583

11537

{

3585

11539

return -1;

3586

11540

}

3587

11541

3588

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11542

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3589

11543

return -1;

3590

if ((error=table->cursor->index_read_map(table->getInsertRecord(),

11544

if ((error=table->file->index_read_map(table->record[0],

3591

11545

tab->ref.key_buff,

3592

11546

make_prev_keypart_map(tab->ref.key_parts),

3593

11547

HA_READ_KEY_EXACT)))

3594

11548

{

3595

11549

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3596

11550

return table->report_error(error);

3597

return -1;

11551

return -1; /* purecov: inspected */

3598

11552

}

3599

11553

update_virtual_fields_marked_for_write(table);

3600

11554

return 0;

3601

11555

}

3602

11556

11557

3603

11558

/**

3604

This function is used when optimizing away ORDER BY in

3605

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

11559

This function is used when optimizing away order_st BY in

11560

SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.

3606

11561

3607

int join_read_last_key(JoinTable *tab)

11562

11563

static int

11564

join_read_last_key(JOIN_TAB *tab)

3608

11565

{

3609

11566

int error;

3610

11567

Table *table= tab->table;

3611

11568

3612

if (!table->cursor->inited)

3613

table->cursor->startIndexScan(tab->ref.key, tab->sorted);

3614

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11569

if (!table->file->inited)

11570

table->file->ha_index_init(tab->ref.key, tab->sorted);

11571

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3615

11572

return -1;

3616

if ((error=table->cursor->index_read_last_map(table->getInsertRecord(),

11573

if ((error=table->file->index_read_last_map(table->record[0],

3617

11574

tab->ref.key_buff,

3618

11575

make_prev_keypart_map(tab->ref.key_parts))))

3619

11576

{

3620

11577

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3621

11578

return table->report_error(error);

3622

return -1;

11579

return -1; /* purecov: inspected */

3623

11580

}

3624

11581

return 0;

3625

11582

}

3626

11583

3627

int join_no_more_records(ReadRecord *)

11584

11585

/* ARGSUSED */

11586

static int

11587

join_no_more_records(READ_RECORD *info __attribute__((unused)))

3628

11588

{

3629

11589

return -1;

3630

11590

}

3631

11591

3632

int join_read_next_same_diff(ReadRecord *info)

11592

static int

11593

join_read_next_same_diff(READ_RECORD *info)

3633

11594

{

3634

11595

Table *table= info->table;

3635

JoinTable *tab=table->reginfo.join_tab;

11596

JOIN_TAB *tab=table->reginfo.join_tab;

3636

11597

if (tab->insideout_match_tab->found_match)

3637

11598

{

3638

KeyInfo *key= tab->table->key_info + tab->index;

3639

11599

KEY *key= tab->table->key_info + tab->index;

11600

3640

11601

{

3641

11602

int error;

3642

11603

/* Save index tuple from record to the buffer */

3643

11604

key_copy(tab->insideout_buf, info->record, key, 0);

3644

11605

3645

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11606

if ((error=table->file->index_next_same(table->record[0],

3646

11607

tab->ref.key_buff,

3647

11608

tab->ref.key_length)))

3648

11609

{

3651

11612

table->status= STATUS_GARBAGE;

3652

11613

return -1;

3653

11614

}

3654

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11615

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3655

11616

tab->insideout_buf, key->key_length));

3656

11617

tab->insideout_match_tab->found_match= 0;

3657

11618

return 0;

3660

11621

return join_read_next_same(info);

3661

11622

}

3662

11623

3663

int join_read_next_same(ReadRecord *info)

11624

static int

11625

join_read_next_same(READ_RECORD *info)

3664

11626

{

3665

11627

int error;

3666

11628

Table *table= info->table;

3667

JoinTable *tab=table->reginfo.join_tab;

11629

JOIN_TAB *tab=table->reginfo.join_tab;

3668

11630

3669

if ((error=table->cursor->index_next_same(table->getInsertRecord(),

11631

if ((error=table->file->index_next_same(table->record[0],

3670

11632

tab->ref.key_buff,

3671

11633

tab->ref.key_length)))

3672

11634

{

3675

11637

table->status= STATUS_GARBAGE;

3676

11638

return -1;

3677

11639

}

3678

11640

update_virtual_fields_marked_for_write(table);

3679

11641

return 0;

3680

11642

}

3681

11643

3682

int join_read_prev_same(ReadRecord *info)

11644

11645

static int

11646

join_read_prev_same(READ_RECORD *info)

3683

11647

{

3684

11648

int error;

3685

11649

Table *table= info->table;

3686

JoinTable *tab=table->reginfo.join_tab;

11650

JOIN_TAB *tab=table->reginfo.join_tab;

3687

11651

3688

if ((error=table->cursor->index_prev(table->getInsertRecord())))

11652

if ((error=table->file->index_prev(table->record[0])))

3689

11653

return table->report_error(error);

3690

11654

if (key_cmp_if_same(table, tab->ref.key_buff, tab->ref.key,

3691

11655

tab->ref.key_length))

3693

11657

table->status=STATUS_NOT_FOUND;

3694

11658

error= -1;

3695

11659

}

11660

update_virtual_fields_marked_for_write(table);

3696

11661

return error;

3697

11662

}

3698

11663

3699

int join_init_quick_read_record(JoinTable *tab)

11664

11665

static int

11666

join_init_quick_read_record(JOIN_TAB *tab)

3700

11667

{

3701

11668

if (test_if_quick_select(tab) == -1)

3702

11669

return -1; /* No possible records */

3703

11670

return join_init_read_record(tab);

3704

11671

}

3705

11672

3706

int init_read_record_seq(JoinTable *tab)

11673

11674

int rr_sequential(READ_RECORD *info);

11675

int init_read_record_seq(JOIN_TAB *tab)

3707

11676

{

3708

tab->read_record.init_reard_record_sequential();

3709

3710

if (tab->read_record.cursor->startTableScan(1))

11677

tab->read_record.read_record= rr_sequential;

11678

if (tab->read_record.file->ha_rnd_init(1))

3711

11679

return 1;

3712

11680

return (*tab->read_record.read_record)(&tab->read_record);

3713

11681

}

3714

11682

3715

int test_if_quick_select(JoinTable *tab)

11683

static int

11684

test_if_quick_select(JOIN_TAB *tab)

3716

11685

{

3717

11686

delete tab->select->quick;

3718

tab->select->quick= 0;

3719

return tab->select->test_quick_select(tab->join->session, tab->keys,

3720

(table_map) 0, HA_POS_ERROR, 0, false);

11687

tab->select->quick=0;

11688

return tab->select->test_quick_select(tab->join->thd, tab->keys,

11689

(table_map) 0, HA_POS_ERROR, 0,

11690

false);

3721

11691

}

3722

11692

3723

int join_init_read_record(JoinTable *tab)

11693

11694

static int

11695

join_init_read_record(JOIN_TAB *tab)

3724

11696

{

3725

11697

if (tab->select && tab->select->quick && tab->select->quick->reset())

3726

11698

return 1;

3727

3728

tab->read_record.init_read_record(tab->join->session, tab->table, tab->select, 1, true);

3729

11699

init_read_record(&tab->read_record, tab->join->thd, tab->table,

11700

tab->select,1,1);

3730

11701

return (*tab->read_record.read_record)(&tab->read_record);

3731

11702

}

3732

11703

3733

int join_read_first(JoinTable *tab)

11704

11705

static int

11706

join_read_first(JOIN_TAB *tab)

3734

11707

{

3735

11708

int error;

3736

11709

Table *table=tab->table;

3737

if (!table->key_read && table->covering_keys.test(tab->index) &&

11710

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3738

11711

!table->no_keyread)

3739

11712

{

3740

table->key_read= 1;

3741

table->cursor->extra(HA_EXTRA_KEYREAD);

11713

table->key_read=1;

11714

table->file->extra(HA_EXTRA_KEYREAD);

3742

11715

}

3743

tab->table->status= 0;

11716

tab->table->status=0;

3744

11717

tab->read_record.table=table;

3745

tab->read_record.cursor=table->cursor;

11718

tab->read_record.file=table->file;

3746

11719

tab->read_record.index=tab->index;

3747

tab->read_record.record=table->getInsertRecord();

11720

tab->read_record.record=table->record[0];

3748

11721

if (tab->insideout_match_tab)

3749

11722

{

3750

11723

tab->read_record.do_insideout_scan= tab;

3757

11730

tab->read_record.do_insideout_scan= 0;

3758

11731

}

3759

11732

3760

if (!table->cursor->inited)

3761

table->cursor->startIndexScan(tab->index, tab->sorted);

3762

if ((error=tab->table->cursor->index_first(tab->table->getInsertRecord())))

11733

if (!table->file->inited)

11734

table->file->ha_index_init(tab->index, tab->sorted);

11735

if ((error=tab->table->file->index_first(tab->table->record[0])))

3763

11736

{

3764

11737

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

3765

11738

table->report_error(error);

3766

11739

return -1;

3767

11740

}

3768

11741

if (not error)

11742

update_virtual_fields_marked_for_write(tab->table);

3769

11743

return 0;

3770

11744

}

3771

11745

3772

int join_read_next_different(ReadRecord *info)

11746

11747

static int

11748

join_read_next_different(READ_RECORD *info)

3773

11749

{

3774

JoinTable *tab= info->do_insideout_scan;

11750

JOIN_TAB *tab= info->do_insideout_scan;

3775

11751

if (tab->insideout_match_tab->found_match)

3776

11752

{

3777

KeyInfo *key= tab->table->key_info + tab->index;

3778

11753

KEY *key= tab->table->key_info + tab->index;

11754

3779

11755

{

3780

11756

int error;

3781

11757

/* Save index tuple from record to the buffer */

3782

11758

key_copy(tab->insideout_buf, info->record, key, 0);

3783

11759

3784

if ((error=info->cursor->index_next(info->record)))

11760

if ((error=info->file->index_next(info->record)))

3785

11761

return info->table->report_error(error);

3786

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11762

if (not error)

11763

update_virtual_fields_marked_for_write(tab->table);

11764

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3787

11765

tab->insideout_buf, key->key_length));

3788

11766

tab->insideout_match_tab->found_match= 0;

3789

11767

return 0;

3792

11770

return join_read_next(info);

3793

11771

}

3794

11772

3795

int join_read_next(ReadRecord *info)

11773

11774

static int

11775

join_read_next(READ_RECORD *info)

3796

11776

{

3797

11777

int error;

3798

if ((error=info->cursor->index_next(info->record)))

11778

if ((error=info->file->index_next(info->record)))

3799

11779

return info->table->report_error(error);

11780

if (not error)

11781

update_virtual_fields_marked_for_write(info->table);

3800

11782

return 0;

3801

11783

}

3802

11784

3803

int join_read_last(JoinTable *tab)

11785

11786

static int

11787

join_read_last(JOIN_TAB *tab)

3804

11788

{

3805

11789

Table *table=tab->table;

3806

11790

int error;

3807

if (!table->key_read && table->covering_keys.test(tab->index) &&

11791

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3808

11792

!table->no_keyread)

3809

11793

{

3810

11794

table->key_read=1;

3811

table->cursor->extra(HA_EXTRA_KEYREAD);

11795

table->file->extra(HA_EXTRA_KEYREAD);

3812

11796

}

3813

11797

tab->table->status=0;

3814

11798

tab->read_record.read_record=join_read_prev;

3815

11799

tab->read_record.table=table;

3816

tab->read_record.cursor=table->cursor;

11800

tab->read_record.file=table->file;

3817

11801

tab->read_record.index=tab->index;

3818

tab->read_record.record=table->getInsertRecord();

3819

if (!table->cursor->inited)

3820

table->cursor->startIndexScan(tab->index, 1);

3821

if ((error= tab->table->cursor->index_last(tab->table->getInsertRecord())))

11802

tab->read_record.record=table->record[0];

11803

if (!table->file->inited)

11804

table->file->ha_index_init(tab->index, 1);

11805

if ((error= tab->table->file->index_last(tab->table->record[0])))

3822

11806

return table->report_error(error);

3823

11807

if (not error)

11808

update_virtual_fields_marked_for_write(tab->table);

3824

11809

return 0;

3825

11810

}

3826

11811

3827

int join_read_prev(ReadRecord *info)

11812

11813

static int

11814

join_read_prev(READ_RECORD *info)

3828

11815

{

3829

11816

int error;

3830

if ((error= info->cursor->index_prev(info->record)))

11817

if ((error= info->file->index_prev(info->record)))

3831

11818

return info->table->report_error(error);

3832

11819

if (not error)

11820

update_virtual_fields_marked_for_write(info->table);

3833

11821

return 0;

3834

11822

}

3835

11823

3836

11824

/**

3837

11825

Reading of key with key reference and one part that may be NULL.

3838

11826

3839

int join_read_always_key_or_null(JoinTable *tab)

11827

11828

int

11829

join_read_always_key_or_null(JOIN_TAB *tab)

3840

11830

{

3841

11831

int res;

3842

11832

3850

11840

return safe_index_read(tab);

3851

11841

}

3852

11842

3853

int join_read_next_same_or_null(ReadRecord *info)

11843

11844

int

11845

join_read_next_same_or_null(READ_RECORD *info)

3854

11846

{

3855

11847

int error;

3856

11848

if ((error= join_read_next_same(info)) >= 0)

3857

11849

return error;

3858

JoinTable *tab= info->table->reginfo.join_tab;

11850

JOIN_TAB *tab= info->table->reginfo.join_tab;

3859

11851

3860

11852

/* Test if we have already done a read after null key */

3861

11853

if (*tab->ref.null_ref_key)

3864

11856

return safe_index_read(tab); // then read null keys

3865

11857

}

3866

11858

3867

enum_nested_loop_state end_send_group(Join *join, JoinTable *, bool end_of_records)

11859

11860

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

11861

DESCRIPTION

11862

Functions that end one nested loop iteration. Different functions

11863

are used to support GROUP BY clause and to redirect records

11864

to a table (e.g. in case of SELECT into a temporary table) or to the

11865

network client.

11866

11867

RETURN VALUES

11868

NESTED_LOOP_OK - the record has been successfully handled

11869

NESTED_LOOP_ERROR - a fatal error (like table corruption)

11870

was detected

11871

NESTED_LOOP_KILLED - thread shutdown was requested while processing

11872

the record

11873

NESTED_LOOP_QUERY_LIMIT - the record has been successfully handled;

11874

additionally, the nested loop produced the

11875

number of rows specified in the LIMIT clause

11876

for the query

11877

NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;

11878

additionally, there is a cursor and the nested

11879

loop algorithm produced the number of rows

11880

that is specified for current cursor fetch

11881

operation.

11882

All return values except NESTED_LOOP_OK abort the nested loop.

11883

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

11884

11885

/* ARGSUSED */

11886

static enum_nested_loop_state

11887

end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11888

bool end_of_records)

11889

{

11890

if (!end_of_records)

11891

{

11892

int error;

11893

if (join->having && join->having->val_int() == 0)

11894

return(NESTED_LOOP_OK); // Didn't match having

11895

error=0;

11896

if (join->do_send_rows)

11897

error=join->result->send_data(*join->fields);

11898

if (error)

11899

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11900

if (++join->send_records >= join->unit->select_limit_cnt &&

11901

join->do_send_rows)

11902

{

11903

if (join->select_options & OPTION_FOUND_ROWS)

11904

{

11905

JOIN_TAB *jt=join->join_tab;

11906

if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group

11907

&& !join->send_group_parts && !join->having && !jt->select_cond &&

11908

!(jt->select && jt->select->quick) &&

11909

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

11910

(jt->ref.key < 0))

11911

{

11912

/* Join over all rows in table; Return number of found rows */

11913

Table *table=jt->table;

11914

11915

join->select_options ^= OPTION_FOUND_ROWS;

11916

if (table->sort.record_pointers ||

11917

(table->sort.io_cache && my_b_inited(table->sort.io_cache)))

11918

{

11919

/* Using filesort */

11920

join->send_records= table->sort.found_records;

11921

}

11922

else

11923

{

11924

table->file->info(HA_STATUS_VARIABLE);

11925

join->send_records= table->file->stats.records;

11926

}

11927

}

11928

else

11929

{

11930

join->do_send_rows= 0;

11931

if (join->unit->fake_select_lex)

11932

join->unit->fake_select_lex->select_limit= 0;

11933

return(NESTED_LOOP_OK);

11934

}

11935

}

11936

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11937

}

11938

else if (join->send_records >= join->fetch_limit)

11939

{

11940

11941

There is a server side cursor and all rows for

11942

this fetch request are sent.

11943

11944

return(NESTED_LOOP_CURSOR_LIMIT);

11945

}

11946

}

11947

11948

return(NESTED_LOOP_OK);

11949

}

11950

11951

11952

/* ARGSUSED */

11953

enum_nested_loop_state

11954

end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11955

bool end_of_records)

3868

11956

{

3869

11957

int idx= -1;

3870

11958

enum_nested_loop_state ok_code= NESTED_LOOP_OK;

3872

11960

if (!join->first_record || end_of_records ||

3873

11961

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3874

11962

{

3875

if (join->first_record ||

11963

if (join->first_record ||

3876

11964

(end_of_records && !join->group && !join->group_optimized_away))

3877

11965

{

3878

11966

if (idx < (int) join->send_group_parts)

3879

11967

{

3880

int error=0;

3881

{

3882

if (!join->first_record)

3883

{

3884

List_iterator_fast<Item> it(*join->fields);

3885

Item *item;

3886

/* No matching rows for group function */

3887

join->clear();

11968

int error=0;

11969

{

11970

if (!join->first_record)

11971

{

11972

List_iterator_fast<Item> it(*join->fields);

11973

Item *item;

11974

/* No matching rows for group function */

11975

join->clear();

3888

11976

3889

11977

while ((item= it++))

3890

11978

item->no_rows_in_result();

3891

}

3892

if (join->having && join->having->val_int() == 0)

3893

error= -1; // Didn't satisfy having

3894

else

3895

{

3896

if (join->do_send_rows)

3897

error=join->result->send_data(*join->fields) ? 1 : 0;

3898

join->send_records++;

3899

}

3900

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

3901

{

3902

if (join->rollup_send_data((uint32_t) (idx+1)))

3903

error= 1;

3904

}

3905

}

3906

if (error > 0)

3907

return(NESTED_LOOP_ERROR);

3908

if (end_of_records)

3909

return(NESTED_LOOP_OK);

3910

if (join->send_records >= join->unit->select_limit_cnt &&

3911

join->do_send_rows)

3912

{

3913

if (!(join->select_options & OPTION_FOUND_ROWS))

3914

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

3915

join->do_send_rows=0;

3916

join->unit->select_limit_cnt = HA_POS_ERROR;

11979

}

11980

if (join->having && join->having->val_int() == 0)

11981

error= -1; // Didn't satisfy having

11982

else

11983

{

11984

if (join->do_send_rows)

11985

error=join->result->send_data(*join->fields) ? 1 : 0;

11986

join->send_records++;

11987

}

11988

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

11989

{

11990

if (join->rollup_send_data((uint) (idx+1)))

11991

error= 1;

11992

}

11993

}

11994

if (error > 0)

11995

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11996

if (end_of_records)

11997

return(NESTED_LOOP_OK);

11998

if (join->send_records >= join->unit->select_limit_cnt &&

11999

join->do_send_rows)

12000

{

12001

if (!(join->select_options & OPTION_FOUND_ROWS))

12002

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

12003

join->do_send_rows=0;

12004

join->unit->select_limit_cnt = HA_POS_ERROR;

3917

12005

}

3918

12006

else if (join->send_records >= join->fetch_limit)

3919

12007

{

3932

12020

else

3933

12021

{

3934

12022

if (end_of_records)

3935

return(NESTED_LOOP_OK);

12023

return(NESTED_LOOP_OK);

3936

12024

join->first_record=1;

3937

12025

test_if_item_cache_changed(join->group_fields);

3938

12026

}

3944

12032

3945

12033

copy_fields(&join->tmp_table_param);

3946

12034

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

3947

return(NESTED_LOOP_ERROR);

12035

return(NESTED_LOOP_ERROR);

3948

12036

return(ok_code);

3949

12037

}

3950

12038

}

3953

12041

return(NESTED_LOOP_OK);

3954

12042

}

3955

12043

3956

enum_nested_loop_state end_write_group(Join *join, JoinTable *, bool end_of_records)

12044

12045

/* ARGSUSED */

12046

enum_nested_loop_state

12047

end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12048

bool end_of_records)

12049

{

12050

Table *table=join->tmp_table;

12051

12052

if (join->thd->killed) // Aborted by user

12053

{

12054

join->thd->send_kill_message();

12055

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12056

}

12057

if (!end_of_records)

12058

{

12059

copy_fields(&join->tmp_table_param);

12060

copy_funcs(join->tmp_table_param.items_to_copy);

12061

#ifdef TO_BE_DELETED

12062

if (!table->uniques) // If not unique handling

12063

{

12064

/* Copy null values from group to row */

12065

order_st *group;

12066

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

12067

{

12068

Item *item= *group->item;

12069

if (item->maybe_null)

12070

{

12071

Field *field=item->get_tmp_table_field();

12072

field->ptr[-1]= (unsigned char) (field->is_null() ? 1 : 0);

12073

}

12074

}

12075

}

12076

#endif

12077

if (!join->having || join->having->val_int())

12078

{

12079

int error;

12080

join->found_records++;

12081

if ((error=table->file->ha_write_row(table->record[0])))

12082

{

12083

if (!table->file->is_fatal_error(error, HA_CHECK_DUP))

12084

goto end;

12085

if (create_myisam_from_heap(join->thd, table,

12086

join->tmp_table_param.start_recinfo,

12087

&join->tmp_table_param.recinfo,

12088

error, 1))

12089

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12090

table->s->uniques=0; // To ensure rows are the same

12091

}

12092

if (++join->send_records >= join->tmp_table_param.end_write_records &&

12093

join->do_send_rows)

12094

{

12095

if (!(join->select_options & OPTION_FOUND_ROWS))

12096

return(NESTED_LOOP_QUERY_LIMIT);

12097

join->do_send_rows=0;

12098

join->unit->select_limit_cnt = HA_POS_ERROR;

12099

return(NESTED_LOOP_OK);

12100

}

12101

}

12102

}

12103

end:

12104

return(NESTED_LOOP_OK);

12105

}

12106

12107

/* ARGSUSED */

12108

/** Group by searching after group record and updating it if possible. */

12109

12110

static enum_nested_loop_state

12111

end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12112

bool end_of_records)

12113

{

12114

Table *table=join->tmp_table;

12115

order_st *group;

12116

int error;

12117

12118

if (end_of_records)

12119

return(NESTED_LOOP_OK);

12120

if (join->thd->killed) // Aborted by user

12121

{

12122

join->thd->send_kill_message();

12123

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12124

}

12125

12126

join->found_records++;

12127

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12128

/* Make a key of group index */

12129

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

12130

{

12131

Item *item= *group->item;

12132

item->save_org_in_field(group->field);

12133

/* Store in the used key if the field was 0 */

12134

if (item->maybe_null)

12135

group->buff[-1]= (char) group->field->is_null();

12136

}

12137

if (!table->file->index_read_map(table->record[1],

12138

join->tmp_table_param.group_buff,

12139

HA_WHOLE_KEY,

12140

HA_READ_KEY_EXACT))

12141

{ /* Update old record */

12142

restore_record(table,record[1]);

12143

update_tmptable_sum_func(join->sum_funcs,table);

12144

if ((error=table->file->ha_update_row(table->record[1],

12145

table->record[0])))

12146

{

12147

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12148

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12149

}

12150

return(NESTED_LOOP_OK);

12151

}

12152

12153

12154

Copy null bits from group key to table

12155

We can't copy all data as the key may have different format

12156

as the row data (for example as with VARCHAR keys)

12157

12158

KEY_PART_INFO *key_part;

12159

for (group=table->group,key_part=table->key_info[0].key_part;

12160

group ;

12161

group=group->next,key_part++)

12162

{

12163

if (key_part->null_bit)

12164

memcpy(table->record[0]+key_part->offset, group->buff, 1);

12165

}

12166

init_tmptable_sum_functions(join->sum_funcs);

12167

copy_funcs(join->tmp_table_param.items_to_copy);

12168

if ((error=table->file->ha_write_row(table->record[0])))

12169

{

12170

if (create_myisam_from_heap(join->thd, table,

12171

join->tmp_table_param.start_recinfo,

12172

&join->tmp_table_param.recinfo,

12173

error, 0))

12174

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12175

/* Change method to update rows */

12176

table->file->ha_index_init(0, 0);

12177

join->join_tab[join->tables-1].next_select=end_unique_update;

12178

}

12179

join->send_records++;

12180

return(NESTED_LOOP_OK);

12181

}

12182

12183

12184

/** Like end_update, but this is done with unique constraints instead of keys. */

12185

12186

static enum_nested_loop_state

12187

end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12188

bool end_of_records)

12189

{

12190

Table *table=join->tmp_table;

12191

int error;

12192

12193

if (end_of_records)

12194

return(NESTED_LOOP_OK);

12195

if (join->thd->killed) // Aborted by user

12196

{

12197

join->thd->send_kill_message();

12198

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12199

}

12200

12201

init_tmptable_sum_functions(join->sum_funcs);

12202

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12203

copy_funcs(join->tmp_table_param.items_to_copy);

12204

12205

if (!(error=table->file->ha_write_row(table->record[0])))

12206

join->send_records++; // New group

12207

else

12208

{

12209

if ((int) table->file->get_dup_key(error) < 0)

12210

{

12211

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12212

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12213

}

12214

if (table->file->rnd_pos(table->record[1],table->file->dup_ref))

12215

{

12216

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12217

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12218

}

12219

restore_record(table,record[1]);

12220

update_tmptable_sum_func(join->sum_funcs,table);

12221

if ((error=table->file->ha_update_row(table->record[1],

12222

table->record[0])))

12223

{

12224

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12225

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12226

}

12227

}

12228

return(NESTED_LOOP_OK);

12229

}

12230

12231

12232

/* ARGSUSED */

12233

enum_nested_loop_state

12234

end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12235

bool end_of_records)

3957

12236

{

3958

12237

Table *table=join->tmp_table;

3959

12238

int idx= -1;

3960

12239

3961

if (join->session->getKilled())

12240

if (join->thd->killed)

3962

12241

{ // Aborted by user

3963

join->session->send_kill_message();

3964

return NESTED_LOOP_KILLED;

12242

join->thd->send_kill_message();

12243

return(NESTED_LOOP_KILLED); /* purecov: inspected */

3965

12244

}

3966

12245

if (!join->first_record || end_of_records ||

3967

12246

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

3971

12250

int send_group_parts= join->send_group_parts;

3972

12251

if (idx < send_group_parts)

3973

12252

{

3974

if (!join->first_record)

3975

{

3976

/* No matching rows for group function */

3977

join->clear();

3978

}

3979

copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);

3980

if (!join->having || join->having->val_int())

3981

{

3982

int error= table->cursor->insertRecord(table->getInsertRecord());

3983

3984

if (error)

3985

{

3986

my_error(ER_USE_SQL_BIG_RESULT, MYF(0));

3987

return NESTED_LOOP_ERROR;

3988

}

12253

if (!join->first_record)

12254

{

12255

/* No matching rows for group function */

12256

join->clear();

12257

}

12258

copy_sum_funcs(join->sum_funcs,

12259

join->sum_funcs_end[send_group_parts]);

12260

if (!join->having || join->having->val_int())

12261

{

12262

int error= table->file->ha_write_row(table->record[0]);

12263

if (error && create_myisam_from_heap(join->thd, table,

12264

join->tmp_table_param.start_recinfo,

12265

&join->tmp_table_param.recinfo,

12266

error, 0))

12267

return(NESTED_LOOP_ERROR);

3989

12268

}

3990

12269

if (join->rollup.state != ROLLUP::STATE_NONE)

3991

{

3992

if (join->rollup_write_data((uint32_t) (idx+1), table))

3993

return NESTED_LOOP_ERROR;

3994

}

3995

if (end_of_records)

3996

return NESTED_LOOP_OK;

12270

{

12271

if (join->rollup_write_data((uint) (idx+1), table))

12272

return(NESTED_LOOP_ERROR);

12273

}

12274

if (end_of_records)

12275

return(NESTED_LOOP_OK);

3997

12276

}

3998

12277

}

3999

12278

else

4000

12279

{

4001

12280

if (end_of_records)

4002

return NESTED_LOOP_OK;

12281

return(NESTED_LOOP_OK);

4003

12282

join->first_record=1;

4004

12283

test_if_item_cache_changed(join->group_fields);

4005

12284

}

4008

12287

copy_fields(&join->tmp_table_param);

4009

12288

copy_funcs(join->tmp_table_param.items_to_copy);

4010

12289

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

4011

return NESTED_LOOP_ERROR;

4012

return NESTED_LOOP_OK;

12290

return(NESTED_LOOP_ERROR);

12291

return(NESTED_LOOP_OK);

4013

12292

}

4014

12293

}

4015

12294

if (update_sum_func(join->sum_funcs))

4016

return NESTED_LOOP_ERROR;

4017

return NESTED_LOOP_OK;

12295

return(NESTED_LOOP_ERROR);

12296

return(NESTED_LOOP_OK);

4018

12297

}

4019

12298

12299

4020

12300

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

4021

12301

Remove calculation with tables that aren't yet read. Remove also tests

4022

12302

against fields that are read through key where the table is not a

4023

12303

outer join table.

4024

12304

We can't remove tests that are made against columns which are stored

4025

12305

in sorted order.

12306

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

12307

12308

/**

4026

12309

@return

4027

1 if right_item used is a removable reference key on left_item

4028

0 otherwise.

4029

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

4030

bool test_if_ref(Item_field *left_item,Item *right_item)

12310

1 if right_item is used removable reference key on left_item

12311

12312

12313

static bool test_if_ref(Item_field *left_item,Item *right_item)

4031

12314

{

4032

12315

Field *field=left_item->field;

4033

12316

// No need to change const test. We also have to keep tests on LEFT JOIN

4034

if (not field->getTable()->const_table && !field->getTable()->maybe_null)

12317

if (!field->table->const_table && !field->table->maybe_null)

4035

12318

{

4036

Item *ref_item=part_of_refkey(field->getTable(),field);

12319

Item *ref_item=part_of_refkey(field->table,field);

4037

12320

if (ref_item && ref_item->eq(right_item,1))

4038

12321

{

4039

12322

right_item= right_item->real_item();

4040

12323

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

4041

return (field->eq_def(((Item_field *) right_item)->field));

12324

return (field->eq_def(((Item_field *) right_item)->field));

4042

12325

/* remove equalities injected by IN->EXISTS transformation */

4043

12326

else if (right_item->type() == Item::CACHE_ITEM)

4044

12327

return ((Item_cache *)right_item)->eq_def (field);

4045

12328

if (right_item->const_item() && !(right_item->is_null()))

4046

12329

{

4047

4048

We can remove binary fields and numerical fields except float,

4049

as float comparison isn't 100 % secure

4050

We have to keep normal strings to be able to check for end spaces

12330

12331

We can remove binary fields and numerical fields except float,

12332

as float comparison isn't 100 % secure

12333

We have to keep normal strings to be able to check for end spaces

4051

12334

4052

sergefp: the above seems to be too restrictive. Counterexample:

4053

create table t100 (v varchar(10), key(v)) default charset=latin1;

4054

insert into t100 values ('a'),('a ');

4055

explain select * from t100 where v='a';

4056

The EXPLAIN shows 'using Where'. Running the query returns both

4057

rows, so it seems there are no problems with endspace in the most

4058

frequent case?

4059

4060

if (field->binary() &&

4061

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

4062

field->decimals() == 0)

4063

{

4064

return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);

4065

}

12335

sergefp: the above seems to be too restrictive. Counterexample:

12336

create table t100 (v varchar(10), key(v)) default charset=latin1;

12337

insert into t100 values ('a'),('a ');

12338

explain select * from t100 where v='a';

12339

The EXPLAIN shows 'using Where'. Running the query returns both

12340

rows, so it seems there are no problems with endspace in the most

12341

frequent case?

12342

12343

if (field->binary() &&

12344

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

12345

field->decimals() == 0)

12346

{

12347

return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);

12348

}

4066

12349

}

4067

12350

}

4068

12351

}

4069

return 0;

12352

return 0; // keep test

12353

}

12354

12355

/**

12356

@brief Replaces an expression destructively inside the expression tree of

12357

the WHERE clase.

12358

12359

@note Because of current requirements for semijoin flattening, we do not

12360

need to recurse here, hence this function will only examine the top-level

12361

AND conditions. (see JOIN::prepare, comment above the line

12362

'if (do_materialize)'

12363

12364

@param join The top-level query.

12365

@param old_cond The expression to be replaced.

12366

@param new_cond The expression to be substituted.

12367

@param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for

12368

the new expression.

12369

@return <code>true</code> if there was an error, <code>false</code> if

12370

successful.

12371

12372

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

12373

Item *new_cond, bool do_fix_fields)

12374

{

12375

if (join->conds == old_cond) {

12376

join->conds= new_cond;

12377

if (do_fix_fields)

12378

new_cond->fix_fields(join->thd, &join->conds);

12379

return false;

12380

}

12381

12382

if (join->conds->type() == Item::COND_ITEM) {

12383

List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());

12384

Item *item;

12385

while ((item= li++))

12386

if (item == old_cond)

12387

{

12388

li.replace(new_cond);

12389

if (do_fix_fields)

12390

new_cond->fix_fields(join->thd, li.ref());

12391

return false;

12392

}

12393

}

12394

12395

return true;

4070

12396

}

4071

12397

4072

12398

4073

12399

Extract a condition that can be checked after reading given table

4074

12400

4075

12401

SYNOPSIS

4076

12402

make_cond_for_table()

4077

12403

cond Condition to analyze

4078

12404

tables Tables for which "current field values" are available

4079

used_table Table that we're extracting the condition for (may

12405

used_table Table that we're extracting the condition for (may

4080

12406

also include PSEUDO_TABLE_BITS

4081

12407

4082

12408

DESCRIPTION

4086

12412

4087

12413

The function assumes that

4088

12414

- Constant parts of the condition has already been checked.

4089

- Condition that could be checked for tables in 'tables' has already

12415

- Condition that could be checked for tables in 'tables' has already

4090

12416

been checked.

4091

12417

4092

12418

The function takes into account that some parts of the condition are

4093

12419

guaranteed to be true by employed 'ref' access methods (the code that

4094

12420

does this is located at the end, search down for "EQ_FUNC").

4095

12421

4096

12422

4097