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

2215

{ /* Must copy to another table */

2216

/* Free first data from old join */

2217

curr_join->join_free();

2218

if (make_simple_join(curr_join, curr_tmp_table))

2219

return;

2220

calc_group_buffer(curr_join, group_list);

2221

count_field_types(select_lex, &curr_join->tmp_table_param,

2222

curr_join->tmp_all_fields1,

2223

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

2224

curr_join->tmp_table_param.hidden_field_count=

2225

(curr_join->tmp_all_fields1.elements-

2226

curr_join->tmp_fields_list1.elements);

2227

2228

2229

if (exec_tmp_table2)

2230

curr_tmp_table= exec_tmp_table2;

2231

else

2232

{

2233

/* group data to new table */

2234

2235

2236

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

2237

functions are precomputed, and should be treated as regular

2238

functions. See extended comment in JOIN::exec.

2239

2240

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

2241

curr_join->tmp_table_param.precomputed_group_by= true;

2242

2243

if (!(curr_tmp_table=

2244

exec_tmp_table2= create_tmp_table(thd,

2245

&curr_join->tmp_table_param,

2246

*curr_all_fields,

2247

(order_st*) 0,

2248

curr_join->select_distinct &&

2249

!curr_join->group_list,

2250

1, curr_join->select_options,

2251

HA_POS_ERROR,

2252

(char *) "")))

2253

return;

2254

curr_join->exec_tmp_table2= exec_tmp_table2;

2255

}

2256

if (curr_join->group_list)

2257

{

2258

thd_proc_info(thd, "Creating sort index");

2259

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

2260

{

2261

return;

2262

}

2263

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

2264

HA_POS_ERROR, HA_POS_ERROR, false) ||

2265

make_group_fields(this, curr_join))

2266

{

2267

return;

2268

}

2269

sortorder= curr_join->sortorder;

2270

}

2271

2272

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

2273

tmp_error= -1;

2274

if (curr_join != this)

2275

{

2276

if (sum_funcs2)

2277

{

2278

curr_join->sum_funcs= sum_funcs2;

2279

curr_join->sum_funcs_end= sum_funcs_end2;

2280

}

2281

else

2282

{

2283

curr_join->alloc_func_list();

2284

sum_funcs2= curr_join->sum_funcs;

2285

sum_funcs_end2= curr_join->sum_funcs_end;

2286

}

2287

}

2288

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

2289

1, true))

2290

return;

2291

curr_join->group_list= 0;

2292

if (!curr_join->sort_and_group &&

2293

curr_join->const_tables != curr_join->tables)

2294

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

2295

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

2296

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

2297

{

2298

error= tmp_error;

2299

return;

2300

}

2301

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

2302

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

2303

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

2304

2305

// No sum funcs anymore

2306

if (!items2)

2307

{

2308

items2= items1 + all_fields.elements;

2309

if (change_to_use_tmp_fields(thd, items2,

2310

tmp_fields_list2, tmp_all_fields2,

2311

fields_list.elements, tmp_all_fields1))

2312

return;

2313

curr_join->tmp_fields_list2= tmp_fields_list2;

2314

curr_join->tmp_all_fields2= tmp_all_fields2;

2315

}

2316

curr_fields_list= &curr_join->tmp_fields_list2;

2317

curr_all_fields= &curr_join->tmp_all_fields2;

2318

curr_join->set_items_ref_array(items2);

2319

curr_join->tmp_table_param.field_count+=

2320

curr_join->tmp_table_param.sum_func_count;

2321

curr_join->tmp_table_param.sum_func_count= 0;

2322

}

2323

if (curr_tmp_table->distinct)

2324

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

2325

2326

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

2327

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

2328

{

2329

thd_proc_info(thd, "Removing duplicates");

2330

if (curr_join->tmp_having)

2331

curr_join->tmp_having->update_used_tables();

2332

if (remove_duplicates(curr_join, curr_tmp_table,

2333

*curr_fields_list, curr_join->tmp_having))

2334

return;

2335

curr_join->tmp_having=0;

2336

curr_join->select_distinct=0;

2337

}

2338

curr_tmp_table->reginfo.lock_type= TL_UNLOCK;

2339

if (make_simple_join(curr_join, curr_tmp_table))

2340

return;

2341

calc_group_buffer(curr_join, curr_join->group_list);

2342

count_field_types(select_lex, &curr_join->tmp_table_param,

2343

*curr_all_fields, 0);

2344

2345

}

2346

2347

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

2348

{

2349

if (make_group_fields(this, curr_join))

2350

{

2351

return;

2352

}

2353

if (!items3)

2354

{

2355

if (!items0)

2356

init_items_ref_array();

2357

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

2358

setup_copy_fields(thd, &curr_join->tmp_table_param,

2359

items3, tmp_fields_list3, tmp_all_fields3,

2360

curr_fields_list->elements, *curr_all_fields);

2361

tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;

2362

tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;

2363

tmp_table_param.save_copy_field_end=

2364

curr_join->tmp_table_param.copy_field_end;

2365

curr_join->tmp_all_fields3= tmp_all_fields3;

2366

curr_join->tmp_fields_list3= tmp_fields_list3;

2367

}

2368

else

2369

{

2370

curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;

2371

curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;

2372

curr_join->tmp_table_param.copy_field_end=

2373

tmp_table_param.save_copy_field_end;

2374

}

2375

curr_fields_list= &tmp_fields_list3;

2376

curr_all_fields= &tmp_all_fields3;

2377

curr_join->set_items_ref_array(items3);

2378

2379

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

2380

1, true) ||

2381

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

2382

thd->is_fatal_error)

2383

return;

2384

}

2385

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

2386

{

2387

thd_proc_info(thd, "Sorting result");

2388

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

2389

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

2390

! curr_join->sort_and_group)

2391

{

2392

// Some tables may have been const

2393

curr_join->tmp_having->update_used_tables();

2394

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

2395

table_map used_tables= (curr_join->const_table_map |

2396

curr_table->table->map);

2397

2398

Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,

2399

used_tables,

2400

used_tables, 0);

2401

if (sort_table_cond)

2402

{

2403

if (!curr_table->select)

2404

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

2405

return;

2406

if (!curr_table->select->cond)

2407

curr_table->select->cond= sort_table_cond;

2408

else // This should never happen

2409

{

2410

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

2411

new Item_cond_and(curr_table->select->cond,

2412

sort_table_cond)))

2413

return;

2414

2415

Item_cond_and do not need fix_fields for execution, its parameters

2416

are fixed or do not need fix_fields, too

2417

2418

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

2419

}

2420

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

2421

curr_table->select_cond->top_level_item();

2422

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

2423

~ (table_map) 0,

2424

~used_tables, 0);

2425

}

2426

}

2427

{

2428

if (group)

2429

curr_join->select_limit= HA_POS_ERROR;

2430

else

2431

{

2432

2433

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

2434

WHERE clause for any tables after the sorted one.

2435

2436

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

2437

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

2438

for (; curr_table < end_table ; curr_table++)

2439

{

2440

2441

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

2442

on the table that was optimized away.

2443

2444

if (curr_table->select_cond ||

2445

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

2446

{

2447

/* We have to sort all rows */

2448

curr_join->select_limit= HA_POS_ERROR;

2449

break;

2450

}

2451

}

2452

}

2453

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

2454

{

2455

return;

2456

}

2457

2458

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

2459

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

2460

suitable index present.

2461

Note, that create_sort_index calls test_if_skip_sort_order and may

2462

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

2463

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

2464

OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.

2465

2466

if (create_sort_index(thd, curr_join,

2467

curr_join->group_list ?

2468

curr_join->group_list : curr_join->order,

2469

curr_join->select_limit,

2470

(select_options & OPTION_FOUND_ROWS ?

2471

HA_POS_ERROR : unit->select_limit_cnt),

2472

curr_join->group_list ? true : false))

2473

return;

2474

sortorder= curr_join->sortorder;

2475

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

2476

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

2477

{

2478

2479

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

2480

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

2481

attribute on the INDEX SCAN.

2482

2483

skip_sort_order= 1;

2484

}

2485

}

2486

}

2487

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

2488

if (thd->is_error())

2489

{

2490

error= thd->is_error();

2491

return;

2492

}

2493

curr_join->having= curr_join->tmp_having;

2494

curr_join->fields= curr_fields_list;

2495

2496

{

2497

thd_proc_info(thd, "Sending data");

2498

result->send_fields(*curr_fields_list,

2499

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);

2500

error= do_select(curr_join, curr_fields_list, NULL);

2501

thd->limit_found_rows= curr_join->send_records;

2502

}

2503

2504

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

2505

thd->examined_row_count+= curr_join->examined_rows;

2506

2507

2508

With EXPLAIN EXTENDED we have to restore original ref_array

2509

for a derived table which is always materialized.

2510

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

2511

2512

if (items0 &&

2513

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

2514

select_lex->linkage == DERIVED_TABLE_TYPE)

2515

set_items_ref_array(items0);

2516

2517

return;

2518

}

2519

2520

2521

/**

2522

Clean up join.

2523

2524

@return

2525

Return error that hold JOIN.

2526

2527

2528

int

2529

JOIN::destroy()

2530

{

2531

select_lex->join= 0;

2532

2533

if (tmp_join)

2534

{

2535

if (join_tab != tmp_join->join_tab)

2536

{

2537

JOIN_TAB *tab, *end;

2538

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

2539

tab->cleanup();

2540

}

2541

tmp_join->tmp_join= 0;

2542

tmp_table_param.copy_field=0;

2543

return(tmp_join->destroy());

2544

}

2545

cond_equal= 0;

2546

2547

cleanup(1);

2548

if (exec_tmp_table1)

2549

exec_tmp_table1->free_tmp_table(thd);

2550

if (exec_tmp_table2)

2551

exec_tmp_table2->free_tmp_table(thd);

2552

delete select;

2553

delete_dynamic(&keyuse);

2554

return(error);

2555

}

2556

2557

2558

2559

315

/**

2560

316

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

2561

317

2562

@param thd thread handler

318

@param session thread handler

2563

319

@param rref_pointer_array a reference to ref_pointer_array of

2564

320

the top-level select_lex for this query

2565

321

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

2566

322

The tables have been pre-opened.

2567

@param wild_num number of wildcards used in the top level

323

@param wild_num number of wildcards used in the top level

2568

324

select of this query.

2569

325

For example statement

2570

326

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

2580

336

@param order linked list of order_st BY agruments

2581

337

@param group linked list of GROUP BY arguments

2582

338

@param having top level item of HAVING expression

2583

@param proc_param list of PROCEDUREs

2584

339

@param select_options select options (BIG_RESULT, etc)

2585

340

@param result an instance of result set handling class.

2586

341

This object is responsible for send result

2587

342

set rows to the client or inserting them

2588

343

into a table.

2589

@param select_lex the only SELECT_LEX of this query

344

@param select_lex the only Select_Lex of this query

2590

345

@param unit top-level UNIT of this query

2591

346

UNIT is an artificial object created by the

2592

347

parser for every SELECT clause.

2599

354

@retval

2600

355

true an error

2601

356

2602

2603

bool

2604

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

2605

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

2606

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

2607

Item *having, order_st *proc_param, uint64_t select_options,

2608

select_result *result, SELECT_LEX_UNIT *unit,

2609

SELECT_LEX *select_lex)

357

bool mysql_select(Session *session,

358

Item ***rref_pointer_array,

359

TableList *tables,

360

uint32_t wild_num,

361

List<Item> &fields,

362

COND *conds,

363

uint32_t og_num,

364

order_st *order,

365

order_st *group,

366

Item *having,

367

uint64_t select_options,

368

select_result *result,

369

Select_Lex_Unit *unit,

370

Select_Lex *select_lex)

2610

371

{

2611

372

bool err;

2612

373

bool free_join= 1;

2621

382

creation

2622

383

2623

384

if (select_lex->linkage != DERIVED_TABLE_TYPE ||

2624

(select_options & SELECT_DESCRIBE))

385

(select_options & SELECT_DESCRIBE))

2625

386

{

2626

387

if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)

2627

388

{

2628

//here is EXPLAIN of subselect or derived table

2629

if (join->change_result(result))

2630

{

2631

return(true);

2632

}

389

//here is EXPLAIN of subselect or derived table

390

if (join->change_result(result))

391

{

392

return(true);

393

}

2633

394

}

2634

395

else

2635

396

{

2636

397

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

2637

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

2638

select_lex, unit)))

2639

{

2640

goto err;

2641

}

398

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

399

{

400

goto err;

401

}

2642

402

}

2643

403

}

2644

404

free_join= 0;

2646

406

}

2647

407

else

2648

408

{

2649

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

2650

return(true);

2651

thd_proc_info(thd, "init");

2652

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

409

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

410

return(true);

411

session->set_proc_info("init");

412

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

2653

413

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

2654

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

414

conds, og_num, order, group, having,

2655

415

select_lex, unit)) == true)

2656

416

{

2657

417

goto err;

2658

418

}

2659

419

}

2660

420

2661

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

2662

if (join->flatten_subqueries())

2663

{

2664

err= 1;

2665

goto err;

2666

}

2667

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

2668

2669

421

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

2670

422

{

2671

423

goto err; // 1

2672

424

}

2673

425

2674

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

426

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

2675

427

{

2676

428

join->conds_history= join->conds;

2677

429

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

2678

430

}

2679

431

2680

if (thd->is_error())

432

if (session->is_error())

2681

433

goto err;

2682

434

2683

435

join->exec();

2684

436

2685

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

437

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

2686

438

{

2687

439

select_lex->where= join->conds_history;

2688

440

select_lex->having= join->having_history;

2691

443

err:

2692

444

if (free_join)

2693

445

{

2694

thd_proc_info(thd, "end");

446

session->set_proc_info("end");

2695

447

err|= select_lex->cleanup();

2696

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

448

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

2697

449

}

2698

450

return(join->error);

2699

451

}

2700

452

2701

2702

int subq_sj_candidate_cmp(Item_in_subselect* const *el1,

2703

Item_in_subselect* const *el2)

2704

{

2705

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

2706

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

2707

}

2708

2709

2710

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

453

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

2711

454

{

2712

455

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

2713

456

}

2714

457

2715

2716

static TableList *alloc_join_nest(THD *thd)

2717

{

2718

TableList *tbl;

2719

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

2720

sizeof(nested_join_st))))

2721

return NULL;

2722

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

2723

ALIGN_SIZE(sizeof(TableList)));

2724

return tbl;

2725

}

2726

2727

2728

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

458

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

2729

459

{

2730

460

List_iterator<TableList> it(*tlist);

2731

461

TableList *table;

2738

468

}

2739

469

}

2740

470

2741

2742

2743

Convert a subquery predicate into a TableList semi-join nest

2744

2745

SYNOPSIS

2746

convert_subq_to_sj()

2747

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

2748

clause

2749

subq_pred Subquery predicate to be converted

2750

2751

DESCRIPTION

2752

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

2753

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

2754

2755

Prepared Statements: the transformation is permanent:

2756

- Changes in TableList structures are naturally permanent

2757

- Item tree changes are performed on statement MEM_ROOT:

2758

= we activate statement MEM_ROOT

2759

= this function is called before the first fix_prepare_information

2760

call.

2761

2762

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

2763

constant for the lifetime of the Prepared Statement.

2764

2765

RETURN

2766

false OK

2767

true Out of memory error

2768

2769

2770

bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)

2771

{

2772

SELECT_LEX *parent_lex= parent_join->select_lex;

2773

TableList *emb_tbl_nest= NULL;

2774

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

2775

THD *thd= parent_join->thd;

2776

2777

2778

1. Find out where to put the predicate into.

2779

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

2780

2781

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

2782

{

2783

if (subq_pred->expr_join_nest->nested_join)

2784

{

2785

2786

We're dealing with

2787

2788

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

2789

2790

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

2791

2792

emb_tbl_nest= subq_pred->expr_join_nest;

2793

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2794

}

2795

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

2796

{

2797

2798

We're dealing with

2799

2800

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

2801

2802

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

2803

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

2804

2805

emb_tbl_nest= subq_pred->expr_join_nest->embedding;

2806

if (emb_tbl_nest)

2807

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2808

}

2809

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

2810

{

2811

TableList *outer_tbl= subq_pred->expr_join_nest;

2812

TableList *wrap_nest;

2813

2814

We're dealing with

2815

2816

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

2817

2818

we'll need to convert it into:

2819

2820

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

2821

| |

2822

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

2823

2824

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

2825

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

2826

But we'll need to fix other pointers.

2827

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

2828

subqueries know the table has been nested.

2829

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

2830

automatically.

2831

2832

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

2833

{

2834

return(true);

2835

}

2836

wrap_nest->embedding= outer_tbl->embedding;

2837

wrap_nest->join_list= outer_tbl->join_list;

2838

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

2839

2840

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

2841

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

2842

2843

outer_tbl->embedding= wrap_nest;

2844

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

2845

2846

2847

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

2848

and on_expr

2849

2850

wrap_nest->outer_join= outer_tbl->outer_join;

2851

outer_tbl->outer_join= 0;

2852

2853

wrap_nest->on_expr= outer_tbl->on_expr;

2854

outer_tbl->on_expr= NULL;

2855

2856

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

2857

TableList *tbl;

2858

while ((tbl= li++))

2859

{

2860

if (tbl == outer_tbl)

2861

{

2862

li.replace(wrap_nest);

2863

break;

2864

}

2865

}

2866

2867

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

2868

semi-join nest into it

2869

2870

emb_join_list= &wrap_nest->nested_join->join_list;

2871

emb_tbl_nest= wrap_nest;

2872

}

2873

}

2874

2875

TableList *sj_nest;

2876

nested_join_st *nested_join;

2877

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

2878

{

2879

return(true);

2880

}

2881

nested_join= sj_nest->nested_join;

2882

2883

sj_nest->join_list= emb_join_list;

2884

sj_nest->embedding= emb_tbl_nest;

2885

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

2886

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

2887

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

2888

emb_join_list->push_back(sj_nest);

2889

2890

2891

nested_join->used_tables and nested_join->not_null_tables are

2892

initialized in simplify_joins().

2893

2894

2895

2896

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

2897

sj-nest.

2898

2899

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

2900

nested_join->join_list.empty();

2901

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

2902

TableList *tl, *last_leaf;

2903

while ((tl= li++))

2904

{

2905

tl->embedding= sj_nest;

2906

tl->join_list= &nested_join->join_list;

2907

nested_join->join_list.push_back(tl);

2908

}

2909

2910

2911

Reconnect the next_leaf chain.

2912

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

2913

Inserting them at the beginning would be a bit faster.

2914

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

2915

reversed in this list.

2916

2917

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

2918

tl->next_leaf= subq_lex->leaf_tables;

2919

last_leaf= tl;

2920

2921

2922

Same as above for next_local chain

2923

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

2924

because view's tables are inserted after the view)

2925

2926

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

2927

tl->next_local= subq_lex->leaf_tables;

2928

2929

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

2930

2931

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

2932

2933

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

2934

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

2935

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

2936

2937

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

2938

uint32_t table_no= parent_join->tables;

2939

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

2940

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

2941

{

2942

tl->table->tablenr= table_no;

2943

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

2944

SELECT_LEX *old_sl= tl->select_lex;

2945

tl->select_lex= parent_join->select_lex;

2946

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

2947

emb->select_lex= parent_join->select_lex;

2948

}

2949

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

2950

2951

2952

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

2953

Add the subquery-induced equalities too.

2954

2955

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

2956

thd->lex->current_select=subq_lex;

2957

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

2958

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

2959

return(true);

2960

thd->lex->current_select=save_lex;

2961

2962

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

2963

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

2964

subq_pred->left_expr->used_tables();

2965

sj_nest->sj_on_expr= subq_lex->where;

2966

2967

2968

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

2969

Additionally, for InsideOut strategy

2970

- Record the number of IN-equalities.

2971

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

2972

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

2973

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

2974

2975

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

2976

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

2977

them into Item_direct_view_refs and store pointers to those. The

2978

pointers to Item_direct_view_refs are guaranteed to be stable as

2979

Item_direct_view_refs doesn't substitute itself with anything in

2980

Item_direct_view_ref::fix_fields.

2981

2982

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

2983

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

2984

2985

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

2986

{

2987

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

2988

2989

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

2990

subq_lex->ref_pointer_array[0]);

2991

item_eq->name= (char*)subq_sj_cond_name;

2992

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

2993

}

2994

else

2995

{

2996

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

2997

{

2998

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

2999

element_index(i));

3000

Item *item_eq=

3001

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

3002

subq_lex->ref_pointer_array[i]);

3003

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

3004

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

3005

}

3006

}

3007

/* Fix the created equality and AND */

3008

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

3009

3010

3011

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

3012

item->fix_table_changes() for all items.

3013

3014

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

3015

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

3016

3017

3018

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

3019

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

3020

3021

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

3022

if (emb_tbl_nest)

3023

{

3024

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

3025

sj_nest->sj_on_expr);

3026

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

3027

}

3028

else

3029

{

3030

/* Inject into the WHERE */

3031

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

3032

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

3033

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

3034

}

3035

3036

return(false);

3037

}

3038

3039

3040

3041

Convert candidate subquery predicates to semi-joins

3042

3043

SYNOPSIS

3044

JOIN::flatten_subqueries()

3045

3046

DESCRIPTION

3047

Convert candidate subquery predicates to semi-joins.

3048

3049

RETURN

3050

false OK

3051

true Error

3052

3053

3054

bool JOIN::flatten_subqueries()

3055

{

3056

Item_in_subselect **in_subq;

3057

Item_in_subselect **in_subq_end;

3058

3059

if (sj_subselects.elements() == 0)

3060

return(false);

3061

3062

/* 1. Fix children subqueries */

3063

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

3064

in_subq != in_subq_end; in_subq++)

3065

{

3066

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

3067

child_join->outer_tables = child_join->tables;

3068

if (child_join->flatten_subqueries())

3069

return(true);

3070

(*in_subq)->sj_convert_priority=

3071

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

3072

}

3073

3074

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

3075

3076

2. Pick which subqueries to convert:

3077

sort the subquery array

3078

- prefer correlated subqueries over uncorrelated;

3079

- prefer subqueries that have greater number of outer tables;

3080

3081

sj_subselects.sort(subq_sj_candidate_cmp);

3082

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

3083

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

3084

for (in_subq= sj_subselects.front();

3085

in_subq != in_subq_end &&

3086

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

3087

in_subq++)

3088

{

3089

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

3090

return(true);

3091

}

3092

3093

for (in_subq= sj_subselects.front();

3094

in_subq != in_subq_end &&

3095

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

3096

in_subq++)

3097

{

3098

if (convert_subq_to_sj(this, *in_subq))

3099

return(true);

3100

}

3101

3102

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

3103

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

3104

{

3105

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

3106

Item_subselect::trans_res res;

3107

(*in_subq)->changed= 0;

3108

(*in_subq)->fixed= 0;

3109

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

3110

if (res == Item_subselect::RES_ERROR)

3111

return(true);

3112

3113

(*in_subq)->changed= 1;

3114

(*in_subq)->fixed= 1;

3115

3116

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

3117

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

3118

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

3119

return(true);

3120

3121

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

3122

// return(true);

3123

}

3124

sj_subselects.clear();

3125

return(false);

3126

}

3127

3128

3129

/**

3130

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

3131

chose hash semi-join.

3132

3133

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

3134

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

3135

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

3136

of the IN predicate,

3137

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

3138

previously blocked during JOIN::prepare.

3139

3140

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

3141

3142

This phase must be called after substitute_for_best_equal_field() because

3143

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

3144

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

3145

IN predicate.

3146

3147

@return Operation status

3148

@retval false success.

3149

@retval true error occurred.

3150

3151

3152

bool JOIN::setup_subquery_materialization()

3153

{

3154

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

3155

un= un->next_unit())

3156

{

3157

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

3158

{

3159

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

3160

if (subquery_predicate &&

3161

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

3162

{

3163

Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;

3164

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

3165

in_subs->setup_engine())

3166

return true;

3167

}

3168

}

3169

}

3170

return false;

3171

}

3172

3173

3174

3175

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

3176

3177

SYNOPSIS

3178

find_eq_ref_candidate()

3179

table Table to be checked

3180

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

3181

count.

3182

3183

DESCRIPTION

3184

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

3185

3186

TODO

3187

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

3188

3189

3190

RETURN

3191

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

3192

false - Otherwise

3193

3194

3195

bool find_eq_ref_candidate(Table *table, table_map sj_inner_tables)

3196

{

3197

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

3198

uint32_t key;

3199

3200

if (keyuse)

3201

{

3202

while (1) /* For each key */

3203

{

3204

key= keyuse->key;

3205

KEY *keyinfo= table->key_info + key;

3206

key_part_map bound_parts= 0;

3207

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

3208

{

3209

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

3210

{

3211

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

3212

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

3213

!(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))

3214

{

3215

bound_parts |= 1 << keyuse->keypart;

3216

}

3217

keyuse++;

3218

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

3219

3220

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

3221

return true;

3222

if (keyuse->table != table)

3223

return false;

3224

}

3225

else

3226

{

3227

3228

{

3229

keyuse++;

3230

if (keyuse->table != table)

3231

return false;

3232

}

3233

while (keyuse->key == key);

3234

}

3235

}

3236

}

3237

return false;

3238

}

3239

3240

3241

3242

Pull tables out of semi-join nests, if possible

3243

3244

SYNOPSIS

3245

pull_out_semijoin_tables()

3246

join The join where to do the semi-join flattening

3247

3248

DESCRIPTION

3249

Try to pull tables out of semi-join nests.

3250

3251

PRECONDITIONS

3252

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

3253

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

3254

one semi-join nest does not contain another.

3255

3256

ACTION

3257

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

3258

- It is a constant table

3259

- It is accessed

3260

3261

POSTCONDITIONS

3262

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

3263

tables)

3264

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

3265

* Semi-join nests TableList::sj_inner_tables

3266

3267

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

3268

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

3269

3270

RETURN

3271

0 - OK

3272

1 - Out of memory error

3273

3274

3275

int pull_out_semijoin_tables(JOIN *join)

3276

{

3277

TableList *sj_nest;

3278

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

3279

3280

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

3281

while ((sj_nest= sj_list_it++))

3282

{

3283

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

3284

table_map pulled_tables= 0;

3285

3286

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

3287

TableList *tbl;

3288

while ((tbl= child_li++))

3289

{

3290

if (tbl->table)

3291

{

3292

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

3293

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

3294

{

3295

pulled_tables |= tbl->table->map;

3296

}

3297

}

3298

}

3299

3300

3301

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

3302

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

3303

us to pull out some other tables too.

3304

3305

bool pulled_a_table;

3306

3307

{

3308

pulled_a_table= false;

3309

child_li.rewind();

3310

while ((tbl= child_li++))

3311

{

3312

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

3313

{

3314

if (find_eq_ref_candidate(tbl->table,

3315

sj_nest->nested_join->used_tables &

3316

~pulled_tables))

3317

{

3318

pulled_a_table= true;

3319

pulled_tables |= tbl->table->map;

3320

}

3321

}

3322

}

3323

} while (pulled_a_table);

3324

3325

child_li.rewind();

3326

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

3327

{

3328

(sj_nest)->sj_inner_tables= 0;

3329

while ((tbl= child_li++))

3330

{

3331

if (tbl->table)

3332

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

3333

}

3334

}

3335

else

3336

{

3337

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

3338

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

3339

~pulled_tables;

3340

(sj_nest)->sj_inner_tables= inner_tables;

3341

while ((tbl= child_li++))

3342

{

3343

if (tbl->table)

3344

{

3345

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

3346

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

3347

else

3348

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

3349

}

3350

}

3351

}

3352

}

3353

return(0);

3354

}

3355

3356

471

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

3357

Create JOIN_TABS, make a guess about the table types,

472

Create JoinTableS, make a guess about the table types,

3358

473

Approximate how many records will be used in each table

3359

474

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

3360

3361

3362

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

3363

Table *table,

3364

const key_map *keys,ha_rows limit)

475

ha_rows get_quick_record_count(Session *session, SQL_SELECT *select, Table *table, const key_map *keys,ha_rows limit)

3365

476

{

3366

477

int error;

3367

if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))

478

if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))

3368

479

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

3369

480

if (select)

3370

481

{

3371

482

select->head=table;

3372

483

table->reginfo.impossible_range=0;

3373

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

484

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

3374

485

limit, 0, false)) == 1)

3375

486

return(select->quick->records);

3376

487

if (error == -1)

3382

493

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

3383

494

}

3384

495

3385

3386

This structure is used to collect info on potentially sargable

3387

predicates in order to check whether they become sargable after

3388

reading const tables.

3389

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

3390

Only such indexes are involved in range analysis.

3391

3392

typedef struct st_sargable_param

3393

{

3394

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

3395

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

3396

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

3397

} SARGABLE_PARAM;

3398

3399

/**

3400

Calculate the best possible join and initialize the join structure.

3401

3402

@retval

3403

0 ok

3404

@retval

3405

1 Fatal error

3406

3407

3408

static bool

3409

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

3410

DYNAMIC_ARRAY *keyuse_array)

3411

{

3412

int error;

3413

Table *table;

3414

uint32_t i,table_count,const_count,key;

3415

table_map found_const_table_map, all_table_map, found_ref, refs;

3416

key_map const_ref, eq_part;

3417

Table **table_vector;

3418

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

3419

KEYUSE *keyuse,*start_keyuse;

3420

table_map outer_join=0;

3421

SARGABLE_PARAM *sargables= 0;

3422

JOIN_TAB *stat_vector[MAX_TABLES+1];

3423

3424

table_count=join->tables;

3425

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

3426

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

3427

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

3428

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

3429

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

3430

3431

join->best_ref=stat_vector;

3432

3433

stat_end=stat+table_count;

3434

found_const_table_map= all_table_map=0;

3435

const_count=0;

3436

3437

for (s= stat, i= 0;

3438

tables;

3439

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

3440

{

3441

TableList *embedding= tables->embedding;

3442

stat_vector[i]=s;

3443

s->keys.init();

3444

s->const_keys.init();

3445

s->checked_keys.init();

3446

s->needed_reg.init();

3447

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

3448

table->pos_in_table_list= tables;

3449

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

3450

if(error)

3451

{

3452

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

3453

return(1);

3454

}

3455

table->quick_keys.clear_all();

3456

table->reginfo.join_tab=s;

3457

table->reginfo.not_exists_optimize=0;

3458

memset(table->const_key_parts, 0,

3459

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

3460

all_table_map|= table->map;

3461

s->join=join;

3462

s->info=0; // For describe

3463

3464

s->dependent= tables->dep_tables;

3465

s->key_dependent= 0;

3466

if (tables->schema_table)

3467

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

3468

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

3469

3470

s->on_expr_ref= &tables->on_expr;

3471

if (*s->on_expr_ref)

3472

{

3473

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

3474

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

3475

{ // Empty table

3476

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

3477

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

3478

continue;

3479

}

3480

outer_join|= table->map;

3481

s->embedding_map= 0;

3482

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

3483

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

3484

continue;

3485

}

3486

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

3487

{

3488

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

3489

s->embedding_map= 0;

3490

3491

{

3492

nested_join_st *nested_join= embedding->nested_join;

3493

s->embedding_map|=nested_join->nj_map;

3494

s->dependent|= embedding->dep_tables;

3495

embedding= embedding->embedding;

3496

outer_join|= nested_join->used_tables;

3497

}

3498

while (embedding);

3499

continue;

3500

}

3501

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

3502

!s->dependent &&

3503

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

3504

{

3505

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

3506

}

3507

}

3508

stat_vector[i]=0;

3509

join->outer_join=outer_join;

3510

3511

if (join->outer_join)

3512

{

3513

3514

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

3515

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

3516

as well as allow us to catch illegal cross references/

3517

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

3518

As we use bitmaps to represent the relation the complexity

3519

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

3520

3521

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

3522

{

3523

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

3524

{

3525

table= stat[j].table;

3526

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

3527

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

3528

}

3529

if (s->dependent)

3530

s->table->maybe_null= 1;

3531

}

3532

/* Catch illegal cross references for outer joins */

3533

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

3534

{

3535

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

3536

{

3537

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

3538

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

3539

return(1);

3540

}

3541

s->key_dependent= s->dependent;

3542

}

3543

}

3544

3545

if (conds || outer_join)

3546

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

3547

conds, join->cond_equal,

3548

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

3549

return(1);

3550

3551

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

3552

join->const_table_map= 0;

3553

3554

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

3555

p_pos < p_end ;

3556

p_pos++)

3557

{

3558

int tmp;

3559

s= p_pos->table;

3560

s->type=JT_SYSTEM;

3561

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

3562

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

3563

{

3564

if (tmp > 0)

3565

return(1); // Fatal error

3566

}

3567

else

3568

found_const_table_map|= s->table->map;

3569

}

3570

3571

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

3572

int ref_changed;

3573

3574

{

3575

more_const_tables_found:

3576

ref_changed = 0;

3577

found_ref=0;

3578

3579

3580

We only have to loop from stat_vector + const_count as

3581

set_position() will move all const_tables first in stat_vector

3582

3583

3584

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

3585

{

3586

table=s->table;

3587

3588

3589

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

3590

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

3591

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

3592

3593

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

3594

{

3595

3596

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

3597

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

3598

null complemented and thus considered as constant tables.

3599

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

3600

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

3601

would require a more thorough analysis.

3602

TODO. Apply single row substitution to null complemented inner tables

3603

for nested outer join operations.

3604

3605

while (keyuse->table == table)

3606

{

3607

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

3608

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

3609

{

3610

s->type= JT_CONST;

3611

mark_as_null_row(table);

3612

found_const_table_map|= table->map;

3613

join->const_table_map|= table->map;

3614

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

3615

goto more_const_tables_found;

3616

}

3617

keyuse++;

3618

}

3619

}

3620

3621

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

3622

{

3623

// All dep. must be constants

3624

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

3625

continue;

3626

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

3627

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

3628

!table->pos_in_table_list->embedding)

3629

{ // system table

3630

int tmp= 0;

3631

s->type=JT_SYSTEM;

3632

join->const_table_map|=table->map;

3633

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

3634

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

3635

{

3636

if (tmp > 0)

3637

return(1); // Fatal error

3638

}

3639

else

3640

found_const_table_map|= table->map;

3641

continue;

3642

}

3643

}

3644

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

3645

if ((keyuse=s->keyuse))

3646

{

3647

s->type= JT_REF;

3648

while (keyuse->table == table)

3649

{

3650

start_keyuse=keyuse;

3651

key=keyuse->key;

3652

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

3653

3654

refs=0;

3655

const_ref.clear_all();

3656

eq_part.clear_all();

3657

3658

{

3659

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

3660

{

3661

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

3662

const_ref.set_bit(keyuse->keypart);

3663

else

3664

refs|=keyuse->used_tables;

3665

eq_part.set_bit(keyuse->keypart);

3666

}

3667

keyuse++;

3668

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

3669

3670

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

3671

!table->pos_in_table_list->embedding)

3672

{

3673

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

3674

== HA_NOSAME)

3675

{

3676

if (const_ref == eq_part)

3677

{ // Found everything for ref.

3678

int tmp;

3679

ref_changed = 1;

3680

s->type= JT_CONST;

3681

join->const_table_map|=table->map;

3682

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

3683

if (create_ref_for_key(join, s, start_keyuse,

3684

found_const_table_map))

3685

return(1);

3686

if ((tmp=join_read_const_table(s,

3687

join->positions+const_count-1)))

3688

{

3689

if (tmp > 0)

3690

return(1); // Fatal error

3691

}

3692

else

3693

found_const_table_map|= table->map;

3694

break;

3695

}

3696

else

3697

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

3698

}

3699

else if (const_ref == eq_part)

3700

s->const_keys.set_bit(key);

3701

}

3702

}

3703

}

3704

}

3705

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

3706

3707

3708

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

3709

reading const tables may has added new sargable predicates.

3710

3711

if (const_count && sargables)

3712

{

3713

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

3714

{

3715

Field *field= sargables->field;

3716

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

3717

key_map possible_keys= field->key_start;

3718

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

3719

bool is_const= 1;

3720

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

3721

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

3722

if (is_const)

3723

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

3724

}

3725

}

3726

3727

if (pull_out_semijoin_tables(join))

3728

return(true);

3729

3730

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

3731

3732

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

3733

{

3734

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

3735

{

3736

/* Only one matching row */

3737

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

3738

continue;

3739

}

3740

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

3741

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

3742

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

3743

3744

3745

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

3746

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

3747

table scan.

3748

3749

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

3750

(double) s->read_time*3);

3751

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

3752

s->worst_seeks=2.0;

3753

3754

3755

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

3756

all select distinct fields participate in one index.

3757

3758

add_group_and_distinct_keys(join, s);

3759

3760

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

3761

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

3762

{

3763

ha_rows records;

3764

SQL_SELECT *select;

3765

select= make_select(s->table, found_const_table_map,

3766

found_const_table_map,

3767

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

3768

1, &error);

3769

if (!select)

3770

return(1);

3771

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

3772

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

3773

s->quick=select->quick;

3774

s->needed_reg=select->needed_reg;

3775

select->quick=0;

3776

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

3777

{

3778

3779

Impossible WHERE or ON expression

3780

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

3781

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

3782

caller to abort with a zero row result.

3783

3784

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

3785

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

3786

s->type= JT_CONST;

3787

if (*s->on_expr_ref)

3788

{

3789

/* Generate empty row */

3790

s->info= "Impossible ON condition";

3791

found_const_table_map|= s->table->map;

3792

s->type= JT_CONST;

3793

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

3794

}

3795

}

3796

if (records != HA_POS_ERROR)

3797

{

3798

s->found_records=records;

3799

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

3800

}

3801

delete select;

3802

}

3803

}

3804

3805

join->join_tab=stat;

3806

join->map2table=stat_ref;

3807

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

3808

join->const_tables=const_count;

3809

join->found_const_table_map=found_const_table_map;

3810

3811

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

3812

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

3813

{

3814

optimize_keyuse(join, keyuse_array);

3815

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

3816

return(true);

3817

}

3818

else

3819

{

3820

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

3821

sizeof(POSITION)*join->const_tables);

3822

join->best_read=1.0;

3823

}

3824

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

3825

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

3826

}

3827

3828

3829

496

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

3830

497

Check with keys are used and with tables references with tables

3831

498

Updates in stat:

3834

501

keyuse Pointer to possible keys

3835

502

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

3836

503

3837

/// Used when finding key fields

3838

typedef struct key_field_t {

3839

Field *field;

3840

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

3841

uint level;

3842

uint optimize; // KEY_OPTIMIZE_*

3843

bool eq_func;

3844

/**

3845

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

3846

when val IS NULL.

3847

3848

bool null_rejecting;

3849

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

3850

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

3851

} KEY_FIELD;

3852

3853

/**

3854

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

3855

3856

This is called for OR between different levels.

3857

3858

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

3859

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

3860

that are internally transformed to something like:.

3861

3862

@code

3863

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

3864

@endcode

3865

3866

KEY_FIELD::null_rejecting is processed as follows: @n

3867

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

3868

for example:

3869

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

3870

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

3871

3872

@todo

3873

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

3874

OptimizerTeam: Fix this

3875

3876

3877

static KEY_FIELD *

3878

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

3879

uint32_t and_level)

3880

{

3881

if (start == new_fields)

3882

return start; // Impossible or

3883

if (new_fields == end)

3884

return start; // No new fields, skip all

3885

3886

KEY_FIELD *first_free=new_fields;

3887

3888

/* Mark all found fields in old array */

3889

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

3890

{

3891

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

3892

{

3893

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

3894

{

3895

3896

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

3897

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

3898

3899

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

3900

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

3901

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

3902

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

3903

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

3904

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

3905

TODO: OptimizerTeam: Fix this

3906

3907

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

3908

{

3909

3910

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

3911

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

3912

3913

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

3914

{

3915

old->level= and_level;

3916

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

3917

KEY_OPTIMIZE_EXISTS) |

3918

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

3919

KEY_OPTIMIZE_REF_OR_NULL));

3920

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

3921

new_fields->null_rejecting);

3922

}

3923

}

3924

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

3925

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

3926

old->field->binary(),

3927

old->field->charset()))

3928

3929

{

3930

old->level= and_level;

3931

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

3932

KEY_OPTIMIZE_EXISTS) |

3933

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

3934

KEY_OPTIMIZE_REF_OR_NULL));

3935

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

3936

new_fields->null_rejecting);

3937

}

3938

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

3939

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

3940

new_fields->val->is_null()))

3941

{

3942

/* field = expression OR field IS NULL */

3943

old->level= and_level;

3944

old->optimize= KEY_OPTIMIZE_REF_OR_NULL;

3945

3946

Remember the NOT NULL value unless the value does not depend

3947

on other tables.

3948

3949

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

3950

old->val= new_fields->val;

3951

/* The referred expression can be NULL: */

3952

old->null_rejecting= 0;

3953

}

3954

else

3955

{

3956

3957

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

3958

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

3959

and let the range optimzier handle it

3960

3961

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

3962

break;

3963

*old= *first_free; // Remove old value

3964

old--; // Retry this value

3965

}

3966

}

3967

}

3968

}

3969

/* Remove all not used items */

3970

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

3971

{

3972

if (old->level != and_level)

3973

{ // Not used in all levels

3974

if (old == --first_free)

3975

break;

3976

*old= *first_free; // Remove old value

3977

continue;

3978

}

3979

old++;

3980

}

3981

return first_free;

3982

}

3983

3984

3985

/**

3986

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

3987

3988

@param key_fields Pointer to add key, if usable

3989

@param and_level And level, to be stored in KEY_FIELD

3990

@param cond Condition predicate

3991

@param field Field used in comparision

3992

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

3993

@param value Value used for comparison with field

3994

@param usable_tables Tables which can be used for key optimization

3995

@param sargables IN/OUT Array of found sargable candidates

3996

3997

@note

3998

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

3999

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

4000

4001

@returns

4002

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

4003

4004

4005

static void

4006

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

4007

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

4008

table_map usable_tables, SARGABLE_PARAM **sargables)

4009

{

4010

uint32_t exists_optimize= 0;

4011

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

4012

{

4013

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

4014

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

4015

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

4016

return; // Not a key. Skip it

4017

exists_optimize= KEY_OPTIMIZE_EXISTS;

4018

assert(num_values == 1);

4019

}

4020

else

4021

{

4022

table_map used_tables=0;

4023

bool optimizable=0;

4024

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

4025

{

4026

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

4027

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

4028

optimizable=1;

4029

}

4030

if (!optimizable)

4031

return;

4032

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

4033

{

4034

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

4035

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

4036

return; // Can't use left join optimize

4037

exists_optimize= KEY_OPTIMIZE_EXISTS;

4038

}

4039

else

4040

{

4041

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

4042

key_map possible_keys=field->key_start;

4043

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

4044

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

4045

4046

4047

Save the following cases:

4048

Field op constant

4049

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

4050

Field = field2 where field2 is in a different table

4051

Field op formula

4052

Field IS NULL

4053

Field IS NOT NULL

4054

Field BETWEEN ...

4055

Field IN ...

4056

4057

stat[0].key_dependent|=used_tables;

4058

4059

bool is_const=1;

4060

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

4061

{

4062

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

4063

break;

4064

}

4065

if (is_const)

4066

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

4067

else if (!eq_func)

4068

{

4069

4070

Save info to be able check whether this predicate can be

4071

considered as sargable for range analisis after reading const tables.

4072

We do not save info about equalities as update_const_equal_items

4073

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

4074

4075

(*sargables)--;

4076

(*sargables)->field= field;

4077

(*sargables)->arg_value= value;

4078

(*sargables)->num_values= num_values;

4079

}

4080

4081

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

4082

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

4083

eq_func is NEVER true when num_values > 1

4084

4085

if (!eq_func)

4086

{

4087

4088

Additional optimization: if we're processing

4089

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

4090

"t.key = c1".

4091

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

4092

There are 2 options:

4093

A) Make equality propagation code be able to handle BETWEEN

4094

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

4095

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

4096

and use them in equality propagation process (see details in

4097

OptimizerKBAndTodo)

4098

4099

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

4100

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

4101

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

4102

return;

4103

eq_func= true;

4104

}

4105

4106

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

4107

{

4108

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

4109

{

4110

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

4111

return;

4112

}

4113

else

4114

{

4115

4116

We can't use indexes if the effective collation

4117

of the operation differ from the field collation.

4118

4119

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

4120

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

4121

return;

4122

}

4123

}

4124

}

4125

}

4126

4127

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

4128

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

4129

4130

assert(eq_func);

4131

/* Store possible eq field */

4132

(*key_fields)->field= field;

4133

(*key_fields)->eq_func= eq_func;

4134

(*key_fields)->val= *value;

4135

(*key_fields)->level= and_level;

4136

(*key_fields)->optimize= exists_optimize;

4137

4138

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

4139

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

4140

has NULL value.

4141

We use null_rejecting in add_not_null_conds() to add

4142

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

4143

4144

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

4145

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

4146

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

4147

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

4148

(*key_fields)->cond_guard= NULL;

4149

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

4150

cond->name < subq_sj_cond_name + 64)?

4151

cond->name - subq_sj_cond_name: UINT_MAX;

4152

(*key_fields)++;

4153

}

4154

4155

/**

4156

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

4157

predicate.

4158

4159

@param key_fields Pointer to add key, if usable

4160

@param and_level And level, to be stored in KEY_FIELD

4161

@param cond Condition predicate

4162

@param field Field used in comparision

4163

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

4164

@param value Value used for comparison with field

4165

Is NULL for BETWEEN and IN

4166

@param usable_tables Tables which can be used for key optimization

4167

@param sargables IN/OUT Array of found sargable candidates

4168

4169

@note

4170

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

4171

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

4172

4173

@returns

4174

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

4175

4176

4177

static void

4178

add_key_equal_fields(KEY_FIELD **key_fields, uint32_t and_level,

4179

Item_func *cond, Item_field *field_item,

4180

bool eq_func, Item **val,

4181

uint32_t num_values, table_map usable_tables,

4182

SARGABLE_PARAM **sargables)

4183

{

4184

Field *field= field_item->field;

4185

add_key_field(key_fields, and_level, cond, field,

4186

eq_func, val, num_values, usable_tables, sargables);

4187

Item_equal *item_equal= field_item->item_equal;

4188

if (item_equal)

4189

{

4190

4191

Add to the set of possible key values every substitution of

4192

the field for an equal field included into item_equal

4193

4194

Item_equal_iterator it(*item_equal);

4195

Item_field *item;

4196

while ((item= it++))

4197

{

4198

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

4199

{

4200

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

4201

eq_func, val, num_values, usable_tables,

4202

sargables);

4203

}

4204

}

4205

}

4206

}

4207

4208

static void

4209

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

4210

COND *cond, table_map usable_tables,

4211

SARGABLE_PARAM **sargables)

4212

{

4213

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

4214

{

4215

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

4216

KEY_FIELD *org_key_fields= *key_fields;

4217

4218

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

4219

{

4220

Item *item;

4221

while ((item=li++))

4222

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

4223

sargables);

4224

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

4225

org_key_fields->level= *and_level;

4226

}

4227

else

4228

{

4229

(*and_level)++;

4230

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

4231

sargables);

4232

Item *item;

4233

while ((item=li++))

4234

{

4235

KEY_FIELD *start_key_fields= *key_fields;

4236

(*and_level)++;

4237

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

4238

sargables);

4239

*key_fields=merge_key_fields(org_key_fields,start_key_fields,

4240

*key_fields,++(*and_level));

4241

}

4242

}

4243

return;

4244

}

4245

4246

4247

Subquery optimization: Conditions that are pushed down into subqueries

4248

are wrapped into Item_func_trig_cond. We process the wrapped condition

4249

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

4250

4251

{

4252

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

4253

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

4254

{

4255

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

4256

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

4257

join->unit->item &&

4258

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

4259

!join->unit->is_union())

4260

{

4261

KEY_FIELD *save= *key_fields;

4262

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

4263

sargables);

4264

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

4265

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

4266

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

4267

}

4268

return;

4269

}

4270

}

4271

4272

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

4273

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

4274

return;

4275

Item_func *cond_func= (Item_func*) cond;

4276

switch (cond_func->select_optimize()) {

4277

case Item_func::OPTIMIZE_NONE:

4278

break;

4279

case Item_func::OPTIMIZE_KEY:

4280

{

4281

Item **values;

4282

// BETWEEN, IN, NE

4283

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

4284

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

4285

{

4286

values= cond_func->arguments()+1;

4287

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

4288

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

4289

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

4290

values--;

4291

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

4292

cond_func->argument_count() != 2);

4293

add_key_equal_fields(key_fields, *and_level, cond_func,

4294

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

4295

0, values,

4296

cond_func->argument_count()-1,

4297

usable_tables, sargables);

4298

}

4299

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

4300

{

4301

values= cond_func->arguments();

4302

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

4303

{

4304

Item_field *field_item;

4305

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

4306

4307

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

4308

{

4309

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

4310

add_key_equal_fields(key_fields, *and_level, cond_func,

4311

field_item, 0, values, 1, usable_tables,

4312

sargables);

4313

}

4314

}

4315

}

4316

break;

4317

}

4318

case Item_func::OPTIMIZE_OP:

4319

{

4320

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

4321

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

4322

4323

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

4324

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

4325

{

4326

add_key_equal_fields(key_fields, *and_level, cond_func,

4327

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

4328

equal_func,

4329

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

4330

sargables);

4331

}

4332

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

4333

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

4334

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

4335

{

4336

add_key_equal_fields(key_fields, *and_level, cond_func,

4337

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

4338

equal_func,

4339

cond_func->arguments(),1,usable_tables,

4340

sargables);

4341

}

4342

break;

4343

}

4344

case Item_func::OPTIMIZE_NULL:

4345

/* column_name IS [NOT] NULL */

4346

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

4347

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

4348

{

4349

Item *tmp=new Item_null;

4350

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

4351

return;

4352

add_key_equal_fields(key_fields, *and_level, cond_func,

4353

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

4354

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

4355

&tmp, 1, usable_tables, sargables);

4356

}

4357

break;

4358

case Item_func::OPTIMIZE_EQUAL:

4359

Item_equal *item_equal= (Item_equal *) cond;

4360

Item *const_item= item_equal->get_const();

4361

Item_equal_iterator it(*item_equal);

4362

Item_field *item;

4363

if (const_item)

4364

{

4365

4366

For each field field1 from item_equal consider the equality

4367

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

4368

with field1 by the keys value of field1.

4369

4370

while ((item= it++))

4371

{

4372

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

4373

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

4374

}

4375

}

4376

else

4377

{

4378

4379

Consider all pairs of different fields included into item_equal.

4380

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

4381

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

4382

with field1 by the keys value of field2.

4383

4384

Item_equal_iterator fi(*item_equal);

4385

while ((item= fi++))

4386

{

4387

Field *field= item->field;

4388

while ((item= it++))

4389

{

4390

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

4391

{

4392

add_key_field(key_fields, *and_level, cond_func, field,

4393

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

4394

sargables);

4395

}

4396

}

4397

it.rewind();

4398

}

4399

}

4400

break;

4401

}

4402

}

4403

504

4404

505

/**

4405

506

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

4406

507

4407

508

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

4408

509

4409

4410

static uint

4411

max_part_bit(key_part_map bits)

510

uint32_t max_part_bit(key_part_map bits)

4412

511

{

4413

512

uint32_t found;

4414

513

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

4415

514

return found;

4416

515

}

4417

516

4418

static void

4419

add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)

4420

{

4421

Field *field=key_field->field;

4422

Table *form= field->table;

4423

KEYUSE keyuse;

4424

4425

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

4426

{

4427

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

4428

{

4429

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

4430

continue;

4431

4432

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

4433

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

4434

{

4435

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

4436

{

4437

keyuse.table= field->table;

4438

keyuse.val = key_field->val;

4439

keyuse.key = key;

4440

keyuse.keypart=part;

4441

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

4442

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

4443

keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;

4444

keyuse.null_rejecting= key_field->null_rejecting;

4445

keyuse.cond_guard= key_field->cond_guard;

4446

keyuse.sj_pred_no= key_field->sj_pred_no;

4447

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

4448

}

4449

}

4450

}

4451

}

4452

}

4453

4454

static int

4455

sort_keyuse(KEYUSE *a,KEYUSE *b)

517

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

4456

518

{

4457

519

int res;

4458

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

4459

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

4460

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

4461

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

4462

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

4463

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

520

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

521

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

522

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

523

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

524

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

525

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

4464

526

// Place const values before other ones

4465

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

4466

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

527

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

528

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

4467

529

return res;

4468

530

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

4469

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

4470

(b->optimize & KEY_OPTIMIZE_REF_OR_NULL));

4471

}

4472

4473

4474

4475

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

4476

4477

This function populates KEY_FIELD array with entries generated from the

4478

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

4479

contained within this nested join.

4480

4481

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

4482

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

4483

@param[in,out] and_level And-level

4484

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

4485

4486

4487

@note

4488

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

4489

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

4490

4491

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

4492

invoked for):

4493

@code

4494

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

4495

@endcode

4496

Example for #2:

4497

@code

4498

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

4499

@endcode

4500

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

4501

t1 only.

4502

Example #3:

4503

@code

4504

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

4505

@endcode

4506

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

4507

4508

4509

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

4510

KEY_FIELD **end, uint32_t *and_level,

4511

SARGABLE_PARAM **sargables)

4512

{

4513

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

4514

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

4515

bool have_another = false;

4516

table_map tables= 0;

4517

TableList *table;

4518

assert(nested_join_table->nested_join);

4519

4520

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

4521

(table= li++))))

4522

{

4523

if (table->nested_join)

4524

{

4525

if (!table->on_expr)

4526

{

4527

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

4528

have_another= true;

4529

li2= li;

4530

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

4531

}

4532

else

4533

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

4534

}

4535

else

4536

if (!table->on_expr)

4537

tables |= table->table->map;

4538

}

4539

if (nested_join_table->on_expr)

4540

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

4541

sargables);

531

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

532

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

4542

533

}

4543

534

4544

535

4545

536

/**

4546

537

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

4547

4548

@param thd

4549

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

538

539

@param session

540

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

4550

541

@param join_tab Array in tablenr_order

4551

542

@param tables Number of tables in join

4552

543

@param cond WHERE condition (note that the function analyzes

4555

546

for which we can make ref access based the WHERE

4556

547

clause)

4557

548

@param select_lex current SELECT

4558

@param[out] sargables Array of found sargable candidates

4559

549

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

550

4560

551

@retval

4561

552

0 OK

4562

553

@retval

4563

554

1 Out of memory.

4564

555

4565

4566

static bool

4567

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

4568

uint32_t tables, COND *cond,

4569

COND_EQUAL *cond_equal __attribute__((unused)),

4570

table_map normal_tables, SELECT_LEX *select_lex,

4571

SARGABLE_PARAM **sargables)

556

bool update_ref_and_keys(Session *session,

557

DYNAMIC_ARRAY *keyuse,

558

JoinTable *join_tab,

559

uint32_t tables,

560

COND *cond,

561

COND_EQUAL *,

562

table_map normal_tables,

563

Select_Lex *select_lex,

564

vector<optimizer::SargableParam> &sargables)

4572

565

{

4573

566

uint and_level,i,found_eq_constant;

4574

KEY_FIELD *key_fields, *end, *field;

567

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

4575

568

uint32_t sz;

4576

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

4577

4578

4579

We use the same piece of memory to store both KEY_FIELD

4580

and SARGABLE_PARAM structure.

4581

KEY_FIELD values are placed at the beginning this memory

4582

while SARGABLE_PARAM values are put at the end.

4583

All predicates that are used to fill arrays of KEY_FIELD

4584

and SARGABLE_PARAM structures have at most 2 arguments

4585

except BETWEEN predicates that have 3 arguments and

569

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

570

571

572

All predicates that are used to fill arrays of KeyField

573

and SargableParam classes have at most 2 arguments

574

except BETWEEN predicates that have 3 arguments and

4586

575

IN predicates.

4587

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

4588

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

4589

or SARGABLE_PARAM type. For a BETWEEN predicate 3 elements

576

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

577

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

578

or SargableParam type. For a BETWEEN predicate 3 elements

4590

579

can be filled as this predicate is considered as

4591

580

saragable with respect to each of its argument.

4592

581

An IN predicate can require at most 1 element as currently

4593

582

it is considered as sargable only for its first argument.

4594

583

Multiple equality can add elements that are filled after

4595

584

substitution of field arguments by equal fields. There

4596

can be not more than select_lex->max_equal_elems such

585

can be not more than select_lex->max_equal_elems such

4597

586

substitutions.

4598

4599

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

4600

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

4601

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

4602

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

4603

return true; /* purecov: inspected */

587

588

sz= sizeof(optimizer::KeyField) *

589

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

590

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

591

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

592

return true;

4604

593

and_level= 0;

4605

594

field= end= key_fields;

4606

*sargables= (SARGABLE_PARAM *) key_fields +

4607

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

4608

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

4609

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

4610

595

4611

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

596

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

4612

597

return true;

4613

598

if (cond)

4614

599

{

4615

600

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

4616

601

sargables);

4617

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

602

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

4618

603

{

4619

add_key_part(keyuse,field);

604

add_key_part(keyuse, field);

4620

605

/* Mark that we can optimize LEFT JOIN */

4621

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

4622

!field->field->real_maybe_null())

4623

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

606

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

607

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

608

{

609

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

610

}

4624

611

}

4625

612

}

4626

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

613

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

4627

614

{

4628

615

4629

616

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

4633

620

In the future when we introduce conditional accesses

4634

621

for inner tables in outer joins these keys will be taken

4635

622

into account as well.

4636

623

4637

624

if (*join_tab[i].on_expr_ref)

4638

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

625

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

4639

626

*join_tab[i].on_expr_ref,

4640

627

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

4641

628

}

4647

634

while ((table= li++))

4648

635

{

4649

636

if (table->nested_join)

4650

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

637

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

4651

638

sargables);

4652

639

}

4653

640

}

4667

654

4668

655

if (keyuse->elements)

4669

656

{

4670

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

657

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

4671

658

4672

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

659

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

4673

660

(qsort_cmp) sort_keyuse);

4674

661

4675

662

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

4676

663

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

4677

664

4678

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

665

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

4679

666

prev= &key_end;

4680

found_eq_constant=0;

4681

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

667

found_eq_constant= 0;

668

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

4682

669

{

4683

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

4684

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

670

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

671

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

672

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

4685

673

{

4686

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

4687

{

4688

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

4689

continue; /* remove */

4690

}

4691

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

4692

continue;

674

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

675

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

676

continue; /* remove */

4693

677

}

678

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

679

continue;

4694

680

4695

681

#ifdef HAVE_purify

4696

682

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

4698

684

#endif

4699

685

*save_pos= *use;

4700

686

prev=use;

4701

found_eq_constant= !use->used_tables;

687

found_eq_constant= ! use->getUsedTables();

4702

688

/* Save ptr to first use */

4703

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

4704

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

4705

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

689

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

690

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

691

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

4706

692

save_pos++;

4707

693

}

4708

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

4709

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

4710

keyuse->elements=i;

694

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

695

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

696

keyuse->elements= i;

4711

697

}

4712

698

return false;

4713

699

}

4715

701

/**

4716

702

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

4717

703

4718

4719

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

704

void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)

4720

705

{

4721

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

706

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

707

708

optimizer::KeyUse*);

4722

709

4723

710

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

4724

711

{

4731

718

Constant tables are ignored.

4732

719

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

4733

720

4734

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

4735

if (keyuse->used_tables &

4736

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

4737

~OUTER_REF_TABLE_BIT)))

721

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

722

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

4738

723

{

4739

724

uint32_t tablenr;

4740

725

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

4741

726

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

4742

727

{

4743

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

4744

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

728

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

729

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

4745

730

}

4746

731

}

4747

732

4748

733

Outer reference (external field) is constant for single executing

4749

734

of subquery

4750

735

4751

if (keyuse->used_tables == OUTER_REF_TABLE_BIT)

4752

keyuse->ref_table_rows= 1;

736

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

737

keyuse->setTableRows(1);

4753

738

}

4754

739

}

4755

740

4771

756

@return

4772

757

None

4773

758

4774

4775

static void

4776

add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab)

759

void add_group_and_distinct_keys(JOIN *join, JoinTable *join_tab)

4777

760

{

4778

761

List<Item_field> indexed_fields;

4779

762

List_iterator<Item_field> indexed_fields_it(indexed_fields);

4804

787

4805

788

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

4806

789

cur_item= indexed_fields_it++;

4807

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

790

possible_keys|= cur_item->field->part_of_key;

4808

791

while ((cur_item= indexed_fields_it++))

4809

792

{

4810

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

4811

}

4812

4813

if (!possible_keys.is_clear_all())

4814

join_tab->const_keys.merge(possible_keys);

4815

}

4816

4817

4818

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

4819

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

4820

which uses least records

4821

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

4822

4823

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

4824

4825

static void

4826

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

4827

{

4828

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

4829

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

4830

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

4831

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

4832

4833

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

4834

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

4835

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

4836

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

4837

{

4838

JOIN_TAB *tmp=pos[0];

4839

pos[0]=next;

4840

next=tmp;

4841

}

4842

join->best_ref[idx]=table;

4843

}

4844

4845

4846

4847

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

4848

4849

SYNOPSIS

4850

get_bound_sj_equalities()

4851

sj_nest Semi-join nest

4852

remaining_tables Tables that are not yet bound

4853

4854

DESCRIPTION

4855

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

4856

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

4857

any of remaining_tables and can be evaluated).

4858

4859

RETURN

4860

Bitmap of bound IN-equalities.

4861

4862

4863

uint64_t get_bound_sj_equalities(TableList *sj_nest,

4864

table_map remaining_tables)

4865

{

4866

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

4867

Item *item;

4868

uint32_t i= 0;

4869

uint64_t res= 0;

4870

while ((item= li++))

4871

{

4872

4873

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

4874

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

4875

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

4876

(this is an optional feature)

4877

4878

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

4879

{

4880

res |= 1UL < i;

4881

}

4882

}

4883

return res;

4884

}

4885

4886

4887

/**

4888

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

4889

plan and add this path to the plan.

4890

4891

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

4892

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

4893

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

4894

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

4895

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

4896

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

4897

4898

@param join pointer to the structure providing all context info

4899

for the query

4900

@param s the table to be joined by the function

4901

@param thd thread for the connection that submitted the query

4902

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

4903

@param idx the length of the partial plan

4904

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

4905

partial plan

4906

@param read_time the cost of the partial plan

4907

4908

@return

4909

None

4910

4911

4912

static void

4913

best_access_path(JOIN *join,

4914

JOIN_TAB *s,

4915

THD *thd,

4916

table_map remaining_tables,

4917

uint32_t idx,

4918

double record_count,

4919

double read_time __attribute__((unused)))

4920

{

4921

KEYUSE *best_key= 0;

4922

uint32_t best_max_key_part= 0;

4923

bool found_constraint= 0;

4924

double best= DBL_MAX;

4925

double best_time= DBL_MAX;

4926

double records= DBL_MAX;

4927

table_map best_ref_depends_map= 0;

4928

double tmp;

4929

ha_rows rec;

4930

uint32_t best_is_sj_inside_out= 0;

4931

4932

if (s->keyuse)

4933

{ /* Use key if possible */

4934

Table *table= s->table;

4935

KEYUSE *keyuse,*start_key=0;

4936

double best_records= DBL_MAX;

4937

uint32_t max_key_part=0;

4938

uint64_t bound_sj_equalities= 0;

4939

bool try_sj_inside_out= false;

4940

4941

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

4942

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

4943

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

4944

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

4945

all or none of their tables in join_table_map), except

4946

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

4947

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

4948

4949

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

4950

s->emb_sj_nest->sj_in_exprs < 64 &&

4951

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

4952

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

4953

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

4954

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

4955

{

4956

/* This table is an InsideOut scan candidate */

4957

bound_sj_equalities= get_bound_sj_equalities(s->emb_sj_nest,

4958

remaining_tables);

4959

try_sj_inside_out= true;

4960

}

4961

4962

/* Test how we can use keys */

4963

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

4964

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

4965

{

4966

key_part_map found_part= 0;

4967

table_map found_ref= 0;

4968

uint32_t key= keyuse->key;

4969

KEY *keyinfo= table->key_info+key;

4970

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

4971

key_part_map const_part= 0;

4972

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

4973

key_part_map ref_or_null_part= 0;

4974

4975

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

4976

start_key= keyuse;

4977

uint64_t handled_sj_equalities=0;

4978

key_part_map sj_insideout_map= 0;

4979

4980

do /* For each keypart */

4981

{

4982

uint32_t keypart= keyuse->keypart;

4983

table_map best_part_found_ref= 0;

4984

double best_prev_record_reads= DBL_MAX;

4985

4986

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

4987

{

4988

4989

4990

if 1. expression doesn't refer to forward tables

4991

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

4992

4993

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

4994

!(ref_or_null_part && (keyuse->optimize &

4995

KEY_OPTIMIZE_REF_OR_NULL)))

4996

{

4997

found_part|= keyuse->keypart_map;

4998

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

4999

const_part|= keyuse->keypart_map;

5000

5001

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

5002

keyuse->used_tables));

5003

if (tmp2 < best_prev_record_reads)

5004

{

5005

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

5006

best_prev_record_reads= tmp2;

5007

}

5008

if (rec > keyuse->ref_table_rows)

5009

rec= keyuse->ref_table_rows;

5010

5011

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

5012

use this ref_or_null optimisation of this field

5013

5014

if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)

5015

ref_or_null_part |= keyuse->keypart_map;

5016

}

5017

5018

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

5019

{

5020

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

5021

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

5022

else

5023

{

5024

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

5025

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

5026

}

5027

}

5028

5029

keyuse++;

5030

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

5031

keyuse->keypart == keypart);

5032

found_ref|= best_part_found_ref;

5033

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

5034

5035

5036

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

5037

5038

if (!found_part && !handled_sj_equalities)

5039

continue; // Nothing usable found

5040

5041

if (rec < MATCHING_ROWS_IN_OTHER_TABLE)

5042

rec= MATCHING_ROWS_IN_OTHER_TABLE; // Fix for small tables

5043

5044

bool sj_inside_out_scan= false;

5045

{

5046

found_constraint= 1;

5047

5048

Check if InsideOut scan is applicable:

5049

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

5050

2. Index keyparts are

5051

...

5052

5053

if (try_sj_inside_out &&

5054

table->covering_keys.is_set(key) &&

5055

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

5056

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

5057

{

5058

uint32_t n_fixed_parts= max_part_bit(found_part);

5059

if (n_fixed_parts != keyinfo->key_parts &&

5060

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

5061

PREV_BITS(uint, keyinfo->key_parts))

5062

{

5063

5064

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

5065

check if all of them are covered.

5066

5067

sj_inside_out_scan= true;

5068

if (!n_fixed_parts)

5069

{

5070

5071

It's a confluent ref scan.

5072

5073

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

5074

and there is really no ref access because there is no

5075

t.keypart0 = {bound expression}

5076

5077

Calculate the cost of complete loose index scan.

5078

5079

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

5080

5081

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

5082

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

5083

5084

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

5085

ulong rpc;

5086

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

5087

records= records / rpc;

5088

start_key= NULL;

5089

}

5090

}

5091

}

5092

5093

5094

Check if we found full key

5095

5096

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

5097

!ref_or_null_part)

5098

{ /* use eq key */

5099

max_key_part= UINT32_MAX;

5100

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

5101

{

5102

tmp = prev_record_reads(join, idx, found_ref);

5103

records=1.0;

5104

}

5105

else

5106

{

5107

if (!found_ref)

5108

{ /* We found a const key */

5109

5110

ReuseRangeEstimateForRef-1:

5111

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

5112

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

5113

5114

If range optimizer was able to construct a "range"

5115

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

5116

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

5117

from the range optimizer.

5118

5119

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

5120

quick_cond will be equal or tighther than ref_const_cond.

5121

ref_const_cond already covers "smallest" possible interval -

5122

a singlepoint interval over all keyparts. Therefore,

5123

quick_cond is equivalent to ref_const_cond (if it was an

5124

empty interval we wouldn't have got here).

5125

5126

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

5127

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

5128

else

5129

{

5130

/* quick_range couldn't use key! */

5131

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

5132

}

5133

}

5134

else

5135

{

5136

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

5137

{ /* Prefer longer keys */

5138

records=

5139

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

5140

(1.0 +

5141

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

5142

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

5143

if (records < 2.0)

5144

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

5145

}

5146

5147

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

5148

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

5149

5150

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

5151

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

5152

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

5153

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

5154

in ReuseRangeEstimateForRef-3.

5155

5156

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

5157

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

5158

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

5159

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

5160

{

5161

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

5162

}

5163

}

5164

/* Limit the number of matched rows */

5165

tmp= records;

5166

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

5167

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

5168

{

5169

/* we can use only index tree */

5170

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

5171

}

5172

else

5173

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

5174

}

5175

}

5176

else

5177

{

5178

5179

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

5180

than a not unique key

5181

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

5182

5183

if ((found_part & 1) &&

5184

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

5185

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

5186

{

5187

max_key_part= max_part_bit(found_part);

5188

5189

ReuseRangeEstimateForRef-3:

5190

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

5191

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

5192

(same-as-above but with one cond replaced

5193

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

5194

5195

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

5196

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

5197

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

5198

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

5199

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

5200

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

5201

The sufficient conditions for re-use are:

5202

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

5203

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

5204

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

5205

join)

5206

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

5207

is apparently a necessary requirement)

5208

5209

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

5210

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

5211

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

5212

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

5213

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

5214

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

5215

5216

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

5217

(same-as-above but with one cond replaced

5218

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

5219

5220

The remaining part is to exclude the situation where range

5221

optimizer used one interval while we're considering

5222

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

5223

is done by last limitation:

5224

5225

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

5226

5227

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

5228

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

5229

table->quick_n_ranges[key] == 1+((ref_or_null_part)?1:0)) //(C3)

5230

{

5231

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

5232

}

5233

else

5234

{

5235

/* Check if we have statistic about the distribution */

5236

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

5237

{

5238

5239

Fix for the case where the index statistics is too

5240

optimistic: If

5241

(1) We're considering ref(const) and there is quick select

5242

on the same index,

5243

(2) and that quick select uses more keyparts (i.e. it will

5244

scan equal/smaller interval then this ref(const))

5245

(3) and E(#rows) for quick select is higher then our

5246

estimate,

5247

Then

5248

We'll use E(#rows) from quick select.

5249

5250

Q: Why do we choose to use 'ref'? Won't quick select be

5251

cheaper in some cases ?

5252

TODO: figure this out and adjust the plan choice if needed.

5253

5254

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

5255

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

5256

records < (double)table->quick_rows[key]) // (3)

5257

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

5258

5259

tmp= records;

5260

}

5261

else

5262

{

5263

5264

Assume that the first key part matches 1% of the file

5265

and that the whole key matches 10 (duplicates) or 1

5266

(unique) records.

5267

Assume also that more key matches proportionally more

5268

records

5269

This gives the formula:

5270

records = (x * (b-a) + a*c-b)/(c-1)

5271

5272

b = records matched by whole key

5273

a = records matched by first key part (1% of all records?)

5274

c = number of key parts in key

5275

x = used key parts (1 <= x <= c)

5276

5277

double rec_per_key;

5278

if (!(rec_per_key=(double)

5279

keyinfo->rec_per_key[keyinfo->key_parts-1]))

5280

rec_per_key=(double) s->records/rec+1;

5281

5282

if (!s->records)

5283

tmp = 0;

5284

else if (rec_per_key/(double) s->records >= 0.01)

5285

tmp = rec_per_key;

5286

else

5287

{

5288

double a=s->records*0.01;

5289

if (keyinfo->key_parts > 1)

5290

tmp= (max_key_part * (rec_per_key - a) +

5291

a*keyinfo->key_parts - rec_per_key)/

5292

(keyinfo->key_parts-1);

5293

else

5294

tmp= a;

5295

set_if_bigger(tmp,1.0);

5296

}

5297

records = (ulong) tmp;

5298

}

5299

5300

if (ref_or_null_part)

5301

{

5302

/* We need to do two key searches to find key */

5303

tmp *= 2.0;

5304

records *= 2.0;

5305

}

5306

5307

5308

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

5309

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

5310

5311

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

5312

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

5313

current estimate, make the adjustment.

5314

5315

The decision whether we can re-use the estimate from the range

5316

optimizer is the same as in ReuseRangeEstimateForRef-3,

5317

applied to first table->quick_key_parts[key] key parts.

5318

5319

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

5320

table->quick_key_parts[key] <= max_key_part &&

5321

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

5322

table->quick_n_ranges[key] == 1 + ((ref_or_null_part &

5323

const_part) ? 1 : 0) &&

5324

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

5325

{

5326

tmp= records= (double) table->quick_rows[key];

5327

}

5328

}

5329

5330

/* Limit the number of matched rows */

5331

set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);

5332

if (table->covering_keys.is_set(key))

5333

{

5334

/* we can use only index tree */

5335

tmp= record_count * table->file->index_only_read_time(key, tmp);

5336

}

5337

else

5338

tmp= record_count * cmin(tmp,s->worst_seeks);

5339

}

5340

else

5341

tmp= best_time; // Do nothing

5342

}

5343

5344

if (sj_inside_out_scan && !start_key)

5345

{

5346

tmp= tmp/2;

5347

if (records)

5348

records= records/2;

5349

}

5350

5351

}

5352

if (tmp < best_time - records/(double) TIME_FOR_COMPARE)

5353

{

5354

best_time= tmp + records/(double) TIME_FOR_COMPARE;

5355

best= tmp;

5356

best_records= records;

5357

best_key= start_key;

5358

best_max_key_part= max_key_part;

5359

best_ref_depends_map= found_ref;

5360

best_is_sj_inside_out= sj_inside_out_scan;

5361

}

5362

}

5363

records= best_records;

5364

}

5365

5366

5367

Don't test table scan if it can't be better.

5368

Prefer key lookup if we would use the same key for scanning.

5369

5370

Don't do a table scan on InnoDB tables, if we can read the used

5371

parts of the row from any of the used index.

5372

This is because table scans uses index and we would not win

5373

anything by using a table scan.

5374

5375

A word for word translation of the below if-statement in sergefp's

5376

understanding: we check if we should use table scan if:

5377

(1) The found 'ref' access produces more records than a table scan

5378

(or index scan, or quick select), or 'ref' is more expensive than

5379

any of them.

5380

(2) This doesn't hold: the best way to perform table scan is to to perform

5381

'range' access using index IDX, and the best way to perform 'ref'

5382

access is to use the same index IDX, with the same or more key parts.

5383

(note: it is not clear how this rule is/should be extended to

5384

index_merge quick selects)

5385

(3) See above note about InnoDB.

5386

(4) NOT ("FORCE INDEX(...)" is used for table and there is 'ref' access

5387

path, but there is no quick select)

5388

If the condition in the above brackets holds, then the only possible

5389

"table scan" access method is ALL/index (there is no quick select).

5390

Since we have a 'ref' access path, and FORCE INDEX instructs us to

5391

choose it over ALL/index, there is no need to consider a full table

5392

scan.

5393

5394

if ((records >= s->found_records || best > s->read_time) && // (1)

5395

!(s->quick && best_key && s->quick->index == best_key->key && // (2)

5396

best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)

5397

!((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) && // (3)

5398

! s->table->covering_keys.is_clear_all() && best_key && !s->quick) &&// (3)

5399

!(s->table->force_index && best_key && !s->quick)) // (4)

5400

{ // Check full join

5401

ha_rows rnd_records= s->found_records;

5402

5403

If there is a filtering condition on the table (i.e. ref analyzer found

5404

at least one "table.keyXpartY= exprZ", where exprZ refers only to tables

5405

preceding this table in the join order we're now considering), then

5406

assume that 25% of the rows will be filtered out by this condition.

5407

5408

This heuristic is supposed to force tables used in exprZ to be before

5409

this table in join order.

5410

5411

if (found_constraint)

5412

rnd_records-= rnd_records/4;

5413

5414

5415

If applicable, get a more accurate estimate. Don't use the two

5416

heuristics at once.

5417

5418

if (s->table->quick_condition_rows != s->found_records)

5419

rnd_records= s->table->quick_condition_rows;

5420

5421

5422

Range optimizer never proposes a RANGE if it isn't better

5423

than FULL: so if RANGE is present, it's always preferred to FULL.

5424

Here we estimate its cost.

5425

5426

if (s->quick)

5427

{

5428

5429

For each record we:

5430

- read record range through 'quick'

5431

- skip rows which does not satisfy WHERE constraints

5432

TODO:

5433

We take into account possible use of join cache for ALL/index

5434

access (see first else-branch below), but we don't take it into

5435

account here for range/index_merge access. Find out why this is so.

5436

5437

tmp= record_count *

5438

(s->quick->read_time +

5439

(s->found_records - rnd_records)/(double) TIME_FOR_COMPARE);

5440

}

5441

else

5442

{

5443

/* Estimate cost of reading table. */

5444

tmp= s->table->file->scan_time();

5445

if (s->table->map & join->outer_join) // Can't use join cache

5446

{

5447

5448

For each record we have to:

5449

- read the whole table record

5450

- skip rows which does not satisfy join condition

5451

5452

tmp= record_count *

5453

(tmp +

5454

(s->records - rnd_records)/(double) TIME_FOR_COMPARE);

5455

}

5456

else

5457

{

5458

/* We read the table as many times as join buffer becomes full. */

5459

tmp*= (1.0 + floor((double) cache_record_length(join,idx) *

5460

record_count /

5461

(double) thd->variables.join_buff_size));

5462

5463

We don't make full cartesian product between rows in the scanned

5464

table and existing records because we skip all rows from the

5465

scanned table, which does not satisfy join condition when

5466

we read the table (see flush_cached_records for details). Here we

5467

take into account cost to read and skip these records.

5468

5469

tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE;

5470

}

5471

}

5472

5473

5474

We estimate the cost of evaluating WHERE clause for found records

5475

as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus

5476

tmp give us total cost of using Table SCAN

5477

5478

if (best == DBL_MAX ||

5479

(tmp + record_count/(double) TIME_FOR_COMPARE*rnd_records <

5480

best + record_count/(double) TIME_FOR_COMPARE*records))

5481

{

5482

5483

If the table has a range (s->quick is set) make_join_select()

5484

will ensure that this will be used

5485

5486

best= tmp;

5487

records= rows2double(rnd_records);

5488

best_key= 0;

5489

/* range/index_merge/ALL/index access method are "independent", so: */

5490

best_ref_depends_map= 0;

5491

best_is_sj_inside_out= false;

5492

}

5493

}

5494

5495

/* Update the cost information for the current partial plan */

5496

join->positions[idx].records_read= records;

5497

join->positions[idx].read_time= best;

5498

join->positions[idx].key= best_key;

5499

join->positions[idx].table= s;

5500

join->positions[idx].ref_depend_map= best_ref_depends_map;

5501

join->positions[idx].use_insideout_scan= best_is_sj_inside_out;

5502

5503

if (!best_key &&

5504

idx == join->const_tables &&

5505

s->table == join->sort_by_table &&

5506

join->unit->select_limit_cnt >= records)

5507

join->sort_by_table= (Table*) 1; // Must use temporary table

5508

5509

return;

5510

}

5511

5512

5513

/**

5514

Selects and invokes a search strategy for an optimal query plan.

5515

5516

The function checks user-configurable parameters that control the search

5517

strategy for an optimal plan, selects the search method and then invokes

5518

it. Each specific optimization procedure stores the final optimal plan in

5519

the array 'join->best_positions', and the cost of the plan in

5520

'join->best_read'.

5521

5522

@param join pointer to the structure providing all context info for

5523

the query

5524

@param join_tables set of the tables in the query

5525

5526

@todo

5527

'MAX_TABLES+2' denotes the old implementation of find_best before

5528

the greedy version. Will be removed when greedy_search is approved.

5529

5530

@retval

5531

false ok

5532

@retval

5533

true Fatal error

5534

5535

5536

static bool

5537

choose_plan(JOIN *join, table_map join_tables)

5538

{

5539

uint32_t search_depth= join->thd->variables.optimizer_search_depth;

5540

uint32_t prune_level= join->thd->variables.optimizer_prune_level;

5541

bool straight_join= test(join->select_options & SELECT_STRAIGHT_JOIN);

5542

5543

join->cur_embedding_map= 0;

5544

reset_nj_counters(join->join_list);

5545

5546

if (SELECT_STRAIGHT_JOIN option is set)

5547

reorder tables so dependent tables come after tables they depend

5548

on, otherwise keep tables in the order they were specified in the query

5549

else

5550

Apply heuristic: pre-sort all access plans with respect to the number of

5551

records accessed.

5552

5553

my_qsort(join->best_ref + join->const_tables,

5554

join->tables - join->const_tables, sizeof(JOIN_TAB*),

5555

straight_join ? join_tab_cmp_straight : join_tab_cmp);

5556

join->cur_emb_sj_nests= 0;

5557

if (straight_join)

5558

{

5559

optimize_straight_join(join, join_tables);

5560

}

5561

else

5562

{

5563

if (search_depth == MAX_TABLES+2)

5564

{ /*

5565

TODO: 'MAX_TABLES+2' denotes the old implementation of find_best before

5566

the greedy version. Will be removed when greedy_search is approved.

5567

5568

join->best_read= DBL_MAX;

5569

if (find_best(join, join_tables, join->const_tables, 1.0, 0.0))

5570

return(true);

5571

}

5572

else

5573

{

5574

if (search_depth == 0)

5575

/* Automatically determine a reasonable value for 'search_depth' */

5576

search_depth= determine_search_depth(join);

5577

if (greedy_search(join, join_tables, search_depth, prune_level))

5578

return(true);

5579

}

5580

}

5581

5582

5583

Store the cost of this query into a user variable

5584

Don't update last_query_cost for statements that are not "flat joins" :

5585

i.e. they have subqueries, unions or call stored procedures.

5586

TODO: calculate a correct cost for a query with subqueries and UNIONs.

5587

5588

if (join->thd->lex->is_single_level_stmt())

5589

join->thd->status_var.last_query_cost= join->best_read;

5590

return(false);

5591

}

5592

5593

5594

/**

5595

Compare two JOIN_TAB objects based on the number of accessed records.

5596

5597

@param ptr1 pointer to first JOIN_TAB object

5598

@param ptr2 pointer to second JOIN_TAB object

793

possible_keys&= cur_item->field->part_of_key;

794

}

795

796

if (possible_keys.any())

797

join_tab->const_keys|= possible_keys;

798

}

799

800

/**

801

Compare two JoinTable objects based on the number of accessed records.

802

803

@param ptr1 pointer to first JoinTable object

804

@param ptr2 pointer to second JoinTable object

5599

805

5600

806

NOTES

5601

807

The order relation implemented by join_tab_cmp() is not transitive,

5607

813

a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0

5608

814

b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838

5609

815

c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0

5610

816

5611

817

@retval

5612

818

1 if first is bigger

5613

819

@retval

5615

821

@retval

5616

822

0 if equal

5617

823

5618

5619

static int

5620

join_tab_cmp(const void* ptr1, const void* ptr2)

824

int join_tab_cmp(const void* ptr1, const void* ptr2)

5621

825

{

5622

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5623

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

826

JoinTable *jt1= *(JoinTable**) ptr1;

827

JoinTable *jt2= *(JoinTable**) ptr2;

5624

828

5625

829

if (jt1->dependent & jt2->table->map)

5626

830

return 1;

5627

831

if (jt2->dependent & jt1->table->map)

5628

return -1;

832

return -1;

5629

833

if (jt1->found_records > jt2->found_records)

5630

834

return 1;

5631

835

if (jt1->found_records < jt2->found_records)

5632

return -1;

836

return -1;

5633

837

return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);

5634

838

}

5635

839

5636

5637

840

/**

5638

841

Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.

5639

842

5640

5641

static int

5642

join_tab_cmp_straight(const void* ptr1, const void* ptr2)

843

int join_tab_cmp_straight(const void* ptr1, const void* ptr2)

5643

844

{

5644

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5645

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

845

JoinTable *jt1= *(JoinTable**) ptr1;

846

JoinTable *jt2= *(JoinTable**) ptr2;

5646

847

5647

848

if (jt1->dependent & jt2->table->map)

5648

849

return 1;

5652

853

}

5653

854

5654

855

/**

5655

Heuristic procedure to automatically guess a reasonable degree of

5656

exhaustiveness for the greedy search procedure.

5657

5658

The procedure estimates the optimization time and selects a search depth

5659

big enough to result in a near-optimal QEP, that doesn't take too long to

5660

find. If the number of tables in the query exceeds some constant, then

5661

search_depth is set to this constant.

5662

5663

@param join pointer to the structure providing all context info for

5664

the query

5665

5666

@note

5667

This is an extremely simplistic implementation that serves as a stub for a

5668

more advanced analysis of the join. Ideally the search depth should be

5669

determined by learning from previous query optimizations, because it will

5670

depend on the CPU power (and other factors).

5671

5672

@todo

5673

this value should be determined dynamically, based on statistics:

5674

uint32_t max_tables_for_exhaustive_opt= 7;

5675

5676

@todo

5677

this value could be determined by some mapping of the form:

5678

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5679

5680

@return

5681

A positive integer that specifies the search depth (and thus the

5682

exhaustiveness) of the depth-first search algorithm used by

5683

'greedy_search'.

5684

5685

5686

static uint

5687

determine_search_depth(JOIN *join)

5688

{

5689

uint32_t table_count= join->tables - join->const_tables;

5690

uint32_t search_depth;

5691

/* TODO: this value should be determined dynamically, based on statistics: */

5692

uint32_t max_tables_for_exhaustive_opt= 7;

5693

5694

if (table_count <= max_tables_for_exhaustive_opt)

5695

search_depth= table_count+1; // use exhaustive for small number of tables

5696

else

5697

5698

TODO: this value could be determined by some mapping of the form:

5699

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5700

5701

search_depth= max_tables_for_exhaustive_opt; // use greedy search

5702

5703

return search_depth;

5704

}

5705

5706

5707

/**

5708

Select the best ways to access the tables in a query without reordering them.

5709

5710

Find the best access paths for each query table and compute their costs

5711

according to their order in the array 'join->best_ref' (thus without

5712

reordering the join tables). The function calls sequentially

5713

'best_access_path' for each table in the query to select the best table

5714

access method. The final optimal plan is stored in the array

5715

'join->best_positions', and the corresponding cost in 'join->best_read'.

5716

5717

@param join pointer to the structure providing all context info for

5718

the query

5719

@param join_tables set of the tables in the query

5720

5721

@note

5722

This function can be applied to:

5723

- queries with STRAIGHT_JOIN

5724

- internally to compute the cost of an arbitrary QEP

5725

@par

5726

Thus 'optimize_straight_join' can be used at any stage of the query

5727

optimization process to finalize a QEP as it is.

5728

5729

5730

static void

5731

optimize_straight_join(JOIN *join, table_map join_tables)

5732

{

5733

JOIN_TAB *s;

5734

uint32_t idx= join->const_tables;

5735

double record_count= 1.0;

5736

double read_time= 0.0;

5737

5738

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

5739

{

5740

/* Find the best access method from 's' to the current partial plan */

5741

advance_sj_state(join_tables, s);

5742

best_access_path(join, s, join->thd, join_tables, idx,

5743

record_count, read_time);

5744

/* compute the cost of the new plan extended with 's' */

5745

record_count*= join->positions[idx].records_read;

5746

read_time+= join->positions[idx].read_time;

5747

join_tables&= ~(s->table->map);

5748

++idx;

5749

}

5750

5751

read_time+= record_count / (double) TIME_FOR_COMPARE;

5752

if (join->sort_by_table &&

5753

join->sort_by_table != join->positions[join->const_tables].table->table)

5754

read_time+= record_count; // We have to make a temp table

5755

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

5756

join->best_read= read_time;

5757

}

5758

5759

5760

/**

5761

Find a good, possibly optimal, query execution plan (QEP) by a greedy search.

5762

5763

The search procedure uses a hybrid greedy/exhaustive search with controlled

5764

exhaustiveness. The search is performed in N = card(remaining_tables)

5765

steps. Each step evaluates how promising is each of the unoptimized tables,

5766

selects the most promising table, and extends the current partial QEP with

5767

that table. Currenly the most 'promising' table is the one with least

5768

expensive extension.\

5769

5770

There are two extreme cases:

5771

-# When (card(remaining_tables) < search_depth), the estimate finds the

5772

best complete continuation of the partial QEP. This continuation can be

5773

used directly as a result of the search.

5774

-# When (search_depth == 1) the 'best_extension_by_limited_search'

5775

consideres the extension of the current QEP with each of the remaining

5776

unoptimized tables.

5777

5778

All other cases are in-between these two extremes. Thus the parameter

5779

'search_depth' controlls the exhaustiveness of the search. The higher the

5780

value, the longer the optimizaton time and possibly the better the

5781

resulting plan. The lower the value, the fewer alternative plans are

5782

estimated, but the more likely to get a bad QEP.

5783

5784

All intermediate and final results of the procedure are stored in 'join':

5785

- join->positions : modified for every partial QEP that is explored

5786

- join->best_positions: modified for the current best complete QEP

5787

- join->best_read : modified for the current best complete QEP

5788

- join->best_ref : might be partially reordered

5789

5790

The final optimal plan is stored in 'join->best_positions', and its

5791

corresponding cost in 'join->best_read'.

5792

5793

@note

5794

The following pseudocode describes the algorithm of 'greedy_search':

5795

5796

@code

5797

procedure greedy_search

5798

input: remaining_tables

5799

output: pplan;

5800

{

5801

pplan = <>;

5802

do {

5803

(t, a) = best_extension(pplan, remaining_tables);

5804

pplan = concat(pplan, (t, a));

5805

remaining_tables = remaining_tables - t;

5806

} while (remaining_tables != {})

5807

return pplan;

5808

}

5809

5810

@endcode

5811

where 'best_extension' is a placeholder for a procedure that selects the

5812

most "promising" of all tables in 'remaining_tables'.

5813

Currently this estimate is performed by calling

5814

'best_extension_by_limited_search' to evaluate all extensions of the

5815

current QEP of size 'search_depth', thus the complexity of 'greedy_search'

5816

mainly depends on that of 'best_extension_by_limited_search'.

5817

5818

@par

5819

If 'best_extension()' == 'best_extension_by_limited_search()', then the

5820

worst-case complexity of this algorithm is <=

5821

O(N*N^search_depth/search_depth). When serch_depth >= N, then the

5822

complexity of greedy_search is O(N!).

5823

5824

@par

5825

In the future, 'greedy_search' might be extended to support other

5826

implementations of 'best_extension', e.g. some simpler quadratic procedure.

5827

5828

@param join pointer to the structure providing all context info

5829

for the query

5830

@param remaining_tables set of tables not included into the partial plan yet

5831

@param search_depth controlls the exhaustiveness of the search

5832

@param prune_level the pruning heuristics that should be applied during

5833

5834

5835

@retval

5836

false ok

5837

@retval

5838

true Fatal error

5839

5840

5841

static bool

5842

greedy_search(JOIN *join,

5843

table_map remaining_tables,

5844

uint32_t search_depth,

5845

uint32_t prune_level)

5846

{

5847

double record_count= 1.0;

5848

double read_time= 0.0;

5849

uint32_t idx= join->const_tables; // index into 'join->best_ref'

5850

uint32_t best_idx;

5851

uint32_t size_remain; // cardinality of remaining_tables

5852

POSITION best_pos;

5853

JOIN_TAB *best_table; // the next plan node to be added to the curr QEP

5854

5855

/* number of tables that remain to be optimized */

5856

size_remain= my_count_bits(remaining_tables);

5857

5858

do {

5859

/* Find the extension of the current QEP with the lowest cost */

5860

join->best_read= DBL_MAX;

5861

if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,

5862

read_time, search_depth, prune_level))

5863

return(true);

5864

5865

if (size_remain <= search_depth)

5866

{

5867

5868

'join->best_positions' contains a complete optimal extension of the

5869

current partial QEP.

5870

5871

return(false);

5872

}

5873

5874

/* select the first table in the optimal extension as most promising */

5875

best_pos= join->best_positions[idx];

5876

best_table= best_pos.table;

5877

5878

Each subsequent loop of 'best_extension_by_limited_search' uses

5879

'join->positions' for cost estimates, therefore we have to update its

5880

value.

5881

5882

join->positions[idx]= best_pos;

5883

5884

/* find the position of 'best_table' in 'join->best_ref' */

5885

best_idx= idx;

5886

JOIN_TAB *pos= join->best_ref[best_idx];

5887

while (pos && best_table != pos)

5888

pos= join->best_ref[++best_idx];

5889

assert((pos != NULL)); // should always find 'best_table'

5890

/* move 'best_table' at the first free position in the array of joins */

5891

std::swap(join->best_ref[idx], join->best_ref[best_idx]);

5892

5893

/* compute the cost of the new plan extended with 'best_table' */

5894

record_count*= join->positions[idx].records_read;

5895

read_time+= join->positions[idx].read_time;

5896

5897

remaining_tables&= ~(best_table->table->map);

5898

--size_remain;

5899

++idx;

5900

} while (true);

5901

}

5902

5903

5904

/**

5905

Find a good, possibly optimal, query execution plan (QEP) by a possibly

5906

exhaustive search.

5907

5908

The procedure searches for the optimal ordering of the query tables in set

5909

'remaining_tables' of size N, and the corresponding optimal access paths to

5910

each table. The choice of a table order and an access path for each table

5911

constitutes a query execution plan (QEP) that fully specifies how to

5912

execute the query.

5913

5914

The maximal size of the found plan is controlled by the parameter

5915

'search_depth'. When search_depth == N, the resulting plan is complete and

5916

can be used directly as a QEP. If search_depth < N, the found plan consists

5917

of only some of the query tables. Such "partial" optimal plans are useful

5918

only as input to query optimization procedures, and cannot be used directly

5919

to execute a query.

5920

5921

The algorithm begins with an empty partial plan stored in 'join->positions'

5922

and a set of N tables - 'remaining_tables'. Each step of the algorithm

5923

evaluates the cost of the partial plan extended by all access plans for

5924

each of the relations in 'remaining_tables', expands the current partial

5925

plan with the access plan that results in lowest cost of the expanded

5926

partial plan, and removes the corresponding relation from

5927

'remaining_tables'. The algorithm continues until it either constructs a

5928

complete optimal plan, or constructs an optimal plartial plan with size =

5929

search_depth.

5930

5931

The final optimal plan is stored in 'join->best_positions'. The

5932

corresponding cost of the optimal plan is in 'join->best_read'.

5933

5934

@note

5935

The procedure uses a recursive depth-first search where the depth of the

5936

recursion (and thus the exhaustiveness of the search) is controlled by the

5937

parameter 'search_depth'.

5938

5939

@note

5940

The pseudocode below describes the algorithm of

5941

'best_extension_by_limited_search'. The worst-case complexity of this

5942

algorithm is O(N*N^search_depth/search_depth). When serch_depth >= N, then

5943

the complexity of greedy_search is O(N!).

5944

5945

@code

5946

procedure best_extension_by_limited_search(

5947

pplan in, // in, partial plan of tables-joined-so-far

5948

pplan_cost, // in, cost of pplan

5949

remaining_tables, // in, set of tables not referenced in pplan

5950

best_plan_so_far, // in/out, best plan found so far

5951

best_plan_so_far_cost,// in/out, cost of best_plan_so_far

5952

search_depth) // in, maximum size of the plans being considered

5953

{

5954

for each table T from remaining_tables

5955

{

5956

// Calculate the cost of using table T as above

5957

cost = complex-series-of-calculations;

5958

5959

// Add the cost to the cost so far.

5960

pplan_cost+= cost;

5961

5962

if (pplan_cost >= best_plan_so_far_cost)

5963

// pplan_cost already too great, stop search

5964

continue;

5965

5966

pplan= expand pplan by best_access_method;

5967

remaining_tables= remaining_tables - table T;

5968

if (remaining_tables is not an empty set

5969

and

5970

search_depth > 1)

5971

{

5972

best_extension_by_limited_search(pplan, pplan_cost,

5973

remaining_tables,

5974

best_plan_so_far,

5975

best_plan_so_far_cost,

5976

search_depth - 1);

5977

}

5978

else

5979

{

5980

best_plan_so_far_cost= pplan_cost;

5981

best_plan_so_far= pplan;

5982

}

5983

}

5984

}

5985

@endcode

5986

5987

@note

5988

When 'best_extension_by_limited_search' is called for the first time,

5989

'join->best_read' must be set to the largest possible value (e.g. DBL_MAX).

5990

The actual implementation provides a way to optionally use pruning

5991

heuristic (controlled by the parameter 'prune_level') to reduce the search

5992

space by skipping some partial plans.

5993

5994

@note

5995

The parameter 'search_depth' provides control over the recursion

5996

depth, and thus the size of the resulting optimal plan.

5997

5998

@param join pointer to the structure providing all context info

5999

for the query

6000

@param remaining_tables set of tables not included into the partial plan yet

6001

@param idx length of the partial QEP in 'join->positions';

6002

since a depth-first search is used, also corresponds

6003

to the current depth of the search tree;

6004

also an index in the array 'join->best_ref';

6005

@param record_count estimate for the number of records returned by the

6006

best partial plan

6007

@param read_time the cost of the best partial plan

6008

@param search_depth maximum depth of the recursion and thus size of the

6009

found optimal plan

6010

(0 < search_depth <= join->tables+1).

6011

@param prune_level pruning heuristics that should be applied during

6012

optimization

6013

(values: 0 = EXHAUSTIVE, 1 = PRUNE_BY_TIME_OR_ROWS)

6014

6015

@retval

6016

false ok

6017

@retval

6018

true Fatal error

6019

6020

6021

static bool

6022

best_extension_by_limited_search(JOIN *join,

6023

table_map remaining_tables,

6024

uint32_t idx,

6025

double record_count,

6026

double read_time,

6027

uint32_t search_depth,

6028

uint32_t prune_level)

6029

{

6030

THD *thd= join->thd;

6031

if (thd->killed) // Abort

6032

return(true);

6033

6034

6035

'join' is a partial plan with lower cost than the best plan so far,

6036

so continue expanding it further with the tables in 'remaining_tables'.

6037

6038

JOIN_TAB *s;

6039

double best_record_count= DBL_MAX;

6040

double best_read_time= DBL_MAX;

6041

6042

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

6043

{

6044

table_map real_table_bit= s->table->map;

6045

if ((remaining_tables & real_table_bit) &&

6046

!(remaining_tables & s->dependent) &&

6047

(!idx || !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6048

{

6049

double current_record_count, current_read_time;

6050

advance_sj_state(remaining_tables, s);

6051

6052

6053

psergey-insideout-todo:

6054

when best_access_path() detects it could do an InsideOut scan or

6055

some other scan, have it return an insideout scan and a flag that

6056

requests to "fork" this loop iteration. (Q: how does that behave

6057

when the depth is insufficient??)

6058

6059

/* Find the best access method from 's' to the current partial plan */

6060

best_access_path(join, s, thd, remaining_tables, idx,

6061

record_count, read_time);

6062

/* Compute the cost of extending the plan with 's' */

6063

current_record_count= record_count * join->positions[idx].records_read;

6064

current_read_time= read_time + join->positions[idx].read_time;

6065

6066

/* Expand only partial plans with lower cost than the best QEP so far */

6067

if ((current_read_time +

6068

current_record_count / (double) TIME_FOR_COMPARE) >= join->best_read)

6069

{

6070

restore_prev_nj_state(s);

6071

restore_prev_sj_state(remaining_tables, s);

6072

continue;

6073

}

6074

6075

6076

Prune some less promising partial plans. This heuristic may miss

6077

the optimal QEPs, thus it results in a non-exhaustive search.

6078

6079

if (prune_level == 1)

6080

{

6081

if (best_record_count > current_record_count ||

6082

best_read_time > current_read_time ||

6083

(idx == join->const_tables && s->table == join->sort_by_table)) // 's' is the first table in the QEP

6084

{

6085

if (best_record_count >= current_record_count &&

6086

best_read_time >= current_read_time &&

6087

/* TODO: What is the reasoning behind this condition? */

6088

(!(s->key_dependent & remaining_tables) ||

6089

join->positions[idx].records_read < 2.0))

6090

{

6091

best_record_count= current_record_count;

6092

best_read_time= current_read_time;

6093

}

6094

}

6095

else

6096

{

6097

restore_prev_nj_state(s);

6098

restore_prev_sj_state(remaining_tables, s);

6099

continue;

6100

}

6101

}

6102

6103

if ( (search_depth > 1) && (remaining_tables & ~real_table_bit) )

6104

{ /* Recursively expand the current partial plan */

6105

std::swap(join->best_ref[idx], *pos);

6106

if (best_extension_by_limited_search(join,

6107

remaining_tables & ~real_table_bit,

6108

idx + 1,

6109

current_record_count,

6110

current_read_time,

6111

search_depth - 1,

6112

prune_level))

6113

return(true);

6114

std::swap(join->best_ref[idx], *pos);

6115

}

6116

else

6117

{ /*

6118

'join' is either the best partial QEP with 'search_depth' relations,

6119

or the best complete QEP so far, whichever is smaller.

6120

6121

current_read_time+= current_record_count / (double) TIME_FOR_COMPARE;

6122

if (join->sort_by_table &&

6123

join->sort_by_table !=

6124

join->positions[join->const_tables].table->table)

6125

/* We have to make a temp table */

6126

current_read_time+= current_record_count;

6127

if ((search_depth == 1) || (current_read_time < join->best_read))

6128

{

6129

memcpy(join->best_positions, join->positions,

6130

sizeof(POSITION) * (idx + 1));

6131

join->best_read= current_read_time - 0.001;

6132

}

6133

}

6134

restore_prev_nj_state(s);

6135

restore_prev_sj_state(remaining_tables, s);

6136

}

6137

}

6138

return(false);

6139

}

6140

6141

6142

/**

6143

@todo

6144

- TODO: this function is here only temporarily until 'greedy_search' is

6145

tested and accepted.

6146

6147

RETURN VALUES

6148

false ok

6149

true Fatal error

6150

6151

static bool

6152

find_best(JOIN *join,table_map rest_tables,uint32_t idx,double record_count,

6153

double read_time)

6154

{

6155

THD *thd= join->thd;

6156

if (thd->killed)

6157

return(true);

6158

if (!rest_tables)

6159

{

6160

read_time+=record_count/(double) TIME_FOR_COMPARE;

6161

if (join->sort_by_table &&

6162

join->sort_by_table !=

6163

join->positions[join->const_tables].table->table)

6164

read_time+=record_count; // We have to make a temp table

6165

if (read_time < join->best_read)

6166

{

6167

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

6168

join->best_read= read_time - 0.001;

6169

}

6170

return(false);

6171

}

6172

if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)

6173

return(false); /* Found better before */

6174

6175

JOIN_TAB *s;

6176

double best_record_count=DBL_MAX,best_read_time=DBL_MAX;

6177

for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)

6178

{

6179

table_map real_table_bit=s->table->map;

6180

if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent) &&

6181

(!idx|| !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6182

{

6183

double records, best;

6184

advance_sj_state(rest_tables, s);

6185

best_access_path(join, s, thd, rest_tables, idx, record_count,

6186

read_time);

6187

records= join->positions[idx].records_read;

6188

best= join->positions[idx].read_time;

6189

6190

Go to the next level only if there hasn't been a better key on

6191

this level! This will cut down the search for a lot simple cases!

6192

6193

double current_record_count=record_count*records;

6194

double current_read_time=read_time+best;

6195

if (best_record_count > current_record_count ||

6196

best_read_time > current_read_time ||

6197

(idx == join->const_tables && s->table == join->sort_by_table))

6198

{

6199

if (best_record_count >= current_record_count &&

6200

best_read_time >= current_read_time &&

6201

(!(s->key_dependent & rest_tables) || records < 2.0))

6202

{

6203

best_record_count=current_record_count;

6204

best_read_time=current_read_time;

6205

}

6206

std::swap(join->best_ref[idx], *pos);

6207

if (find_best(join,rest_tables & ~real_table_bit,idx+1,

6208

current_record_count,current_read_time))

6209

return(true);

6210

std::swap(join->best_ref[idx], *pos);

6211

}

6212

restore_prev_nj_state(s);

6213

restore_prev_sj_state(rest_tables, s);

6214

if (join->select_options & SELECT_STRAIGHT_JOIN)

6215

break; // Don't test all combinations

6216

}

6217

}

6218

return(false);

6219

}

6220

6221

6222

/**

6223

856

Find how much space the prevous read not const tables takes in cache.

6224

857

6225

6226

static void calc_used_field_length(THD *thd __attribute__((unused)),

6227

JOIN_TAB *join_tab)

858

void calc_used_field_length(Session *, JoinTable *join_tab)

6228

859

{

6229

860

uint32_t null_fields,blobs,fields,rec_length;

6230

861

Field **f_ptr,*field;

6231

MY_BITMAP *read_set= join_tab->table->read_set;;

6232

862

6233

863

null_fields= blobs= fields= rec_length=0;

6234

864

for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)

6235

865

{

6236

if (bitmap_is_set(read_set, field->field_index))

866

if (field->isReadSet())

6237

867

{

6238

868

uint32_t flags=field->flags;

6239

869

fields++;

6240

870

rec_length+=field->pack_length();

6241

871

if (flags & BLOB_FLAG)

6242

blobs++;

872

blobs++;

6243

873

if (!(flags & NOT_NULL_FLAG))

6244

null_fields++;

874

null_fields++;

6245

875

}

6246

876

}

6247

877

if (null_fields)

6250

880

rec_length+=sizeof(bool);

6251

881

if (blobs)

6252

882

{

6253

uint32_t blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-

6254

(join_tab->table->getRecordLength()- rec_length));

6255

rec_length+=(uint) cmax((uint)4,blob_length);

6256

}

6257

join_tab->used_fields=fields;

6258

join_tab->used_fieldlength=rec_length;

6259

join_tab->used_blobs=blobs;

6260

}

6261

6262

6263

static uint

6264

cache_record_length(JOIN *join,uint32_t idx)

6265

{

6266

uint32_t length=0;

6267

JOIN_TAB **pos,**end;

6268

THD *thd=join->thd;

6269

6270

for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;

6271

pos != end ;

6272

pos++)

6273

{

6274

JOIN_TAB *join_tab= *pos;

6275

if (!join_tab->used_fieldlength) /* Not calced yet */

6276

calc_used_field_length(thd, join_tab);

6277

length+=join_tab->used_fieldlength;

6278

}

6279

return length;

6280

}

6281

6282

6283

6284

Get the number of different row combinations for subset of partial join

6285

6286

SYNOPSIS

6287

prev_record_reads()

6288

join The join structure

6289

idx Number of tables in the partial join order (i.e. the

6290

partial join order is in join->positions[0..idx-1])

6291

found_ref Bitmap of tables for which we need to find # of distinct

6292

row combinations.

6293

6294

DESCRIPTION

6295

Given a partial join order (in join->positions[0..idx-1]) and a subset of

6296

tables within that join order (specified in found_ref), find out how many

6297

distinct row combinations of subset tables will be in the result of the

6298

partial join order.

6299

6300

This is used as follows: Suppose we have a table accessed with a ref-based

6301

method. The ref access depends on current rows of tables in found_ref.

6302

We want to count # of different ref accesses. We assume two ref accesses

6303

will be different if at least one of access parameters is different.

6304

Example: consider a query

6305

6306

SELECT * FROM t1, t2, t3 WHERE t1.key=c1 AND t2.key=c2 AND t3.key=t1.field

6307

6308

and a join order:

6309

t1, ref access on t1.key=c1

6310

t2, ref access on t2.key=c2

6311

t3, ref access on t3.key=t1.field

6312

6313

For t1: n_ref_scans = 1, n_distinct_ref_scans = 1

6314

For t2: n_ref_scans = records_read(t1), n_distinct_ref_scans=1

6315

For t3: n_ref_scans = records_read(t1)*records_read(t2)

6316

n_distinct_ref_scans = #records_read(t1)

6317

6318

The reason for having this function (at least the latest version of it)

6319

is that we need to account for buffering in join execution.

6320

6321

An edge-case example: if we have a non-first table in join accessed via

6322

ref(const) or ref(param) where there is a small number of different

6323

values of param, then the access will likely hit the disk cache and will

6324

not require any disk seeks.

6325

6326

The proper solution would be to assume an LRU disk cache of some size,

6327

calculate probability of cache hits, etc. For now we just count

6328

identical ref accesses as one.

6329

6330

RETURN

6331

Expected number of row combinations

6332

6333

6334

static double

6335

prev_record_reads(JOIN *join, uint32_t idx, table_map found_ref)

6336

{

6337

double found=1.0;

6338

POSITION *pos_end= join->positions - 1;

6339

for (POSITION *pos= join->positions + idx - 1; pos != pos_end; pos--)

6340

{

6341

if (pos->table->table->map & found_ref)

6342

{

6343

found_ref|= pos->ref_depend_map;

6344

6345

For the case of "t1 LEFT JOIN t2 ON ..." where t2 is a const table

6346

with no matching row we will get position[t2].records_read==0.

6347

Actually the size of output is one null-complemented row, therefore

6348

we will use value of 1 whenever we get records_read==0.

6349

6350

Note

6351

- the above case can't occur if inner part of outer join has more

6352

than one table: table with no matches will not be marked as const.

6353

6354

- Ideally we should add 1 to records_read for every possible null-

6355

complemented row. We're not doing it because: 1. it will require

6356

non-trivial code and add overhead. 2. The value of records_read

6357

is an inprecise estimate and adding 1 (or, in the worst case,

6358

#max_nested_outer_joins=64-1) will not make it any more precise.

6359

6360

if (pos->records_read > DBL_EPSILON)

6361

found*= pos->records_read;

6362

}

6363

}

6364

return found;

6365

}

6366

883

uint32_t blob_length=(uint32_t) (join_tab->table->file->stats.mean_rec_length-

884

(join_tab->table->getRecordLength()- rec_length));

885

rec_length+= max((uint32_t)4,blob_length);

886

}

887

join_tab->used_fields= fields;

888

join_tab->used_fieldlength= rec_length;

889

join_tab->used_blobs= blobs;

890

}

891

892

StoredKey *get_store_key(Session *session,

893

optimizer::KeyUse *keyuse,

894

table_map used_tables,

895

KEY_PART_INFO *key_part,

896

unsigned char *key_buff,

897

uint32_t maybe_null)

898

{

899

Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());

900

Item_ref **dir_val= reinterpret_cast<Item_ref **>(key_use_val->ref);

901

if (! ((~used_tables) & keyuse->getUsedTables())) // if const item

902

{

903

return new store_key_const_item(session,

904

key_part->field,

905

key_buff + maybe_null,

906

maybe_null ? key_buff : 0,

907

key_part->length,

908

key_use_val);

909

}

910

else if (key_use_val->type() == Item::FIELD_ITEM ||

911

(key_use_val->type() == Item::REF_ITEM &&

912

key_use_val->ref_type() == Item_ref::OUTER_REF &&

913

(*dir_val)->ref_type() == Item_ref::DIRECT_REF &&

914

key_use_val->real_item()->type() == Item::FIELD_ITEM))

915

{

916

return new store_key_field(session,

917

key_part->field,

918

key_buff + maybe_null,

919

maybe_null ? key_buff : 0,

920

key_part->length,

921

((Item_field*) key_use_val->real_item())->field,

922

key_use_val->full_name());

923

}

924

return new store_key_item(session,

925

key_part->field,

926

key_buff + maybe_null,

927

maybe_null ? key_buff : 0,

928

key_part->length,

929

key_use_val);

930

}

6367

931

6368

932

/**

6369

Set up join struct according to best position.

933

This function is only called for const items on fields which are keys.

934

935

@return

936

returns 1 if there was some conversion made when the field was stored.

6370

937

6371

6372

static bool

6373

get_best_combination(JOIN *join)

6374

{

6375

uint32_t i,tablenr;

6376

table_map used_tables;

6377

JOIN_TAB *join_tab,*j;

6378

KEYUSE *keyuse;

6379

uint32_t table_count;

6380

THD *thd=join->thd;

6381

6382

table_count=join->tables;

6383

if (!(join->join_tab=join_tab=

6384

(JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))

6385

return(true);

6386

6387

join->full_join=0;

6388

6389

used_tables= OUTER_REF_TABLE_BIT; // Outer row is already read

6390

for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)

938

bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

939

{

940

bool error;

941

Table *table= field->table;

942

Session *session= table->in_use;

943

ha_rows cuted_fields=session->cuted_fields;

944

945

946

we should restore old value of count_cuted_fields because

947

store_val_in_field can be called from mysql_insert

948

with select_insert, which make count_cuted_fields= 1

949

950

enum_check_fields old_count_cuted_fields= session->count_cuted_fields;

951

session->count_cuted_fields= check_flag;

952

error= item->save_in_field(field, 1);

953

session->count_cuted_fields= old_count_cuted_fields;

954

return error || cuted_fields != session->cuted_fields;

955

}

956

957

inline void add_cond_and_fix(Item **e1, Item *e2)

958

{

959

if (*e1)

6391

960

{

6392

Table *form;

6393

*j= *join->best_positions[tablenr].table;

6394

form=join->table[tablenr]=j->table;

6395

used_tables|= form->map;

6396

form->reginfo.join_tab=j;

6397

if (!*j->on_expr_ref)

6398

form->reginfo.not_exists_optimize=0; // Only with LEFT JOIN

6399

if (j->type == JT_CONST)

6400

continue; // Handled in make_join_stat..

6401

6402

j->ref.key = -1;

6403

j->ref.key_parts=0;

6404

6405

if (j->type == JT_SYSTEM)

6406

continue;

6407

if (j->keys.is_clear_all() || !(keyuse= join->best_positions[tablenr].key))

961

Item *res;

962

if ((res= new Item_cond_and(*e1, e2)))

6408

963

{

6409

j->type=JT_ALL;

6410

if (tablenr != join->const_tables)

6411

join->full_join=1;

964

*e1= res;

965

res->quick_fix_field();

6412

966

}

6413

else if (create_ref_for_key(join, j, keyuse, used_tables))

6414

return(true); // Something went wrong

6415

967

}

6416

6417

for (i=0 ; i < table_count ; i++)

6418

join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;

6419

update_depend_map(join);

6420

return(0);

968

else

969

*e1= e2;

6421

970

}

6422

971

6423

6424

static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,

6425

table_map used_tables)

972

bool create_ref_for_key(JOIN *join,

973

JoinTable *j,

974

optimizer::KeyUse *org_keyuse,

975

table_map used_tables)

6426

976

{

6427

KEYUSE *keyuse=org_keyuse;

6428

THD *thd= join->thd;

6429

uint32_t keyparts,length,key;

6430

Table *table;

6431

KEY *keyinfo;

977

optimizer::KeyUse *keyuse= org_keyuse;

978

Session *session= join->session;

979

uint32_t keyparts;

980

uint32_t length;

981

uint32_t key;

982

Table *table= NULL;

983

KEY *keyinfo= NULL;

6432

984

6433

985

/* Use best key from find_best */

6434

table=j->table;

6435

key=keyuse->key;

6436

keyinfo=table->key_info+key;

986

table= j->table;

987

key= keyuse->getKey();

988

keyinfo= table->key_info + key;

6437

989

6438

990

{

6439

keyparts=length=0;

991

keyparts= length= 0;

6440

992

uint32_t found_part_ref_or_null= 0;

6441

993

6442

994

Calculate length for the used key

6445

997

6446

998

6447

999

{

6448

if (!(~used_tables & keyuse->used_tables))

1000

if (! (~used_tables & keyuse->getUsedTables()))

6449

1001

{

6450

if (keyparts == keyuse->keypart &&

6451

!(found_part_ref_or_null & keyuse->optimize))

6452

{

6453

keyparts++;

6454

length+= keyinfo->key_part[keyuse->keypart].store_length;

6455

found_part_ref_or_null|= keyuse->optimize;

6456

}

1002

if (keyparts == keyuse->getKeypart() &&

1003

! (found_part_ref_or_null & keyuse->getOptimizeFlags()))

1004

{

1005

keyparts++;

1006

length+= keyinfo->key_part[keyuse->getKeypart()].store_length;

1007

found_part_ref_or_null|= keyuse->getOptimizeFlags();

1008

}

6457

1009

}

6458

1010

keyuse++;

6459

} while (keyuse->table == table && keyuse->key == key);

1011

} while (keyuse->getTable() == table && keyuse->getKey() == key);

6460

1012

}

6461

1013

6462

1014

/* set up fieldref */

6464

1016

j->ref.key_parts=keyparts;

6465

1017

j->ref.key_length=length;

6466

1018

j->ref.key=(int) key;

6467

if (!(j->ref.key_buff= (unsigned char*) thd->calloc(ALIGN_SIZE(length)*2)) ||

6468

!(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *

6469

(keyparts+1)))) ||

6470

!(j->ref.items= (Item**) thd->alloc(sizeof(Item*)*keyparts)) ||

6471

!(j->ref.cond_guards= (bool**) thd->alloc(sizeof(uint*)*keyparts)))

1019

if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

1020

!(j->ref.key_copy= (StoredKey**) session->alloc((sizeof(StoredKey*) *

1021

(keyparts+1)))) ||

1022

!(j->ref.items= (Item**) session->alloc(sizeof(Item*)*keyparts)) ||

1023

!(j->ref.cond_guards= (bool**) session->alloc(sizeof(uint*)*keyparts)))

6472

1024

{

6473

1025

return(true);

6474

1026

}

6478

1030

j->ref.disable_cache= false;

6479

1031

keyuse=org_keyuse;

6480

1032

6481

store_key **ref_key= j->ref.key_copy;

6482

unsigned char *key_buff=j->ref.key_buff, *null_ref_key= 0;

1033

StoredKey **ref_key= j->ref.key_copy;

1034

unsigned char *key_buff= j->ref.key_buff, *null_ref_key= 0;

6483

1035

bool keyuse_uses_no_tables= true;

6484

1036

{

6485

uint32_t i;

6486

for (i=0 ; i < keyparts ; keyuse++,i++)

1037

for (uint32_t i= 0; i < keyparts; keyuse++, i++)

6487

1038

{

6488

while (keyuse->keypart != i ||

6489

((~used_tables) & keyuse->used_tables))

6490

keyuse++; /* Skip other parts */

1039

while (keyuse->getKeypart() != i ||

1040

((~used_tables) & keyuse->getUsedTables()))

1041

keyuse++; /* Skip other parts */

6491

1042

6492

1043

uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);

6493

j->ref.items[i]=keyuse->val; // Save for cond removal

6494

j->ref.cond_guards[i]= keyuse->cond_guard;

6495

if (keyuse->null_rejecting)

1044

j->ref.items[i]= keyuse->getVal(); // Save for cond removal

1045

j->ref.cond_guards[i]= keyuse->getConditionalGuard();

1046

if (keyuse->isNullRejected())

6496

1047

j->ref.null_rejecting |= 1 << i;

6497

keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;

6498

if (!keyuse->used_tables &&

6499

!(join->select_options & SELECT_DESCRIBE))

6500

{ // Compare against constant

6501

store_key_item tmp(thd, keyinfo->key_part[i].field,

1048

keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();

1049

if (! keyuse->getUsedTables() && !(join->select_options & SELECT_DESCRIBE))

1050

{ // Compare against constant

1051

store_key_item tmp(session, keyinfo->key_part[i].field,

6502

1052

key_buff + maybe_null,

6503

1053

maybe_null ? key_buff : 0,

6504

keyinfo->key_part[i].length, keyuse->val);

6505

if (thd->is_fatal_error)

6506

return(true);

6507

tmp.copy();

1054

keyinfo->key_part[i].length, keyuse->getVal());

1055

if (session->is_fatal_error)

1056

return(true);

1057

tmp.copy();

6508

1058

}

6509

1059

else

6510

*ref_key++= get_store_key(thd,

6511

keyuse,join->const_table_map,

6512

&keyinfo->key_part[i],

6513

key_buff, maybe_null);

1060

*ref_key++= get_store_key(session,

1061

keyuse,join->const_table_map,

1062

&keyinfo->key_part[i],

1063

key_buff, maybe_null);

6514

1064

6515

Remember if we are going to use REF_OR_NULL

6516

But only if field _really_ can be null i.e. we force JT_REF

6517

instead of JT_REF_OR_NULL in case if field can't be null

1065

Remember if we are going to use REF_OR_NULL

1066

But only if field _really_ can be null i.e. we force AM_REF

1067

instead of AM_REF_OR_NULL in case if field can't be null

6518

1068

6519

if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

6520

null_ref_key= key_buff;

1069

if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

1070

null_ref_key= key_buff;

6521

1071

key_buff+=keyinfo->key_part[i].store_length;

6522

1072

}

6523

1073

}

6524

*ref_key=0; // end_marker

6525

if (j->type == JT_CONST)

1074

*ref_key= 0; // end_marker

1075

if (j->type == AM_CONST)

6526

1076

j->table->const_table= 1;

6527

1077

else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||

6528

1078

keyparts != keyinfo->key_parts || null_ref_key)

6529

1079

{

6530

1080

/* Must read with repeat */

6531

j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;

1081

j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;

6532

1082

j->ref.null_ref_key= null_ref_key;

6533

1083

}

6534

1084

else if (keyuse_uses_no_tables)

6540

1090

Here we should not mark the table as a 'const' as a field may

6541

1091

have a 'normal' value or a NULL value.

6542

1092

6543

j->type=JT_CONST;

6544

}

6545

else

6546

j->type=JT_EQ_REF;

6547

return(0);

6548

}

6549

6550

6551

6552

static store_key *

6553

get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,

6554

KEY_PART_INFO *key_part, unsigned char *key_buff, uint32_t maybe_null)

6555

{

6556

if (!((~used_tables) & keyuse->used_tables)) // if const item

6557

{

6558

return new store_key_const_item(thd,

6559

key_part->field,

6560

key_buff + maybe_null,

6561

maybe_null ? key_buff : 0,

6562

key_part->length,

6563

keyuse->val);

6564

}

6565

else if (keyuse->val->type() == Item::FIELD_ITEM ||

6566

(keyuse->val->type() == Item::REF_ITEM &&

6567

((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&

6568

(*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==

6569

Item_ref::DIRECT_REF &&

6570

keyuse->val->real_item()->type() == Item::FIELD_ITEM))

6571

return new store_key_field(thd,

6572

key_part->field,

6573

key_buff + maybe_null,

6574

maybe_null ? key_buff : 0,

6575

key_part->length,

6576

((Item_field*) keyuse->val->real_item())->field,

6577

keyuse->val->full_name());

6578

return new store_key_item(thd,

6579

key_part->field,

6580

key_buff + maybe_null,

6581

maybe_null ? key_buff : 0,

6582

key_part->length,

6583

keyuse->val);

6584

}

6585

6586

/**

6587

This function is only called for const items on fields which are keys.

6588

6589

@return

6590

returns 1 if there was some conversion made when the field was stored.

6591

6592

6593

bool

6594

store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

6595

{

6596

bool error;

6597

Table *table= field->table;

6598

THD *thd= table->in_use;

6599

ha_rows cuted_fields=thd->cuted_fields;

6600

6601

6602

we should restore old value of count_cuted_fields because

6603

store_val_in_field can be called from mysql_insert

6604

with select_insert, which make count_cuted_fields= 1

6605

6606

enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;

6607

thd->count_cuted_fields= check_flag;

6608

error= item->save_in_field(field, 1);

6609

thd->count_cuted_fields= old_count_cuted_fields;

6610

return error || cuted_fields != thd->cuted_fields;

6611

}

6612

6613

6614

static bool

6615

make_simple_join(JOIN *join,Table *tmp_table)

6616

{

6617

Table **tableptr;

6618

JOIN_TAB *join_tab;

6619

6620

6621

Reuse Table * and JOIN_TAB if already allocated by a previous call

6622

to this function through JOIN::exec (may happen for sub-queries).

6623

6624

if (!join->table_reexec)

6625

{

6626

if (!(join->table_reexec= (Table**) join->thd->alloc(sizeof(Table*))))

6627

return(true); /* purecov: inspected */

6628

if (join->tmp_join)

6629

join->tmp_join->table_reexec= join->table_reexec;

6630

}

6631

if (!join->join_tab_reexec)

6632

{

6633

if (!(join->join_tab_reexec=

6634

(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))

6635

return(true); /* purecov: inspected */

6636

if (join->tmp_join)

6637

join->tmp_join->join_tab_reexec= join->join_tab_reexec;

6638

}

6639

tableptr= join->table_reexec;

6640

join_tab= join->join_tab_reexec;

6641

6642

join->join_tab=join_tab;

6643

join->table=tableptr; tableptr[0]=tmp_table;

6644

join->tables=1;

6645

join->const_tables=0;

6646

join->const_table_map=0;

6647

join->tmp_table_param.field_count= join->tmp_table_param.sum_func_count=

6648

join->tmp_table_param.func_count=0;

6649

join->tmp_table_param.copy_field=join->tmp_table_param.copy_field_end=0;

6650

join->first_record=join->sort_and_group=0;

6651

join->send_records=(ha_rows) 0;

6652

join->group=0;

6653

join->row_limit=join->unit->select_limit_cnt;

6654

join->do_send_rows = (join->row_limit) ? 1 : 0;

6655

6656

join_tab->cache.buff=0; /* No caching */

6657

join_tab->table=tmp_table;

6658

join_tab->select=0;

6659

join_tab->select_cond=0;

6660

join_tab->quick=0;

6661

join_tab->type= JT_ALL; /* Map through all records */

6662

join_tab->keys.init();

6663

join_tab->keys.set_all(); /* test everything in quick */

6664

join_tab->info=0;

6665

join_tab->on_expr_ref=0;

6666

join_tab->last_inner= 0;

6667

join_tab->first_unmatched= 0;

6668

join_tab->ref.key = -1;

6669

join_tab->not_used_in_distinct=0;

6670

join_tab->read_first_record= join_init_read_record;

6671

join_tab->join=join;

6672

join_tab->ref.key_parts= 0;

6673

join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;

6674

join_tab->do_firstmatch= NULL;

6675

memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));

6676

tmp_table->status=0;

6677

tmp_table->null_row=0;

6678

return(false);

6679

}

6680

6681

6682

inline void add_cond_and_fix(Item **e1, Item *e2)

6683

{

6684

if (*e1)

6685

{

6686

Item *res;

6687

if ((res= new Item_cond_and(*e1, e2)))

6688

{

6689

*e1= res;

6690

res->quick_fix_field();

6691

}

6692

}

6693

else

6694

*e1= e2;

6695

}

6696

1093

j->type= AM_CONST;

1094

}

1095

else

1096

j->type= AM_EQ_REF;

1097

return 0;

1098

}

6697

1099

6698

1100

/**

6699

1101

Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions

6708

1110

add "t1.field IS NOT NULL" to t1's table condition. @n

6709

1111

6710

1112

Description of the optimization:

6711

1113

6712

1114

We look through equalities choosen to perform ref/eq_ref access,

6713

1115

pick equalities that have form "tbl.part_of_key = othertbl.field"

6714

1116

(where othertbl is a non-const table and othertbl.field may be NULL)

6736

1138

This optimization doesn't affect the choices that ref, range, or join

6737

1139

optimizer make. This was intentional because this was added after 4.1

6738

1140

was GA.

6739

1141

6740

1142

Implementation overview

6741

1143

1. update_ref_and_keys() accumulates info about null-rejecting

6742

predicates in in KEY_FIELD::null_rejecting

6743

1.1 add_key_part saves these to KEYUSE.

6744

2. create_ref_for_key copies them to TABLE_REF.

1144

predicates in in KeyField::null_rejecting

1145

1.1 add_key_part saves these to KeyUse.

1146

2. create_ref_for_key copies them to table_reference_st.

6745

1147

3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of

6746

appropiate JOIN_TAB members.

1148

appropiate JoinTable members.

6747

1149

6748

6749

static void add_not_null_conds(JOIN *join)

1150

void add_not_null_conds(JOIN *join)

6750

1151

{

6751

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

1152

for (uint32_t i= join->const_tables; i < join->tables; i++)

6752

1153

{

6753

JOIN_TAB *tab=join->join_tab+i;

6754

if ((tab->type == JT_REF || tab->type == JT_EQ_REF ||

6755

tab->type == JT_REF_OR_NULL) &&

1154

JoinTable *tab=join->join_tab+i;

1155

if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||

1156

tab->type == AM_REF_OR_NULL) &&

6756

1157

!tab->table->maybe_null)

6757

1158

{

6758

1159

for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)

6763

1164

Item *notnull;

6764

1165

assert(item->type() == Item::FIELD_ITEM);

6765

1166

Item_field *not_null_item= (Item_field*)item;

6766

JOIN_TAB *referred_tab= not_null_item->field->table->reginfo.join_tab;

1167

JoinTable *referred_tab= not_null_item->field->table->reginfo.join_tab;

6767

1168

6768

1169

For UPDATE queries such as:

6769

1170

UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);

6775

1176

return;

6776

1177

6777

1178

We need to do full fix_fields() call here in order to have correct

6778

notnull->const_item(). This is needed e.g. by test_quick_select

6779

when it is called from make_join_select after this function is

1179

notnull->const_item(). This is needed e.g. by test_quick_select

1180

when it is called from make_join_select after this function is

6780

1181

called.

6781

1182

6782

if (notnull->fix_fields(join->thd, &notnull))

1183

if (notnull->fix_fields(join->session, &notnull))

6783

1184

return;

6784

1185

add_cond_and_fix(&referred_tab->select_cond, notnull);

6785

1186

}

6804

1205

- pointer to the guarded predicate, if success

6805

1206

- 0, otherwise

6806

1207

6807

6808

static COND*

6809

add_found_match_trig_cond(JOIN_TAB *tab, COND *cond, JOIN_TAB *root_tab)

1208

COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab)

6810

1209

{

6811

1210

COND *tmp;

6812

1211

assert(cond != 0);

6822

1221

return tmp;

6823

1222

}

6824

1223

6825

6826

/**

6827

Fill in outer join related info for the execution plan structure.

6828

6829

For each outer join operation left after simplification of the

6830

original query the function set up the following pointers in the linear

6831

structure join->join_tab representing the selected execution plan.

6832

The first inner table t0 for the operation is set to refer to the last

6833

inner table tk through the field t0->last_inner.

6834

Any inner table ti for the operation are set to refer to the first

6835

inner table ti->first_inner.

6836

The first inner table t0 for the operation is set to refer to the

6837

first inner table of the embedding outer join operation, if there is any,

6838

through the field t0->first_upper.

6839

The on expression for the outer join operation is attached to the

6840

corresponding first inner table through the field t0->on_expr_ref.

6841

Here ti are structures of the JOIN_TAB type.

6842

6843

EXAMPLE. For the query:

6844

@code

6845

SELECT * FROM t1

6846

LEFT JOIN

6847

(t2, t3 LEFT JOIN t4 ON t3.a=t4.a)

6848

ON (t1.a=t2.a AND t1.b=t3.b)

6849

WHERE t1.c > 5,

6850

@endcode

6851

6852

given the execution plan with the table order t1,t2,t3,t4

6853

is selected, the following references will be set;

6854

t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]

6855

t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],

6856

on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to

6857

*t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.

6858

6859

@param join reference to the info fully describing the query

6860

6861

@note

6862

The function assumes that the simplification procedure has been

6863

already applied to the join query (see simplify_joins).

6864

This function can be called only after the execution plan

6865

has been chosen.

6866

6867

6868

static void

6869

make_outerjoin_info(JOIN *join)

6870

{

6871

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

6872

{

6873

JOIN_TAB *tab=join->join_tab+i;

6874

Table *table=tab->table;

6875

TableList *tbl= table->pos_in_table_list;

6876

TableList *embedding= tbl->embedding;

6877

6878

if (tbl->outer_join)

6879

{

6880

6881

Table tab is the only one inner table for outer join.

6882

(Like table t4 for the table reference t3 LEFT JOIN t4 ON t3.a=t4.a

6883

is in the query above.)

6884

6885

tab->last_inner= tab->first_inner= tab;

6886

tab->on_expr_ref= &tbl->on_expr;

6887

tab->cond_equal= tbl->cond_equal;

6888

if (embedding)

6889

tab->first_upper= embedding->nested_join->first_nested;

6890

}

6891

for ( ; embedding ; embedding= embedding->embedding)

6892

{

6893

/* Ignore sj-nests: */

6894

if (!embedding->on_expr)

6895

continue;

6896

nested_join_st *nested_join= embedding->nested_join;

6897

if (!nested_join->counter_)

6898

{

6899

6900

Table tab is the first inner table for nested_join.

6901

Save reference to it in the nested join structure.

6902

6903

nested_join->first_nested= tab;

6904

tab->on_expr_ref= &embedding->on_expr;

6905

tab->cond_equal= tbl->cond_equal;

6906

if (embedding->embedding)

6907

tab->first_upper= embedding->embedding->nested_join->first_nested;

6908

}

6909

if (!tab->first_inner)

6910

tab->first_inner= nested_join->first_nested;

6911

if (++nested_join->counter_ < nested_join->join_list.elements)

6912

break;

6913

/* Table tab is the last inner table for nested join. */

6914

nested_join->first_nested->last_inner= tab;

6915

}

6916

}

6917

return;

6918

}

6919

6920

6921

static bool

6922

make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)

6923

{

6924

THD *thd= join->thd;

6925

if (select)

6926

{

6927

add_not_null_conds(join);

6928

table_map used_tables;

6929

if (cond) /* Because of QUICK_GROUP_MIN_MAX_SELECT */

6930

{ /* there may be a select without a cond. */

6931

if (join->tables > 1)

6932

cond->update_used_tables(); // Tablenr may have changed

6933

if (join->const_tables == join->tables &&

6934

thd->lex->current_select->master_unit() ==

6935

&thd->lex->unit) // not upper level SELECT

6936

join->const_table_map|=RAND_TABLE_BIT;

6937

{ // Check const tables

6938

COND *const_cond=

6939

make_cond_for_table(cond,

6940

join->const_table_map,

6941

(table_map) 0, 1);

6942

for (JOIN_TAB *tab= join->join_tab+join->const_tables;

6943

tab < join->join_tab+join->tables ; tab++)

6944

{

6945

if (*tab->on_expr_ref)

6946

{

6947

JOIN_TAB *cond_tab= tab->first_inner;

6948

COND *tmp= make_cond_for_table(*tab->on_expr_ref,

6949

join->const_table_map,

6950

( table_map) 0, 0);

6951

if (!tmp)

6952

continue;

6953

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

6954

if (!tmp)

6955

return(1);

6956

tmp->quick_fix_field();

6957

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

6958

new Item_cond_and(cond_tab->select_cond,

6959

tmp);

6960

if (!cond_tab->select_cond)

6961

return(1);

6962

cond_tab->select_cond->quick_fix_field();

6963

}

6964

}

6965

if (const_cond && !const_cond->val_int())

6966

{

6967

return(1); // Impossible const condition

6968

}

6969

}

6970

}

6971

used_tables=((select->const_tables=join->const_table_map) |

6972

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

6973

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

6974

{

6975

JOIN_TAB *tab=join->join_tab+i;

6976

6977

first_inner is the X in queries like:

6978

SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X

6979

6980

JOIN_TAB *first_inner_tab= tab->first_inner;

6981

table_map current_map= tab->table->map;

6982

bool use_quick_range=0;

6983

COND *tmp;

6984

6985

6986

Following force including random expression in last table condition.

6987

It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5

6988

6989

if (i == join->tables-1)

6990

current_map|= OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;

6991

used_tables|=current_map;

6992

6993

if (tab->type == JT_REF && tab->quick &&

6994

(uint) tab->ref.key == tab->quick->index &&

6995

tab->ref.key_length < tab->quick->max_used_key_length)

6996

{

6997

/* Range uses longer key; Use this instead of ref on key */

6998

tab->type=JT_ALL;

6999

use_quick_range=1;

7000

tab->use_quick=1;

7001

tab->ref.key= -1;

7002

tab->ref.key_parts=0; // Don't use ref key.

7003

join->best_positions[i].records_read= rows2double(tab->quick->records);

7004

7005

We will use join cache here : prevent sorting of the first

7006

table only and sort at the end.

7007

7008

if (i != join->const_tables && join->tables > join->const_tables + 1)

7009

join->full_join= 1;

7010

}

7011

7012

tmp= NULL;

7013

if (cond)

7014

tmp= make_cond_for_table(cond,used_tables,current_map, 0);

7015

if (cond && !tmp && tab->quick)

7016

{ // Outer join

7017

if (tab->type != JT_ALL)

7018

{

7019

7020

Don't use the quick method

7021

We come here in the case where we have 'key=constant' and

7022

the test is removed by make_cond_for_table()

7023

7024

delete tab->quick;

7025

tab->quick= 0;

7026

}

7027

else

7028

{

7029

7030

Hack to handle the case where we only refer to a table

7031

in the ON part of an OUTER JOIN. In this case we want the code

7032

below to check if we should use 'quick' instead.

7033

7034

tmp= new Item_int((int64_t) 1,1); // Always true

7035

}

7036

7037

}

7038

if (tmp || !cond || tab->type == JT_REF || tab->type == JT_REF_OR_NULL ||

7039

tab->type == JT_EQ_REF)

7040

{

7041

SQL_SELECT *sel= tab->select= ((SQL_SELECT*)

7042

thd->memdup((unsigned char*) select,

7043

sizeof(*select)));

7044

if (!sel)

7045

return(1); // End of memory

7046

7047

If tab is an inner table of an outer join operation,

7048

add a match guard to the pushed down predicate.

7049

The guard will turn the predicate on only after

7050

the first match for outer tables is encountered.

7051

7052

if (cond && tmp)

7053

{

7054

7055

Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without

7056

a cond, so neutralize the hack above.

7057

7058

if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))

7059

return(1);

7060

tab->select_cond=sel->cond=tmp;

7061

/* Push condition to storage engine if this is enabled

7062

and the condition is not guarded */

7063

tab->table->file->pushed_cond= NULL;

7064

if (thd->variables.engine_condition_pushdown)

7065

{

7066

COND *push_cond=

7067

make_cond_for_table(tmp, current_map, current_map, 0);

7068

if (push_cond)

7069

{

7070

/* Push condition to handler */

7071

if (!tab->table->file->cond_push(push_cond))

7072

tab->table->file->pushed_cond= push_cond;

7073

}

7074

}

7075

}

7076

else

7077

tab->select_cond= sel->cond= NULL;

7078

7079

sel->head=tab->table;

7080

if (tab->quick)

7081

{

7082

/* Use quick key read if it's a constant and it's not used

7083

with key reading */

7084

if (tab->needed_reg.is_clear_all() && tab->type != JT_EQ_REF

7085

&& (tab->type != JT_REF || (uint) tab->ref.key == tab->quick->index))

7086

{

7087

sel->quick=tab->quick; // Use value from get_quick_...

7088

sel->quick_keys.clear_all();

7089

sel->needed_reg.clear_all();

7090

}

7091

else

7092

{

7093

delete tab->quick;

7094

}

7095

tab->quick=0;

7096

}

7097

uint32_t ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;

7098

if (i == join->const_tables && ref_key)

7099

{

7100

if (!tab->const_keys.is_clear_all() &&

7101

tab->table->reginfo.impossible_range)

7102

return(1);

7103

}

7104

else if (tab->type == JT_ALL && ! use_quick_range)

7105

{

7106

if (!tab->const_keys.is_clear_all() &&

7107

tab->table->reginfo.impossible_range)

7108

return(1); // Impossible range

7109

7110

We plan to scan all rows.

7111

Check again if we should use an index.

7112

We could have used an column from a previous table in

7113

the index if we are using limit and this is the first table

7114

7115

7116

if ((cond && (!tab->keys.is_subset(tab->const_keys) && i > 0)) ||

7117

(!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)))

7118

{

7119

/* Join with outer join condition */

7120

COND *orig_cond=sel->cond;

7121

sel->cond= and_conds(sel->cond, *tab->on_expr_ref);

7122

7123

7124

We can't call sel->cond->fix_fields,

7125

as it will break tab->on_expr if it's AND condition

7126

(fix_fields currently removes extra AND/OR levels).

7127

Yet attributes of the just built condition are not needed.

7128

Thus we call sel->cond->quick_fix_field for safety.

7129

7130

if (sel->cond && !sel->cond->fixed)

7131

sel->cond->quick_fix_field();

7132

7133

if (sel->test_quick_select(thd, tab->keys,

7134

used_tables & ~ current_map,

7135

(join->select_options &

7136

OPTION_FOUND_ROWS ?

7137

HA_POS_ERROR :

7138

join->unit->select_limit_cnt), 0,

7139

false) < 0)

7140

{

7141

7142

Before reporting "Impossible WHERE" for the whole query

7143

we have to check isn't it only "impossible ON" instead

7144

7145

sel->cond=orig_cond;

7146

if (!*tab->on_expr_ref ||

7147

sel->test_quick_select(thd, tab->keys,

7148

used_tables & ~ current_map,

7149

(join->select_options &

7150

OPTION_FOUND_ROWS ?

7151

HA_POS_ERROR :

7152

join->unit->select_limit_cnt),0,

7153

false) < 0)

7154

return(1); // Impossible WHERE

7155

}

7156

else

7157

sel->cond=orig_cond;

7158

7159

/* Fix for EXPLAIN */

7160

if (sel->quick)

7161

join->best_positions[i].records_read= (double)sel->quick->records;

7162

}

7163

else

7164

{

7165

sel->needed_reg=tab->needed_reg;

7166

sel->quick_keys.clear_all();

7167

}

7168

if (!sel->quick_keys.is_subset(tab->checked_keys) ||

7169

!sel->needed_reg.is_subset(tab->checked_keys))

7170

{

7171

tab->keys=sel->quick_keys;

7172

tab->keys.merge(sel->needed_reg);

7173

tab->use_quick= (!sel->needed_reg.is_clear_all() &&

7174

(select->quick_keys.is_clear_all() ||

7175

(select->quick &&

7176

(select->quick->records >= 100L)))) ?

7177

2 : 1;

7178

sel->read_tables= used_tables & ~current_map;

7179

}

7180

if (i != join->const_tables && tab->use_quick != 2)

7181

{ /* Read with cache */

7182

if (cond &&

7183

(tmp=make_cond_for_table(cond,

7184

join->const_table_map |

7185

current_map,

7186

current_map, 0)))

7187

{

7188

tab->cache.select=(SQL_SELECT*)

7189

thd->memdup((unsigned char*) sel, sizeof(SQL_SELECT));

7190

tab->cache.select->cond=tmp;

7191

tab->cache.select->read_tables=join->const_table_map;

7192

}

7193

}

7194

}

7195

}

7196

7197

7198

Push down conditions from all on expressions.

7199

Each of these conditions are guarded by a variable

7200

that turns if off just before null complemented row for

7201

outer joins is formed. Thus, the condition from an

7202

'on expression' are guaranteed not to be checked for

7203

the null complemented row.

7204

7205

7206

/* First push down constant conditions from on expressions */

7207

for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;

7208

join_tab < join->join_tab+join->tables ; join_tab++)

7209

{

7210

if (*join_tab->on_expr_ref)

7211

{

7212

JOIN_TAB *cond_tab= join_tab->first_inner;

7213

COND *tmp= make_cond_for_table(*join_tab->on_expr_ref,

7214

join->const_table_map,

7215

(table_map) 0, 0);

7216

if (!tmp)

7217

continue;

7218

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

7219

if (!tmp)

7220

return(1);

7221

tmp->quick_fix_field();

7222

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

7223

new Item_cond_and(cond_tab->select_cond,tmp);

7224

if (!cond_tab->select_cond)

7225

return(1);

7226

cond_tab->select_cond->quick_fix_field();

7227

}

7228

}

7229

7230

/* Push down non-constant conditions from on expressions */

7231

JOIN_TAB *last_tab= tab;

7232

while (first_inner_tab && first_inner_tab->last_inner == last_tab)

7233

{

7234

7235

Table tab is the last inner table of an outer join.

7236

An on expression is always attached to it.

7237

7238

COND *on_expr= *first_inner_tab->on_expr_ref;

7239

7240

table_map used_tables2= (join->const_table_map |

7241

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

7242

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

7243

{

7244

current_map= tab->table->map;

7245

used_tables2|= current_map;

7246

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

7247

current_map, 0);

7248

if (tmp_cond)

7249

{

7250

JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

7251

7252

First add the guards for match variables of

7253

all embedding outer join operations.

7254

7255

if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,

7256

tmp_cond,

7257

first_inner_tab)))

7258

return(1);

7259

7260

Now add the guard turning the predicate off for

7261

the null complemented row.

7262

7263

tmp_cond= new Item_func_trig_cond(tmp_cond,

7264

&first_inner_tab->

7265

not_null_compl);

7266

if (tmp_cond)

7267

tmp_cond->quick_fix_field();

7268

/* Add the predicate to other pushed down predicates */

7269

cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :

7270

new Item_cond_and(cond_tab->select_cond,

7271

tmp_cond);

7272

if (!cond_tab->select_cond)

7273

return(1);

7274

cond_tab->select_cond->quick_fix_field();

7275

}

7276

}

7277

first_inner_tab= first_inner_tab->first_upper;

7278

}

7279

}

7280

}

7281

return(0);

7282

}

7283

7284

7285

1224

7286

1225

Check if given expression uses only table fields covered by the given index

7287

1226

7288

1227

SYNOPSIS

7295

1234

DESCRIPTION

7296

1235

Check if given expression only uses fields covered by index #keyno in the

7297

1236

table tbl. The expression can use any fields in any other tables.

7298

7299

The expression is guaranteed not to be AND or OR - those constructs are

1237

1238

The expression is guaranteed not to be AND or OR - those constructs are

7300

1239

handled outside of this function.

7301

1240

7302

1241

RETURN

7303

1242

true Yes

7304

1243

false No

7305

1244

7306

7307

bool uses_index_fields_only(Item *item, Table *tbl, uint32_t keyno,

7308

bool other_tbls_ok)

1245

static bool uses_index_fields_only(Item *item, Table *tbl, uint32_t keyno, bool other_tbls_ok)

7309

1246

{

7310

1247

if (item->const_item())

7311

1248

return true;

7312

1249

7313

7314

Don't push down the triggered conditions. Nested outer joins execution

1250

1251

Don't push down the triggered conditions. Nested outer joins execution

7315

1252

code may need to evaluate a condition several times (both triggered and

7316

1253

untriggered), and there is no way to put thi

7317

1254

TODO: Consider cloning the triggered condition and using the copies for:

7318

1255

1. push the first copy down, to have most restrictive index condition

7319

1256

possible

7320

2. Put the second copy into tab->select_cond.

1257

2. Put the second copy into tab->select_cond.

7321

1258

7322

if (item->type() == Item::FUNC_ITEM &&

1259

if (item->type() == Item::FUNC_ITEM &&

7323

1260

((Item_func*)item)->functype() == Item_func::TRIG_COND_FUNC)

7324

1261

return false;

7325

1262

7345

1282

{

7346

1283

/* This is a function, apply condition recursively to arguments */

7347

1284

List_iterator<Item> li(*((Item_cond*)item)->argument_list());

7348

Item *item;

7349

while ((item=li++))

1285

Item *list_item;

1286

while ((list_item=li++))

7350

1287

{

7351

1288

if (!uses_index_fields_only(item, tbl, keyno, other_tbls_ok))

7352

1289

return false;

7356

1293

case Item::FIELD_ITEM:

7357

1294

{

7358

1295

Item_field *item_field= (Item_field*)item;

7359

if (item_field->field->table != tbl)

1296

if (item_field->field->table != tbl)

7360

1297

return true;

7361

return item_field->field->part_of_key.is_set(keyno);

1298

return item_field->field->part_of_key.test(keyno);

7362

1299

}

7363

1300

case Item::REF_ITEM:

7364

1301

return uses_index_fields_only(item->real_item(), tbl, keyno,

7368

1305

}

7369

1306

}

7370

1307

7371

7372

1308

#define ICP_COND_USES_INDEX_ONLY 10

7373

1309

7374

1310

7383

1319

other_tbls_ok true <=> Fields of other non-const tables are allowed

7384

1320

7385

1321

DESCRIPTION

7386

Get a part of the condition that can be checked when for the given table

1322

Get a part of the condition that can be checked when for the given table

7387

1323

we have values only of fields covered by some index. The condition may

7388

refer to other tables, it is assumed that we have values of all of their

1324

refer to other tables, it is assumed that we have values of all of their

7389

1325

fields.

7390

1326

7391

1327

Example:

7392

1328

make_cond_for_index(

7393

1329

"cond(t1.field) AND cond(t2.key1) AND cond(t2.non_key) AND cond(t2.key2)",

7394

t2, keyno(t2.key1))

1330

t2, keyno(t2.key1))

7395

1331

will return

7396

1332

"cond(t1.field) AND cond(t2.key2)"

7397

1333

7398

1334

RETURN

7399

1335

Index condition, or NULL if no condition could be inferred.

7400

1336

7401

7402

Item *make_cond_for_index(Item *cond, Table *table, uint32_t keyno,

7403

bool other_tbls_ok)

1337

static Item *make_cond_for_index(Item *cond, Table *table, uint32_t keyno, bool other_tbls_ok)

7404

1338

{

7405

1339

if (!cond)

7406

1340

return NULL;

7411

1345

{

7412

1346

Item_cond_and *new_cond=new Item_cond_and;

7413

1347

if (!new_cond)

7414

return (COND*) 0;

1348

return (COND*) 0;

7415

1349

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7416

1350

Item *item;

7417

1351

while ((item=li++))

7418

1352

{

7419

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7420

if (fix)

7421

new_cond->argument_list()->push_back(fix);

1353

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

1354

if (fix)

1355

new_cond->argument_list()->push_back(fix);

7422

1356

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7423

1357

}

7424

1358

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7425

1359

cond->marker= ICP_COND_USES_INDEX_ONLY;

7426

1360

switch (new_cond->argument_list()->elements) {

7427

1361

case 0:

7428

return (COND*) 0;

1362

return (COND*) 0;

7429

1363

case 1:

7430

return new_cond->argument_list()->head();

1364

return new_cond->argument_list()->head();

7431

1365

default:

7432

new_cond->quick_fix_field();

7433

return new_cond;

1366

new_cond->quick_fix_field();

1367

return new_cond;

7434

1368

}

7435

1369

}

7436

1370

else /* It's OR */

7437

1371

{

7438

1372

Item_cond_or *new_cond=new Item_cond_or;

7439

1373

if (!new_cond)

7440

return (COND*) 0;

1374

return (COND*) 0;

7441

1375

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7442

1376

Item *item;

7443

1377

while ((item=li++))

7444

1378

{

7445

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7446

if (!fix)

7447

return (COND*) 0;

7448

new_cond->argument_list()->push_back(fix);

1379

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

1380

if (!fix)

1381

return (COND*) 0;

1382

new_cond->argument_list()->push_back(fix);

7449

1383

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7450

1384

}

7451

1385

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7463

1397

}

7464

1398

7465

1399

7466

Item *make_cond_remainder(Item *cond, bool exclude_index)

1400

static Item *make_cond_remainder(Item *cond, bool exclude_index)

7467

1401

{

7468

1402

if (exclude_index && cond->marker == ICP_COND_USES_INDEX_ONLY)

7469

1403

return 0; /* Already checked */

7476

1410

/* Create new top level AND item */

7477

1411

Item_cond_and *new_cond=new Item_cond_and;

7478

1412

if (!new_cond)

7479

return (COND*) 0;

1413

return (COND*) 0;

7480

1414

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7481

1415

Item *item;

7482

1416

while ((item=li++))

7483

1417

{

7484

Item *fix= make_cond_remainder(item, exclude_index);

7485

if (fix)

1418

Item *fix= make_cond_remainder(item, exclude_index);

1419

if (fix)

7486

1420

{

7487

new_cond->argument_list()->push_back(fix);

1421

new_cond->argument_list()->push_back(fix);

7488

1422

tbl_map |= fix->used_tables();

7489

1423

}

7490

1424

}

7491

1425

switch (new_cond->argument_list()->elements) {

7492

1426

case 0:

7493

return (COND*) 0;

1427

return (COND*) 0;

7494

1428

case 1:

7495

return new_cond->argument_list()->head();

1429

return new_cond->argument_list()->head();

7496

1430

default:

7497

new_cond->quick_fix_field();

1431

new_cond->quick_fix_field();

7498

1432

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7499

return new_cond;

1433

return new_cond;

7500

1434

}

7501

1435

}

7502

1436

else /* It's OR */

7503

1437

{

7504

1438

Item_cond_or *new_cond=new Item_cond_or;

7505

1439

if (!new_cond)

7506

return (COND*) 0;

1440

return (COND*) 0;

7507

1441

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7508

1442

Item *item;

7509

1443

while ((item=li++))

7510

1444

{

7511

Item *fix= make_cond_remainder(item, false);

7512

if (!fix)

7513

return (COND*) 0;

7514

new_cond->argument_list()->push_back(fix);

1445

Item *fix= make_cond_remainder(item, false);

1446

if (!fix)

1447

return (COND*) 0;

1448

new_cond->argument_list()->push_back(fix);

7515

1449

tbl_map |= fix->used_tables();

7516

1450

}

7517

1451

new_cond->quick_fix_field();

7523

1457

return cond;

7524

1458

}

7525

1459

7526

7527

7528

Try to extract and push the index condition

7529

7530

SYNOPSIS

7531

push_index_cond()

7532

tab A join tab that has tab->table->file and its condition

7533

in tab->select_cond

7534

keyno Index for which extract and push the condition

7535

other_tbls_ok true <=> Fields of other non-const tables are allowed

7536

7537

DESCRIPTION

7538

Try to extract and push the index condition down to table handler

7539

7540

7541

static void push_index_cond(JOIN_TAB *tab, uint32_t keyno, bool other_tbls_ok)

7542

{

7543

Item *idx_cond;

7544

if (tab->table->file->index_flags(keyno, 0, 1) & HA_DO_INDEX_COND_PUSHDOWN &&

7545

tab->join->thd->variables.engine_condition_pushdown)

7546

{

7547

idx_cond= make_cond_for_index(tab->select_cond, tab->table, keyno,

7548

other_tbls_ok);

7549

7550

if (idx_cond)

7551

{

7552

tab->pre_idx_push_select_cond= tab->select_cond;

7553

Item *idx_remainder_cond=

7554

tab->table->file->idx_cond_push(keyno, idx_cond);

7555

7556

7557

Disable eq_ref's "lookup cache" if we've pushed down an index

7558

condition.

7559

TODO: This check happens to work on current ICP implementations, but

7560

there may exist a compliant implementation that will not work

7561

correctly with it. Sort this out when we stabilize the condition

7562

pushdown APIs.

7563

7564

if (idx_remainder_cond != idx_cond)

7565

tab->ref.disable_cache= true;

7566

7567

Item *row_cond= make_cond_remainder(tab->select_cond, true);

7568

7569

if (row_cond)

7570

{

7571

if (!idx_remainder_cond)

7572

tab->select_cond= row_cond;

7573

else

7574

{

7575

tab->select_cond= new Item_cond_and(row_cond, idx_remainder_cond);

7576

tab->select_cond->quick_fix_field();

7577

((Item_cond_and*)tab->select_cond)->used_tables_cache=

7578

row_cond->used_tables() | idx_remainder_cond->used_tables();

7579

}

7580

}

7581

else

7582

tab->select_cond= idx_remainder_cond;

7583

if (tab->select)

7584

{

7585

tab->select->cond= tab->select_cond;

7586

}

7587

}

7588

}

7589

return;

7590

}

7591

7592

7593

7594

7595

Determine if the set is already ordered for order_st BY, so it can

7596

disable join cache because it will change the ordering of the results.

7597

Code handles sort table that is at any location (not only first after

7598

the const tables) despite the fact that it's currently prohibited.

7599

We must disable join cache if the first non-const table alone is

7600

ordered. If there is a temp table the ordering is done as a last

7601

operation and doesn't prevent join cache usage.

7602

7603

uint32_t make_join_orderinfo(JOIN *join)

7604

{

7605

uint32_t i;

7606

if (join->need_tmp)

7607

return join->tables;

7608

7609

for (i=join->const_tables ; i < join->tables ; i++)

7610

{

7611

JOIN_TAB *tab=join->join_tab+i;

7612

Table *table=tab->table;

7613

if ((table == join->sort_by_table &&

7614

(!join->order || join->skip_sort_order)) ||

7615

(join->sort_by_table == (Table *) 1 && i != join->const_tables))

7616

{

7617

break;

7618

}

7619

}

7620

return i;

7621

}

7622

7623

7624

7625

Plan refinement stage: do various set ups for the executioner

7626

7627

SYNOPSIS

7628

make_join_readinfo()

7629

join Join being processed

7630

options Join's options (checking for SELECT_DESCRIBE,

7631

SELECT_NO_JOIN_CACHE)

7632

no_jbuf_after Don't use join buffering after table with this number.

7633

7634

DESCRIPTION

7635

Plan refinement stage: do various set ups for the executioner

7636

- set up use of join buffering

7637

- push index conditions

7638

- increment counters

7639

- etc

7640

7641

RETURN

7642

false - OK

7643

true - Out of memory

7644

7645

7646

static bool

7647

make_join_readinfo(JOIN *join, uint64_t options, uint32_t no_jbuf_after)

7648

{

7649

uint32_t i;

7650

bool statistics= test(!(join->select_options & SELECT_DESCRIBE));

7651

bool sorted= 1;

7652

7653

for (i=join->const_tables ; i < join->tables ; i++)

7654

{

7655

JOIN_TAB *tab=join->join_tab+i;

7656

Table *table=tab->table;

7657

bool using_join_cache;

7658

tab->read_record.table= table;

7659

tab->read_record.file=table->file;

7660

tab->next_select=sub_select; /* normal select */

7661

7662

TODO: don't always instruct first table's ref/range access method to

7663

produce sorted output.

7664

7665

tab->sorted= sorted;

7666

sorted= 0; // only first must be sorted

7667

if (tab->insideout_match_tab)

7668

{

7669

if (!(tab->insideout_buf= (unsigned char*)join->thd->alloc(tab->table->key_info

7670

[tab->index].

7671

key_length)))

7672

return true;

7673

}

7674

switch (tab->type) {

7675

case JT_SYSTEM: // Only happens with left join

7676

table->status=STATUS_NO_RECORD;

7677

tab->read_first_record= join_read_system;

7678

tab->read_record.read_record= join_no_more_records;

7679

break;

7680

case JT_CONST: // Only happens with left join

7681

table->status=STATUS_NO_RECORD;

7682

tab->read_first_record= join_read_const;

7683

tab->read_record.read_record= join_no_more_records;

7684

if (table->covering_keys.is_set(tab->ref.key) &&

7685

!table->no_keyread)

7686

{

7687

table->key_read=1;

7688

table->file->extra(HA_EXTRA_KEYREAD);

7689

}

7690

break;

7691

case JT_EQ_REF:

7692

table->status=STATUS_NO_RECORD;

7693

if (tab->select)

7694

{

7695

delete tab->select->quick;

7696

tab->select->quick=0;

7697

}

7698

delete tab->quick;

7699

tab->quick=0;

7700

tab->read_first_record= join_read_key;

7701

tab->read_record.read_record= join_no_more_records;

7702

if (table->covering_keys.is_set(tab->ref.key) &&

7703

!table->no_keyread)

7704

{

7705

table->key_read=1;

7706

table->file->extra(HA_EXTRA_KEYREAD);

7707

}

7708

else

7709

push_index_cond(tab, tab->ref.key, true);

7710

break;

7711

case JT_REF_OR_NULL:

7712

case JT_REF:

7713

table->status=STATUS_NO_RECORD;

7714

if (tab->select)

7715

{

7716

delete tab->select->quick;

7717

tab->select->quick=0;

7718

}

7719

delete tab->quick;

7720

tab->quick=0;

7721

if (table->covering_keys.is_set(tab->ref.key) &&

7722

!table->no_keyread)

7723

{

7724

table->key_read=1;

7725

table->file->extra(HA_EXTRA_KEYREAD);

7726

}

7727

else

7728

push_index_cond(tab, tab->ref.key, true);

7729

if (tab->type == JT_REF)

7730

{

7731

tab->read_first_record= join_read_always_key;

7732

tab->read_record.read_record= tab->insideout_match_tab?

7733

join_read_next_same_diff : join_read_next_same;

7734

}

7735

else

7736

{

7737

tab->read_first_record= join_read_always_key_or_null;

7738

tab->read_record.read_record= join_read_next_same_or_null;

7739

}

7740

break;

7741

case JT_ALL:

7742

7743

If previous table use cache

7744

If the incoming data set is already sorted don't use cache.

7745

7746

table->status=STATUS_NO_RECORD;

7747

using_join_cache= false;

7748

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

7749

tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&

7750

!tab->insideout_match_tab)

7751

{

7752

if ((options & SELECT_DESCRIBE) ||

7753

!join_init_cache(join->thd,join->join_tab+join->const_tables,

7754

i-join->const_tables))

7755

{

7756

using_join_cache= true;

7757

tab[-1].next_select=sub_select_cache; /* Patch previous */

7758

}

7759

}

7760

/* These init changes read_record */

7761

if (tab->use_quick == 2)

7762

{

7763

join->thd->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

7764

tab->read_first_record= join_init_quick_read_record;

7765

if (statistics)

7766

status_var_increment(join->thd->status_var.select_range_check_count);

7767

}

7768

else

7769

{

7770

tab->read_first_record= join_init_read_record;

7771

if (i == join->const_tables)

7772

{

7773

if (tab->select && tab->select->quick)

7774

{

7775

if (statistics)

7776

status_var_increment(join->thd->status_var.select_range_count);

7777

}

7778

else

7779

{

7780

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7781

if (statistics)

7782

status_var_increment(join->thd->status_var.select_scan_count);

7783

}

7784

}

7785

else

7786

{

7787

if (tab->select && tab->select->quick)

7788

{

7789

if (statistics)

7790

status_var_increment(join->thd->status_var.select_full_range_join_count);

7791

}

7792

else

7793

{

7794

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7795

if (statistics)

7796

status_var_increment(join->thd->status_var.select_full_join_count);

7797

}

7798

}

7799

if (!table->no_keyread)

7800

{

7801

if (tab->select && tab->select->quick &&

7802

tab->select->quick->index != MAX_KEY && //not index_merge

7803

table->covering_keys.is_set(tab->select->quick->index))

7804

{

7805

table->key_read=1;

7806

table->file->extra(HA_EXTRA_KEYREAD);

7807

}

7808

else if (!table->covering_keys.is_clear_all() &&

7809

!(tab->select && tab->select->quick))

7810

{ // Only read index tree

7811

if (!tab->insideout_match_tab)

7812

{

7813

7814

See bug #26447: "Using the clustered index for a table scan

7815

is always faster than using a secondary index".

7816

7817

if (table->s->primary_key != MAX_KEY &&

7818

table->file->primary_key_is_clustered())

7819

tab->index= table->s->primary_key;

7820

else

7821

tab->index= table->find_shortest_key(&table->covering_keys);

7822

}

7823

tab->read_first_record= join_read_first;

7824

tab->type=JT_NEXT; // Read with index_first / index_next

7825

}

7826

}

7827

if (tab->select && tab->select->quick &&

7828

tab->select->quick->index != MAX_KEY && ! tab->table->key_read)

7829

push_index_cond(tab, tab->select->quick->index, !using_join_cache);

7830

}

7831

break;

7832

default:

7833

break; /* purecov: deadcode */

7834

case JT_UNKNOWN:

7835

case JT_MAYBE_REF:

7836

abort(); /* purecov: deadcode */

7837

}

7838

}

7839

join->join_tab[join->tables-1].next_select=0; /* Set by do_select */

7840

return(false);

7841

}

7842

7843

7844

/**

7845

Give error if we some tables are done with a full join.

7846

7847

This is used by multi_table_update and multi_table_delete when running

7848

in safe mode.

7849

7850

@param join Join condition

7851

7852

@retval

7853

0 ok

7854

@retval

7855

1 Error (full join used)

7856

7857

7858

bool error_if_full_join(JOIN *join)

7859

{

7860

for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;

7861

tab < end;

7862

tab++)

7863

{

7864

if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))

7865

{

7866

my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,

7867

ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));

7868

return(1);

7869

}

7870

}

7871

return(0);

7872

}

7873

7874

7875

/**

7876

cleanup JOIN_TAB.

7877

7878

7879

void JOIN_TAB::cleanup()

1460

/**

1461

cleanup JoinTable.

1462

1463

void JoinTable::cleanup()

7880

1464

{

7881

1465

delete select;

7882

1466

select= 0;

7903

1487

end_read_record(&read_record);

7904

1488

}

7905

1489

7906

7907

/**

7908

Partially cleanup JOIN after it has executed: close index or rnd read

7909

(table cursors), free quick selects.

7910

7911

This function is called in the end of execution of a JOIN, before the used

7912

tables are unlocked and closed.

7913

7914

For a join that is resolved using a temporary table, the first sweep is

7915

performed against actual tables and an intermediate result is inserted

7916

into the temprorary table.

7917

The last sweep is performed against the temporary table. Therefore,

7918

the base tables and associated buffers used to fill the temporary table

7919

are no longer needed, and this function is called to free them.

7920

7921

For a join that is performed without a temporary table, this function

7922

is called after all rows are sent, but before EOF packet is sent.

7923

7924

For a simple SELECT with no subqueries this function performs a full

7925

cleanup of the JOIN and calls mysql_unlock_read_tables to free used base

7926

tables.

7927

7928

If a JOIN is executed for a subquery or if it has a subquery, we can't

7929

do the full cleanup and need to do a partial cleanup only.

7930

- If a JOIN is not the top level join, we must not unlock the tables

7931

because the outer select may not have been evaluated yet, and we

7932

can't unlock only selected tables of a query.

7933

- Additionally, if this JOIN corresponds to a correlated subquery, we

7934

should not free quick selects and join buffers because they will be

7935

needed for the next execution of the correlated subquery.

7936

- However, if this is a JOIN for a [sub]select, which is not

7937

a correlated subquery itself, but has subqueries, we can free it

7938

fully and also free JOINs of all its subqueries. The exception

7939

is a subquery in SELECT list, e.g: @n

7940

SELECT a, (select cmax(b) from t1) group by c @n

7941

This subquery will not be evaluated at first sweep and its value will

7942

not be inserted into the temporary table. Instead, it's evaluated

7943

when selecting from the temporary table. Therefore, it can't be freed

7944

here even though it's not correlated.

7945

7946

@todo

7947

Unlock tables even if the join isn't top level select in the tree

7948

7949

7950

void JOIN::join_free()

7951

{

7952

SELECT_LEX_UNIT *tmp_unit;

7953

SELECT_LEX *sl;

7954

7955

Optimization: if not EXPLAIN and we are done with the JOIN,

7956

free all tables.

7957

7958

bool full= (!select_lex->uncacheable && !thd->lex->describe);

7959

bool can_unlock= full;

7960

7961

cleanup(full);

7962

7963

for (tmp_unit= select_lex->first_inner_unit();

7964

tmp_unit;

7965

tmp_unit= tmp_unit->next_unit())

7966

for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())

7967

{

7968

Item_subselect *subselect= sl->master_unit()->item;

7969

bool full_local= full && (!subselect || subselect->is_evaluated());

7970

7971

If this join is evaluated, we can fully clean it up and clean up all

7972

its underlying joins even if they are correlated -- they will not be

7973

used any more anyway.

7974

If this join is not yet evaluated, we still must clean it up to

7975

close its table cursors -- it may never get evaluated, as in case of

7976

... HAVING false OR a IN (SELECT ...))

7977

but all table cursors must be closed before the unlock.

7978

7979

sl->cleanup_all_joins(full_local);

7980

/* Can't unlock if at least one JOIN is still needed */

7981

can_unlock= can_unlock && full_local;

7982

}

7983

7984

7985

We are not using tables anymore

7986

Unlock all tables. We may be in an INSERT .... SELECT statement.

7987

7988

if (can_unlock && lock && thd->lock &&

7989

!(select_options & SELECT_NO_UNLOCK) &&

7990

!select_lex->subquery_in_having &&

7991

(select_lex == (thd->lex->unit.fake_select_lex ?

7992

thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))

7993

{

7994

7995

TODO: unlock tables even if the join isn't top level select in the

7996

tree.

7997

7998

mysql_unlock_read_tables(thd, lock); // Don't free join->lock

7999

lock= 0;

8000

}

8001

8002

return;

8003

}

8004

8005

8006

/**

8007

Free resources of given join.

8008

8009

@param fill true if we should free all resources, call with full==1

8010

should be last, before it this function can be called with

8011

full==0

8012

8013

@note

8014

With subquery this function definitely will be called several times,

8015

but even for simple query it can be called several times.

8016

8017

8018

void JOIN::cleanup(bool full)

8019

{

8020

if (table)

8021

{

8022

JOIN_TAB *tab,*end;

8023

8024

Only a sorted table may be cached. This sorted table is always the

8025

first non const table in join->table

8026

8027

if (tables > const_tables) // Test for not-const tables

8028

{

8029

free_io_cache(table[const_tables]);

8030

filesort_free_buffers(table[const_tables],full);

8031

}

8032

8033

if (full)

8034

{

8035

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8036

tab->cleanup();

8037

table= 0;

8038

}

8039

else

8040

{

8041

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8042

{

8043

if (tab->table)

8044

tab->table->file->ha_index_or_rnd_end();

8045

}

8046

}

8047

cleanup_sj_tmp_tables(this);//

8048

}

8049

8050

We are not using tables anymore

8051

Unlock all tables. We may be in an INSERT .... SELECT statement.

8052

8053

if (full)

8054

{

8055

if (tmp_join)

8056

tmp_table_param.copy_field= 0;

8057

group_fields.delete_elements();

8058

8059

We can't call delete_elements() on copy_funcs as this will cause

8060

problems in free_elements() as some of the elements are then deleted.

8061

8062

tmp_table_param.copy_funcs.empty();

8063

8064

If we have tmp_join and 'this' JOIN is not tmp_join and

8065

tmp_table_param.copy_field's of them are equal then we have to remove

8066

pointer to tmp_table_param.copy_field from tmp_join, because it qill

8067

be removed in tmp_table_param.cleanup().

8068

8069

if (tmp_join &&

8070

tmp_join != this &&

8071

tmp_join->tmp_table_param.copy_field ==

8072

tmp_table_param.copy_field)

8073

{

8074

tmp_join->tmp_table_param.copy_field=

8075

tmp_join->tmp_table_param.save_copy_field= 0;

8076

}

8077

tmp_table_param.cleanup();

8078

}

8079

return;

8080

}

8081

1490

bool only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)

1491

{

1492

for (JoinTable **tab=join->map2table ; tables ; tab++, tables>>=1)

1493

{

1494

if (tables & 1 && !eq_ref_table(join, order, *tab))

1495

return 0;

1496

}

1497

return 1;

1498

}

8082

1499

8083

1500

/**

8084

1501

Remove the following expressions from order_st BY and GROUP BY:

8099

1516

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.b,t1.a

8100

1517

@endcode

8101

1518

8102

8103

static bool

8104

eq_ref_table(JOIN *join, order_st *start_order, JOIN_TAB *tab)

1519

bool eq_ref_table(JOIN *join, order_st *start_order, JoinTable *tab)

8105

1520

{

8106

1521

if (tab->cached_eq_ref_table) // If cached

8107

1522

return tab->eq_ref_table;

8108

1523

tab->cached_eq_ref_table=1;

8109

1524

/* We can skip const tables only if not an outer table */

8110

if (tab->type == JT_CONST && !tab->first_inner)

8111

return (tab->eq_ref_table=1); /* purecov: inspected */

8112

if (tab->type != JT_EQ_REF || tab->table->maybe_null)

1525

if (tab->type == AM_CONST && !tab->first_inner)

1526

return (tab->eq_ref_table=1);

1527

if (tab->type != AM_EQ_REF || tab->table->maybe_null)

8113

1528

return (tab->eq_ref_table=0); // We must use this

8114

1529

Item **ref_item=tab->ref.items;

8115

1530

Item **end=ref_item+tab->ref.key_parts;

8123

1538

order_st *order;

8124

1539

for (order=start_order ; order ; order=order->next)

8125

1540

{

8126

if ((*ref_item)->eq(order->item[0],0))

8127

break;

1541

if ((*ref_item)->eq(order->item[0],0))

1542

break;

8128

1543

}

8129

1544

if (order)

8130

1545

{

8131

found++;

8132

assert(!(order->used & map));

8133

order->used|=map;

8134

continue; // Used in order_st BY

1546

found++;

1547

assert(!(order->used & map));

1548

order->used|=map;

1549

continue; // Used in order_st BY

8135

1550

}

8136

1551

if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))

8137

return (tab->eq_ref_table=0);

1552

return (tab->eq_ref_table= 0);

8138

1553

}

8139

1554

}

8140

1555

/* Check that there was no reference to table before sort order */

8146

1561

continue;

8147

1562

}

8148

1563

if (start_order->depend_map & map)

8149

return (tab->eq_ref_table=0);

8150

}

8151

return tab->eq_ref_table=1;

8152

}

8153

8154

8155

static bool

8156

only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)

8157

{

8158

for (JOIN_TAB **tab=join->map2table ; tables ; tab++, tables>>=1)

8159

{

8160

if (tables & 1 && !eq_ref_table(join, order, *tab))

8161

return 0;

8162

}

8163

return 1;

8164

}

8165

8166

8167

/** Update the dependency map for the tables. */

8168

8169

static void update_depend_map(JOIN *join)

8170

{

8171

JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;

8172

8173

for (; join_tab != end ; join_tab++)

8174

{

8175

TABLE_REF *ref= &join_tab->ref;

8176

table_map depend_map=0;

8177

Item **item=ref->items;

8178

uint32_t i;

8179

for (i=0 ; i < ref->key_parts ; i++,item++)

8180

depend_map|=(*item)->used_tables();

8181

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

8182

depend_map&= ~OUTER_REF_TABLE_BIT;

8183

for (JOIN_TAB **tab=join->map2table;

8184

depend_map ;

8185

tab++,depend_map>>=1 )

8186

{

8187

if (depend_map & 1)

8188

ref->depend_map|=(*tab)->ref.depend_map;

8189

}

8190

}

8191

}

8192

8193

8194

/** Update the dependency map for the sort order. */

8195

8196

static void update_depend_map(JOIN *join, order_st *order)

8197

{

8198

for (; order ; order=order->next)

8199

{

8200

table_map depend_map;

8201

order->item[0]->update_used_tables();

8202

order->depend_map=depend_map=order->item[0]->used_tables();

8203

// Not item_sum(), RAND() and no reference to table outside of sub select

8204

if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))

8205

&& !order->item[0]->with_sum_func)

8206

{

8207

for (JOIN_TAB **tab=join->map2table;

8208

depend_map ;

8209

tab++, depend_map>>=1)

8210

{

8211

if (depend_map & 1)

8212

order->depend_map|=(*tab)->ref.depend_map;

8213

}

8214

}

8215

}

8216

}

8217

8218

8219

/**

8220

Remove all constants and check if order_st only contains simple

8221

expressions.

8222

8223

simple_order is set to 1 if sort_order only uses fields from head table

8224

and the head table is not a LEFT JOIN table.

8225

8226

@param join Join handler

8227

@param first_order List of SORT or GROUP order

8228

@param cond WHERE statement

8229

@param change_list Set to 1 if we should remove things from list.

8230

If this is not set, then only simple_order is

8231

calculated.

8232

@param simple_order Set to 1 if we are only using simple expressions

8233

8234

@return

8235

Returns new sort order

8236

8237

8238

static order_st *

8239

remove_const(JOIN *join,order_st *first_order, COND *cond,

8240

bool change_list, bool *simple_order)

8241

{

8242

if (join->tables == join->const_tables)

8243

return change_list ? 0 : first_order; // No need to sort

8244

8245

order_st *order,**prev_ptr;

8246

table_map first_table= join->join_tab[join->const_tables].table->map;

8247

table_map not_const_tables= ~join->const_table_map;

8248

table_map ref;

8249

8250

prev_ptr= &first_order;

8251

*simple_order= *join->join_tab[join->const_tables].on_expr_ref ? 0 : 1;

8252

8253

/* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */

8254

8255

update_depend_map(join, first_order);

8256

for (order=first_order; order ; order=order->next)

8257

{

8258

table_map order_tables=order->item[0]->used_tables();

8259

if (order->item[0]->with_sum_func)

8260

*simple_order=0; // Must do a temp table to sort

8261

else if (!(order_tables & not_const_tables))

8262

{

8263

if (order->item[0]->with_subselect)

8264

order->item[0]->val_str(&order->item[0]->str_value);

8265

continue; // skip const item

8266

}

8267

else

8268

{

8269

if (order_tables & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT))

8270

*simple_order=0;

8271

else

8272

{

8273

Item *comp_item=0;

8274

if (cond && const_expression_in_where(cond,order->item[0], &comp_item))

8275

{

8276

continue;

8277

}

8278

if ((ref=order_tables & (not_const_tables ^ first_table)))

8279

{

8280

if (!(order_tables & first_table) &&

8281

only_eq_ref_tables(join,first_order, ref))

8282

{

8283

continue;

8284

}

8285

*simple_order=0; // Must do a temp table to sort

8286

}

8287

}

8288

}

8289

if (change_list)

8290

*prev_ptr= order; // use this entry

8291

prev_ptr= &order->next;

8292

}

8293

if (change_list)

8294

*prev_ptr=0;

8295

if (prev_ptr == &first_order) // Nothing to sort/group

8296

*simple_order=1;

8297

return(first_order);

8298

}

8299

8300

8301

static int

8302

return_zero_rows(JOIN *join, select_result *result,TableList *tables,

8303

List<Item> &fields, bool send_row, uint64_t select_options,

8304

const char *info, Item *having)

8305

{

8306

if (select_options & SELECT_DESCRIBE)

8307

{

8308

select_describe(join, false, false, false, info);

8309

return(0);

8310

}

8311

8312

join->join_free();

8313

8314

if (send_row)

8315

{

8316

for (TableList *table= tables; table; table= table->next_leaf)

8317

mark_as_null_row(table->table); // All fields are NULL

8318

if (having && having->val_int() == 0)

8319

send_row=0;

8320

}

8321

if (!(result->send_fields(fields,

8322

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))

8323

{

8324

if (send_row)

8325

{

8326

List_iterator_fast<Item> it(fields);

8327

Item *item;

8328

while ((item= it++))

8329

item->no_rows_in_result();

8330

result->send_data(fields);

8331

}

8332

result->send_eof(); // Should be safe

8333

}

8334

/* Update results for FOUND_ROWS */

8335

join->thd->limit_found_rows= join->thd->examined_row_count= 0;

8336

return(0);

8337

}

8338

8339

8340

used only in JOIN::clear

8341

8342

static void clear_tables(JOIN *join)

8343

{

8344

8345

must clear only the non-const tables, as const tables

8346

are not re-calculated.

8347

8348

for (uint32_t i=join->const_tables ; i < join->tables ; i++)

8349

mark_as_null_row(join->table[i]); // All fields are NULL

8350

}

8351

8352

/*****************************************************************************

8353

Make som simple condition optimization:

8354

If there is a test 'field = const' change all refs to 'field' to 'const'

8355

Remove all dummy tests 'item = item', 'const op const'.

8356

Remove all 'item is NULL', when item can never be null!

8357

item->marker should be 0 for all items on entry

8358

Return in cond_value false if condition is impossible (1 = 2)

8359

*****************************************************************************/

8360

8361

class COND_CMP :public ilink {

8362

public:

8363

static void *operator new(size_t size)

8364

{

8365

return (void*) sql_alloc((uint) size);

8366

}

8367

static void operator delete(void *ptr __attribute__((unused)),

8368

size_t size __attribute__((unused)))

8369

{ TRASH(ptr, size); }

8370

8371

Item *and_level;

8372

Item_func *cmp_func;

8373

COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}

8374

};

8375

8376

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

8377

template class I_List<COND_CMP>;

8378

template class I_List_iterator<COND_CMP>;

8379

#endif

8380

1564

return (tab->eq_ref_table= 0);

1565

}

1566

return tab->eq_ref_table= 1;

1567

}

8381

1568

8382

1569

/**

8383

1570

Find the multiple equality predicate containing a field.

8397

1584

- Item_equal for the found multiple equality predicate if a success;

8398

1585

- NULL otherwise.

8399

1586

8400

8401

Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field,

8402

bool *inherited_fl)

1587

static Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field, bool *inherited_fl)

8403

1588

{

8404

1589

Item_equal *item= 0;

8405

1590

bool in_upper_level= false;

8420

1605

return item;

8421

1606

}

8422

1607

8423

8424

1608

/**

8425

1609

Check whether an equality can be used to build multiple equalities.

8426

1610

8447

1631

the check_equality will be called for the following equality

8448

1632

predicates a=b, b=c, b=2 and f=e.

8449

1633

- For a=b it will be called with *cond_equal=(0,[]) and will transform

8450

*cond_equal into (0,[Item_equal(a,b)]).

1634

*cond_equal into (0,[Item_equal(a,b)]).

8451

1635

- For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])

8452

1636

and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).

8453

1637

- For b=2 it will be called with *cond_equal=(ptr(CE),[])

8460

1644

the Field::eq_def method) are placed to the same multiple equalities.

8461

1645

Because of this some equality predicates are not eliminated and

8462

1646

can be used in the constant propagation procedure.

8463

We could weeken the equlity test as soon as at least one of the

8464

equal fields is to be equal to a constant. It would require a

1647

We could weeken the equlity test as soon as at least one of the

1648

equal fields is to be equal to a constant. It would require a

8465

1649

more complicated implementation: we would have to store, in

8466

1650

general case, its own constant for each fields from the multiple

8467

1651

equality. But at the same time it would allow us to get rid

8479

1663

containing just field1 and field2 is added to the existing

8480

1664

multiple equalities.

8481

1665

If the function processes the predicate of the form field1=const,

8482

it looks for a multiple equality containing field1. If found, the

1666

it looks for a multiple equality containing field1. If found, the

8483

1667

function checks the constant of the multiple equality. If the value

8484

1668

is unknown, it is setup to const. Otherwise the value is compared with

8485

1669

const and the evaluation of the equality predicate is performed.

8502

1686

@retval

8503

1687

false otherwise

8504

1688

8505

8506

static bool check_simple_equality(Item *left_item, Item *right_item,

8507

Item *item, COND_EQUAL *cond_equal)

1689

static bool check_simple_equality(Item *left_item,

1690

Item *right_item,

1691

Item *item,

1692

COND_EQUAL *cond_equal)

8508

1693

{

8509

if (left_item->type() == Item::REF_ITEM &&

8510

((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)

8511

{

8512

if (((Item_ref*)left_item)->depended_from)

8513

return false;

8514

left_item= left_item->real_item();

8515

}

8516

if (right_item->type() == Item::REF_ITEM &&

8517

((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)

8518

{

8519

if (((Item_ref*)right_item)->depended_from)

8520

return false;

8521

right_item= right_item->real_item();

8522

}

8523

1694

if (left_item->type() == Item::FIELD_ITEM &&

8524

1695

right_item->type() == Item::FIELD_ITEM &&

8525

1696

!((Item_field*)left_item)->depended_from &&

8537

1708

bool left_copyfl, right_copyfl;

8538

1709

Item_equal *left_item_equal=

8539

1710

find_item_equal(cond_equal, left_field, &left_copyfl);

8540

Item_equal *right_item_equal=

1711

Item_equal *right_item_equal=

8541

1712

find_item_equal(cond_equal, right_field, &right_copyfl);

8542

1713

8543

1714

/* As (NULL=NULL) != true we can't just remove the predicate f=f */

8544

1715

if (left_field->eq(right_field)) /* f = f */

8545

return (!(left_field->maybe_null() && !left_item_equal));

1716

return (!(left_field->maybe_null() && !left_item_equal));

8546

1717

8547

1718

if (left_item_equal && left_item_equal == right_item_equal)

8548

1719

{

8549

1720

8550

1721

The equality predicate is inference of one of the existing

8551

1722

multiple equalities, i.e the condition is already covered

8552

1723

by upper level equalities

8553

1724

8554

1725

return true;

8555

1726

}

8556

8557

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

1727

1728

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

8558

1729

item->name < subq_sj_cond_name + 64);

8559

1730

/* Copy the found multiple equalities at the current level if needed */

8560

1731

if (left_copyfl)

8575

1746

}

8576

1747

8577

1748

if (left_item_equal)

8578

{

1749

{

8579

1750

/* left item was found in the current or one of the upper levels */

8580

1751

if (! right_item_equal)

8581

1752

left_item_equal->add((Item_field *) right_item);

8590

1761

}

8591

1762

}

8592

1763

else

8593

{

1764

{

8594

1765

/* left item was not found neither the current nor in upper levels */

8595

1766

if (right_item_equal)

8596

1767

{

8598

1769

if (copy_item_name)

8599

1770

right_item_equal->name = item->name;

8600

1771

}

8601

else

1772

else

8602

1773

{

8603

1774

/* None of the fields was found in multiple equalities */

8604

1775

Item_equal *item_equal= new Item_equal((Item_field *) left_item,

8646

1817

eq_item->set_cmp_func();

8647

1818

eq_item->quick_fix_field();

8648

1819

item= eq_item;

8649

}

1820

}

8650

1821

if ((cs != ((Item_func *) item)->compare_collation()) ||

8651

1822

!cs->coll->propagate(cs, 0, 0))

8652

1823

return false;

8661

1832

}

8662

1833

if (item_equal)

8663

1834

{

8664

1835

8665

1836

The flag cond_false will be set to 1 after this, if item_equal

8666

1837

already contains a constant and its value is not equal to

8667

1838

the value of const_item.

8679

1850

return false;

8680

1851

}

8681

1852

8682

8683

1853

/**

8684

1854

Convert row equalities into a conjunction of regular equalities.

8685

1855

8692

1862

simple equality nor a row equality the item for this predicate is added

8693

1863

to eq_list.

8694

1864

8695

@param thd thread handle

1865

@param session thread handle

8696

1866

@param left_row left term of the row equality to be processed

8697

1867

@param right_row right term of the row equality to be processed

8698

1868

@param cond_equal multiple equalities that must hold together with the

8705

1875

@retval

8706

1876

false otherwise

8707

1877

8708

8709

static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,

8710

COND_EQUAL *cond_equal, List<Item>* eq_list)

8711

{

1878

static bool check_row_equality(Session *session,

1879

Item *left_row,

1880

Item_row *right_row,

1881

COND_EQUAL *cond_equal,

1882

List<Item>* eq_list)

1883

{

8712

1884

uint32_t n= left_row->cols();

8713

1885

for (uint32_t i= 0 ; i < n; i++)

8714

1886

{

8718

1890

if (left_item->type() == Item::ROW_ITEM &&

8719

1891

right_item->type() == Item::ROW_ITEM)

8720

1892

{

8721

is_converted= check_row_equality(thd,

1893

is_converted= check_row_equality(session,

8722

1894

(Item_row *) left_item,

8723

1895

(Item_row *) right_item,

8724

1896

cond_equal, eq_list);

8725

1897

if (!is_converted)

8726

thd->lex->current_select->cond_count++;

1898

session->lex->current_select->cond_count++;

8727

1899

}

8728

1900

else

8729

{

1901

{

8730

1902

is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

8731

thd->lex->current_select->cond_count++;

8732

}

8733

1903

session->lex->current_select->cond_count++;

1904

}

1905

8734

1906

if (!is_converted)

8735

1907

{

8736

1908

Item_func_eq *eq_item;

8744

1916

return true;

8745

1917

}

8746

1918

8747

8748

1919

/**

8749

1920

Eliminate row equalities and form multiple equalities predicates.

8750

1921

8759

1930

equalities which are treated in the same way as original equality

8760

1931

predicates.

8761

1932

8762

@param thd thread handle

1933

@param session thread handle

8763

1934

@param item predicate to process

8764

1935

@param cond_equal multiple equalities that must hold together with the

8765

1936

predicate

8774

1945

or, if the equality is neither a simple one nor a row equality,

8775

1946

or, if the procedure fails by a fatal error.

8776

1947

8777

8778

static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,

8779

List<Item> *eq_list)

1948

static bool check_equality(Session *session, Item *item, COND_EQUAL *cond_equal, List<Item> *eq_list)

8780

1949

{

8781

1950

if (item->type() == Item::FUNC_ITEM &&

8782

1951

((Item_func*) item)->functype() == Item_func::EQ_FUNC)

8787

1956

if (left_item->type() == Item::ROW_ITEM &&

8788

1957

right_item->type() == Item::ROW_ITEM)

8789

1958

{

8790

thd->lex->current_select->cond_count--;

8791

return check_row_equality(thd,

1959

session->lex->current_select->cond_count--;

1960

return check_row_equality(session,

8792

1961

(Item_row *) left_item,

8793

1962

(Item_row *) right_item,

8794

1963

cond_equal, eq_list);

8795

1964

}

8796

else

1965

else

8797

1966

return check_simple_equality(left_item, right_item, item, cond_equal);

8798

}

1967

}

8799

1968

return false;

8800

1969

}

8801

1970

8802

8803

1971

/**

8804

1972

Replace all equality predicates in a condition by multiple equality items.

8805

1973

8806

1974

At each 'and' level the function detects items for equality predicates

8807

1975

and replaced them by a set of multiple equality items of class Item_equal,

8808

taking into account inherited equalities from upper levels.

1976

taking into account inherited equalities from upper levels.

8809

1977

If an equality predicate is used not in a conjunction it's just

8810

1978

replaced by a multiple equality predicate.

8811

1979

For each 'and' level the function set a pointer to the inherited

8812

1980

multiple equalities in the cond_equal field of the associated

8813

object of the type Item_cond_and.

1981

object of the type Item_cond_and.

8814

1982

The function also traverses the cond tree and and for each field reference

8815

1983

sets a pointer to the multiple equality item containing the field, if there

8816

1984

is any. If this multiple equality equates fields to a constant the

8817

function replaces the field reference by the constant in the cases

1985

function replaces the field reference by the constant in the cases

8818

1986

when the field is not of a string type or when the field reference is

8819

1987

just an argument of a comparison predicate.

8820

The function also determines the maximum number of members in

1988

The function also determines the maximum number of members in

8821

1989

equality lists of each Item_cond_and object assigning it to

8822

thd->lex->current_select->max_equal_elems.

1990

session->lex->current_select->max_equal_elems.

8823

1991

8824

1992

@note

8825

1993

Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

8831

1999

in a conjuction for a minimal set of multiple equality predicates.

8832

2000

This set can be considered as a canonical representation of the

8833

2001

sub-conjunction of the equality predicates.

8834

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

2002

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

8835

2003

(=(t1.a,t2.b,t3.c) AND t2.b>5), not by

8836

2004

(=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);

8837

2005

while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by

8842

2010

The function performs the substitution in a recursive descent by

8843

2011

the condtion tree, passing to the next AND level a chain of multiple

8844

2012

equality predicates which have been built at the upper levels.

8845

The Item_equal items built at the level are attached to other

2013

The Item_equal items built at the level are attached to other

8846

2014

non-equality conjucts as a sublist. The pointer to the inherited

8847

2015

multiple equalities is saved in the and condition object (Item_cond_and).

8848

This chain allows us for any field reference occurence easyly to find a

2016

This chain allows us for any field reference occurence easyly to find a

8849

2017

multiple equality that must be held for this occurence.

8850

2018

For each AND level we do the following:

8851

2019

- scan it for all equality predicate (=) items

8852

2020

- join them into disjoint Item_equal() groups

8853

- process the included OR conditions recursively to do the same for

8854

lower AND levels.

2021

- process the included OR conditions recursively to do the same for

2022

lower AND levels.

8855

2023

8856

2024

We need to do things in this order as lower AND levels need to know about

8857

2025

all possible Item_equal objects in upper levels.

8858

2026

8859

@param thd thread handle

2027

@param session thread handle

8860

2028

@param cond condition(expression) where to make replacement

8861

2029

@param inherited path to all inherited multiple equality items

8862

2030

8863

2031

@return

8864

2032

pointer to the transformed condition

8865

2033

8866

8867

static COND *build_equal_items_for_cond(THD *thd, COND *cond,

8868

COND_EQUAL *inherited)

2034

static COND *build_equal_items_for_cond(Session *session, COND *cond, COND_EQUAL *inherited)

8869

2035

{

8870

2036

Item_equal *item_equal;

8871

2037

COND_EQUAL cond_equal;

8877

2043

bool and_level= ((Item_cond*) cond)->functype() ==

8878

2044

Item_func::COND_AND_FUNC;

8879

2045

List<Item> *args= ((Item_cond*) cond)->argument_list();

8880

2046

8881

2047

List_iterator<Item> li(*args);

8882

2048

Item *item;

8883

2049

8886

2052

8887

2053

Retrieve all conjucts of this level detecting the equality

8888

2054

that are subject to substitution by multiple equality items and

8889

removing each such predicate from the conjunction after having

2055

removing each such predicate from the conjunction after having

8890

2056

found/created a multiple equality whose inference the predicate is.

8891

2057

8892

2058

while ((item= li++))

8893

2059

{

8894

2060

8896

2062

structure here because it's restored before each

8897

2063

re-execution of any prepared statement/stored procedure.

8898

2064

8899

if (check_equality(thd, item, &cond_equal, &eq_list))

2065

if (check_equality(session, item, &cond_equal, &eq_list))

8900

2066

li.remove();

8901

2067

}

8902

2068

8905

2071

{

8906

2072

item_equal->fix_length_and_dec();

8907

2073

item_equal->update_used_tables();

8908

set_if_bigger(thd->lex->current_select->max_equal_elems,

8909

item_equal->members());

2074

set_if_bigger(session->lex->current_select->max_equal_elems,

2075

item_equal->members());

8910

2076

}

8911

2077

8912

2078

((Item_cond_and*)cond)->cond_equal= cond_equal;

8918

2084

8919

2085

li.rewind();

8920

2086

while ((item= li++))

8921

{

2087

{

8922

2088

Item *new_item;

8923

if ((new_item= build_equal_items_for_cond(thd, item, inherited)) != item)

2089

if ((new_item= build_equal_items_for_cond(session, item, inherited)) != item)

8924

2090

{

8925

2091

/* This replacement happens only for standalone equalities */

8926

2092

8948

2114

(b=5) and (a=c) are standalone equalities.

8949

2115

In general we can't leave alone standalone eqalities:

8950

2116

for WHERE a=b AND c=d AND (b=c OR d=5)

8951

b=c is replaced by =(a,b,c,d).

2117

b=c is replaced by =(a,b,c,d).

8952

2118

8953

if (check_equality(thd, cond, &cond_equal, &eq_list))

2119

if (check_equality(session, cond, &cond_equal, &eq_list))

8954

2120

{

8955

2121

int n= cond_equal.current_level.elements + eq_list.elements;

8956

2122

if (n == 0)

8961

2127

{

8962

2128

item_equal->fix_length_and_dec();

8963

2129

item_equal->update_used_tables();

8964

}

2130

}

8965

2131

else

8966

2132

item_equal= (Item_equal *) eq_list.pop();

8967

set_if_bigger(thd->lex->current_select->max_equal_elems,

8968

item_equal->members());

2133

set_if_bigger(session->lex->current_select->max_equal_elems,

2134

item_equal->members());

8969

2135

return item_equal;

8970

2136

}

8971

2137

else

8972

2138

{

8973

2139

8974

2140

Here a new AND level must be created. It can happen only

8975

2141

when a row equality is processed as a standalone predicate.

8976

2142

8977

2143

Item_cond_and *and_cond= new Item_cond_and(eq_list);

8978

2144

and_cond->quick_fix_field();

8979

2145

List<Item> *args= and_cond->argument_list();

8982

2148

{

8983

2149

item_equal->fix_length_and_dec();

8984

2150

item_equal->update_used_tables();

8985

set_if_bigger(thd->lex->current_select->max_equal_elems,

8986

item_equal->members());

2151

set_if_bigger(session->lex->current_select->max_equal_elems,

2152

item_equal->members());

8987

2153

}

8988

2154

and_cond->cond_equal= cond_equal;

8989

2155

args->concat((List<Item> *)&cond_equal.current_level);

8990

2156

8991

2157

return and_cond;

8992

2158

}

8993

2159

}

8994

2160

8995

2161

For each field reference in cond, not from equal item predicates,

8996

2162

set a pointer to the multiple equality it belongs to (if there is any)

8997

2163

as soon the field is not of a string type or the field reference is

8998

an argument of a comparison predicate.

8999

2164

an argument of a comparison predicate.

2165

9000

2166

unsigned char *is_subst_valid= (unsigned char *) 1;

9001

2167

cond= cond->compile(&Item::subst_argument_checker,

9002

&is_subst_valid,

2168

&is_subst_valid,

9003

2169

&Item::equal_fields_propagator,

9004

2170

(unsigned char *) inherited);

9005

2171

cond->update_used_tables();

9007

2173

return cond;

9008

2174

}

9009

2175

9010

9011

2176

/**

9012

2177

Build multiple equalities for a condition and all on expressions that

9013

2178

inherit these multiple equalities.

9053

2218

SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a

9054

2219

WHERE t1.a=t2.a

9055

2220

@endcode

9056

that is equivalent to:

2221

that is equivalent to:

9057

2222

@code

9058

2223

SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1

9059

2224

WHERE t1.a=t2.a

9060

2225

@endcode

9061

2226

Thus, applying equalities from the where condition we basically

9062

2227

can get more freedom in performing join operations.

9063

Althogh we don't use this property now, it probably makes sense to use

9064

it in the future.

9065

@param thd Thread handler

2228

Althogh we don't use this property now, it probably makes sense to use

2229

it in the future.

2230

@param session Thread handler

9066

2231

@param cond condition to build the multiple equalities for

9067

2232

@param inherited path to all inherited multiple equality items

9068

2233

@param join_list list of join tables to which the condition

9073

2238

@return

9074

2239

pointer to the transformed condition containing multiple equalities

9075

2240

9076

9077

static COND *build_equal_items(THD *thd, COND *cond,

2241

static COND *build_equal_items(Session *session, COND *cond,

9078

2242

COND_EQUAL *inherited,

9079

2243

List<TableList> *join_list,

9080

2244

COND_EQUAL **cond_equal_ref)

9081

2245

{

9082

2246

COND_EQUAL *cond_equal= 0;

9083

2247

9084

if (cond)

2248

if (cond)

9085

2249

{

9086

cond= build_equal_items_for_cond(thd, cond, inherited);

2250

cond= build_equal_items_for_cond(session, cond, inherited);

9087

2251

cond->update_used_tables();

9088

2252

if (cond->type() == Item::COND_ITEM &&

9089

2253

((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

9117

2281

We can modify table->on_expr because its old value will

9118

2282

be restored before re-execution of PS/SP.

9119

2283

9120

table->on_expr= build_equal_items(thd, table->on_expr, inherited,

2284

table->on_expr= build_equal_items(session, table->on_expr, inherited,

9121

2285

nested_join_list,

9122

2286

&table->cond_equal);

9123

2287

}

9125

2289

}

9126

2290

9127

2291

return cond;

9128

}

9129

2292

}

9130

2293

9131

2294

/**

9132

2295

Compare field items by table order in the execution plan.

9133

2296

9134

2297

field1 considered as better than field2 if the table containing

9135

field1 is accessed earlier than the table containing field2.

2298

field1 is accessed earlier than the table containing field2.

9136

2299

The function finds out what of two fields is better according

9137

2300

this criteria.

9138

2301

9147

2310

@retval

9148

2311

0 otherwise

9149

2312

9150

9151

2313

static int compare_fields_by_table_order(Item_field *field1,

9152

Item_field *field2,

9153

void *table_join_idx)

2314

Item_field *field2,

2315

void *table_join_idx)

9154

2316

{

9155

2317

int cmp= 0;

9156

2318

bool outer_ref= 0;

9157

2319

if (field2->used_tables() & OUTER_REF_TABLE_BIT)

9158

{

2320

{

9159

2321

outer_ref= 1;

9160

2322

cmp= -1;

9161

2323

}

9166

2328

}

9167

2329

if (outer_ref)

9168

2330

return cmp;

9169

JOIN_TAB **idx= (JOIN_TAB **) table_join_idx;

2331

JoinTable **idx= (JoinTable **) table_join_idx;

9170

2332

cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];

9171

2333

return cmp < 0 ? -1 : (cmp ? 1 : 0);

9172

2334

}

9173

2335

9174

9175

2336

/**

9176

2337

Generate minimal set of simple equalities equivalent to a multiple equality.

9177

2338

9211

2372

a pointer to the simple generated equality, if success.

9212

2373

- 0, otherwise.

9213

2374

9214

9215

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,

9216

Item_equal *item_equal)

2375

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels, Item_equal *item_equal)

9217

2376

{

9218

2377

List<Item> eq_list;

9219

2378

Item_func_eq *eq_item= 0;

9220

2379

if (((Item *) item_equal)->const_item() && !item_equal->val_int())

9221

return new Item_int((int64_t) 0,1);

2380

return new Item_int((int64_t) 0,1);

9222

2381

Item *item_const= item_equal->get_const();

9223

2382

Item_equal_iterator it(*item_equal);

9224

2383

Item *head;

9235

2394

Item_equal *upper= item_field->find_item_equal(upper_levels);

9236

2395

Item_field *item= item_field;

9237

2396

if (upper)

9238

{

2397

{

9239

2398

if (item_const && upper->get_const())

9240

2399

item= 0;

9241

2400

else

9279

2438

9280

2439

cond->quick_fix_field();

9281

2440

cond->update_used_tables();

9282

2441

9283

2442

return cond;

9284

2443

}

9285

2444

9286

9287

2445

/**

9288

2446

Substitute every field reference in a condition by the best equal field

9289

2447

and eliminate all multiple equality predicates.

9292

2450

multiple equality predicate it sorts the field references in it

9293

2451

according to the order of tables specified by the table_join_idx

9294

2452

parameter. Then it eliminates the multiple equality predicate it

9295

replacing it by the conjunction of simple equality predicates

2453

replacing it by the conjunction of simple equality predicates

9296

2454

equating every field from the multiple equality to the first

9297

2455

field in it, or to the constant, if there is any.

9298

2456

After this the function retrieves all other conjuncted

9311

2469

@return

9312

2470

The transformed condition

9313

2471

9314

9315

static COND* substitute_for_best_equal_field(COND *cond,

9316

COND_EQUAL *cond_equal,

9317

void *table_join_idx)

2472

COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx)

9318

2473

{

9319

2474

Item_equal *item_equal;

9320

2475

9329

2484

cond_equal= &((Item_cond_and *) cond)->cond_equal;

9330

2485

cond_list->disjoin((List<Item> *) &cond_equal->current_level);

9331

2486

9332

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2487

List_iterator_fast<Item_equal> it(cond_equal->current_level);

9333

2488

while ((item_equal= it++))

9334

2489

{

9335

2490

item_equal->sort(&compare_fields_by_table_order, table_join_idx);

9336

2491

}

9337

2492

}

9338

2493

9339

2494

List_iterator<Item> li(*cond_list);

9340

2495

Item *item;

9341

2496

while ((item= li++))

9368

2523

cond= new Item_int((int32_t)cond->val_bool());

9369

2524

9370

2525

}

9371

else if (cond->type() == Item::FUNC_ITEM &&

2526

else if (cond->type() == Item::FUNC_ITEM &&

9372

2527

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

9373

2528

{

9374

2529

item_equal= (Item_equal *) cond;

9382

2537

return cond;

9383

2538

}

9384

2539

9385

9386

2540

/**

9387

2541

Check appearance of new constant items in multiple equalities

9388

2542

of a condition after reading a constant table.

9395

2549

@param cond condition whose multiple equalities are to be checked

9396

2550

@param table constant table that has been read

9397

2551

9398

9399

static void update_const_equal_items(COND *cond, JOIN_TAB *tab)

2552

static void update_const_equal_items(COND *cond, JoinTable *tab)

9400

2553

{

9401

2554

if (!(cond->used_tables() & tab->table->map))

9402

2555

return;

9403

2556

9404

2557

if (cond->type() == Item::COND_ITEM)

9405

2558

{

9406

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

2559

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

9407

2560

List_iterator_fast<Item> li(*cond_list);

9408

2561

Item *item;

9409

2562

while ((item= li++))

9410

2563

update_const_equal_items(item, tab);

9411

2564

}

9412

else if (cond->type() == Item::FUNC_ITEM &&

2565

else if (cond->type() == Item::FUNC_ITEM &&

9413

2566

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

9414

2567

{

9415

2568

Item_equal *item_equal= (Item_equal *) cond;

9423

2576

while ((item_field= it++))

9424

2577

{

9425

2578

Field *field= item_field->field;

9426

JOIN_TAB *stat= field->table->reginfo.join_tab;

2579

JoinTable *stat= field->table->reginfo.join_tab;

9427

2580

key_map possible_keys= field->key_start;

9428

possible_keys.intersect(field->table->keys_in_use_for_query);

9429

stat[0].const_keys.merge(possible_keys);

2581

possible_keys&= field->table->keys_in_use_for_query;

2582

stat[0].const_keys|= possible_keys;

9430

2583

9431

2584

9432

For each field in the multiple equality (for which we know that it

9433

is a constant) we have to find its corresponding key part, and set

2585

For each field in the multiple equality (for which we know that it

2586

is a constant) we have to find its corresponding key part, and set

9434

2587

that key part in const_key_parts.

9435

9436

if (!possible_keys.is_clear_all())

2588

2589

if (possible_keys.any())

9437

2590

{

9438

Table *tab= field->table;

9439

KEYUSE *use;

9440

for (use= stat->keyuse; use && use->table == tab; use++)

9441

if (possible_keys.is_set(use->key) &&

9442

tab->key_info[use->key].key_part[use->keypart].field ==

2591

Table *field_tab= field->table;

2592

optimizer::KeyUse *use;

2593

for (use= stat->keyuse; use && use->getTable() == field_tab; use++)

2594

if (possible_keys.test(use->getKey()) &&

2595

field_tab->key_info[use->getKey()].key_part[use->getKeypart()].field ==

9443

2596

field)

9444

tab->const_key_parts[use->key]|= use->keypart_map;

2597

field_tab->const_key_parts[use->getKey()]|= use->getKeypartMap();

9445

2598

}

9446

2599

}

9447

2600

}

9448

2601

}

9449

2602

}

9450

2603

9451

9452

2604

9453

2605

change field = field to field = const for each found field = const in the

9454

2606

and_level

9455

2607

9456

9457

static void

9458

change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,

9459

Item *and_father, Item *cond,

9460

Item *field, Item *value)

2608

static void change_cond_ref_to_const(Session *session,

2609

vector<COND_CMP>& save_list,

2610

Item *and_father,

2611

Item *cond,

2612

Item *field,

2613

Item *value)

9461

2614

{

9462

2615

if (cond->type() == Item::COND_ITEM)

9463

2616

{

9464

bool and_level= ((Item_cond*) cond)->functype() ==

9465

Item_func::COND_AND_FUNC;

2617

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9466

2618

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

9467

2619

Item *item;

9468

2620

while ((item=li++))

9469

change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,

9470

field, value);

2621

change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

9471

2622

return;

9472

2623

}

9473

2624

if (cond->eq_cmp_result() == Item::COND_OK)

9487

2638

{

9488

2639

Item *tmp=value->clone_item();

9489

2640

tmp->collation.set(right_item->collation);

9490

2641

9491

2642

if (tmp)

9492

2643

{

9493

thd->change_item_tree(args + 1, tmp);

2644

session->change_item_tree(args + 1, tmp);

9494

2645

func->update_used_tables();

9495

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9496

&& and_father != cond && !left_item->const_item())

2646

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2647

and_father != cond &&

2648

! left_item->const_item())

9497

2649

{

9498

cond->marker=1;

9499

COND_CMP *tmp2;

9500

if ((tmp2=new COND_CMP(and_father,func)))

9501

save_list->push_back(tmp2);

2650

cond->marker=1;

2651

save_list.push_back( COND_CMP(and_father, func) );

9502

2652

}

9503

2653

func->set_cmp_func();

9504

2654

}

9511

2661

{

9512

2662

Item *tmp= value->clone_item();

9513

2663

tmp->collation.set(left_item->collation);

9514

2664

9515

2665

if (tmp)

9516

2666

{

9517

thd->change_item_tree(args, tmp);

2667

session->change_item_tree(args, tmp);

9518

2668

value= tmp;

9519

2669

func->update_used_tables();

9520

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9521

&& and_father != cond && !right_item->const_item())

2670

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2671

and_father != cond &&

2672

! right_item->const_item())

9522

2673

{

9523

2674

args[0]= args[1]; // For easy check

9524

thd->change_item_tree(args + 1, value);

9525

cond->marker=1;

9526

COND_CMP *tmp2;

9527

if ((tmp2=new COND_CMP(and_father,func)))

9528

save_list->push_back(tmp2);

2675

session->change_item_tree(args + 1, value);

2676

cond->marker=1;

2677

save_list.push_back( COND_CMP(and_father, func) );

9529

2678

}

9530

2679

func->set_cmp_func();

9531

2680

}

9540

2689

@return

9541

2690

new conditions

9542

2691

9543

9544

static Item *remove_additional_cond(Item* conds)

2692

Item *remove_additional_cond(Item* conds)

9545

2693

{

9546

2694

if (conds->name == in_additional_cond)

9547

2695

return 0;

9564

2712

return conds;

9565

2713

}

9566

2714

9567

static void

9568

propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,

9569

COND *and_father, COND *cond)

2715

static void propagate_cond_constants(Session *session,

2716

vector<COND_CMP>& save_list,

2717

COND *and_father,

2718

COND *cond)

9570

2719

{

9571

2720

if (cond->type() == Item::COND_ITEM)

9572

2721

{

9573

bool and_level= ((Item_cond*) cond)->functype() ==

9574

Item_func::COND_AND_FUNC;

2722

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9575

2723

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

9576

2724

Item *item;

9577

I_List<COND_CMP> save;

2725

vector<COND_CMP> save;

9578

2726

while ((item=li++))

9579

2727

{

9580

propagate_cond_constants(thd, &save,and_level ? cond : item, item);

2728

propagate_cond_constants(session, save, and_level ? cond : item, item);

9581

2729

}

9582

2730

if (and_level)

9583

{ // Handle other found items

9584

I_List_iterator<COND_CMP> cond_itr(save);

9585

COND_CMP *cond_cmp;

9586

while ((cond_cmp=cond_itr++))

2731

{

2732

// Handle other found items

2733

for (vector<COND_CMP>::iterator iter= save.begin(); iter != save.end(); ++iter)

9587

2734

{

9588

Item **args= cond_cmp->cmp_func->arguments();

2735

Item **args= iter->cmp_func->arguments();

9589

2736

if (!args[0]->const_item())

9590

change_cond_ref_to_const(thd, &save,cond_cmp->and_level,

9591

cond_cmp->and_level, args[0], args[1]);

2737

{

2738

change_cond_ref_to_const( session, save, iter->and_level,

2739

iter->and_level, args[0], args[1] );

2740

}

9592

2741

}

9593

2742

}

9594

2743

}

9595

2744

else if (and_father != cond && !cond->marker) // In a AND group

9596

2745

{

9597

2746

if (cond->type() == Item::FUNC_ITEM &&

9598

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

9599

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

2747

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

2748

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

9600

2749

{

9601

2750

Item_func_eq *func=(Item_func_eq*) cond;

9602

2751

Item **args= func->arguments();

9605

2754

if (!(left_const && right_const) &&

9606

2755

args[0]->result_type() == args[1]->result_type())

9607

2756

{

9608

if (right_const)

9609

{

9610

resolve_const_item(thd, &args[1], args[0]);

9611

func->update_used_tables();

9612

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9613

args[0], args[1]);

9614

}

9615

else if (left_const)

9616

{

9617

resolve_const_item(thd, &args[0], args[1]);

9618

func->update_used_tables();

9619

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9620

args[1], args[0]);

9621

}

9622

}

9623

}

9624

}

9625

}

9626

9627

9628

/**

9629

Simplify joins replacing outer joins by inner joins whenever it's

9630

possible.

9631

9632

The function, during a retrieval of join_list, eliminates those

9633

outer joins that can be converted into inner join, possibly nested.

9634

It also moves the on expressions for the converted outer joins

9635

and from inner joins to conds.

9636

The function also calculates some attributes for nested joins:

9637

- used_tables

9638

- not_null_tables

9639

- dep_tables.

9640

- on_expr_dep_tables

9641

The first two attributes are used to test whether an outer join can

9642

be substituted for an inner join. The third attribute represents the

9643

relation 'to be dependent on' for tables. If table t2 is dependent

9644

on table t1, then in any evaluated execution plan table access to

9645

table t2 must precede access to table t2. This relation is used also

9646

to check whether the query contains invalid cross-references.

9647

The forth attribute is an auxiliary one and is used to calculate

9648

dep_tables.

9649

As the attribute dep_tables qualifies possibles orders of tables in the

9650

execution plan, the dependencies required by the straight join

9651

modifiers are reflected in this attribute as well.

9652

The function also removes all braces that can be removed from the join

9653

expression without changing its meaning.

9654

9655

@note

9656

An outer join can be replaced by an inner join if the where condition

9657

or the on expression for an embedding nested join contains a conjunctive

9658

predicate rejecting null values for some attribute of the inner tables.

9659

9660

E.g. in the query:

9661

@code

9662

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9663

@endcode

9664

the predicate t2.b < 5 rejects nulls.

9665

The query is converted first to:

9666

@code

9667

SELECT * FROM t1 INNER JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9668

@endcode

9669

then to the equivalent form:

9670

@code

9671

SELECT * FROM t1, t2 ON t2.a=t1.a WHERE t2.b < 5 AND t2.a=t1.a

9672

@endcode

9673

9674

9675

Similarly the following query:

9676

@code

9677

SELECT * from t1 LEFT JOIN (t2, t3) ON t2.a=t1.a t3.b=t1.b

9678

WHERE t2.c < 5

9679

@endcode

9680

is converted to:

9681

@code

9682

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a t3.b=t1.b

9683

9684

@endcode

9685

9686

One conversion might trigger another:

9687

@code

9688

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a

9689

LEFT JOIN t3 ON t3.b=t2.b

9690

WHERE t3 IS NOT NULL =>

9691

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a, t3

9692

WHERE t3 IS NOT NULL AND t3.b=t2.b =>

9693

SELECT * FROM t1, t2, t3

9694

WHERE t3 IS NOT NULL AND t3.b=t2.b AND t2.a=t1.a

9695

@endcode

9696

9697

The function removes all unnecessary braces from the expression

9698

produced by the conversions.

9699

E.g.

9700

@code

9701

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9702

@endcode

9703

finally is converted to:

9704

@code

9705

SELECT * FROM t1, t2, t3 WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9706

9707

@endcode

9708

9709

9710

It also will remove braces from the following queries:

9711

@code

9712

SELECT * from (t1 LEFT JOIN t2 ON t2.a=t1.a) LEFT JOIN t3 ON t3.b=t2.b

9713

SELECT * from (t1, (t2,t3)) WHERE t1.a=t2.a AND t2.b=t3.b.

9714

@endcode

9715

9716

The benefit of this simplification procedure is that it might return

9717

a query for which the optimizer can evaluate execution plan with more

9718

join orders. With a left join operation the optimizer does not

9719

consider any plan where one of the inner tables is before some of outer

9720

tables.

9721

9722

IMPLEMENTATION

9723

The function is implemented by a recursive procedure. On the recursive

9724

ascent all attributes are calculated, all outer joins that can be

9725

converted are replaced and then all unnecessary braces are removed.

9726

As join list contains join tables in the reverse order sequential

9727

elimination of outer joins does not require extra recursive calls.

9728

9729

SEMI-JOIN NOTES

9730

Remove all semi-joins that have are within another semi-join (i.e. have

9731

an "ancestor" semi-join nest)

9732

9733

EXAMPLES

9734

Here is an example of a join query with invalid cross references:

9735

@code

9736

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t3.a LEFT JOIN t3 ON t3.b=t1.b

9737

@endcode

9738

9739

@param join reference to the query info

9740

@param join_list list representation of the join to be converted

9741

@param conds conditions to add on expressions for converted joins

9742

@param top true <=> conds is the where condition

9743

9744

@return

9745

- The new condition, if success

9746

- 0, otherwise

9747

9748

9749

static COND *

9750

simplify_joins(JOIN *join, List<TableList> *join_list, COND *conds, bool top,

9751

bool in_sj)

9752

{

9753

TableList *table;

9754

nested_join_st *nested_join;

9755

TableList *prev_table= 0;

9756

List_iterator<TableList> li(*join_list);

9757

9758

9759

Try to simplify join operations from join_list.

9760

The most outer join operation is checked for conversion first.

9761

9762

while ((table= li++))

9763

{

9764

table_map used_tables;

9765

table_map not_null_tables= (table_map) 0;

9766

9767

if ((nested_join= table->nested_join))

9768

{

9769

9770

If the element of join_list is a nested join apply

9771

the procedure to its nested join list first.

9772

9773

if (table->on_expr)

9774

{

9775

Item *expr= table->on_expr;

9776

9777

If an on expression E is attached to the table,

9778

check all null rejected predicates in this expression.

9779

If such a predicate over an attribute belonging to

9780

an inner table of an embedded outer join is found,

9781

the outer join is converted to an inner join and

9782

the corresponding on expression is added to E.

9783

9784

expr= simplify_joins(join, &nested_join->join_list,

9785

expr, false, in_sj || table->sj_on_expr);

9786

9787

if (!table->prep_on_expr || expr != table->on_expr)

9788

{

9789

assert(expr);

9790

9791

table->on_expr= expr;

9792

table->prep_on_expr= expr->copy_andor_structure(join->thd);

9793

}

9794

}

9795

nested_join->used_tables= (table_map) 0;

9796

nested_join->not_null_tables=(table_map) 0;

9797

conds= simplify_joins(join, &nested_join->join_list, conds, top,

9798

in_sj || table->sj_on_expr);

9799

used_tables= nested_join->used_tables;

9800

not_null_tables= nested_join->not_null_tables;

9801

}

9802

else

9803

{

9804

if (!table->prep_on_expr)

9805

table->prep_on_expr= table->on_expr;

9806

used_tables= table->table->map;

9807

if (conds)

9808

not_null_tables= conds->not_null_tables();

9809

}

9810

9811

if (table->embedding)

9812

{

9813

table->embedding->nested_join->used_tables|= used_tables;

9814

table->embedding->nested_join->not_null_tables|= not_null_tables;

9815

}

9816

9817

if (!table->outer_join || (used_tables & not_null_tables))

9818

{

9819

9820

For some of the inner tables there are conjunctive predicates

9821

that reject nulls => the outer join can be replaced by an inner join.

9822

9823

table->outer_join= 0;

9824

if (table->on_expr)

9825

{

9826

/* Add ON expression to the WHERE or upper-level ON condition. */

9827

if (conds)

9828

{

9829

conds= and_conds(conds, table->on_expr);

9830

conds->top_level_item();

9831

/* conds is always a new item as both cond and on_expr existed */

9832

assert(!conds->fixed);

9833

conds->fix_fields(join->thd, &conds);

9834

}

9835

else

9836

conds= table->on_expr;

9837

table->prep_on_expr= table->on_expr= 0;

9838

}

9839

}

9840

9841

if (!top)

9842

continue;

9843

9844

9845

Only inner tables of non-convertible outer joins

9846

remain with on_expr.

9847

9848

if (table->on_expr)

9849

{

9850

table->dep_tables|= table->on_expr->used_tables();

9851

if (table->embedding)

9852

{

9853

table->dep_tables&= ~table->embedding->nested_join->used_tables;

9854

9855

Embedding table depends on tables used

9856

in embedded on expressions.

9857

9858

table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();

9859

}

9860

else

9861

table->dep_tables&= ~table->table->map;

9862

}

9863

9864

if (prev_table)

9865

{

9866

/* The order of tables is reverse: prev_table follows table */

9867

if (prev_table->straight)

9868

prev_table->dep_tables|= used_tables;

9869

if (prev_table->on_expr)

9870

{

9871

prev_table->dep_tables|= table->on_expr_dep_tables;

9872

table_map prev_used_tables= prev_table->nested_join ?

9873

prev_table->nested_join->used_tables :

9874

prev_table->table->map;

9875

9876

If on expression contains only references to inner tables

9877

we still make the inner tables dependent on the outer tables.

9878

It would be enough to set dependency only on one outer table

9879

for them. Yet this is really a rare case.

9880

9881

if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))

9882

prev_table->dep_tables|= used_tables;

9883

}

9884

}

9885

prev_table= table;

9886

}

9887

9888

9889

Flatten nested joins that can be flattened.

9890

no ON expression and not a semi-join => can be flattened.

9891

9892

li.rewind();

9893

while ((table= li++))

9894

{

9895

nested_join= table->nested_join;

9896

if (table->sj_on_expr && !in_sj)

9897

{

9898

9899

If this is a semi-join that is not contained within another semi-join,

9900

leave it intact (otherwise it is flattened)

9901

9902

join->select_lex->sj_nests.push_back(table);

9903

}

9904

else if (nested_join && !table->on_expr)

9905

{

9906

TableList *tbl;

9907

List_iterator<TableList> it(nested_join->join_list);

9908

while ((tbl= it++))

9909

{

9910

tbl->embedding= table->embedding;

9911

tbl->join_list= table->join_list;

9912

}

9913

li.replace(nested_join->join_list);

9914

}

9915

}

9916

return(conds);

9917

}

9918

9919

9920

/**

9921

Assign each nested join structure a bit in nested_join_map.

9922

9923

Assign each nested join structure (except "confluent" ones - those that

9924

embed only one element) a bit in nested_join_map.

9925

9926

@param join Join being processed

9927

@param join_list List of tables

9928

@param first_unused Number of first unused bit in nested_join_map before the

9929

call

9930

9931

@note

9932

This function is called after simplify_joins(), when there are no

9933

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

9934

we will not run out of bits in nested_join_map.

9935

9936

@return

9937

First unused bit in nested_join_map after the call.

9938

9939

9940

static uint32_t build_bitmap_for_nested_joins(List<TableList> *join_list,

9941

uint32_t first_unused)

9942

{

9943

List_iterator<TableList> li(*join_list);

9944

TableList *table;

9945

while ((table= li++))

9946

{

9947

nested_join_st *nested_join;

9948

if ((nested_join= table->nested_join))

9949

{

9950

9951

It is guaranteed by simplify_joins() function that a nested join

9952

that has only one child is either

9953

- a single-table view (the child is the underlying table), or

9954

- a single-table semi-join nest

9955

9956

We don't assign bits to such sj-nests because

9957

1. it is redundant (a "sequence" of one table cannot be interleaved

9958

with anything)

9959

2. we could run out bits in nested_join_map otherwise.

9960

9961

if (nested_join->join_list.elements != 1)

9962

{

9963

/* Don't assign bits to sj-nests */

9964

if (table->on_expr)

9965

nested_join->nj_map= (nested_join_map) 1 << first_unused++;

9966

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

9967

first_unused);

9968

}

9969

}

9970

}

9971

return(first_unused);

9972

}

9973

9974

9975

/**

9976

Set nested_join_st::counter=0 in all nested joins in passed list.

9977

9978

Recursively set nested_join_st::counter=0 for all nested joins contained in

9979

the passed join_list.

9980

9981

@param join_list List of nested joins to process. It may also contain base

9982

tables which will be ignored.

9983

9984

9985

static void reset_nj_counters(List<TableList> *join_list)

9986

{

9987

List_iterator<TableList> li(*join_list);

9988

TableList *table;

9989

while ((table= li++))

9990

{

9991

nested_join_st *nested_join;

9992

if ((nested_join= table->nested_join))

9993

{

9994

nested_join->counter_= 0;

9995

reset_nj_counters(&nested_join->join_list);

9996

}

9997

}

9998

return;

9999

}

10000

2757

if (right_const)

2758

{

2759

resolve_const_item(session, &args[1], args[0]);

2760

func->update_used_tables();

2761

change_cond_ref_to_const(session, save_list, and_father, and_father,

2762

args[0], args[1]);

2763

}

2764

else if (left_const)

2765

{

2766

resolve_const_item(session, &args[0], args[1]);

2767

func->update_used_tables();

2768

change_cond_ref_to_const(session, save_list, and_father, and_father,

2769

args[1], args[0]);

2770

}

2771

}

2772

}

2773

}

2774

}

10001

2775

10002

2776

/**

10003

2777

Check interleaving with an inner tables of an outer join for

10004

2778

extension table.

10005

2779

10006

Check if table next_tab can be added to current partial join order, and

2780

Check if table next_tab can be added to current partial join order, and

10007

2781

if yes, record that it has been added.

10008

2782

10009

2783

The function assumes that both current partial join order and its

10010

2784

extension with next_tab are valid wrt table dependencies.

10011

2785

10012

2786

@verbatim

10013

IMPLEMENTATION

2787

IMPLEMENTATION

10014

2788

LIMITATIONS ON JOIN order_st

10015

2789

The nested [outer] joins executioner algorithm imposes these limitations

10016

2790

on join order:

10017

1. "Outer tables first" - any "outer" table must be before any

2791

1. "Outer tables first" - any "outer" table must be before any

10018

2792

corresponding "inner" table.

10019

2793

2. "No interleaving" - tables inside a nested join must form a continuous

10020

sequence in join order (i.e. the sequence must not be interrupted by

2794

sequence in join order (i.e. the sequence must not be interrupted by

10021

2795

tables that are outside of this nested join).

10022

2796

10023

2797

#1 is checked elsewhere, this function checks #2 provided that #1 has

10024

2798

been already checked.

10025

2799

10026

2800

WHY NEED NON-INTERLEAVING

10027

Consider an example:

2801

Consider an example:

10028

2802

10029

2803

select * from t0 join t1 left join (t2 join t3) on cond1

10030

2804

10048

2822

The limitations on join order can be rephrased as follows: for valid

10049

2823

join order one must be able to:

10050

2824

1. write down the used tables in the join order on one line.

10051

2. for each nested join, put one '(' and one ')' on the said line

2825

2. for each nested join, put one '(' and one ')' on the said line

10052

2826

3. write "LEFT JOIN" and "ON (...)" where appropriate

10053

2827

4. get a query equivalent to the query we're trying to execute.

10054

2828

10055

2829

Calls to check_interleaving_with_nj() are equivalent to writing the

10056

above described line from left to right.

10057

A single check_interleaving_with_nj(A,B) call is equivalent to writing

2830

above described line from left to right.

2831

A single check_interleaving_with_nj(A,B) call is equivalent to writing

10058

2832

table B and appropriate brackets on condition that table A and

10059

2833

appropriate brackets is the last what was written. Graphically the

10060

2834

transition is as follows:

10067

2841

position.

10068

2842

10069

2843

Notes about the position:

10070

The caller guarantees that there is no more then one X-bracket by

10071

checking "!(remaining_tables & s->dependent)" before calling this

2844

The caller guarantees that there is no more then one X-bracket by

2845

checking "!(remaining_tables & s->dependent)" before calling this

10072

2846

function. X-bracket may have a pair in Y-bracket.

10073

2847

10074

2848

When "writing" we store/update this auxilary info about the current

10091

2865

@retval

10092

2866

true Requested join order extension not allowed.

10093

2867

10094

10095

static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)

2868

bool check_interleaving_with_nj(JoinTable *last_tab, JoinTable *next_tab)

10096

2869

{

10097

2870

TableList *next_emb= next_tab->table->pos_in_table_list->embedding;

10098

2871

JOIN *join= last_tab->join;

10099

2872

10100

if (join->cur_embedding_map & ~next_tab->embedding_map)

2873

if ((join->cur_embedding_map & ~next_tab->embedding_map).any())

10101

2874

{

10102

2875

10103

2876

next_tab is outside of the "pair of brackets" we're currently in.

10104

2877

Cannot add it.

10105

2878

10106

2879

return true;

10107

2880

}

10108

2881

10109

2882

10110

2883

Do update counters for "pairs of brackets" that we've left (marked as

10111

2884

X,Y,Z in the above picture)

10115

2888

next_emb->nested_join->counter_++;

10116

2889

if (next_emb->nested_join->counter_ == 1)

10117

2890

{

10118

2891

10119

2892

next_emb is the first table inside a nested join we've "entered". In

10120

2893

the picture above, we're looking at the 'X' bracket. Don't exit yet as

10121

2894

X bracket might have Y pair bracket.

10122

2895

10123

2896

join->cur_embedding_map |= next_emb->nested_join->nj_map;

10124

2897

}

10125

2898

10126

2899

if (next_emb->nested_join->join_list.elements !=

10127

2900

next_emb->nested_join->counter_)

10128

2901

break;

10136

2909

return false;

10137

2910

}

10138

2911

10139

10140

/**

10141

Nested joins perspective: Remove the last table from the join order.

10142

10143

Remove the last table from the partial join order and update the nested

10144

joins counters and join->cur_embedding_map. It is ok to call this

10145

function for the first table in join order (for which

10146

check_interleaving_with_nj has not been called)

10147

10148

@param last join table to remove, it is assumed to be the last in current

10149

partial join order.

10150

10151

10152

static void restore_prev_nj_state(JOIN_TAB *last)

10153

{

10154

TableList *last_emb= last->table->pos_in_table_list->embedding;

10155

JOIN *join= last->join;

10156

while (last_emb)

10157

{

10158

if (last_emb->on_expr)

10159

{

10160

if (!(--last_emb->nested_join->counter_))

10161

join->cur_embedding_map&= ~last_emb->nested_join->nj_map;

10162

else if (last_emb->nested_join->join_list.elements-1 ==

10163

last_emb->nested_join->counter_)

10164

join->cur_embedding_map|= last_emb->nested_join->nj_map;

10165

else

10166

break;

10167

}

10168

last_emb= last_emb->embedding;

10169

}

10170

}

10171

10172

10173

10174

static

10175

void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab)

10176

{

10177

TableList *emb_sj_nest;

10178

if ((emb_sj_nest= tab->emb_sj_nest))

10179

{

10180

tab->join->cur_emb_sj_nests |= emb_sj_nest->sj_inner_tables;

10181

/* Remove the sj_nest if all of its SJ-inner tables are in cur_table_map */

10182

if (!(remaining_tables & emb_sj_nest->sj_inner_tables))

10183

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10184

}

10185

}

10186

10187

10188

10189

we assume remaining_tables doesnt contain @tab.

10190

10191

10192

static void restore_prev_sj_state(const table_map remaining_tables,

10193

const JOIN_TAB *tab)

10194

{

10195

TableList *emb_sj_nest;

10196

if ((emb_sj_nest= tab->emb_sj_nest))

10197

{

10198

/* If we're removing the last SJ-inner table, remove the sj-nest */

10199

if ((remaining_tables & emb_sj_nest->sj_inner_tables) ==

10200

(emb_sj_nest->sj_inner_tables & ~tab->table->map))

10201

{

10202

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10203

}

10204

}

10205

}

10206

10207

10208

static COND *

10209

optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list,

10210

Item::cond_result *cond_value)

10211

{

10212

THD *thd= join->thd;

2912

COND *optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)

2913

{

2914

Session *session= join->session;

10213

2915

10214

2916

if (!conds)

10215

2917

*cond_value= Item::COND_TRUE;

10216

2918

else

10217

2919

{

10218

2920

10219

2921

Build all multiple equality predicates and eliminate equality

10220

2922

predicates that can be inferred from these multiple equalities.

10221

2923

For each reference of a field included into a multiple equality

10222

2924

that occurs in a function set a pointer to the multiple equality

10223

2925

predicate. Substitute a constant instead of this field if the

10224

2926

multiple equality contains a constant.

10225

10226

conds= build_equal_items(join->thd, conds, NULL, join_list,

2927

2928

conds= build_equal_items(join->session, conds, NULL, join_list,

10227

2929

&join->cond_equal);

10228

2930

10229

2931

/* change field = field to field = const for each found field = const */

10230

propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);

2932

vector<COND_CMP> temp;

2933

propagate_cond_constants(session, temp, conds, conds);

10231

2934

10232

2935

Remove all instances of item == item

10233

2936

Remove all and-levels where CONST item != CONST item

10234

2937

10235

conds= remove_eq_conds(thd, conds, cond_value) ;

2938

conds= remove_eq_conds(session, conds, cond_value) ;

10236

2939

}

10237

2940

return(conds);

10238

2941

}

10239

2942

10240

10241

2943

/**

10242

2944

Remove const and eq items.

10243

2945

10248

2950

- COND_TRUE : always true ( 1 = 1 )

10249

2951

- COND_FALSE : always false ( 1 = 2 )

10250

2952

10251

10252

COND *

10253

remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)

2953

COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value)

10254

2954

{

10255

2955

if (cond->type() == Item::COND_ITEM)

10256

2956

{

10257

bool and_level= ((Item_cond*) cond)->functype()

10258

== Item_func::COND_AND_FUNC;

2957

bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

2958

10259

2959

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

10260

2960

Item::cond_result tmp_cond_value;

10261

bool should_fix_fields=0;

2961

bool should_fix_fields= false;

10262

2962

10263

*cond_value=Item::COND_UNDEF;

2963

*cond_value= Item::COND_UNDEF;

10264

2964

Item *item;

10265

while ((item=li++))

2965

while ((item= li++))

10266

2966

{

10267

Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);

10268

if (!new_item)

10269

li.remove();

2967

Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);

2968

if (! new_item)

2969

li.remove();

10270

2970

else if (item != new_item)

10271

2971

{

10272

li.replace(new_item);

10273

should_fix_fields=1;

2972

li.replace(new_item);

2973

should_fix_fields= true;

10274

2974

}

10275

2975

if (*cond_value == Item::COND_UNDEF)

10276

*cond_value=tmp_cond_value;

10277

switch (tmp_cond_value) {

10278

case Item::COND_OK: // Not true or false

10279

if (and_level || *cond_value == Item::COND_FALSE)

10280

*cond_value=tmp_cond_value;

10281

break;

10282

case Item::COND_FALSE:

10283

if (and_level)

10284

{

10285

*cond_value=tmp_cond_value;

10286

return (COND*) 0; // Always false

10287

}

10288

break;

10289

case Item::COND_TRUE:

10290

if (!and_level)

10291

{

10292

*cond_value= tmp_cond_value;

10293

return (COND*) 0; // Always true

10294

}

10295

break;

10296

case Item::COND_UNDEF: // Impossible

10297

break; /* purecov: deadcode */

2976

*cond_value= tmp_cond_value;

2977

2978

switch (tmp_cond_value)

2979

{

2980

case Item::COND_OK: /* Not true or false */

2981

if (and_level || (*cond_value == Item::COND_FALSE))

2982

*cond_value= tmp_cond_value;

2983

break;

2984

case Item::COND_FALSE:

2985

if (and_level)

2986

{

2987

*cond_value= tmp_cond_value;

2988

return (COND *) NULL; /* Always false */

2989

}

2990

break;

2991

case Item::COND_TRUE:

2992

if (! and_level)

2993

{

2994

*cond_value= tmp_cond_value;

2995

return (COND *) NULL; /* Always true */

2996

}

2997

break;

2998

case Item::COND_UNDEF: /* Impossible */

2999

break;

10298

3000

}

10299

3001

}

3002

10300

3003

if (should_fix_fields)

10301

3004

cond->update_used_tables();

10302

3005

10303

if (!((Item_cond*) cond)->argument_list()->elements ||

10304

*cond_value != Item::COND_OK)

10305

return (COND*) 0;

3006

if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)

3007

return (COND*) NULL;

3008

10306

3009

if (((Item_cond*) cond)->argument_list()->elements == 1)

10307

{ // Remove list

3010

{

3011

/* Argument list contains only one element, so reduce it so a single item, then remove list */

10308

3012

item= ((Item_cond*) cond)->argument_list()->head();

10309

3013

((Item_cond*) cond)->argument_list()->empty();

10310

3014

return item;

10311

3015

}

10312

3016

}

10313

else if (cond->type() == Item::FUNC_ITEM &&

10314

((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

3017

else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

10315

3018

{

10316

3019

10317

3020

Handles this special case for some ODBC applications:

10323

3026

SELECT * from table_name where auto_increment_column = LAST_INSERT_ID

10324

3027

10325

3028

10326

Item_func_isnull *func=(Item_func_isnull*) cond;

3029

Item_func_isnull *func= (Item_func_isnull*) cond;

10327

3030

Item **args= func->arguments();

10328

3031

if (args[0]->type() == Item::FIELD_ITEM)

10329

3032

{

10330

Field *field=((Item_field*) args[0])->field;

10331

if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&

10332

(thd->options & OPTION_AUTO_IS_NULL) &&

10333

(thd->first_successful_insert_id_in_prev_stmt > 0 &&

10334

thd->substitute_null_with_insert_id))

3033

Field *field= ((Item_field*) args[0])->field;

3034

if (field->flags & AUTO_INCREMENT_FLAG

3035

&& ! field->table->maybe_null

3036

&& session->options & OPTION_AUTO_IS_NULL

3037

&& (

3038

session->first_successful_insert_id_in_prev_stmt > 0

3039

&& session->substitute_null_with_insert_id

3040

)

3041

)

10335

3042

{

10336

COND *new_cond;

10337

if ((new_cond= new Item_func_eq(args[0],

10338

new Item_int("last_insert_id()",

10339

thd->read_first_successful_insert_id_in_prev_stmt(),

10340

MY_INT64_NUM_DECIMAL_DIGITS))))

10341

{

10342

cond=new_cond;

3043

COND *new_cond;

3044

if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",

3045

session->read_first_successful_insert_id_in_prev_stmt(),

3046

MY_INT64_NUM_DECIMAL_DIGITS))))

3047

{

3048

cond= new_cond;

10343

3049

10344

3050

Item_func_eq can't be fixed after creation so we do not check

10345

3051

cond->fixed, also it do not need tables so we use 0 as second

10346

3052

argument.

10347

3053

10348

cond->fix_fields(thd, &cond);

10349

}

3054

cond->fix_fields(session, &cond);

3055

}

10350

3056

10351

3057

IS NULL should be mapped to LAST_INSERT_ID only for first row, so

10352

3058

clear for next row

10353

3059

10354

thd->substitute_null_with_insert_id= false;

3060

session->substitute_null_with_insert_id= false;

10355

3061

}

3062

#ifdef NOTDEFINED

10356

3063

/* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */

10357

else if (((field->type() == DRIZZLE_TYPE_NEWDATE) ||

10358

(field->type() == DRIZZLE_TYPE_DATETIME)) &&

10359

(field->flags & NOT_NULL_FLAG) &&

10360

!field->table->maybe_null)

3064

else if (

3065

((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME))

3066

&& (field->flags & NOT_NULL_FLAG)

3067

&& ! field->table->maybe_null)

10361

3068

{

10362

COND *new_cond;

10363

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

10364

{

10365

cond=new_cond;

3069

COND *new_cond;

3070

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

3071

{

3072

cond= new_cond;

10366

3073

10367

3074

Item_func_eq can't be fixed after creation so we do not check

10368

3075

cond->fixed, also it do not need tables so we use 0 as second

10369

3076

argument.

10370

3077

10371

cond->fix_fields(thd, &cond);

10372

}

3078

cond->fix_fields(session, &cond);

3079

}

10373

3080

}

3081

#endif /* NOTDEFINED */

10374

3082

}

10375

3083

if (cond->const_item())

10376

3084

{

10377

3085

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

10378

return (COND*) 0;

3086

return (COND *) NULL;

10379

3087

}

10380

3088

}

10381

3089

else if (cond->const_item() && !cond->is_expensive())

10391

3099

10392

3100

{

10393

3101

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

10394

return (COND*) 0;

3102

return (COND *) NULL;

10395

3103

}

10396

3104

else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)

10397

{ // boolan compare function

3105

{

3106

/* boolan compare function */

10398

3107

Item *left_item= ((Item_func*) cond)->arguments()[0];

10399

3108

Item *right_item= ((Item_func*) cond)->arguments()[1];

10400

3109

if (left_item->eq(right_item,1))

10401

3110

{

10402

if (!left_item->maybe_null ||

10403

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

10404

return (COND*) 0; // Compare of identical items

3111

if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

3112

return (COND*) NULL; /* Comparison of identical items */

10405

3113

}

10406

3114

}

10407

*cond_value=Item::COND_OK;

10408

return cond; // Point at next and level

3115

*cond_value= Item::COND_OK;

3116

return cond; /* Point at next and return into recursion */

10409

3117

}

10410

3118

10411

3119

10412

3120

Check if equality can be used in removing components of GROUP BY/DISTINCT

10413

3121

10414

3122

SYNOPSIS

10415

3123

test_if_equality_guarantees_uniqueness()

10416

3124

l the left comparison argument (a field if any)

10417

3125

r the right comparison argument (a const of any)

10418

10419

DESCRIPTION

10420

Checks if an equality predicate can be used to take away

10421

DISTINCT/GROUP BY because it is known to be true for exactly one

3126

3127

DESCRIPTION

3128

Checks if an equality predicate can be used to take away

3129

DISTINCT/GROUP BY because it is known to be true for exactly one

10422

3130

distinct value (e.g. <expr> == <const>).

10423

Arguments must be of the same type because e.g.

10424

<string_field> = <int_const> may match more than 1 distinct value from

10425

the column.

10426

We must take into consideration and the optimization done for various

3131

Arguments must be of the same type because e.g.

3132

<string_field> = <int_const> may match more than 1 distinct value from

3133

the column.

3134

We must take into consideration and the optimization done for various

10427

3135

string constants when compared to dates etc (see Item_int_with_ref) as

10428

3136

well as the collation of the arguments.

10429

10430

RETURN VALUE

3137

3138

RETURN VALUE

10431

3139

true can be used

10432

3140

false cannot be used

10433

3141

10434

static bool

10435

test_if_equality_guarantees_uniqueness(Item *l, Item *r)

3142

static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)

10436

3143

{

10437

3144

return r->const_item() &&

10438

3145

/* elements must be compared as dates */

10447

3154

/**

10448

3155

Return true if the item is a const value in all the WHERE clause.

10449

3156

10450

10451

static bool

10452

const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

3157

bool const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

10453

3158

{

10454

3159

if (cond->type() == Item::COND_ITEM)

10455

3160

{

10462

3167

bool res=const_expression_in_where(item, comp_item, const_item);

10463

3168

if (res) // Is a const value

10464

3169

{

10465

if (and_level)

10466

return 1;

3170

if (and_level)

3171

return 1;

10467

3172

}

10468

3173

else if (!and_level)

10469

return 0;

3174

return 0;

10470

3175

}

10471

3176

return and_level ? 0 : 1;

10472

3177

}

10474

3179

{ // boolan compare function

10475

3180

Item_func* func= (Item_func*) cond;

10476

3181

if (func->functype() != Item_func::EQUAL_FUNC &&

10477

func->functype() != Item_func::EQ_FUNC)

3182

func->functype() != Item_func::EQ_FUNC)

10478

3183

return 0;

10479

3184

Item *left_item= ((Item_func*) cond)->arguments()[0];

10480

3185

Item *right_item= ((Item_func*) cond)->arguments()[1];

10482

3187

{

10483

3188

if (test_if_equality_guarantees_uniqueness (left_item, right_item))

10484

3189

{

10485

if (*const_item)

10486

return right_item->eq(*const_item, 1);

10487

*const_item=right_item;

10488

return 1;

3190

if (*const_item)

3191

return right_item->eq(*const_item, 1);

3192

*const_item=right_item;

3193

return 1;

10489

3194

}

10490

3195

}

10491

3196

else if (right_item->eq(comp_item,1))

10492

3197

{

10493

3198

if (test_if_equality_guarantees_uniqueness (right_item, left_item))

10494

3199

{

10495

if (*const_item)

10496

return left_item->eq(*const_item, 1);

10497

*const_item=left_item;

10498

return 1;

3200

if (*const_item)

3201

return left_item->eq(*const_item, 1);

3202

*const_item=left_item;

3203

return 1;

10499

3204

}

10500

3205

}

10501

3206

}

10502

3207

return 0;

10503

3208

}

10504

3209

10505

10506

3210

/**

10507

3211

@details

10508

3212

Rows produced by a join sweep may end up in a temporary table or be sent

10514

3218

@return

10515

3219

end_select function to use. This function can't fail.

10516

3220

10517

10518

3221

Next_select_func setup_end_select_func(JOIN *join)

10519

3222

{

10520

3223

Table *table= join->tmp_table;

10521

TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;

3224

Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;

10522

3225

Next_select_func end_select;

10523

3226

10524

3227

/* Set up select_end */

10525

3228

if (table)

10526

3229

{

10527

if (table->group && tmp_tbl->sum_func_count &&

3230

if (table->group && tmp_tbl->sum_func_count &&

10528

3231

!tmp_tbl->precomputed_group_by)

10529

3232

{

10530

3233

if (table->s->keys)

10531

3234

{

10532

end_select=end_update;

3235

end_select= end_update;

10533

3236

}

10534

3237

else

10535

3238

{

10536

end_select=end_unique_update;

3239

end_select= end_unique_update;

10537

3240

}

10538

3241

}

10539

3242

else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)

10548

3251

10549

3252

A preceding call to create_tmp_table in the case when loose

10550

3253

index scan is used guarantees that

10551

TMP_TABLE_PARAM::items_to_copy has enough space for the group

3254

Tmp_Table_Param::items_to_copy has enough space for the group

10552

3255

by functions. It is OK here to use memcpy since we copy

10553

3256

Item_sum pointers into an array of Item pointers.

10554

3257

10570

3273

return end_select;

10571

3274

}

10572

3275

10573

10574

3276

/**

10575

3277

Make a join of all tables and write it on socket or to table.

10576

3278

10581

3283

@retval

10582

3284

-1 if error should be sent

10583

3285

10584

10585

static int

10586

do_select(JOIN *join,List<Item> *fields,Table *table)

3286

int do_select(JOIN *join, List<Item> *fields, Table *table)

10587

3287

{

10588

3288

int rc= 0;

10589

3289

enum_nested_loop_state error= NESTED_LOOP_OK;

10590

JOIN_TAB *join_tab= NULL;

10591

3290

JoinTable *join_tab= NULL;

3291

10592

3292

join->tmp_table= table; /* Save for easy recursion */

10593

3293

join->fields= fields;

10594

3294

10595

3295

if (table)

10596

3296

{

10597

3297

table->file->extra(HA_EXTRA_WRITE_CACHE);

10598

empty_record(table);

3298

table->emptyRecord();

10599

3299

if (table->group && join->tmp_table_param.sum_func_count &&

10600

3300

table->s->keys && !table->file->inited)

10601

3301

table->file->ha_index_init(0, 0);

10619

3319

{

10620

3320

error= (*end_select)(join, 0, 0);

10621

3321

if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)

10622

error= (*end_select)(join, 0, 1);

3322

error= (*end_select)(join, 0, 1);

10623

3323

10624

3324

10625

3325

If we don't go through evaluate_join_record(), do the counting

10627

3327

so we don't touch it here.

10628

3328

10629

3329

join->examined_rows++;

10630

join->thd->row_count++;

3330

join->session->row_count++;

10631

3331

assert(join->examined_rows <= 1);

10632

3332

}

10633

3333

else if (join->send_row_on_empty_set())

10657

3357

if (!table) // If sending data to client

10658

3358

{

10659

3359

10660

The following will unlock all cursors if the command wasn't an

10661

update command

3360

The following will unlock all cursors if the command wasn't an

3361

update command

10662

3362

10663

3363

join->join_free(); // Unlock all cursors

10664

3364

if (join->result->send_eof())

10665

rc= 1; // Don't send error

3365

rc= 1; // Don't send error

10666

3366

}

10667

3367

}

10668

3368

else

10681

3381

if (new_errno)

10682

3382

table->file->print_error(new_errno,MYF(0));

10683

3383

}

10684

return(join->thd->is_error() ? -1 : rc);

3384

return(join->session->is_error() ? -1 : rc);

10685

3385

}

10686

3386

10687

10688

enum_nested_loop_state

10689

sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3387

enum_nested_loop_state sub_select_cache(JOIN *join, JoinTable *join_tab, bool end_of_records)

10690

3388

{

10691

3389

enum_nested_loop_state rc;

10692

3390

10697

3395

rc= sub_select(join,join_tab,end_of_records);

10698

3396

return rc;

10699

3397

}

10700

if (join->thd->killed) // If aborted by user

3398

if (join->session->killed) // If aborted by user

10701

3399

{

10702

join->thd->send_kill_message();

10703

return NESTED_LOOP_KILLED; /* purecov: inspected */

3400

join->session->send_kill_message();

3401

return NESTED_LOOP_KILLED;

10704

3402

}

10705

3403

if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)

10706

3404

{

10707

if (!store_record_in_cache(&join_tab->cache))

3405

if (! store_record_in_cache(&join_tab->cache))

10708

3406

return NESTED_LOOP_OK; // There is more room in cache

10709

3407

return flush_cached_records(join,join_tab,false);

10710

3408

}

10717

3415

/**

10718

3416

Retrieve records ends with a given beginning from the result of a join.

10719

3417

10720

For a given partial join record consisting of records from the tables

3418

For a given partial join record consisting of records from the tables

10721

3419

preceding the table join_tab in the execution plan, the function

10722

3420

retrieves all matching full records from the result set and

10723

send them to the result set stream.

3421

send them to the result set stream.

10724

3422

10725

3423

@note

10726

3424

The function effectively implements the final (n-k) nested loops

10760

3458

first row with t3.a=t1.a has been encountered.

10761

3459

Thus, the second predicate P2 is supplied with a guarded value that are

10762

3460

stored in the field 'found' of the first inner table for the outer join

10763

(table t2). When the first row with t3.a=t1.a for the current row

3461

(table t2). When the first row with t3.a=t1.a for the current row

10764

3462

of table t1 appears, the value becomes true. For now on the predicate

10765

3463

is evaluated immediately after the row of table t2 has been read.

10766

3464

When the first row with t3.a=t1.a has been encountered all

10768

3466

Only when all of them are true the row is sent to the output stream.

10769

3467

If not, the function returns to the lowest nest level that has a false

10770

3468

attached condition.

10771

The predicates from on expressions are also pushed down. If in the

3469

The predicates from on expressions are also pushed down. If in the

10772

3470

the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),

10773

3471

then t1.a=t2.a would be pushed down to table t2, and without any

10774

3472

guard.

10778

3476

is complemented by nulls for t2 and t3. Then the pushed down predicates

10779

3477

are checked for the composed row almost in the same way as it had

10780

3478

been done for the first row with a match. The only difference is

10781

the predicates from on expressions are not checked.

3479

the predicates from on expressions are not checked.

10782

3480

10783

3481

@par

10784

3482

@b IMPLEMENTATION

10794

3492

and a pointer to a guarding boolean variable.

10795

3493

When the value of the guard variable is true the value of the object

10796

3494

is the same as the value of the predicate, otherwise it's just returns

10797

true.

10798

To carry out a return to a nested loop level of join table t the pointer

3495

true.

3496

To carry out a return to a nested loop level of join table t the pointer

10799

3497

to t is remembered in the field 'return_tab' of the join structure.

10800

3498

Consider the following query:

10801

3499

@code

10812

3510

t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL

10813

3511

becomes 'activated', as well the predicate t4.a=t2.a. But

10814

3512

the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until

10815

t4.a=t2.a becomes true.

3513

t4.a=t2.a becomes true.

10816

3514

In order not to re-evaluate the predicates that were already evaluated

10817

3515

as attached pushed down predicates, a pointer to the the first

10818

3516

most inner unmatched table is maintained in join_tab->first_unmatched.

10819

3517

Thus, when the first row from t5 with t5.a=t3.a is found

10820

this pointer for t5 is changed from t4 to t2.

3518

this pointer for t5 is changed from t4 to t2.

10821

3519

10822

3520

@par

10823

3521

@b STRUCTURE @b NOTES

10828

3526

@param join pointer to the structure providing all context info for

10829

3527

the query

10830

3528

@param join_tab the first next table of the execution plan to be retrieved

10831

@param end_records true when we need to perform final steps of retrival

3529

@param end_records true when we need to perform final steps of retrival

10832

3530

10833

3531

@return

10834

3532

return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.

10835

3533

10836

int do_sj_reset(SJ_TMP_TABLE *sj_tbl);

10837

10838

enum_nested_loop_state

10839

sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3534

enum_nested_loop_state sub_select(JOIN *join, JoinTable *join_tab, bool end_of_records)

10840

3535

{

10841

3536

join_tab->table->null_row=0;

10842

3537

if (end_of_records)

10846

3541

enum_nested_loop_state rc;

10847

3542

READ_RECORD *info= &join_tab->read_record;

10848

3543

10849

if (join_tab->flush_weedout_table)

10850

{

10851

do_sj_reset(join_tab->flush_weedout_table);

10852

}

10853

10854

3544

if (join->resume_nested_loop)

10855

3545

{

10856

3546

/* If not the last table, plunge down the nested loop */

10877

3567

/* Set first_unmatched for the last inner table of this group */

10878

3568

join_tab->last_inner->first_unmatched= join_tab;

10879

3569

}

10880

join->thd->row_count= 0;

3570

join->session->row_count= 0;

10881

3571

10882

3572

error= (*join_tab->read_first_record)(join_tab);

10883

3573

rc= evaluate_join_record(join, join_tab, error);

10884

3574

}

10885

10886

10887

Note: psergey has added the 2nd part of the following condition; the

3575

3576

3577

Note: psergey has added the 2nd part of the following condition; the

10888

3578

change should probably be made in 5.1, too.

10889

3579

10890

3580

while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)

10902

3592

return rc;

10903

3593

}

10904

3594

10905

10906

10907

10908

10909

SemiJoinDuplicateElimination: Weed out duplicate row combinations

10910

10911

SYNPOSIS

10912

do_sj_dups_weedout()

10913

10914

RETURN

10915

-1 Error

10916

1 The row combination is a duplicate (discard it)

10917

0 The row combination is not a duplicate (continue)

10918

10919

10920

int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl)

10921

{

10922

int error;

10923

SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;

10924

SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;

10925

unsigned char *ptr= sjtbl->tmp_table->record[0] + 1;

10926

unsigned char *nulls_ptr= ptr;

10927

10928

/* Put the the rowids tuple into table->record[0]: */

10929

10930

// 1. Store the length

10931

if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)

10932

{

10933

*ptr= (unsigned char)(sjtbl->rowid_len + sjtbl->null_bytes);

10934

ptr++;

10935

}

10936

else

10937

{

10938

int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);

10939

ptr += 2;

10940

}

10941

10942

// 2. Zero the null bytes

10943

if (sjtbl->null_bytes)

10944

{

10945

memset(ptr, 0, sjtbl->null_bytes);

10946

ptr += sjtbl->null_bytes;

10947

}

10948

10949

// 3. Put the rowids

10950

for (uint32_t i=0; tab != tab_end; tab++, i++)

10951

{

10952

handler *h= tab->join_tab->table->file;

10953

if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)

10954

{

10955

/* It's a NULL-complemented row */

10956

*(nulls_ptr + tab->null_byte) |= tab->null_bit;

10957

memset(ptr + tab->rowid_offset, 0, h->ref_length);

10958

}

10959

else

10960

{

10961

/* Copy the rowid value */

10962

if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)

10963

h->position(tab->join_tab->table->record[0]);

10964

memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);

10965

}

10966

}

10967

10968

error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);

10969

if (error)

10970

{

10971

/* create_myisam_from_heap will generate error if needed */

10972

if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&

10973

create_myisam_from_heap(thd, sjtbl->tmp_table, sjtbl->start_recinfo,

10974

&sjtbl->recinfo, error, 1))

10975

return -1;

10976

//return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;

10977

return 1;

10978

}

10979

return 0;

10980

}

10981

10982

10983

10984

SemiJoinDuplicateElimination: Reset the temporary table

10985

10986

10987

int do_sj_reset(SJ_TMP_TABLE *sj_tbl)

10988

{

10989

if (sj_tbl->tmp_table)

10990

return sj_tbl->tmp_table->file->ha_delete_all_rows();

10991

return 0;

10992

}

10993

10994

10995

Process one record of the nested loop join.

10996

10997

This function will evaluate parts of WHERE/ON clauses that are

10998

applicable to the partial record on hand and in case of success

10999

submit this record to the next level of the nested loop.

11000

11001

11002

static enum_nested_loop_state

11003

evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,

11004

int error)

11005

{

11006

bool not_used_in_distinct=join_tab->not_used_in_distinct;

11007

ha_rows found_records=join->found_records;

11008

COND *select_cond= join_tab->select_cond;

11009

11010

if (error > 0 || (join->thd->is_error())) // Fatal error

11011

return NESTED_LOOP_ERROR;

11012

if (error < 0)

11013

return NESTED_LOOP_NO_MORE_ROWS;

11014

if (join->thd->killed) // Aborted by user

11015

{

11016

join->thd->send_kill_message();

11017

return NESTED_LOOP_KILLED; /* purecov: inspected */

11018

}

11019

if (!select_cond || select_cond->val_int())

11020

{

11021

11022

There is no select condition or the attached pushed down

11023

condition is true => a match is found.

11024

11025

bool found= 1;

11026

while (join_tab->first_unmatched && found)

11027

{

11028

11029

The while condition is always false if join_tab is not

11030

the last inner join table of an outer join operation.

11031

11032

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11033

11034

Mark that a match for current outer table is found.

11035

This activates push down conditional predicates attached

11036

to the all inner tables of the outer join.

11037

11038

first_unmatched->found= 1;

11039

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11040

{

11041

if (tab->table->reginfo.not_exists_optimize)

11042

return NESTED_LOOP_NO_MORE_ROWS;

11043

/* Check all predicates that has just been activated. */

11044

11045

Actually all predicates non-guarded by first_unmatched->found

11046

will be re-evaluated again. It could be fixed, but, probably,

11047

it's not worth doing now.

11048

11049

if (tab->select_cond && !tab->select_cond->val_int())

11050

{

11051

/* The condition attached to table tab is false */

11052

if (tab == join_tab)

11053

found= 0;

11054

else

11055

{

11056

11057

Set a return point if rejected predicate is attached

11058

not to the last table of the current nest level.

11059

11060

join->return_tab= tab;

11061

return NESTED_LOOP_OK;

11062

}

11063

}

11064

}

11065

11066

Check whether join_tab is not the last inner table

11067

for another embedding outer join.

11068

11069

if ((first_unmatched= first_unmatched->first_upper) &&

11070

first_unmatched->last_inner != join_tab)

11071

first_unmatched= 0;

11072

join_tab->first_unmatched= first_unmatched;

11073

}

11074

11075

JOIN_TAB *return_tab= join->return_tab;

11076

join_tab->found_match= true;

11077

if (join_tab->check_weed_out_table)

11078

{

11079

int res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table);

11080

if (res == -1)

11081

return NESTED_LOOP_ERROR;

11082

if (res == 1)

11083

return NESTED_LOOP_OK;

11084

}

11085

else if (join_tab->do_firstmatch)

11086

{

11087

11088

We should return to the join_tab->do_firstmatch after we have

11089

enumerated all the suffixes for current prefix row combination

11090

11091

return_tab= join_tab->do_firstmatch;

11092

}

11093

11094

11095

It was not just a return to lower loop level when one

11096

of the newly activated predicates is evaluated as false

11097

(See above join->return_tab= tab).

11098

11099

join->examined_rows++;

11100

join->thd->row_count++;

11101

11102

if (found)

11103

{

11104

enum enum_nested_loop_state rc;

11105

/* A match from join_tab is found for the current partial join. */

11106

rc= (*join_tab->next_select)(join, join_tab+1, 0);

11107

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11108

return rc;

11109

if (return_tab < join->return_tab)

11110

join->return_tab= return_tab;

11111

11112

if (join->return_tab < join_tab)

11113

return NESTED_LOOP_OK;

11114

11115

Test if this was a SELECT DISTINCT query on a table that

11116

was not in the field list; In this case we can abort if

11117

we found a row, as no new rows can be added to the result.

11118

11119

if (not_used_in_distinct && found_records != join->found_records)

11120

return NESTED_LOOP_NO_MORE_ROWS;

11121

}

11122

else

11123

join_tab->read_record.file->unlock_row();

11124

}

11125

else

11126

{

11127

11128

The condition pushed down to the table join_tab rejects all rows

11129

with the beginning coinciding with the current partial join.

11130

11131

join->examined_rows++;

11132

join->thd->row_count++;

11133

join_tab->read_record.file->unlock_row();

11134

}

11135

return NESTED_LOOP_OK;

11136

}

11137

11138

11139

/**

11140

11141

@details

11142

Construct a NULL complimented partial join record and feed it to the next

11143

level of the nested loop. This function is used in case we have

11144

an OUTER join and no matching record was found.

11145

11146

11147

static enum_nested_loop_state

11148

evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab)

11149

{

11150

11151

The table join_tab is the first inner table of a outer join operation

11152

and no matches has been found for the current outer row.

11153

11154

JOIN_TAB *last_inner_tab= join_tab->last_inner;

11155

/* Cache variables for faster loop */

11156

COND *select_cond;

11157

for ( ; join_tab <= last_inner_tab ; join_tab++)

11158

{

11159

/* Change the the values of guard predicate variables. */

11160

join_tab->found= 1;

11161

join_tab->not_null_compl= 0;

11162

/* The outer row is complemented by nulls for each inner tables */

11163

restore_record(join_tab->table,s->default_values); // Make empty record

11164

mark_as_null_row(join_tab->table); // For group by without error

11165

select_cond= join_tab->select_cond;

11166

/* Check all attached conditions for inner table rows. */

11167

if (select_cond && !select_cond->val_int())

11168

return NESTED_LOOP_OK;

11169

}

11170

join_tab--;

11171

11172

The row complemented by nulls might be the first row

11173

of embedding outer joins.

11174

If so, perform the same actions as in the code

11175

for the first regular outer join row above.

11176

11177

for ( ; ; )

11178

{

11179

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

11180

if ((first_unmatched= first_unmatched->first_upper) &&

11181

first_unmatched->last_inner != join_tab)

11182

first_unmatched= 0;

11183

join_tab->first_unmatched= first_unmatched;

11184

if (!first_unmatched)

11185

break;

11186

first_unmatched->found= 1;

11187

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

11188

{

11189

if (tab->select_cond && !tab->select_cond->val_int())

11190

{

11191

join->return_tab= tab;

11192

return NESTED_LOOP_OK;

11193

}

11194

}

11195

}

11196

11197

The row complemented by nulls satisfies all conditions

11198

attached to inner tables.

11199

Send the row complemented by nulls to be joined with the

11200

remaining tables.

11201

11202

return (*join_tab->next_select)(join, join_tab+1, 0);

11203

}

11204

11205

11206

static enum_nested_loop_state

11207

flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skip_last)

11208

{

11209

enum_nested_loop_state rc= NESTED_LOOP_OK;

11210

int error;

11211

READ_RECORD *info;

11212

11213

join_tab->table->null_row= 0;

11214

if (!join_tab->cache.records)

11215

return NESTED_LOOP_OK; /* Nothing to do */

11216

if (skip_last)

11217

(void) store_record_in_cache(&join_tab->cache); // Must save this for later

11218

if (join_tab->use_quick == 2)

11219

{

11220

if (join_tab->select->quick)

11221

{ /* Used quick select last. reset it */

11222

delete join_tab->select->quick;

11223

join_tab->select->quick=0;

11224

}

11225

}

11226

/* read through all records */

11227

if ((error=join_init_read_record(join_tab)))

11228

{

11229

reset_cache_write(&join_tab->cache);

11230

return error < 0 ? NESTED_LOOP_NO_MORE_ROWS: NESTED_LOOP_ERROR;

11231

}

11232

11233

for (JOIN_TAB *tmp=join->join_tab; tmp != join_tab ; tmp++)

11234

{

11235

tmp->status=tmp->table->status;

11236

tmp->table->status=0;

11237

}

11238

11239

info= &join_tab->read_record;

11240

11241

{

11242

if (join->thd->killed)

11243

{

11244

join->thd->send_kill_message();

11245

return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */

11246

}

11247

SQL_SELECT *select=join_tab->select;

11248

if (rc == NESTED_LOOP_OK &&

11249

(!join_tab->cache.select || !join_tab->cache.select->skip_record()))

11250

{

11251

uint32_t i;

11252

reset_cache_read(&join_tab->cache);

11253

for (i=(join_tab->cache.records- (skip_last ? 1 : 0)) ; i-- > 0 ;)

11254

{

11255

read_cached_record(join_tab);

11256

if (!select || !select->skip_record())

11257

{

11258

int res= 0;

11259

if (!join_tab->check_weed_out_table ||

11260

!(res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table)))

11261

{

11262

rc= (join_tab->next_select)(join,join_tab+1,0);

11263

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

11264

{

11265

reset_cache_write(&join_tab->cache);

11266

return rc;

11267

}

11268

}

11269

if (res == -1)

11270

return NESTED_LOOP_ERROR;

11271

}

11272

}

11273

}

11274

} while (!(error=info->read_record(info)));

11275

11276

if (skip_last)

11277

read_cached_record(join_tab); // Restore current record

11278

reset_cache_write(&join_tab->cache);

11279

if (error > 0) // Fatal error

11280

return NESTED_LOOP_ERROR; /* purecov: inspected */

11281

for (JOIN_TAB *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)

11282

tmp2->table->status=tmp2->status;

11283

return NESTED_LOOP_OK;

11284

}

11285

11286

int safe_index_read(JOIN_TAB *tab)

3595

int safe_index_read(JoinTable *tab)

11287

3596

{

11288

3597

int error;

11289

3598

Table *table= tab->table;

11295

3604

return 0;

11296

3605

}

11297

3606

11298

11299

static int

11300

join_read_const_table(JOIN_TAB *tab, POSITION *pos)

3607

int join_read_const_table(JoinTable *tab, optimizer::Position *pos)

11301

3608

{

11302

3609

int error;

11303

3610

Table *table=tab->table;

11304

3611

table->const_table=1;

11305

3612

table->null_row=0;

11306

3613

table->status=STATUS_NO_RECORD;

11307

11308

if (tab->type == JT_SYSTEM)

3614

3615

if (tab->type == AM_SYSTEM)

11309

3616

{

11310

3617

if ((error=join_read_system(tab)))

11311

3618

{ // Info for DESCRIBE

11312

3619

tab->info="const row not found";

11313

3620

/* Mark for EXPLAIN that the row was not found */

11314

pos->records_read=0.0;

11315

pos->ref_depend_map= 0;

11316

if (!table->maybe_null || error > 0)

11317

return(error);

3621

pos->setFanout(0.0);

3622

pos->clearRefDependMap();

3623

if (! table->maybe_null || error > 0)

3624

return(error);

11318

3625

}

11319

3626

}

11320

3627

else

11321

3628

{

11322

if (!table->key_read && table->covering_keys.is_set(tab->ref.key) &&

11323

!table->no_keyread &&

11324

(int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY)

3629

if (! table->key_read &&

3630

table->covering_keys.test(tab->ref.key) &&

3631

! table->no_keyread &&

3632

(int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS)

11325

3633

{

11326

3634

table->key_read=1;

11327

3635

table->file->extra(HA_EXTRA_KEYREAD);

11337

3645

{

11338

3646

tab->info="unique row not found";

11339

3647

/* Mark for EXPLAIN that the row was not found */

11340

pos->records_read=0.0;

11341

pos->ref_depend_map= 0;

3648

pos->setFanout(0.0);

3649

pos->clearRefDependMap();

11342

3650

if (!table->maybe_null || error > 0)

11343

return(error);

3651

return(error);

11344

3652

}

11345

3653

}

11346

3654

if (*tab->on_expr_ref && !table->null_row)

11347

3655

{

11348

3656

if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))

11349

mark_as_null_row(table);

3657

table->mark_as_null_row();

11350

3658

}

11351

3659

if (!table->null_row)

11352

3660

table->maybe_null=0;

11374

3682

return(0);

11375

3683

}

11376

3684

11377

11378

static int

11379

join_read_system(JOIN_TAB *tab)

3685

int join_read_system(JoinTable *tab)

11380

3686

{

11381

3687

Table *table= tab->table;

11382

3688

int error;

11386

3692

table->s->primary_key)))

11387

3693

{

11388

3694

if (error != HA_ERR_END_OF_FILE)

11389

return table->report_error(error);

11390

mark_as_null_row(tab->table);

11391

empty_record(table); // Make empty record

3695

return table->report_error(error);

3696

tab->table->mark_as_null_row();

3697

table->emptyRecord(); // Make empty record

11392

3698

return -1;

11393

3699

}

11394

store_record(table,record[1]);

3700

table->storeRecord();

11395

3701

}

11396

3702

else if (!table->status) // Only happens with left join

11397

restore_record(table,record[1]); // restore old record

3703

table->restoreRecord(); // restore old record

11398

3704

table->null_row=0;

11399

3705

return table->status ? -1 : 0;

11400

3706

}

11401

3707

11402

11403

3708

/**

11404

3709

Read a (constant) table when there is at most one matching row.

11405

3710

11412

3717

@retval

11413

3718

1 Got an error (other than row not found) during read

11414

3719

11415

11416

static int

11417

join_read_const(JOIN_TAB *tab)

3720

int join_read_const(JoinTable *tab)

11418

3721

{

11419

3722

int error;

11420

3723

Table *table= tab->table;

11421

3724

if (table->status & STATUS_GARBAGE) // If first read

11422

3725

{

11423

3726

table->status= 0;

11424

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

11425

error=HA_ERR_KEY_NOT_FOUND;

3727

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

3728

error= HA_ERR_KEY_NOT_FOUND;

11426

3729

else

11427

3730

{

11428

3731

error=table->file->index_read_idx_map(table->record[0],tab->ref.key,

11433

3736

if (error)

11434

3737

{

11435

3738

table->status= STATUS_NOT_FOUND;

11436

mark_as_null_row(tab->table);

11437

empty_record(table);

3739

tab->table->mark_as_null_row();

3740

table->emptyRecord();

11438

3741

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

11439

return table->report_error(error);

3742

return table->report_error(error);

11440

3743

return -1;

11441

3744

}

11442

store_record(table,record[1]);

3745

table->storeRecord();

11443

3746

}

11444

3747

else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join

11445

3748

{

11446

3749

table->status=0;

11447

restore_record(table,record[1]); // restore old record

3750

table->restoreRecord(); // restore old record

11448

3751

}

11449

3752

table->null_row=0;

11450

3753

return table->status ? -1 : 0;

11451

3754

}

11452

3755

11453

11454

3756

11455

3757

eq_ref access method implementation: "read_first" function

11456

3758

11457

3759

SYNOPSIS

11458

3760

join_read_key()

11459

tab JOIN_TAB of the accessed table

3761

tab JoinTable of the accessed table

11460

3762

11461

3763

DESCRIPTION

11462

3764

This is "read_fist" function for the "ref" access method. The difference

11464

3766

11465

3767

RETURN

11466

3768

0 - Ok

11467

-1 - Row not found

3769

-1 - Row not found

11468

3770

1 - Error

11469

3771

11470

11471

static int

11472

join_read_key(JOIN_TAB *tab)

3772

int join_read_key(JoinTable *tab)

11473

3773

{

11474

3774

int error;

11475

3775

Table *table= tab->table;

11499

3799

return table->status ? -1 : 0;

11500

3800

}

11501

3801

11502

11503

3802

11504

3803

ref access method implementation: "read_first" function

11505

3804

11506

3805

SYNOPSIS

11507

3806

join_read_always_key()

11508

tab JOIN_TAB of the accessed table

3807

tab JoinTable of the accessed table

11509

3808

11510

3809

DESCRIPTION

11511

This is "read_fist" function for the "ref" access method.

11512

3810

This is "read_first" function for the "ref" access method.

3811

11513

3812

The functon must leave the index initialized when it returns.

11514

3813

ref_or_null access implementation depends on that.

11515

3814

11516

3815

RETURN

11517

3816

0 - Ok

11518

-1 - Row not found

3817

-1 - Row not found

11519

3818

1 - Error

11520

3819

11521

11522

static int

11523

join_read_always_key(JOIN_TAB *tab)

3820

int join_read_always_key(JoinTable *tab)

11524

3821

{

11525

3822

int error;

11526

3823

Table *table= tab->table;

11528

3825

/* Initialize the index first */

11529

3826

if (!table->file->inited)

11530

3827

table->file->ha_index_init(tab->ref.key, tab->sorted);

11531

3828

11532

3829

/* Perform "Late NULLs Filtering" (see internals manual for explanations) */

11533

3830

for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)

11534

3831

{

11536

3833

return -1;

11537

3834

}

11538

3835

11539

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3836

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11540

3837

return -1;

11541

3838

if ((error=table->file->index_read_map(table->record[0],

11542

3839

tab->ref.key_buff,

11545

3842

{

11546

3843

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

11547

3844

return table->report_error(error);

11548

return -1; /* purecov: inspected */

3845

return -1;

11549

3846

}

3847

11550

3848

return 0;

11551

3849

}

11552

3850

11553

11554

3851

/**

11555

This function is used when optimizing away order_st BY in

3852

This function is used when optimizing away order_st BY in

11556

3853

SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.

11557

3854

11558

11559

static int

11560

join_read_last_key(JOIN_TAB *tab)

3855

int join_read_last_key(JoinTable *tab)

11561

3856

{

11562

3857

int error;

11563

3858

Table *table= tab->table;

11564

3859

11565

3860

if (!table->file->inited)

11566

3861

table->file->ha_index_init(tab->ref.key, tab->sorted);

11567

if (cp_buffer_from_ref(tab->join->thd, &tab->ref))

3862

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

11568

3863

return -1;

11569

3864

if ((error=table->file->index_read_last_map(table->record[0],

11570

3865

tab->ref.key_buff,

11572

3867

{

11573

3868

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

11574

3869

return table->report_error(error);

11575

return -1; /* purecov: inspected */

3870

return -1;

11576

3871

}

11577

3872

return 0;

11578

3873

}

11579

3874

11580

11581

/* ARGSUSED */

11582

static int

11583

join_no_more_records(READ_RECORD *info __attribute__((unused)))

3875

int join_no_more_records(READ_RECORD *)

11584

3876

{

11585

3877

return -1;

11586

3878

}

11587

3879

11588

static int

11589

join_read_next_same_diff(READ_RECORD *info)

3880

int join_read_next_same_diff(READ_RECORD *info)

11590

3881

{

11591

3882

Table *table= info->table;

11592

JOIN_TAB *tab=table->reginfo.join_tab;

3883

JoinTable *tab=table->reginfo.join_tab;

11593

3884

if (tab->insideout_match_tab->found_match)

11594

3885

{

11595

3886

KEY *key= tab->table->key_info + tab->index;

11596

3887

11597

3888

{

11598

3889

int error;

11599

3890

/* Save index tuple from record to the buffer */

11608

3899

table->status= STATUS_GARBAGE;

11609

3900

return -1;

11610

3901

}

11611

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3902

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11612

3903

tab->insideout_buf, key->key_length));

11613

3904

tab->insideout_match_tab->found_match= 0;

11614

3905

return 0;

11617

3908

return join_read_next_same(info);

11618

3909

}

11619

3910

11620

static int

11621

join_read_next_same(READ_RECORD *info)

3911

int join_read_next_same(READ_RECORD *info)

11622

3912

{

11623

3913

int error;

11624

3914

Table *table= info->table;

11625

JOIN_TAB *tab=table->reginfo.join_tab;

3915

JoinTable *tab=table->reginfo.join_tab;

11626

3916

11627

3917

if ((error=table->file->index_next_same(table->record[0],

11628

3918

tab->ref.key_buff,

11633

3923

table->status= STATUS_GARBAGE;

11634

3924

return -1;

11635

3925

}

3926

11636

3927

return 0;

11637

3928

}

11638

3929

11639

11640

static int

11641

join_read_prev_same(READ_RECORD *info)

3930

int join_read_prev_same(READ_RECORD *info)

11642

3931

{

11643

3932

int error;

11644

3933

Table *table= info->table;

11645

JOIN_TAB *tab=table->reginfo.join_tab;

3934

JoinTable *tab=table->reginfo.join_tab;

11646

3935

11647

3936

if ((error=table->file->index_prev(table->record[0])))

11648

3937

return table->report_error(error);

11655

3944

return error;

11656

3945

}

11657

3946

11658

11659

static int

11660

join_init_quick_read_record(JOIN_TAB *tab)

3947

int join_init_quick_read_record(JoinTable *tab)

11661

3948

{

11662

3949

if (test_if_quick_select(tab) == -1)

11663

3950

return -1; /* No possible records */

11664

3951

return join_init_read_record(tab);

11665

3952

}

11666

3953

11667

11668

3954

int rr_sequential(READ_RECORD *info);

11669

int init_read_record_seq(JOIN_TAB *tab)

3955

int init_read_record_seq(JoinTable *tab)

11670

3956

{

11671

3957

tab->read_record.read_record= rr_sequential;

11672

3958

if (tab->read_record.file->ha_rnd_init(1))

11674

3960

return (*tab->read_record.read_record)(&tab->read_record);

11675

3961

}

11676

3962

11677

static int

11678

test_if_quick_select(JOIN_TAB *tab)

3963

int test_if_quick_select(JoinTable *tab)

11679

3964

{

11680

3965

delete tab->select->quick;

11681

tab->select->quick=0;

11682

return tab->select->test_quick_select(tab->join->thd, tab->keys,

11683

(table_map) 0, HA_POS_ERROR, 0,

11684

false);

3966

tab->select->quick= 0;

3967

return tab->select->test_quick_select(tab->join->session, tab->keys,

3968

(table_map) 0, HA_POS_ERROR, 0, false);

11685

3969

}

11686

3970

11687

11688

static int

11689

join_init_read_record(JOIN_TAB *tab)

3971

int join_init_read_record(JoinTable *tab)

11690

3972

{

11691

3973

if (tab->select && tab->select->quick && tab->select->quick->reset())

11692

3974

return 1;

11693

init_read_record(&tab->read_record, tab->join->thd, tab->table,

3975

init_read_record(&tab->read_record, tab->join->session, tab->table,

11694

3976

tab->select,1,1);

11695

3977

return (*tab->read_record.read_record)(&tab->read_record);

11696

3978

}

11697

3979

11698

11699

static int

11700

join_read_first(JOIN_TAB *tab)

3980

int join_read_first(JoinTable *tab)

11701

3981

{

11702

3982

int error;

11703

3983

Table *table=tab->table;

11704

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3984

if (!table->key_read && table->covering_keys.test(tab->index) &&

11705

3985

!table->no_keyread)

11706

3986

{

11707

3987

table->key_read=1;

11732

4012

table->report_error(error);

11733

4013

return -1;

11734

4014

}

4015

11735

4016

return 0;

11736

4017

}

11737

4018

11738

11739

static int

11740

join_read_next_different(READ_RECORD *info)

4019

int join_read_next_different(READ_RECORD *info)

11741

4020

{

11742

JOIN_TAB *tab= info->do_insideout_scan;

4021

JoinTable *tab= info->do_insideout_scan;

11743

4022

if (tab->insideout_match_tab->found_match)

11744

4023

{

11745

4024

KEY *key= tab->table->key_info + tab->index;

11746

4025

11747

4026

{

11748

4027

int error;

11749

4028

/* Save index tuple from record to the buffer */

11751

4030

11752

4031

if ((error=info->file->index_next(info->record)))

11753

4032

return info->table->report_error(error);

11754

11755

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

4033

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

11756

4034

tab->insideout_buf, key->key_length));

11757

4035

tab->insideout_match_tab->found_match= 0;

11758

4036

return 0;

11761

4039

return join_read_next(info);

11762

4040

}

11763

4041

11764

11765

static int

11766

join_read_next(READ_RECORD *info)

4042

int join_read_next(READ_RECORD *info)

11767

4043

{

11768

4044

int error;

11769

4045

if ((error=info->file->index_next(info->record)))

11771

4047

return 0;

11772

4048

}

11773

4049

11774

11775

static int

11776

join_read_last(JOIN_TAB *tab)

4050

int join_read_last(JoinTable *tab)

11777

4051

{

11778

4052

Table *table=tab->table;

11779

4053

int error;

11780

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

4054

if (!table->key_read && table->covering_keys.test(tab->index) &&

11781

4055

!table->no_keyread)

11782

4056

{

11783

4057

table->key_read=1;

11793

4067

table->file->ha_index_init(tab->index, 1);

11794

4068

if ((error= tab->table->file->index_last(tab->table->record[0])))

11795

4069

return table->report_error(error);

4070

11796

4071

return 0;

11797

4072

}

11798

4073

11799

11800

static int

11801

join_read_prev(READ_RECORD *info)

4074

int join_read_prev(READ_RECORD *info)

11802

4075

{

11803

4076

int error;

11804

4077

if ((error= info->file->index_prev(info->record)))

11805

4078

return info->table->report_error(error);

4079

11806

4080

return 0;

11807

4081

}

11808

4082

11809

4083

/**

11810

4084

Reading of key with key reference and one part that may be NULL.

11811

4085

11812

11813

int

11814

join_read_always_key_or_null(JOIN_TAB *tab)

4086

int join_read_always_key_or_null(JoinTable *tab)

11815

4087

{

11816

4088

int res;

11817

4089

11825

4097

return safe_index_read(tab);

11826

4098

}

11827

4099

11828

11829

int

11830

join_read_next_same_or_null(READ_RECORD *info)

4100

int join_read_next_same_or_null(READ_RECORD *info)

11831

4101

{

11832

4102

int error;

11833

4103

if ((error= join_read_next_same(info)) >= 0)

11834

4104

return error;

11835

JOIN_TAB *tab= info->table->reginfo.join_tab;

4105

JoinTable *tab= info->table->reginfo.join_tab;

11836

4106

11837

4107

/* Test if we have already done a read after null key */

11838

4108

if (*tab->ref.null_ref_key)

11841

4111

return safe_index_read(tab); // then read null keys

11842

4112

}

11843

4113

11844

11845

/*****************************************************************************

11846

DESCRIPTION

11847

Functions that end one nested loop iteration. Different functions

11848

are used to support GROUP BY clause and to redirect records

11849

to a table (e.g. in case of SELECT into a temporary table) or to the

11850

network client.

11851

11852

RETURN VALUES

11853

NESTED_LOOP_OK - the record has been successfully handled

11854

NESTED_LOOP_ERROR - a fatal error (like table corruption)

11855

was detected

11856

NESTED_LOOP_KILLED - thread shutdown was requested while processing

11857

the record

11858

NESTED_LOOP_QUERY_LIMIT - the record has been successfully handled;

11859

additionally, the nested loop produced the

11860

number of rows specified in the LIMIT clause

11861

for the query

11862

NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;

11863

additionally, there is a cursor and the nested

11864

loop algorithm produced the number of rows

11865

that is specified for current cursor fetch

11866

operation.

11867

All return values except NESTED_LOOP_OK abort the nested loop.

11868

*****************************************************************************/

11869

11870

/* ARGSUSED */

11871

static enum_nested_loop_state

11872

end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11873

bool end_of_records)

11874

{

11875

if (!end_of_records)

11876

{

11877

int error;

11878

if (join->having && join->having->val_int() == 0)

11879

return(NESTED_LOOP_OK); // Didn't match having

11880

error=0;

11881

if (join->do_send_rows)

11882

error=join->result->send_data(*join->fields);

11883

if (error)

11884

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11885

if (++join->send_records >= join->unit->select_limit_cnt &&

11886

join->do_send_rows)

11887

{

11888

if (join->select_options & OPTION_FOUND_ROWS)

11889

{

11890

JOIN_TAB *jt=join->join_tab;

11891

if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group

11892

&& !join->send_group_parts && !join->having && !jt->select_cond &&

11893

!(jt->select && jt->select->quick) &&

11894

(jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&

11895

(jt->ref.key < 0))

11896

{

11897

/* Join over all rows in table; Return number of found rows */

11898

Table *table=jt->table;

11899

11900

join->select_options ^= OPTION_FOUND_ROWS;

11901

if (table->sort.record_pointers ||

11902

(table->sort.io_cache && my_b_inited(table->sort.io_cache)))

11903

{

11904

/* Using filesort */

11905

join->send_records= table->sort.found_records;

11906

}

11907

else

11908

{

11909

table->file->info(HA_STATUS_VARIABLE);

11910

join->send_records= table->file->stats.records;

11911

}

11912

}

11913

else

11914

{

11915

join->do_send_rows= 0;

11916

if (join->unit->fake_select_lex)

11917

join->unit->fake_select_lex->select_limit= 0;

11918

return(NESTED_LOOP_OK);

11919

}

11920

}

11921

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11922

}

11923

else if (join->send_records >= join->fetch_limit)

11924

{

11925

11926

There is a server side cursor and all rows for

11927

this fetch request are sent.

11928

11929

return(NESTED_LOOP_CURSOR_LIMIT);

11930

}

11931

}

11932

11933

return(NESTED_LOOP_OK);

11934

}

11935

11936

11937

/* ARGSUSED */

11938

enum_nested_loop_state

11939

end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

11940

bool end_of_records)

4114

enum_nested_loop_state end_send_group(JOIN *join, JoinTable *, bool end_of_records)

11941

4115

{

11942

4116

int idx= -1;

11943

4117

enum_nested_loop_state ok_code= NESTED_LOOP_OK;

11945

4119

if (!join->first_record || end_of_records ||

11946

4120

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

11947

4121

{

11948

if (join->first_record ||

4122

if (join->first_record ||

11949

4123

(end_of_records && !join->group && !join->group_optimized_away))

11950

4124

{

11951

4125

if (idx < (int) join->send_group_parts)

11952

4126

{

11953

int error=0;

11954

{

11955

if (!join->first_record)

11956

{

11957

List_iterator_fast<Item> it(*join->fields);

11958

Item *item;

11959

/* No matching rows for group function */

11960

join->clear();

4127

int error=0;

4128

{

4129

if (!join->first_record)

4130

{

4131

List_iterator_fast<Item> it(*join->fields);

4132

Item *item;

4133

/* No matching rows for group function */

4134

join->clear();

11961

4135

11962

4136

while ((item= it++))

11963

4137

item->no_rows_in_result();

11964

}

11965

if (join->having && join->having->val_int() == 0)

11966

error= -1; // Didn't satisfy having

11967

else

11968

{

11969

if (join->do_send_rows)

11970

error=join->result->send_data(*join->fields) ? 1 : 0;

11971

join->send_records++;

11972

}

11973

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

11974

{

11975

if (join->rollup_send_data((uint) (idx+1)))

11976

error= 1;

11977

}

11978

}

11979

if (error > 0)

11980

return(NESTED_LOOP_ERROR); /* purecov: inspected */

11981

if (end_of_records)

11982

return(NESTED_LOOP_OK);

11983

if (join->send_records >= join->unit->select_limit_cnt &&

11984

join->do_send_rows)

11985

{

11986

if (!(join->select_options & OPTION_FOUND_ROWS))

11987

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

11988

join->do_send_rows=0;

11989

join->unit->select_limit_cnt = HA_POS_ERROR;

4138

}

4139

if (join->having && join->having->val_int() == 0)

4140

error= -1; // Didn't satisfy having

4141

else

4142

{

4143

if (join->do_send_rows)

4144

error=join->result->send_data(*join->fields) ? 1 : 0;

4145

join->send_records++;

4146

}

4147

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

4148

{

4149

if (join->rollup_send_data((uint32_t) (idx+1)))

4150

error= 1;

4151

}

4152

}

4153

if (error > 0)

4154

return(NESTED_LOOP_ERROR);

4155

if (end_of_records)

4156

return(NESTED_LOOP_OK);

4157

if (join->send_records >= join->unit->select_limit_cnt &&

4158

join->do_send_rows)

4159

{

4160

if (!(join->select_options & OPTION_FOUND_ROWS))

4161

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

4162

join->do_send_rows=0;

4163

join->unit->select_limit_cnt = HA_POS_ERROR;

11990

4164

}

11991

4165

else if (join->send_records >= join->fetch_limit)

11992

4166

{

12005

4179

else

12006

4180

{

12007

4181

if (end_of_records)

12008

return(NESTED_LOOP_OK);

4182

return(NESTED_LOOP_OK);

12009

4183

join->first_record=1;

12010

4184

test_if_item_cache_changed(join->group_fields);

12011

4185

}

12017

4191

12018

4192

copy_fields(&join->tmp_table_param);

12019

4193

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

12020

return(NESTED_LOOP_ERROR);

4194

return(NESTED_LOOP_ERROR);

12021

4195

return(ok_code);

12022

4196

}

12023

4197

}

12026

4200

return(NESTED_LOOP_OK);

12027

4201

}

12028

4202

12029

12030

/* ARGSUSED */

12031

enum_nested_loop_state

12032

end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12033

bool end_of_records)

12034

{

12035

Table *table=join->tmp_table;

12036

12037

if (join->thd->killed) // Aborted by user

12038

{

12039

join->thd->send_kill_message();

12040

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12041

}

12042

if (!end_of_records)

12043

{

12044

copy_fields(&join->tmp_table_param);

12045

copy_funcs(join->tmp_table_param.items_to_copy);

12046

#ifdef TO_BE_DELETED

12047

if (!table->uniques) // If not unique handling

12048

{

12049

/* Copy null values from group to row */

12050

order_st *group;

12051

for (group=table->group ; group ; group=group->next)

12052

{

12053

Item *item= *group->item;

12054

if (item->maybe_null)

12055

{

12056

Field *field=item->get_tmp_table_field();

12057

field->ptr[-1]= (unsigned char) (field->is_null() ? 1 : 0);

12058

}

12059

}

12060

}

12061

#endif

12062

if (!join->having || join->having->val_int())

12063

{

12064

int error;

12065

join->found_records++;

12066

if ((error=table->file->ha_write_row(table->record[0])))

12067

{

12068

if (!table->file->is_fatal_error(error, HA_CHECK_DUP))

12069

goto end;

12070

if (create_myisam_from_heap(join->thd, table,

12071

join->tmp_table_param.start_recinfo,

12072

&join->tmp_table_param.recinfo,

12073

error, 1))

12074

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12075

table->s->uniques=0; // To ensure rows are the same

12076

}

12077

if (++join->send_records >= join->tmp_table_param.end_write_records &&

12078

join->do_send_rows)

12079

{

12080

if (!(join->select_options & OPTION_FOUND_ROWS))

12081

return(NESTED_LOOP_QUERY_LIMIT);

12082

join->do_send_rows=0;

12083

join->unit->select_limit_cnt = HA_POS_ERROR;

12084

return(NESTED_LOOP_OK);

12085

}

12086

}

12087

}

12088

end:

12089

return(NESTED_LOOP_OK);

12090

}

12091

12092

/* ARGSUSED */

12093

/** Group by searching after group record and updating it if possible. */

12094

12095

static enum_nested_loop_state

12096

end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12097

bool end_of_records)

12098

{

12099

Table *table=join->tmp_table;

12100

order_st *group;

12101

int error;

12102

12103

if (end_of_records)

12104

return(NESTED_LOOP_OK);

12105

if (join->thd->killed) // Aborted by user

12106

{

12107

join->thd->send_kill_message();

12108

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12109

}

12110

12111

join->found_records++;

12112

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12113

/* Make a key of group index */

12114

for (group=table->group ; group ; group=group->next)

12115

{

12116

Item *item= *group->item;

12117

item->save_org_in_field(group->field);

12118

/* Store in the used key if the field was 0 */

12119

if (item->maybe_null)

12120

group->buff[-1]= (char) group->field->is_null();

12121

}

12122

if (!table->file->index_read_map(table->record[1],

12123

join->tmp_table_param.group_buff,

12124

HA_WHOLE_KEY,

12125

HA_READ_KEY_EXACT))

12126

{ /* Update old record */

12127

restore_record(table,record[1]);

12128

update_tmptable_sum_func(join->sum_funcs,table);

12129

if ((error=table->file->ha_update_row(table->record[1],

12130

table->record[0])))

12131

{

12132

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12133

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12134

}

12135

return(NESTED_LOOP_OK);

12136

}

12137

12138

12139

Copy null bits from group key to table

12140

We can't copy all data as the key may have different format

12141

as the row data (for example as with VARCHAR keys)

12142

12143

KEY_PART_INFO *key_part;

12144

for (group=table->group,key_part=table->key_info[0].key_part;

12145

group ;

12146

group=group->next,key_part++)

12147

{

12148

if (key_part->null_bit)

12149

memcpy(table->record[0]+key_part->offset, group->buff, 1);

12150

}

12151

init_tmptable_sum_functions(join->sum_funcs);

12152

copy_funcs(join->tmp_table_param.items_to_copy);

12153

if ((error=table->file->ha_write_row(table->record[0])))

12154

{

12155

if (create_myisam_from_heap(join->thd, table,

12156

join->tmp_table_param.start_recinfo,

12157

&join->tmp_table_param.recinfo,

12158

error, 0))

12159

return(NESTED_LOOP_ERROR); // Not a table_is_full error

12160

/* Change method to update rows */

12161

table->file->ha_index_init(0, 0);

12162

join->join_tab[join->tables-1].next_select=end_unique_update;

12163

}

12164

join->send_records++;

12165

return(NESTED_LOOP_OK);

12166

}

12167

12168

12169

/** Like end_update, but this is done with unique constraints instead of keys. */

12170

12171

static enum_nested_loop_state

12172

end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12173

bool end_of_records)

12174

{

12175

Table *table=join->tmp_table;

12176

int error;

12177

12178

if (end_of_records)

12179

return(NESTED_LOOP_OK);

12180

if (join->thd->killed) // Aborted by user

12181

{

12182

join->thd->send_kill_message();

12183

return(NESTED_LOOP_KILLED); /* purecov: inspected */

12184

}

12185

12186

init_tmptable_sum_functions(join->sum_funcs);

12187

copy_fields(&join->tmp_table_param); // Groups are copied twice.

12188

copy_funcs(join->tmp_table_param.items_to_copy);

12189

12190

if (!(error=table->file->ha_write_row(table->record[0])))

12191

join->send_records++; // New group

12192

else

12193

{

12194

if ((int) table->file->get_dup_key(error) < 0)

12195

{

12196

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12197

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12198

}

12199

if (table->file->rnd_pos(table->record[1],table->file->dup_ref))

12200

{

12201

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12202

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12203

}

12204

restore_record(table,record[1]);

12205

update_tmptable_sum_func(join->sum_funcs,table);

12206

if ((error=table->file->ha_update_row(table->record[1],

12207

table->record[0])))

12208

{

12209

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12210

return(NESTED_LOOP_ERROR); /* purecov: inspected */

12211

}

12212

}

12213

return(NESTED_LOOP_OK);

12214

}

12215

12216

12217

/* ARGSUSED */

12218

enum_nested_loop_state

12219

end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

12220

bool end_of_records)

4203

enum_nested_loop_state end_write_group(JOIN *join, JoinTable *, bool end_of_records)

12221

4204

{

12222

4205

Table *table=join->tmp_table;

12223

4206

int idx= -1;

12224

4207

12225

if (join->thd->killed)

4208

if (join->session->killed)

12226

4209

{ // Aborted by user

12227

join->thd->send_kill_message();

12228

return(NESTED_LOOP_KILLED); /* purecov: inspected */

4210

join->session->send_kill_message();

4211

return NESTED_LOOP_KILLED;

12229

4212

}

12230

4213

if (!join->first_record || end_of_records ||

12231

4214

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

12235

4218

int send_group_parts= join->send_group_parts;

12236

4219

if (idx < send_group_parts)

12237

4220

{

12238

if (!join->first_record)

12239

{

12240

/* No matching rows for group function */

12241

join->clear();

12242

}

12243

copy_sum_funcs(join->sum_funcs,

12244

join->sum_funcs_end[send_group_parts]);

12245

if (!join->having || join->having->val_int())

12246

{

4221

if (!join->first_record)

4222

{

4223

/* No matching rows for group function */

4224

join->clear();

4225

}

4226

copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);

4227

if (!join->having || join->having->val_int())

4228

{

12247

4229

int error= table->file->ha_write_row(table->record[0]);

12248

if (error && create_myisam_from_heap(join->thd, table,

12249

join->tmp_table_param.start_recinfo,

4230

if (error && create_myisam_from_heap(join->session, table,

4231

join->tmp_table_param.start_recinfo,

12250

4232

&join->tmp_table_param.recinfo,

12251

error, 0))

12252

return(NESTED_LOOP_ERROR);

4233

error, 0))

4234

return NESTED_LOOP_ERROR;

12253

4235

}

12254

4236

if (join->rollup.state != ROLLUP::STATE_NONE)

12255

{

12256

if (join->rollup_write_data((uint) (idx+1), table))

12257

return(NESTED_LOOP_ERROR);

12258

}

12259

if (end_of_records)

12260

return(NESTED_LOOP_OK);

4237

{

4238

if (join->rollup_write_data((uint32_t) (idx+1), table))

4239

return NESTED_LOOP_ERROR;

4240

}

4241

if (end_of_records)

4242

return NESTED_LOOP_OK;

12261

4243

}

12262

4244

}

12263

4245

else

12264

4246

{

12265

4247

if (end_of_records)

12266

return(NESTED_LOOP_OK);

4248

return NESTED_LOOP_OK;

12267

4249

join->first_record=1;

12268

4250

test_if_item_cache_changed(join->group_fields);

12269

4251

}

12272

4254

copy_fields(&join->tmp_table_param);

12273

4255

copy_funcs(join->tmp_table_param.items_to_copy);

12274

4256

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

12275

return(NESTED_LOOP_ERROR);

12276

return(NESTED_LOOP_OK);

4257

return NESTED_LOOP_ERROR;

4258

return NESTED_LOOP_OK;

12277

4259

}

12278

4260

}

12279

4261

if (update_sum_func(join->sum_funcs))

12280

return(NESTED_LOOP_ERROR);

12281

return(NESTED_LOOP_OK);

4262

return NESTED_LOOP_ERROR;

4263

return NESTED_LOOP_OK;

12282

4264

}

12283

4265

12284

12285

4266

/*****************************************************************************

12286

4267

Remove calculation with tables that aren't yet read. Remove also tests

12287

4268

against fields that are read through key where the table is not a

12294

4275

@return

12295

4276

1 if right_item is used removable reference key on left_item

12296

4277

12297

12298

static bool test_if_ref(Item_field *left_item,Item *right_item)

4278

bool test_if_ref(Item_field *left_item,Item *right_item)

12299

4279

{

12300

4280

Field *field=left_item->field;

12301

4281

// No need to change const test. We also have to keep tests on LEFT JOIN

12306

4286

{

12307

4287

right_item= right_item->real_item();

12308

4288

if (right_item->type() == Item::FIELD_ITEM)

12309

return (field->eq_def(((Item_field *) right_item)->field));

4289

return (field->eq_def(((Item_field *) right_item)->field));

12310

4290

/* remove equalities injected by IN->EXISTS transformation */

12311

4291

else if (right_item->type() == Item::CACHE_ITEM)

12312

4292

return ((Item_cache *)right_item)->eq_def (field);

12313

4293

if (right_item->const_item() && !(right_item->is_null()))

12314

4294

{

12315

12316

We can remove binary fields and numerical fields except float,

12317

as float comparison isn't 100 % secure

12318

We have to keep normal strings to be able to check for end spaces

4295

4296

We can remove binary fields and numerical fields except float,

4297

as float comparison isn't 100 % secure

4298

We have to keep normal strings to be able to check for end spaces

12319

4299

12320

sergefp: the above seems to be too restrictive. Counterexample:

12321

create table t100 (v varchar(10), key(v)) default charset=latin1;

12322

insert into t100 values ('a'),('a ');

12323

explain select * from t100 where v='a';

12324

The EXPLAIN shows 'using Where'. Running the query returns both

12325

rows, so it seems there are no problems with endspace in the most

12326

frequent case?

12327

12328

if (field->binary() &&

12329

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

12330

field->decimals() == 0)

12331

{

12332

return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);

12333

}

4300

sergefp: the above seems to be too restrictive. Counterexample:

4301

create table t100 (v varchar(10), key(v)) default charset=latin1;

4302

insert into t100 values ('a'),('a ');

4303

explain select * from t100 where v='a';

4304

The EXPLAIN shows 'using Where'. Running the query returns both

4305

rows, so it seems there are no problems with endspace in the most

4306

frequent case?

4307

4308

if (field->binary() &&

4309

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

4310

field->decimals() == 0)

4311

{

4312

return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);

4313

}

12334

4314

}

12335

4315

}

12336

4316

}

12337

return 0; // keep test

12338

}

12339

12340

/**

12341

@brief Replaces an expression destructively inside the expression tree of

12342

the WHERE clase.

12343

12344

@note Because of current requirements for semijoin flattening, we do not

12345

need to recurse here, hence this function will only examine the top-level

12346

AND conditions. (see JOIN::prepare, comment above the line

12347

'if (do_materialize)'

12348

12349

@param join The top-level query.

12350

@param old_cond The expression to be replaced.

12351

@param new_cond The expression to be substituted.

12352

@param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for

12353

the new expression.

12354

@return <code>true</code> if there was an error, <code>false</code> if

12355

successful.

12356

12357

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

12358

Item *new_cond, bool do_fix_fields)

12359

{

12360

if (join->conds == old_cond) {

12361

join->conds= new_cond;

12362

if (do_fix_fields)

12363

new_cond->fix_fields(join->thd, &join->conds);

12364

return false;

12365

}

12366

12367

if (join->conds->type() == Item::COND_ITEM) {

12368

List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());

12369

Item *item;

12370

while ((item= li++))

12371

if (item == old_cond)

12372

{

12373

li.replace(new_cond);

12374

if (do_fix_fields)

12375

new_cond->fix_fields(join->thd, li.ref());

12376

return false;

12377

}

12378

}

12379

12380

return true;

4317

return 0;

12381

4318

}

12382

4319

12383

4320

12384

4321

Extract a condition that can be checked after reading given table

12385

4322

12386

4323

SYNOPSIS

12387

4324

make_cond_for_table()

12388

4325

cond Condition to analyze

12389

4326

tables Tables for which "current field values" are available

12390

used_table Table that we're extracting the condition for (may

4327

used_table Table that we're extracting the condition for (may

12391

4328

also include PSEUDO_TABLE_BITS

12392

4329

12393

4330

DESCRIPTION

12397

4334

12398

4335

The function assumes that

12399

4336

- Constant parts of the condition has already been checked.

12400

- Condition that could be checked for tables in 'tables' has already

4337

- Condition that could be checked for tables in 'tables' has already

12401

4338

been checked.

12402

4339

12403

4340

The function takes into account that some parts of the condition are

12404

4341

guaranteed to be true by employed 'ref' access methods (the code that

12405

4342

does this is located at the end, search down for "EQ_FUNC").

12406

4343

12407

4344

12408