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

2231

{ /* Must copy to another table */

2232

/* Free first data from old join */

2233

curr_join->join_free();

2234

if (make_simple_join(curr_join, curr_tmp_table))

2235

return;

2236

calc_group_buffer(curr_join, group_list);

2237

count_field_types(select_lex, &curr_join->tmp_table_param,

2238

curr_join->tmp_all_fields1,

2239

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

2240

curr_join->tmp_table_param.hidden_field_count=

2241

(curr_join->tmp_all_fields1.elements-

2242

curr_join->tmp_fields_list1.elements);

2243

2244

2245

if (exec_tmp_table2)

2246

curr_tmp_table= exec_tmp_table2;

2247

else

2248

{

2249

/* group data to new table */

2250

2251

2252

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

2253

functions are precomputed, and should be treated as regular

2254

functions. See extended comment in JOIN::exec.

2255

2256

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

2257

curr_join->tmp_table_param.precomputed_group_by= true;

2258

2259

if (!(curr_tmp_table=

2260

exec_tmp_table2= create_tmp_table(thd,

2261

&curr_join->tmp_table_param,

2262

*curr_all_fields,

2263

(ORDER*) 0,

2264

curr_join->select_distinct &&

2265

!curr_join->group_list,

2266

1, curr_join->select_options,

2267

HA_POS_ERROR,

2268

(char *) "")))

2269

return;

2270

curr_join->exec_tmp_table2= exec_tmp_table2;

2271

}

2272

if (curr_join->group_list)

2273

{

2274

thd_proc_info(thd, "Creating sort index");

2275

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

2276

{

2277

return;

2278

}

2279

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

2280

HA_POS_ERROR, HA_POS_ERROR, false) ||

2281

make_group_fields(this, curr_join))

2282

{

2283

return;

2284

}

2285

sortorder= curr_join->sortorder;

2286

}

2287

2288

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

2289

tmp_error= -1;

2290

if (curr_join != this)

2291

{

2292

if (sum_funcs2)

2293

{

2294

curr_join->sum_funcs= sum_funcs2;

2295

curr_join->sum_funcs_end= sum_funcs_end2;

2296

}

2297

else

2298

{

2299

curr_join->alloc_func_list();

2300

sum_funcs2= curr_join->sum_funcs;

2301

sum_funcs_end2= curr_join->sum_funcs_end;

2302

}

2303

}

2304

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

2305

1, true))

2306

return;

2307

curr_join->group_list= 0;

2308

if (!curr_join->sort_and_group &&

2309

curr_join->const_tables != curr_join->tables)

2310

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

2311

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

2312

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

2313

{

2314

error= tmp_error;

2315

return;

2316

}

2317

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

2318

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

2319

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

2320

2321

// No sum funcs anymore

2322

if (!items2)

2323

{

2324

items2= items1 + all_fields.elements;

2325

if (change_to_use_tmp_fields(thd, items2,

2326

tmp_fields_list2, tmp_all_fields2,

2327

fields_list.elements, tmp_all_fields1))

2328

return;

2329

curr_join->tmp_fields_list2= tmp_fields_list2;

2330

curr_join->tmp_all_fields2= tmp_all_fields2;

2331

}

2332

curr_fields_list= &curr_join->tmp_fields_list2;

2333

curr_all_fields= &curr_join->tmp_all_fields2;

2334

curr_join->set_items_ref_array(items2);

2335

curr_join->tmp_table_param.field_count+=

2336

curr_join->tmp_table_param.sum_func_count;

2337

curr_join->tmp_table_param.sum_func_count= 0;

2338

}

2339

if (curr_tmp_table->distinct)

2340

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

2341

2342

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

2343

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

2344

{

2345

thd_proc_info(thd, "Removing duplicates");

2346

if (curr_join->tmp_having)

2347

curr_join->tmp_having->update_used_tables();

2348

if (remove_duplicates(curr_join, curr_tmp_table,

2349

*curr_fields_list, curr_join->tmp_having))

2350

return;

2351

curr_join->tmp_having=0;

2352

curr_join->select_distinct=0;

2353

}

2354

curr_tmp_table->reginfo.lock_type= TL_UNLOCK;

2355

if (make_simple_join(curr_join, curr_tmp_table))

2356

return;

2357

calc_group_buffer(curr_join, curr_join->group_list);

2358

count_field_types(select_lex, &curr_join->tmp_table_param,

2359

*curr_all_fields, 0);

2360

2361

}

2362

2363

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

2364

{

2365

if (make_group_fields(this, curr_join))

2366

{

2367

return;

2368

}

2369

if (!items3)

2370

{

2371

if (!items0)

2372

init_items_ref_array();

2373

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

2374

setup_copy_fields(thd, &curr_join->tmp_table_param,

2375

items3, tmp_fields_list3, tmp_all_fields3,

2376

curr_fields_list->elements, *curr_all_fields);

2377

tmp_table_param.save_copy_funcs= curr_join->tmp_table_param.copy_funcs;

2378

tmp_table_param.save_copy_field= curr_join->tmp_table_param.copy_field;

2379

tmp_table_param.save_copy_field_end=

2380

curr_join->tmp_table_param.copy_field_end;

2381

curr_join->tmp_all_fields3= tmp_all_fields3;

2382

curr_join->tmp_fields_list3= tmp_fields_list3;

2383

}

2384

else

2385

{

2386

curr_join->tmp_table_param.copy_funcs= tmp_table_param.save_copy_funcs;

2387

curr_join->tmp_table_param.copy_field= tmp_table_param.save_copy_field;

2388

curr_join->tmp_table_param.copy_field_end=

2389

tmp_table_param.save_copy_field_end;

2390

}

2391

curr_fields_list= &tmp_fields_list3;

2392

curr_all_fields= &tmp_all_fields3;

2393

curr_join->set_items_ref_array(items3);

2394

2395

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

2396

1, true) ||

2397

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

2398

thd->is_fatal_error)

2399

return;

2400

}

2401

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

2402

{

2403

thd_proc_info(thd, "Sorting result");

2404

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

2405

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

2406

! curr_join->sort_and_group)

2407

{

2408

// Some tables may have been const

2409

curr_join->tmp_having->update_used_tables();

2410

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

2411

table_map used_tables= (curr_join->const_table_map |

2412

curr_table->table->map);

2413

2414

Item* sort_table_cond= make_cond_for_table(curr_join->tmp_having,

2415

used_tables,

2416

used_tables, 0);

2417

if (sort_table_cond)

2418

{

2419

if (!curr_table->select)

2420

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

2421

return;

2422

if (!curr_table->select->cond)

2423

curr_table->select->cond= sort_table_cond;

2424

else // This should never happen

2425

{

2426

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

2427

new Item_cond_and(curr_table->select->cond,

2428

sort_table_cond)))

2429

return;

2430

2431

Item_cond_and do not need fix_fields for execution, its parameters

2432

are fixed or do not need fix_fields, too

2433

2434

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

2435

}

2436

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

2437

curr_table->select_cond->top_level_item();

2438

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

2439

~ (table_map) 0,

2440

~used_tables, 0);

2441

}

2442

}

2443

{

2444

if (group)

2445

curr_join->select_limit= HA_POS_ERROR;

2446

else

2447

{

2448

2449

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

2450

WHERE clause for any tables after the sorted one.

2451

2452

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

2453

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

2454

for (; curr_table < end_table ; curr_table++)

2455

{

2456

2457

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

2458

on the table that was optimized away.

2459

2460

if (curr_table->select_cond ||

2461

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

2462

{

2463

/* We have to sort all rows */

2464

curr_join->select_limit= HA_POS_ERROR;

2465

break;

2466

}

2467

}

2468

}

2469

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

2470

{

2471

return;

2472

}

2473

2474

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

2475

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

2476

suitable index present.

2477

Note, that create_sort_index calls test_if_skip_sort_order and may

2478

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

2479

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

2480

OPTION_FOUND_ROWS supersedes LIMIT and is taken into account.

2481

2482

if (create_sort_index(thd, curr_join,

2483

curr_join->group_list ?

2484

curr_join->group_list : curr_join->order,

2485

curr_join->select_limit,

2486

(select_options & OPTION_FOUND_ROWS ?

2487

HA_POS_ERROR : unit->select_limit_cnt),

2488

curr_join->group_list ? true : false))

2489

return;

2490

sortorder= curr_join->sortorder;

2491

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

2492

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

2493

{

2494

2495

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

2496

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

2497

attribute on the INDEX SCAN.

2498

2499

skip_sort_order= 1;

2500

}

2501

}

2502

}

2503

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

2504

if (thd->is_error())

2505

{

2506

error= thd->is_error();

2507

return;

2508

}

2509

curr_join->having= curr_join->tmp_having;

2510

curr_join->fields= curr_fields_list;

2511

2512

{

2513

thd_proc_info(thd, "Sending data");

2514

result->send_fields(*curr_fields_list,

2515

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF);

2516

error= do_select(curr_join, curr_fields_list, NULL);

2517

thd->limit_found_rows= curr_join->send_records;

2518

}

2519

2520

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

2521

thd->examined_row_count+= curr_join->examined_rows;

2522

2523

2524

With EXPLAIN EXTENDED we have to restore original ref_array

2525

for a derived table which is always materialized.

2526

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

2527

2528

if (items0 &&

2529

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

2530

select_lex->linkage == DERIVED_TABLE_TYPE)

2531

set_items_ref_array(items0);

2532

2533

return;

2534

}

2535

2536

2537

/**

2538

Clean up join.

2539

2540

@return

2541

Return error that hold JOIN.

2542

2543

2544

int

2545

JOIN::destroy()

2546

{

2547

select_lex->join= 0;

2548

2549

if (tmp_join)

2550

{

2551

if (join_tab != tmp_join->join_tab)

2552

{

2553

JOIN_TAB *tab, *end;

2554

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

2555

tab->cleanup();

2556

}

2557

tmp_join->tmp_join= 0;

2558

tmp_table_param.copy_field=0;

2559

return(tmp_join->destroy());

2560

}

2561

cond_equal= 0;

2562

2563

cleanup(1);

2564

if (exec_tmp_table1)

2565

free_tmp_table(thd, exec_tmp_table1);

2566

if (exec_tmp_table2)

2567

free_tmp_table(thd, exec_tmp_table2);

2568

delete select;

2569

delete_dynamic(&keyuse);

2570

return(error);

2571

}

2572

2573

2574

2575

305

/**

2576

306

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

2577

307

2578

@param thd thread handler

308

@param session thread Cursor

2579

309

@param rref_pointer_array a reference to ref_pointer_array of

2580

310

the top-level select_lex for this query

2581

311

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

2582

312

The tables have been pre-opened.

2583

@param wild_num number of wildcards used in the top level

313

@param wild_num number of wildcards used in the top level

2584

314

select of this query.

2585

315

For example statement

2586

316

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

2591

321

for a, b and c in this list.

2592

322

@param conds top level item of an expression representing

2593

323

WHERE clause of the top level select

2594

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

324

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

2595

325

arguments

2596

@param order linked list of ORDER BY agruments

326

@param order linked list of order_st BY agruments

2597

327

@param group linked list of GROUP BY arguments

2598

328

@param having top level item of HAVING expression

2599

@param proc_param list of PROCEDUREs

2600

329

@param select_options select options (BIG_RESULT, etc)

2601

330

@param result an instance of result set handling class.

2602

331

This object is responsible for send result

2603

332

set rows to the client or inserting them

2604

333

into a table.

2605

@param select_lex the only SELECT_LEX of this query

334

@param select_lex the only Select_Lex of this query

2606

335

@param unit top-level UNIT of this query

2607

336

UNIT is an artificial object created by the

2608

337

parser for every SELECT clause.

2615

344

@retval

2616

345

true an error

2617

346

2618

2619

bool

2620

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

2621

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

2622

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

2623

Item *having, ORDER *proc_param, uint64_t select_options,

2624

select_result *result, SELECT_LEX_UNIT *unit,

2625

SELECT_LEX *select_lex)

347

bool mysql_select(Session *session,

348

Item ***rref_pointer_array,

349

TableList *tables,

350

uint32_t wild_num,

351

List<Item> &fields,

352

COND *conds,

353

uint32_t og_num,

354

order_st *order,

355

order_st *group,

356

Item *having,

357

uint64_t select_options,

358

select_result *result,

359

Select_Lex_Unit *unit,

360

Select_Lex *select_lex)

2626

361

{

2627

362

bool err;

2628

363

bool free_join= 1;

2637

372

creation

2638

373

2639

374

if (select_lex->linkage != DERIVED_TABLE_TYPE ||

2640

(select_options & SELECT_DESCRIBE))

375

(select_options & SELECT_DESCRIBE))

2641

376

{

2642

377

if (select_lex->linkage != GLOBAL_OPTIONS_TYPE)

2643

378

{

2644

//here is EXPLAIN of subselect or derived table

2645

if (join->change_result(result))

2646

{

2647

return(true);

2648

}

379

//here is EXPLAIN of subselect or derived table

380

if (join->change_result(result))

381

{

382

return(true);

383

}

2649

384

}

2650

385

else

2651

386

{

2652

387

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

2653

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

2654

select_lex, unit)))

2655

{

2656

goto err;

2657

}

388

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

389

{

390

goto err;

391

}

2658

392

}

2659

393

}

2660

394

free_join= 0;

2662

396

}

2663

397

else

2664

398

{

2665

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

2666

return(true);

2667

thd_proc_info(thd, "init");

2668

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

399

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

400

return(true);

401

session->set_proc_info("init");

402

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

2669

403

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

2670

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

404

conds, og_num, order, group, having,

2671

405

select_lex, unit)) == true)

2672

406

{

2673

407

goto err;

2674

408

}

2675

409

}

2676

410

2677

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

2678

if (join->flatten_subqueries())

2679

{

2680

err= 1;

2681

goto err;

2682

}

2683

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

2684

2685

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

2686

{

2687

goto err; // 1

2688

}

2689

2690

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

411

err= join->optimize();

412

if (err)

413

{

414

goto err; // 1

415

}

416

417

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

2691

418

{

2692

419

join->conds_history= join->conds;

2693

420

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

2694

421

}

2695

422

2696

if (thd->is_error())

423

if (session->is_error())

2697

424

goto err;

2698

425

2699

426

join->exec();

2700

427

2701

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

428

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

2702

429

{

2703

430

select_lex->where= join->conds_history;

2704

431

select_lex->having= join->having_history;

2707

434

err:

2708

435

if (free_join)

2709

436

{

2710

thd_proc_info(thd, "end");

437

session->set_proc_info("end");

2711

438

err|= select_lex->cleanup();

2712

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

439

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

2713

440

}

2714

441

return(join->error);

2715

442

}

2716

443

2717

2718

int subq_sj_candidate_cmp(Item_in_subselect* const *el1,

2719

Item_in_subselect* const *el2)

2720

{

2721

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

2722

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

2723

}

2724

2725

2726

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

444

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

2727

445

{

2728

446

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

2729

447

}

2730

448

2731

2732

static TABLE_LIST *alloc_join_nest(THD *thd)

2733

{

2734

TABLE_LIST *tbl;

2735

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

2736

sizeof(NESTED_JOIN))))

2737

return NULL;

2738

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

2739

ALIGN_SIZE(sizeof(TABLE_LIST)));

2740

return tbl;

2741

}

2742

2743

2744

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

2745

{

2746

List_iterator<TABLE_LIST> it(*tlist);

2747

TABLE_LIST *table;

449

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

450

{

451

List_iterator<TableList> it(*tlist);

452

TableList *table;

2748

453

while ((table= it++))

2749

454

{

2750

455

if (table->on_expr)

2754

459

}

2755

460

}

2756

461

2757

2758

2759

Convert a subquery predicate into a TABLE_LIST semi-join nest

2760

2761

SYNOPSIS

2762

convert_subq_to_sj()

2763

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

2764

clause

2765

subq_pred Subquery predicate to be converted

2766

2767

DESCRIPTION

2768

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

2769

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

2770

2771

Prepared Statements: the transformation is permanent:

2772

- Changes in TABLE_LIST structures are naturally permanent

2773

- Item tree changes are performed on statement MEM_ROOT:

2774

= we activate statement MEM_ROOT

2775

= this function is called before the first fix_prepare_information

2776

call.

2777

2778

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

2779

constant for the lifetime of the Prepared Statement.

2780

2781

RETURN

2782

false OK

2783

true Out of memory error

2784

2785

2786

bool convert_subq_to_sj(JOIN *parent_join, Item_in_subselect *subq_pred)

2787

{

2788

SELECT_LEX *parent_lex= parent_join->select_lex;

2789

TABLE_LIST *emb_tbl_nest= NULL;

2790

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

2791

THD *thd= parent_join->thd;

2792

2793

2794

1. Find out where to put the predicate into.

2795

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

2796

2797

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

2798

{

2799

if (subq_pred->expr_join_nest->nested_join)

2800

{

2801

2802

We're dealing with

2803

2804

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

2805

2806

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

2807

2808

emb_tbl_nest= subq_pred->expr_join_nest;

2809

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2810

}

2811

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

2812

{

2813

2814

We're dealing with

2815

2816

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

2817

2818

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

2819

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

2820

2821

emb_tbl_nest= subq_pred->expr_join_nest->embedding;

2822

if (emb_tbl_nest)

2823

emb_join_list= &emb_tbl_nest->nested_join->join_list;

2824

}

2825

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

2826

{

2827

TABLE_LIST *outer_tbl= subq_pred->expr_join_nest;

2828

TABLE_LIST *wrap_nest;

2829

2830

We're dealing with

2831

2832

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

2833

2834

we'll need to convert it into:

2835

2836

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

2837

| |

2838

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

2839

2840

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

2841

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

2842

But we'll need to fix other pointers.

2843

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

2844

subqueries know the table has been nested.

2845

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

2846

automatically.

2847

2848

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

2849

{

2850

return(true);

2851

}

2852

wrap_nest->embedding= outer_tbl->embedding;

2853

wrap_nest->join_list= outer_tbl->join_list;

2854

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

2855

2856

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

2857

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

2858

2859

outer_tbl->embedding= wrap_nest;

2860

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

2861

2862

2863

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

2864

and on_expr

2865

2866

wrap_nest->outer_join= outer_tbl->outer_join;

2867

outer_tbl->outer_join= 0;

2868

2869

wrap_nest->on_expr= outer_tbl->on_expr;

2870

outer_tbl->on_expr= NULL;

2871

2872

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

2873

TABLE_LIST *tbl;

2874

while ((tbl= li++))

2875

{

2876

if (tbl == outer_tbl)

2877

{

2878

li.replace(wrap_nest);

2879

break;

2880

}

2881

}

2882

2883

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

2884

semi-join nest into it

2885

2886

emb_join_list= &wrap_nest->nested_join->join_list;

2887

emb_tbl_nest= wrap_nest;

2888

}

2889

}

2890

2891

TABLE_LIST *sj_nest;

2892

NESTED_JOIN *nested_join;

2893

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

2894

{

2895

return(true);

2896

}

2897

nested_join= sj_nest->nested_join;

2898

2899

sj_nest->join_list= emb_join_list;

2900

sj_nest->embedding= emb_tbl_nest;

2901

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

2902

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

2903

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

2904

emb_join_list->push_back(sj_nest);

2905

2906

2907

nested_join->used_tables and nested_join->not_null_tables are

2908

initialized in simplify_joins().

2909

2910

2911

2912

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

2913

sj-nest.

2914

2915

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

2916

nested_join->join_list.empty();

2917

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

2918

TABLE_LIST *tl, *last_leaf;

2919

while ((tl= li++))

2920

{

2921

tl->embedding= sj_nest;

2922

tl->join_list= &nested_join->join_list;

2923

nested_join->join_list.push_back(tl);

2924

}

2925

2926

2927

Reconnect the next_leaf chain.

2928

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

2929

Inserting them at the beginning would be a bit faster.

2930

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

2931

reversed in this list.

2932

2933

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

2934

tl->next_leaf= subq_lex->leaf_tables;

2935

last_leaf= tl;

2936

2937

2938

Same as above for next_local chain

2939

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

2940

because view's tables are inserted after the view)

2941

2942

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

2943

tl->next_local= subq_lex->leaf_tables;

2944

2945

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

2946

2947

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

2948

2949

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

2950

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

2951

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

2952

2953

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

2954

uint table_no= parent_join->tables;

2955

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

2956

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

2957

{

2958

tl->table->tablenr= table_no;

2959

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

2960

SELECT_LEX *old_sl= tl->select_lex;

2961

tl->select_lex= parent_join->select_lex;

2962

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

2963

emb->select_lex= parent_join->select_lex;

2964

}

2965

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

2966

2967

2968

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

2969

Add the subquery-induced equalities too.

2970

2971

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

2972

thd->lex->current_select=subq_lex;

2973

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

2974

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

2975

return(true);

2976

thd->lex->current_select=save_lex;

2977

2978

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

2979

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

2980

subq_pred->left_expr->used_tables();

2981

sj_nest->sj_on_expr= subq_lex->where;

2982

2983

2984

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

2985

Additionally, for InsideOut strategy

2986

- Record the number of IN-equalities.

2987

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

2988

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

2989

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

2990

2991

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

2992

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

2993

them into Item_direct_view_refs and store pointers to those. The

2994

pointers to Item_direct_view_refs are guaranteed to be stable as

2995

Item_direct_view_refs doesn't substitute itself with anything in

2996

Item_direct_view_ref::fix_fields.

2997

2998

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

2999

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

3000

3001

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

3002

{

3003

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

3004

3005

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

3006

subq_lex->ref_pointer_array[0]);

3007

item_eq->name= (char*)subq_sj_cond_name;

3008

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

3009

}

3010

else

3011

{

3012

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

3013

{

3014

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

3015

element_index(i));

3016

Item *item_eq=

3017

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

3018

subq_lex->ref_pointer_array[i]);

3019

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

3020

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

3021

}

3022

}

3023

/* Fix the created equality and AND */

3024

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

3025

3026

3027

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

3028

item->fix_table_changes() for all items.

3029

3030

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

3031

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

3032

3033

3034

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

3035

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

3036

3037

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

3038

if (emb_tbl_nest)

3039

{

3040

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

3041

sj_nest->sj_on_expr);

3042

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

3043

}

3044

else

3045

{

3046

/* Inject into the WHERE */

3047

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

3048

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

3049

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

3050

}

3051

3052

return(false);

3053

}

3054

3055

3056

3057

Convert candidate subquery predicates to semi-joins

3058

3059

SYNOPSIS

3060

JOIN::flatten_subqueries()

3061

3062

DESCRIPTION

3063

Convert candidate subquery predicates to semi-joins.

3064

3065

RETURN

3066

false OK

3067

true Error

3068

3069

3070

bool JOIN::flatten_subqueries()

3071

{

3072

Item_in_subselect **in_subq;

3073

Item_in_subselect **in_subq_end;

3074

3075

if (sj_subselects.elements() == 0)

3076

return(false);

3077

3078

/* 1. Fix children subqueries */

3079

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

3080

in_subq != in_subq_end; in_subq++)

3081

{

3082

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

3083

child_join->outer_tables = child_join->tables;

3084

if (child_join->flatten_subqueries())

3085

return(true);

3086

(*in_subq)->sj_convert_priority=

3087

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

3088

}

3089

3090

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

3091

3092

2. Pick which subqueries to convert:

3093

sort the subquery array

3094

- prefer correlated subqueries over uncorrelated;

3095

- prefer subqueries that have greater number of outer tables;

3096

3097

sj_subselects.sort(subq_sj_candidate_cmp);

3098

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

3099

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

3100

for (in_subq= sj_subselects.front();

3101

in_subq != in_subq_end &&

3102

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

3103

in_subq++)

3104

{

3105

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

3106

return(true);

3107

}

3108

3109

for (in_subq= sj_subselects.front();

3110

in_subq != in_subq_end &&

3111

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

3112

in_subq++)

3113

{

3114

if (convert_subq_to_sj(this, *in_subq))

3115

return(true);

3116

}

3117

3118

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

3119

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

3120

{

3121

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

3122

Item_subselect::trans_res res;

3123

(*in_subq)->changed= 0;

3124

(*in_subq)->fixed= 0;

3125

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

3126

if (res == Item_subselect::RES_ERROR)

3127

return(true);

3128

3129

(*in_subq)->changed= 1;

3130

(*in_subq)->fixed= 1;

3131

3132

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

3133

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

3134

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

3135

return(true);

3136

3137

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

3138

// return(true);

3139

}

3140

sj_subselects.clear();

3141

return(false);

3142

}

3143

3144

3145

/**

3146

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

3147

chose hash semi-join.

3148

3149

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

3150

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

3151

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

3152

of the IN predicate,

3153

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

3154

previously blocked during JOIN::prepare.

3155

3156

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

3157

3158

This phase must be called after substitute_for_best_equal_field() because

3159

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

3160

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

3161

IN predicate.

3162

3163

@return Operation status

3164

@retval false success.

3165

@retval true error occurred.

3166

3167

3168

bool JOIN::setup_subquery_materialization()

3169

{

3170

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

3171

un= un->next_unit())

3172

{

3173

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

3174

{

3175

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

3176

if (subquery_predicate &&

3177

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

3178

{

3179

Item_in_subselect *in_subs= (Item_in_subselect*) subquery_predicate;

3180

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

3181

in_subs->setup_engine())

3182

return true;

3183

}

3184

}

3185

}

3186

return false;

3187

}

3188

3189

3190

3191

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

3192

3193

SYNOPSIS

3194

find_eq_ref_candidate()

3195

table Table to be checked

3196

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

3197

count.

3198

3199

DESCRIPTION

3200

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

3201

3202

TODO

3203

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

3204

3205

3206

RETURN

3207

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

3208

false - Otherwise

3209

3210

3211

bool find_eq_ref_candidate(TABLE *table, table_map sj_inner_tables)

3212

{

3213

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

3214

uint key;

3215

3216

if (keyuse)

3217

{

3218

while (1) /* For each key */

3219

{

3220

key= keyuse->key;

3221

KEY *keyinfo= table->key_info + key;

3222

key_part_map bound_parts= 0;

3223

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

3224

{

3225

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

3226

{

3227

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

3228

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

3229

!(keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL))

3230

{

3231

bound_parts |= 1 << keyuse->keypart;

3232

}

3233

keyuse++;

3234

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

3235

3236

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

3237

return true;

3238

if (keyuse->table != table)

3239

return false;

3240

}

3241

else

3242

{

3243

3244

{

3245

keyuse++;

3246

if (keyuse->table != table)

3247

return false;

3248

}

3249

while (keyuse->key == key);

3250

}

3251

}

3252

}

3253

return false;

3254

}

3255

3256

3257

3258

Pull tables out of semi-join nests, if possible

3259

3260

SYNOPSIS

3261

pull_out_semijoin_tables()

3262

join The join where to do the semi-join flattening

3263

3264

DESCRIPTION

3265

Try to pull tables out of semi-join nests.

3266

3267

PRECONDITIONS

3268

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

3269

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

3270

one semi-join nest does not contain another.

3271

3272

ACTION

3273

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

3274

- It is a constant table

3275

- It is accessed

3276

3277

POSTCONDITIONS

3278

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

3279

tables)

3280

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

3281

* Semi-join nests TABLE_LIST::sj_inner_tables

3282

3283

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

3284

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

3285

3286

RETURN

3287

0 - OK

3288

1 - Out of memory error

3289

3290

3291

int pull_out_semijoin_tables(JOIN *join)

3292

{

3293

TABLE_LIST *sj_nest;

3294

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

3295

3296

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

3297

while ((sj_nest= sj_list_it++))

3298

{

3299

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

3300

table_map pulled_tables= 0;

3301

3302

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

3303

TABLE_LIST *tbl;

3304

while ((tbl= child_li++))

3305

{

3306

if (tbl->table)

3307

{

3308

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

3309

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

3310

{

3311

pulled_tables |= tbl->table->map;

3312

}

3313

}

3314

}

3315

3316

3317

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

3318

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

3319

us to pull out some other tables too.

3320

3321

bool pulled_a_table;

3322

3323

{

3324

pulled_a_table= false;

3325

child_li.rewind();

3326

while ((tbl= child_li++))

3327

{

3328

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

3329

{

3330

if (find_eq_ref_candidate(tbl->table,

3331

sj_nest->nested_join->used_tables &

3332

~pulled_tables))

3333

{

3334

pulled_a_table= true;

3335

pulled_tables |= tbl->table->map;

3336

}

3337

}

3338

}

3339

} while (pulled_a_table);

3340

3341

child_li.rewind();

3342

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

3343

{

3344

(sj_nest)->sj_inner_tables= 0;

3345

while ((tbl= child_li++))

3346

{

3347

if (tbl->table)

3348

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

3349

}

3350

}

3351

else

3352

{

3353

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

3354

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

3355

~pulled_tables;

3356

(sj_nest)->sj_inner_tables= inner_tables;

3357

while ((tbl= child_li++))

3358

{

3359

if (tbl->table)

3360

{

3361

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

3362

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

3363

else

3364

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

3365

}

3366

}

3367

}

3368

}

3369

return(0);

3370

}

3371

3372

462

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

3373

Create JOIN_TABS, make a guess about the table types,

463

Create JoinTableS, make a guess about the table types,

3374

464

Approximate how many records will be used in each table

3375

465

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

3376

3377

3378

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

3379

TABLE *table,

3380

const key_map *keys,ha_rows limit)

466

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

3381

467

{

3382

468

int error;

3383

if (check_stack_overrun(thd, STACK_MIN_SIZE, NULL))

469

if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))

3384

470

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

3385

471

if (select)

3386

472

{

3387

473

select->head=table;

3388

474

table->reginfo.impossible_range=0;

3389

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

475

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

3390

476

limit, 0, false)) == 1)

3391

477

return(select->quick->records);

3392

478

if (error == -1)

3398

484

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

3399

485

}

3400

486

3401

3402

This structure is used to collect info on potentially sargable

3403

predicates in order to check whether they become sargable after

3404

reading const tables.

3405

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

3406

Only such indexes are involved in range analysis.

3407

3408

typedef struct st_sargable_param

3409

{

3410

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

3411

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

3412

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

3413

} SARGABLE_PARAM;

3414

3415

/**

3416

Calculate the best possible join and initialize the join structure.

3417

3418

@retval

3419

0 ok

3420

@retval

3421

1 Fatal error

3422

3423

3424

static bool

3425

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

3426

DYNAMIC_ARRAY *keyuse_array)

3427

{

3428

int error;

3429

TABLE *table;

3430

uint i,table_count,const_count,key;

3431

table_map found_const_table_map, all_table_map, found_ref, refs;

3432

key_map const_ref, eq_part;

3433

TABLE **table_vector;

3434

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

3435

KEYUSE *keyuse,*start_keyuse;

3436

table_map outer_join=0;

3437

SARGABLE_PARAM *sargables= 0;

3438

JOIN_TAB *stat_vector[MAX_TABLES+1];

3439

3440

table_count=join->tables;

3441

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

3442

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

3443

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

3444

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

3445

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

3446

3447

join->best_ref=stat_vector;

3448

3449

stat_end=stat+table_count;

3450

found_const_table_map= all_table_map=0;

3451

const_count=0;

3452

3453

for (s= stat, i= 0;

3454

tables;

3455

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

3456

{

3457

TABLE_LIST *embedding= tables->embedding;

3458

stat_vector[i]=s;

3459

s->keys.init();

3460

s->const_keys.init();

3461

s->checked_keys.init();

3462

s->needed_reg.init();

3463

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

3464

table->pos_in_table_list= tables;

3465

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

3466

if(error)

3467

{

3468

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

3469

return(1);

3470

}

3471

table->quick_keys.clear_all();

3472

table->reginfo.join_tab=s;

3473

table->reginfo.not_exists_optimize=0;

3474

memset(table->const_key_parts, 0,

3475

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

3476

all_table_map|= table->map;

3477

s->join=join;

3478

s->info=0; // For describe

3479

3480

s->dependent= tables->dep_tables;

3481

s->key_dependent= 0;

3482

if (tables->schema_table)

3483

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

3484

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

3485

3486

s->on_expr_ref= &tables->on_expr;

3487

if (*s->on_expr_ref)

3488

{

3489

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

3490

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

3491

{ // Empty table

3492

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

3493

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

3494

continue;

3495

}

3496

outer_join|= table->map;

3497

s->embedding_map= 0;

3498

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

3499

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

3500

continue;

3501

}

3502

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

3503

{

3504

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

3505

s->embedding_map= 0;

3506

3507

{

3508

NESTED_JOIN *nested_join= embedding->nested_join;

3509

s->embedding_map|=nested_join->nj_map;

3510

s->dependent|= embedding->dep_tables;

3511

embedding= embedding->embedding;

3512

outer_join|= nested_join->used_tables;

3513

}

3514

while (embedding);

3515

continue;

3516

}

3517

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

3518

!s->dependent &&

3519

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

3520

{

3521

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

3522

}

3523

}

3524

stat_vector[i]=0;

3525

join->outer_join=outer_join;

3526

3527

if (join->outer_join)

3528

{

3529

3530

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

3531

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

3532

as well as allow us to catch illegal cross references/

3533

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

3534

As we use bitmaps to represent the relation the complexity

3535

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

3536

3537

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

3538

{

3539

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

3540

{

3541

table= stat[j].table;

3542

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

3543

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

3544

}

3545

if (s->dependent)

3546

s->table->maybe_null= 1;

3547

}

3548

/* Catch illegal cross references for outer joins */

3549

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

3550

{

3551

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

3552

{

3553

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

3554

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

3555

return(1);

3556

}

3557

s->key_dependent= s->dependent;

3558

}

3559

}

3560

3561

if (conds || outer_join)

3562

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

3563

conds, join->cond_equal,

3564

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

3565

return(1);

3566

3567

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

3568

join->const_table_map= 0;

3569

3570

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

3571

p_pos < p_end ;

3572

p_pos++)

3573

{

3574

int tmp;

3575

s= p_pos->table;

3576

s->type=JT_SYSTEM;

3577

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

3578

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

3579

{

3580

if (tmp > 0)

3581

return(1); // Fatal error

3582

}

3583

else

3584

found_const_table_map|= s->table->map;

3585

}

3586

3587

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

3588

int ref_changed;

3589

3590

{

3591

more_const_tables_found:

3592

ref_changed = 0;

3593

found_ref=0;

3594

3595

3596

We only have to loop from stat_vector + const_count as

3597

set_position() will move all const_tables first in stat_vector

3598

3599

3600

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

3601

{

3602

table=s->table;

3603

3604

3605

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

3606

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

3607

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

3608

3609

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

3610

{

3611

3612

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

3613

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

3614

null complemented and thus considered as constant tables.

3615

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

3616

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

3617

would require a more thorough analysis.

3618

TODO. Apply single row substitution to null complemented inner tables

3619

for nested outer join operations.

3620

3621

while (keyuse->table == table)

3622

{

3623

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

3624

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

3625

{

3626

s->type= JT_CONST;

3627

mark_as_null_row(table);

3628

found_const_table_map|= table->map;

3629

join->const_table_map|= table->map;

3630

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

3631

goto more_const_tables_found;

3632

}

3633

keyuse++;

3634

}

3635

}

3636

3637

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

3638

{

3639

// All dep. must be constants

3640

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

3641

continue;

3642

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

3643

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

3644

!table->pos_in_table_list->embedding)

3645

{ // system table

3646

int tmp= 0;

3647

s->type=JT_SYSTEM;

3648

join->const_table_map|=table->map;

3649

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

3650

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

3651

{

3652

if (tmp > 0)

3653

return(1); // Fatal error

3654

}

3655

else

3656

found_const_table_map|= table->map;

3657

continue;

3658

}

3659

}

3660

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

3661

if ((keyuse=s->keyuse))

3662

{

3663

s->type= JT_REF;

3664

while (keyuse->table == table)

3665

{

3666

start_keyuse=keyuse;

3667

key=keyuse->key;

3668

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

3669

3670

refs=0;

3671

const_ref.clear_all();

3672

eq_part.clear_all();

3673

3674

{

3675

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

3676

{

3677

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

3678

const_ref.set_bit(keyuse->keypart);

3679

else

3680

refs|=keyuse->used_tables;

3681

eq_part.set_bit(keyuse->keypart);

3682

}

3683

keyuse++;

3684

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

3685

3686

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

3687

!table->pos_in_table_list->embedding)

3688

{

3689

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

3690

== HA_NOSAME)

3691

{

3692

if (const_ref == eq_part)

3693

{ // Found everything for ref.

3694

int tmp;

3695

ref_changed = 1;

3696

s->type= JT_CONST;

3697

join->const_table_map|=table->map;

3698

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

3699

if (create_ref_for_key(join, s, start_keyuse,

3700

found_const_table_map))

3701

return(1);

3702

if ((tmp=join_read_const_table(s,

3703

join->positions+const_count-1)))

3704

{

3705

if (tmp > 0)

3706

return(1); // Fatal error

3707

}

3708

else

3709

found_const_table_map|= table->map;

3710

break;

3711

}

3712

else

3713

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

3714

}

3715

else if (const_ref == eq_part)

3716

s->const_keys.set_bit(key);

3717

}

3718

}

3719

}

3720

}

3721

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

3722

3723

3724

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

3725

reading const tables may has added new sargable predicates.

3726

3727

if (const_count && sargables)

3728

{

3729

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

3730

{

3731

Field *field= sargables->field;

3732

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

3733

key_map possible_keys= field->key_start;

3734

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

3735

bool is_const= 1;

3736

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

3737

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

3738

if (is_const)

3739

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

3740

}

3741

}

3742

3743

if (pull_out_semijoin_tables(join))

3744

return(true);

3745

3746

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

3747

3748

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

3749

{

3750

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

3751

{

3752

/* Only one matching row */

3753

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

3754

continue;

3755

}

3756

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

3757

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

3758

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

3759

3760

3761

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

3762

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

3763

table scan.

3764

3765

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

3766

(double) s->read_time*3);

3767

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

3768

s->worst_seeks=2.0;

3769

3770

3771

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

3772

all select distinct fields participate in one index.

3773

3774

add_group_and_distinct_keys(join, s);

3775

3776

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

3777

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

3778

{

3779

ha_rows records;

3780

SQL_SELECT *select;

3781

select= make_select(s->table, found_const_table_map,

3782

found_const_table_map,

3783

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

3784

1, &error);

3785

if (!select)

3786

return(1);

3787

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

3788

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

3789

s->quick=select->quick;

3790

s->needed_reg=select->needed_reg;

3791

select->quick=0;

3792

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

3793

{

3794

3795

Impossible WHERE or ON expression

3796

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

3797

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

3798

caller to abort with a zero row result.

3799

3800

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

3801

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

3802

s->type= JT_CONST;

3803

if (*s->on_expr_ref)

3804

{

3805

/* Generate empty row */

3806

s->info= "Impossible ON condition";

3807

found_const_table_map|= s->table->map;

3808

s->type= JT_CONST;

3809

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

3810

}

3811

}

3812

if (records != HA_POS_ERROR)

3813

{

3814

s->found_records=records;

3815

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

3816

}

3817

delete select;

3818

}

3819

}

3820

3821

join->join_tab=stat;

3822

join->map2table=stat_ref;

3823

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

3824

join->const_tables=const_count;

3825

join->found_const_table_map=found_const_table_map;

3826

3827

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

3828

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

3829

{

3830

optimize_keyuse(join, keyuse_array);

3831

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

3832

return(true);

3833

}

3834

else

3835

{

3836

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

3837

sizeof(POSITION)*join->const_tables);

3838

join->best_read=1.0;

3839

}

3840

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

3841

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

3842

}

3843

3844

3845

487

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

3846

488

Check with keys are used and with tables references with tables

3847

489

Updates in stat:

3850

492

keyuse Pointer to possible keys

3851

493

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

3852

494

3853

/// Used when finding key fields

3854

typedef struct key_field_t {

3855

Field *field;

3856

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

3857

uint level;

3858

uint optimize; // KEY_OPTIMIZE_*

3859

bool eq_func;

3860

/**

3861

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

3862

when val IS NULL.

3863

3864

bool null_rejecting;

3865

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

3866

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

3867

} KEY_FIELD;

3868

3869

/**

3870

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

3871

3872

This is called for OR between different levels.

3873

3874

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

3875

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

3876

that are internally transformed to something like:.

3877

3878

@code

3879

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

3880

@endcode

3881

3882

KEY_FIELD::null_rejecting is processed as follows: @n

3883

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

3884

for example:

3885

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

3886

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

3887

3888

@todo

3889

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

3890

OptimizerTeam: Fix this

3891

3892

3893

static KEY_FIELD *

3894

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

3895

uint and_level)

3896

{

3897

if (start == new_fields)

3898

return start; // Impossible or

3899

if (new_fields == end)

3900

return start; // No new fields, skip all

3901

3902

KEY_FIELD *first_free=new_fields;

3903

3904

/* Mark all found fields in old array */

3905

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

3906

{

3907

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

3908

{

3909

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

3910

{

3911

3912

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

3913

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

3914

3915

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

3916

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

3917

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

3918

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

3919

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

3920

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

3921

TODO: OptimizerTeam: Fix this

3922

3923

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

3924

{

3925

3926

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

3927

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

3928

3929

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

3930

{

3931

old->level= and_level;

3932

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

3933

KEY_OPTIMIZE_EXISTS) |

3934

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

3935

KEY_OPTIMIZE_REF_OR_NULL));

3936

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

3937

new_fields->null_rejecting);

3938

}

3939

}

3940

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

3941

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

3942

old->field->binary(),

3943

old->field->charset()))

3944

3945

{

3946

old->level= and_level;

3947

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

3948

KEY_OPTIMIZE_EXISTS) |

3949

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

3950

KEY_OPTIMIZE_REF_OR_NULL));

3951

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

3952

new_fields->null_rejecting);

3953

}

3954

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

3955

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

3956

new_fields->val->is_null()))

3957

{

3958

/* field = expression OR field IS NULL */

3959

old->level= and_level;

3960

old->optimize= KEY_OPTIMIZE_REF_OR_NULL;

3961

3962

Remember the NOT NULL value unless the value does not depend

3963

on other tables.

3964

3965

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

3966

old->val= new_fields->val;

3967

/* The referred expression can be NULL: */

3968

old->null_rejecting= 0;

3969

}

3970

else

3971

{

3972

3973

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

3974

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

3975

and let the range optimzier handle it

3976

3977

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

3978

break;

3979

*old= *first_free; // Remove old value

3980

old--; // Retry this value

3981

}

3982

}

3983

}

3984

}

3985

/* Remove all not used items */

3986

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

3987

{

3988

if (old->level != and_level)

3989

{ // Not used in all levels

3990

if (old == --first_free)

3991

break;

3992

*old= *first_free; // Remove old value

3993

continue;

3994

}

3995

old++;

3996

}

3997

return first_free;

3998

}

3999

4000

4001

/**

4002

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

4003

4004

@param key_fields Pointer to add key, if usable

4005

@param and_level And level, to be stored in KEY_FIELD

4006

@param cond Condition predicate

4007

@param field Field used in comparision

4008

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

4009

@param value Value used for comparison with field

4010

@param usable_tables Tables which can be used for key optimization

4011

@param sargables IN/OUT Array of found sargable candidates

4012

4013

@note

4014

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

4015

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

4016

4017

@returns

4018

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

4019

4020

4021

static void

4022

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

4023

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

4024

table_map usable_tables, SARGABLE_PARAM **sargables)

4025

{

4026

uint exists_optimize= 0;

4027

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

4028

{

4029

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

4030

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

4031

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

4032

return; // Not a key. Skip it

4033

exists_optimize= KEY_OPTIMIZE_EXISTS;

4034

assert(num_values == 1);

4035

}

4036

else

4037

{

4038

table_map used_tables=0;

4039

bool optimizable=0;

4040

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

4041

{

4042

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

4043

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

4044

optimizable=1;

4045

}

4046

if (!optimizable)

4047

return;

4048

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

4049

{

4050

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

4051

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

4052

return; // Can't use left join optimize

4053

exists_optimize= KEY_OPTIMIZE_EXISTS;

4054

}

4055

else

4056

{

4057

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

4058

key_map possible_keys=field->key_start;

4059

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

4060

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

4061

4062

4063

Save the following cases:

4064

Field op constant

4065

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

4066

Field = field2 where field2 is in a different table

4067

Field op formula

4068

Field IS NULL

4069

Field IS NOT NULL

4070

Field BETWEEN ...

4071

Field IN ...

4072

4073

stat[0].key_dependent|=used_tables;

4074

4075

bool is_const=1;

4076

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

4077

{

4078

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

4079

break;

4080

}

4081

if (is_const)

4082

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

4083

else if (!eq_func)

4084

{

4085

4086

Save info to be able check whether this predicate can be

4087

considered as sargable for range analisis after reading const tables.

4088

We do not save info about equalities as update_const_equal_items

4089

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

4090

4091

(*sargables)--;

4092

(*sargables)->field= field;

4093

(*sargables)->arg_value= value;

4094

(*sargables)->num_values= num_values;

4095

}

4096

4097

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

4098

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

4099

eq_func is NEVER true when num_values > 1

4100

4101

if (!eq_func)

4102

{

4103

4104

Additional optimization: if we're processing

4105

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

4106

"t.key = c1".

4107

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

4108

There are 2 options:

4109

A) Make equality propagation code be able to handle BETWEEN

4110

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

4111

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

4112

and use them in equality propagation process (see details in

4113

OptimizerKBAndTodo)

4114

4115

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

4116

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

4117

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

4118

return;

4119

eq_func= true;

4120

}

4121

4122

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

4123

{

4124

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

4125

{

4126

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

4127

return;

4128

}

4129

else

4130

{

4131

4132

We can't use indexes if the effective collation

4133

of the operation differ from the field collation.

4134

4135

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

4136

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

4137

return;

4138

}

4139

}

4140

}

4141

}

4142

4143

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

4144

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

4145

4146

assert(eq_func);

4147

/* Store possible eq field */

4148

(*key_fields)->field= field;

4149

(*key_fields)->eq_func= eq_func;

4150

(*key_fields)->val= *value;

4151

(*key_fields)->level= and_level;

4152

(*key_fields)->optimize= exists_optimize;

4153

4154

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

4155

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

4156

has NULL value.

4157

We use null_rejecting in add_not_null_conds() to add

4158

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

4159

4160

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

4161

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

4162

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

4163

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

4164

(*key_fields)->cond_guard= NULL;

4165

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

4166

cond->name < subq_sj_cond_name + 64)?

4167

cond->name - subq_sj_cond_name: UINT_MAX;

4168

(*key_fields)++;

4169

}

4170

4171

/**

4172

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

4173

predicate.

4174

4175

@param key_fields Pointer to add key, if usable

4176

@param and_level And level, to be stored in KEY_FIELD

4177

@param cond Condition predicate

4178

@param field Field used in comparision

4179

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

4180

@param value Value used for comparison with field

4181

Is NULL for BETWEEN and IN

4182

@param usable_tables Tables which can be used for key optimization

4183

@param sargables IN/OUT Array of found sargable candidates

4184

4185

@note

4186

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

4187

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

4188

4189

@returns

4190

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

4191

4192

4193

static void

4194

add_key_equal_fields(KEY_FIELD **key_fields, uint and_level,

4195

Item_func *cond, Item_field *field_item,

4196

bool eq_func, Item **val,

4197

uint num_values, table_map usable_tables,

4198

SARGABLE_PARAM **sargables)

4199

{

4200

Field *field= field_item->field;

4201

add_key_field(key_fields, and_level, cond, field,

4202

eq_func, val, num_values, usable_tables, sargables);

4203

Item_equal *item_equal= field_item->item_equal;

4204

if (item_equal)

4205

{

4206

4207

Add to the set of possible key values every substitution of

4208

the field for an equal field included into item_equal

4209

4210

Item_equal_iterator it(*item_equal);

4211

Item_field *item;

4212

while ((item= it++))

4213

{

4214

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

4215

{

4216

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

4217

eq_func, val, num_values, usable_tables,

4218

sargables);

4219

}

4220

}

4221

}

4222

}

4223

4224

static void

4225

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

4226

COND *cond, table_map usable_tables,

4227

SARGABLE_PARAM **sargables)

4228

{

4229

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

4230

{

4231

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

4232

KEY_FIELD *org_key_fields= *key_fields;

4233

4234

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

4235

{

4236

Item *item;

4237

while ((item=li++))

4238

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

4239

sargables);

4240

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

4241

org_key_fields->level= *and_level;

4242

}

4243

else

4244

{

4245

(*and_level)++;

4246

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

4247

sargables);

4248

Item *item;

4249

while ((item=li++))

4250

{

4251

KEY_FIELD *start_key_fields= *key_fields;

4252

(*and_level)++;

4253

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

4254

sargables);

4255

*key_fields=merge_key_fields(org_key_fields,start_key_fields,

4256

*key_fields,++(*and_level));

4257

}

4258

}

4259

return;

4260

}

4261

4262

4263

Subquery optimization: Conditions that are pushed down into subqueries

4264

are wrapped into Item_func_trig_cond. We process the wrapped condition

4265

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

4266

4267

{

4268

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

4269

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

4270

{

4271

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

4272

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

4273

join->unit->item &&

4274

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

4275

!join->unit->is_union())

4276

{

4277

KEY_FIELD *save= *key_fields;

4278

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

4279

sargables);

4280

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

4281

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

4282

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

4283

}

4284

return;

4285

}

4286

}

4287

4288

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

4289

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

4290

return;

4291

Item_func *cond_func= (Item_func*) cond;

4292

switch (cond_func->select_optimize()) {

4293

case Item_func::OPTIMIZE_NONE:

4294

break;

4295

case Item_func::OPTIMIZE_KEY:

4296

{

4297

Item **values;

4298

// BETWEEN, IN, NE

4299

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

4300

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

4301

{

4302

values= cond_func->arguments()+1;

4303

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

4304

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

4305

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

4306

values--;

4307

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

4308

cond_func->argument_count() != 2);

4309

add_key_equal_fields(key_fields, *and_level, cond_func,

4310

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

4311

0, values,

4312

cond_func->argument_count()-1,

4313

usable_tables, sargables);

4314

}

4315

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

4316

{

4317

values= cond_func->arguments();

4318

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

4319

{

4320

Item_field *field_item;

4321

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

4322

4323

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

4324

{

4325

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

4326

add_key_equal_fields(key_fields, *and_level, cond_func,

4327

field_item, 0, values, 1, usable_tables,

4328

sargables);

4329

}

4330

}

4331

}

4332

break;

4333

}

4334

case Item_func::OPTIMIZE_OP:

4335

{

4336

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

4337

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

4338

4339

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

4340

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

4341

{

4342

add_key_equal_fields(key_fields, *and_level, cond_func,

4343

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

4344

equal_func,

4345

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

4346

sargables);

4347

}

4348

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

4349

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

4350

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

4351

{

4352

add_key_equal_fields(key_fields, *and_level, cond_func,

4353

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

4354

equal_func,

4355

cond_func->arguments(),1,usable_tables,

4356

sargables);

4357

}

4358

break;

4359

}

4360

case Item_func::OPTIMIZE_NULL:

4361

/* column_name IS [NOT] NULL */

4362

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

4363

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

4364

{

4365

Item *tmp=new Item_null;

4366

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

4367

return;

4368

add_key_equal_fields(key_fields, *and_level, cond_func,

4369

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

4370

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

4371

&tmp, 1, usable_tables, sargables);

4372

}

4373

break;

4374

case Item_func::OPTIMIZE_EQUAL:

4375

Item_equal *item_equal= (Item_equal *) cond;

4376

Item *const_item= item_equal->get_const();

4377

Item_equal_iterator it(*item_equal);

4378

Item_field *item;

4379

if (const_item)

4380

{

4381

4382

For each field field1 from item_equal consider the equality

4383

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

4384

with field1 by the keys value of field1.

4385

4386

while ((item= it++))

4387

{

4388

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

4389

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

4390

}

4391

}

4392

else

4393

{

4394

4395

Consider all pairs of different fields included into item_equal.

4396

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

4397

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

4398

with field1 by the keys value of field2.

4399

4400

Item_equal_iterator fi(*item_equal);

4401

while ((item= fi++))

4402

{

4403

Field *field= item->field;

4404

while ((item= it++))

4405

{

4406

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

4407

{

4408

add_key_field(key_fields, *and_level, cond_func, field,

4409

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

4410

sargables);

4411

}

4412

}

4413

it.rewind();

4414

}

4415

}

4416

break;

4417

}

4418

}

4419

495

4420

496

/**

4421

497

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

4422

498

4423

499

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

4424

500

4425

4426

static uint

4427

max_part_bit(key_part_map bits)

501

uint32_t max_part_bit(key_part_map bits)

4428

502

{

4429

uint found;

503

uint32_t found;

4430

504

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

4431

505

return found;

4432

506

}

4433

507

4434

static void

4435

add_key_part(DYNAMIC_ARRAY *keyuse_array,KEY_FIELD *key_field)

4436

{

4437

Field *field=key_field->field;

4438

TABLE *form= field->table;

4439

KEYUSE keyuse;

4440

4441

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

4442

{

4443

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

4444

{

4445

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

4446

continue;

4447

4448

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

4449

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

4450

{

4451

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

4452

{

4453

keyuse.table= field->table;

4454

keyuse.val = key_field->val;

4455

keyuse.key = key;

4456

keyuse.keypart=part;

4457

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

4458

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

4459

keyuse.optimize= key_field->optimize & KEY_OPTIMIZE_REF_OR_NULL;

4460

keyuse.null_rejecting= key_field->null_rejecting;

4461

keyuse.cond_guard= key_field->cond_guard;

4462

keyuse.sj_pred_no= key_field->sj_pred_no;

4463

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

4464

}

4465

}

4466

}

4467

}

4468

}

4469

4470

static int

4471

sort_keyuse(KEYUSE *a,KEYUSE *b)

508

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

4472

509

{

4473

510

int res;

4474

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

4475

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

4476

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

4477

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

4478

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

4479

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

511

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

512

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

513

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

514

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

515

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

516

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

4480

517

// Place const values before other ones

4481

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

4482

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

518

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

519

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

4483

520

return res;

4484

521

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

4485

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

4486

(b->optimize & KEY_OPTIMIZE_REF_OR_NULL));

4487

}

4488

4489

4490

4491

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

4492

4493

This function populates KEY_FIELD array with entries generated from the

4494

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

4495

contained within this nested join.

4496

4497

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

4498

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

4499

@param[in,out] and_level And-level

4500

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

4501

4502

4503

@note

4504

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

4505

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

4506

4507

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

4508

invoked for):

4509

@code

4510

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

4511

@endcode

4512

Example for #2:

4513

@code

4514

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

4515

@endcode

4516

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

4517

t1 only.

4518

Example #3:

4519

@code

4520

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

4521

@endcode

4522

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

4523

4524

4525

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

4526

KEY_FIELD **end, uint *and_level,

4527

SARGABLE_PARAM **sargables)

4528

{

4529

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

4530

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

4531

bool have_another = false;

4532

table_map tables= 0;

4533

TABLE_LIST *table;

4534

assert(nested_join_table->nested_join);

4535

4536

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

4537

(table= li++))))

4538

{

4539

if (table->nested_join)

4540

{

4541

if (!table->on_expr)

4542

{

4543

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

4544

have_another= true;

4545

li2= li;

4546

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

4547

}

4548

else

4549

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

4550

}

4551

else

4552

if (!table->on_expr)

4553

tables |= table->table->map;

4554

}

4555

if (nested_join_table->on_expr)

4556

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

4557

sargables);

522

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

523

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

4558

524

}

4559

525

4560

526

4561

527

/**

4562

528

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

4563

4564

@param thd

4565

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

529

530

@param session

531

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

4566

532

@param join_tab Array in tablenr_order

4567

533

@param tables Number of tables in join

4568

534

@param cond WHERE condition (note that the function analyzes

4571

537

for which we can make ref access based the WHERE

4572

538

clause)

4573

539

@param select_lex current SELECT

4574

@param[out] sargables Array of found sargable candidates

4575

540

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

541

4576

542

@retval

4577

543

0 OK

4578

544

@retval

4579

545

1 Out of memory.

4580

546

4581

4582

static bool

4583

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

4584

uint tables, COND *cond,

4585

COND_EQUAL *cond_equal __attribute__((unused)),

4586

table_map normal_tables, SELECT_LEX *select_lex,

4587

SARGABLE_PARAM **sargables)

547

bool update_ref_and_keys(Session *session,

548

DYNAMIC_ARRAY *keyuse,

549

JoinTable *join_tab,

550

uint32_t tables,

551

COND *cond,

552

COND_EQUAL *,

553

table_map normal_tables,

554

Select_Lex *select_lex,

555

vector<optimizer::SargableParam> &sargables)

4588

556

{

4589

557

uint and_level,i,found_eq_constant;

4590

KEY_FIELD *key_fields, *end, *field;

4591

uint sz;

4592

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

4593

4594

4595

We use the same piece of memory to store both KEY_FIELD

4596

and SARGABLE_PARAM structure.

4597

KEY_FIELD values are placed at the beginning this memory

4598

while SARGABLE_PARAM values are put at the end.

4599

All predicates that are used to fill arrays of KEY_FIELD

4600

and SARGABLE_PARAM structures have at most 2 arguments

4601

except BETWEEN predicates that have 3 arguments and

558

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

559

uint32_t sz;

560

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

561

562

563

All predicates that are used to fill arrays of KeyField

564

and SargableParam classes have at most 2 arguments

565

except BETWEEN predicates that have 3 arguments and

4602

566

IN predicates.

4603

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

4604

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

4605

or SARGABLE_PARAM type. For a BETWEEN predicate 3 elements

567

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

568

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

569

or SargableParam type. For a BETWEEN predicate 3 elements

4606

570

can be filled as this predicate is considered as

4607

571

saragable with respect to each of its argument.

4608

572

An IN predicate can require at most 1 element as currently

4609

573

it is considered as sargable only for its first argument.

4610

574

Multiple equality can add elements that are filled after

4611

575

substitution of field arguments by equal fields. There

4612

can be not more than select_lex->max_equal_elems such

576

can be not more than select_lex->max_equal_elems such

4613

577

substitutions.

4614

4615

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

4616

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

4617

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

4618

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

4619

return true; /* purecov: inspected */

578

579

sz= sizeof(optimizer::KeyField) *

580

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

581

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

582

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

583

return true;

4620

584

and_level= 0;

4621

585

field= end= key_fields;

4622

*sargables= (SARGABLE_PARAM *) key_fields +

4623

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

4624

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

4625

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

4626

586

4627

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

587

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

4628

588

return true;

4629

589

if (cond)

4630

590

{

4631

591

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

4632

592

sargables);

4633

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

593

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

4634

594

{

4635

add_key_part(keyuse,field);

595

add_key_part(keyuse, field);

4636

596

/* Mark that we can optimize LEFT JOIN */

4637

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

4638

!field->field->real_maybe_null())

4639

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

597

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

598

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

599

{

600

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

601

}

4640

602

}

4641

603

}

4642

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

604

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

4643

605

{

4644

606

4645

607

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

4649

611

In the future when we introduce conditional accesses

4650

612

for inner tables in outer joins these keys will be taken

4651

613

into account as well.

4652

614

4653

615

if (*join_tab[i].on_expr_ref)

4654

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

616

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

4655

617

*join_tab[i].on_expr_ref,

4656

618

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

4657

619

}

4658

620

4659

621

/* Process ON conditions for the nested joins */

4660

622

{

4661

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

4662

TABLE_LIST *table;

623

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

624

TableList *table;

4663

625

while ((table= li++))

4664

626

{

4665

627

if (table->nested_join)

4666

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

628

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

4667

629

sargables);

4668

630

}

4669

631

}

4683

645

4684

646

if (keyuse->elements)

4685

647

{

4686

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

648

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

4687

649

4688

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

650

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

4689

651

(qsort_cmp) sort_keyuse);

4690

652

4691

653

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

4692

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

654

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

4693

655

4694

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

656

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

4695

657

prev= &key_end;

4696

found_eq_constant=0;

4697

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

658

found_eq_constant= 0;

659

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

4698

660

{

4699

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

4700

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

661

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

662

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

663

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

4701

664

{

4702

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

4703

{

4704

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

4705

continue; /* remove */

4706

}

4707

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

4708

continue;

665

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

666

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

667

continue; /* remove */

4709

668

}

669

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

670

continue;

4710

671

4711

672

#ifdef HAVE_purify

4712

673

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

4714

675

#endif

4715

676

*save_pos= *use;

4716

677

prev=use;

4717

found_eq_constant= !use->used_tables;

678

found_eq_constant= ! use->getUsedTables();

4718

679

/* Save ptr to first use */

4719

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

4720

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

4721

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

680

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

681

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

682

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

4722

683

save_pos++;

4723

684

}

4724

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

4725

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

4726

keyuse->elements=i;

685

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

686

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

687

keyuse->elements= i;

4727

688

}

4728

689

return false;

4729

690

}

4731

692

/**

4732

693

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

4733

694

4734

4735

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

695

void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)

4736

696

{

4737

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

697

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

698

699

optimizer::KeyUse*);

4738

700

4739

701

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

4740

702

{

4747

709

Constant tables are ignored.

4748

710

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

4749

711

4750

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

4751

if (keyuse->used_tables &

4752

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

4753

~OUTER_REF_TABLE_BIT)))

712

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

713

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

4754

714

{

4755

uint tablenr;

715

uint32_t tablenr;

4756

716

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

4757

717

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

4758

718

{

4759

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

4760

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

719

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

720

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

4761

721

}

4762

722

}

4763

723

4764

724

Outer reference (external field) is constant for single executing

4765

725

of subquery

4766

726

4767

if (keyuse->used_tables == OUTER_REF_TABLE_BIT)

4768

keyuse->ref_table_rows= 1;

727

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

728

keyuse->setTableRows(1);

4769

729

}

4770

730

}

4771

731

4787

747

@return

4788

748

None

4789

749

4790

4791

static void

4792

add_group_and_distinct_keys(JOIN *join, JOIN_TAB *join_tab)

750

void add_group_and_distinct_keys(JOIN *join, JoinTable *join_tab)

4793

751

{

4794

752

List<Item_field> indexed_fields;

4795

753

List_iterator<Item_field> indexed_fields_it(indexed_fields);

4796

ORDER *cur_group;

754

order_st *cur_group;

4797

755

Item_field *cur_item;

4798

756

key_map possible_keys(0);

4799

757

4801

759

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

4802

760

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

4803

761

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

4804

(uchar*) &indexed_fields);

762

(unsigned char*) &indexed_fields);

4805

763

}

4806

764

else if (join->select_distinct)

4807

765

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

4810

768

Item *item;

4811

769

while ((item= select_items_it++))

4812

770

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

4813

(uchar*) &indexed_fields);

771

(unsigned char*) &indexed_fields);

4814

772

}

4815

773

else

4816

774

return;

4820

778

4821

779

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

4822

780

cur_item= indexed_fields_it++;

4823

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

781

possible_keys|= cur_item->field->part_of_key;

4824

782

while ((cur_item= indexed_fields_it++))

4825

783

{

4826

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

4827

}

4828

4829

if (!possible_keys.is_clear_all())

4830

join_tab->const_keys.merge(possible_keys);

4831

}

4832

4833

4834

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

4835

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

4836

which uses least records

4837

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

4838

4839

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

4840

4841

static void

4842

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

4843

{

4844

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

4845

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

4846

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

4847

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

4848

4849

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

4850

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

4851

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

4852

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

4853

{

4854

JOIN_TAB *tmp=pos[0];

4855

pos[0]=next;

4856

next=tmp;

4857

}

4858

join->best_ref[idx]=table;

4859

}

4860

4861

4862

4863

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

4864

4865

SYNOPSIS

4866

get_bound_sj_equalities()

4867

sj_nest Semi-join nest

4868

remaining_tables Tables that are not yet bound

4869

4870

DESCRIPTION

4871

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

4872

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

4873

any of remaining_tables and can be evaluated).

4874

4875

RETURN

4876

Bitmap of bound IN-equalities.

4877

4878

4879

uint64_t get_bound_sj_equalities(TABLE_LIST *sj_nest,

4880

table_map remaining_tables)

4881

{

4882

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

4883

Item *item;

4884

uint i= 0;

4885

uint64_t res= 0;

4886

while ((item= li++))

4887

{

4888

4889

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

4890

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

4891

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

4892

(this is an optional feature)

4893

4894

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

4895

{

4896

res |= 1ULL < i;

4897

}

4898

}

4899

return res;

4900

}

4901

4902

4903

/**

4904

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

4905

plan and add this path to the plan.

4906

4907

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

4908

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

4909

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

4910

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

4911

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

4912

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

4913

4914

@param join pointer to the structure providing all context info

4915

for the query

4916

@param s the table to be joined by the function

4917

@param thd thread for the connection that submitted the query

4918

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

4919

@param idx the length of the partial plan

4920

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

4921

partial plan

4922

@param read_time the cost of the partial plan

4923

4924

@return

4925

None

4926

4927

4928

static void

4929

best_access_path(JOIN *join,

4930

JOIN_TAB *s,

4931

THD *thd,

4932

table_map remaining_tables,

4933

uint idx,

4934

double record_count,

4935

double read_time __attribute__((unused)))

4936

{

4937

KEYUSE *best_key= 0;

4938

uint best_max_key_part= 0;

4939

bool found_constraint= 0;

4940

double best= DBL_MAX;

4941

double best_time= DBL_MAX;

4942

double records= DBL_MAX;

4943

table_map best_ref_depends_map= 0;

4944

double tmp;

4945

ha_rows rec;

4946

uint best_is_sj_inside_out= 0;

4947

4948

if (s->keyuse)

4949

{ /* Use key if possible */

4950

TABLE *table= s->table;

4951

KEYUSE *keyuse,*start_key=0;

4952

double best_records= DBL_MAX;

4953

uint max_key_part=0;

4954

uint64_t bound_sj_equalities= 0;

4955

bool try_sj_inside_out= false;

4956

4957

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

4958

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

4959

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

4960

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

4961

all or none of their tables in join_table_map), except

4962

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

4963

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

4964

4965

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

4966

s->emb_sj_nest->sj_in_exprs < 64 &&

4967

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

4968

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

4969

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

4970

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

4971

{

4972

/* This table is an InsideOut scan candidate */

4973

bound_sj_equalities= get_bound_sj_equalities(s->emb_sj_nest,

4974

remaining_tables);

4975

try_sj_inside_out= true;

4976

}

4977

4978

/* Test how we can use keys */

4979

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

4980

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

4981

{

4982

key_part_map found_part= 0;

4983

table_map found_ref= 0;

4984

uint key= keyuse->key;

4985

KEY *keyinfo= table->key_info+key;

4986

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

4987

key_part_map const_part= 0;

4988

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

4989

key_part_map ref_or_null_part= 0;

4990

4991

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

4992

start_key= keyuse;

4993

uint64_t handled_sj_equalities=0;

4994

key_part_map sj_insideout_map= 0;

4995

4996

do /* For each keypart */

4997

{

4998

uint keypart= keyuse->keypart;

4999

table_map best_part_found_ref= 0;

5000

double best_prev_record_reads= DBL_MAX;

5001

5002

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

5003

{

5004

5005

5006

if 1. expression doesn't refer to forward tables

5007

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

5008

5009

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

5010

!(ref_or_null_part && (keyuse->optimize &

5011

KEY_OPTIMIZE_REF_OR_NULL)))

5012

{

5013

found_part|= keyuse->keypart_map;

5014

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

5015

const_part|= keyuse->keypart_map;

5016

5017

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

5018

keyuse->used_tables));

5019

if (tmp2 < best_prev_record_reads)

5020

{

5021

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

5022

best_prev_record_reads= tmp2;

5023

}

5024

if (rec > keyuse->ref_table_rows)

5025

rec= keyuse->ref_table_rows;

5026

5027

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

5028

use this ref_or_null optimisation of this field

5029

5030

if (keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL)

5031

ref_or_null_part |= keyuse->keypart_map;

5032

}

5033

5034

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

5035

{

5036

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

5037

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

5038

else

5039

{

5040

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

5041

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

5042

}

5043

}

5044

5045

keyuse++;

5046

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

5047

keyuse->keypart == keypart);

5048

found_ref|= best_part_found_ref;

5049

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

5050

5051

5052

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

5053

5054

if (!found_part && !handled_sj_equalities)

5055

continue; // Nothing usable found

5056

5057

if (rec < MATCHING_ROWS_IN_OTHER_TABLE)

5058

rec= MATCHING_ROWS_IN_OTHER_TABLE; // Fix for small tables

5059

5060

bool sj_inside_out_scan= false;

5061

{

5062

found_constraint= 1;

5063

5064

Check if InsideOut scan is applicable:

5065

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

5066

2. Index keyparts are

5067

...

5068

5069

if (try_sj_inside_out &&

5070

table->covering_keys.is_set(key) &&

5071

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

5072

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

5073

{

5074

uint n_fixed_parts= max_part_bit(found_part);

5075

if (n_fixed_parts != keyinfo->key_parts &&

5076

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

5077

PREV_BITS(uint, keyinfo->key_parts))

5078

{

5079

5080

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

5081

check if all of them are covered.

5082

5083

sj_inside_out_scan= true;

5084

if (!n_fixed_parts)

5085

{

5086

5087

It's a confluent ref scan.

5088

5089

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

5090

and there is really no ref access because there is no

5091

t.keypart0 = {bound expression}

5092

5093

Calculate the cost of complete loose index scan.

5094

5095

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

5096

5097

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

5098

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

5099

5100

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

5101

ulong rpc;

5102

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

5103

records= records / rpc;

5104

start_key= NULL;

5105

}

5106

}

5107

}

5108

5109

5110

Check if we found full key

5111

5112

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

5113

!ref_or_null_part)

5114

{ /* use eq key */

5115

max_key_part= (uint) ~0;

5116

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

5117

{

5118

tmp = prev_record_reads(join, idx, found_ref);

5119

records=1.0;

5120

}

5121

else

5122

{

5123

if (!found_ref)

5124

{ /* We found a const key */

5125

5126

ReuseRangeEstimateForRef-1:

5127

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

5128

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

5129

5130

If range optimizer was able to construct a "range"

5131

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

5132

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

5133

from the range optimizer.

5134

5135

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

5136

quick_cond will be equal or tighther than ref_const_cond.

5137

ref_const_cond already covers "smallest" possible interval -

5138

a singlepoint interval over all keyparts. Therefore,

5139

quick_cond is equivalent to ref_const_cond (if it was an

5140

empty interval we wouldn't have got here).

5141

5142

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

5143

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

5144

else

5145

{

5146

/* quick_range couldn't use key! */

5147

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

5148

}

5149

}

5150

else

5151

{

5152

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

5153

{ /* Prefer longer keys */

5154

records=

5155

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

5156

(1.0 +

5157

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

5158

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

5159

if (records < 2.0)

5160

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

5161

}

5162

5163

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

5164

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

5165

5166

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

5167

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

5168

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

5169

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

5170

in ReuseRangeEstimateForRef-3.

5171

5172

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

5173

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

5174

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

5175

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

5176

{

5177

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

5178

}

5179

}

5180

/* Limit the number of matched rows */

5181

tmp= records;

5182

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

5183

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

5184

{

5185

/* we can use only index tree */

5186

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

5187

}

5188

else

5189

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

5190

}

5191

}

5192

else

5193

{

5194

5195

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

5196

than a not unique key

5197

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

5198

5199

if ((found_part & 1) &&

5200

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

5201

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

5202

{

5203

max_key_part= max_part_bit(found_part);

5204

5205

ReuseRangeEstimateForRef-3:

5206

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

5207

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

5208

(same-as-above but with one cond replaced

5209

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

5210

5211

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

5212

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

5213

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

5214

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

5215

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

5216

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

5217

The sufficient conditions for re-use are:

5218

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

5219

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

5220

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

5221

join)

5222

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

5223

is apparently a necessary requirement)

5224

5225

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

5226

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

5227

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

5228

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

5229

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

5230

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

5231

5232

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

5233

(same-as-above but with one cond replaced

5234

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

5235

5236

The remaining part is to exclude the situation where range

5237

optimizer used one interval while we're considering

5238

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

5239

is done by last limitation:

5240

5241

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

5242

5243

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

5244

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

5245

table->quick_n_ranges[key] == 1+test(ref_or_null_part)) //(C3)

5246

{

5247

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

5248

}

5249

else

5250

{

5251

/* Check if we have statistic about the distribution */

5252

if ((records= keyinfo->rec_per_key[max_key_part-1]))

5253

{

5254

5255

Fix for the case where the index statistics is too

5256

optimistic: If

5257

(1) We're considering ref(const) and there is quick select

5258

on the same index,

5259

(2) and that quick select uses more keyparts (i.e. it will

5260

scan equal/smaller interval then this ref(const))

5261

(3) and E(#rows) for quick select is higher then our

5262

estimate,

5263

Then

5264

We'll use E(#rows) from quick select.

5265

5266

Q: Why do we choose to use 'ref'? Won't quick select be

5267

cheaper in some cases ?

5268

TODO: figure this out and adjust the plan choice if needed.

5269

5270

if (!found_ref && table->quick_keys.is_set(key) && // (1)

5271

table->quick_key_parts[key] > max_key_part && // (2)

5272

records < (double)table->quick_rows[key]) // (3)

5273

records= (double)table->quick_rows[key];

5274

5275

tmp= records;

5276

}

5277

else

5278

{

5279

5280

Assume that the first key part matches 1% of the file

5281

and that the whole key matches 10 (duplicates) or 1

5282

(unique) records.

5283

Assume also that more key matches proportionally more

5284

records

5285

This gives the formula:

5286

records = (x * (b-a) + a*c-b)/(c-1)

5287

5288

b = records matched by whole key

5289

a = records matched by first key part (1% of all records?)

5290

c = number of key parts in key

5291

x = used key parts (1 <= x <= c)

5292

5293

double rec_per_key;

5294

if (!(rec_per_key=(double)

5295

keyinfo->rec_per_key[keyinfo->key_parts-1]))

5296

rec_per_key=(double) s->records/rec+1;

5297

5298

if (!s->records)

5299

tmp = 0;

5300

else if (rec_per_key/(double) s->records >= 0.01)

5301

tmp = rec_per_key;

5302

else

5303

{

5304

double a=s->records*0.01;

5305

if (keyinfo->key_parts > 1)

5306

tmp= (max_key_part * (rec_per_key - a) +

5307

a*keyinfo->key_parts - rec_per_key)/

5308

(keyinfo->key_parts-1);

5309

else

5310

tmp= a;

5311

set_if_bigger(tmp,1.0);

5312

}

5313

records = (ulong) tmp;

5314

}

5315

5316

if (ref_or_null_part)

5317

{

5318

/* We need to do two key searches to find key */

5319

tmp *= 2.0;

5320

records *= 2.0;

5321

}

5322

5323

5324

ReuseRangeEstimateForRef-4: We get here if we could not reuse

5325

E(#rows) from range optimizer. Make another try:

5326

5327

If range optimizer produced E(#rows) for a prefix of the ref

5328

access we're considering, and that E(#rows) is lower then our

5329

current estimate, make the adjustment.

5330

5331

The decision whether we can re-use the estimate from the range

5332

optimizer is the same as in ReuseRangeEstimateForRef-3,

5333

applied to first table->quick_key_parts[key] key parts.

5334

5335

if (table->quick_keys.is_set(key) &&

5336

table->quick_key_parts[key] <= max_key_part &&

5337

const_part & (1 << table->quick_key_parts[key]) &&

5338

table->quick_n_ranges[key] == 1 + test(ref_or_null_part &

5339

const_part) &&

5340

records > (double) table->quick_rows[key])

5341

{

5342

tmp= records= (double) table->quick_rows[key];

5343

}

5344

}

5345

5346

/* Limit the number of matched rows */

5347

set_if_smaller(tmp, (double) thd->variables.max_seeks_for_key);

5348

if (table->covering_keys.is_set(key))

5349

{

5350

/* we can use only index tree */

5351

tmp= record_count * table->file->index_only_read_time(key, tmp);

5352

}

5353

else

5354

tmp= record_count * min(tmp,s->worst_seeks);

5355

}

5356

else

5357

tmp= best_time; // Do nothing

5358

}

5359

5360

if (sj_inside_out_scan && !start_key)

5361

{

5362

tmp= tmp/2;

5363

if (records)

5364

records= records/2;

5365

}

5366

5367

}

5368

if (tmp < best_time - records/(double) TIME_FOR_COMPARE)

5369

{

5370

best_time= tmp + records/(double) TIME_FOR_COMPARE;

5371

best= tmp;

5372

best_records= records;

5373

best_key= start_key;

5374

best_max_key_part= max_key_part;

5375

best_ref_depends_map= found_ref;

5376

best_is_sj_inside_out= sj_inside_out_scan;

5377

}

5378

}

5379

records= best_records;

5380

}

5381

5382

5383

Don't test table scan if it can't be better.

5384

Prefer key lookup if we would use the same key for scanning.

5385

5386

Don't do a table scan on InnoDB tables, if we can read the used

5387

parts of the row from any of the used index.

5388

This is because table scans uses index and we would not win

5389

anything by using a table scan.

5390

5391

A word for word translation of the below if-statement in sergefp's

5392

understanding: we check if we should use table scan if:

5393

(1) The found 'ref' access produces more records than a table scan

5394

(or index scan, or quick select), or 'ref' is more expensive than

5395

any of them.

5396

(2) This doesn't hold: the best way to perform table scan is to to perform

5397

'range' access using index IDX, and the best way to perform 'ref'

5398

access is to use the same index IDX, with the same or more key parts.

5399

(note: it is not clear how this rule is/should be extended to

5400

index_merge quick selects)

5401

(3) See above note about InnoDB.

5402

(4) NOT ("FORCE INDEX(...)" is used for table and there is 'ref' access

5403

path, but there is no quick select)

5404

If the condition in the above brackets holds, then the only possible

5405

"table scan" access method is ALL/index (there is no quick select).

5406

Since we have a 'ref' access path, and FORCE INDEX instructs us to

5407

choose it over ALL/index, there is no need to consider a full table

5408

scan.

5409

5410

if ((records >= s->found_records || best > s->read_time) && // (1)

5411

!(s->quick && best_key && s->quick->index == best_key->key && // (2)

5412

best_max_key_part >= s->table->quick_key_parts[best_key->key]) &&// (2)

5413

!((s->table->file->ha_table_flags() & HA_TABLE_SCAN_ON_INDEX) && // (3)

5414

! s->table->covering_keys.is_clear_all() && best_key && !s->quick) &&// (3)

5415

!(s->table->force_index && best_key && !s->quick)) // (4)

5416

{ // Check full join

5417

ha_rows rnd_records= s->found_records;

5418

5419

If there is a filtering condition on the table (i.e. ref analyzer found

5420

at least one "table.keyXpartY= exprZ", where exprZ refers only to tables

5421

preceding this table in the join order we're now considering), then

5422

assume that 25% of the rows will be filtered out by this condition.

5423

5424

This heuristic is supposed to force tables used in exprZ to be before

5425

this table in join order.

5426

5427

if (found_constraint)

5428

rnd_records-= rnd_records/4;

5429

5430

5431

If applicable, get a more accurate estimate. Don't use the two

5432

heuristics at once.

5433

5434

if (s->table->quick_condition_rows != s->found_records)

5435

rnd_records= s->table->quick_condition_rows;

5436

5437

5438

Range optimizer never proposes a RANGE if it isn't better

5439

than FULL: so if RANGE is present, it's always preferred to FULL.

5440

Here we estimate its cost.

5441

5442

if (s->quick)

5443

{

5444

5445

For each record we:

5446

- read record range through 'quick'

5447

- skip rows which does not satisfy WHERE constraints

5448

TODO:

5449

We take into account possible use of join cache for ALL/index

5450

access (see first else-branch below), but we don't take it into

5451

account here for range/index_merge access. Find out why this is so.

5452

5453

tmp= record_count *

5454

(s->quick->read_time +

5455

(s->found_records - rnd_records)/(double) TIME_FOR_COMPARE);

5456

}

5457

else

5458

{

5459

/* Estimate cost of reading table. */

5460

tmp= s->table->file->scan_time();

5461

if (s->table->map & join->outer_join) // Can't use join cache

5462

{

5463

5464

For each record we have to:

5465

- read the whole table record

5466

- skip rows which does not satisfy join condition

5467

5468

tmp= record_count *

5469

(tmp +

5470

(s->records - rnd_records)/(double) TIME_FOR_COMPARE);

5471

}

5472

else

5473

{

5474

/* We read the table as many times as join buffer becomes full. */

5475

tmp*= (1.0 + floor((double) cache_record_length(join,idx) *

5476

record_count /

5477

(double) thd->variables.join_buff_size));

5478

5479

We don't make full cartesian product between rows in the scanned

5480

table and existing records because we skip all rows from the

5481

scanned table, which does not satisfy join condition when

5482

we read the table (see flush_cached_records for details). Here we

5483

take into account cost to read and skip these records.

5484

5485

tmp+= (s->records - rnd_records)/(double) TIME_FOR_COMPARE;

5486

}

5487

}

5488

5489

5490

We estimate the cost of evaluating WHERE clause for found records

5491

as record_count * rnd_records / TIME_FOR_COMPARE. This cost plus

5492

tmp give us total cost of using TABLE SCAN

5493

5494

if (best == DBL_MAX ||

5495

(tmp + record_count/(double) TIME_FOR_COMPARE*rnd_records <

5496

best + record_count/(double) TIME_FOR_COMPARE*records))

5497

{

5498

5499

If the table has a range (s->quick is set) make_join_select()

5500

will ensure that this will be used

5501

5502

best= tmp;

5503

records= rows2double(rnd_records);

5504

best_key= 0;

5505

/* range/index_merge/ALL/index access method are "independent", so: */

5506

best_ref_depends_map= 0;

5507

best_is_sj_inside_out= false;

5508

}

5509

}

5510

5511

/* Update the cost information for the current partial plan */

5512

join->positions[idx].records_read= records;

5513

join->positions[idx].read_time= best;

5514

join->positions[idx].key= best_key;

5515

join->positions[idx].table= s;

5516

join->positions[idx].ref_depend_map= best_ref_depends_map;

5517

join->positions[idx].use_insideout_scan= best_is_sj_inside_out;

5518

5519

if (!best_key &&

5520

idx == join->const_tables &&

5521

s->table == join->sort_by_table &&

5522

join->unit->select_limit_cnt >= records)

5523

join->sort_by_table= (TABLE*) 1; // Must use temporary table

5524

5525

return;

5526

}

5527

5528

5529

/**

5530

Selects and invokes a search strategy for an optimal query plan.

5531

5532

The function checks user-configurable parameters that control the search

5533

strategy for an optimal plan, selects the search method and then invokes

5534

it. Each specific optimization procedure stores the final optimal plan in

5535

the array 'join->best_positions', and the cost of the plan in

5536

'join->best_read'.

5537

5538

@param join pointer to the structure providing all context info for

5539

the query

5540

@param join_tables set of the tables in the query

5541

5542

@todo

5543

'MAX_TABLES+2' denotes the old implementation of find_best before

5544

the greedy version. Will be removed when greedy_search is approved.

5545

5546

@retval

5547

false ok

5548

@retval

5549

true Fatal error

5550

5551

5552

static bool

5553

choose_plan(JOIN *join, table_map join_tables)

5554

{

5555

uint search_depth= join->thd->variables.optimizer_search_depth;

5556

uint prune_level= join->thd->variables.optimizer_prune_level;

5557

bool straight_join= test(join->select_options & SELECT_STRAIGHT_JOIN);

5558

5559

join->cur_embedding_map= 0;

5560

reset_nj_counters(join->join_list);

5561

5562

if (SELECT_STRAIGHT_JOIN option is set)

5563

reorder tables so dependent tables come after tables they depend

5564

on, otherwise keep tables in the order they were specified in the query

5565

else

5566

Apply heuristic: pre-sort all access plans with respect to the number of

5567

records accessed.

5568

5569

my_qsort(join->best_ref + join->const_tables,

5570

join->tables - join->const_tables, sizeof(JOIN_TAB*),

5571

straight_join ? join_tab_cmp_straight : join_tab_cmp);

5572

join->cur_emb_sj_nests= 0;

5573

if (straight_join)

5574

{

5575

optimize_straight_join(join, join_tables);

5576

}

5577

else

5578

{

5579

if (search_depth == MAX_TABLES+2)

5580

{ /*

5581

TODO: 'MAX_TABLES+2' denotes the old implementation of find_best before

5582

the greedy version. Will be removed when greedy_search is approved.

5583

5584

join->best_read= DBL_MAX;

5585

if (find_best(join, join_tables, join->const_tables, 1.0, 0.0))

5586

return(true);

5587

}

5588

else

5589

{

5590

if (search_depth == 0)

5591

/* Automatically determine a reasonable value for 'search_depth' */

5592

search_depth= determine_search_depth(join);

5593

if (greedy_search(join, join_tables, search_depth, prune_level))

5594

return(true);

5595

}

5596

}

5597

5598

5599

Store the cost of this query into a user variable

5600

Don't update last_query_cost for statements that are not "flat joins" :

5601

i.e. they have subqueries, unions or call stored procedures.

5602

TODO: calculate a correct cost for a query with subqueries and UNIONs.

5603

5604

if (join->thd->lex->is_single_level_stmt())

5605

join->thd->status_var.last_query_cost= join->best_read;

5606

return(false);

5607

}

5608

5609

5610

/**

5611

Compare two JOIN_TAB objects based on the number of accessed records.

5612

5613

@param ptr1 pointer to first JOIN_TAB object

5614

@param ptr2 pointer to second JOIN_TAB object

784

possible_keys&= cur_item->field->part_of_key;

785

}

786

787

if (possible_keys.any())

788

join_tab->const_keys|= possible_keys;

789

}

790

791

/**

792

Compare two JoinTable objects based on the number of accessed records.

793

794

@param ptr1 pointer to first JoinTable object

795

@param ptr2 pointer to second JoinTable object

5615

796

5616

797

NOTES

5617

798

The order relation implemented by join_tab_cmp() is not transitive,

5623

804

a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0

5624

805

b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838

5625

806

c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0

5626

807

5627

808

@retval

5628

809

1 if first is bigger

5629

810

@retval

5631

812

@retval

5632

813

0 if equal

5633

814

5634

5635

static int

5636

join_tab_cmp(const void* ptr1, const void* ptr2)

815

int join_tab_cmp(const void* ptr1, const void* ptr2)

5637

816

{

5638

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5639

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

817

JoinTable *jt1= *(JoinTable**) ptr1;

818

JoinTable *jt2= *(JoinTable**) ptr2;

5640

819

5641

820

if (jt1->dependent & jt2->table->map)

5642

821

return 1;

5643

822

if (jt2->dependent & jt1->table->map)

5644

return -1;

823

return -1;

5645

824

if (jt1->found_records > jt2->found_records)

5646

825

return 1;

5647

826

if (jt1->found_records < jt2->found_records)

5648

return -1;

827

return -1;

5649

828

return jt1 > jt2 ? 1 : (jt1 < jt2 ? -1 : 0);

5650

829

}

5651

830

5652

5653

831

/**

5654

832

Same as join_tab_cmp, but for use with SELECT_STRAIGHT_JOIN.

5655

833

5656

5657

static int

5658

join_tab_cmp_straight(const void* ptr1, const void* ptr2)

834

int join_tab_cmp_straight(const void* ptr1, const void* ptr2)

5659

835

{

5660

JOIN_TAB *jt1= *(JOIN_TAB**) ptr1;

5661

JOIN_TAB *jt2= *(JOIN_TAB**) ptr2;

836

JoinTable *jt1= *(JoinTable**) ptr1;

837

JoinTable *jt2= *(JoinTable**) ptr2;

5662

838

5663

839

if (jt1->dependent & jt2->table->map)

5664

840

return 1;

5668

844

}

5669

845

5670

846

/**

5671

Heuristic procedure to automatically guess a reasonable degree of

5672

exhaustiveness for the greedy search procedure.

5673

5674

The procedure estimates the optimization time and selects a search depth

5675

big enough to result in a near-optimal QEP, that doesn't take too long to

5676

find. If the number of tables in the query exceeds some constant, then

5677

search_depth is set to this constant.

5678

5679

@param join pointer to the structure providing all context info for

5680

the query

5681

5682

@note

5683

This is an extremely simplistic implementation that serves as a stub for a

5684

more advanced analysis of the join. Ideally the search depth should be

5685

determined by learning from previous query optimizations, because it will

5686

depend on the CPU power (and other factors).

5687

5688

@todo

5689

this value should be determined dynamically, based on statistics:

5690

uint max_tables_for_exhaustive_opt= 7;

5691

5692

@todo

5693

this value could be determined by some mapping of the form:

5694

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5695

5696

@return

5697

A positive integer that specifies the search depth (and thus the

5698

exhaustiveness) of the depth-first search algorithm used by

5699

'greedy_search'.

5700

5701

5702

static uint

5703

determine_search_depth(JOIN *join)

5704

{

5705

uint table_count= join->tables - join->const_tables;

5706

uint search_depth;

5707

/* TODO: this value should be determined dynamically, based on statistics: */

5708

uint max_tables_for_exhaustive_opt= 7;

5709

5710

if (table_count <= max_tables_for_exhaustive_opt)

5711

search_depth= table_count+1; // use exhaustive for small number of tables

5712

else

5713

5714

TODO: this value could be determined by some mapping of the form:

5715

depth : table_count -> [max_tables_for_exhaustive_opt..MAX_EXHAUSTIVE]

5716

5717

search_depth= max_tables_for_exhaustive_opt; // use greedy search

5718

5719

return search_depth;

5720

}

5721

5722

5723

/**

5724

Select the best ways to access the tables in a query without reordering them.

5725

5726

Find the best access paths for each query table and compute their costs

5727

according to their order in the array 'join->best_ref' (thus without

5728

reordering the join tables). The function calls sequentially

5729

'best_access_path' for each table in the query to select the best table

5730

access method. The final optimal plan is stored in the array

5731

'join->best_positions', and the corresponding cost in 'join->best_read'.

5732

5733

@param join pointer to the structure providing all context info for

5734

the query

5735

@param join_tables set of the tables in the query

5736

5737

@note

5738

This function can be applied to:

5739

- queries with STRAIGHT_JOIN

5740

- internally to compute the cost of an arbitrary QEP

5741

@par

5742

Thus 'optimize_straight_join' can be used at any stage of the query

5743

optimization process to finalize a QEP as it is.

5744

5745

5746

static void

5747

optimize_straight_join(JOIN *join, table_map join_tables)

5748

{

5749

JOIN_TAB *s;

5750

uint idx= join->const_tables;

5751

double record_count= 1.0;

5752

double read_time= 0.0;

5753

5754

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

5755

{

5756

/* Find the best access method from 's' to the current partial plan */

5757

advance_sj_state(join_tables, s);

5758

best_access_path(join, s, join->thd, join_tables, idx,

5759

record_count, read_time);

5760

/* compute the cost of the new plan extended with 's' */

5761

record_count*= join->positions[idx].records_read;

5762

read_time+= join->positions[idx].read_time;

5763

join_tables&= ~(s->table->map);

5764

++idx;

5765

}

5766

5767

read_time+= record_count / (double) TIME_FOR_COMPARE;

5768

if (join->sort_by_table &&

5769

join->sort_by_table != join->positions[join->const_tables].table->table)

5770

read_time+= record_count; // We have to make a temp table

5771

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

5772

join->best_read= read_time;

5773

}

5774

5775

5776

/**

5777

Find a good, possibly optimal, query execution plan (QEP) by a greedy search.

5778

5779

The search procedure uses a hybrid greedy/exhaustive search with controlled

5780

exhaustiveness. The search is performed in N = card(remaining_tables)

5781

steps. Each step evaluates how promising is each of the unoptimized tables,

5782

selects the most promising table, and extends the current partial QEP with

5783

that table. Currenly the most 'promising' table is the one with least

5784

expensive extension.\

5785

5786

There are two extreme cases:

5787

-# When (card(remaining_tables) < search_depth), the estimate finds the

5788

best complete continuation of the partial QEP. This continuation can be

5789

used directly as a result of the search.

5790

-# When (search_depth == 1) the 'best_extension_by_limited_search'

5791

consideres the extension of the current QEP with each of the remaining

5792

unoptimized tables.

5793

5794

All other cases are in-between these two extremes. Thus the parameter

5795

'search_depth' controlls the exhaustiveness of the search. The higher the

5796

value, the longer the optimizaton time and possibly the better the

5797

resulting plan. The lower the value, the fewer alternative plans are

5798

estimated, but the more likely to get a bad QEP.

5799

5800

All intermediate and final results of the procedure are stored in 'join':

5801

- join->positions : modified for every partial QEP that is explored

5802

- join->best_positions: modified for the current best complete QEP

5803

- join->best_read : modified for the current best complete QEP

5804

- join->best_ref : might be partially reordered

5805

5806

The final optimal plan is stored in 'join->best_positions', and its

5807

corresponding cost in 'join->best_read'.

5808

5809

@note

5810

The following pseudocode describes the algorithm of 'greedy_search':

5811

5812

@code

5813

procedure greedy_search

5814

input: remaining_tables

5815

output: pplan;

5816

{

5817

pplan = <>;

5818

do {

5819

(t, a) = best_extension(pplan, remaining_tables);

5820

pplan = concat(pplan, (t, a));

5821

remaining_tables = remaining_tables - t;

5822

} while (remaining_tables != {})

5823

return pplan;

5824

}

5825

5826

@endcode

5827

where 'best_extension' is a placeholder for a procedure that selects the

5828

most "promising" of all tables in 'remaining_tables'.

5829

Currently this estimate is performed by calling

5830

'best_extension_by_limited_search' to evaluate all extensions of the

5831

current QEP of size 'search_depth', thus the complexity of 'greedy_search'

5832

mainly depends on that of 'best_extension_by_limited_search'.

5833

5834

@par

5835

If 'best_extension()' == 'best_extension_by_limited_search()', then the

5836

worst-case complexity of this algorithm is <=

5837

O(N*N^search_depth/search_depth). When serch_depth >= N, then the

5838

complexity of greedy_search is O(N!).

5839

5840

@par

5841

In the future, 'greedy_search' might be extended to support other

5842

implementations of 'best_extension', e.g. some simpler quadratic procedure.

5843

5844

@param join pointer to the structure providing all context info

5845

for the query

5846

@param remaining_tables set of tables not included into the partial plan yet

5847

@param search_depth controlls the exhaustiveness of the search

5848

@param prune_level the pruning heuristics that should be applied during

5849

5850

5851

@retval

5852

false ok

5853

@retval

5854

true Fatal error

5855

5856

5857

static bool

5858

greedy_search(JOIN *join,

5859

table_map remaining_tables,

5860

uint search_depth,

5861

uint prune_level)

5862

{

5863

double record_count= 1.0;

5864

double read_time= 0.0;

5865

uint idx= join->const_tables; // index into 'join->best_ref'

5866

uint best_idx;

5867

uint size_remain; // cardinality of remaining_tables

5868

POSITION best_pos;

5869

JOIN_TAB *best_table; // the next plan node to be added to the curr QEP

5870

5871

/* number of tables that remain to be optimized */

5872

size_remain= my_count_bits(remaining_tables);

5873

5874

do {

5875

/* Find the extension of the current QEP with the lowest cost */

5876

join->best_read= DBL_MAX;

5877

if (best_extension_by_limited_search(join, remaining_tables, idx, record_count,

5878

read_time, search_depth, prune_level))

5879

return(true);

5880

5881

if (size_remain <= search_depth)

5882

{

5883

5884

'join->best_positions' contains a complete optimal extension of the

5885

current partial QEP.

5886

5887

return(false);

5888

}

5889

5890

/* select the first table in the optimal extension as most promising */

5891

best_pos= join->best_positions[idx];

5892

best_table= best_pos.table;

5893

5894

Each subsequent loop of 'best_extension_by_limited_search' uses

5895

'join->positions' for cost estimates, therefore we have to update its

5896

value.

5897

5898

join->positions[idx]= best_pos;

5899

5900

/* find the position of 'best_table' in 'join->best_ref' */

5901

best_idx= idx;

5902

JOIN_TAB *pos= join->best_ref[best_idx];

5903

while (pos && best_table != pos)

5904

pos= join->best_ref[++best_idx];

5905

assert((pos != NULL)); // should always find 'best_table'

5906

/* move 'best_table' at the first free position in the array of joins */

5907

swap_variables(JOIN_TAB*, join->best_ref[idx], join->best_ref[best_idx]);

5908

5909

/* compute the cost of the new plan extended with 'best_table' */

5910

record_count*= join->positions[idx].records_read;

5911

read_time+= join->positions[idx].read_time;

5912

5913

remaining_tables&= ~(best_table->table->map);

5914

--size_remain;

5915

++idx;

5916

} while (true);

5917

}

5918

5919

5920

/**

5921

Find a good, possibly optimal, query execution plan (QEP) by a possibly

5922

exhaustive search.

5923

5924

The procedure searches for the optimal ordering of the query tables in set

5925

'remaining_tables' of size N, and the corresponding optimal access paths to

5926

each table. The choice of a table order and an access path for each table

5927

constitutes a query execution plan (QEP) that fully specifies how to

5928

execute the query.

5929

5930

The maximal size of the found plan is controlled by the parameter

5931

'search_depth'. When search_depth == N, the resulting plan is complete and

5932

can be used directly as a QEP. If search_depth < N, the found plan consists

5933

of only some of the query tables. Such "partial" optimal plans are useful

5934

only as input to query optimization procedures, and cannot be used directly

5935

to execute a query.

5936

5937

The algorithm begins with an empty partial plan stored in 'join->positions'

5938

and a set of N tables - 'remaining_tables'. Each step of the algorithm

5939

evaluates the cost of the partial plan extended by all access plans for

5940

each of the relations in 'remaining_tables', expands the current partial

5941

plan with the access plan that results in lowest cost of the expanded

5942

partial plan, and removes the corresponding relation from

5943

'remaining_tables'. The algorithm continues until it either constructs a

5944

complete optimal plan, or constructs an optimal plartial plan with size =

5945

search_depth.

5946

5947

The final optimal plan is stored in 'join->best_positions'. The

5948

corresponding cost of the optimal plan is in 'join->best_read'.

5949

5950

@note

5951

The procedure uses a recursive depth-first search where the depth of the

5952

recursion (and thus the exhaustiveness of the search) is controlled by the

5953

parameter 'search_depth'.

5954

5955

@note

5956

The pseudocode below describes the algorithm of

5957

'best_extension_by_limited_search'. The worst-case complexity of this

5958

algorithm is O(N*N^search_depth/search_depth). When serch_depth >= N, then

5959

the complexity of greedy_search is O(N!).

5960

5961

@code

5962

procedure best_extension_by_limited_search(

5963

pplan in, // in, partial plan of tables-joined-so-far

5964

pplan_cost, // in, cost of pplan

5965

remaining_tables, // in, set of tables not referenced in pplan

5966

best_plan_so_far, // in/out, best plan found so far

5967

best_plan_so_far_cost,// in/out, cost of best_plan_so_far

5968

search_depth) // in, maximum size of the plans being considered

5969

{

5970

for each table T from remaining_tables

5971

{

5972

// Calculate the cost of using table T as above

5973

cost = complex-series-of-calculations;

5974

5975

// Add the cost to the cost so far.

5976

pplan_cost+= cost;

5977

5978

if (pplan_cost >= best_plan_so_far_cost)

5979

// pplan_cost already too great, stop search

5980

continue;

5981

5982

pplan= expand pplan by best_access_method;

5983

remaining_tables= remaining_tables - table T;

5984

if (remaining_tables is not an empty set

5985

and

5986

search_depth > 1)

5987

{

5988

best_extension_by_limited_search(pplan, pplan_cost,

5989

remaining_tables,

5990

best_plan_so_far,

5991

best_plan_so_far_cost,

5992

search_depth - 1);

5993

}

5994

else

5995

{

5996

best_plan_so_far_cost= pplan_cost;

5997

best_plan_so_far= pplan;

5998

}

5999

}

6000

}

6001

@endcode

6002

6003

@note

6004

When 'best_extension_by_limited_search' is called for the first time,

6005

'join->best_read' must be set to the largest possible value (e.g. DBL_MAX).

6006

The actual implementation provides a way to optionally use pruning

6007

heuristic (controlled by the parameter 'prune_level') to reduce the search

6008

space by skipping some partial plans.

6009

6010

@note

6011

The parameter 'search_depth' provides control over the recursion

6012

depth, and thus the size of the resulting optimal plan.

6013

6014

@param join pointer to the structure providing all context info

6015

for the query

6016

@param remaining_tables set of tables not included into the partial plan yet

6017

@param idx length of the partial QEP in 'join->positions';

6018

since a depth-first search is used, also corresponds

6019

to the current depth of the search tree;

6020

also an index in the array 'join->best_ref';

6021

@param record_count estimate for the number of records returned by the

6022

best partial plan

6023

@param read_time the cost of the best partial plan

6024

@param search_depth maximum depth of the recursion and thus size of the

6025

found optimal plan

6026

(0 < search_depth <= join->tables+1).

6027

@param prune_level pruning heuristics that should be applied during

6028

optimization

6029

(values: 0 = EXHAUSTIVE, 1 = PRUNE_BY_TIME_OR_ROWS)

6030

6031

@retval

6032

false ok

6033

@retval

6034

true Fatal error

6035

6036

6037

static bool

6038

best_extension_by_limited_search(JOIN *join,

6039

table_map remaining_tables,

6040

uint idx,

6041

double record_count,

6042

double read_time,

6043

uint search_depth,

6044

uint prune_level)

6045

{

6046

THD *thd= join->thd;

6047

if (thd->killed) // Abort

6048

return(true);

6049

6050

6051

'join' is a partial plan with lower cost than the best plan so far,

6052

so continue expanding it further with the tables in 'remaining_tables'.

6053

6054

JOIN_TAB *s;

6055

double best_record_count= DBL_MAX;

6056

double best_read_time= DBL_MAX;

6057

6058

for (JOIN_TAB **pos= join->best_ref + idx ; (s= *pos) ; pos++)

6059

{

6060

table_map real_table_bit= s->table->map;

6061

if ((remaining_tables & real_table_bit) &&

6062

!(remaining_tables & s->dependent) &&

6063

(!idx || !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6064

{

6065

double current_record_count, current_read_time;

6066

advance_sj_state(remaining_tables, s);

6067

6068

6069

psergey-insideout-todo:

6070

when best_access_path() detects it could do an InsideOut scan or

6071

some other scan, have it return an insideout scan and a flag that

6072

requests to "fork" this loop iteration. (Q: how does that behave

6073

when the depth is insufficient??)

6074

6075

/* Find the best access method from 's' to the current partial plan */

6076

best_access_path(join, s, thd, remaining_tables, idx,

6077

record_count, read_time);

6078

/* Compute the cost of extending the plan with 's' */

6079

current_record_count= record_count * join->positions[idx].records_read;

6080

current_read_time= read_time + join->positions[idx].read_time;

6081

6082

/* Expand only partial plans with lower cost than the best QEP so far */

6083

if ((current_read_time +

6084

current_record_count / (double) TIME_FOR_COMPARE) >= join->best_read)

6085

{

6086

restore_prev_nj_state(s);

6087

restore_prev_sj_state(remaining_tables, s);

6088

continue;

6089

}

6090

6091

6092

Prune some less promising partial plans. This heuristic may miss

6093

the optimal QEPs, thus it results in a non-exhaustive search.

6094

6095

if (prune_level == 1)

6096

{

6097

if (best_record_count > current_record_count ||

6098

best_read_time > current_read_time ||

6099

(idx == join->const_tables && s->table == join->sort_by_table)) // 's' is the first table in the QEP

6100

{

6101

if (best_record_count >= current_record_count &&

6102

best_read_time >= current_read_time &&

6103

/* TODO: What is the reasoning behind this condition? */

6104

(!(s->key_dependent & remaining_tables) ||

6105

join->positions[idx].records_read < 2.0))

6106

{

6107

best_record_count= current_record_count;

6108

best_read_time= current_read_time;

6109

}

6110

}

6111

else

6112

{

6113

restore_prev_nj_state(s);

6114

restore_prev_sj_state(remaining_tables, s);

6115

continue;

6116

}

6117

}

6118

6119

if ( (search_depth > 1) && (remaining_tables & ~real_table_bit) )

6120

{ /* Recursively expand the current partial plan */

6121

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6122

if (best_extension_by_limited_search(join,

6123

remaining_tables & ~real_table_bit,

6124

idx + 1,

6125

current_record_count,

6126

current_read_time,

6127

search_depth - 1,

6128

prune_level))

6129

return(true);

6130

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6131

}

6132

else

6133

{ /*

6134

'join' is either the best partial QEP with 'search_depth' relations,

6135

or the best complete QEP so far, whichever is smaller.

6136

6137

current_read_time+= current_record_count / (double) TIME_FOR_COMPARE;

6138

if (join->sort_by_table &&

6139

join->sort_by_table !=

6140

join->positions[join->const_tables].table->table)

6141

/* We have to make a temp table */

6142

current_read_time+= current_record_count;

6143

if ((search_depth == 1) || (current_read_time < join->best_read))

6144

{

6145

memcpy(join->best_positions, join->positions,

6146

sizeof(POSITION) * (idx + 1));

6147

join->best_read= current_read_time - 0.001;

6148

}

6149

}

6150

restore_prev_nj_state(s);

6151

restore_prev_sj_state(remaining_tables, s);

6152

}

6153

}

6154

return(false);

6155

}

6156

6157

6158

/**

6159

@todo

6160

- TODO: this function is here only temporarily until 'greedy_search' is

6161

tested and accepted.

6162

6163

RETURN VALUES

6164

false ok

6165

true Fatal error

6166

6167

static bool

6168

find_best(JOIN *join,table_map rest_tables,uint idx,double record_count,

6169

double read_time)

6170

{

6171

THD *thd= join->thd;

6172

if (thd->killed)

6173

return(true);

6174

if (!rest_tables)

6175

{

6176

read_time+=record_count/(double) TIME_FOR_COMPARE;

6177

if (join->sort_by_table &&

6178

join->sort_by_table !=

6179

join->positions[join->const_tables].table->table)

6180

read_time+=record_count; // We have to make a temp table

6181

if (read_time < join->best_read)

6182

{

6183

memcpy(join->best_positions, join->positions, sizeof(POSITION)*idx);

6184

join->best_read= read_time - 0.001;

6185

}

6186

return(false);

6187

}

6188

if (read_time+record_count/(double) TIME_FOR_COMPARE >= join->best_read)

6189

return(false); /* Found better before */

6190

6191

JOIN_TAB *s;

6192

double best_record_count=DBL_MAX,best_read_time=DBL_MAX;

6193

for (JOIN_TAB **pos=join->best_ref+idx ; (s=*pos) ; pos++)

6194

{

6195

table_map real_table_bit=s->table->map;

6196

if ((rest_tables & real_table_bit) && !(rest_tables & s->dependent) &&

6197

(!idx|| !check_interleaving_with_nj(join->positions[idx-1].table, s)))

6198

{

6199

double records, best;

6200

advance_sj_state(rest_tables, s);

6201

best_access_path(join, s, thd, rest_tables, idx, record_count,

6202

read_time);

6203

records= join->positions[idx].records_read;

6204

best= join->positions[idx].read_time;

6205

6206

Go to the next level only if there hasn't been a better key on

6207

this level! This will cut down the search for a lot simple cases!

6208

6209

double current_record_count=record_count*records;

6210

double current_read_time=read_time+best;

6211

if (best_record_count > current_record_count ||

6212

best_read_time > current_read_time ||

6213

(idx == join->const_tables && s->table == join->sort_by_table))

6214

{

6215

if (best_record_count >= current_record_count &&

6216

best_read_time >= current_read_time &&

6217

(!(s->key_dependent & rest_tables) || records < 2.0))

6218

{

6219

best_record_count=current_record_count;

6220

best_read_time=current_read_time;

6221

}

6222

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6223

if (find_best(join,rest_tables & ~real_table_bit,idx+1,

6224

current_record_count,current_read_time))

6225

return(true);

6226

swap_variables(JOIN_TAB*, join->best_ref[idx], *pos);

6227

}

6228

restore_prev_nj_state(s);

6229

restore_prev_sj_state(rest_tables, s);

6230

if (join->select_options & SELECT_STRAIGHT_JOIN)

6231

break; // Don't test all combinations

6232

}

6233

}

6234

return(false);

6235

}

6236

6237

6238

/**

6239

847

Find how much space the prevous read not const tables takes in cache.

6240

848

6241

6242

static void calc_used_field_length(THD *thd __attribute__((unused)),

6243

JOIN_TAB *join_tab)

849

void calc_used_field_length(Session *, JoinTable *join_tab)

6244

850

{

6245

uint null_fields,blobs,fields,rec_length;

851

uint32_t null_fields,blobs,fields,rec_length;

6246

852

Field **f_ptr,*field;

6247

MY_BITMAP *read_set= join_tab->table->read_set;;

6248

853

6249

854

null_fields= blobs= fields= rec_length=0;

6250

855

for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)

6251

856

{

6252

if (bitmap_is_set(read_set, field->field_index))

857

if (field->isReadSet())

6253

858

{

6254

uint flags=field->flags;

859

uint32_t flags=field->flags;

6255

860

fields++;

6256

861

rec_length+=field->pack_length();

6257

862

if (flags & BLOB_FLAG)

6258

blobs++;

863

blobs++;

6259

864

if (!(flags & NOT_NULL_FLAG))

6260

null_fields++;

865

null_fields++;

6261

866

}

6262

867

}

6263

868

if (null_fields)

6264

rec_length+=(join_tab->table->s->null_fields+7)/8;

869

rec_length+=(join_tab->table->getNullFields() + 7)/8;

6265

870

if (join_tab->table->maybe_null)

6266

871

rec_length+=sizeof(bool);

6267

872

if (blobs)

6268

873

{

6269

uint blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-

6270

(join_tab->table->s->reclength- rec_length));

6271

rec_length+=(uint) max((uint)4,blob_length);

6272

}

6273

join_tab->used_fields=fields;

6274

join_tab->used_fieldlength=rec_length;

6275

join_tab->used_blobs=blobs;

6276

}

6277

6278

6279

static uint

6280

cache_record_length(JOIN *join,uint idx)

6281

{

6282

uint length=0;

6283

JOIN_TAB **pos,**end;

6284

THD *thd=join->thd;

6285

6286

for (pos=join->best_ref+join->const_tables,end=join->best_ref+idx ;

6287

pos != end ;

6288

pos++)

6289

{

6290

JOIN_TAB *join_tab= *pos;

6291

if (!join_tab->used_fieldlength) /* Not calced yet */

6292

calc_used_field_length(thd, join_tab);

6293

length+=join_tab->used_fieldlength;

6294

}

6295

return length;

6296

}

6297

6298

6299

6300

Get the number of different row combinations for subset of partial join

6301

6302

SYNOPSIS

6303

prev_record_reads()

6304

join The join structure

6305

idx Number of tables in the partial join order (i.e. the

6306

partial join order is in join->positions[0..idx-1])

6307

found_ref Bitmap of tables for which we need to find # of distinct

6308

row combinations.

6309

6310

DESCRIPTION

6311

Given a partial join order (in join->positions[0..idx-1]) and a subset of

6312

tables within that join order (specified in found_ref), find out how many

6313

distinct row combinations of subset tables will be in the result of the

6314

partial join order.

6315

6316

This is used as follows: Suppose we have a table accessed with a ref-based

6317

method. The ref access depends on current rows of tables in found_ref.

6318

We want to count # of different ref accesses. We assume two ref accesses

6319

will be different if at least one of access parameters is different.

6320

Example: consider a query

6321

6322

SELECT * FROM t1, t2, t3 WHERE t1.key=c1 AND t2.key=c2 AND t3.key=t1.field

6323

6324

and a join order:

6325

t1, ref access on t1.key=c1

6326

t2, ref access on t2.key=c2

6327

t3, ref access on t3.key=t1.field

6328

6329

For t1: n_ref_scans = 1, n_distinct_ref_scans = 1

6330

For t2: n_ref_scans = records_read(t1), n_distinct_ref_scans=1

6331

For t3: n_ref_scans = records_read(t1)*records_read(t2)

6332

n_distinct_ref_scans = #records_read(t1)

6333

6334

The reason for having this function (at least the latest version of it)

6335

is that we need to account for buffering in join execution.

6336

6337

An edge-case example: if we have a non-first table in join accessed via

6338

ref(const) or ref(param) where there is a small number of different

6339

values of param, then the access will likely hit the disk cache and will

6340

not require any disk seeks.

6341

6342

The proper solution would be to assume an LRU disk cache of some size,

6343

calculate probability of cache hits, etc. For now we just count

6344

identical ref accesses as one.

6345

6346

RETURN

6347

Expected number of row combinations

6348

6349

6350

static double

6351

prev_record_reads(JOIN *join, uint idx, table_map found_ref)

6352

{

6353

double found=1.0;

6354

POSITION *pos_end= join->positions - 1;

6355

for (POSITION *pos= join->positions + idx - 1; pos != pos_end; pos--)

6356

{

6357

if (pos->table->table->map & found_ref)

6358

{

6359

found_ref|= pos->ref_depend_map;

6360

6361

For the case of "t1 LEFT JOIN t2 ON ..." where t2 is a const table

6362

with no matching row we will get position[t2].records_read==0.

6363

Actually the size of output is one null-complemented row, therefore

6364

we will use value of 1 whenever we get records_read==0.

6365

6366

Note

6367

- the above case can't occur if inner part of outer join has more

6368

than one table: table with no matches will not be marked as const.

6369

6370

- Ideally we should add 1 to records_read for every possible null-

6371

complemented row. We're not doing it because: 1. it will require

6372

non-trivial code and add overhead. 2. The value of records_read

6373

is an inprecise estimate and adding 1 (or, in the worst case,

6374

#max_nested_outer_joins=64-1) will not make it any more precise.

6375

6376

if (pos->records_read > DBL_EPSILON)

6377

found*= pos->records_read;

6378

}

6379

}

6380

return found;

6381

}

6382

874

uint32_t blob_length=(uint32_t) (join_tab->table->cursor->stats.mean_rec_length-

875

(join_tab->table->getRecordLength()- rec_length));

876

rec_length+= max((uint32_t)4,blob_length);

877

}

878

join_tab->used_fields= fields;

879

join_tab->used_fieldlength= rec_length;

880

join_tab->used_blobs= blobs;

881

}

882

883

StoredKey *get_store_key(Session *session,

884

optimizer::KeyUse *keyuse,

885

table_map used_tables,

886

KEY_PART_INFO *key_part,

887

unsigned char *key_buff,

888

uint32_t maybe_null)

889

{

890

Item_ref *key_use_val= static_cast<Item_ref *>(keyuse->getVal());

891

if (! ((~used_tables) & keyuse->getUsedTables())) // if const item

892

{

893

return new store_key_const_item(session,

894

key_part->field,

895

key_buff + maybe_null,

896

maybe_null ? key_buff : 0,

897

key_part->length,

898

key_use_val);

899

}

900

else if (key_use_val->type() == Item::FIELD_ITEM ||

901

(key_use_val->type() == Item::REF_ITEM &&

902

key_use_val->ref_type() == Item_ref::OUTER_REF &&

903

(*(Item_ref**)((Item_ref*)key_use_val)->ref)->ref_type() == Item_ref::DIRECT_REF &&

904

key_use_val->real_item()->type() == Item::FIELD_ITEM))

905

{

906

return new store_key_field(session,

907

key_part->field,

908

key_buff + maybe_null,

909

maybe_null ? key_buff : 0,

910

key_part->length,

911

((Item_field*) key_use_val->real_item())->field,

912

key_use_val->full_name());

913

}

914

return new store_key_item(session,

915

key_part->field,

916

key_buff + maybe_null,

917

maybe_null ? key_buff : 0,

918

key_part->length,

919

key_use_val);

920

}

6383

921

6384

922

/**

6385

Set up join struct according to best position.

923

This function is only called for const items on fields which are keys.

924

925

@return

926

returns 1 if there was some conversion made when the field was stored.

6386

927

6387

6388

static bool

6389

get_best_combination(JOIN *join)

6390

{

6391

uint i,tablenr;

6392

table_map used_tables;

6393

JOIN_TAB *join_tab,*j;

6394

KEYUSE *keyuse;

6395

uint table_count;

6396

THD *thd=join->thd;

6397

6398

table_count=join->tables;

6399

if (!(join->join_tab=join_tab=

6400

(JOIN_TAB*) thd->alloc(sizeof(JOIN_TAB)*table_count)))

6401

return(true);

6402

6403

join->full_join=0;

6404

6405

used_tables= OUTER_REF_TABLE_BIT; // Outer row is already read

6406

for (j=join_tab, tablenr=0 ; tablenr < table_count ; tablenr++,j++)

928

bool store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

929

{

930

bool error;

931

Table *table= field->table;

932

Session *session= table->in_use;

933

ha_rows cuted_fields=session->cuted_fields;

934

935

936

we should restore old value of count_cuted_fields because

937

store_val_in_field can be called from mysql_insert

938

with select_insert, which make count_cuted_fields= 1

939

940

enum_check_fields old_count_cuted_fields= session->count_cuted_fields;

941

session->count_cuted_fields= check_flag;

942

error= item->save_in_field(field, 1);

943

session->count_cuted_fields= old_count_cuted_fields;

944

return error || cuted_fields != session->cuted_fields;

945

}

946

947

inline void add_cond_and_fix(Item **e1, Item *e2)

948

{

949

if (*e1)

6407

950

{

6408

TABLE *form;

6409

*j= *join->best_positions[tablenr].table;

6410

form=join->table[tablenr]=j->table;

6411

used_tables|= form->map;

6412

form->reginfo.join_tab=j;

6413

if (!*j->on_expr_ref)

6414

form->reginfo.not_exists_optimize=0; // Only with LEFT JOIN

6415

if (j->type == JT_CONST)

6416

continue; // Handled in make_join_stat..

6417

6418

j->ref.key = -1;

6419

j->ref.key_parts=0;

6420

6421

if (j->type == JT_SYSTEM)

6422

continue;

6423

if (j->keys.is_clear_all() || !(keyuse= join->best_positions[tablenr].key))

951

Item *res;

952

if ((res= new Item_cond_and(*e1, e2)))

6424

953

{

6425

j->type=JT_ALL;

6426

if (tablenr != join->const_tables)

6427

join->full_join=1;

954

*e1= res;

955

res->quick_fix_field();

6428

956

}

6429

else if (create_ref_for_key(join, j, keyuse, used_tables))

6430

return(true); // Something went wrong

6431

957

}

6432

6433

for (i=0 ; i < table_count ; i++)

6434

join->map2table[join->join_tab[i].table->tablenr]=join->join_tab+i;

6435

update_depend_map(join);

6436

return(0);

958

else

959

*e1= e2;

6437

960

}

6438

961

6439

6440

static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,

6441

table_map used_tables)

962

bool create_ref_for_key(JOIN *join,

963

JoinTable *j,

964

optimizer::KeyUse *org_keyuse,

965

table_map used_tables)

6442

966

{

6443

KEYUSE *keyuse=org_keyuse;

6444

THD *thd= join->thd;

6445

uint keyparts,length,key;

6446

TABLE *table;

6447

KEY *keyinfo;

967

optimizer::KeyUse *keyuse= org_keyuse;

968

Session *session= join->session;

969

uint32_t keyparts;

970

uint32_t length;

971

uint32_t key;

972

Table *table= NULL;

973

KEY *keyinfo= NULL;

6448

974

6449

975

/* Use best key from find_best */

6450

table=j->table;

6451

key=keyuse->key;

6452

keyinfo=table->key_info+key;

976

table= j->table;

977

key= keyuse->getKey();

978

keyinfo= table->key_info + key;

6453

979

6454

980

{

6455

keyparts=length=0;

6456

uint found_part_ref_or_null= 0;

981

keyparts= length= 0;

982

uint32_t found_part_ref_or_null= 0;

6457

983

6458

984

Calculate length for the used key

6459

985

Stop if there is a missing key part or when we find second key_part

6461

987

6462

988

6463

989

{

6464

if (!(~used_tables & keyuse->used_tables))

990

if (! (~used_tables & keyuse->getUsedTables()))

6465

991

{

6466

if (keyparts == keyuse->keypart &&

6467

!(found_part_ref_or_null & keyuse->optimize))

6468

{

6469

keyparts++;

6470

length+= keyinfo->key_part[keyuse->keypart].store_length;

6471

found_part_ref_or_null|= keyuse->optimize;

6472

}

992

if (keyparts == keyuse->getKeypart() &&

993

! (found_part_ref_or_null & keyuse->getOptimizeFlags()))

994

{

995

keyparts++;

996

length+= keyinfo->key_part[keyuse->getKeypart()].store_length;

997

found_part_ref_or_null|= keyuse->getOptimizeFlags();

998

}

6473

999

}

6474

1000

keyuse++;

6475

} while (keyuse->table == table && keyuse->key == key);

1001

} while (keyuse->getTable() == table && keyuse->getKey() == key);

6476

1002

}

6477

1003

6478

1004

/* set up fieldref */

6480

1006

j->ref.key_parts=keyparts;

6481

1007

j->ref.key_length=length;

6482

1008

j->ref.key=(int) key;

6483

if (!(j->ref.key_buff= (uchar*) thd->calloc(ALIGN_SIZE(length)*2)) ||

6484

!(j->ref.key_copy= (store_key**) thd->alloc((sizeof(store_key*) *

6485

(keyparts+1)))) ||

6486

!(j->ref.items= (Item**) thd->alloc(sizeof(Item*)*keyparts)) ||

6487

!(j->ref.cond_guards= (bool**) thd->alloc(sizeof(uint*)*keyparts)))

1009

if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||

1010

!(j->ref.key_copy= (StoredKey**) session->alloc((sizeof(StoredKey*) *

1011

(keyparts+1)))) ||

1012

!(j->ref.items= (Item**) session->alloc(sizeof(Item*)*keyparts)) ||

1013

!(j->ref.cond_guards= (bool**) session->alloc(sizeof(uint*)*keyparts)))

6488

1014

{

6489

1015

return(true);

6490

1016

}

6494

1020

j->ref.disable_cache= false;

6495

1021

keyuse=org_keyuse;

6496

1022

6497

store_key **ref_key= j->ref.key_copy;

6498

uchar *key_buff=j->ref.key_buff, *null_ref_key= 0;

1023

StoredKey **ref_key= j->ref.key_copy;

1024

unsigned char *key_buff= j->ref.key_buff, *null_ref_key= 0;

6499

1025

bool keyuse_uses_no_tables= true;

6500

1026

{

6501

uint i;

6502

for (i=0 ; i < keyparts ; keyuse++,i++)

1027

for (uint32_t i= 0; i < keyparts; keyuse++, i++)

6503

1028

{

6504

while (keyuse->keypart != i ||

6505

((~used_tables) & keyuse->used_tables))

6506

keyuse++; /* Skip other parts */

1029

while (keyuse->getKeypart() != i ||

1030

((~used_tables) & keyuse->getUsedTables()))

1031

keyuse++; /* Skip other parts */

6507

1032

6508

uint maybe_null= test(keyinfo->key_part[i].null_bit);

6509

j->ref.items[i]=keyuse->val; // Save for cond removal

6510

j->ref.cond_guards[i]= keyuse->cond_guard;

6511

if (keyuse->null_rejecting)

1033

uint32_t maybe_null= test(keyinfo->key_part[i].null_bit);

1034

j->ref.items[i]= keyuse->getVal(); // Save for cond removal

1035

j->ref.cond_guards[i]= keyuse->getConditionalGuard();

1036

if (keyuse->isNullRejected())

6512

1037

j->ref.null_rejecting |= 1 << i;

6513

keyuse_uses_no_tables= keyuse_uses_no_tables && !keyuse->used_tables;

6514

if (!keyuse->used_tables &&

6515

!(join->select_options & SELECT_DESCRIBE))

6516

{ // Compare against constant

6517

store_key_item tmp(thd, keyinfo->key_part[i].field,

1038

keyuse_uses_no_tables= keyuse_uses_no_tables && ! keyuse->getUsedTables();

1039

if (! keyuse->getUsedTables() && !(join->select_options & SELECT_DESCRIBE))

1040

{ // Compare against constant

1041

store_key_item tmp(session, keyinfo->key_part[i].field,

6518

1042

key_buff + maybe_null,

6519

1043

maybe_null ? key_buff : 0,

6520

keyinfo->key_part[i].length, keyuse->val);

6521

if (thd->is_fatal_error)

6522

return(true);

6523

tmp.copy();

1044

keyinfo->key_part[i].length, keyuse->getVal());

1045

if (session->is_fatal_error)

1046

return(true);

1047

tmp.copy();

6524

1048

}

6525

1049

else

6526

*ref_key++= get_store_key(thd,

6527

keyuse,join->const_table_map,

6528

&keyinfo->key_part[i],

6529

key_buff, maybe_null);

1050

*ref_key++= get_store_key(session,

1051

keyuse,join->const_table_map,

1052

&keyinfo->key_part[i],

1053

key_buff, maybe_null);

6530

1054

6531

Remember if we are going to use REF_OR_NULL

6532

But only if field _really_ can be null i.e. we force JT_REF

6533

instead of JT_REF_OR_NULL in case if field can't be null

1055

Remember if we are going to use REF_OR_NULL

1056

But only if field _really_ can be null i.e. we force AM_REF

1057

instead of AM_REF_OR_NULL in case if field can't be null

6534

1058

6535

if ((keyuse->optimize & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

6536

null_ref_key= key_buff;

1059

if ((keyuse->getOptimizeFlags() & KEY_OPTIMIZE_REF_OR_NULL) && maybe_null)

1060

null_ref_key= key_buff;

6537

1061

key_buff+=keyinfo->key_part[i].store_length;

6538

1062

}

6539

1063

}

6540

*ref_key=0; // end_marker

6541

if (j->type == JT_CONST)

1064

*ref_key= 0; // end_marker

1065

if (j->type == AM_CONST)

6542

1066

j->table->const_table= 1;

6543

1067

else if (((keyinfo->flags & (HA_NOSAME | HA_NULL_PART_KEY)) != HA_NOSAME) ||

6544

1068

keyparts != keyinfo->key_parts || null_ref_key)

6545

1069

{

6546

1070

/* Must read with repeat */

6547

j->type= null_ref_key ? JT_REF_OR_NULL : JT_REF;

1071

j->type= null_ref_key ? AM_REF_OR_NULL : AM_REF;

6548

1072

j->ref.null_ref_key= null_ref_key;

6549

1073

}

6550

1074

else if (keyuse_uses_no_tables)

6556

1080

Here we should not mark the table as a 'const' as a field may

6557

1081

have a 'normal' value or a NULL value.

6558

1082

6559

j->type=JT_CONST;

6560

}

6561

else

6562

j->type=JT_EQ_REF;

6563

return(0);

6564

}

6565

6566

6567

6568

static store_key *

6569

get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,

6570

KEY_PART_INFO *key_part, uchar *key_buff, uint maybe_null)

6571

{

6572

if (!((~used_tables) & keyuse->used_tables)) // if const item

6573

{

6574

return new store_key_const_item(thd,

6575

key_part->field,

6576

key_buff + maybe_null,

6577

maybe_null ? key_buff : 0,

6578

key_part->length,

6579

keyuse->val);

6580

}

6581

else if (keyuse->val->type() == Item::FIELD_ITEM ||

6582

(keyuse->val->type() == Item::REF_ITEM &&

6583

((Item_ref*)keyuse->val)->ref_type() == Item_ref::OUTER_REF &&

6584

(*(Item_ref**)((Item_ref*)keyuse->val)->ref)->ref_type() ==

6585

Item_ref::DIRECT_REF &&

6586

keyuse->val->real_item()->type() == Item::FIELD_ITEM))

6587

return new store_key_field(thd,

6588

key_part->field,

6589

key_buff + maybe_null,

6590

maybe_null ? key_buff : 0,

6591

key_part->length,

6592

((Item_field*) keyuse->val->real_item())->field,

6593

keyuse->val->full_name());

6594

return new store_key_item(thd,

6595

key_part->field,

6596

key_buff + maybe_null,

6597

maybe_null ? key_buff : 0,

6598

key_part->length,

6599

keyuse->val);

6600

}

6601

6602

/**

6603

This function is only called for const items on fields which are keys.

6604

6605

@return

6606

returns 1 if there was some conversion made when the field was stored.

6607

6608

6609

bool

6610

store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)

6611

{

6612

bool error;

6613

TABLE *table= field->table;

6614

THD *thd= table->in_use;

6615

ha_rows cuted_fields=thd->cuted_fields;

6616

my_bitmap_map *old_map= dbug_tmp_use_all_columns(table,

6617

table->write_set);

6618

6619

6620

we should restore old value of count_cuted_fields because

6621

store_val_in_field can be called from mysql_insert

6622

with select_insert, which make count_cuted_fields= 1

6623

6624

enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;

6625

thd->count_cuted_fields= check_flag;

6626

error= item->save_in_field(field, 1);

6627

thd->count_cuted_fields= old_count_cuted_fields;

6628

dbug_tmp_restore_column_map(table->write_set, old_map);

6629

return error || cuted_fields != thd->cuted_fields;

6630

}

6631

6632

6633

static bool

6634

make_simple_join(JOIN *join,TABLE *tmp_table)

6635

{

6636

TABLE **tableptr;

6637

JOIN_TAB *join_tab;

6638

6639

6640

Reuse TABLE * and JOIN_TAB if already allocated by a previous call

6641

to this function through JOIN::exec (may happen for sub-queries).

6642

6643

if (!join->table_reexec)

6644

{

6645

if (!(join->table_reexec= (TABLE**) join->thd->alloc(sizeof(TABLE*))))

6646

return(true); /* purecov: inspected */

6647

if (join->tmp_join)

6648

join->tmp_join->table_reexec= join->table_reexec;

6649

}

6650

if (!join->join_tab_reexec)

6651

{

6652

if (!(join->join_tab_reexec=

6653

(JOIN_TAB*) join->thd->alloc(sizeof(JOIN_TAB))))

6654

return(true); /* purecov: inspected */

6655

if (join->tmp_join)

6656

join->tmp_join->join_tab_reexec= join->join_tab_reexec;

6657

}

6658

tableptr= join->table_reexec;

6659

join_tab= join->join_tab_reexec;

6660

6661

join->join_tab=join_tab;

6662

join->table=tableptr; tableptr[0]=tmp_table;

6663

join->tables=1;

6664

join->const_tables=0;

6665

join->const_table_map=0;

6666

join->tmp_table_param.field_count= join->tmp_table_param.sum_func_count=

6667

join->tmp_table_param.func_count=0;

6668

join->tmp_table_param.copy_field=join->tmp_table_param.copy_field_end=0;

6669

join->first_record=join->sort_and_group=0;

6670

join->send_records=(ha_rows) 0;

6671

join->group=0;

6672

join->row_limit=join->unit->select_limit_cnt;

6673

join->do_send_rows = (join->row_limit) ? 1 : 0;

6674

6675

join_tab->cache.buff=0; /* No caching */

6676

join_tab->table=tmp_table;

6677

join_tab->select=0;

6678

join_tab->select_cond=0;

6679

join_tab->quick=0;

6680

join_tab->type= JT_ALL; /* Map through all records */

6681

join_tab->keys.init();

6682

join_tab->keys.set_all(); /* test everything in quick */

6683

join_tab->info=0;

6684

join_tab->on_expr_ref=0;

6685

join_tab->last_inner= 0;

6686

join_tab->first_unmatched= 0;

6687

join_tab->ref.key = -1;

6688

join_tab->not_used_in_distinct=0;

6689

join_tab->read_first_record= join_init_read_record;

6690

join_tab->join=join;

6691

join_tab->ref.key_parts= 0;

6692

join_tab->flush_weedout_table= join_tab->check_weed_out_table= NULL;

6693

join_tab->do_firstmatch= NULL;

6694

memset(&join_tab->read_record, 0, sizeof(join_tab->read_record));

6695

tmp_table->status=0;

6696

tmp_table->null_row=0;

6697

return(false);

6698

}

6699

6700

6701

inline void add_cond_and_fix(Item **e1, Item *e2)

6702

{

6703

if (*e1)

6704

{

6705

Item *res;

6706

if ((res= new Item_cond_and(*e1, e2)))

6707

{

6708

*e1= res;

6709

res->quick_fix_field();

6710

}

6711

}

6712

else

6713

*e1= e2;

6714

}

6715

1083

j->type= AM_CONST;

1084

}

1085

else

1086

j->type= AM_EQ_REF;

1087

return 0;

1088

}

6716

1089

6717

1090

/**

6718

1091

Add to join_tab->select_cond[i] "table.field IS NOT NULL" conditions

6727

1100

add "t1.field IS NOT NULL" to t1's table condition. @n

6728

1101

6729

1102

Description of the optimization:

6730

1103

6731

1104

We look through equalities choosen to perform ref/eq_ref access,

6732

1105

pick equalities that have form "tbl.part_of_key = othertbl.field"

6733

1106

(where othertbl is a non-const table and othertbl.field may be NULL)

6755

1128

This optimization doesn't affect the choices that ref, range, or join

6756

1129

optimizer make. This was intentional because this was added after 4.1

6757

1130

was GA.

6758

1131

6759

1132

Implementation overview

6760

1133

1. update_ref_and_keys() accumulates info about null-rejecting

6761

predicates in in KEY_FIELD::null_rejecting

6762

1.1 add_key_part saves these to KEYUSE.

6763

2. create_ref_for_key copies them to TABLE_REF.

1134

predicates in in KeyField::null_rejecting

1135

1.1 add_key_part saves these to KeyUse.

1136

2. create_ref_for_key copies them to table_reference_st.

6764

1137

3. add_not_null_conds adds "x IS NOT NULL" to join_tab->select_cond of

6765

appropiate JOIN_TAB members.

1138

appropiate JoinTable members.

6766

1139

6767

6768

static void add_not_null_conds(JOIN *join)

1140

void add_not_null_conds(JOIN *join)

6769

1141

{

6770

for (uint i=join->const_tables ; i < join->tables ; i++)

1142

for (uint32_t i= join->const_tables; i < join->tables; i++)

6771

1143

{

6772

JOIN_TAB *tab=join->join_tab+i;

6773

if ((tab->type == JT_REF || tab->type == JT_EQ_REF ||

6774

tab->type == JT_REF_OR_NULL) &&

1144

JoinTable *tab=join->join_tab+i;

1145

if ((tab->type == AM_REF || tab->type == AM_EQ_REF ||

1146

tab->type == AM_REF_OR_NULL) &&

6775

1147

!tab->table->maybe_null)

6776

1148

{

6777

for (uint keypart= 0; keypart < tab->ref.key_parts; keypart++)

1149

for (uint32_t keypart= 0; keypart < tab->ref.key_parts; keypart++)

6778

1150

{

6779

1151

if (tab->ref.null_rejecting & (1 << keypart))

6780

1152

{

6782

1154

Item *notnull;

6783

1155

assert(item->type() == Item::FIELD_ITEM);

6784

1156

Item_field *not_null_item= (Item_field*)item;

6785

JOIN_TAB *referred_tab= not_null_item->field->table->reginfo.join_tab;

1157

JoinTable *referred_tab= not_null_item->field->table->reginfo.join_tab;

6786

1158

6787

1159

For UPDATE queries such as:

6788

1160

UPDATE t1 SET t1.f2=(SELECT MAX(t2.f4) FROM t2 WHERE t2.f3=t1.f1);

6794

1166

return;

6795

1167

6796

1168

We need to do full fix_fields() call here in order to have correct

6797

notnull->const_item(). This is needed e.g. by test_quick_select

6798

when it is called from make_join_select after this function is

1169

notnull->const_item(). This is needed e.g. by test_quick_select

1170

when it is called from make_join_select after this function is

6799

1171

called.

6800

1172

6801

if (notnull->fix_fields(join->thd, &notnull))

1173

if (notnull->fix_fields(join->session, &notnull))

6802

1174

return;

6803

1175

add_cond_and_fix(&referred_tab->select_cond, notnull);

6804

1176

}

6823

1195

- pointer to the guarded predicate, if success

6824

1196

- 0, otherwise

6825

1197

6826

6827

static COND*

6828

add_found_match_trig_cond(JOIN_TAB *tab, COND *cond, JOIN_TAB *root_tab)

1198

COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab)

6829

1199

{

6830

1200

COND *tmp;

6831

1201

assert(cond != 0);

6841

1211

return tmp;

6842

1212

}

6843

1213

6844

6845

/**

6846

Fill in outer join related info for the execution plan structure.

6847

6848

For each outer join operation left after simplification of the

6849

original query the function set up the following pointers in the linear

6850

structure join->join_tab representing the selected execution plan.

6851

The first inner table t0 for the operation is set to refer to the last

6852

inner table tk through the field t0->last_inner.

6853

Any inner table ti for the operation are set to refer to the first

6854

inner table ti->first_inner.

6855

The first inner table t0 for the operation is set to refer to the

6856

first inner table of the embedding outer join operation, if there is any,

6857

through the field t0->first_upper.

6858

The on expression for the outer join operation is attached to the

6859

corresponding first inner table through the field t0->on_expr_ref.

6860

Here ti are structures of the JOIN_TAB type.

6861

6862

EXAMPLE. For the query:

6863

@code

6864

SELECT * FROM t1

6865

LEFT JOIN

6866

(t2, t3 LEFT JOIN t4 ON t3.a=t4.a)

6867

ON (t1.a=t2.a AND t1.b=t3.b)

6868

WHERE t1.c > 5,

6869

@endcode

6870

6871

given the execution plan with the table order t1,t2,t3,t4

6872

is selected, the following references will be set;

6873

t4->last_inner=[t4], t4->first_inner=[t4], t4->first_upper=[t2]

6874

t2->last_inner=[t4], t2->first_inner=t3->first_inner=[t2],

6875

on expression (t1.a=t2.a AND t1.b=t3.b) will be attached to

6876

*t2->on_expr_ref, while t3.a=t4.a will be attached to *t4->on_expr_ref.

6877

6878

@param join reference to the info fully describing the query

6879

6880

@note

6881

The function assumes that the simplification procedure has been

6882

already applied to the join query (see simplify_joins).

6883

This function can be called only after the execution plan

6884

has been chosen.

6885

6886

6887

static void

6888

make_outerjoin_info(JOIN *join)

6889

{

6890

for (uint i=join->const_tables ; i < join->tables ; i++)

6891

{

6892

JOIN_TAB *tab=join->join_tab+i;

6893

TABLE *table=tab->table;

6894

TABLE_LIST *tbl= table->pos_in_table_list;

6895

TABLE_LIST *embedding= tbl->embedding;

6896

6897

if (tbl->outer_join)

6898

{

6899

6900

Table tab is the only one inner table for outer join.

6901

(Like table t4 for the table reference t3 LEFT JOIN t4 ON t3.a=t4.a

6902

is in the query above.)

6903

6904

tab->last_inner= tab->first_inner= tab;

6905

tab->on_expr_ref= &tbl->on_expr;

6906

tab->cond_equal= tbl->cond_equal;

6907

if (embedding)

6908

tab->first_upper= embedding->nested_join->first_nested;

6909

}

6910

for ( ; embedding ; embedding= embedding->embedding)

6911

{

6912

/* Ignore sj-nests: */

6913

if (!embedding->on_expr)

6914

continue;

6915

NESTED_JOIN *nested_join= embedding->nested_join;

6916

if (!nested_join->counter_)

6917

{

6918

6919

Table tab is the first inner table for nested_join.

6920

Save reference to it in the nested join structure.

6921

6922

nested_join->first_nested= tab;

6923

tab->on_expr_ref= &embedding->on_expr;

6924

tab->cond_equal= tbl->cond_equal;

6925

if (embedding->embedding)

6926

tab->first_upper= embedding->embedding->nested_join->first_nested;

6927

}

6928

if (!tab->first_inner)

6929

tab->first_inner= nested_join->first_nested;

6930

if (++nested_join->counter_ < nested_join->join_list.elements)

6931

break;

6932

/* Table tab is the last inner table for nested join. */

6933

nested_join->first_nested->last_inner= tab;

6934

}

6935

}

6936

return;

6937

}

6938

6939

6940

static bool

6941

make_join_select(JOIN *join,SQL_SELECT *select,COND *cond)

6942

{

6943

THD *thd= join->thd;

6944

if (select)

6945

{

6946

add_not_null_conds(join);

6947

table_map used_tables;

6948

if (cond) /* Because of QUICK_GROUP_MIN_MAX_SELECT */

6949

{ /* there may be a select without a cond. */

6950

if (join->tables > 1)

6951

cond->update_used_tables(); // Tablenr may have changed

6952

if (join->const_tables == join->tables &&

6953

thd->lex->current_select->master_unit() ==

6954

&thd->lex->unit) // not upper level SELECT

6955

join->const_table_map|=RAND_TABLE_BIT;

6956

{ // Check const tables

6957

COND *const_cond=

6958

make_cond_for_table(cond,

6959

join->const_table_map,

6960

(table_map) 0, 1);

6961

for (JOIN_TAB *tab= join->join_tab+join->const_tables;

6962

tab < join->join_tab+join->tables ; tab++)

6963

{

6964

if (*tab->on_expr_ref)

6965

{

6966

JOIN_TAB *cond_tab= tab->first_inner;

6967

COND *tmp= make_cond_for_table(*tab->on_expr_ref,

6968

join->const_table_map,

6969

( table_map) 0, 0);

6970

if (!tmp)

6971

continue;

6972

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

6973

if (!tmp)

6974

return(1);

6975

tmp->quick_fix_field();

6976

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

6977

new Item_cond_and(cond_tab->select_cond,

6978

tmp);

6979

if (!cond_tab->select_cond)

6980

return(1);

6981

cond_tab->select_cond->quick_fix_field();

6982

}

6983

}

6984

if (const_cond && !const_cond->val_int())

6985

{

6986

return(1); // Impossible const condition

6987

}

6988

}

6989

}

6990

used_tables=((select->const_tables=join->const_table_map) |

6991

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

6992

for (uint i=join->const_tables ; i < join->tables ; i++)

6993

{

6994

JOIN_TAB *tab=join->join_tab+i;

6995

6996

first_inner is the X in queries like:

6997

SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X

6998

6999

JOIN_TAB *first_inner_tab= tab->first_inner;

7000

table_map current_map= tab->table->map;

7001

bool use_quick_range=0;

7002

COND *tmp;

7003

7004

7005

Following force including random expression in last table condition.

7006

It solve problem with select like SELECT * FROM t1 WHERE rand() > 0.5

7007

7008

if (i == join->tables-1)

7009

current_map|= OUTER_REF_TABLE_BIT | RAND_TABLE_BIT;

7010

used_tables|=current_map;

7011

7012

if (tab->type == JT_REF && tab->quick &&

7013

(uint) tab->ref.key == tab->quick->index &&

7014

tab->ref.key_length < tab->quick->max_used_key_length)

7015

{

7016

/* Range uses longer key; Use this instead of ref on key */

7017

tab->type=JT_ALL;

7018

use_quick_range=1;

7019

tab->use_quick=1;

7020

tab->ref.key= -1;

7021

tab->ref.key_parts=0; // Don't use ref key.

7022

join->best_positions[i].records_read= rows2double(tab->quick->records);

7023

7024

We will use join cache here : prevent sorting of the first

7025

table only and sort at the end.

7026

7027

if (i != join->const_tables && join->tables > join->const_tables + 1)

7028

join->full_join= 1;

7029

}

7030

7031

tmp= NULL;

7032

if (cond)

7033

tmp= make_cond_for_table(cond,used_tables,current_map, 0);

7034

if (cond && !tmp && tab->quick)

7035

{ // Outer join

7036

if (tab->type != JT_ALL)

7037

{

7038

7039

Don't use the quick method

7040

We come here in the case where we have 'key=constant' and

7041

the test is removed by make_cond_for_table()

7042

7043

delete tab->quick;

7044

tab->quick= 0;

7045

}

7046

else

7047

{

7048

7049

Hack to handle the case where we only refer to a table

7050

in the ON part of an OUTER JOIN. In this case we want the code

7051

below to check if we should use 'quick' instead.

7052

7053

tmp= new Item_int((int64_t) 1,1); // Always true

7054

}

7055

7056

}

7057

if (tmp || !cond || tab->type == JT_REF || tab->type == JT_REF_OR_NULL ||

7058

tab->type == JT_EQ_REF)

7059

{

7060

SQL_SELECT *sel= tab->select= ((SQL_SELECT*)

7061

thd->memdup((uchar*) select,

7062

sizeof(*select)));

7063

if (!sel)

7064

return(1); // End of memory

7065

7066

If tab is an inner table of an outer join operation,

7067

add a match guard to the pushed down predicate.

7068

The guard will turn the predicate on only after

7069

the first match for outer tables is encountered.

7070

7071

if (cond && tmp)

7072

{

7073

7074

Because of QUICK_GROUP_MIN_MAX_SELECT there may be a select without

7075

a cond, so neutralize the hack above.

7076

7077

if (!(tmp= add_found_match_trig_cond(first_inner_tab, tmp, 0)))

7078

return(1);

7079

tab->select_cond=sel->cond=tmp;

7080

/* Push condition to storage engine if this is enabled

7081

and the condition is not guarded */

7082

tab->table->file->pushed_cond= NULL;

7083

if (thd->variables.engine_condition_pushdown)

7084

{

7085

COND *push_cond=

7086

make_cond_for_table(tmp, current_map, current_map, 0);

7087

if (push_cond)

7088

{

7089

/* Push condition to handler */

7090

if (!tab->table->file->cond_push(push_cond))

7091

tab->table->file->pushed_cond= push_cond;

7092

}

7093

}

7094

}

7095

else

7096

tab->select_cond= sel->cond= NULL;

7097

7098

sel->head=tab->table;

7099

if (tab->quick)

7100

{

7101

/* Use quick key read if it's a constant and it's not used

7102

with key reading */

7103

if (tab->needed_reg.is_clear_all() && tab->type != JT_EQ_REF

7104

&& (tab->type != JT_REF || (uint) tab->ref.key == tab->quick->index))

7105

{

7106

sel->quick=tab->quick; // Use value from get_quick_...

7107

sel->quick_keys.clear_all();

7108

sel->needed_reg.clear_all();

7109

}

7110

else

7111

{

7112

delete tab->quick;

7113

}

7114

tab->quick=0;

7115

}

7116

uint ref_key=(uint) sel->head->reginfo.join_tab->ref.key+1;

7117

if (i == join->const_tables && ref_key)

7118

{

7119

if (!tab->const_keys.is_clear_all() &&

7120

tab->table->reginfo.impossible_range)

7121

return(1);

7122

}

7123

else if (tab->type == JT_ALL && ! use_quick_range)

7124

{

7125

if (!tab->const_keys.is_clear_all() &&

7126

tab->table->reginfo.impossible_range)

7127

return(1); // Impossible range

7128

7129

We plan to scan all rows.

7130

Check again if we should use an index.

7131

We could have used an column from a previous table in

7132

the index if we are using limit and this is the first table

7133

7134

7135

if ((cond && (!tab->keys.is_subset(tab->const_keys) && i > 0)) ||

7136

(!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)))

7137

{

7138

/* Join with outer join condition */

7139

COND *orig_cond=sel->cond;

7140

sel->cond= and_conds(sel->cond, *tab->on_expr_ref);

7141

7142

7143

We can't call sel->cond->fix_fields,

7144

as it will break tab->on_expr if it's AND condition

7145

(fix_fields currently removes extra AND/OR levels).

7146

Yet attributes of the just built condition are not needed.

7147

Thus we call sel->cond->quick_fix_field for safety.

7148

7149

if (sel->cond && !sel->cond->fixed)

7150

sel->cond->quick_fix_field();

7151

7152

if (sel->test_quick_select(thd, tab->keys,

7153

used_tables & ~ current_map,

7154

(join->select_options &

7155

OPTION_FOUND_ROWS ?

7156

HA_POS_ERROR :

7157

join->unit->select_limit_cnt), 0,

7158

false) < 0)

7159

{

7160

7161

Before reporting "Impossible WHERE" for the whole query

7162

we have to check isn't it only "impossible ON" instead

7163

7164

sel->cond=orig_cond;

7165

if (!*tab->on_expr_ref ||

7166

sel->test_quick_select(thd, tab->keys,

7167

used_tables & ~ current_map,

7168

(join->select_options &

7169

OPTION_FOUND_ROWS ?

7170

HA_POS_ERROR :

7171

join->unit->select_limit_cnt),0,

7172

false) < 0)

7173

return(1); // Impossible WHERE

7174

}

7175

else

7176

sel->cond=orig_cond;

7177

7178

/* Fix for EXPLAIN */

7179

if (sel->quick)

7180

join->best_positions[i].records_read= (double)sel->quick->records;

7181

}

7182

else

7183

{

7184

sel->needed_reg=tab->needed_reg;

7185

sel->quick_keys.clear_all();

7186

}

7187

if (!sel->quick_keys.is_subset(tab->checked_keys) ||

7188

!sel->needed_reg.is_subset(tab->checked_keys))

7189

{

7190

tab->keys=sel->quick_keys;

7191

tab->keys.merge(sel->needed_reg);

7192

tab->use_quick= (!sel->needed_reg.is_clear_all() &&

7193

(select->quick_keys.is_clear_all() ||

7194

(select->quick &&

7195

(select->quick->records >= 100L)))) ?

7196

2 : 1;

7197

sel->read_tables= used_tables & ~current_map;

7198

}

7199

if (i != join->const_tables && tab->use_quick != 2)

7200

{ /* Read with cache */

7201

if (cond &&

7202

(tmp=make_cond_for_table(cond,

7203

join->const_table_map |

7204

current_map,

7205

current_map, 0)))

7206

{

7207

tab->cache.select=(SQL_SELECT*)

7208

thd->memdup((uchar*) sel, sizeof(SQL_SELECT));

7209

tab->cache.select->cond=tmp;

7210

tab->cache.select->read_tables=join->const_table_map;

7211

}

7212

}

7213

}

7214

}

7215

7216

7217

Push down conditions from all on expressions.

7218

Each of these conditions are guarded by a variable

7219

that turns if off just before null complemented row for

7220

outer joins is formed. Thus, the condition from an

7221

'on expression' are guaranteed not to be checked for

7222

the null complemented row.

7223

7224

7225

/* First push down constant conditions from on expressions */

7226

for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;

7227

join_tab < join->join_tab+join->tables ; join_tab++)

7228

{

7229

if (*join_tab->on_expr_ref)

7230

{

7231

JOIN_TAB *cond_tab= join_tab->first_inner;

7232

COND *tmp= make_cond_for_table(*join_tab->on_expr_ref,

7233

join->const_table_map,

7234

(table_map) 0, 0);

7235

if (!tmp)

7236

continue;

7237

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

7238

if (!tmp)

7239

return(1);

7240

tmp->quick_fix_field();

7241

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

7242

new Item_cond_and(cond_tab->select_cond,tmp);

7243

if (!cond_tab->select_cond)

7244

return(1);

7245

cond_tab->select_cond->quick_fix_field();

7246

}

7247

}

7248

7249

/* Push down non-constant conditions from on expressions */

7250

JOIN_TAB *last_tab= tab;

7251

while (first_inner_tab && first_inner_tab->last_inner == last_tab)

7252

{

7253

7254

Table tab is the last inner table of an outer join.

7255

An on expression is always attached to it.

7256

7257

COND *on_expr= *first_inner_tab->on_expr_ref;

7258

7259

table_map used_tables2= (join->const_table_map |

7260

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

7261

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

7262

{

7263

current_map= tab->table->map;

7264

used_tables2|= current_map;

7265

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

7266

current_map, 0);

7267

if (tmp_cond)

7268

{

7269

JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

7270

7271

First add the guards for match variables of

7272

all embedding outer join operations.

7273

7274

if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,

7275

tmp_cond,

7276

first_inner_tab)))

7277

return(1);

7278

7279

Now add the guard turning the predicate off for

7280

the null complemented row.

7281

7282

tmp_cond= new Item_func_trig_cond(tmp_cond,

7283

&first_inner_tab->

7284

not_null_compl);

7285

if (tmp_cond)

7286

tmp_cond->quick_fix_field();

7287

/* Add the predicate to other pushed down predicates */

7288

cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :

7289

new Item_cond_and(cond_tab->select_cond,

7290

tmp_cond);

7291

if (!cond_tab->select_cond)

7292

return(1);

7293

cond_tab->select_cond->quick_fix_field();

7294

}

7295

}

7296

first_inner_tab= first_inner_tab->first_upper;

7297

}

7298

}

7299

}

7300

return(0);

7301

}

7302

7303

7304

1214

7305

1215

Check if given expression uses only table fields covered by the given index

7306

1216

7307

1217

SYNOPSIS

7314

1224

DESCRIPTION

7315

1225

Check if given expression only uses fields covered by index #keyno in the

7316

1226

table tbl. The expression can use any fields in any other tables.

7317

7318

The expression is guaranteed not to be AND or OR - those constructs are

1227

1228

The expression is guaranteed not to be AND or OR - those constructs are

7319

1229

handled outside of this function.

7320

1230

7321

1231

RETURN

7322

1232

true Yes

7323

1233

false No

7324

1234

7325

7326

bool uses_index_fields_only(Item *item, TABLE *tbl, uint keyno,

7327

bool other_tbls_ok)

1235

static bool uses_index_fields_only(Item *item, Table *tbl, uint32_t keyno, bool other_tbls_ok)

7328

1236

{

7329

1237

if (item->const_item())

7330

1238

return true;

7331

1239

7332

7333

Don't push down the triggered conditions. Nested outer joins execution

1240

1241

Don't push down the triggered conditions. Nested outer joins execution

7334

1242

code may need to evaluate a condition several times (both triggered and

7335

1243

untriggered), and there is no way to put thi

7336

1244

TODO: Consider cloning the triggered condition and using the copies for:

7337

1245

1. push the first copy down, to have most restrictive index condition

7338

1246

possible

7339

2. Put the second copy into tab->select_cond.

1247

2. Put the second copy into tab->select_cond.

7340

1248

7341

if (item->type() == Item::FUNC_ITEM &&

1249

if (item->type() == Item::FUNC_ITEM &&

7342

1250

((Item_func*)item)->functype() == Item_func::TRIG_COND_FUNC)

7343

1251

return false;

7344

1252

7364

1272

{

7365

1273

/* This is a function, apply condition recursively to arguments */

7366

1274

List_iterator<Item> li(*((Item_cond*)item)->argument_list());

7367

Item *item;

7368

while ((item=li++))

1275

Item *list_item;

1276

while ((list_item=li++))

7369

1277

{

7370

1278

if (!uses_index_fields_only(item, tbl, keyno, other_tbls_ok))

7371

1279

return false;

7375

1283

case Item::FIELD_ITEM:

7376

1284

{

7377

1285

Item_field *item_field= (Item_field*)item;

7378

if (item_field->field->table != tbl)

1286

if (item_field->field->table != tbl)

7379

1287

return true;

7380

return item_field->field->part_of_key.is_set(keyno);

1288

return item_field->field->part_of_key.test(keyno);

7381

1289

}

7382

1290

case Item::REF_ITEM:

7383

1291

return uses_index_fields_only(item->real_item(), tbl, keyno,

7387

1295

}

7388

1296

}

7389

1297

7390

7391

1298

#define ICP_COND_USES_INDEX_ONLY 10

7392

1299

7393

1300

7402

1309

other_tbls_ok true <=> Fields of other non-const tables are allowed

7403

1310

7404

1311

DESCRIPTION

7405

Get a part of the condition that can be checked when for the given table

1312

Get a part of the condition that can be checked when for the given table

7406

1313

we have values only of fields covered by some index. The condition may

7407

refer to other tables, it is assumed that we have values of all of their

1314

refer to other tables, it is assumed that we have values of all of their

7408

1315

fields.

7409

1316

7410

1317

Example:

7411

1318

make_cond_for_index(

7412

1319

"cond(t1.field) AND cond(t2.key1) AND cond(t2.non_key) AND cond(t2.key2)",

7413

t2, keyno(t2.key1))

1320

t2, keyno(t2.key1))

7414

1321

will return

7415

1322

"cond(t1.field) AND cond(t2.key2)"

7416

1323

7417

1324

RETURN

7418

1325

Index condition, or NULL if no condition could be inferred.

7419

1326

7420

7421

Item *make_cond_for_index(Item *cond, TABLE *table, uint keyno,

7422

bool other_tbls_ok)

1327

static Item *make_cond_for_index(Item *cond, Table *table, uint32_t keyno, bool other_tbls_ok)

7423

1328

{

7424

1329

if (!cond)

7425

1330

return NULL;

7426

1331

if (cond->type() == Item::COND_ITEM)

7427

1332

{

7428

uint n_marked= 0;

1333

uint32_t n_marked= 0;

7429

1334

if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

7430

1335

{

7431

1336

Item_cond_and *new_cond=new Item_cond_and;

7432

1337

if (!new_cond)

7433

return (COND*) 0;

1338

return (COND*) 0;

7434

1339

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7435

1340

Item *item;

7436

1341

while ((item=li++))

7437

1342

{

7438

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7439

if (fix)

7440

new_cond->argument_list()->push_back(fix);

1343

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

1344

if (fix)

1345

new_cond->argument_list()->push_back(fix);

7441

1346

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7442

1347

}

7443

1348

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7444

1349

cond->marker= ICP_COND_USES_INDEX_ONLY;

7445

1350

switch (new_cond->argument_list()->elements) {

7446

1351

case 0:

7447

return (COND*) 0;

1352

return (COND*) 0;

7448

1353

case 1:

7449

return new_cond->argument_list()->head();

1354

return new_cond->argument_list()->head();

7450

1355

default:

7451

new_cond->quick_fix_field();

7452

return new_cond;

1356

new_cond->quick_fix_field();

1357

return new_cond;

7453

1358

}

7454

1359

}

7455

1360

else /* It's OR */

7456

1361

{

7457

1362

Item_cond_or *new_cond=new Item_cond_or;

7458

1363

if (!new_cond)

7459

return (COND*) 0;

1364

return (COND*) 0;

7460

1365

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7461

1366

Item *item;

7462

1367

while ((item=li++))

7463

1368

{

7464

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

7465

if (!fix)

7466

return (COND*) 0;

7467

new_cond->argument_list()->push_back(fix);

1369

Item *fix= make_cond_for_index(item, table, keyno, other_tbls_ok);

1370

if (!fix)

1371

return (COND*) 0;

1372

new_cond->argument_list()->push_back(fix);

7468

1373

n_marked += test(item->marker == ICP_COND_USES_INDEX_ONLY);

7469

1374

}

7470

1375

if (n_marked ==((Item_cond*)cond)->argument_list()->elements)

7482

1387

}

7483

1388

7484

1389

7485

Item *make_cond_remainder(Item *cond, bool exclude_index)

1390

static Item *make_cond_remainder(Item *cond, bool exclude_index)

7486

1391

{

7487

1392

if (exclude_index && cond->marker == ICP_COND_USES_INDEX_ONLY)

7488

1393

return 0; /* Already checked */

7495

1400

/* Create new top level AND item */

7496

1401

Item_cond_and *new_cond=new Item_cond_and;

7497

1402

if (!new_cond)

7498

return (COND*) 0;

1403

return (COND*) 0;

7499

1404

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7500

1405

Item *item;

7501

1406

while ((item=li++))

7502

1407

{

7503

Item *fix= make_cond_remainder(item, exclude_index);

7504

if (fix)

1408

Item *fix= make_cond_remainder(item, exclude_index);

1409

if (fix)

7505

1410

{

7506

new_cond->argument_list()->push_back(fix);

1411

new_cond->argument_list()->push_back(fix);

7507

1412

tbl_map |= fix->used_tables();

7508

1413

}

7509

1414

}

7510

1415

switch (new_cond->argument_list()->elements) {

7511

1416

case 0:

7512

return (COND*) 0;

1417

return (COND*) 0;

7513

1418

case 1:

7514

return new_cond->argument_list()->head();

1419

return new_cond->argument_list()->head();

7515

1420

default:

7516

new_cond->quick_fix_field();

1421

new_cond->quick_fix_field();

7517

1422

((Item_cond*)new_cond)->used_tables_cache= tbl_map;

7518

return new_cond;

1423

return new_cond;

7519

1424

}

7520

1425

}

7521

1426

else /* It's OR */

7522

1427

{

7523

1428

Item_cond_or *new_cond=new Item_cond_or;

7524

1429

if (!new_cond)

7525

return (COND*) 0;

1430

return (COND*) 0;

7526

1431

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

7527

1432

Item *item;

7528

1433

while ((item=li++))

7529

1434

{

7530

Item *fix= make_cond_remainder(item, false);

7531

if (!fix)

7532

return (COND*) 0;

7533

new_cond->argument_list()->push_back(fix);

1435

Item *fix= make_cond_remainder(item, false);

1436

if (!fix)

1437

return (COND*) 0;

1438

new_cond->argument_list()->push_back(fix);

7534

1439

tbl_map |= fix->used_tables();

7535

1440

}

7536

1441

new_cond->quick_fix_field();

7542

1447

return cond;

7543

1448

}

7544

1449

7545

7546

7547

Try to extract and push the index condition

7548

7549

SYNOPSIS

7550

push_index_cond()

7551

tab A join tab that has tab->table->file and its condition

7552

in tab->select_cond

7553

keyno Index for which extract and push the condition

7554

other_tbls_ok true <=> Fields of other non-const tables are allowed

7555

7556

DESCRIPTION

7557

Try to extract and push the index condition down to table handler

7558

7559

7560

static void push_index_cond(JOIN_TAB *tab, uint keyno, bool other_tbls_ok)

7561

{

7562

Item *idx_cond;

7563

if (tab->table->file->index_flags(keyno, 0, 1) & HA_DO_INDEX_COND_PUSHDOWN &&

7564

tab->join->thd->variables.engine_condition_pushdown)

7565

{

7566

idx_cond= make_cond_for_index(tab->select_cond, tab->table, keyno,

7567

other_tbls_ok);

7568

7569

if (idx_cond)

7570

{

7571

tab->pre_idx_push_select_cond= tab->select_cond;

7572

Item *idx_remainder_cond=

7573

tab->table->file->idx_cond_push(keyno, idx_cond);

7574

7575

7576

Disable eq_ref's "lookup cache" if we've pushed down an index

7577

condition.

7578

TODO: This check happens to work on current ICP implementations, but

7579

there may exist a compliant implementation that will not work

7580

correctly with it. Sort this out when we stabilize the condition

7581

pushdown APIs.

7582

7583

if (idx_remainder_cond != idx_cond)

7584

tab->ref.disable_cache= true;

7585

7586

Item *row_cond= make_cond_remainder(tab->select_cond, true);

7587

7588

if (row_cond)

7589

{

7590

if (!idx_remainder_cond)

7591

tab->select_cond= row_cond;

7592

else

7593

{

7594

tab->select_cond= new Item_cond_and(row_cond, idx_remainder_cond);

7595

tab->select_cond->quick_fix_field();

7596

((Item_cond_and*)tab->select_cond)->used_tables_cache=

7597

row_cond->used_tables() | idx_remainder_cond->used_tables();

7598

}

7599

}

7600

else

7601

tab->select_cond= idx_remainder_cond;

7602

if (tab->select)

7603

{

7604

tab->select->cond= tab->select_cond;

7605

}

7606

}

7607

}

7608

return;

7609

}

7610

7611

7612

7613

7614

Determine if the set is already ordered for ORDER BY, so it can

7615

disable join cache because it will change the ordering of the results.

7616

Code handles sort table that is at any location (not only first after

7617

the const tables) despite the fact that it's currently prohibited.

7618

We must disable join cache if the first non-const table alone is

7619

ordered. If there is a temp table the ordering is done as a last

7620

operation and doesn't prevent join cache usage.

7621

7622

uint make_join_orderinfo(JOIN *join)

7623

{

7624

uint i;

7625

if (join->need_tmp)

7626

return join->tables;

7627

7628

for (i=join->const_tables ; i < join->tables ; i++)

7629

{

7630

JOIN_TAB *tab=join->join_tab+i;

7631

TABLE *table=tab->table;

7632

if ((table == join->sort_by_table &&

7633

(!join->order || join->skip_sort_order)) ||

7634

(join->sort_by_table == (TABLE *) 1 && i != join->const_tables))

7635

{

7636

break;

7637

}

7638

}

7639

return i;

7640

}

7641

7642

7643

7644

Plan refinement stage: do various set ups for the executioner

7645

7646

SYNOPSIS

7647

make_join_readinfo()

7648

join Join being processed

7649

options Join's options (checking for SELECT_DESCRIBE,

7650

SELECT_NO_JOIN_CACHE)

7651

no_jbuf_after Don't use join buffering after table with this number.

7652

7653

DESCRIPTION

7654

Plan refinement stage: do various set ups for the executioner

7655

- set up use of join buffering

7656

- push index conditions

7657

- increment counters

7658

- etc

7659

7660

RETURN

7661

false - OK

7662

true - Out of memory

7663

7664

7665

static bool

7666

make_join_readinfo(JOIN *join, uint64_t options, uint no_jbuf_after)

7667

{

7668

uint i;

7669

bool statistics= test(!(join->select_options & SELECT_DESCRIBE));

7670

bool sorted= 1;

7671

7672

for (i=join->const_tables ; i < join->tables ; i++)

7673

{

7674

JOIN_TAB *tab=join->join_tab+i;

7675

TABLE *table=tab->table;

7676

bool using_join_cache;

7677

tab->read_record.table= table;

7678

tab->read_record.file=table->file;

7679

tab->next_select=sub_select; /* normal select */

7680

7681

TODO: don't always instruct first table's ref/range access method to

7682

produce sorted output.

7683

7684

tab->sorted= sorted;

7685

sorted= 0; // only first must be sorted

7686

if (tab->insideout_match_tab)

7687

{

7688

if (!(tab->insideout_buf= (uchar*)join->thd->alloc(tab->table->key_info

7689

[tab->index].

7690

key_length)))

7691

return true;

7692

}

7693

switch (tab->type) {

7694

case JT_SYSTEM: // Only happens with left join

7695

table->status=STATUS_NO_RECORD;

7696

tab->read_first_record= join_read_system;

7697

tab->read_record.read_record= join_no_more_records;

7698

break;

7699

case JT_CONST: // Only happens with left join

7700

table->status=STATUS_NO_RECORD;

7701

tab->read_first_record= join_read_const;

7702

tab->read_record.read_record= join_no_more_records;

7703

if (table->covering_keys.is_set(tab->ref.key) &&

7704

!table->no_keyread)

7705

{

7706

table->key_read=1;

7707

table->file->extra(HA_EXTRA_KEYREAD);

7708

}

7709

break;

7710

case JT_EQ_REF:

7711

table->status=STATUS_NO_RECORD;

7712

if (tab->select)

7713

{

7714

delete tab->select->quick;

7715

tab->select->quick=0;

7716

}

7717

delete tab->quick;

7718

tab->quick=0;

7719

tab->read_first_record= join_read_key;

7720

tab->read_record.read_record= join_no_more_records;

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

break;

7730

case JT_REF_OR_NULL:

7731

case JT_REF:

7732

table->status=STATUS_NO_RECORD;

7733

if (tab->select)

7734

{

7735

delete tab->select->quick;

7736

tab->select->quick=0;

7737

}

7738

delete tab->quick;

7739

tab->quick=0;

7740

if (table->covering_keys.is_set(tab->ref.key) &&

7741

!table->no_keyread)

7742

{

7743

table->key_read=1;

7744

table->file->extra(HA_EXTRA_KEYREAD);

7745

}

7746

else

7747

push_index_cond(tab, tab->ref.key, true);

7748

if (tab->type == JT_REF)

7749

{

7750

tab->read_first_record= join_read_always_key;

7751

tab->read_record.read_record= tab->insideout_match_tab?

7752

join_read_next_same_diff : join_read_next_same;

7753

}

7754

else

7755

{

7756

tab->read_first_record= join_read_always_key_or_null;

7757

tab->read_record.read_record= join_read_next_same_or_null;

7758

}

7759

break;

7760

case JT_ALL:

7761

7762

If previous table use cache

7763

If the incoming data set is already sorted don't use cache.

7764

7765

table->status=STATUS_NO_RECORD;

7766

using_join_cache= false;

7767

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

7768

tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&

7769

!tab->insideout_match_tab)

7770

{

7771

if ((options & SELECT_DESCRIBE) ||

7772

!join_init_cache(join->thd,join->join_tab+join->const_tables,

7773

i-join->const_tables))

7774

{

7775

using_join_cache= true;

7776

tab[-1].next_select=sub_select_cache; /* Patch previous */

7777

}

7778

}

7779

/* These init changes read_record */

7780

if (tab->use_quick == 2)

7781

{

7782

join->thd->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

7783

tab->read_first_record= join_init_quick_read_record;

7784

if (statistics)

7785

status_var_increment(join->thd->status_var.select_range_check_count);

7786

}

7787

else

7788

{

7789

tab->read_first_record= join_init_read_record;

7790

if (i == join->const_tables)

7791

{

7792

if (tab->select && tab->select->quick)

7793

{

7794

if (statistics)

7795

status_var_increment(join->thd->status_var.select_range_count);

7796

}

7797

else

7798

{

7799

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7800

if (statistics)

7801

status_var_increment(join->thd->status_var.select_scan_count);

7802

}

7803

}

7804

else

7805

{

7806

if (tab->select && tab->select->quick)

7807

{

7808

if (statistics)

7809

status_var_increment(join->thd->status_var.select_full_range_join_count);

7810

}

7811

else

7812

{

7813

join->thd->server_status|=SERVER_QUERY_NO_INDEX_USED;

7814

if (statistics)

7815

status_var_increment(join->thd->status_var.select_full_join_count);

7816

}

7817

}

7818

if (!table->no_keyread)

7819

{

7820

if (tab->select && tab->select->quick &&

7821

tab->select->quick->index != MAX_KEY && //not index_merge

7822

table->covering_keys.is_set(tab->select->quick->index))

7823

{

7824

table->key_read=1;

7825

table->file->extra(HA_EXTRA_KEYREAD);

7826

}

7827

else if (!table->covering_keys.is_clear_all() &&

7828

!(tab->select && tab->select->quick))

7829

{ // Only read index tree

7830

if (!tab->insideout_match_tab)

7831

{

7832

7833

See bug #26447: "Using the clustered index for a table scan

7834

is always faster than using a secondary index".

7835

7836

if (table->s->primary_key != MAX_KEY &&

7837

table->file->primary_key_is_clustered())

7838

tab->index= table->s->primary_key;

7839

else

7840

tab->index=find_shortest_key(table, & table->covering_keys);

7841

}

7842

tab->read_first_record= join_read_first;

7843

tab->type=JT_NEXT; // Read with index_first / index_next

7844

}

7845

}

7846

if (tab->select && tab->select->quick &&

7847

tab->select->quick->index != MAX_KEY && ! tab->table->key_read)

7848

push_index_cond(tab, tab->select->quick->index, !using_join_cache);

7849

}

7850

break;

7851

default:

7852

break; /* purecov: deadcode */

7853

case JT_UNKNOWN:

7854

case JT_MAYBE_REF:

7855

abort(); /* purecov: deadcode */

7856

}

7857

}

7858

join->join_tab[join->tables-1].next_select=0; /* Set by do_select */

7859

return(false);

7860

}

7861

7862

7863

/**

7864

Give error if we some tables are done with a full join.

7865

7866

This is used by multi_table_update and multi_table_delete when running

7867

in safe mode.

7868

7869

@param join Join condition

7870

7871

@retval

7872

0 ok

7873

@retval

7874

1 Error (full join used)

7875

7876

7877

bool error_if_full_join(JOIN *join)

7878

{

7879

for (JOIN_TAB *tab=join->join_tab, *end=join->join_tab+join->tables;

7880

tab < end;

7881

tab++)

7882

{

7883

if (tab->type == JT_ALL && (!tab->select || !tab->select->quick))

7884

{

7885

my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,

7886

ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));

7887

return(1);

7888

}

7889

}

7890

return(0);

7891

}

7892

7893

7894

/**

7895

cleanup JOIN_TAB.

7896

7897

7898

void JOIN_TAB::cleanup()

1450

/**

1451

cleanup JoinTable.

1452

1453

void JoinTable::cleanup()

7899

1454

{

7900

1455

delete select;

7901

1456

select= 0;

7902

1457

delete quick;

7903

1458

quick= 0;

7904

x_free(cache.buff);

1459

if (cache.buff)

1460

free(cache.buff);

7905

1461

cache.buff= 0;

7906

1462

limit= 0;

7907

1463

if (table)

7909

1465

if (table->key_read)

7910

1466

{

7911

1467

table->key_read= 0;

7912

table->file->extra(HA_EXTRA_NO_KEYREAD);

1468

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

7913

1469

}

7914

table->file->ha_index_or_rnd_end();

1470

table->cursor->ha_index_or_rnd_end();

7915

1471

7916

1472

We need to reset this for next select

7917

1473

(Tested in part_of_refkey)

7921

1477

end_read_record(&read_record);

7922

1478

}

7923

1479

7924

7925

/**

7926

Partially cleanup JOIN after it has executed: close index or rnd read

7927

(table cursors), free quick selects.

7928

7929

This function is called in the end of execution of a JOIN, before the used

7930

tables are unlocked and closed.

7931

7932

For a join that is resolved using a temporary table, the first sweep is

7933

performed against actual tables and an intermediate result is inserted

7934

into the temprorary table.

7935

The last sweep is performed against the temporary table. Therefore,

7936

the base tables and associated buffers used to fill the temporary table

7937

are no longer needed, and this function is called to free them.

7938

7939

For a join that is performed without a temporary table, this function

7940

is called after all rows are sent, but before EOF packet is sent.

7941

7942

For a simple SELECT with no subqueries this function performs a full

7943

cleanup of the JOIN and calls mysql_unlock_read_tables to free used base

7944

tables.

7945

7946

If a JOIN is executed for a subquery or if it has a subquery, we can't

7947

do the full cleanup and need to do a partial cleanup only.

7948

- If a JOIN is not the top level join, we must not unlock the tables

7949

because the outer select may not have been evaluated yet, and we

7950

can't unlock only selected tables of a query.

7951

- Additionally, if this JOIN corresponds to a correlated subquery, we

7952

should not free quick selects and join buffers because they will be

7953

needed for the next execution of the correlated subquery.

7954

- However, if this is a JOIN for a [sub]select, which is not

7955

a correlated subquery itself, but has subqueries, we can free it

7956

fully and also free JOINs of all its subqueries. The exception

7957

is a subquery in SELECT list, e.g: @n

7958

SELECT a, (select max(b) from t1) group by c @n

7959

This subquery will not be evaluated at first sweep and its value will

7960

not be inserted into the temporary table. Instead, it's evaluated

7961

when selecting from the temporary table. Therefore, it can't be freed

7962

here even though it's not correlated.

7963

7964

@todo

7965

Unlock tables even if the join isn't top level select in the tree

7966

7967

7968

void JOIN::join_free()

7969

{

7970

SELECT_LEX_UNIT *tmp_unit;

7971

SELECT_LEX *sl;

7972

7973

Optimization: if not EXPLAIN and we are done with the JOIN,

7974

free all tables.

7975

7976

bool full= (!select_lex->uncacheable && !thd->lex->describe);

7977

bool can_unlock= full;

7978

7979

cleanup(full);

7980

7981

for (tmp_unit= select_lex->first_inner_unit();

7982

tmp_unit;

7983

tmp_unit= tmp_unit->next_unit())

7984

for (sl= tmp_unit->first_select(); sl; sl= sl->next_select())

7985

{

7986

Item_subselect *subselect= sl->master_unit()->item;

7987

bool full_local= full && (!subselect || subselect->is_evaluated());

7988

7989

If this join is evaluated, we can fully clean it up and clean up all

7990

its underlying joins even if they are correlated -- they will not be

7991

used any more anyway.

7992

If this join is not yet evaluated, we still must clean it up to

7993

close its table cursors -- it may never get evaluated, as in case of

7994

... HAVING false OR a IN (SELECT ...))

7995

but all table cursors must be closed before the unlock.

7996

7997

sl->cleanup_all_joins(full_local);

7998

/* Can't unlock if at least one JOIN is still needed */

7999

can_unlock= can_unlock && full_local;

8000

}

8001

8002

8003

We are not using tables anymore

8004

Unlock all tables. We may be in an INSERT .... SELECT statement.

8005

8006

if (can_unlock && lock && thd->lock &&

8007

!(select_options & SELECT_NO_UNLOCK) &&

8008

!select_lex->subquery_in_having &&

8009

(select_lex == (thd->lex->unit.fake_select_lex ?

8010

thd->lex->unit.fake_select_lex : &thd->lex->select_lex)))

8011

{

8012

8013

TODO: unlock tables even if the join isn't top level select in the

8014

tree.

8015

8016

mysql_unlock_read_tables(thd, lock); // Don't free join->lock

8017

lock= 0;

8018

}

8019

8020

return;

8021

}

8022

8023

8024

/**

8025

Free resources of given join.

8026

8027

@param fill true if we should free all resources, call with full==1

8028

should be last, before it this function can be called with

8029

full==0

8030

8031

@note

8032

With subquery this function definitely will be called several times,

8033

but even for simple query it can be called several times.

8034

8035

8036

void JOIN::cleanup(bool full)

8037

{

8038

if (table)

8039

{

8040

JOIN_TAB *tab,*end;

8041

8042

Only a sorted table may be cached. This sorted table is always the

8043

first non const table in join->table

8044

8045

if (tables > const_tables) // Test for not-const tables

8046

{

8047

free_io_cache(table[const_tables]);

8048

filesort_free_buffers(table[const_tables],full);

8049

}

8050

8051

if (full)

8052

{

8053

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8054

tab->cleanup();

8055

table= 0;

8056

}

8057

else

8058

{

8059

for (tab= join_tab, end= tab+tables; tab != end; tab++)

8060

{

8061

if (tab->table)

8062

tab->table->file->ha_index_or_rnd_end();

8063

}

8064

}

8065

cleanup_sj_tmp_tables(this);//

8066

}

8067

8068

We are not using tables anymore

8069

Unlock all tables. We may be in an INSERT .... SELECT statement.

8070

8071

if (full)

8072

{

8073

if (tmp_join)

8074

tmp_table_param.copy_field= 0;

8075

group_fields.delete_elements();

8076

8077

We can't call delete_elements() on copy_funcs as this will cause

8078

problems in free_elements() as some of the elements are then deleted.

8079

8080

tmp_table_param.copy_funcs.empty();

8081

8082

If we have tmp_join and 'this' JOIN is not tmp_join and

8083

tmp_table_param.copy_field's of them are equal then we have to remove

8084

pointer to tmp_table_param.copy_field from tmp_join, because it qill

8085

be removed in tmp_table_param.cleanup().

8086

8087

if (tmp_join &&

8088

tmp_join != this &&

8089

tmp_join->tmp_table_param.copy_field ==

8090

tmp_table_param.copy_field)

8091

{

8092

tmp_join->tmp_table_param.copy_field=

8093

tmp_join->tmp_table_param.save_copy_field= 0;

8094

}

8095

tmp_table_param.cleanup();

8096

}

8097

return;

8098

}

8099

8100

8101

/**

8102

Remove the following expressions from ORDER BY and GROUP BY:

1480

bool only_eq_ref_tables(JOIN *join,order_st *order,table_map tables)

1481

{

1482

for (JoinTable **tab=join->map2table ; tables ; tab++, tables>>=1)

1483

{

1484

if (tables & 1 && !eq_ref_table(join, order, *tab))

1485

return 0;

1486

}

1487

return 1;

1488

}

1489

1490

/**

1491

Remove the following expressions from order_st BY and GROUP BY:

8103

1492

Constant expressions @n

8104

1493

Expression that only uses tables that are of type EQ_REF and the reference

8105

is in the ORDER list or if all refereed tables are of the above type.

1494

is in the order_st list or if all refereed tables are of the above type.

8106

1495

8107

1496

In the following, the X field can be removed:

8108

1497

@code

8109

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t1.a,t2.X

8110

SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b ORDER BY t1.a,t3.X

1498

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t1.a,t2.X

1499

SELECT * FROM t1,t2,t3 WHERE t1.a=t2.a AND t2.b=t3.b order_st BY t1.a,t3.X

8111

1500

@endcode

8112

1501

8113

1502

These can't be optimized:

8114

1503

@code

8115

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.X,t1.a

8116

SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b ORDER BY t1.a,t2.c

8117

SELECT * FROM t1,t2 WHERE t1.a=t2.a ORDER BY t2.b,t1.a

1504

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.X,t1.a

1505

SELECT * FROM t1,t2 WHERE t1.a=t2.a AND t1.b=t2.b order_st BY t1.a,t2.c

1506

SELECT * FROM t1,t2 WHERE t1.a=t2.a order_st BY t2.b,t1.a

8118

1507

@endcode

8119

1508

8120

8121

static bool

8122

eq_ref_table(JOIN *join, ORDER *start_order, JOIN_TAB *tab)

1509

bool eq_ref_table(JOIN *join, order_st *start_order, JoinTable *tab)

8123

1510

{

8124

1511

if (tab->cached_eq_ref_table) // If cached

8125

1512

return tab->eq_ref_table;

8126

1513

tab->cached_eq_ref_table=1;

8127

1514

/* We can skip const tables only if not an outer table */

8128

if (tab->type == JT_CONST && !tab->first_inner)

8129

return (tab->eq_ref_table=1); /* purecov: inspected */

8130

if (tab->type != JT_EQ_REF || tab->table->maybe_null)

1515

if (tab->type == AM_CONST && !tab->first_inner)

1516

return (tab->eq_ref_table=1);

1517

if (tab->type != AM_EQ_REF || tab->table->maybe_null)

8131

1518

return (tab->eq_ref_table=0); // We must use this

8132

1519

Item **ref_item=tab->ref.items;

8133

1520

Item **end=ref_item+tab->ref.key_parts;

8134

uint found=0;

1521

uint32_t found=0;

8135

1522

table_map map=tab->table->map;

8136

1523

8137

1524

for (; ref_item != end ; ref_item++)

8138

1525

{

8139

1526

if (! (*ref_item)->const_item())

8140

1527

{ // Not a const ref

8141

ORDER *order;

1528

order_st *order;

8142

1529

for (order=start_order ; order ; order=order->next)

8143

1530

{

8144

if ((*ref_item)->eq(order->item[0],0))

8145

break;

1531

if ((*ref_item)->eq(order->item[0],0))

1532

break;

8146

1533

}

8147

1534

if (order)

8148

1535

{

8149

found++;

8150

assert(!(order->used & map));

8151

order->used|=map;

8152

continue; // Used in ORDER BY

1536

found++;

1537

assert(!(order->used & map));

1538

order->used|=map;

1539

continue; // Used in order_st BY

8153

1540

}

8154

1541

if (!only_eq_ref_tables(join,start_order, (*ref_item)->used_tables()))

8155

return (tab->eq_ref_table=0);

1542

return (tab->eq_ref_table= 0);

8156

1543

}

8157

1544

}

8158

1545

/* Check that there was no reference to table before sort order */

8164

1551

continue;

8165

1552

}

8166

1553

if (start_order->depend_map & map)

8167

return (tab->eq_ref_table=0);

8168

}

8169

return tab->eq_ref_table=1;

8170

}

8171

8172

8173

static bool

8174

only_eq_ref_tables(JOIN *join,ORDER *order,table_map tables)

8175

{

8176

if (specialflag & SPECIAL_SAFE_MODE)

8177

return 0; // skip this optimize /* purecov: inspected */

8178

for (JOIN_TAB **tab=join->map2table ; tables ; tab++, tables>>=1)

8179

{

8180

if (tables & 1 && !eq_ref_table(join, order, *tab))

8181

return 0;

8182

}

8183

return 1;

8184

}

8185

8186

8187

/** Update the dependency map for the tables. */

8188

8189

static void update_depend_map(JOIN *join)

8190

{

8191

JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;

8192

8193

for (; join_tab != end ; join_tab++)

8194

{

8195

TABLE_REF *ref= &join_tab->ref;

8196

table_map depend_map=0;

8197

Item **item=ref->items;

8198

uint i;

8199

for (i=0 ; i < ref->key_parts ; i++,item++)

8200

depend_map|=(*item)->used_tables();

8201

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

8202

depend_map&= ~OUTER_REF_TABLE_BIT;

8203

for (JOIN_TAB **tab=join->map2table;

8204

depend_map ;

8205

tab++,depend_map>>=1 )

8206

{

8207

if (depend_map & 1)

8208

ref->depend_map|=(*tab)->ref.depend_map;

8209

}

8210

}

8211

}

8212

8213

8214

/** Update the dependency map for the sort order. */

8215

8216

static void update_depend_map(JOIN *join, ORDER *order)

8217

{

8218

for (; order ; order=order->next)

8219

{

8220

table_map depend_map;

8221

order->item[0]->update_used_tables();

8222

order->depend_map=depend_map=order->item[0]->used_tables();

8223

// Not item_sum(), RAND() and no reference to table outside of sub select

8224

if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))

8225

&& !order->item[0]->with_sum_func)

8226

{

8227

for (JOIN_TAB **tab=join->map2table;

8228

depend_map ;

8229

tab++, depend_map>>=1)

8230

{

8231

if (depend_map & 1)

8232

order->depend_map|=(*tab)->ref.depend_map;

8233

}

8234

}

8235

}

8236

}

8237

8238

8239

/**

8240

Remove all constants and check if ORDER only contains simple

8241

expressions.

8242

8243

simple_order is set to 1 if sort_order only uses fields from head table

8244

and the head table is not a LEFT JOIN table.

8245

8246

@param join Join handler

8247

@param first_order List of SORT or GROUP order

8248

@param cond WHERE statement

8249

@param change_list Set to 1 if we should remove things from list.

8250

If this is not set, then only simple_order is

8251

calculated.

8252

@param simple_order Set to 1 if we are only using simple expressions

8253

8254

@return

8255

Returns new sort order

8256

8257

8258

static ORDER *

8259

remove_const(JOIN *join,ORDER *first_order, COND *cond,

8260

bool change_list, bool *simple_order)

8261

{

8262

if (join->tables == join->const_tables)

8263

return change_list ? 0 : first_order; // No need to sort

8264

8265

ORDER *order,**prev_ptr;

8266

table_map first_table= join->join_tab[join->const_tables].table->map;

8267

table_map not_const_tables= ~join->const_table_map;

8268

table_map ref;

8269

8270

prev_ptr= &first_order;

8271

*simple_order= *join->join_tab[join->const_tables].on_expr_ref ? 0 : 1;

8272

8273

/* NOTE: A variable of not_const_tables ^ first_table; breaks gcc 2.7 */

8274

8275

update_depend_map(join, first_order);

8276

for (order=first_order; order ; order=order->next)

8277

{

8278

table_map order_tables=order->item[0]->used_tables();

8279

if (order->item[0]->with_sum_func)

8280

*simple_order=0; // Must do a temp table to sort

8281

else if (!(order_tables & not_const_tables))

8282

{

8283

if (order->item[0]->with_subselect)

8284

order->item[0]->val_str(&order->item[0]->str_value);

8285

continue; // skip const item

8286

}

8287

else

8288

{

8289

if (order_tables & (RAND_TABLE_BIT | OUTER_REF_TABLE_BIT))

8290

*simple_order=0;

8291

else

8292

{

8293

Item *comp_item=0;

8294

if (cond && const_expression_in_where(cond,order->item[0], &comp_item))

8295

{

8296

continue;

8297

}

8298

if ((ref=order_tables & (not_const_tables ^ first_table)))

8299

{

8300

if (!(order_tables & first_table) &&

8301

only_eq_ref_tables(join,first_order, ref))

8302

{

8303

continue;

8304

}

8305

*simple_order=0; // Must do a temp table to sort

8306

}

8307

}

8308

}

8309

if (change_list)

8310

*prev_ptr= order; // use this entry

8311

prev_ptr= &order->next;

8312

}

8313

if (change_list)

8314

*prev_ptr=0;

8315

if (prev_ptr == &first_order) // Nothing to sort/group

8316

*simple_order=1;

8317

return(first_order);

8318

}

8319

8320

8321

static int

8322

return_zero_rows(JOIN *join, select_result *result,TABLE_LIST *tables,

8323

List<Item> &fields, bool send_row, uint64_t select_options,

8324

const char *info, Item *having)

8325

{

8326

if (select_options & SELECT_DESCRIBE)

8327

{

8328

select_describe(join, false, false, false, info);

8329

return(0);

8330

}

8331

8332

join->join_free();

8333

8334

if (send_row)

8335

{

8336

for (TABLE_LIST *table= tables; table; table= table->next_leaf)

8337

mark_as_null_row(table->table); // All fields are NULL

8338

if (having && having->val_int() == 0)

8339

send_row=0;

8340

}

8341

if (!(result->send_fields(fields,

8342

Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))

8343

{

8344

if (send_row)

8345

{

8346

List_iterator_fast<Item> it(fields);

8347

Item *item;

8348

while ((item= it++))

8349

item->no_rows_in_result();

8350

result->send_data(fields);

8351

}

8352

result->send_eof(); // Should be safe

8353

}

8354

/* Update results for FOUND_ROWS */

8355

join->thd->limit_found_rows= join->thd->examined_row_count= 0;

8356

return(0);

8357

}

8358

8359

8360

used only in JOIN::clear

8361

8362

static void clear_tables(JOIN *join)

8363

{

8364

8365

must clear only the non-const tables, as const tables

8366

are not re-calculated.

8367

8368

for (uint i=join->const_tables ; i < join->tables ; i++)

8369

mark_as_null_row(join->table[i]); // All fields are NULL

8370

}

8371

8372

/*****************************************************************************

8373

Make som simple condition optimization:

8374

If there is a test 'field = const' change all refs to 'field' to 'const'

8375

Remove all dummy tests 'item = item', 'const op const'.

8376

Remove all 'item is NULL', when item can never be null!

8377

item->marker should be 0 for all items on entry

8378

Return in cond_value false if condition is impossible (1 = 2)

8379

*****************************************************************************/

8380

8381

class COND_CMP :public ilink {

8382

public:

8383

static void *operator new(size_t size)

8384

{

8385

return (void*) sql_alloc((uint) size);

8386

}

8387

static void operator delete(void *ptr __attribute__((unused)),

8388

size_t size __attribute__((unused)))

8389

{ TRASH(ptr, size); }

8390

8391

Item *and_level;

8392

Item_func *cmp_func;

8393

COND_CMP(Item *a,Item_func *b) :and_level(a),cmp_func(b) {}

8394

};

8395

8396

#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION

8397

template class I_List<COND_CMP>;

8398

template class I_List_iterator<COND_CMP>;

8399

#endif

8400

1554

return (tab->eq_ref_table= 0);

1555

}

1556

return tab->eq_ref_table= 1;

1557

}

8401

1558

8402

1559

/**

8403

1560

Find the multiple equality predicate containing a field.

8417

1574

- Item_equal for the found multiple equality predicate if a success;

8418

1575

- NULL otherwise.

8419

1576

8420

8421

Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field,

8422

bool *inherited_fl)

1577

static Item_equal *find_item_equal(COND_EQUAL *cond_equal, Field *field, bool *inherited_fl)

8423

1578

{

8424

1579

Item_equal *item= 0;

8425

1580

bool in_upper_level= false;

8440

1595

return item;

8441

1596

}

8442

1597

8443

8444

1598

/**

8445

1599

Check whether an equality can be used to build multiple equalities.

8446

1600

8467

1621

the check_equality will be called for the following equality

8468

1622

predicates a=b, b=c, b=2 and f=e.

8469

1623

- For a=b it will be called with *cond_equal=(0,[]) and will transform

8470

*cond_equal into (0,[Item_equal(a,b)]).

1624

*cond_equal into (0,[Item_equal(a,b)]).

8471

1625

- For b=c it will be called with *cond_equal=(0,[Item_equal(a,b)])

8472

1626

and will transform *cond_equal into CE=(0,[Item_equal(a,b,c)]).

8473

1627

- For b=2 it will be called with *cond_equal=(ptr(CE),[])

8480

1634

the Field::eq_def method) are placed to the same multiple equalities.

8481

1635

Because of this some equality predicates are not eliminated and

8482

1636

can be used in the constant propagation procedure.

8483

We could weeken the equlity test as soon as at least one of the

8484

equal fields is to be equal to a constant. It would require a

1637

We could weeken the equlity test as soon as at least one of the

1638

equal fields is to be equal to a constant. It would require a

8485

1639

more complicated implementation: we would have to store, in

8486

1640

general case, its own constant for each fields from the multiple

8487

1641

equality. But at the same time it would allow us to get rid

8499

1653

containing just field1 and field2 is added to the existing

8500

1654

multiple equalities.

8501

1655

If the function processes the predicate of the form field1=const,

8502

it looks for a multiple equality containing field1. If found, the

1656

it looks for a multiple equality containing field1. If found, the

8503

1657

function checks the constant of the multiple equality. If the value

8504

1658

is unknown, it is setup to const. Otherwise the value is compared with

8505

1659

const and the evaluation of the equality predicate is performed.

8522

1676

@retval

8523

1677

false otherwise

8524

1678

8525

8526

static bool check_simple_equality(Item *left_item, Item *right_item,

8527

Item *item, COND_EQUAL *cond_equal)

1679

static bool check_simple_equality(Item *left_item,

1680

Item *right_item,

1681

Item *item,

1682

COND_EQUAL *cond_equal)

8528

1683

{

8529

if (left_item->type() == Item::REF_ITEM &&

8530

((Item_ref*)left_item)->ref_type() == Item_ref::VIEW_REF)

8531

{

8532

if (((Item_ref*)left_item)->depended_from)

8533

return false;

8534

left_item= left_item->real_item();

8535

}

8536

if (right_item->type() == Item::REF_ITEM &&

8537

((Item_ref*)right_item)->ref_type() == Item_ref::VIEW_REF)

8538

{

8539

if (((Item_ref*)right_item)->depended_from)

8540

return false;

8541

right_item= right_item->real_item();

8542

}

8543

1684

if (left_item->type() == Item::FIELD_ITEM &&

8544

1685

right_item->type() == Item::FIELD_ITEM &&

8545

1686

!((Item_field*)left_item)->depended_from &&

8557

1698

bool left_copyfl, right_copyfl;

8558

1699

Item_equal *left_item_equal=

8559

1700

find_item_equal(cond_equal, left_field, &left_copyfl);

8560

Item_equal *right_item_equal=

1701

Item_equal *right_item_equal=

8561

1702

find_item_equal(cond_equal, right_field, &right_copyfl);

8562

1703

8563

1704

/* As (NULL=NULL) != true we can't just remove the predicate f=f */

8564

1705

if (left_field->eq(right_field)) /* f = f */

8565

return (!(left_field->maybe_null() && !left_item_equal));

1706

return (!(left_field->maybe_null() && !left_item_equal));

8566

1707

8567

1708

if (left_item_equal && left_item_equal == right_item_equal)

8568

1709

{

8569

1710

8570

1711

The equality predicate is inference of one of the existing

8571

1712

multiple equalities, i.e the condition is already covered

8572

1713

by upper level equalities

8573

1714

8574

1715

return true;

8575

1716

}

8576

8577

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

1717

1718

bool copy_item_name= test(item && item->name >= subq_sj_cond_name &&

8578

1719

item->name < subq_sj_cond_name + 64);

8579

1720

/* Copy the found multiple equalities at the current level if needed */

8580

1721

if (left_copyfl)

8595

1736

}

8596

1737

8597

1738

if (left_item_equal)

8598

{

1739

{

8599

1740

/* left item was found in the current or one of the upper levels */

8600

1741

if (! right_item_equal)

8601

1742

left_item_equal->add((Item_field *) right_item);

8610

1751

}

8611

1752

}

8612

1753

else

8613

{

1754

{

8614

1755

/* left item was not found neither the current nor in upper levels */

8615

1756

if (right_item_equal)

8616

1757

{

8618

1759

if (copy_item_name)

8619

1760

right_item_equal->name = item->name;

8620

1761

}

8621

else

1762

else

8622

1763

{

8623

1764

/* None of the fields was found in multiple equalities */

8624

1765

Item_equal *item_equal= new Item_equal((Item_field *) left_item,

8666

1807

eq_item->set_cmp_func();

8667

1808

eq_item->quick_fix_field();

8668

1809

item= eq_item;

8669

}

1810

}

8670

1811

if ((cs != ((Item_func *) item)->compare_collation()) ||

8671

1812

!cs->coll->propagate(cs, 0, 0))

8672

1813

return false;

8681

1822

}

8682

1823

if (item_equal)

8683

1824

{

8684

1825

8685

1826

The flag cond_false will be set to 1 after this, if item_equal

8686

1827

already contains a constant and its value is not equal to

8687

1828

the value of const_item.

8699

1840

return false;

8700

1841

}

8701

1842

8702

8703

1843

/**

8704

1844

Convert row equalities into a conjunction of regular equalities.

8705

1845

8712

1852

simple equality nor a row equality the item for this predicate is added

8713

1853

to eq_list.

8714

1854

8715

@param thd thread handle

1855

@param session thread handle

8716

1856

@param left_row left term of the row equality to be processed

8717

1857

@param right_row right term of the row equality to be processed

8718

1858

@param cond_equal multiple equalities that must hold together with the

8725

1865

@retval

8726

1866

false otherwise

8727

1867

8728

8729

static bool check_row_equality(THD *thd, Item *left_row, Item_row *right_row,

8730

COND_EQUAL *cond_equal, List<Item>* eq_list)

8731

{

8732

uint n= left_row->cols();

8733

for (uint i= 0 ; i < n; i++)

1868

static bool check_row_equality(Session *session,

1869

Item *left_row,

1870

Item_row *right_row,

1871

COND_EQUAL *cond_equal,

1872

List<Item>* eq_list)

1873

{

1874

uint32_t n= left_row->cols();

1875

for (uint32_t i= 0 ; i < n; i++)

8734

1876

{

8735

1877

bool is_converted;

8736

1878

Item *left_item= left_row->element_index(i);

8738

1880

if (left_item->type() == Item::ROW_ITEM &&

8739

1881

right_item->type() == Item::ROW_ITEM)

8740

1882

{

8741

is_converted= check_row_equality(thd,

1883

is_converted= check_row_equality(session,

8742

1884

(Item_row *) left_item,

8743

1885

(Item_row *) right_item,

8744

1886

cond_equal, eq_list);

8745

1887

if (!is_converted)

8746

thd->lex->current_select->cond_count++;

1888

session->lex->current_select->cond_count++;

8747

1889

}

8748

1890

else

8749

{

1891

{

8750

1892

is_converted= check_simple_equality(left_item, right_item, 0, cond_equal);

8751

thd->lex->current_select->cond_count++;

8752

}

8753

1893

session->lex->current_select->cond_count++;

1894

}

1895

8754

1896

if (!is_converted)

8755

1897

{

8756

1898

Item_func_eq *eq_item;

8764

1906

return true;

8765

1907

}

8766

1908

8767

8768

1909

/**

8769

1910

Eliminate row equalities and form multiple equalities predicates.

8770

1911

8779

1920

equalities which are treated in the same way as original equality

8780

1921

predicates.

8781

1922

8782

@param thd thread handle

1923

@param session thread handle

8783

1924

@param item predicate to process

8784

1925

@param cond_equal multiple equalities that must hold together with the

8785

1926

predicate

8794

1935

or, if the equality is neither a simple one nor a row equality,

8795

1936

or, if the procedure fails by a fatal error.

8796

1937

8797

8798

static bool check_equality(THD *thd, Item *item, COND_EQUAL *cond_equal,

8799

List<Item> *eq_list)

1938

static bool check_equality(Session *session, Item *item, COND_EQUAL *cond_equal, List<Item> *eq_list)

8800

1939

{

8801

1940

if (item->type() == Item::FUNC_ITEM &&

8802

1941

((Item_func*) item)->functype() == Item_func::EQ_FUNC)

8807

1946

if (left_item->type() == Item::ROW_ITEM &&

8808

1947

right_item->type() == Item::ROW_ITEM)

8809

1948

{

8810

thd->lex->current_select->cond_count--;

8811

return check_row_equality(thd,

1949

session->lex->current_select->cond_count--;

1950

return check_row_equality(session,

8812

1951

(Item_row *) left_item,

8813

1952

(Item_row *) right_item,

8814

1953

cond_equal, eq_list);

8815

1954

}

8816

else

1955

else

8817

1956

return check_simple_equality(left_item, right_item, item, cond_equal);

8818

}

1957

}

8819

1958

return false;

8820

1959

}

8821

1960

8822

8823

1961

/**

8824

1962

Replace all equality predicates in a condition by multiple equality items.

8825

1963

8826

1964

At each 'and' level the function detects items for equality predicates

8827

1965

and replaced them by a set of multiple equality items of class Item_equal,

8828

taking into account inherited equalities from upper levels.

1966

taking into account inherited equalities from upper levels.

8829

1967

If an equality predicate is used not in a conjunction it's just

8830

1968

replaced by a multiple equality predicate.

8831

1969

For each 'and' level the function set a pointer to the inherited

8832

1970

multiple equalities in the cond_equal field of the associated

8833

object of the type Item_cond_and.

1971

object of the type Item_cond_and.

8834

1972

The function also traverses the cond tree and and for each field reference

8835

1973

sets a pointer to the multiple equality item containing the field, if there

8836

1974

is any. If this multiple equality equates fields to a constant the

8837

function replaces the field reference by the constant in the cases

1975

function replaces the field reference by the constant in the cases

8838

1976

when the field is not of a string type or when the field reference is

8839

1977

just an argument of a comparison predicate.

8840

The function also determines the maximum number of members in

1978

The function also determines the maximum number of members in

8841

1979

equality lists of each Item_cond_and object assigning it to

8842

thd->lex->current_select->max_equal_elems.

1980

session->lex->current_select->max_equal_elems.

8843

1981

8844

1982

@note

8845

1983

Multiple equality predicate =(f1,..fn) is equivalent to the conjuction of

8851

1989

in a conjuction for a minimal set of multiple equality predicates.

8852

1990

This set can be considered as a canonical representation of the

8853

1991

sub-conjunction of the equality predicates.

8854

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

1992

E.g. (t1.a=t2.b AND t2.b>5 AND t1.a=t3.c) is replaced by

8855

1993

(=(t1.a,t2.b,t3.c) AND t2.b>5), not by

8856

1994

(=(t1.a,t2.b) AND =(t1.a,t3.c) AND t2.b>5);

8857

1995

while (t1.a=t2.b AND t2.b>5 AND t3.c=t4.d) is replaced by

8862

2000

The function performs the substitution in a recursive descent by

8863

2001

the condtion tree, passing to the next AND level a chain of multiple

8864

2002

equality predicates which have been built at the upper levels.

8865

The Item_equal items built at the level are attached to other

2003

The Item_equal items built at the level are attached to other

8866

2004

non-equality conjucts as a sublist. The pointer to the inherited

8867

2005

multiple equalities is saved in the and condition object (Item_cond_and).

8868

This chain allows us for any field reference occurence easyly to find a

2006

This chain allows us for any field reference occurence easyly to find a

8869

2007

multiple equality that must be held for this occurence.

8870

2008

For each AND level we do the following:

8871

2009

- scan it for all equality predicate (=) items

8872

2010

- join them into disjoint Item_equal() groups

8873

- process the included OR conditions recursively to do the same for

8874

lower AND levels.

2011

- process the included OR conditions recursively to do the same for

2012

lower AND levels.

8875

2013

8876

2014

We need to do things in this order as lower AND levels need to know about

8877

2015

all possible Item_equal objects in upper levels.

8878

2016

8879

@param thd thread handle

2017

@param session thread handle

8880

2018

@param cond condition(expression) where to make replacement

8881

2019

@param inherited path to all inherited multiple equality items

8882

2020

8883

2021

@return

8884

2022

pointer to the transformed condition

8885

2023

8886

8887

static COND *build_equal_items_for_cond(THD *thd, COND *cond,

8888

COND_EQUAL *inherited)

2024

static COND *build_equal_items_for_cond(Session *session, COND *cond, COND_EQUAL *inherited)

8889

2025

{

8890

2026

Item_equal *item_equal;

8891

2027

COND_EQUAL cond_equal;

8897

2033

bool and_level= ((Item_cond*) cond)->functype() ==

8898

2034

Item_func::COND_AND_FUNC;

8899

2035

List<Item> *args= ((Item_cond*) cond)->argument_list();

8900

2036

8901

2037

List_iterator<Item> li(*args);

8902

2038

Item *item;

8903

2039

8906

2042

8907

2043

Retrieve all conjucts of this level detecting the equality

8908

2044

that are subject to substitution by multiple equality items and

8909

removing each such predicate from the conjunction after having

2045

removing each such predicate from the conjunction after having

8910

2046

found/created a multiple equality whose inference the predicate is.

8911

2047

8912

2048

while ((item= li++))

8913

2049

{

8914

2050

8916

2052

structure here because it's restored before each

8917

2053

re-execution of any prepared statement/stored procedure.

8918

2054

8919

if (check_equality(thd, item, &cond_equal, &eq_list))

2055

if (check_equality(session, item, &cond_equal, &eq_list))

8920

2056

li.remove();

8921

2057

}

8922

2058

8925

2061

{

8926

2062

item_equal->fix_length_and_dec();

8927

2063

item_equal->update_used_tables();

8928

set_if_bigger(thd->lex->current_select->max_equal_elems,

8929

item_equal->members());

2064

set_if_bigger(session->lex->current_select->max_equal_elems,

2065

item_equal->members());

8930

2066

}

8931

2067

8932

2068

((Item_cond_and*)cond)->cond_equal= cond_equal;

8938

2074

8939

2075

li.rewind();

8940

2076

while ((item= li++))

8941

{

2077

{

8942

2078

Item *new_item;

8943

if ((new_item= build_equal_items_for_cond(thd, item, inherited)) != item)

2079

if ((new_item= build_equal_items_for_cond(session, item, inherited)) != item)

8944

2080

{

8945

2081

/* This replacement happens only for standalone equalities */

8946

2082

8968

2104

(b=5) and (a=c) are standalone equalities.

8969

2105

In general we can't leave alone standalone eqalities:

8970

2106

for WHERE a=b AND c=d AND (b=c OR d=5)

8971

b=c is replaced by =(a,b,c,d).

2107

b=c is replaced by =(a,b,c,d).

8972

2108

8973

if (check_equality(thd, cond, &cond_equal, &eq_list))

2109

if (check_equality(session, cond, &cond_equal, &eq_list))

8974

2110

{

8975

2111

int n= cond_equal.current_level.elements + eq_list.elements;

8976

2112

if (n == 0)

8981

2117

{

8982

2118

item_equal->fix_length_and_dec();

8983

2119

item_equal->update_used_tables();

8984

}

2120

}

8985

2121

else

8986

2122

item_equal= (Item_equal *) eq_list.pop();

8987

set_if_bigger(thd->lex->current_select->max_equal_elems,

8988

item_equal->members());

2123

set_if_bigger(session->lex->current_select->max_equal_elems,

2124

item_equal->members());

8989

2125

return item_equal;

8990

2126

}

8991

2127

else

8992

2128

{

8993

2129

8994

2130

Here a new AND level must be created. It can happen only

8995

2131

when a row equality is processed as a standalone predicate.

8996

2132

8997

2133

Item_cond_and *and_cond= new Item_cond_and(eq_list);

8998

2134

and_cond->quick_fix_field();

8999

2135

List<Item> *args= and_cond->argument_list();

9002

2138

{

9003

2139

item_equal->fix_length_and_dec();

9004

2140

item_equal->update_used_tables();

9005

set_if_bigger(thd->lex->current_select->max_equal_elems,

9006

item_equal->members());

2141

set_if_bigger(session->lex->current_select->max_equal_elems,

2142

item_equal->members());

9007

2143

}

9008

2144

and_cond->cond_equal= cond_equal;

9009

2145

args->concat((List<Item> *)&cond_equal.current_level);

9010

2146

9011

2147

return and_cond;

9012

2148

}

9013

2149

}

9014

2150

9015

2151

For each field reference in cond, not from equal item predicates,

9016

2152

set a pointer to the multiple equality it belongs to (if there is any)

9017

2153

as soon the field is not of a string type or the field reference is

9018

an argument of a comparison predicate.

9019

9020

uchar *is_subst_valid= (uchar *) 1;

2154

an argument of a comparison predicate.

2155

2156

unsigned char *is_subst_valid= (unsigned char *) 1;

9021

2157

cond= cond->compile(&Item::subst_argument_checker,

9022

&is_subst_valid,

2158

&is_subst_valid,

9023

2159

&Item::equal_fields_propagator,

9024

(uchar *) inherited);

2160

(unsigned char *) inherited);

9025

2161

cond->update_used_tables();

9026

2162

}

9027

2163

return cond;

9028

2164

}

9029

2165

9030

9031

2166

/**

9032

2167

Build multiple equalities for a condition and all on expressions that

9033

2168

inherit these multiple equalities.

9073

2208

SELECT * FROM (t1,t2) LEFT JOIN (t3,t4) ON t2.a=t4.a AND t3.a=t4.a

9074

2209

WHERE t1.a=t2.a

9075

2210

@endcode

9076

that is equivalent to:

2211

that is equivalent to:

9077

2212

@code

9078

2213

SELECT * FROM (t2 LEFT JOIN (t3,t4)ON t2.a=t4.a AND t3.a=t4.a), t1

9079

2214

WHERE t1.a=t2.a

9080

2215

@endcode

9081

2216

Thus, applying equalities from the where condition we basically

9082

2217

can get more freedom in performing join operations.

9083

Althogh we don't use this property now, it probably makes sense to use

9084

it in the future.

9085

@param thd Thread handler

2218

Althogh we don't use this property now, it probably makes sense to use

2219

it in the future.

2220

@param session Thread Cursor

9086

2221

@param cond condition to build the multiple equalities for

9087

2222

@param inherited path to all inherited multiple equality items

9088

2223

@param join_list list of join tables to which the condition

9093

2228

@return

9094

2229

pointer to the transformed condition containing multiple equalities

9095

2230

9096

9097

static COND *build_equal_items(THD *thd, COND *cond,

2231

static COND *build_equal_items(Session *session, COND *cond,

9098

2232

COND_EQUAL *inherited,

9099

List<TABLE_LIST> *join_list,

2233

List<TableList> *join_list,

9100

2234

COND_EQUAL **cond_equal_ref)

9101

2235

{

9102

2236

COND_EQUAL *cond_equal= 0;

9103

2237

9104

if (cond)

2238

if (cond)

9105

2239

{

9106

cond= build_equal_items_for_cond(thd, cond, inherited);

2240

cond= build_equal_items_for_cond(session, cond, inherited);

9107

2241

cond->update_used_tables();

9108

2242

if (cond->type() == Item::COND_ITEM &&

9109

2243

((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)

9124

2258

9125

2259

if (join_list)

9126

2260

{

9127

TABLE_LIST *table;

9128

List_iterator<TABLE_LIST> li(*join_list);

2261

TableList *table;

2262

List_iterator<TableList> li(*join_list);

9129

2263

9130

2264

while ((table= li++))

9131

2265

{

9132

2266

if (table->on_expr)

9133

2267

{

9134

List<TABLE_LIST> *nested_join_list= table->nested_join ?

2268

List<TableList> *nested_join_list= table->nested_join ?

9135

2269

&table->nested_join->join_list : NULL;

9136

2270

9137

2271

We can modify table->on_expr because its old value will

9138

2272

be restored before re-execution of PS/SP.

9139

2273

9140

table->on_expr= build_equal_items(thd, table->on_expr, inherited,

2274

table->on_expr= build_equal_items(session, table->on_expr, inherited,

9141

2275

nested_join_list,

9142

2276

&table->cond_equal);

9143

2277

}

9145

2279

}

9146

2280

9147

2281

return cond;

9148

}

9149

2282

}

9150

2283

9151

2284

/**

9152

2285

Compare field items by table order in the execution plan.

9153

2286

9154

2287

field1 considered as better than field2 if the table containing

9155

field1 is accessed earlier than the table containing field2.

2288

field1 is accessed earlier than the table containing field2.

9156

2289

The function finds out what of two fields is better according

9157

2290

this criteria.

9158

2291

9167

2300

@retval

9168

2301

0 otherwise

9169

2302

9170

9171

2303

static int compare_fields_by_table_order(Item_field *field1,

9172

Item_field *field2,

9173

void *table_join_idx)

2304

Item_field *field2,

2305

void *table_join_idx)

9174

2306

{

9175

2307

int cmp= 0;

9176

2308

bool outer_ref= 0;

9177

2309

if (field2->used_tables() & OUTER_REF_TABLE_BIT)

9178

{

2310

{

9179

2311

outer_ref= 1;

9180

2312

cmp= -1;

9181

2313

}

9186

2318

}

9187

2319

if (outer_ref)

9188

2320

return cmp;

9189

JOIN_TAB **idx= (JOIN_TAB **) table_join_idx;

2321

JoinTable **idx= (JoinTable **) table_join_idx;

9190

2322

cmp= idx[field2->field->table->tablenr]-idx[field1->field->table->tablenr];

9191

2323

return cmp < 0 ? -1 : (cmp ? 1 : 0);

9192

2324

}

9193

2325

9194

9195

2326

/**

9196

2327

Generate minimal set of simple equalities equivalent to a multiple equality.

9197

2328

9231

2362

a pointer to the simple generated equality, if success.

9232

2363

- 0, otherwise.

9233

2364

9234

9235

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels,

9236

Item_equal *item_equal)

2365

static Item *eliminate_item_equal(COND *cond, COND_EQUAL *upper_levels, Item_equal *item_equal)

9237

2366

{

9238

2367

List<Item> eq_list;

9239

2368

Item_func_eq *eq_item= 0;

9240

2369

if (((Item *) item_equal)->const_item() && !item_equal->val_int())

9241

return new Item_int((int64_t) 0,1);

2370

return new Item_int((int64_t) 0,1);

9242

2371

Item *item_const= item_equal->get_const();

9243

2372

Item_equal_iterator it(*item_equal);

9244

2373

Item *head;

9255

2384

Item_equal *upper= item_field->find_item_equal(upper_levels);

9256

2385

Item_field *item= item_field;

9257

2386

if (upper)

9258

{

2387

{

9259

2388

if (item_const && upper->get_const())

9260

2389

item= 0;

9261

2390

else

9299

2428

9300

2429

cond->quick_fix_field();

9301

2430

cond->update_used_tables();

9302

2431

9303

2432

return cond;

9304

2433

}

9305

2434

9306

9307

2435

/**

9308

2436

Substitute every field reference in a condition by the best equal field

9309

2437

and eliminate all multiple equality predicates.

9312

2440

multiple equality predicate it sorts the field references in it

9313

2441

according to the order of tables specified by the table_join_idx

9314

2442

parameter. Then it eliminates the multiple equality predicate it

9315

replacing it by the conjunction of simple equality predicates

2443

replacing it by the conjunction of simple equality predicates

9316

2444

equating every field from the multiple equality to the first

9317

2445

field in it, or to the constant, if there is any.

9318

2446

After this the function retrieves all other conjuncted

9331

2459

@return

9332

2460

The transformed condition

9333

2461

9334

9335

static COND* substitute_for_best_equal_field(COND *cond,

9336

COND_EQUAL *cond_equal,

9337

void *table_join_idx)

2462

COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx)

9338

2463

{

9339

2464

Item_equal *item_equal;

9340

2465

9349

2474

cond_equal= &((Item_cond_and *) cond)->cond_equal;

9350

2475

cond_list->disjoin((List<Item> *) &cond_equal->current_level);

9351

2476

9352

List_iterator_fast<Item_equal> it(cond_equal->current_level);

2477

List_iterator_fast<Item_equal> it(cond_equal->current_level);

9353

2478

while ((item_equal= it++))

9354

2479

{

9355

2480

item_equal->sort(&compare_fields_by_table_order, table_join_idx);

9356

2481

}

9357

2482

}

9358

2483

9359

2484

List_iterator<Item> li(*cond_list);

9360

2485

Item *item;

9361

2486

while ((item= li++))

9388

2513

cond= new Item_int((int32_t)cond->val_bool());

9389

2514

9390

2515

}

9391

else if (cond->type() == Item::FUNC_ITEM &&

2516

else if (cond->type() == Item::FUNC_ITEM &&

9392

2517

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

9393

2518

{

9394

2519

item_equal= (Item_equal *) cond;

9402

2527

return cond;

9403

2528

}

9404

2529

9405

9406

2530

/**

9407

2531

Check appearance of new constant items in multiple equalities

9408

2532

of a condition after reading a constant table.

9415

2539

@param cond condition whose multiple equalities are to be checked

9416

2540

@param table constant table that has been read

9417

2541

9418

9419

static void update_const_equal_items(COND *cond, JOIN_TAB *tab)

2542

static void update_const_equal_items(COND *cond, JoinTable *tab)

9420

2543

{

9421

2544

if (!(cond->used_tables() & tab->table->map))

9422

2545

return;

9423

2546

9424

2547

if (cond->type() == Item::COND_ITEM)

9425

2548

{

9426

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

2549

List<Item> *cond_list= ((Item_cond*) cond)->argument_list();

9427

2550

List_iterator_fast<Item> li(*cond_list);

9428

2551

Item *item;

9429

2552

while ((item= li++))

9430

2553

update_const_equal_items(item, tab);

9431

2554

}

9432

else if (cond->type() == Item::FUNC_ITEM &&

2555

else if (cond->type() == Item::FUNC_ITEM &&

9433

2556

((Item_cond*) cond)->functype() == Item_func::MULT_EQUAL_FUNC)

9434

2557

{

9435

2558

Item_equal *item_equal= (Item_equal *) cond;

9443

2566

while ((item_field= it++))

9444

2567

{

9445

2568

Field *field= item_field->field;

9446

JOIN_TAB *stat= field->table->reginfo.join_tab;

2569

JoinTable *stat= field->table->reginfo.join_tab;

9447

2570

key_map possible_keys= field->key_start;

9448

possible_keys.intersect(field->table->keys_in_use_for_query);

9449

stat[0].const_keys.merge(possible_keys);

2571

possible_keys&= field->table->keys_in_use_for_query;

2572

stat[0].const_keys|= possible_keys;

9450

2573

9451

2574

9452

For each field in the multiple equality (for which we know that it

9453

is a constant) we have to find its corresponding key part, and set

2575

For each field in the multiple equality (for which we know that it

2576

is a constant) we have to find its corresponding key part, and set

9454

2577

that key part in const_key_parts.

9455

9456

if (!possible_keys.is_clear_all())

2578

2579

if (possible_keys.any())

9457

2580

{

9458

TABLE *tab= field->table;

9459

KEYUSE *use;

9460

for (use= stat->keyuse; use && use->table == tab; use++)

9461

if (possible_keys.is_set(use->key) &&

9462

tab->key_info[use->key].key_part[use->keypart].field ==

2581

Table *field_tab= field->table;

2582

optimizer::KeyUse *use;

2583

for (use= stat->keyuse; use && use->getTable() == field_tab; use++)

2584

if (possible_keys.test(use->getKey()) &&

2585

field_tab->key_info[use->getKey()].key_part[use->getKeypart()].field ==

9463

2586

field)

9464

tab->const_key_parts[use->key]|= use->keypart_map;

2587

field_tab->const_key_parts[use->getKey()]|= use->getKeypartMap();

9465

2588

}

9466

2589

}

9467

2590

}

9468

2591

}

9469

2592

}

9470

2593

9471

9472

2594

9473

2595

change field = field to field = const for each found field = const in the

9474

2596

and_level

9475

2597

9476

9477

static void

9478

change_cond_ref_to_const(THD *thd, I_List<COND_CMP> *save_list,

9479

Item *and_father, Item *cond,

9480

Item *field, Item *value)

2598

static void change_cond_ref_to_const(Session *session,

2599

vector<COND_CMP>& save_list,

2600

Item *and_father,

2601

Item *cond,

2602

Item *field,

2603

Item *value)

9481

2604

{

9482

2605

if (cond->type() == Item::COND_ITEM)

9483

2606

{

9484

bool and_level= ((Item_cond*) cond)->functype() ==

9485

Item_func::COND_AND_FUNC;

2607

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9486

2608

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

9487

2609

Item *item;

9488

2610

while ((item=li++))

9489

change_cond_ref_to_const(thd, save_list,and_level ? cond : item, item,

9490

field, value);

2611

change_cond_ref_to_const(session, save_list, and_level ? cond : item, item, field, value);

9491

2612

return;

9492

2613

}

9493

2614

if (cond->eq_cmp_result() == Item::COND_OK)

9507

2628

{

9508

2629

Item *tmp=value->clone_item();

9509

2630

tmp->collation.set(right_item->collation);

9510

2631

9511

2632

if (tmp)

9512

2633

{

9513

thd->change_item_tree(args + 1, tmp);

2634

session->change_item_tree(args + 1, tmp);

9514

2635

func->update_used_tables();

9515

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9516

&& and_father != cond && !left_item->const_item())

2636

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2637

and_father != cond &&

2638

! left_item->const_item())

9517

2639

{

9518

cond->marker=1;

9519

COND_CMP *tmp2;

9520

if ((tmp2=new COND_CMP(and_father,func)))

9521

save_list->push_back(tmp2);

2640

cond->marker=1;

2641

save_list.push_back( COND_CMP(and_father, func) );

9522

2642

}

9523

2643

func->set_cmp_func();

9524

2644

}

9531

2651

{

9532

2652

Item *tmp= value->clone_item();

9533

2653

tmp->collation.set(left_item->collation);

9534

2654

9535

2655

if (tmp)

9536

2656

{

9537

thd->change_item_tree(args, tmp);

2657

session->change_item_tree(args, tmp);

9538

2658

value= tmp;

9539

2659

func->update_used_tables();

9540

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC)

9541

&& and_father != cond && !right_item->const_item())

2660

if ((functype == Item_func::EQ_FUNC || functype == Item_func::EQUAL_FUNC) &&

2661

and_father != cond &&

2662

! right_item->const_item())

9542

2663

{

9543

2664

args[0]= args[1]; // For easy check

9544

thd->change_item_tree(args + 1, value);

9545

cond->marker=1;

9546

COND_CMP *tmp2;

9547

if ((tmp2=new COND_CMP(and_father,func)))

9548

save_list->push_back(tmp2);

2665

session->change_item_tree(args + 1, value);

2666

cond->marker=1;

2667

save_list.push_back( COND_CMP(and_father, func) );

9549

2668

}

9550

2669

func->set_cmp_func();

9551

2670

}

9560

2679

@return

9561

2680

new conditions

9562

2681

9563

9564

static Item *remove_additional_cond(Item* conds)

2682

Item *remove_additional_cond(Item* conds)

9565

2683

{

9566

2684

if (conds->name == in_additional_cond)

9567

2685

return 0;

9584

2702

return conds;

9585

2703

}

9586

2704

9587

static void

9588

propagate_cond_constants(THD *thd, I_List<COND_CMP> *save_list,

9589

COND *and_father, COND *cond)

2705

static void propagate_cond_constants(Session *session,

2706

vector<COND_CMP>& save_list,

2707

COND *and_father,

2708

COND *cond)

9590

2709

{

9591

2710

if (cond->type() == Item::COND_ITEM)

9592

2711

{

9593

bool and_level= ((Item_cond*) cond)->functype() ==

9594

Item_func::COND_AND_FUNC;

2712

bool and_level= ((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC;

9595

2713

List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());

9596

2714

Item *item;

9597

I_List<COND_CMP> save;

2715

vector<COND_CMP> save;

9598

2716

while ((item=li++))

9599

2717

{

9600

propagate_cond_constants(thd, &save,and_level ? cond : item, item);

2718

propagate_cond_constants(session, save, and_level ? cond : item, item);

9601

2719

}

9602

2720

if (and_level)

9603

{ // Handle other found items

9604

I_List_iterator<COND_CMP> cond_itr(save);

9605

COND_CMP *cond_cmp;

9606

while ((cond_cmp=cond_itr++))

2721

{

2722

// Handle other found items

2723

for (vector<COND_CMP>::iterator iter= save.begin(); iter != save.end(); ++iter)

9607

2724

{

9608

Item **args= cond_cmp->cmp_func->arguments();

2725

Item **args= iter->cmp_func->arguments();

9609

2726

if (!args[0]->const_item())

9610

change_cond_ref_to_const(thd, &save,cond_cmp->and_level,

9611

cond_cmp->and_level, args[0], args[1]);

2727

{

2728

change_cond_ref_to_const( session, save, iter->and_level,

2729

iter->and_level, args[0], args[1] );

2730

}

9612

2731

}

9613

2732

}

9614

2733

}

9615

2734

else if (and_father != cond && !cond->marker) // In a AND group

9616

2735

{

9617

2736

if (cond->type() == Item::FUNC_ITEM &&

9618

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

9619

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

2737

(((Item_func*) cond)->functype() == Item_func::EQ_FUNC ||

2738

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC))

9620

2739

{

9621

2740

Item_func_eq *func=(Item_func_eq*) cond;

9622

2741

Item **args= func->arguments();

9625

2744

if (!(left_const && right_const) &&

9626

2745

args[0]->result_type() == args[1]->result_type())

9627

2746

{

9628

if (right_const)

9629

{

9630

resolve_const_item(thd, &args[1], args[0]);

9631

func->update_used_tables();

9632

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9633

args[0], args[1]);

9634

}

9635

else if (left_const)

9636

{

9637

resolve_const_item(thd, &args[0], args[1]);

9638

func->update_used_tables();

9639

change_cond_ref_to_const(thd, save_list, and_father, and_father,

9640

args[1], args[0]);

9641

}

9642

}

9643

}

9644

}

9645

}

9646

9647

9648

/**

9649

Simplify joins replacing outer joins by inner joins whenever it's

9650

possible.

9651

9652

The function, during a retrieval of join_list, eliminates those

9653

outer joins that can be converted into inner join, possibly nested.

9654

It also moves the on expressions for the converted outer joins

9655

and from inner joins to conds.

9656

The function also calculates some attributes for nested joins:

9657

- used_tables

9658

- not_null_tables

9659

- dep_tables.

9660

- on_expr_dep_tables

9661

The first two attributes are used to test whether an outer join can

9662

be substituted for an inner join. The third attribute represents the

9663

relation 'to be dependent on' for tables. If table t2 is dependent

9664

on table t1, then in any evaluated execution plan table access to

9665

table t2 must precede access to table t2. This relation is used also

9666

to check whether the query contains invalid cross-references.

9667

The forth attribute is an auxiliary one and is used to calculate

9668

dep_tables.

9669

As the attribute dep_tables qualifies possibles orders of tables in the

9670

execution plan, the dependencies required by the straight join

9671

modifiers are reflected in this attribute as well.

9672

The function also removes all braces that can be removed from the join

9673

expression without changing its meaning.

9674

9675

@note

9676

An outer join can be replaced by an inner join if the where condition

9677

or the on expression for an embedding nested join contains a conjunctive

9678

predicate rejecting null values for some attribute of the inner tables.

9679

9680

E.g. in the query:

9681

@code

9682

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9683

@endcode

9684

the predicate t2.b < 5 rejects nulls.

9685

The query is converted first to:

9686

@code

9687

SELECT * FROM t1 INNER JOIN t2 ON t2.a=t1.a WHERE t2.b < 5

9688

@endcode

9689

then to the equivalent form:

9690

@code

9691

SELECT * FROM t1, t2 ON t2.a=t1.a WHERE t2.b < 5 AND t2.a=t1.a

9692

@endcode

9693

9694

9695

Similarly the following query:

9696

@code

9697

SELECT * from t1 LEFT JOIN (t2, t3) ON t2.a=t1.a t3.b=t1.b

9698

WHERE t2.c < 5

9699

@endcode

9700

is converted to:

9701

@code

9702

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a t3.b=t1.b

9703

9704

@endcode

9705

9706

One conversion might trigger another:

9707

@code

9708

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a

9709

LEFT JOIN t3 ON t3.b=t2.b

9710

WHERE t3 IS NOT NULL =>

9711

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t1.a, t3

9712

WHERE t3 IS NOT NULL AND t3.b=t2.b =>

9713

SELECT * FROM t1, t2, t3

9714

WHERE t3 IS NOT NULL AND t3.b=t2.b AND t2.a=t1.a

9715

@endcode

9716

9717

The function removes all unnecessary braces from the expression

9718

produced by the conversions.

9719

E.g.

9720

@code

9721

SELECT * FROM t1, (t2, t3) WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9722

@endcode

9723

finally is converted to:

9724

@code

9725

SELECT * FROM t1, t2, t3 WHERE t2.c < 5 AND t2.a=t1.a AND t3.b=t1.b

9726

9727

@endcode

9728

9729

9730

It also will remove braces from the following queries:

9731

@code

9732

SELECT * from (t1 LEFT JOIN t2 ON t2.a=t1.a) LEFT JOIN t3 ON t3.b=t2.b

9733

SELECT * from (t1, (t2,t3)) WHERE t1.a=t2.a AND t2.b=t3.b.

9734

@endcode

9735

9736

The benefit of this simplification procedure is that it might return

9737

a query for which the optimizer can evaluate execution plan with more

9738

join orders. With a left join operation the optimizer does not

9739

consider any plan where one of the inner tables is before some of outer

9740

tables.

9741

9742

IMPLEMENTATION

9743

The function is implemented by a recursive procedure. On the recursive

9744

ascent all attributes are calculated, all outer joins that can be

9745

converted are replaced and then all unnecessary braces are removed.

9746

As join list contains join tables in the reverse order sequential

9747

elimination of outer joins does not require extra recursive calls.

9748

9749

SEMI-JOIN NOTES

9750

Remove all semi-joins that have are within another semi-join (i.e. have

9751

an "ancestor" semi-join nest)

9752

9753

EXAMPLES

9754

Here is an example of a join query with invalid cross references:

9755

@code

9756

SELECT * FROM t1 LEFT JOIN t2 ON t2.a=t3.a LEFT JOIN t3 ON t3.b=t1.b

9757

@endcode

9758

9759

@param join reference to the query info

9760

@param join_list list representation of the join to be converted

9761

@param conds conditions to add on expressions for converted joins

9762

@param top true <=> conds is the where condition

9763

9764

@return

9765

- The new condition, if success

9766

- 0, otherwise

9767

9768

9769

static COND *

9770

simplify_joins(JOIN *join, List<TABLE_LIST> *join_list, COND *conds, bool top,

9771

bool in_sj)

9772

{

9773

TABLE_LIST *table;

9774

NESTED_JOIN *nested_join;

9775

TABLE_LIST *prev_table= 0;

9776

List_iterator<TABLE_LIST> li(*join_list);

9777

9778

9779

Try to simplify join operations from join_list.

9780

The most outer join operation is checked for conversion first.

9781

9782

while ((table= li++))

9783

{

9784

table_map used_tables;

9785

table_map not_null_tables= (table_map) 0;

9786

9787

if ((nested_join= table->nested_join))

9788

{

9789

9790

If the element of join_list is a nested join apply

9791

the procedure to its nested join list first.

9792

9793

if (table->on_expr)

9794

{

9795

Item *expr= table->on_expr;

9796

9797

If an on expression E is attached to the table,

9798

check all null rejected predicates in this expression.

9799

If such a predicate over an attribute belonging to

9800

an inner table of an embedded outer join is found,

9801

the outer join is converted to an inner join and

9802

the corresponding on expression is added to E.

9803

9804

expr= simplify_joins(join, &nested_join->join_list,

9805

expr, false, in_sj || table->sj_on_expr);

9806

9807

if (!table->prep_on_expr || expr != table->on_expr)

9808

{

9809

assert(expr);

9810

9811

table->on_expr= expr;

9812

table->prep_on_expr= expr->copy_andor_structure(join->thd);

9813

}

9814

}

9815

nested_join->used_tables= (table_map) 0;

9816

nested_join->not_null_tables=(table_map) 0;

9817

conds= simplify_joins(join, &nested_join->join_list, conds, top,

9818

in_sj || table->sj_on_expr);

9819

used_tables= nested_join->used_tables;

9820

not_null_tables= nested_join->not_null_tables;

9821

}

9822

else

9823

{

9824

if (!table->prep_on_expr)

9825

table->prep_on_expr= table->on_expr;

9826

used_tables= table->table->map;

9827

if (conds)

9828

not_null_tables= conds->not_null_tables();

9829

}

9830

9831

if (table->embedding)

9832

{

9833

table->embedding->nested_join->used_tables|= used_tables;

9834

table->embedding->nested_join->not_null_tables|= not_null_tables;

9835

}

9836

9837

if (!table->outer_join || (used_tables & not_null_tables))

9838

{

9839

9840

For some of the inner tables there are conjunctive predicates

9841

that reject nulls => the outer join can be replaced by an inner join.

9842

9843

table->outer_join= 0;

9844

if (table->on_expr)

9845

{

9846

/* Add ON expression to the WHERE or upper-level ON condition. */

9847

if (conds)

9848

{

9849

conds= and_conds(conds, table->on_expr);

9850

conds->top_level_item();

9851

/* conds is always a new item as both cond and on_expr existed */

9852

assert(!conds->fixed);

9853

conds->fix_fields(join->thd, &conds);

9854

}

9855

else

9856

conds= table->on_expr;

9857

table->prep_on_expr= table->on_expr= 0;

9858

}

9859

}

9860

9861

if (!top)

9862

continue;

9863

9864

9865

Only inner tables of non-convertible outer joins

9866

remain with on_expr.

9867

9868

if (table->on_expr)

9869

{

9870

table->dep_tables|= table->on_expr->used_tables();

9871

if (table->embedding)

9872

{

9873

table->dep_tables&= ~table->embedding->nested_join->used_tables;

9874

9875

Embedding table depends on tables used

9876

in embedded on expressions.

9877

9878

table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();

9879

}

9880

else

9881

table->dep_tables&= ~table->table->map;

9882

}

9883

9884

if (prev_table)

9885

{

9886

/* The order of tables is reverse: prev_table follows table */

9887

if (prev_table->straight)

9888

prev_table->dep_tables|= used_tables;

9889

if (prev_table->on_expr)

9890

{

9891

prev_table->dep_tables|= table->on_expr_dep_tables;

9892

table_map prev_used_tables= prev_table->nested_join ?

9893

prev_table->nested_join->used_tables :

9894

prev_table->table->map;

9895

9896

If on expression contains only references to inner tables

9897

we still make the inner tables dependent on the outer tables.

9898

It would be enough to set dependency only on one outer table

9899

for them. Yet this is really a rare case.

9900

9901

if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))

9902

prev_table->dep_tables|= used_tables;

9903

}

9904

}

9905

prev_table= table;

9906

}

9907

9908

9909

Flatten nested joins that can be flattened.

9910

no ON expression and not a semi-join => can be flattened.

9911

9912

li.rewind();

9913

while ((table= li++))

9914

{

9915

nested_join= table->nested_join;

9916

if (table->sj_on_expr && !in_sj)

9917

{

9918

9919

If this is a semi-join that is not contained within another semi-join,

9920

leave it intact (otherwise it is flattened)

9921

9922

join->select_lex->sj_nests.push_back(table);

9923

}

9924

else if (nested_join && !table->on_expr)

9925

{

9926

TABLE_LIST *tbl;

9927

List_iterator<TABLE_LIST> it(nested_join->join_list);

9928

while ((tbl= it++))

9929

{

9930

tbl->embedding= table->embedding;

9931

tbl->join_list= table->join_list;

9932

}

9933

li.replace(nested_join->join_list);

9934

}

9935

}

9936

return(conds);

9937

}

9938

9939

9940

/**

9941

Assign each nested join structure a bit in nested_join_map.

9942

9943

Assign each nested join structure (except "confluent" ones - those that

9944

embed only one element) a bit in nested_join_map.

9945

9946

@param join Join being processed

9947

@param join_list List of tables

9948

@param first_unused Number of first unused bit in nested_join_map before the

9949

call

9950

9951

@note

9952

This function is called after simplify_joins(), when there are no

9953

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

9954

we will not run out of bits in nested_join_map.

9955

9956

@return

9957

First unused bit in nested_join_map after the call.

9958

9959

9960

static uint build_bitmap_for_nested_joins(List<TABLE_LIST> *join_list,

9961

uint first_unused)

9962

{

9963

List_iterator<TABLE_LIST> li(*join_list);

9964

TABLE_LIST *table;

9965

while ((table= li++))

9966

{

9967

NESTED_JOIN *nested_join;

9968

if ((nested_join= table->nested_join))

9969

{

9970

9971

It is guaranteed by simplify_joins() function that a nested join

9972

that has only one child is either

9973

- a single-table view (the child is the underlying table), or

9974

- a single-table semi-join nest

9975

9976

We don't assign bits to such sj-nests because

9977

1. it is redundant (a "sequence" of one table cannot be interleaved

9978

with anything)

9979

2. we could run out bits in nested_join_map otherwise.

9980

9981

if (nested_join->join_list.elements != 1)

9982

{

9983

/* Don't assign bits to sj-nests */

9984

if (table->on_expr)

9985

nested_join->nj_map= (nested_join_map) 1 << first_unused++;

9986

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

9987

first_unused);

9988

}

9989

}

9990

}

9991

return(first_unused);

9992

}

9993

9994

9995

/**

9996

Set NESTED_JOIN::counter=0 in all nested joins in passed list.

9997

9998

Recursively set NESTED_JOIN::counter=0 for all nested joins contained in

9999

the passed join_list.

10000

10001

@param join_list List of nested joins to process. It may also contain base

10002

tables which will be ignored.

10003

10004

10005

static void reset_nj_counters(List<TABLE_LIST> *join_list)

10006

{

10007

List_iterator<TABLE_LIST> li(*join_list);

10008

TABLE_LIST *table;

10009

while ((table= li++))

10010

{

10011

NESTED_JOIN *nested_join;

10012

if ((nested_join= table->nested_join))

10013

{

10014

nested_join->counter_= 0;

10015

reset_nj_counters(&nested_join->join_list);

10016

}

10017

}

10018

return;

10019

}

10020

2747

if (right_const)

2748

{

2749

resolve_const_item(session, &args[1], args[0]);

2750

func->update_used_tables();

2751

change_cond_ref_to_const(session, save_list, and_father, and_father,

2752

args[0], args[1]);

2753

}

2754

else if (left_const)

2755

{

2756

resolve_const_item(session, &args[0], args[1]);

2757

func->update_used_tables();

2758

change_cond_ref_to_const(session, save_list, and_father, and_father,

2759

args[1], args[0]);

2760

}

2761

}

2762

}

2763

}

2764

}

10021

2765

10022

2766

/**

10023

2767

Check interleaving with an inner tables of an outer join for

10024

2768

extension table.

10025

2769

10026

Check if table next_tab can be added to current partial join order, and

2770

Check if table next_tab can be added to current partial join order, and

10027

2771

if yes, record that it has been added.

10028

2772

10029

2773

The function assumes that both current partial join order and its

10030

2774

extension with next_tab are valid wrt table dependencies.

10031

2775

10032

2776

@verbatim

10033

IMPLEMENTATION

10034

LIMITATIONS ON JOIN ORDER

2777

IMPLEMENTATION

2778

LIMITATIONS ON JOIN order_st

10035

2779

The nested [outer] joins executioner algorithm imposes these limitations

10036

2780

on join order:

10037

1. "Outer tables first" - any "outer" table must be before any

2781

1. "Outer tables first" - any "outer" table must be before any

10038

2782

corresponding "inner" table.

10039

2783

2. "No interleaving" - tables inside a nested join must form a continuous

10040

sequence in join order (i.e. the sequence must not be interrupted by

2784

sequence in join order (i.e. the sequence must not be interrupted by

10041

2785

tables that are outside of this nested join).

10042

2786

10043

2787

#1 is checked elsewhere, this function checks #2 provided that #1 has

10044

2788

been already checked.

10045

2789

10046

2790

WHY NEED NON-INTERLEAVING

10047

Consider an example:

2791

Consider an example:

10048

2792

10049

2793

select * from t0 join t1 left join (t2 join t3) on cond1

10050

2794

10068

2812

The limitations on join order can be rephrased as follows: for valid

10069

2813

join order one must be able to:

10070

2814

1. write down the used tables in the join order on one line.

10071

2. for each nested join, put one '(' and one ')' on the said line

2815

2. for each nested join, put one '(' and one ')' on the said line

10072

2816

3. write "LEFT JOIN" and "ON (...)" where appropriate

10073

2817

4. get a query equivalent to the query we're trying to execute.

10074

2818

10075

2819

Calls to check_interleaving_with_nj() are equivalent to writing the

10076

above described line from left to right.

10077

A single check_interleaving_with_nj(A,B) call is equivalent to writing

2820

above described line from left to right.

2821

A single check_interleaving_with_nj(A,B) call is equivalent to writing

10078

2822

table B and appropriate brackets on condition that table A and

10079

2823

appropriate brackets is the last what was written. Graphically the

10080

2824

transition is as follows:

10087

2831

position.

10088

2832

10089

2833

Notes about the position:

10090

The caller guarantees that there is no more then one X-bracket by

10091

checking "!(remaining_tables & s->dependent)" before calling this

2834

The caller guarantees that there is no more then one X-bracket by

2835

checking "!(remaining_tables & s->dependent)" before calling this

10092

2836

function. X-bracket may have a pair in Y-bracket.

10093

2837

10094

2838

When "writing" we store/update this auxilary info about the current

10095

2839

position:

10096

2840

1. join->cur_embedding_map - bitmap of pairs of brackets (aka nested

10097

2841

joins) we've opened but didn't close.

10098

2. {each NESTED_JOIN structure not simplified away}->counter - number

2842

2. {each nested_join_st structure not simplified away}->counter - number

10099

2843

of this nested join's children that have already been added to to

10100

2844

the partial join order.

10101

2845

@endverbatim

10111

2855

@retval

10112

2856

true Requested join order extension not allowed.

10113

2857

10114

10115

static bool check_interleaving_with_nj(JOIN_TAB *last_tab, JOIN_TAB *next_tab)

2858

bool check_interleaving_with_nj(JoinTable *last_tab, JoinTable *next_tab)

10116

2859

{

10117

TABLE_LIST *next_emb= next_tab->table->pos_in_table_list->embedding;

2860

TableList *next_emb= next_tab->table->pos_in_table_list->embedding;

10118

2861

JOIN *join= last_tab->join;

10119

2862

10120

if (join->cur_embedding_map & ~next_tab->embedding_map)

2863

if ((join->cur_embedding_map & ~next_tab->embedding_map).any())

10121

2864

{

10122

2865

10123

2866

next_tab is outside of the "pair of brackets" we're currently in.

10124

2867

Cannot add it.

10125

2868

10126

2869

return true;

10127

2870

}

10128

2871

10129

2872

10130

2873

Do update counters for "pairs of brackets" that we've left (marked as

10131

2874

X,Y,Z in the above picture)

10135

2878

next_emb->nested_join->counter_++;

10136

2879

if (next_emb->nested_join->counter_ == 1)

10137

2880

{

10138

2881

10139

2882

next_emb is the first table inside a nested join we've "entered". In

10140

2883

the picture above, we're looking at the 'X' bracket. Don't exit yet as

10141

2884

X bracket might have Y pair bracket.

10142

2885

10143

2886

join->cur_embedding_map |= next_emb->nested_join->nj_map;

10144

2887

}

10145

2888

10146

2889

if (next_emb->nested_join->join_list.elements !=

10147

2890

next_emb->nested_join->counter_)

10148

2891

break;

10156

2899

return false;

10157

2900

}

10158

2901

10159

10160

/**

10161

Nested joins perspective: Remove the last table from the join order.

10162

10163

Remove the last table from the partial join order and update the nested

10164

joins counters and join->cur_embedding_map. It is ok to call this

10165

function for the first table in join order (for which

10166

check_interleaving_with_nj has not been called)

10167

10168

@param last join table to remove, it is assumed to be the last in current

10169

partial join order.

10170

10171

10172

static void restore_prev_nj_state(JOIN_TAB *last)

10173

{

10174

TABLE_LIST *last_emb= last->table->pos_in_table_list->embedding;

10175

JOIN *join= last->join;

10176

while (last_emb)

10177

{

10178

if (last_emb->on_expr)

10179

{

10180

if (!(--last_emb->nested_join->counter_))

10181

join->cur_embedding_map&= ~last_emb->nested_join->nj_map;

10182

else if (last_emb->nested_join->join_list.elements-1 ==

10183

last_emb->nested_join->counter_)

10184

join->cur_embedding_map|= last_emb->nested_join->nj_map;

10185

else

10186

break;

10187

}

10188

last_emb= last_emb->embedding;

10189

}

10190

}

10191

10192

10193

10194

static

10195

void advance_sj_state(const table_map remaining_tables, const JOIN_TAB *tab)

10196

{

10197

TABLE_LIST *emb_sj_nest;

10198

if ((emb_sj_nest= tab->emb_sj_nest))

10199

{

10200

tab->join->cur_emb_sj_nests |= emb_sj_nest->sj_inner_tables;

10201

/* Remove the sj_nest if all of its SJ-inner tables are in cur_table_map */

10202

if (!(remaining_tables & emb_sj_nest->sj_inner_tables))

10203

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10204

}

10205

}

10206

10207

10208

10209

we assume remaining_tables doesnt contain @tab.

10210

10211

10212

static void restore_prev_sj_state(const table_map remaining_tables,

10213

const JOIN_TAB *tab)

10214

{

10215

TABLE_LIST *emb_sj_nest;

10216

if ((emb_sj_nest= tab->emb_sj_nest))

10217

{

10218

/* If we're removing the last SJ-inner table, remove the sj-nest */

10219

if ((remaining_tables & emb_sj_nest->sj_inner_tables) ==

10220

(emb_sj_nest->sj_inner_tables & ~tab->table->map))

10221

{

10222

tab->join->cur_emb_sj_nests &= ~emb_sj_nest->sj_inner_tables;

10223

}

10224

}

10225

}

10226

10227

10228

static COND *

10229

optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,

10230

Item::cond_result *cond_value)

10231

{

10232

THD *thd= join->thd;

2902

COND *optimize_cond(JOIN *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value)

2903

{

2904

Session *session= join->session;

10233

2905

10234

2906

if (!conds)

10235

2907

*cond_value= Item::COND_TRUE;

10236

2908

else

10237

2909

{

10238

2910

10239

2911

Build all multiple equality predicates and eliminate equality

10240

2912

predicates that can be inferred from these multiple equalities.

10241

2913

For each reference of a field included into a multiple equality

10242

2914

that occurs in a function set a pointer to the multiple equality

10243

2915

predicate. Substitute a constant instead of this field if the

10244

2916

multiple equality contains a constant.

10245

10246

conds= build_equal_items(join->thd, conds, NULL, join_list,

2917

2918

conds= build_equal_items(join->session, conds, NULL, join_list,

10247

2919

&join->cond_equal);

10248

2920

10249

2921

/* change field = field to field = const for each found field = const */

10250

propagate_cond_constants(thd, (I_List<COND_CMP> *) 0, conds, conds);

2922

vector<COND_CMP> temp;

2923

propagate_cond_constants(session, temp, conds, conds);

10251

2924

10252

2925

Remove all instances of item == item

10253

2926

Remove all and-levels where CONST item != CONST item

10254

2927

10255

conds= remove_eq_conds(thd, conds, cond_value) ;

2928

conds= remove_eq_conds(session, conds, cond_value) ;

10256

2929

}

10257

2930

return(conds);

10258

2931

}

10259

2932

10260

10261

2933

/**

10262

2934

Remove const and eq items.

10263

2935

10268

2940

- COND_TRUE : always true ( 1 = 1 )

10269

2941

- COND_FALSE : always false ( 1 = 2 )

10270

2942

10271

10272

COND *

10273

remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)

2943

COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value)

10274

2944

{

10275

2945

if (cond->type() == Item::COND_ITEM)

10276

2946

{

10277

bool and_level= ((Item_cond*) cond)->functype()

10278

== Item_func::COND_AND_FUNC;

2947

bool and_level= (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC);

2948

10279

2949

List_iterator<Item> li(*((Item_cond*) cond)->argument_list());

10280

2950

Item::cond_result tmp_cond_value;

10281

bool should_fix_fields=0;

2951

bool should_fix_fields= false;

10282

2952

10283

*cond_value=Item::COND_UNDEF;

2953

*cond_value= Item::COND_UNDEF;

10284

2954

Item *item;

10285

while ((item=li++))

2955

while ((item= li++))

10286

2956

{

10287

Item *new_item=remove_eq_conds(thd, item, &tmp_cond_value);

10288

if (!new_item)

10289

li.remove();

2957

Item *new_item= remove_eq_conds(session, item, &tmp_cond_value);

2958

if (! new_item)

2959

li.remove();

10290

2960

else if (item != new_item)

10291

2961

{

10292

VOID(li.replace(new_item));

10293

should_fix_fields=1;

2962

li.replace(new_item);

2963

should_fix_fields= true;

10294

2964

}

10295

2965

if (*cond_value == Item::COND_UNDEF)

10296

*cond_value=tmp_cond_value;

10297

switch (tmp_cond_value) {

10298

case Item::COND_OK: // Not true or false

10299

if (and_level || *cond_value == Item::COND_FALSE)

10300

*cond_value=tmp_cond_value;

10301

break;

10302

case Item::COND_FALSE:

10303

if (and_level)

10304

{

10305

*cond_value=tmp_cond_value;

10306

return (COND*) 0; // Always false

10307

}

10308

break;

10309

case Item::COND_TRUE:

10310

if (!and_level)

10311

{

10312

*cond_value= tmp_cond_value;

10313

return (COND*) 0; // Always true

10314

}

10315

break;

10316

case Item::COND_UNDEF: // Impossible

10317

break; /* purecov: deadcode */

2966

*cond_value= tmp_cond_value;

2967

2968

switch (tmp_cond_value)

2969

{

2970

case Item::COND_OK: /* Not true or false */

2971

if (and_level || (*cond_value == Item::COND_FALSE))

2972

*cond_value= tmp_cond_value;

2973

break;

2974

case Item::COND_FALSE:

2975

if (and_level)

2976

{

2977

*cond_value= tmp_cond_value;

2978

return (COND *) NULL; /* Always false */

2979

}

2980

break;

2981

case Item::COND_TRUE:

2982

if (! and_level)

2983

{

2984

*cond_value= tmp_cond_value;

2985

return (COND *) NULL; /* Always true */

2986

}

2987

break;

2988

case Item::COND_UNDEF: /* Impossible */

2989

break;

10318

2990

}

10319

2991

}

2992

10320

2993

if (should_fix_fields)

10321

2994

cond->update_used_tables();

10322

2995

10323

if (!((Item_cond*) cond)->argument_list()->elements ||

10324

*cond_value != Item::COND_OK)

10325

return (COND*) 0;

2996

if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)

2997

return (COND*) NULL;

2998

10326

2999

if (((Item_cond*) cond)->argument_list()->elements == 1)

10327

{ // Remove list

3000

{

3001

/* Argument list contains only one element, so reduce it so a single item, then remove list */

10328

3002

item= ((Item_cond*) cond)->argument_list()->head();

10329

3003

((Item_cond*) cond)->argument_list()->empty();

10330

3004

return item;

10331

3005

}

10332

3006

}

10333

else if (cond->type() == Item::FUNC_ITEM &&

10334

((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

3007

else if (cond->type() == Item::FUNC_ITEM && ((Item_func*) cond)->functype() == Item_func::ISNULL_FUNC)

10335

3008

{

10336

3009

10337

3010

Handles this special case for some ODBC applications:

10343

3016

SELECT * from table_name where auto_increment_column = LAST_INSERT_ID

10344

3017

10345

3018

10346

Item_func_isnull *func=(Item_func_isnull*) cond;

3019

Item_func_isnull *func= (Item_func_isnull*) cond;

10347

3020

Item **args= func->arguments();

10348

3021

if (args[0]->type() == Item::FIELD_ITEM)

10349

3022

{

10350

Field *field=((Item_field*) args[0])->field;

10351

if (field->flags & AUTO_INCREMENT_FLAG && !field->table->maybe_null &&

10352

(thd->options & OPTION_AUTO_IS_NULL) &&

10353

(thd->first_successful_insert_id_in_prev_stmt > 0 &&

10354

thd->substitute_null_with_insert_id))

3023

Field *field= ((Item_field*) args[0])->field;

3024

if (field->flags & AUTO_INCREMENT_FLAG

3025

&& ! field->table->maybe_null

3026

&& session->options & OPTION_AUTO_IS_NULL

3027

&& (

3028

session->first_successful_insert_id_in_prev_stmt > 0

3029

&& session->substitute_null_with_insert_id

3030

)

3031

)

10355

3032

{

10356

COND *new_cond;

10357

if ((new_cond= new Item_func_eq(args[0],

10358

new Item_int("last_insert_id()",

10359

thd->read_first_successful_insert_id_in_prev_stmt(),

10360

MY_INT64_NUM_DECIMAL_DIGITS))))

10361

{

10362

cond=new_cond;

3033

COND *new_cond;

3034

if ((new_cond= new Item_func_eq(args[0], new Item_int("last_insert_id()",

3035

session->read_first_successful_insert_id_in_prev_stmt(),

3036

MY_INT64_NUM_DECIMAL_DIGITS))))

3037

{

3038

cond= new_cond;

10363

3039

10364

3040

Item_func_eq can't be fixed after creation so we do not check

10365

3041

cond->fixed, also it do not need tables so we use 0 as second

10366

3042

argument.

10367

3043

10368

cond->fix_fields(thd, &cond);

10369

}

3044

cond->fix_fields(session, &cond);

3045

}

10370

3046

10371

3047

IS NULL should be mapped to LAST_INSERT_ID only for first row, so

10372

3048

clear for next row

10373

3049

10374

thd->substitute_null_with_insert_id= false;

3050

session->substitute_null_with_insert_id= false;

10375

3051

}

3052

#ifdef NOTDEFINED

10376

3053

/* fix to replace 'NULL' dates with '0' (shreeve@uci.edu) */

10377

else if (((field->type() == DRIZZLE_TYPE_NEWDATE) ||

10378

(field->type() == DRIZZLE_TYPE_DATETIME)) &&

10379

(field->flags & NOT_NULL_FLAG) &&

10380

!field->table->maybe_null)

3054

else if (

3055

((field->type() == DRIZZLE_TYPE_DATE) || (field->type() == DRIZZLE_TYPE_DATETIME))

3056

&& (field->flags & NOT_NULL_FLAG)

3057

&& ! field->table->maybe_null)

10381

3058

{

10382

COND *new_cond;

10383

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

10384

{

10385

cond=new_cond;

3059

COND *new_cond;

3060

if ((new_cond= new Item_func_eq(args[0],new Item_int("0", 0, 2))))

3061

{

3062

cond= new_cond;

10386

3063

10387

3064

Item_func_eq can't be fixed after creation so we do not check

10388

3065

cond->fixed, also it do not need tables so we use 0 as second

10389

3066

argument.

10390

3067

10391

cond->fix_fields(thd, &cond);

10392

}

3068

cond->fix_fields(session, &cond);

3069

}

10393

3070

}

3071

#endif /* NOTDEFINED */

10394

3072

}

10395

3073

if (cond->const_item())

10396

3074

{

10397

3075

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

10398

return (COND*) 0;

3076

return (COND *) NULL;

10399

3077

}

10400

3078

}

10401

3079

else if (cond->const_item() && !cond->is_expensive())

10411

3089

10412

3090

{

10413

3091

*cond_value= eval_const_cond(cond) ? Item::COND_TRUE : Item::COND_FALSE;

10414

return (COND*) 0;

3092

return (COND *) NULL;

10415

3093

}

10416

3094

else if ((*cond_value= cond->eq_cmp_result()) != Item::COND_OK)

10417

{ // boolan compare function

3095

{

3096

/* boolan compare function */

10418

3097

Item *left_item= ((Item_func*) cond)->arguments()[0];

10419

3098

Item *right_item= ((Item_func*) cond)->arguments()[1];

10420

3099

if (left_item->eq(right_item,1))

10421

3100

{

10422

if (!left_item->maybe_null ||

10423

((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

10424

return (COND*) 0; // Compare of identical items

3101

if (!left_item->maybe_null || ((Item_func*) cond)->functype() == Item_func::EQUAL_FUNC)

3102

return (COND*) NULL; /* Comparison of identical items */

10425

3103

}

10426

3104

}

10427

*cond_value=Item::COND_OK;

10428

return cond; // Point at next and level

3105

*cond_value= Item::COND_OK;

3106

return cond; /* Point at next and return into recursion */

10429

3107

}

10430

3108

10431

3109

10432

3110

Check if equality can be used in removing components of GROUP BY/DISTINCT

10433

3111

10434

3112

SYNOPSIS

10435

3113

test_if_equality_guarantees_uniqueness()

10436

3114

l the left comparison argument (a field if any)

10437

3115

r the right comparison argument (a const of any)

10438

10439

DESCRIPTION

10440

Checks if an equality predicate can be used to take away

10441

DISTINCT/GROUP BY because it is known to be true for exactly one

3116

3117

DESCRIPTION

3118

Checks if an equality predicate can be used to take away

3119

DISTINCT/GROUP BY because it is known to be true for exactly one

10442

3120

distinct value (e.g. <expr> == <const>).

10443

Arguments must be of the same type because e.g.

10444

<string_field> = <int_const> may match more than 1 distinct value from

10445

the column.

10446

We must take into consideration and the optimization done for various

3121

Arguments must be of the same type because e.g.

3122

<string_field> = <int_const> may match more than 1 distinct value from

3123

the column.

3124

We must take into consideration and the optimization done for various

10447

3125

string constants when compared to dates etc (see Item_int_with_ref) as

10448

3126

well as the collation of the arguments.

10449

10450

RETURN VALUE

3127

3128

RETURN VALUE

10451

3129

true can be used

10452

3130

false cannot be used

10453

3131

10454

static bool

10455

test_if_equality_guarantees_uniqueness(Item *l, Item *r)

3132

static bool test_if_equality_guarantees_uniqueness(Item *l, Item *r)

10456

3133

{

10457

3134

return r->const_item() &&

10458

3135

/* elements must be compared as dates */

10467

3144

/**

10468

3145

Return true if the item is a const value in all the WHERE clause.

10469

3146

10470

10471

static bool

10472

const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

3147

bool const_expression_in_where(COND *cond, Item *comp_item, Item **const_item)

10473

3148

{

10474

3149

if (cond->type() == Item::COND_ITEM)

10475

3150

{

10482

3157

bool res=const_expression_in_where(item, comp_item, const_item);

10483

3158

if (res) // Is a const value

10484

3159

{

10485

if (and_level)

10486

return 1;

3160

if (and_level)

3161

return 1;

10487

3162

}

10488

3163

else if (!and_level)

10489

return 0;

3164

return 0;

10490

3165

}

10491

3166

return and_level ? 0 : 1;

10492

3167

}

10494

3169

{ // boolan compare function

10495

3170

Item_func* func= (Item_func*) cond;

10496

3171

if (func->functype() != Item_func::EQUAL_FUNC &&

10497

func->functype() != Item_func::EQ_FUNC)

3172

func->functype() != Item_func::EQ_FUNC)

10498

3173

return 0;

10499

3174

Item *left_item= ((Item_func*) cond)->arguments()[0];

10500

3175

Item *right_item= ((Item_func*) cond)->arguments()[1];

10502

3177

{

10503

3178

if (test_if_equality_guarantees_uniqueness (left_item, right_item))

10504

3179

{

10505

if (*const_item)

10506

return right_item->eq(*const_item, 1);

10507

*const_item=right_item;

10508

return 1;

3180

if (*const_item)

3181

return right_item->eq(*const_item, 1);

3182

*const_item=right_item;

3183

return 1;

10509

3184

}

10510

3185

}

10511

3186

else if (right_item->eq(comp_item,1))

10512

3187

{

10513

3188

if (test_if_equality_guarantees_uniqueness (right_item, left_item))

10514

3189

{

10515

if (*const_item)

10516

return left_item->eq(*const_item, 1);

10517

*const_item=left_item;

10518

return 1;

10519

}

10520

}

10521

}

10522

return 0;

10523

}

10524

10525

/****************************************************************************

10526

Create internal temporary table

10527

****************************************************************************/

10528

10529

/**

10530

Create field for temporary table from given field.

10531

10532

@param thd Thread handler

10533

@param org_field field from which new field will be created

10534

@param name New field name

10535

@param table Temporary table

10536

@param item !=NULL if item->result_field should point to new field.

10537

This is relevant for how fill_record() is going to work:

10538

If item != NULL then fill_record() will update

10539

the record in the original table.

10540

If item == NULL then fill_record() will update

10541

the temporary table

10542

@param convert_blob_length If >0 create a varstring(convert_blob_length)

10543

field instead of blob.

10544

10545

@retval

10546

NULL on error

10547

@retval

10548

new_created field

10549

10550

10551

Field *create_tmp_field_from_field(THD *thd, Field *org_field,

10552

const char *name, TABLE *table,

10553

Item_field *item, uint convert_blob_length)

10554

{

10555

Field *new_field;

10556

10557

10558

Make sure that the blob fits into a Field_varstring which has

10559

2-byte lenght.

10560

10561

if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&

10562

(org_field->flags & BLOB_FLAG))

10563

new_field= new Field_varstring(convert_blob_length,

10564

org_field->maybe_null(),

10565

org_field->field_name, table->s,

10566

org_field->charset());

10567

else

10568

new_field= org_field->new_field(thd->mem_root, table,

10569

table == org_field->table);

10570

if (new_field)

10571

{

10572

new_field->init(table);

10573

new_field->orig_table= org_field->orig_table;

10574

if (item)

10575

item->result_field= new_field;

10576

else

10577

new_field->field_name= name;

10578

new_field->flags|= (org_field->flags & NO_DEFAULT_VALUE_FLAG);

10579

if (org_field->maybe_null() || (item && item->maybe_null))

10580

new_field->flags&= ~NOT_NULL_FLAG; // Because of outer join

10581

if (org_field->type() == DRIZZLE_TYPE_VARCHAR)

10582

table->s->db_create_options|= HA_OPTION_PACK_RECORD;

10583

else if (org_field->type() == DRIZZLE_TYPE_DOUBLE)

10584

((Field_double *) new_field)->not_fixed= true;

10585

}

10586

return new_field;

10587

}

10588

10589

/**

10590

Create field for temporary table using type of given item.

10591

10592

@param thd Thread handler

10593

@param item Item to create a field for

10594

@param table Temporary table

10595

@param copy_func If set and item is a function, store copy of

10596

item in this array

10597

@param modify_item 1 if item->result_field should point to new

10598

item. This is relevent for how fill_record()

10599

is going to work:

10600

If modify_item is 1 then fill_record() will

10601

update the record in the original table.

10602

If modify_item is 0 then fill_record() will

10603

update the temporary table

10604

@param convert_blob_length If >0 create a varstring(convert_blob_length)

10605

field instead of blob.

10606

10607

@retval

10608

0 on error

10609

@retval

10610

new_created field

10611

10612

10613

static Field *create_tmp_field_from_item(THD *thd __attribute__((unused)),

10614

Item *item, TABLE *table,

10615

Item ***copy_func, bool modify_item,

10616

uint convert_blob_length)

10617

{

10618

bool maybe_null= item->maybe_null;

10619

Field *new_field;

10620

10621

switch (item->result_type()) {

10622

case REAL_RESULT:

10623

new_field= new Field_double(item->max_length, maybe_null,

10624

item->name, item->decimals, true);

10625

break;

10626

case INT_RESULT:

10627

10628

Select an integer type with the minimal fit precision.

10629

MY_INT32_NUM_DECIMAL_DIGITS is sign inclusive, don't consider the sign.

10630

Values with MY_INT32_NUM_DECIMAL_DIGITS digits may or may not fit into

10631

Field_long : make them Field_int64_t.

10632

10633

if (item->max_length >= (MY_INT32_NUM_DECIMAL_DIGITS - 1))

10634

new_field=new Field_int64_t(item->max_length, maybe_null,

10635

item->name, item->unsigned_flag);

10636

else

10637

new_field=new Field_long(item->max_length, maybe_null,

10638

item->name, item->unsigned_flag);

10639

break;

10640

case STRING_RESULT:

10641

assert(item->collation.collation);

10642

10643

enum enum_field_types type;

10644

10645

DATE/TIME fields have STRING_RESULT result type.

10646

To preserve type they needed to be handled separately.

10647

10648

if ((type= item->field_type()) == DRIZZLE_TYPE_DATETIME ||

10649

type == DRIZZLE_TYPE_TIME || type == DRIZZLE_TYPE_NEWDATE ||

10650

type == DRIZZLE_TYPE_TIMESTAMP)

10651

new_field= item->tmp_table_field_from_field_type(table, 1);

10652

10653

Make sure that the blob fits into a Field_varstring which has

10654

2-byte lenght.

10655

10656

else if (item->max_length/item->collation.collation->mbmaxlen > 255 &&

10657

convert_blob_length <= Field_varstring::MAX_SIZE &&

10658

convert_blob_length)

10659

new_field= new Field_varstring(convert_blob_length, maybe_null,

10660

item->name, table->s,

10661

item->collation.collation);

10662

else

10663

new_field= item->make_string_field(table);

10664

new_field->set_derivation(item->collation.derivation);

10665

break;

10666

case DECIMAL_RESULT:

10667

{

10668

uint8_t dec= item->decimals;

10669

uint8_t intg= ((Item_decimal *) item)->decimal_precision() - dec;

10670

uint32_t len= item->max_length;

10671

10672

10673

Trying to put too many digits overall in a DECIMAL(prec,dec)

10674

will always throw a warning. We must limit dec to

10675

DECIMAL_MAX_SCALE however to prevent an assert() later.

10676

10677

10678

if (dec > 0)

10679

{

10680

signed int overflow;

10681

10682

dec= min(dec, (uint8_t)DECIMAL_MAX_SCALE);

10683

10684

10685

If the value still overflows the field with the corrected dec,

10686

we'll throw out decimals rather than integers. This is still

10687

bad and of course throws a truncation warning.

10688

+1: for decimal point

10689

10690

10691

overflow= my_decimal_precision_to_length(intg + dec, dec,

10692

item->unsigned_flag) - len;

10693

10694

if (overflow > 0)

10695

dec= max(0, dec - overflow); // too long, discard fract

10696

else

10697

len -= item->decimals - dec; // corrected value fits

10698

}

10699

10700

new_field= new Field_new_decimal(len, maybe_null, item->name,

10701

dec, item->unsigned_flag);

10702

break;

10703

}

10704

case ROW_RESULT:

10705

default:

10706

// This case should never be choosen

10707

assert(0);

10708

new_field= 0;

10709

break;

10710

}

10711

if (new_field)

10712

new_field->init(table);

10713

10714

if (copy_func && item->is_result_field())

10715

*((*copy_func)++) = item; // Save for copy_funcs

10716

if (modify_item)

10717

item->set_result_field(new_field);

10718

if (item->type() == Item::NULL_ITEM)

10719

new_field->is_created_from_null_item= true;

10720

return new_field;

10721

}

10722

10723

10724

/**

10725

Create field for information schema table.

10726

10727

@param thd Thread handler

10728

@param table Temporary table

10729

@param item Item to create a field for

10730

10731

@retval

10732

0 on error

10733

@retval

10734

new_created field

10735

10736

10737

Field *create_tmp_field_for_schema(THD *thd __attribute__((unused)),

10738

Item *item, TABLE *table)

10739

{

10740

if (item->field_type() == DRIZZLE_TYPE_VARCHAR)

10741

{

10742

Field *field;

10743

if (item->max_length > MAX_FIELD_VARCHARLENGTH)

10744

field= new Field_blob(item->max_length, item->maybe_null,

10745

item->name, item->collation.collation);

10746

else

10747

field= new Field_varstring(item->max_length, item->maybe_null,

10748

item->name,

10749

table->s, item->collation.collation);

10750

if (field)

10751

field->init(table);

10752

return field;

10753

}

10754

return item->tmp_table_field_from_field_type(table, 0);

10755

}

10756

10757

10758

/**

10759

Create field for temporary table.

10760

10761

@param thd Thread handler

10762

@param table Temporary table

10763

@param item Item to create a field for

10764

@param type Type of item (normally item->type)

10765

@param copy_func If set and item is a function, store copy of item

10766

in this array

10767

@param from_field if field will be created using other field as example,

10768

pointer example field will be written here

10769

@param default_field If field has a default value field, store it here

10770

@param group 1 if we are going to do a relative group by on result

10771

@param modify_item 1 if item->result_field should point to new item.

10772

This is relevent for how fill_record() is going to

10773

work:

10774

If modify_item is 1 then fill_record() will update

10775

the record in the original table.

10776

If modify_item is 0 then fill_record() will update

10777

the temporary table

10778

@param convert_blob_length If >0 create a varstring(convert_blob_length)

10779

field instead of blob.

10780

10781

@retval

10782

0 on error

10783

@retval

10784

new_created field

10785

10786

10787

Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,

10788

Item ***copy_func, Field **from_field,

10789

Field **default_field,

10790

bool group, bool modify_item,

10791

bool table_cant_handle_bit_fields __attribute__((unused)),

10792

bool make_copy_field,

10793

uint convert_blob_length)

10794

{

10795

Field *result;

10796

Item::Type orig_type= type;

10797

Item *orig_item= 0;

10798

10799

if (type != Item::FIELD_ITEM &&

10800

item->real_item()->type() == Item::FIELD_ITEM)

10801

{

10802

orig_item= item;

10803

item= item->real_item();

10804

type= Item::FIELD_ITEM;

10805

}

10806

10807

switch (type) {

10808

case Item::SUM_FUNC_ITEM:

10809

{

10810

Item_sum *item_sum=(Item_sum*) item;

10811

result= item_sum->create_tmp_field(group, table, convert_blob_length);

10812

if (!result)

10813

my_error(ER_OUT_OF_RESOURCES, MYF(ME_FATALERROR));

10814

return result;

10815

}

10816

case Item::FIELD_ITEM:

10817

case Item::DEFAULT_VALUE_ITEM:

10818

{

10819

Item_field *field= (Item_field*) item;

10820

bool orig_modify= modify_item;

10821

if (orig_type == Item::REF_ITEM)

10822

modify_item= 0;

10823

10824

If item have to be able to store NULLs but underlaid field can't do it,

10825

create_tmp_field_from_field() can't be used for tmp field creation.

10826

10827

if (field->maybe_null && !field->field->maybe_null())

10828

{

10829

result= create_tmp_field_from_item(thd, item, table, NULL,

10830

modify_item, convert_blob_length);

10831

*from_field= field->field;

10832

if (result && modify_item)

10833

field->result_field= result;

10834

}

10835

else

10836

result= create_tmp_field_from_field(thd, (*from_field= field->field),

10837

orig_item ? orig_item->name :

10838

item->name,

10839

table,

10840

modify_item ? field :

10841

NULL,

10842

convert_blob_length);

10843

if (orig_type == Item::REF_ITEM && orig_modify)

10844

((Item_ref*)orig_item)->set_result_field(result);

10845

if (field->field->eq_def(result))

10846

*default_field= field->field;

10847

return result;

10848

}

10849

/* Fall through */

10850

case Item::FUNC_ITEM:

10851

/* Fall through */

10852

case Item::COND_ITEM:

10853

case Item::FIELD_AVG_ITEM:

10854

case Item::FIELD_STD_ITEM:

10855

case Item::SUBSELECT_ITEM:

10856

/* The following can only happen with 'CREATE TABLE ... SELECT' */

10857

case Item::PROC_ITEM:

10858

case Item::INT_ITEM:

10859

case Item::REAL_ITEM:

10860

case Item::DECIMAL_ITEM:

10861

case Item::STRING_ITEM:

10862

case Item::REF_ITEM:

10863

case Item::NULL_ITEM:

10864

case Item::VARBIN_ITEM:

10865

if (make_copy_field)

10866

{

10867

assert(((Item_result_field*)item)->result_field);

10868

*from_field= ((Item_result_field*)item)->result_field;

10869

}

10870

return create_tmp_field_from_item(thd, item, table,

10871

(make_copy_field ? 0 : copy_func),

10872

modify_item, convert_blob_length);

10873

case Item::TYPE_HOLDER:

10874

result= ((Item_type_holder *)item)->make_field_by_type(table);

10875

result->set_derivation(item->collation.derivation);

10876

return result;

10877

default: // Dosen't have to be stored

10878

return 0;

10879

}

10880

}

10881

10882

10883

Set up column usage bitmaps for a temporary table

10884

10885

IMPLEMENTATION

10886

For temporary tables, we need one bitmap with all columns set and

10887

a tmp_set bitmap to be used by things like filesort.

10888

10889

10890

void setup_tmp_table_column_bitmaps(TABLE *table, uchar *bitmaps)

10891

{

10892

uint field_count= table->s->fields;

10893

bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,

10894

false);

10895

bitmap_init(&table->tmp_set,

10896

(my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)),

10897

field_count, false);

10898

/* write_set and all_set are copies of read_set */

10899

table->def_write_set= table->def_read_set;

10900

table->s->all_set= table->def_read_set;

10901

bitmap_set_all(&table->s->all_set);

10902

table->default_column_bitmaps();

10903

}

10904

10905

10906

/**

10907

Create a temp table according to a field list.

10908

10909

Given field pointers are changed to point at tmp_table for

10910

send_fields. The table object is self contained: it's

10911

allocated in its own memory root, as well as Field objects

10912

created for table columns.

10913

This function will replace Item_sum items in 'fields' list with

10914

corresponding Item_field items, pointing at the fields in the

10915

temporary table, unless this was prohibited by true

10916

value of argument save_sum_fields. The Item_field objects

10917

are created in THD memory root.

10918

10919

@param thd thread handle

10920

@param param a description used as input to create the table

10921

@param fields list of items that will be used to define

10922

column types of the table (also see NOTES)

10923

@param group TODO document

10924

@param distinct should table rows be distinct

10925

@param save_sum_fields see NOTES

10926

@param select_options

10927

@param rows_limit

10928

@param table_alias possible name of the temporary table that can

10929

be used for name resolving; can be "".

10930

10931

10932

#define STRING_TOTAL_LENGTH_TO_PACK_ROWS 128

10933

#define AVG_STRING_LENGTH_TO_PACK_ROWS 64

10934

#define RATIO_TO_PACK_ROWS 2

10935

#define MIN_STRING_LENGTH_TO_PACK_ROWS 10

10936

10937

TABLE *

10938

create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,

10939

ORDER *group, bool distinct, bool save_sum_fields,

10940

uint64_t select_options, ha_rows rows_limit,

10941

char *table_alias)

10942

{

10943

MEM_ROOT *mem_root_save, own_root;

10944

TABLE *table;

10945

TABLE_SHARE *share;

10946

uint i,field_count,null_count,null_pack_length;

10947

uint copy_func_count= param->func_count;

10948

uint hidden_null_count, hidden_null_pack_length, hidden_field_count;

10949

uint blob_count,group_null_items, string_count;

10950

uint temp_pool_slot=MY_BIT_NONE;

10951

uint fieldnr= 0;

10952

ulong reclength, string_total_length;

10953

bool using_unique_constraint= 0;

10954

bool use_packed_rows= 0;

10955

bool not_all_columns= !(select_options & TMP_TABLE_ALL_COLUMNS);

10956

char *tmpname,path[FN_REFLEN];

10957

uchar *pos, *group_buff, *bitmaps;

10958

uchar *null_flags;

10959

Field **reg_field, **from_field, **default_field;

10960

uint *blob_field;

10961

Copy_field *copy=0;

10962

KEY *keyinfo;

10963

KEY_PART_INFO *key_part_info;

10964

Item **copy_func;

10965

MI_COLUMNDEF *recinfo;

10966

uint total_uneven_bit_length= 0;

10967

bool force_copy_fields= param->force_copy_fields;

10968

10969

status_var_increment(thd->status_var.created_tmp_tables);

10970

10971

if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))

10972

temp_pool_slot = bitmap_lock_set_next(&temp_pool);

10973

10974

if (temp_pool_slot != MY_BIT_NONE) // we got a slot

10975

sprintf(path, "%s_%lx_%i", tmp_file_prefix,

10976

current_pid, temp_pool_slot);

10977

else

10978

{

10979

/* if we run out of slots or we are not using tempool */

10980

sprintf(path,"%s%lx_%lx_%x", tmp_file_prefix,current_pid,

10981

thd->thread_id, thd->tmp_table++);

10982

}

10983

10984

10985

No need to change table name to lower case as we are only creating

10986

MyISAM or HEAP tables here

10987

10988

fn_format(path, path, mysql_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);

10989

10990

10991

if (group)

10992

{

10993

if (!param->quick_group)

10994

group=0; // Can't use group key

10995

else for (ORDER *tmp=group ; tmp ; tmp=tmp->next)

10996

{

10997

10998

marker == 4 means two things:

10999

- store NULLs in the key, and

11000

- convert BIT fields to 64-bit long, needed because MEMORY tables

11001

can't index BIT fields.

11002

11003

(*tmp->item)->marker= 4;

11004

if ((*tmp->item)->max_length >= CONVERT_IF_BIGGER_TO_BLOB)

11005

using_unique_constraint=1;

11006

}

11007

if (param->group_length >= MAX_BLOB_WIDTH)

11008

using_unique_constraint=1;

11009

if (group)

11010

distinct=0; // Can't use distinct

11011

}

11012

11013

field_count=param->field_count+param->func_count+param->sum_func_count;

11014

hidden_field_count=param->hidden_field_count;

11015

11016

11017

When loose index scan is employed as access method, it already

11018

computes all groups and the result of all aggregate functions. We

11019

make space for the items of the aggregate function in the list of

11020

functions TMP_TABLE_PARAM::items_to_copy, so that the values of

11021

these items are stored in the temporary table.

11022

11023

if (param->precomputed_group_by)

11024

copy_func_count+= param->sum_func_count;

11025

11026

init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);

11027

11028

if (!multi_alloc_root(&own_root,

11029

&table, sizeof(*table),

11030

&share, sizeof(*share),

11031

&reg_field, sizeof(Field*) * (field_count+1),

11032

&default_field, sizeof(Field*) * (field_count),

11033

&blob_field, sizeof(uint)*(field_count+1),

11034

&from_field, sizeof(Field*)*field_count,

11035

&copy_func, sizeof(*copy_func)*(copy_func_count+1),

11036

&param->keyinfo, sizeof(*param->keyinfo),

11037

&key_part_info,

11038

sizeof(*key_part_info)*(param->group_parts+1),

11039

&param->start_recinfo,

11040

sizeof(*param->recinfo)*(field_count*2+4),

11041

&tmpname, (uint) strlen(path)+1,

11042

&group_buff, (group && ! using_unique_constraint ?

11043

param->group_length : 0),

11044

&bitmaps, bitmap_buffer_size(field_count)*2,

11045

NullS))

11046

{

11047

if (temp_pool_slot != MY_BIT_NONE)

11048

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

11049

return(NULL); /* purecov: inspected */

11050

}

11051

/* Copy_field belongs to TMP_TABLE_PARAM, allocate it in THD mem_root */

11052

if (!(param->copy_field= copy= new (thd->mem_root) Copy_field[field_count]))

11053

{

11054

if (temp_pool_slot != MY_BIT_NONE)

11055

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

11056

free_root(&own_root, MYF(0)); /* purecov: inspected */

11057

return(NULL); /* purecov: inspected */

11058

}

11059

param->items_to_copy= copy_func;

11060

stpcpy(tmpname,path);

11061

/* make table according to fields */

11062

11063

memset(table, 0, sizeof(*table));

11064

memset(reg_field, 0, sizeof(Field*)*(field_count+1));

11065

memset(default_field, 0, sizeof(Field*) * (field_count));

11066

memset(from_field, 0, sizeof(Field*)*field_count);

11067

11068

table->mem_root= own_root;

11069

mem_root_save= thd->mem_root;

11070

thd->mem_root= &table->mem_root;

11071

11072

table->field=reg_field;

11073

table->alias= table_alias;

11074

table->reginfo.lock_type=TL_WRITE; /* Will be updated */

11075

table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;

11076

table->map=1;

11077

table->temp_pool_slot = temp_pool_slot;

11078

table->copy_blobs= 1;

11079

table->in_use= thd;

11080

table->quick_keys.init();

11081

table->covering_keys.init();

11082

table->keys_in_use_for_query.init();

11083

11084

table->s= share;

11085

init_tmp_table_share(thd, share, "", 0, tmpname, tmpname);

11086

share->blob_field= blob_field;

11087

share->blob_ptr_size= portable_sizeof_char_ptr;

11088

share->db_low_byte_first=1; // True for HEAP and MyISAM

11089

share->table_charset= param->table_charset;

11090

share->primary_key= MAX_KEY; // Indicate no primary key

11091

share->keys_for_keyread.init();

11092

share->keys_in_use.init();

11093

11094

/* Calculate which type of fields we will store in the temporary table */

11095

11096

reclength= string_total_length= 0;

11097

blob_count= string_count= null_count= hidden_null_count= group_null_items= 0;

11098

param->using_indirect_summary_function=0;

11099

11100

List_iterator_fast<Item> li(fields);

11101

Item *item;

11102

Field **tmp_from_field=from_field;

11103

while ((item=li++))

11104

{

11105

Item::Type type=item->type();

11106

if (not_all_columns)

11107

{

11108

if (item->with_sum_func && type != Item::SUM_FUNC_ITEM)

11109

{

11110

if (item->used_tables() & OUTER_REF_TABLE_BIT)

11111

item->update_used_tables();

11112

if (type == Item::SUBSELECT_ITEM ||

11113

(item->used_tables() & ~OUTER_REF_TABLE_BIT))

11114

{

11115

11116

Mark that the we have ignored an item that refers to a summary

11117

function. We need to know this if someone is going to use

11118

DISTINCT on the result.

11119

11120

param->using_indirect_summary_function=1;

11121

continue;

11122

}

11123

}

11124

if (item->const_item() && (int) hidden_field_count <= 0)

11125

continue; // We don't have to store this

11126

}

11127

if (type == Item::SUM_FUNC_ITEM && !group && !save_sum_fields)

11128

{ /* Can't calc group yet */

11129

((Item_sum*) item)->result_field=0;

11130

for (i=0 ; i < ((Item_sum*) item)->arg_count ; i++)

11131

{

11132

Item **argp= ((Item_sum*) item)->args + i;

11133

Item *arg= *argp;

11134

if (!arg->const_item())

11135

{

11136

Field *new_field=

11137

create_tmp_field(thd, table, arg, arg->type(), &copy_func,

11138

tmp_from_field, &default_field[fieldnr],

11139

group != 0,not_all_columns,

11140

distinct, 0,

11141

param->convert_blob_length);

11142

if (!new_field)

11143

goto err; // Should be OOM

11144

tmp_from_field++;

11145

reclength+=new_field->pack_length();

11146

if (new_field->flags & BLOB_FLAG)

11147

{

11148

*blob_field++= fieldnr;

11149

blob_count++;

11150

}

11151

*(reg_field++)= new_field;

11152

if (new_field->real_type() == DRIZZLE_TYPE_VARCHAR)

11153

{

11154

string_count++;

11155

string_total_length+= new_field->pack_length();

11156

}

11157

thd->mem_root= mem_root_save;

11158

thd->change_item_tree(argp, new Item_field(new_field));

11159

thd->mem_root= &table->mem_root;

11160

if (!(new_field->flags & NOT_NULL_FLAG))

11161

{

11162

null_count++;

11163

11164

new_field->maybe_null() is still false, it will be

11165

changed below. But we have to setup Item_field correctly

11166

11167

(*argp)->maybe_null=1;

11168

}

11169

new_field->field_index= fieldnr++;

11170

}

11171

}

11172

}

11173

else

11174

{

11175

11176

The last parameter to create_tmp_field() is a bit tricky:

11177

11178

We need to set it to 0 in union, to get fill_record() to modify the

11179

temporary table.

11180

We need to set it to 1 on multi-table-update and in select to

11181

write rows to the temporary table.

11182

We here distinguish between UNION and multi-table-updates by the fact

11183

that in the later case group is set to the row pointer.

11184

11185

Field *new_field= (param->schema_table) ?

11186

create_tmp_field_for_schema(thd, item, table) :

11187

create_tmp_field(thd, table, item, type, &copy_func,

11188

tmp_from_field, &default_field[fieldnr],

11189

group != 0,

11190

!force_copy_fields &&

11191

(not_all_columns || group !=0),

11192

11193

If item->marker == 4 then we force create_tmp_field

11194

to create a 64-bit longs for BIT fields because HEAP

11195

tables can't index BIT fields directly. We do the same

11196

for distinct, as we want the distinct index to be

11197

usable in this case too.

11198

11199

item->marker == 4 || param->bit_fields_as_long,

11200

force_copy_fields,

11201

param->convert_blob_length);

11202

11203

if (!new_field)

11204

{

11205

if (thd->is_fatal_error)

11206

goto err; // Got OOM

11207

continue; // Some kindf of const item

11208

}

11209

if (type == Item::SUM_FUNC_ITEM)

11210

((Item_sum *) item)->result_field= new_field;

11211

tmp_from_field++;

11212

reclength+=new_field->pack_length();

11213

if (!(new_field->flags & NOT_NULL_FLAG))

11214

null_count++;

11215

if (new_field->flags & BLOB_FLAG)

11216

{

11217

*blob_field++= fieldnr;

11218

blob_count++;

11219

}

11220

if (item->marker == 4 && item->maybe_null)

11221

{

11222

group_null_items++;

11223

new_field->flags|= GROUP_FLAG;

11224

}

11225

new_field->field_index= fieldnr++;

11226

*(reg_field++)= new_field;

11227

}

11228

if (!--hidden_field_count)

11229

{

11230

11231

This was the last hidden field; Remember how many hidden fields could

11232

have null

11233

11234

hidden_null_count=null_count;

11235

11236

We need to update hidden_field_count as we may have stored group

11237

functions with constant arguments

11238

11239

param->hidden_field_count= fieldnr;

11240

null_count= 0;

11241

}

11242

}

11243

assert(fieldnr == (uint) (reg_field - table->field));

11244

assert(field_count >= (uint) (reg_field - table->field));

11245

field_count= fieldnr;

11246

*reg_field= 0;

11247

*blob_field= 0; // End marker

11248

share->fields= field_count;

11249

11250

/* If result table is small; use a heap */

11251

/* future: storage engine selection can be made dynamic? */

11252

if (blob_count || using_unique_constraint ||

11253

(select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==

11254

OPTION_BIG_TABLES || (select_options & TMP_TABLE_FORCE_MYISAM))

11255

{

11256

share->db_plugin= ha_lock_engine(0, myisam_hton);

11257

table->file= get_new_handler(share, &table->mem_root,

11258

share->db_type());

11259

if (group &&

11260

(param->group_parts > table->file->max_key_parts() ||

11261

param->group_length > table->file->max_key_length()))

11262

using_unique_constraint=1;

11263

}

11264

else

11265

{

11266

share->db_plugin= ha_lock_engine(0, heap_hton);

11267

table->file= get_new_handler(share, &table->mem_root,

11268

share->db_type());

11269

}

11270

if (!table->file)

11271

goto err;

11272

11273

11274

if (!using_unique_constraint)

11275

reclength+= group_null_items; // null flag is stored separately

11276

11277

share->blob_fields= blob_count;

11278

if (blob_count == 0)

11279

{

11280

/* We need to ensure that first byte is not 0 for the delete link */

11281

if (param->hidden_field_count)

11282

hidden_null_count++;

11283

else

11284

null_count++;

11285

}

11286

hidden_null_pack_length=(hidden_null_count+7)/8;

11287

null_pack_length= (hidden_null_pack_length +

11288

(null_count + total_uneven_bit_length + 7) / 8);

11289

reclength+=null_pack_length;

11290

if (!reclength)

11291

reclength=1; // Dummy select

11292

/* Use packed rows if there is blobs or a lot of space to gain */

11293

if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))

11294

use_packed_rows= 1;

11295

11296

share->reclength= reclength;

11297

{

11298

uint alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);

11299

share->rec_buff_length= alloc_length;

11300

if (!(table->record[0]= (uchar*)

11301

alloc_root(&table->mem_root, alloc_length*3)))

11302

goto err;

11303

table->record[1]= table->record[0]+alloc_length;

11304

share->default_values= table->record[1]+alloc_length;

11305

}

11306

copy_func[0]=0; // End marker

11307

param->func_count= copy_func - param->items_to_copy;

11308

11309

setup_tmp_table_column_bitmaps(table, bitmaps);

11310

11311

recinfo=param->start_recinfo;

11312

null_flags=(uchar*) table->record[0];

11313

pos=table->record[0]+ null_pack_length;

11314

if (null_pack_length)

11315

{

11316

memset(recinfo, 0, sizeof(*recinfo));

11317

recinfo->type=FIELD_NORMAL;

11318

recinfo->length=null_pack_length;

11319

recinfo++;

11320

memset(null_flags, 255, null_pack_length); // Set null fields

11321

11322

table->null_flags= (uchar*) table->record[0];

11323

share->null_fields= null_count+ hidden_null_count;

11324

share->null_bytes= null_pack_length;

11325

}

11326

null_count= (blob_count == 0) ? 1 : 0;

11327

hidden_field_count=param->hidden_field_count;

11328

for (i=0,reg_field=table->field; i < field_count; i++,reg_field++,recinfo++)

11329

{

11330

Field *field= *reg_field;

11331

uint length;

11332

memset(recinfo, 0, sizeof(*recinfo));

11333

11334

if (!(field->flags & NOT_NULL_FLAG))

11335

{

11336

if (field->flags & GROUP_FLAG && !using_unique_constraint)

11337

{

11338

11339

We have to reserve one byte here for NULL bits,

11340

as this is updated by 'end_update()'

11341

11342

*pos++=0; // Null is stored here

11343

recinfo->length=1;

11344

recinfo->type=FIELD_NORMAL;

11345

recinfo++;

11346

memset(recinfo, 0, sizeof(*recinfo));

11347

}

11348

else

11349

{

11350

recinfo->null_bit= 1 << (null_count & 7);

11351

recinfo->null_pos= null_count/8;

11352

}

11353

field->move_field(pos,null_flags+null_count/8,

11354

1 << (null_count & 7));

11355

null_count++;

11356

}

11357

else

11358

field->move_field(pos,(uchar*) 0,0);

11359

field->reset();

11360

11361

11362

Test if there is a default field value. The test for ->ptr is to skip

11363

'offset' fields generated by initalize_tables

11364

11365

if (default_field[i] && default_field[i]->ptr)

11366

{

11367

11368

default_field[i] is set only in the cases when 'field' can

11369

inherit the default value that is defined for the field referred

11370

by the Item_field object from which 'field' has been created.

11371

11372

my_ptrdiff_t diff;

11373

Field *orig_field= default_field[i];

11374

/* Get the value from default_values */

11375

diff= (my_ptrdiff_t) (orig_field->table->s->default_values-

11376

orig_field->table->record[0]);

11377

orig_field->move_field_offset(diff); // Points now at default_values

11378

if (orig_field->is_real_null())

11379

field->set_null();

11380

else

11381

{

11382

field->set_notnull();

11383

memcpy(field->ptr, orig_field->ptr, field->pack_length());

11384

}

11385

orig_field->move_field_offset(-diff); // Back to record[0]

11386

}

11387

11388

if (from_field[i])

11389

{ /* Not a table Item */

11390

copy->set(field,from_field[i],save_sum_fields);

11391

copy++;

11392

}

11393

length=field->pack_length();

11394

pos+= length;

11395

11396

/* Make entry for create table */

11397

recinfo->length=length;

11398

if (field->flags & BLOB_FLAG)

11399

recinfo->type= (int) FIELD_BLOB;

11400

else

11401

recinfo->type=FIELD_NORMAL;

11402

if (!--hidden_field_count)

11403

null_count=(null_count+7) & ~7; // move to next byte

11404

11405

// fix table name in field entry

11406

field->table_name= &table->alias;

11407

}

11408

11409

param->copy_field_end=copy;

11410

param->recinfo=recinfo;

11411

store_record(table,s->default_values); // Make empty default record

11412

11413

if (thd->variables.tmp_table_size == ~ (uint64_t) 0) // No limit

11414

share->max_rows= ~(ha_rows) 0;

11415

else

11416

share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?

11417

min(thd->variables.tmp_table_size,

11418

thd->variables.max_heap_table_size) :

11419

thd->variables.tmp_table_size) /

11420

share->reclength);

11421

set_if_bigger(share->max_rows,1); // For dummy start options

11422

11423

Push the LIMIT clause to the temporary table creation, so that we

11424

materialize only up to 'rows_limit' records instead of all result records.

11425

11426

set_if_smaller(share->max_rows, rows_limit);

11427

param->end_write_records= rows_limit;

11428

11429

keyinfo= param->keyinfo;

11430

11431

if (group)

11432

{

11433

table->group=group; /* Table is grouped by key */

11434

param->group_buff=group_buff;

11435

share->keys=1;

11436

share->uniques= test(using_unique_constraint);

11437

table->key_info=keyinfo;

11438

keyinfo->key_part=key_part_info;

11439

keyinfo->flags=HA_NOSAME;

11440

keyinfo->usable_key_parts=keyinfo->key_parts= param->group_parts;

11441

keyinfo->key_length=0;

11442

keyinfo->rec_per_key=0;

11443

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

11444

keyinfo->name= (char*) "group_key";

11445

ORDER *cur_group= group;

11446

for (; cur_group ; cur_group= cur_group->next, key_part_info++)

11447

{

11448

Field *field=(*cur_group->item)->get_tmp_table_field();

11449

bool maybe_null=(*cur_group->item)->maybe_null;

11450

key_part_info->null_bit=0;

11451

key_part_info->field= field;

11452

key_part_info->offset= field->offset(table->record[0]);

11453

key_part_info->length= (uint16_t) field->key_length();

11454

key_part_info->type= (uint8_t) field->key_type();

11455

key_part_info->key_type =

11456

((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||

11457

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||

11458

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?

11459

0 : FIELDFLAG_BINARY;

11460

if (!using_unique_constraint)

11461

{

11462

cur_group->buff=(char*) group_buff;

11463

if (!(cur_group->field= field->new_key_field(thd->mem_root,table,

11464

group_buff +

11465

test(maybe_null),

11466

field->null_ptr,

11467

field->null_bit)))

11468

goto err; /* purecov: inspected */

11469

if (maybe_null)

11470

{

11471

11472

To be able to group on NULL, we reserved place in group_buff

11473

for the NULL flag just before the column. (see above).

11474

The field data is after this flag.

11475

The NULL flag is updated in 'end_update()' and 'end_write()'

11476

11477

keyinfo->flags|= HA_NULL_ARE_EQUAL; // def. that NULL == NULL

11478

key_part_info->null_bit=field->null_bit;

11479

key_part_info->null_offset= (uint) (field->null_ptr -

11480

(uchar*) table->record[0]);

11481

cur_group->buff++; // Pointer to field data

11482

group_buff++; // Skipp null flag

11483

}

11484

/* In GROUP BY 'a' and 'a ' are equal for VARCHAR fields */

11485

key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL;

11486

group_buff+= cur_group->field->pack_length();

11487

}

11488

keyinfo->key_length+= key_part_info->length;

11489

}

11490

}

11491

11492

if (distinct && field_count != param->hidden_field_count)

11493

{

11494

11495

Create an unique key or an unique constraint over all columns

11496

that should be in the result. In the temporary table, there are

11497

'param->hidden_field_count' extra columns, whose null bits are stored

11498

in the first 'hidden_null_pack_length' bytes of the row.

11499

11500

if (blob_count)

11501

{

11502

11503

Special mode for index creation in MyISAM used to support unique

11504

indexes on blobs with arbitrary length. Such indexes cannot be

11505

used for lookups.

11506

11507

share->uniques= 1;

11508

}

11509

null_pack_length-=hidden_null_pack_length;

11510

keyinfo->key_parts= ((field_count-param->hidden_field_count)+

11511

(share->uniques ? test(null_pack_length) : 0));

11512

table->distinct= 1;

11513

share->keys= 1;

11514

if (!(key_part_info= (KEY_PART_INFO*)

11515

alloc_root(&table->mem_root,

11516

keyinfo->key_parts * sizeof(KEY_PART_INFO))))

11517

goto err;

11518

memset(key_part_info, 0, keyinfo->key_parts * sizeof(KEY_PART_INFO));

11519

table->key_info=keyinfo;

11520

keyinfo->key_part=key_part_info;

11521

keyinfo->flags=HA_NOSAME | HA_NULL_ARE_EQUAL;

11522

keyinfo->key_length=(uint16_t) reclength;

11523

keyinfo->name= (char*) "distinct_key";

11524

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

11525

keyinfo->rec_per_key=0;

11526

11527

11528

Create an extra field to hold NULL bits so that unique indexes on

11529

blobs can distinguish NULL from 0. This extra field is not needed

11530

when we do not use UNIQUE indexes for blobs.

11531

11532

if (null_pack_length && share->uniques)

11533

{

11534

key_part_info->null_bit=0;

11535

key_part_info->offset=hidden_null_pack_length;

11536

key_part_info->length=null_pack_length;

11537

key_part_info->field= new Field_varstring(table->record[0],

11538

(uint32_t) key_part_info->length,

11539

11540

(uchar*) 0,

11541

(uint) 0,

11542

Field::NONE,

11543

NullS,

11544

table->s,

11545

&my_charset_bin);

11546

if (!key_part_info->field)

11547

goto err;

11548

key_part_info->field->init(table);

11549

key_part_info->key_type=FIELDFLAG_BINARY;

11550

key_part_info->type= HA_KEYTYPE_BINARY;

11551

key_part_info++;

11552

}

11553

/* Create a distinct key over the columns we are going to return */

11554

for (i=param->hidden_field_count, reg_field=table->field + i ;

11555

i < field_count;

11556

i++, reg_field++, key_part_info++)

11557

{

11558

key_part_info->null_bit=0;

11559

key_part_info->field= *reg_field;

11560

key_part_info->offset= (*reg_field)->offset(table->record[0]);

11561

key_part_info->length= (uint16_t) (*reg_field)->pack_length();

11562

/* TODO:

11563

The below method of computing the key format length of the

11564

key part is a copy/paste from opt_range.cc, and table.cc.

11565

This should be factored out, e.g. as a method of Field.

11566

In addition it is not clear if any of the Field::*_length

11567

methods is supposed to compute the same length. If so, it

11568

might be reused.

11569

11570

key_part_info->store_length= key_part_info->length;

11571

11572

if ((*reg_field)->real_maybe_null())

11573

key_part_info->store_length+= HA_KEY_NULL_LENGTH;

11574

if ((*reg_field)->type() == DRIZZLE_TYPE_BLOB ||

11575

(*reg_field)->real_type() == DRIZZLE_TYPE_VARCHAR)

11576

key_part_info->store_length+= HA_KEY_BLOB_LENGTH;

11577

11578

key_part_info->type= (uint8_t) (*reg_field)->key_type();

11579

key_part_info->key_type =

11580

((ha_base_keytype) key_part_info->type == HA_KEYTYPE_TEXT ||

11581

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT1 ||

11582

(ha_base_keytype) key_part_info->type == HA_KEYTYPE_VARTEXT2) ?

11583

0 : FIELDFLAG_BINARY;

11584

}

11585

}

11586

11587

if (thd->is_fatal_error) // If end of memory

11588

goto err; /* purecov: inspected */

11589

share->db_record_offset= 1;

11590

if (share->db_type() == myisam_hton)

11591

{

11592

if (create_myisam_tmp_table(table, param->keyinfo, param->start_recinfo,

11593

&param->recinfo, select_options))

11594

goto err;

11595

}

11596

if (open_tmp_table(table))

11597

goto err;

11598

11599

thd->mem_root= mem_root_save;

11600

11601

return(table);

11602

11603

err:

11604

thd->mem_root= mem_root_save;

11605

free_tmp_table(thd,table); /* purecov: inspected */

11606

if (temp_pool_slot != MY_BIT_NONE)

11607

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

11608

return(NULL); /* purecov: inspected */

11609

}

11610

11611

11612

11613

11614

11615

Create a temporary table to weed out duplicate rowid combinations

11616

11617

SYNOPSIS

11618

11619

create_duplicate_weedout_tmp_table()

11620

thd

11621

uniq_tuple_length_arg

11622

SJ_TMP_TABLE

11623

11624

DESCRIPTION

11625

Create a temporary table to weed out duplicate rowid combinations. The

11626

table has a single column that is a concatenation of all rowids in the

11627

combination.

11628

11629

Depending on the needed length, there are two cases:

11630

11631

1. When the length of the column < max_key_length:

11632

11633

CREATE TABLE tmp (col VARBINARY(n) NOT NULL, UNIQUE KEY(col));

11634

11635

2. Otherwise (not a valid SQL syntax but internally supported):

11636

11637

CREATE TABLE tmp (col VARBINARY NOT NULL, UNIQUE CONSTRAINT(col));

11638

11639

The code in this function was produced by extraction of relevant parts

11640

from create_tmp_table().

11641

11642

RETURN

11643

created table

11644

NULL on error

11645

11646

11647

TABLE *create_duplicate_weedout_tmp_table(THD *thd,

11648

uint uniq_tuple_length_arg,

11649

SJ_TMP_TABLE *sjtbl)

11650

{

11651

MEM_ROOT *mem_root_save, own_root;

11652

TABLE *table;

11653

TABLE_SHARE *share;

11654

uint temp_pool_slot=MY_BIT_NONE;

11655

char *tmpname,path[FN_REFLEN];

11656

Field **reg_field;

11657

KEY_PART_INFO *key_part_info;

11658

KEY *keyinfo;

11659

uchar *group_buff;

11660

uchar *bitmaps;

11661

uint *blob_field;

11662

MI_COLUMNDEF *recinfo, *start_recinfo;

11663

bool using_unique_constraint=false;

11664

Field *field, *key_field;

11665

uint blob_count, null_pack_length, null_count;

11666

uchar *null_flags;

11667

uchar *pos;

11668

11669

11670

STEP 1: Get temporary table name

11671

11672

statistic_increment(thd->status_var.created_tmp_tables, &LOCK_status);

11673

if (use_temp_pool && !(test_flags & TEST_KEEP_TMP_TABLES))

11674

temp_pool_slot = bitmap_lock_set_next(&temp_pool);

11675

11676

if (temp_pool_slot != MY_BIT_NONE) // we got a slot

11677

sprintf(path, "%s_%lx_%i", tmp_file_prefix,

11678

current_pid, temp_pool_slot);

11679

else

11680

{

11681

/* if we run out of slots or we are not using tempool */

11682

sprintf(path,"%s%lx_%lx_%x", tmp_file_prefix,current_pid,

11683

thd->thread_id, thd->tmp_table++);

11684

}

11685

fn_format(path, path, mysql_tmpdir, "", MY_REPLACE_EXT|MY_UNPACK_FILENAME);

11686

11687

/* STEP 2: Figure if we'll be using a key or blob+constraint */

11688

if (uniq_tuple_length_arg >= CONVERT_IF_BIGGER_TO_BLOB)

11689

using_unique_constraint= true;

11690

11691

/* STEP 3: Allocate memory for temptable description */

11692

init_sql_alloc(&own_root, TABLE_ALLOC_BLOCK_SIZE, 0);

11693

if (!multi_alloc_root(&own_root,

11694

&table, sizeof(*table),

11695

&share, sizeof(*share),

11696

&reg_field, sizeof(Field*) * (1+1),

11697

&blob_field, sizeof(uint)*2,

11698

&keyinfo, sizeof(*keyinfo),

11699

&key_part_info, sizeof(*key_part_info) * 2,

11700

&start_recinfo,

11701

sizeof(*recinfo)*(1*2+4),

11702

&tmpname, (uint) strlen(path)+1,

11703

&group_buff, (!using_unique_constraint ?

11704

uniq_tuple_length_arg : 0),

11705

&bitmaps, bitmap_buffer_size(1)*2,

11706

NullS))

11707

{

11708

if (temp_pool_slot != MY_BIT_NONE)

11709

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

11710

return(NULL);

11711

}

11712

stpcpy(tmpname,path);

11713

11714

11715

/* STEP 4: Create TABLE description */

11716

memset(table, 0, sizeof(*table));

11717

memset(reg_field, 0, sizeof(Field*)*2);

11718

11719

table->mem_root= own_root;

11720

mem_root_save= thd->mem_root;

11721

thd->mem_root= &table->mem_root;

11722

11723

table->field=reg_field;

11724

table->alias= "weedout-tmp";

11725

table->reginfo.lock_type=TL_WRITE; /* Will be updated */

11726

table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;

11727

table->map=1;

11728

table->temp_pool_slot = temp_pool_slot;

11729

table->copy_blobs= 1;

11730

table->in_use= thd;

11731

table->quick_keys.init();

11732

table->covering_keys.init();

11733

table->keys_in_use_for_query.init();

11734

11735

table->s= share;

11736

init_tmp_table_share(thd, share, "", 0, tmpname, tmpname);

11737

share->blob_field= blob_field;

11738

share->blob_ptr_size= portable_sizeof_char_ptr;

11739

share->db_low_byte_first=1; // True for HEAP and MyISAM

11740

share->table_charset= NULL;

11741

share->primary_key= MAX_KEY; // Indicate no primary key

11742

share->keys_for_keyread.init();

11743

share->keys_in_use.init();

11744

11745

blob_count= 0;

11746

11747

/* Create the field */

11748

{

11749

11750

For the sake of uniformity, always use Field_varstring.

11751

11752

field= new Field_varstring(uniq_tuple_length_arg, false, "rowids", share,

11753

&my_charset_bin);

11754

if (!field)

11755

return(0);

11756

field->table= table;

11757

field->key_start.init(0);

11758

field->part_of_key.init(0);

11759

field->part_of_sortkey.init(0);

11760

field->unireg_check= Field::NONE;

11761

field->flags= (NOT_NULL_FLAG | BINARY_FLAG | NO_DEFAULT_VALUE_FLAG);

11762

field->reset_fields();

11763

field->init(table);

11764

field->orig_table= NULL;

11765

11766

field->field_index= 0;

11767

11768

*(reg_field++)= field;

11769

*blob_field= 0;

11770

*reg_field= 0;

11771

11772

share->fields= 1;

11773

share->blob_fields= 0;

11774

}

11775

11776

uint reclength= field->pack_length();

11777

if (using_unique_constraint)

11778

{

11779

share->db_plugin= ha_lock_engine(0, myisam_hton);

11780

table->file= get_new_handler(share, &table->mem_root,

11781

share->db_type());

11782

assert(uniq_tuple_length_arg <= table->file->max_key_length());

11783

}

11784

else

11785

{

11786

share->db_plugin= ha_lock_engine(0, heap_hton);

11787

table->file= get_new_handler(share, &table->mem_root,

11788

share->db_type());

11789

}

11790

if (!table->file)

11791

goto err;

11792

11793

null_count=1;

11794

11795

null_pack_length= 1;

11796

reclength += null_pack_length;

11797

11798

share->reclength= reclength;

11799

{

11800

uint alloc_length=ALIGN_SIZE(share->reclength + MI_UNIQUE_HASH_LENGTH+1);

11801

share->rec_buff_length= alloc_length;

11802

if (!(table->record[0]= (uchar*)

11803

alloc_root(&table->mem_root, alloc_length*3)))

11804

goto err;

11805

table->record[1]= table->record[0]+alloc_length;

11806

share->default_values= table->record[1]+alloc_length;

11807

}

11808

setup_tmp_table_column_bitmaps(table, bitmaps);

11809

11810

recinfo= start_recinfo;

11811

null_flags=(uchar*) table->record[0];

11812

pos=table->record[0]+ null_pack_length;

11813

if (null_pack_length)

11814

{

11815

memset(recinfo, 0, sizeof(*recinfo));

11816

recinfo->type=FIELD_NORMAL;

11817

recinfo->length=null_pack_length;

11818

recinfo++;

11819

memset(null_flags, 255, null_pack_length); // Set null fields

11820

11821

table->null_flags= (uchar*) table->record[0];

11822

share->null_fields= null_count;

11823

share->null_bytes= null_pack_length;

11824

}

11825

null_count=1;

11826

11827

{

11828

//Field *field= *reg_field;

11829

uint length;

11830

memset(recinfo, 0, sizeof(*recinfo));

11831

field->move_field(pos,(uchar*) 0,0);

11832

11833

field->reset();

11834

11835

Test if there is a default field value. The test for ->ptr is to skip

11836

'offset' fields generated by initalize_tables

11837

11838

// Initialize the table field:

11839

memset(field->ptr, 0, field->pack_length());

11840

11841

length=field->pack_length();

11842

pos+= length;

11843

11844

/* Make entry for create table */

11845

recinfo->length=length;

11846

if (field->flags & BLOB_FLAG)

11847

recinfo->type= (int) FIELD_BLOB;

11848

else

11849

recinfo->type=FIELD_NORMAL;

11850

11851

field->table_name= &table->alias;

11852

}

11853

11854

//param->recinfo=recinfo;

11855

//store_record(table,s->default_values); // Make empty default record

11856

11857

if (thd->variables.tmp_table_size == ~ (uint64_t) 0) // No limit

11858

share->max_rows= ~(ha_rows) 0;

11859

else

11860

share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?

11861

min(thd->variables.tmp_table_size,

11862

thd->variables.max_heap_table_size) :

11863

thd->variables.tmp_table_size) /

11864

share->reclength);

11865

set_if_bigger(share->max_rows,1); // For dummy start options

11866

11867

11868

//// keyinfo= param->keyinfo;

11869

if (true)

11870

{

11871

share->keys=1;

11872

share->uniques= test(using_unique_constraint);

11873

table->key_info=keyinfo;

11874

keyinfo->key_part=key_part_info;

11875

keyinfo->flags=HA_NOSAME;

11876

keyinfo->usable_key_parts= keyinfo->key_parts= 1;

11877

keyinfo->key_length=0;

11878

keyinfo->rec_per_key=0;

11879

keyinfo->algorithm= HA_KEY_ALG_UNDEF;

11880

keyinfo->name= (char*) "weedout_key";

11881

{

11882

key_part_info->null_bit=0;

11883

key_part_info->field= field;

11884

key_part_info->offset= field->offset(table->record[0]);

11885

key_part_info->length= (uint16_t) field->key_length();

11886

key_part_info->type= (uint8_t) field->key_type();

11887

key_part_info->key_type = FIELDFLAG_BINARY;

11888

if (!using_unique_constraint)

11889

{

11890

if (!(key_field= field->new_key_field(thd->mem_root, table,

11891

group_buff,

11892

field->null_ptr,

11893

field->null_bit)))

11894

goto err;

11895

key_part_info->key_part_flag|= HA_END_SPACE_ARE_EQUAL; //todo need this?

11896

}

11897

keyinfo->key_length+= key_part_info->length;

11898

}

11899

}

11900

11901

if (thd->is_fatal_error) // If end of memory

11902

goto err;

11903

share->db_record_offset= 1;

11904

if (share->db_type() == myisam_hton)

11905

{

11906

recinfo++;

11907

if (create_myisam_tmp_table(table, keyinfo, start_recinfo, &recinfo, 0))

11908

goto err;

11909

}

11910

sjtbl->start_recinfo= start_recinfo;

11911

sjtbl->recinfo= recinfo;

11912

if (open_tmp_table(table))

11913

goto err;

11914

11915

thd->mem_root= mem_root_save;

11916

return(table);

11917

11918

err:

11919

thd->mem_root= mem_root_save;

11920

free_tmp_table(thd,table); /* purecov: inspected */

11921

if (temp_pool_slot != MY_BIT_NONE)

11922

bitmap_lock_clear_bit(&temp_pool, temp_pool_slot);

11923

return(NULL); /* purecov: inspected */

11924

}

11925

11926

/****************************************************************************/

11927

11928

/**

11929

Create a reduced TABLE object with properly set up Field list from a

11930

list of field definitions.

11931

11932

The created table doesn't have a table handler associated with

11933

it, has no keys, no group/distinct, no copy_funcs array.

11934

The sole purpose of this TABLE object is to use the power of Field

11935

class to read/write data to/from table->record[0]. Then one can store

11936

the record in any container (RB tree, hash, etc).

11937

The table is created in THD mem_root, so are the table's fields.

11938

Consequently, if you don't BLOB fields, you don't need to free it.

11939

11940

@param thd connection handle

11941

@param field_list list of column definitions

11942

11943

@return

11944

0 if out of memory, TABLE object in case of success

11945

11946

11947

TABLE *create_virtual_tmp_table(THD *thd, List<Create_field> &field_list)

11948

{

11949

uint field_count= field_list.elements;

11950

uint blob_count= 0;

11951

Field **field;

11952

Create_field *cdef; /* column definition */

11953

uint record_length= 0;

11954

uint null_count= 0; /* number of columns which may be null */

11955

uint null_pack_length; /* NULL representation array length */

11956

uint *blob_field;

11957

uchar *bitmaps;

11958

TABLE *table;

11959

TABLE_SHARE *share;

11960

11961

if (!multi_alloc_root(thd->mem_root,

11962

&table, sizeof(*table),

11963

&share, sizeof(*share),

11964

&field, (field_count + 1) * sizeof(Field*),

11965

&blob_field, (field_count+1) *sizeof(uint),

11966

&bitmaps, bitmap_buffer_size(field_count)*2,

11967

NullS))

11968

return 0;

11969

11970

memset(table, 0, sizeof(*table));

11971

memset(share, 0, sizeof(*share));

11972

table->field= field;

11973

table->s= share;

11974

share->blob_field= blob_field;

11975

share->fields= field_count;

11976

share->blob_ptr_size= portable_sizeof_char_ptr;

11977

setup_tmp_table_column_bitmaps(table, bitmaps);

11978

11979

/* Create all fields and calculate the total length of record */

11980

List_iterator_fast<Create_field> it(field_list);

11981

while ((cdef= it++))

11982

{

11983

*field= make_field(share, 0, cdef->length,

11984

(uchar*) (f_maybe_null(cdef->pack_flag) ? "" : 0),

11985

f_maybe_null(cdef->pack_flag) ? 1 : 0,

11986

cdef->pack_flag, cdef->sql_type, cdef->charset,

11987

cdef->unireg_check,

11988

cdef->interval, cdef->field_name);

11989

if (!*field)

11990

goto error;

11991

(*field)->init(table);

11992

record_length+= (*field)->pack_length();

11993

if (! ((*field)->flags & NOT_NULL_FLAG))

11994

null_count++;

11995

11996

if ((*field)->flags & BLOB_FLAG)

11997

share->blob_field[blob_count++]= (uint) (field - table->field);

11998

11999

field++;

12000

}

12001

*field= NULL; /* mark the end of the list */

12002

share->blob_field[blob_count]= 0; /* mark the end of the list */

12003

share->blob_fields= blob_count;

12004

12005

null_pack_length= (null_count + 7)/8;

12006

share->reclength= record_length + null_pack_length;

12007

share->rec_buff_length= ALIGN_SIZE(share->reclength + 1);

12008

table->record[0]= (uchar*) thd->alloc(share->rec_buff_length);

12009

if (!table->record[0])

12010

goto error;

12011

12012

if (null_pack_length)

12013

{

12014

table->null_flags= (uchar*) table->record[0];

12015

share->null_fields= null_count;

12016

share->null_bytes= null_pack_length;

12017

}

12018

12019

table->in_use= thd; /* field->reset() may access table->in_use */

12020

{

12021

/* Set up field pointers */

12022

uchar *null_pos= table->record[0];

12023

uchar *field_pos= null_pos + share->null_bytes;

12024

uint null_bit= 1;

12025

12026

for (field= table->field; *field; ++field)

12027

{

12028

Field *cur_field= *field;

12029

if ((cur_field->flags & NOT_NULL_FLAG))

12030

cur_field->move_field(field_pos);

12031

else

12032

{

12033

cur_field->move_field(field_pos, (uchar*) null_pos, null_bit);

12034

null_bit<<= 1;

12035

if (null_bit == (1 << 8))

12036

{

12037

++null_pos;

12038

null_bit= 1;

12039

}

12040

}

12041

cur_field->reset();

12042

12043

field_pos+= cur_field->pack_length();

12044

}

12045

}

12046

return table;

12047

error:

12048

for (field= table->field; *field; ++field)

12049

delete *field; /* just invokes field destructor */

12050

return 0;

12051

}

12052

12053

12054

static bool open_tmp_table(TABLE *table)

12055

{

12056

int error;

12057

if ((error=table->file->ha_open(table, table->s->table_name.str,O_RDWR,

12058

HA_OPEN_TMP_TABLE | HA_OPEN_INTERNAL_TABLE)))

12059

{

12060

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12061

table->db_stat=0;

12062

return(1);

12063

}

12064

(void) table->file->extra(HA_EXTRA_QUICK); /* Faster */

12065

return(0);

12066

}

12067

12068

12069

12070

Create MyISAM temporary table

12071

12072

SYNOPSIS

12073

create_myisam_tmp_table()

12074

table Table object that descrimes the table to be created

12075

keyinfo Description of the index (there is always one index)

12076

start_recinfo MyISAM's column descriptions

12077

recinfo INOUT End of MyISAM's column descriptions

12078

options Option bits

12079

12080

DESCRIPTION

12081

Create a MyISAM temporary table according to passed description. The is

12082

assumed to have one unique index or constraint.

12083

12084

The passed array or MI_COLUMNDEF structures must have this form:

12085

12086

1. 1-byte column (afaiu for 'deleted' flag) (note maybe not 1-byte

12087

when there are many nullable columns)

12088

2. Table columns

12089

3. One free MI_COLUMNDEF element (*recinfo points here)

12090

12091

This function may use the free element to create hash column for unique

12092

constraint.

12093

12094

RETURN

12095

false - OK

12096

true - Error

12097

12098

12099

static bool create_myisam_tmp_table(TABLE *table, KEY *keyinfo,

12100

MI_COLUMNDEF *start_recinfo,

12101

MI_COLUMNDEF **recinfo,

12102

uint64_t options)

12103

{

12104

int error;

12105

MI_KEYDEF keydef;

12106

MI_UNIQUEDEF uniquedef;

12107

TABLE_SHARE *share= table->s;

12108

12109

if (share->keys)

12110

{ // Get keys for ni_create

12111

bool using_unique_constraint=0;

12112

HA_KEYSEG *seg= (HA_KEYSEG*) alloc_root(&table->mem_root,

12113

sizeof(*seg) * keyinfo->key_parts);

12114

if (!seg)

12115

goto err;

12116

12117

memset(seg, 0, sizeof(*seg) * keyinfo->key_parts);

12118

if (keyinfo->key_length >= table->file->max_key_length() ||

12119

keyinfo->key_parts > table->file->max_key_parts() ||

12120

share->uniques)

12121

{

12122

/* Can't create a key; Make a unique constraint instead of a key */

12123

share->keys= 0;

12124

share->uniques= 1;

12125

using_unique_constraint=1;

12126

memset(&uniquedef, 0, sizeof(uniquedef));

12127

uniquedef.keysegs=keyinfo->key_parts;

12128

uniquedef.seg=seg;

12129

uniquedef.null_are_equal=1;

12130

12131

/* Create extra column for hash value */

12132

memset(*recinfo, 0, sizeof(**recinfo));

12133

(*recinfo)->type= FIELD_CHECK;

12134

(*recinfo)->length=MI_UNIQUE_HASH_LENGTH;

12135

(*recinfo)++;

12136

share->reclength+=MI_UNIQUE_HASH_LENGTH;

12137

}

12138

else

12139

{

12140

/* Create an unique key */

12141

memset(&keydef, 0, sizeof(keydef));

12142

keydef.flag=HA_NOSAME | HA_BINARY_PACK_KEY | HA_PACK_KEY;

12143

keydef.keysegs= keyinfo->key_parts;

12144

keydef.seg= seg;

12145

}

12146

for (uint i=0; i < keyinfo->key_parts ; i++,seg++)

12147

{

12148

Field *field=keyinfo->key_part[i].field;

12149

seg->flag= 0;

12150

seg->language= field->charset()->number;

12151

seg->length= keyinfo->key_part[i].length;

12152

seg->start= keyinfo->key_part[i].offset;

12153

if (field->flags & BLOB_FLAG)

12154

{

12155

seg->type=

12156

((keyinfo->key_part[i].key_type & FIELDFLAG_BINARY) ?

12157

HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2);

12158

seg->bit_start= (uint8_t)(field->pack_length() - share->blob_ptr_size);

12159

seg->flag= HA_BLOB_PART;

12160

seg->length=0; // Whole blob in unique constraint

12161

}

12162

else

12163

{

12164

seg->type= keyinfo->key_part[i].type;

12165

}

12166

if (!(field->flags & NOT_NULL_FLAG))

12167

{

12168

seg->null_bit= field->null_bit;

12169

seg->null_pos= (uint) (field->null_ptr - (uchar*) table->record[0]);

12170

12171

We are using a GROUP BY on something that contains NULL

12172

In this case we have to tell MyISAM that two NULL should

12173

on INSERT be regarded at the same value

12174

12175

if (!using_unique_constraint)

12176

keydef.flag|= HA_NULL_ARE_EQUAL;

12177

}

12178

}

12179

}

12180

MI_CREATE_INFO create_info;

12181

memset(&create_info, 0, sizeof(create_info));

12182

12183

if ((options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) ==

12184

OPTION_BIG_TABLES)

12185

create_info.data_file_length= ~(uint64_t) 0;

12186

12187

if ((error=mi_create(share->table_name.str, share->keys, &keydef,

12188

(uint) (*recinfo-start_recinfo),

12189

start_recinfo,

12190

share->uniques, &uniquedef,

12191

&create_info,

12192

HA_CREATE_TMP_TABLE)))

12193

{

12194

table->file->print_error(error,MYF(0)); /* purecov: inspected */

12195

table->db_stat=0;

12196

goto err;

12197

}

12198

status_var_increment(table->in_use->status_var.created_tmp_disk_tables);

12199

share->db_record_offset= 1;

12200

return(0);

12201

err:

12202

return(1);

12203

}

12204

12205

12206

void

12207

free_tmp_table(THD *thd, TABLE *entry)

12208

{

12209

MEM_ROOT own_root= entry->mem_root;

12210

const char *save_proc_info;

12211

12212

save_proc_info=thd->proc_info;

12213

thd_proc_info(thd, "removing tmp table");

12214

12215

if (entry->file)

12216

{

12217

if (entry->db_stat)

12218

entry->file->ha_drop_table(entry->s->table_name.str);

12219

else

12220

entry->file->ha_delete_table(entry->s->table_name.str);

12221

delete entry->file;

12222

}

12223

12224

/* free blobs */

12225

for (Field **ptr=entry->field ; *ptr ; ptr++)

12226

(*ptr)->free();

12227

free_io_cache(entry);

12228

12229

if (entry->temp_pool_slot != MY_BIT_NONE)

12230

bitmap_lock_clear_bit(&temp_pool, entry->temp_pool_slot);

12231

12232

plugin_unlock(0, entry->s->db_plugin);

12233

12234

free_root(&own_root, MYF(0)); /* the table is allocated in its own root */

12235

thd_proc_info(thd, save_proc_info);

12236

12237

return;

12238

}

12239

12240

/**

12241

If a HEAP table gets full, create a MyISAM table and copy all rows

12242

to this.

12243

12244

12245

bool create_myisam_from_heap(THD *thd, TABLE *table,

12246

MI_COLUMNDEF *start_recinfo,

12247

MI_COLUMNDEF **recinfo,

12248

int error, bool ignore_last_dupp_key_error)

12249

{

12250

TABLE new_table;

12251

TABLE_SHARE share;

12252

const char *save_proc_info;

12253

int write_err;

12254

12255

if (table->s->db_type() != heap_hton ||

12256

error != HA_ERR_RECORD_FILE_FULL)

12257

{

12258

table->file->print_error(error,MYF(0));

12259

return(1);

12260

}

12261

new_table= *table;

12262

share= *table->s;

12263

new_table.s= &share;

12264

new_table.s->db_plugin= ha_lock_engine(thd, myisam_hton);

12265

if (!(new_table.file= get_new_handler(&share, &new_table.mem_root,

12266

new_table.s->db_type())))

12267

return(1); // End of memory

12268

12269

save_proc_info=thd->proc_info;

12270

thd_proc_info(thd, "converting HEAP to MyISAM");

12271

12272

if (create_myisam_tmp_table(&new_table, table->key_info, start_recinfo,

12273

recinfo, thd->lex->select_lex.options |

12274

thd->options))

12275

goto err2;

12276

if (open_tmp_table(&new_table))

12277

goto err1;

12278

if (table->file->indexes_are_disabled())

12279

new_table.file->ha_disable_indexes(HA_KEY_SWITCH_ALL);

12280

table->file->ha_index_or_rnd_end();

12281

table->file->ha_rnd_init(1);

12282

if (table->no_rows)

12283

{

12284

new_table.file->extra(HA_EXTRA_NO_ROWS);

12285

new_table.no_rows=1;

12286

}

12287

12288

#ifdef TO_BE_DONE_LATER_IN_4_1

12289

12290

To use start_bulk_insert() (which is new in 4.1) we need to find

12291

all places where a corresponding end_bulk_insert() should be put.

12292

12293

table->file->info(HA_STATUS_VARIABLE); /* update table->file->stats.records */

12294

new_table.file->ha_start_bulk_insert(table->file->stats.records);

12295

#else

12296

/* HA_EXTRA_WRITE_CACHE can stay until close, no need to disable it */

12297

new_table.file->extra(HA_EXTRA_WRITE_CACHE);

12298

#endif

12299

12300

12301

copy all old rows from heap table to MyISAM table

12302

This is the only code that uses record[1] to read/write but this

12303

is safe as this is a temporary MyISAM table without timestamp/autoincrement.

12304

12305

while (!table->file->rnd_next(new_table.record[1]))

12306

{

12307

write_err= new_table.file->ha_write_row(new_table.record[1]);

12308

if (write_err)

12309

goto err;

12310

}

12311

/* copy row that filled HEAP table */

12312

if ((write_err=new_table.file->ha_write_row(table->record[0])))

12313

{

12314

if (new_table.file->is_fatal_error(write_err, HA_CHECK_DUP) ||

12315

!ignore_last_dupp_key_error)

12316

goto err;

12317

}

12318

12319

/* remove heap table and change to use myisam table */

12320

(void) table->file->ha_rnd_end();

12321

(void) table->file->close(); // This deletes the table !

12322

delete table->file;

12323

table->file=0;

12324

plugin_unlock(0, table->s->db_plugin);

12325

share.db_plugin= my_plugin_lock(0, &share.db_plugin);

12326

new_table.s= table->s; // Keep old share

12327

*table= new_table;

12328

*table->s= share;

12329

12330

table->file->change_table_ptr(table, table->s);

12331

table->use_all_columns();

12332

if (save_proc_info)

12333

{

12334

const char *new_proc_info=

12335

(!strcmp(save_proc_info,"Copying to tmp table") ?

12336

"Copying to tmp table on disk" : save_proc_info);

12337

thd_proc_info(thd, new_proc_info);

12338

}

12339

return(0);

12340

12341

err:

12342

table->file->print_error(write_err, MYF(0));

12343

(void) table->file->ha_rnd_end();

12344

(void) new_table.file->close();

12345

err1:

12346

new_table.file->ha_delete_table(new_table.s->table_name.str);

12347

err2:

12348

delete new_table.file;

12349

thd_proc_info(thd, save_proc_info);

12350

table->mem_root= new_table.mem_root;

12351

return(1);

12352

}

12353

3190

if (*const_item)

3191

return left_item->eq(*const_item, 1);

3192

*const_item=left_item;

3193

return 1;

3194

}

3195

}

3196

}

3197

return 0;

3198

}

12354

3199

12355

3200

/**

12356

3201

@details

12363

3208

@return

12364

3209

end_select function to use. This function can't fail.

12365

3210

12366

12367

3211

Next_select_func setup_end_select_func(JOIN *join)

12368

3212

{

12369

TABLE *table= join->tmp_table;

12370

TMP_TABLE_PARAM *tmp_tbl= &join->tmp_table_param;

3213

Table *table= join->tmp_table;

3214

Tmp_Table_Param *tmp_tbl= &join->tmp_table_param;

12371

3215

Next_select_func end_select;

12372

3216

12373

3217

/* Set up select_end */

12374

3218

if (table)

12375

3219

{

12376

if (table->group && tmp_tbl->sum_func_count &&

3220

if (table->group && tmp_tbl->sum_func_count &&

12377

3221

!tmp_tbl->precomputed_group_by)

12378

3222

{

12379

3223

if (table->s->keys)

12380

3224

{

12381

end_select=end_update;

3225

end_select= end_update;

12382

3226

}

12383

3227

else

12384

3228

{

12385

end_select=end_unique_update;

3229

end_select= end_unique_update;

12386

3230

}

12387

3231

}

12388

3232

else if (join->sort_and_group && !tmp_tbl->precomputed_group_by)

12397

3241

12398

3242

A preceding call to create_tmp_table in the case when loose

12399

3243

index scan is used guarantees that

12400

TMP_TABLE_PARAM::items_to_copy has enough space for the group

3244

Tmp_Table_Param::items_to_copy has enough space for the group

12401

3245

by functions. It is OK here to use memcpy since we copy

12402

3246

Item_sum pointers into an array of Item pointers.

12403

3247

12419

3263

return end_select;

12420

3264

}

12421

3265

12422

12423

3266

/**

12424

3267

Make a join of all tables and write it on socket or to table.

12425

3268

12430

3273

@retval

12431

3274

-1 if error should be sent

12432

3275

12433

12434

static int

12435

do_select(JOIN *join,List<Item> *fields,TABLE *table)

3276

int do_select(JOIN *join, List<Item> *fields, Table *table)

12436

3277

{

12437

3278

int rc= 0;

12438

3279

enum_nested_loop_state error= NESTED_LOOP_OK;

12439

JOIN_TAB *join_tab= NULL;

12440

3280

JoinTable *join_tab= NULL;

3281

12441

3282

join->tmp_table= table; /* Save for easy recursion */

12442

3283

join->fields= fields;

12443

3284

12444

3285

if (table)

12445

3286

{

12446

VOID(table->file->extra(HA_EXTRA_WRITE_CACHE));

12447

empty_record(table);

3287

table->cursor->extra(HA_EXTRA_WRITE_CACHE);

3288

table->emptyRecord();

12448

3289

if (table->group && join->tmp_table_param.sum_func_count &&

12449

table->s->keys && !table->file->inited)

12450

table->file->ha_index_init(0, 0);

3290

table->s->keys && !table->cursor->inited)

3291

table->cursor->ha_index_init(0, 0);

12451

3292

}

12452

3293

/* Set up select_end */

12453

3294

Next_select_func end_select= setup_end_select_func(join);

12468

3309

{

12469

3310

error= (*end_select)(join, 0, 0);

12470

3311

if (error == NESTED_LOOP_OK || error == NESTED_LOOP_QUERY_LIMIT)

12471

error= (*end_select)(join, 0, 1);

3312

error= (*end_select)(join, 0, 1);

12472

3313

12473

3314

12474

3315

If we don't go through evaluate_join_record(), do the counting

12476

3317

so we don't touch it here.

12477

3318

12478

3319

join->examined_rows++;

12479

join->thd->row_count++;

3320

join->session->row_count++;

12480

3321

assert(join->examined_rows <= 1);

12481

3322

}

12482

3323

else if (join->send_row_on_empty_set())

12506

3347

if (!table) // If sending data to client

12507

3348

{

12508

3349

12509

The following will unlock all cursors if the command wasn't an

12510

update command

3350

The following will unlock all cursors if the command wasn't an

3351

update command

12511

3352

12512

3353

join->join_free(); // Unlock all cursors

12513

3354

if (join->result->send_eof())

12514

rc= 1; // Don't send error

3355

rc= 1; // Don't send error

12515

3356

}

12516

3357

}

12517

3358

else

12519

3360

if (table)

12520

3361

{

12521

3362

int tmp, new_errno= 0;

12522

if ((tmp=table->file->extra(HA_EXTRA_NO_CACHE)))

3363

if ((tmp=table->cursor->extra(HA_EXTRA_NO_CACHE)))

12523

3364

{

12524

3365

new_errno= tmp;

12525

3366

}

12526

if ((tmp=table->file->ha_index_or_rnd_end()))

3367

if ((tmp=table->cursor->ha_index_or_rnd_end()))

12527

3368

{

12528

3369

new_errno= tmp;

12529

3370

}

12530

3371

if (new_errno)

12531

table->file->print_error(new_errno,MYF(0));

3372

table->print_error(new_errno,MYF(0));

12532

3373

}

12533

return(join->thd->is_error() ? -1 : rc);

3374

return(join->session->is_error() ? -1 : rc);

12534

3375

}

12535

3376

12536

12537

enum_nested_loop_state

12538

sub_select_cache(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3377

enum_nested_loop_state sub_select_cache(JOIN *join, JoinTable *join_tab, bool end_of_records)

12539

3378

{

12540

3379

enum_nested_loop_state rc;

12541

3380

12546

3385

rc= sub_select(join,join_tab,end_of_records);

12547

3386

return rc;

12548

3387

}

12549

if (join->thd->killed) // If aborted by user

3388

if (join->session->killed) // If aborted by user

12550

3389

{

12551

join->thd->send_kill_message();

12552

return NESTED_LOOP_KILLED; /* purecov: inspected */

3390

join->session->send_kill_message();

3391

return NESTED_LOOP_KILLED;

12553

3392

}

12554

3393

if (join_tab->use_quick != 2 || test_if_quick_select(join_tab) <= 0)

12555

3394

{

12556

if (!store_record_in_cache(&join_tab->cache))

3395

if (! store_record_in_cache(&join_tab->cache))

12557

3396

return NESTED_LOOP_OK; // There is more room in cache

12558

3397

return flush_cached_records(join,join_tab,false);

12559

3398

}

12566

3405

/**

12567

3406

Retrieve records ends with a given beginning from the result of a join.

12568

3407

12569

For a given partial join record consisting of records from the tables

3408

For a given partial join record consisting of records from the tables

12570

3409

preceding the table join_tab in the execution plan, the function

12571

3410

retrieves all matching full records from the result set and

12572

send them to the result set stream.

3411

send them to the result set stream.

12573

3412

12574

3413

@note

12575

3414

The function effectively implements the final (n-k) nested loops

12609

3448

first row with t3.a=t1.a has been encountered.

12610

3449

Thus, the second predicate P2 is supplied with a guarded value that are

12611

3450

stored in the field 'found' of the first inner table for the outer join

12612

(table t2). When the first row with t3.a=t1.a for the current row

3451

(table t2). When the first row with t3.a=t1.a for the current row

12613

3452

of table t1 appears, the value becomes true. For now on the predicate

12614

3453

is evaluated immediately after the row of table t2 has been read.

12615

3454

When the first row with t3.a=t1.a has been encountered all

12617

3456

Only when all of them are true the row is sent to the output stream.

12618

3457

If not, the function returns to the lowest nest level that has a false

12619

3458

attached condition.

12620

The predicates from on expressions are also pushed down. If in the

3459

The predicates from on expressions are also pushed down. If in the

12621

3460

the above example the on expression were (t3.a=t1.a AND t2.a=t1.a),

12622

3461

then t1.a=t2.a would be pushed down to table t2, and without any

12623

3462

guard.

12627

3466

is complemented by nulls for t2 and t3. Then the pushed down predicates

12628

3467

are checked for the composed row almost in the same way as it had

12629

3468

been done for the first row with a match. The only difference is

12630

the predicates from on expressions are not checked.

3469

the predicates from on expressions are not checked.

12631

3470

12632

3471

@par

12633

3472

@b IMPLEMENTATION

12643

3482

and a pointer to a guarding boolean variable.

12644

3483

When the value of the guard variable is true the value of the object

12645

3484

is the same as the value of the predicate, otherwise it's just returns

12646

true.

12647

To carry out a return to a nested loop level of join table t the pointer

3485

true.

3486

To carry out a return to a nested loop level of join table t the pointer

12648

3487

to t is remembered in the field 'return_tab' of the join structure.

12649

3488

Consider the following query:

12650

3489

@code

12661

3500

t5.a=t3.a is found, the pushed down predicate t4.b=2 OR t4.b IS NULL

12662

3501

becomes 'activated', as well the predicate t4.a=t2.a. But

12663

3502

the predicate (t2.b=5 OR t2.b IS NULL) can not be checked until

12664

t4.a=t2.a becomes true.

3503

t4.a=t2.a becomes true.

12665

3504

In order not to re-evaluate the predicates that were already evaluated

12666

3505

as attached pushed down predicates, a pointer to the the first

12667

3506

most inner unmatched table is maintained in join_tab->first_unmatched.

12668

3507

Thus, when the first row from t5 with t5.a=t3.a is found

12669

this pointer for t5 is changed from t4 to t2.

3508

this pointer for t5 is changed from t4 to t2.

12670

3509

12671

3510

@par

12672

3511

@b STRUCTURE @b NOTES

12677

3516

@param join pointer to the structure providing all context info for

12678

3517

the query

12679

3518

@param join_tab the first next table of the execution plan to be retrieved

12680

@param end_records true when we need to perform final steps of retrival

3519

@param end_records true when we need to perform final steps of retrival

12681

3520

12682

3521

@return

12683

3522

return one of enum_nested_loop_state, except NESTED_LOOP_NO_MORE_ROWS.

12684

3523

12685

int do_sj_reset(SJ_TMP_TABLE *sj_tbl);

12686

12687

enum_nested_loop_state

12688

sub_select(JOIN *join,JOIN_TAB *join_tab,bool end_of_records)

3524

enum_nested_loop_state sub_select(JOIN *join, JoinTable *join_tab, bool end_of_records)

12689

3525

{

12690

3526

join_tab->table->null_row=0;

12691

3527

if (end_of_records)

12695

3531

enum_nested_loop_state rc;

12696

3532

READ_RECORD *info= &join_tab->read_record;

12697

3533

12698

if (join_tab->flush_weedout_table)

12699

{

12700

do_sj_reset(join_tab->flush_weedout_table);

12701

}

12702

12703

3534

if (join->resume_nested_loop)

12704

3535

{

12705

3536

/* If not the last table, plunge down the nested loop */

12726

3557

/* Set first_unmatched for the last inner table of this group */

12727

3558

join_tab->last_inner->first_unmatched= join_tab;

12728

3559

}

12729

join->thd->row_count= 0;

3560

join->session->row_count= 0;

12730

3561

12731

3562

error= (*join_tab->read_first_record)(join_tab);

12732

3563

rc= evaluate_join_record(join, join_tab, error);

12733

3564

}

12734

12735

12736

Note: psergey has added the 2nd part of the following condition; the

3565

3566

3567

Note: psergey has added the 2nd part of the following condition; the

12737

3568

change should probably be made in 5.1, too.

12738

3569

12739

3570

while (rc == NESTED_LOOP_OK && join->return_tab >= join_tab)

12751

3582

return rc;

12752

3583

}

12753

3584

12754

12755

12756

12757

12758

SemiJoinDuplicateElimination: Weed out duplicate row combinations

12759

12760

SYNPOSIS

12761

do_sj_dups_weedout()

12762

12763

RETURN

12764

-1 Error

12765

1 The row combination is a duplicate (discard it)

12766

0 The row combination is not a duplicate (continue)

12767

12768

12769

int do_sj_dups_weedout(THD *thd, SJ_TMP_TABLE *sjtbl)

12770

{

12771

int error;

12772

SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;

12773

SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;

12774

uchar *ptr= sjtbl->tmp_table->record[0] + 1;

12775

uchar *nulls_ptr= ptr;

12776

12777

/* Put the the rowids tuple into table->record[0]: */

12778

12779

// 1. Store the length

12780

if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)

12781

{

12782

*ptr= (uchar)(sjtbl->rowid_len + sjtbl->null_bytes);

12783

ptr++;

12784

}

12785

else

12786

{

12787

int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);

12788

ptr += 2;

12789

}

12790

12791

// 2. Zero the null bytes

12792

if (sjtbl->null_bytes)

12793

{

12794

memset(ptr, 0, sjtbl->null_bytes);

12795

ptr += sjtbl->null_bytes;

12796

}

12797

12798

// 3. Put the rowids

12799

for (uint i=0; tab != tab_end; tab++, i++)

12800

{

12801

handler *h= tab->join_tab->table->file;

12802

if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)

12803

{

12804

/* It's a NULL-complemented row */

12805

*(nulls_ptr + tab->null_byte) |= tab->null_bit;

12806

memset(ptr + tab->rowid_offset, 0, h->ref_length);

12807

}

12808

else

12809

{

12810

/* Copy the rowid value */

12811

if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)

12812

h->position(tab->join_tab->table->record[0]);

12813

memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);

12814

}

12815

}

12816

12817

error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);

12818

if (error)

12819

{

12820

/* create_myisam_from_heap will generate error if needed */

12821

if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&

12822

create_myisam_from_heap(thd, sjtbl->tmp_table, sjtbl->start_recinfo,

12823

&sjtbl->recinfo, error, 1))

12824

return -1;

12825

//return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;

12826

return 1;

12827

}

12828

return 0;

12829

}

12830

12831

12832

12833

SemiJoinDuplicateElimination: Reset the temporary table

12834

12835

12836

int do_sj_reset(SJ_TMP_TABLE *sj_tbl)

12837

{

12838

if (sj_tbl->tmp_table)

12839

return sj_tbl->tmp_table->file->ha_delete_all_rows();

12840

return 0;

12841

}

12842

12843

12844

Process one record of the nested loop join.

12845

12846

This function will evaluate parts of WHERE/ON clauses that are

12847

applicable to the partial record on hand and in case of success

12848

submit this record to the next level of the nested loop.

12849

12850

12851

static enum_nested_loop_state

12852

evaluate_join_record(JOIN *join, JOIN_TAB *join_tab,

12853

int error)

12854

{

12855

bool not_used_in_distinct=join_tab->not_used_in_distinct;

12856

ha_rows found_records=join->found_records;

12857

COND *select_cond= join_tab->select_cond;

12858

12859

if (error > 0 || (join->thd->is_error())) // Fatal error

12860

return NESTED_LOOP_ERROR;

12861

if (error < 0)

12862

return NESTED_LOOP_NO_MORE_ROWS;

12863

if (join->thd->killed) // Aborted by user

12864

{

12865

join->thd->send_kill_message();

12866

return NESTED_LOOP_KILLED; /* purecov: inspected */

12867

}

12868

if (!select_cond || select_cond->val_int())

12869

{

12870

12871

There is no select condition or the attached pushed down

12872

condition is true => a match is found.

12873

12874

bool found= 1;

12875

while (join_tab->first_unmatched && found)

12876

{

12877

12878

The while condition is always false if join_tab is not

12879

the last inner join table of an outer join operation.

12880

12881

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

12882

12883

Mark that a match for current outer table is found.

12884

This activates push down conditional predicates attached

12885

to the all inner tables of the outer join.

12886

12887

first_unmatched->found= 1;

12888

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

12889

{

12890

if (tab->table->reginfo.not_exists_optimize)

12891

return NESTED_LOOP_NO_MORE_ROWS;

12892

/* Check all predicates that has just been activated. */

12893

12894

Actually all predicates non-guarded by first_unmatched->found

12895

will be re-evaluated again. It could be fixed, but, probably,

12896

it's not worth doing now.

12897

12898

if (tab->select_cond && !tab->select_cond->val_int())

12899

{

12900

/* The condition attached to table tab is false */

12901

if (tab == join_tab)

12902

found= 0;

12903

else

12904

{

12905

12906

Set a return point if rejected predicate is attached

12907

not to the last table of the current nest level.

12908

12909

join->return_tab= tab;

12910

return NESTED_LOOP_OK;

12911

}

12912

}

12913

}

12914

12915

Check whether join_tab is not the last inner table

12916

for another embedding outer join.

12917

12918

if ((first_unmatched= first_unmatched->first_upper) &&

12919

first_unmatched->last_inner != join_tab)

12920

first_unmatched= 0;

12921

join_tab->first_unmatched= first_unmatched;

12922

}

12923

12924

JOIN_TAB *return_tab= join->return_tab;

12925

join_tab->found_match= true;

12926

if (join_tab->check_weed_out_table)

12927

{

12928

int res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table);

12929

if (res == -1)

12930

return NESTED_LOOP_ERROR;

12931

if (res == 1)

12932

return NESTED_LOOP_OK;

12933

}

12934

else if (join_tab->do_firstmatch)

12935

{

12936

12937

We should return to the join_tab->do_firstmatch after we have

12938

enumerated all the suffixes for current prefix row combination

12939

12940

return_tab= join_tab->do_firstmatch;

12941

}

12942

12943

12944

It was not just a return to lower loop level when one

12945

of the newly activated predicates is evaluated as false

12946

(See above join->return_tab= tab).

12947

12948

join->examined_rows++;

12949

join->thd->row_count++;

12950

12951

if (found)

12952

{

12953

enum enum_nested_loop_state rc;

12954

/* A match from join_tab is found for the current partial join. */

12955

rc= (*join_tab->next_select)(join, join_tab+1, 0);

12956

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

12957

return rc;

12958

if (return_tab < join->return_tab)

12959

join->return_tab= return_tab;

12960

12961

if (join->return_tab < join_tab)

12962

return NESTED_LOOP_OK;

12963

12964

Test if this was a SELECT DISTINCT query on a table that

12965

was not in the field list; In this case we can abort if

12966

we found a row, as no new rows can be added to the result.

12967

12968

if (not_used_in_distinct && found_records != join->found_records)

12969

return NESTED_LOOP_NO_MORE_ROWS;

12970

}

12971

else

12972

join_tab->read_record.file->unlock_row();

12973

}

12974

else

12975

{

12976

12977

The condition pushed down to the table join_tab rejects all rows

12978

with the beginning coinciding with the current partial join.

12979

12980

join->examined_rows++;

12981

join->thd->row_count++;

12982

join_tab->read_record.file->unlock_row();

12983

}

12984

return NESTED_LOOP_OK;

12985

}

12986

12987

12988

/**

12989

12990

@details

12991

Construct a NULL complimented partial join record and feed it to the next

12992

level of the nested loop. This function is used in case we have

12993

an OUTER join and no matching record was found.

12994

12995

12996

static enum_nested_loop_state

12997

evaluate_null_complemented_join_record(JOIN *join, JOIN_TAB *join_tab)

12998

{

12999

13000

The table join_tab is the first inner table of a outer join operation

13001

and no matches has been found for the current outer row.

13002

13003

JOIN_TAB *last_inner_tab= join_tab->last_inner;

13004

/* Cache variables for faster loop */

13005

COND *select_cond;

13006

for ( ; join_tab <= last_inner_tab ; join_tab++)

13007

{

13008

/* Change the the values of guard predicate variables. */

13009

join_tab->found= 1;

13010

join_tab->not_null_compl= 0;

13011

/* The outer row is complemented by nulls for each inner tables */

13012

restore_record(join_tab->table,s->default_values); // Make empty record

13013

mark_as_null_row(join_tab->table); // For group by without error

13014

select_cond= join_tab->select_cond;

13015

/* Check all attached conditions for inner table rows. */

13016

if (select_cond && !select_cond->val_int())

13017

return NESTED_LOOP_OK;

13018

}

13019

join_tab--;

13020

13021

The row complemented by nulls might be the first row

13022

of embedding outer joins.

13023

If so, perform the same actions as in the code

13024

for the first regular outer join row above.

13025

13026

for ( ; ; )

13027

{

13028

JOIN_TAB *first_unmatched= join_tab->first_unmatched;

13029

if ((first_unmatched= first_unmatched->first_upper) &&

13030

first_unmatched->last_inner != join_tab)

13031

first_unmatched= 0;

13032

join_tab->first_unmatched= first_unmatched;

13033

if (!first_unmatched)

13034

break;

13035

first_unmatched->found= 1;

13036

for (JOIN_TAB *tab= first_unmatched; tab <= join_tab; tab++)

13037

{

13038

if (tab->select_cond && !tab->select_cond->val_int())

13039

{

13040

join->return_tab= tab;

13041

return NESTED_LOOP_OK;

13042

}

13043

}

13044

}

13045

13046

The row complemented by nulls satisfies all conditions

13047

attached to inner tables.

13048

Send the row complemented by nulls to be joined with the

13049

remaining tables.

13050

13051

return (*join_tab->next_select)(join, join_tab+1, 0);

13052

}

13053

13054

13055

static enum_nested_loop_state

13056

flush_cached_records(JOIN *join,JOIN_TAB *join_tab,bool skip_last)

13057

{

13058

enum_nested_loop_state rc= NESTED_LOOP_OK;

13059

int error;

13060

READ_RECORD *info;

13061

13062

join_tab->table->null_row= 0;

13063

if (!join_tab->cache.records)

13064

return NESTED_LOOP_OK; /* Nothing to do */

13065

if (skip_last)

13066

(void) store_record_in_cache(&join_tab->cache); // Must save this for later

13067

if (join_tab->use_quick == 2)

13068

{

13069

if (join_tab->select->quick)

13070

{ /* Used quick select last. reset it */

13071

delete join_tab->select->quick;

13072

join_tab->select->quick=0;

13073

}

13074

}

13075

/* read through all records */

13076

if ((error=join_init_read_record(join_tab)))

13077

{

13078

reset_cache_write(&join_tab->cache);

13079

return error < 0 ? NESTED_LOOP_NO_MORE_ROWS: NESTED_LOOP_ERROR;

13080

}

13081

13082

for (JOIN_TAB *tmp=join->join_tab; tmp != join_tab ; tmp++)

13083

{

13084

tmp->status=tmp->table->status;

13085

tmp->table->status=0;

13086

}

13087

13088

info= &join_tab->read_record;

13089

13090

{

13091

if (join->thd->killed)

13092

{

13093

join->thd->send_kill_message();

13094

return NESTED_LOOP_KILLED; // Aborted by user /* purecov: inspected */

13095

}

13096

SQL_SELECT *select=join_tab->select;

13097

if (rc == NESTED_LOOP_OK &&

13098

(!join_tab->cache.select || !join_tab->cache.select->skip_record()))

13099

{

13100

uint i;

13101

reset_cache_read(&join_tab->cache);

13102

for (i=(join_tab->cache.records- (skip_last ? 1 : 0)) ; i-- > 0 ;)

13103

{

13104

read_cached_record(join_tab);

13105

if (!select || !select->skip_record())

13106

{

13107

int res= 0;

13108

if (!join_tab->check_weed_out_table ||

13109

!(res= do_sj_dups_weedout(join->thd, join_tab->check_weed_out_table)))

13110

{

13111

rc= (join_tab->next_select)(join,join_tab+1,0);

13112

if (rc != NESTED_LOOP_OK && rc != NESTED_LOOP_NO_MORE_ROWS)

13113

{

13114

reset_cache_write(&join_tab->cache);

13115

return rc;

13116

}

13117

}

13118

if (res == -1)

13119

return NESTED_LOOP_ERROR;

13120

}

13121

}

13122

}

13123

} while (!(error=info->read_record(info)));

13124

13125

if (skip_last)

13126

read_cached_record(join_tab); // Restore current record

13127

reset_cache_write(&join_tab->cache);

13128

if (error > 0) // Fatal error

13129

return NESTED_LOOP_ERROR; /* purecov: inspected */

13130

for (JOIN_TAB *tmp2=join->join_tab; tmp2 != join_tab ; tmp2++)

13131

tmp2->table->status=tmp2->status;

13132

return NESTED_LOOP_OK;

13133

}

13134

13135

13136

/*****************************************************************************

13137

The different ways to read a record

13138

Returns -1 if row was not found, 0 if row was found and 1 on errors

13139

*****************************************************************************/

13140

13141

/** Help function when we get some an error from the table handler. */

13142

13143

int report_error(TABLE *table, int error)

13144

{

13145

if (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND)

13146

{

13147

table->status= STATUS_GARBAGE;

13148

return -1; // key not found; ok

13149

}

13150

13151

Locking reads can legally return also these errors, do not

13152

print them to the .err log

13153

13154

if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)

13155

sql_print_error("Got error %d when reading table '%s'",

13156

error, table->s->path.str);

13157

table->file->print_error(error,MYF(0));

13158

return 1;

13159

}

13160

13161

13162

int safe_index_read(JOIN_TAB *tab)

13163

{

13164

int error;

13165

TABLE *table= tab->table;

13166

if ((error=table->file->index_read_map(table->record[0],

3585

int safe_index_read(JoinTable *tab)

3586

{

3587

int error;

3588

Table *table= tab->table;

3589

if ((error=table->cursor->index_read_map(table->record[0],

13167

3590

tab->ref.key_buff,

13168

3591

make_prev_keypart_map(tab->ref.key_parts),

13169

3592

HA_READ_KEY_EXACT)))

13170

return report_error(table, error);

3593

return table->report_error(error);

13171

3594

return 0;

13172

3595

}

13173

3596

13174

13175

static int

13176

join_read_const_table(JOIN_TAB *tab, POSITION *pos)

3597

int join_read_const_table(JoinTable *tab, optimizer::Position *pos)

13177

3598

{

13178

3599

int error;

13179

TABLE *table=tab->table;

3600

Table *table=tab->table;

13180

3601

table->const_table=1;

13181

3602

table->null_row=0;

13182

3603

table->status=STATUS_NO_RECORD;

13183

13184

if (tab->type == JT_SYSTEM)

3604

3605

if (tab->type == AM_SYSTEM)

13185

3606

{

13186

3607

if ((error=join_read_system(tab)))

13187

3608

{ // Info for DESCRIBE

13188

3609

tab->info="const row not found";

13189

3610

/* Mark for EXPLAIN that the row was not found */

13190

pos->records_read=0.0;

13191

pos->ref_depend_map= 0;

13192

if (!table->maybe_null || error > 0)

13193

return(error);

3611

pos->setFanout(0.0);

3612

pos->clearRefDependMap();

3613

if (! table->maybe_null || error > 0)

3614

return(error);

13194

3615

}

13195

3616

}

13196

3617

else

13197

3618

{

13198

if (!table->key_read && table->covering_keys.is_set(tab->ref.key) &&

13199

!table->no_keyread &&

13200

(int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY)

3619

if (! table->key_read &&

3620

table->covering_keys.test(tab->ref.key) &&

3621

! table->no_keyread &&

3622

(int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS)

13201

3623

{

13202

3624

table->key_read=1;

13203

table->file->extra(HA_EXTRA_KEYREAD);

3625

table->cursor->extra(HA_EXTRA_KEYREAD);

13204

3626

tab->index= tab->ref.key;

13205

3627

}

13206

3628

error=join_read_const(tab);

13207

3629

if (table->key_read)

13208

3630

{

13209

3631

table->key_read=0;

13210

table->file->extra(HA_EXTRA_NO_KEYREAD);

3632

table->cursor->extra(HA_EXTRA_NO_KEYREAD);

13211

3633

}

13212

3634

if (error)

13213

3635

{

13214

3636

tab->info="unique row not found";

13215

3637

/* Mark for EXPLAIN that the row was not found */

13216

pos->records_read=0.0;

13217

pos->ref_depend_map= 0;

3638

pos->setFanout(0.0);

3639

pos->clearRefDependMap();

13218

3640

if (!table->maybe_null || error > 0)

13219

return(error);

3641

return(error);

13220

3642

}

13221

3643

}

13222

3644

if (*tab->on_expr_ref && !table->null_row)

13223

3645

{

13224

3646

if ((table->null_row= test((*tab->on_expr_ref)->val_int() == 0)))

13225

mark_as_null_row(table);

3647

table->mark_as_null_row();

13226

3648

}

13227

3649

if (!table->null_row)

13228

3650

table->maybe_null=0;

13231

3653

JOIN *join= tab->join;

13232

3654

if (join->conds)

13233

3655

update_const_equal_items(join->conds, tab);

13234

TABLE_LIST *tbl;

3656

TableList *tbl;

13235

3657

for (tbl= join->select_lex->leaf_tables; tbl; tbl= tbl->next_leaf)

13236

3658

{

13237

TABLE_LIST *embedded;

13238

TABLE_LIST *embedding= tbl;

3659

TableList *embedded;

3660

TableList *embedding= tbl;

13239

3661

13240

3662

{

13241

3663

embedded= embedding;

13250

3672

return(0);

13251

3673

}

13252

3674

13253

13254

static int

13255

join_read_system(JOIN_TAB *tab)

3675

int join_read_system(JoinTable *tab)

13256

3676

{

13257

TABLE *table= tab->table;

3677

Table *table= tab->table;

13258

3678

int error;

13259

3679

if (table->status & STATUS_GARBAGE) // If first read

13260

3680

{

13261

if ((error=table->file->read_first_row(table->record[0],

3681

if ((error=table->cursor->read_first_row(table->record[0],

13262

3682

table->s->primary_key)))

13263

3683

{

13264

3684

if (error != HA_ERR_END_OF_FILE)

13265

return report_error(table, error);

13266

mark_as_null_row(tab->table);

13267

empty_record(table); // Make empty record

3685

return table->report_error(error);

3686

tab->table->mark_as_null_row();

3687

table->emptyRecord(); // Make empty record

13268

3688

return -1;

13269

3689

}

13270

store_record(table,record[1]);

3690

table->storeRecord();

13271

3691

}

13272

3692

else if (!table->status) // Only happens with left join

13273

restore_record(table,record[1]); // restore old record

3693

table->restoreRecord(); // restore old record

13274

3694

table->null_row=0;

13275

3695

return table->status ? -1 : 0;

13276

3696

}

13277

3697

13278

13279

3698

/**

13280

3699

Read a (constant) table when there is at most one matching row.

13281

3700

13288

3707

@retval

13289

3708

1 Got an error (other than row not found) during read

13290

3709

13291

13292

static int

13293

join_read_const(JOIN_TAB *tab)

3710

int join_read_const(JoinTable *tab)

13294

3711

{

13295

3712

int error;

13296

TABLE *table= tab->table;

3713

Table *table= tab->table;

13297

3714

if (table->status & STATUS_GARBAGE) // If first read

13298

3715

{

13299

3716

table->status= 0;

13300

if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))

13301

error=HA_ERR_KEY_NOT_FOUND;

3717

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

3718

error= HA_ERR_KEY_NOT_FOUND;

13302

3719

else

13303

3720

{

13304

error=table->file->index_read_idx_map(table->record[0],tab->ref.key,

13305

(uchar*) tab->ref.key_buff,

3721

error=table->cursor->index_read_idx_map(table->record[0],tab->ref.key,

3722

(unsigned char*) tab->ref.key_buff,

13306

3723

make_prev_keypart_map(tab->ref.key_parts),

13307

3724

HA_READ_KEY_EXACT);

13308

3725

}

13309

3726

if (error)

13310

3727

{

13311

3728

table->status= STATUS_NOT_FOUND;

13312

mark_as_null_row(tab->table);

13313

empty_record(table);

3729

tab->table->mark_as_null_row();

3730

table->emptyRecord();

13314

3731

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

13315

return report_error(table, error);

3732

return table->report_error(error);

13316

3733

return -1;

13317

3734

}

13318

store_record(table,record[1]);

3735

table->storeRecord();

13319

3736

}

13320

3737

else if (!(table->status & ~STATUS_NULL_ROW)) // Only happens with left join

13321

3738

{

13322

3739

table->status=0;

13323

restore_record(table,record[1]); // restore old record

3740

table->restoreRecord(); // restore old record

13324

3741

}

13325

3742

table->null_row=0;

13326

3743

return table->status ? -1 : 0;

13327

3744

}

13328

3745

13329

13330

3746

13331

3747

eq_ref access method implementation: "read_first" function

13332

3748

13333

3749

SYNOPSIS

13334

3750

join_read_key()

13335

tab JOIN_TAB of the accessed table

3751

tab JoinTable of the accessed table

13336

3752

13337

3753

DESCRIPTION

13338

3754

This is "read_fist" function for the "ref" access method. The difference

13340

3756

13341

3757

RETURN

13342

3758

0 - Ok

13343

-1 - Row not found

3759

-1 - Row not found

13344

3760

1 - Error

13345

3761

13346

13347

static int

13348

join_read_key(JOIN_TAB *tab)

3762

int join_read_key(JoinTable *tab)

13349

3763

{

13350

3764

int error;

13351

TABLE *table= tab->table;

3765

Table *table= tab->table;

13352

3766

13353

if (!table->file->inited)

3767

if (!table->cursor->inited)

13354

3768

{

13355

table->file->ha_index_init(tab->ref.key, tab->sorted);

3769

table->cursor->ha_index_init(tab->ref.key, tab->sorted);

13356

3770

}

13357

3771

13358

3772

/* TODO: Why don't we do "Late NULLs Filtering" here? */

13364

3778

table->status=STATUS_NOT_FOUND;

13365

3779

return -1;

13366

3780

}

13367

error=table->file->index_read_map(table->record[0],

3781

error=table->cursor->index_read_map(table->record[0],

13368

3782

tab->ref.key_buff,

13369

3783

make_prev_keypart_map(tab->ref.key_parts),

13370

3784

HA_READ_KEY_EXACT);

13371

3785

if (error && error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

13372

return report_error(table, error);

3786

return table->report_error(error);

13373

3787

}

13374

3788

table->null_row=0;

13375

3789

return table->status ? -1 : 0;

13376

3790

}

13377

3791

13378

13379

3792

13380

3793

ref access method implementation: "read_first" function

13381

3794

13382

3795

SYNOPSIS

13383

3796

join_read_always_key()

13384

tab JOIN_TAB of the accessed table

3797

tab JoinTable of the accessed table

13385

3798

13386

3799

DESCRIPTION

13387

This is "read_fist" function for the "ref" access method.

13388

3800

This is "read_first" function for the "ref" access method.

3801

13389

3802

The functon must leave the index initialized when it returns.

13390

3803

ref_or_null access implementation depends on that.

13391

3804

13392

3805

RETURN

13393

3806

0 - Ok

13394

-1 - Row not found

3807

-1 - Row not found

13395

3808

1 - Error

13396

3809

13397

13398

static int

13399

join_read_always_key(JOIN_TAB *tab)

3810

int join_read_always_key(JoinTable *tab)

13400

3811

{

13401

3812

int error;

13402

TABLE *table= tab->table;

3813

Table *table= tab->table;

13403

3814

13404

3815

/* Initialize the index first */

13405

if (!table->file->inited)

13406

table->file->ha_index_init(tab->ref.key, tab->sorted);

13407

3816

if (!table->cursor->inited)

3817

table->cursor->ha_index_init(tab->ref.key, tab->sorted);

3818

13408

3819

/* Perform "Late NULLs Filtering" (see internals manual for explanations) */

13409

for (uint i= 0 ; i < tab->ref.key_parts ; i++)

3820

for (uint32_t i= 0 ; i < tab->ref.key_parts ; i++)

13410

3821

{

13411

3822

if ((tab->ref.null_rejecting & 1 << i) && tab->ref.items[i]->is_null())

13412

3823

return -1;

13413

3824

}

13414

3825

13415

if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))

3826

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

13416

3827

return -1;

13417

if ((error=table->file->index_read_map(table->record[0],

3828

if ((error=table->cursor->index_read_map(table->record[0],

13418

3829

tab->ref.key_buff,

13419

3830

make_prev_keypart_map(tab->ref.key_parts),

13420

3831

HA_READ_KEY_EXACT)))

13421

3832

{

13422

3833

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

13423

return report_error(table, error);

13424

return -1; /* purecov: inspected */

3834

return table->report_error(error);

3835

return -1;

13425

3836

}

3837

13426

3838

return 0;

13427

3839

}

13428

3840

13429

13430

3841

/**

13431

This function is used when optimizing away ORDER BY in

13432

SELECT * FROM t1 WHERE a=1 ORDER BY a DESC,b DESC.

3842

This function is used when optimizing away order_st BY in

3843

SELECT * FROM t1 WHERE a=1 order_st BY a DESC,b DESC.

13433

3844

13434

13435

static int

13436

join_read_last_key(JOIN_TAB *tab)

3845

int join_read_last_key(JoinTable *tab)

13437

3846

{

13438

3847

int error;

13439

TABLE *table= tab->table;

3848

Table *table= tab->table;

13440

3849

13441

if (!table->file->inited)

13442

table->file->ha_index_init(tab->ref.key, tab->sorted);

13443

if (cp_buffer_from_ref(tab->join->thd, table, &tab->ref))

3850

if (!table->cursor->inited)

3851

table->cursor->ha_index_init(tab->ref.key, tab->sorted);

3852

if (cp_buffer_from_ref(tab->join->session, &tab->ref))

13444

3853

return -1;

13445

if ((error=table->file->index_read_last_map(table->record[0],

3854

if ((error=table->cursor->index_read_last_map(table->record[0],

13446

3855

tab->ref.key_buff,

13447

3856

make_prev_keypart_map(tab->ref.key_parts))))

13448

3857

{

13449

3858

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

13450

return report_error(table, error);

13451

return -1; /* purecov: inspected */

3859

return table->report_error(error);

3860

return -1;

13452

3861

}

13453

3862

return 0;

13454

3863

}

13455

3864

13456

13457

/* ARGSUSED */

13458

static int

13459

join_no_more_records(READ_RECORD *info __attribute__((unused)))

3865

int join_no_more_records(READ_RECORD *)

13460

3866

{

13461

3867

return -1;

13462

3868

}

13463

3869

13464

static int

13465

join_read_next_same_diff(READ_RECORD *info)

3870

int join_read_next_same_diff(READ_RECORD *info)

13466

3871

{

13467

TABLE *table= info->table;

13468

JOIN_TAB *tab=table->reginfo.join_tab;

3872

Table *table= info->table;

3873

JoinTable *tab=table->reginfo.join_tab;

13469

3874

if (tab->insideout_match_tab->found_match)

13470

3875

{

13471

3876

KEY *key= tab->table->key_info + tab->index;

13472

3877

13473

3878

{

13474

3879

int error;

13475

3880

/* Save index tuple from record to the buffer */

13476

3881

key_copy(tab->insideout_buf, info->record, key, 0);

13477

3882

13478

if ((error=table->file->index_next_same(table->record[0],

3883

if ((error=table->cursor->index_next_same(table->record[0],

13479

3884

tab->ref.key_buff,

13480

3885

tab->ref.key_length)))

13481

3886

{

13482

3887

if (error != HA_ERR_END_OF_FILE)

13483

return report_error(table, error);

3888

return table->report_error(error);

13484

3889

table->status= STATUS_GARBAGE;

13485

3890

return -1;

13486

3891

}

13487

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

3892

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

13488

3893

tab->insideout_buf, key->key_length));

13489

3894

tab->insideout_match_tab->found_match= 0;

13490

3895

return 0;

13493

3898

return join_read_next_same(info);

13494

3899

}

13495

3900

13496

static int

13497

join_read_next_same(READ_RECORD *info)

3901

int join_read_next_same(READ_RECORD *info)

13498

3902

{

13499

3903

int error;

13500

TABLE *table= info->table;

13501

JOIN_TAB *tab=table->reginfo.join_tab;

3904

Table *table= info->table;

3905

JoinTable *tab=table->reginfo.join_tab;

13502

3906

13503

if ((error=table->file->index_next_same(table->record[0],

3907

if ((error=table->cursor->index_next_same(table->record[0],

13504

3908

tab->ref.key_buff,

13505

3909

tab->ref.key_length)))

13506

3910

{

13507

3911

if (error != HA_ERR_END_OF_FILE)

13508

return report_error(table, error);

3912

return table->report_error(error);

13509

3913

table->status= STATUS_GARBAGE;

13510

3914

return -1;

13511

3915

}

3916

13512

3917

return 0;

13513

3918

}

13514

3919

13515

13516

static int

13517

join_read_prev_same(READ_RECORD *info)

3920

int join_read_prev_same(READ_RECORD *info)

13518

3921

{

13519

3922

int error;

13520

TABLE *table= info->table;

13521

JOIN_TAB *tab=table->reginfo.join_tab;

3923

Table *table= info->table;

3924

JoinTable *tab=table->reginfo.join_tab;

13522

3925

13523

if ((error=table->file->index_prev(table->record[0])))

13524

return report_error(table, error);

3926

if ((error=table->cursor->index_prev(table->record[0])))

3927

return table->report_error(error);

13525

3928

if (key_cmp_if_same(table, tab->ref.key_buff, tab->ref.key,

13526

3929

tab->ref.key_length))

13527

3930

{

13531

3934

return error;

13532

3935

}

13533

3936

13534

13535

static int

13536

join_init_quick_read_record(JOIN_TAB *tab)

3937

int join_init_quick_read_record(JoinTable *tab)

13537

3938

{

13538

3939

if (test_if_quick_select(tab) == -1)

13539

3940

return -1; /* No possible records */

13540

3941

return join_init_read_record(tab);

13541

3942

}

13542

3943

13543

13544

3944

int rr_sequential(READ_RECORD *info);

13545

int init_read_record_seq(JOIN_TAB *tab)

3945

int init_read_record_seq(JoinTable *tab)

13546

3946

{

13547

3947

tab->read_record.read_record= rr_sequential;

13548

if (tab->read_record.file->ha_rnd_init(1))

3948

if (tab->read_record.cursor->ha_rnd_init(1))

13549

3949

return 1;

13550

3950

return (*tab->read_record.read_record)(&tab->read_record);

13551

3951

}

13552

3952

13553

static int

13554

test_if_quick_select(JOIN_TAB *tab)

3953

int test_if_quick_select(JoinTable *tab)

13555

3954

{

13556

3955

delete tab->select->quick;

13557

tab->select->quick=0;

13558

return tab->select->test_quick_select(tab->join->thd, tab->keys,

13559

(table_map) 0, HA_POS_ERROR, 0,

13560

false);

3956

tab->select->quick= 0;

3957

return tab->select->test_quick_select(tab->join->session, tab->keys,

3958

(table_map) 0, HA_POS_ERROR, 0, false);

13561

3959

}

13562

3960

13563

13564

static int

13565

join_init_read_record(JOIN_TAB *tab)

3961

int join_init_read_record(JoinTable *tab)

13566

3962

{

13567

3963

if (tab->select && tab->select->quick && tab->select->quick->reset())

13568

3964

return 1;

13569

init_read_record(&tab->read_record, tab->join->thd, tab->table,

3965

init_read_record(&tab->read_record, tab->join->session, tab->table,

13570

3966

tab->select,1,1);

13571

3967

return (*tab->read_record.read_record)(&tab->read_record);

13572

3968

}

13573

3969

13574

13575

static int

13576

join_read_first(JOIN_TAB *tab)

3970

int join_read_first(JoinTable *tab)

13577

3971

{

13578

3972

int error;

13579

TABLE *table=tab->table;

13580

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

3973

Table *table=tab->table;

3974

if (!table->key_read && table->covering_keys.test(tab->index) &&

13581

3975

!table->no_keyread)

13582

3976

{

13583

3977

table->key_read=1;

13584

table->file->extra(HA_EXTRA_KEYREAD);

3978

table->cursor->extra(HA_EXTRA_KEYREAD);

13585

3979

}

13586

3980

tab->table->status=0;

13587

3981

tab->read_record.table=table;

13588

tab->read_record.file=table->file;

3982

tab->read_record.cursor=table->cursor;

13589

3983

tab->read_record.index=tab->index;

13590

3984

tab->read_record.record=table->record[0];

13591

3985

if (tab->insideout_match_tab)

13600

3994

tab->read_record.do_insideout_scan= 0;

13601

3995

}

13602

3996

13603

if (!table->file->inited)

13604

table->file->ha_index_init(tab->index, tab->sorted);

13605

if ((error=tab->table->file->index_first(tab->table->record[0])))

3997

if (!table->cursor->inited)

3998

table->cursor->ha_index_init(tab->index, tab->sorted);

3999

if ((error=tab->table->cursor->index_first(tab->table->record[0])))

13606

4000

{

13607

4001

if (error != HA_ERR_KEY_NOT_FOUND && error != HA_ERR_END_OF_FILE)

13608

report_error(table, error);

4002

table->report_error(error);

13609

4003

return -1;

13610

4004

}

4005

13611

4006

return 0;

13612

4007

}

13613

4008

13614

13615

static int

13616

join_read_next_different(READ_RECORD *info)

4009

int join_read_next_different(READ_RECORD *info)

13617

4010

{

13618

JOIN_TAB *tab= info->do_insideout_scan;

4011

JoinTable *tab= info->do_insideout_scan;

13619

4012

if (tab->insideout_match_tab->found_match)

13620

4013

{

13621

4014

KEY *key= tab->table->key_info + tab->index;

13622

4015

13623

4016

{

13624

4017

int error;

13625

4018

/* Save index tuple from record to the buffer */

13626

4019

key_copy(tab->insideout_buf, info->record, key, 0);

13627

4020

13628

if ((error=info->file->index_next(info->record)))

13629

return report_error(info->table, error);

13630

13631

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

4021

if ((error=info->cursor->index_next(info->record)))

4022

return info->table->report_error(error);

4023

} while (!key_cmp(tab->table->key_info[tab->index].key_part,

13632

4024

tab->insideout_buf, key->key_length));

13633

4025

tab->insideout_match_tab->found_match= 0;

13634

4026

return 0;

13637

4029

return join_read_next(info);

13638

4030

}

13639

4031

13640

13641

static int

13642

join_read_next(READ_RECORD *info)

4032

int join_read_next(READ_RECORD *info)

13643

4033

{

13644

4034

int error;

13645

if ((error=info->file->index_next(info->record)))

13646

return report_error(info->table, error);

4035

if ((error=info->cursor->index_next(info->record)))

4036

return info->table->report_error(error);

13647

4037

return 0;

13648

4038

}

13649

4039

13650

13651

static int

13652

join_read_last(JOIN_TAB *tab)

4040

int join_read_last(JoinTable *tab)

13653

4041

{

13654

TABLE *table=tab->table;

4042

Table *table=tab->table;

13655

4043

int error;

13656

if (!table->key_read && table->covering_keys.is_set(tab->index) &&

4044

if (!table->key_read && table->covering_keys.test(tab->index) &&

13657

4045

!table->no_keyread)

13658

4046

{

13659

4047

table->key_read=1;

13660

table->file->extra(HA_EXTRA_KEYREAD);

4048

table->cursor->extra(HA_EXTRA_KEYREAD);

13661

4049

}

13662

4050

tab->table->status=0;

13663

4051

tab->read_record.read_record=join_read_prev;

13664

4052

tab->read_record.table=table;

13665

tab->read_record.file=table->file;

4053

tab->read_record.cursor=table->cursor;

13666

4054

tab->read_record.index=tab->index;

13667

4055

tab->read_record.record=table->record[0];

13668

if (!table->file->inited)

13669

table->file->ha_index_init(tab->index, 1);

13670

if ((error= tab->table->file->index_last(tab->table->record[0])))

13671

return report_error(table, error);

4056

if (!table->cursor->inited)

4057

table->cursor->ha_index_init(tab->index, 1);

4058

if ((error= tab->table->cursor->index_last(tab->table->record[0])))

4059

return table->report_error(error);

4060

13672

4061

return 0;

13673

4062

}

13674

4063

13675

13676

static int

13677

join_read_prev(READ_RECORD *info)

4064

int join_read_prev(READ_RECORD *info)

13678

4065

{

13679

4066

int error;

13680

if ((error= info->file->index_prev(info->record)))

13681

return report_error(info->table, error);

4067

if ((error= info->cursor->index_prev(info->record)))

4068

return info->table->report_error(error);

4069

13682

4070

return 0;

13683

4071

}

13684

4072

13685

4073

/**

13686

4074

Reading of key with key reference and one part that may be NULL.

13687

4075

13688

13689

int

13690

join_read_always_key_or_null(JOIN_TAB *tab)

4076

int join_read_always_key_or_null(JoinTable *tab)

13691

4077

{

13692

4078

int res;

13693

4079

13701

4087

return safe_index_read(tab);

13702

4088

}

13703

4089

13704

13705

int

13706

join_read_next_same_or_null(READ_RECORD *info)

4090

int join_read_next_same_or_null(READ_RECORD *info)

13707

4091

{

13708

4092

int error;

13709

4093

if ((error= join_read_next_same(info)) >= 0)

13710

4094

return error;

13711

JOIN_TAB *tab= info->table->reginfo.join_tab;

4095

JoinTable *tab= info->table->reginfo.join_tab;

13712

4096

13713

4097

/* Test if we have already done a read after null key */

13714

4098

if (*tab->ref.null_ref_key)

13717

4101

return safe_index_read(tab); // then read null keys

13718

4102

}

13719

4103

13720

13721

/*****************************************************************************

13722

DESCRIPTION

13723

Functions that end one nested loop iteration. Different functions

13724

are used to support GROUP BY clause and to redirect records

13725

to a table (e.g. in case of SELECT into a temporary table) or to the

13726

network client.

13727

13728

RETURN VALUES

13729

NESTED_LOOP_OK - the record has been successfully handled

13730

NESTED_LOOP_ERROR - a fatal error (like table corruption)

13731

was detected

13732

NESTED_LOOP_KILLED - thread shutdown was requested while processing

13733

the record

13734

NESTED_LOOP_QUERY_LIMIT - the record has been successfully handled;

13735

additionally, the nested loop produced the

13736

number of rows specified in the LIMIT clause

13737

for the query

13738

NESTED_LOOP_CURSOR_LIMIT - the record has been successfully handled;

13739

additionally, there is a cursor and the nested

13740

loop algorithm produced the number of rows

13741

that is specified for current cursor fetch

13742

operation.

13743

All return values except NESTED_LOOP_OK abort the nested loop.

13744

*****************************************************************************/

13745

13746

/* ARGSUSED */

13747

static enum_nested_loop_state

13748

end_send(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

13749

bool end_of_records)

13750

{

13751

if (!end_of_records)

13752

{

13753

int error;

13754

if (join->having && join->having->val_int() == 0)

13755

return(NESTED_LOOP_OK); // Didn't match having

13756

error=0;

13757

if (join->do_send_rows)

13758

error=join->result->send_data(*join->fields);

13759

if (error)

13760

return(NESTED_LOOP_ERROR); /* purecov: inspected */

13761

if (++join->send_records >= join->unit->select_limit_cnt &&

13762

join->do_send_rows)

13763

{

13764

if (join->select_options & OPTION_FOUND_ROWS)

13765

{

13766

JOIN_TAB *jt=join->join_tab;

13767

if ((join->tables == 1) && !join->tmp_table && !join->sort_and_group

13768

&& !join->send_group_parts && !join->having && !jt->select_cond &&

13769

!(jt->select && jt->select->quick) &&

13770

(jt->table->file->ha_table_flags() & HA_STATS_RECORDS_IS_EXACT) &&

13771

(jt->ref.key < 0))

13772

{

13773

/* Join over all rows in table; Return number of found rows */

13774

TABLE *table=jt->table;

13775

13776

join->select_options ^= OPTION_FOUND_ROWS;

13777

if (table->sort.record_pointers ||

13778

(table->sort.io_cache && my_b_inited(table->sort.io_cache)))

13779

{

13780

/* Using filesort */

13781

join->send_records= table->sort.found_records;

13782

}

13783

else

13784

{

13785

table->file->info(HA_STATUS_VARIABLE);

13786

join->send_records= table->file->stats.records;

13787

}

13788

}

13789

else

13790

{

13791

join->do_send_rows= 0;

13792

if (join->unit->fake_select_lex)

13793

join->unit->fake_select_lex->select_limit= 0;

13794

return(NESTED_LOOP_OK);

13795

}

13796

}

13797

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

13798

}

13799

else if (join->send_records >= join->fetch_limit)

13800

{

13801

13802

There is a server side cursor and all rows for

13803

this fetch request are sent.

13804

13805

return(NESTED_LOOP_CURSOR_LIMIT);

13806

}

13807

}

13808

13809

return(NESTED_LOOP_OK);

13810

}

13811

13812

13813

/* ARGSUSED */

13814

enum_nested_loop_state

13815

end_send_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

13816

bool end_of_records)

4104

enum_nested_loop_state end_send_group(JOIN *join, JoinTable *, bool end_of_records)

13817

4105

{

13818

4106

int idx= -1;

13819

4107

enum_nested_loop_state ok_code= NESTED_LOOP_OK;

13821

4109

if (!join->first_record || end_of_records ||

13822

4110

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

13823

4111

{

13824

if (join->first_record ||

4112

if (join->first_record ||

13825

4113

(end_of_records && !join->group && !join->group_optimized_away))

13826

4114

{

13827

4115

if (idx < (int) join->send_group_parts)

13828

4116

{

13829

int error=0;

13830

{

13831

if (!join->first_record)

13832

{

13833

List_iterator_fast<Item> it(*join->fields);

13834

Item *item;

13835

/* No matching rows for group function */

13836

join->clear();

4117

int error=0;

4118

{

4119

if (!join->first_record)

4120

{

4121

List_iterator_fast<Item> it(*join->fields);

4122

Item *item;

4123

/* No matching rows for group function */

4124

join->clear();

13837

4125

13838

4126

while ((item= it++))

13839

4127

item->no_rows_in_result();

13840

}

13841

if (join->having && join->having->val_int() == 0)

13842

error= -1; // Didn't satisfy having

13843

else

13844

{

13845

if (join->do_send_rows)

13846

error=join->result->send_data(*join->fields) ? 1 : 0;

13847

join->send_records++;

13848

}

13849

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

13850

{

13851

if (join->rollup_send_data((uint) (idx+1)))

13852

error= 1;

13853

}

13854

}

13855

if (error > 0)

13856

return(NESTED_LOOP_ERROR); /* purecov: inspected */

13857

if (end_of_records)

13858

return(NESTED_LOOP_OK);

13859

if (join->send_records >= join->unit->select_limit_cnt &&

13860

join->do_send_rows)

13861

{

13862

if (!(join->select_options & OPTION_FOUND_ROWS))

13863

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

13864

join->do_send_rows=0;

13865

join->unit->select_limit_cnt = HA_POS_ERROR;

4128

}

4129

if (join->having && join->having->val_int() == 0)

4130

error= -1; // Didn't satisfy having

4131

else

4132

{

4133

if (join->do_send_rows)

4134

error=join->result->send_data(*join->fields) ? 1 : 0;

4135

join->send_records++;

4136

}

4137

if (join->rollup.state != ROLLUP::STATE_NONE && error <= 0)

4138

{

4139

if (join->rollup_send_data((uint32_t) (idx+1)))

4140

error= 1;

4141

}

4142

}

4143

if (error > 0)

4144

return(NESTED_LOOP_ERROR);

4145

if (end_of_records)

4146

return(NESTED_LOOP_OK);

4147

if (join->send_records >= join->unit->select_limit_cnt &&

4148

join->do_send_rows)

4149

{

4150

if (!(join->select_options & OPTION_FOUND_ROWS))

4151

return(NESTED_LOOP_QUERY_LIMIT); // Abort nicely

4152

join->do_send_rows=0;

4153

join->unit->select_limit_cnt = HA_POS_ERROR;

13866

4154

}

13867

4155

else if (join->send_records >= join->fetch_limit)

13868

4156

{

13881

4169

else

13882

4170

{

13883

4171

if (end_of_records)

13884

return(NESTED_LOOP_OK);

4172

return(NESTED_LOOP_OK);

13885

4173

join->first_record=1;

13886

VOID(test_if_item_cache_changed(join->group_fields));

4174

test_if_item_cache_changed(join->group_fields);

13887

4175

}

13888

4176

if (idx < (int) join->send_group_parts)

13889

4177

{

13893

4181

13894

4182

copy_fields(&join->tmp_table_param);

13895

4183

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

13896

return(NESTED_LOOP_ERROR);

4184

return(NESTED_LOOP_ERROR);

13897

4185

return(ok_code);

13898

4186

}

13899

4187

}

13902

4190

return(NESTED_LOOP_OK);

13903

4191

}

13904

4192

13905

13906

/* ARGSUSED */

13907

enum_nested_loop_state

13908

end_write(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

13909

bool end_of_records)

13910

{

13911

TABLE *table=join->tmp_table;

13912

13913

if (join->thd->killed) // Aborted by user

13914

{

13915

join->thd->send_kill_message();

13916

return(NESTED_LOOP_KILLED); /* purecov: inspected */

13917

}

13918

if (!end_of_records)

13919

{

13920

copy_fields(&join->tmp_table_param);

13921

copy_funcs(join->tmp_table_param.items_to_copy);

13922

#ifdef TO_BE_DELETED

13923

if (!table->uniques) // If not unique handling

13924

{

13925

/* Copy null values from group to row */

13926

ORDER *group;

13927

for (group=table->group ; group ; group=group->next)

13928

{

13929

Item *item= *group->item;

13930

if (item->maybe_null)

13931

{

13932

Field *field=item->get_tmp_table_field();

13933

field->ptr[-1]= (uchar) (field->is_null() ? 1 : 0);

13934

}

13935

}

13936

}

13937

#endif

13938

if (!join->having || join->having->val_int())

13939

{

13940

int error;

13941

join->found_records++;

13942

if ((error=table->file->ha_write_row(table->record[0])))

13943

{

13944

if (!table->file->is_fatal_error(error, HA_CHECK_DUP))

13945

goto end;

13946

if (create_myisam_from_heap(join->thd, table,

13947

join->tmp_table_param.start_recinfo,

13948

&join->tmp_table_param.recinfo,

13949

error, 1))

13950

return(NESTED_LOOP_ERROR); // Not a table_is_full error

13951

table->s->uniques=0; // To ensure rows are the same

13952

}

13953

if (++join->send_records >= join->tmp_table_param.end_write_records &&

13954

join->do_send_rows)

13955

{

13956

if (!(join->select_options & OPTION_FOUND_ROWS))

13957

return(NESTED_LOOP_QUERY_LIMIT);

13958

join->do_send_rows=0;

13959

join->unit->select_limit_cnt = HA_POS_ERROR;

13960

return(NESTED_LOOP_OK);

13961

}

13962

}

13963

}

13964

end:

13965

return(NESTED_LOOP_OK);

13966

}

13967

13968

/* ARGSUSED */

13969

/** Group by searching after group record and updating it if possible. */

13970

13971

static enum_nested_loop_state

13972

end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

13973

bool end_of_records)

13974

{

13975

TABLE *table=join->tmp_table;

13976

ORDER *group;

13977

int error;

13978

13979

if (end_of_records)

13980

return(NESTED_LOOP_OK);

13981

if (join->thd->killed) // Aborted by user

13982

{

13983

join->thd->send_kill_message();

13984

return(NESTED_LOOP_KILLED); /* purecov: inspected */

13985

}

13986

13987

join->found_records++;

13988

copy_fields(&join->tmp_table_param); // Groups are copied twice.

13989

/* Make a key of group index */

13990

for (group=table->group ; group ; group=group->next)

13991

{

13992

Item *item= *group->item;

13993

item->save_org_in_field(group->field);

13994

/* Store in the used key if the field was 0 */

13995

if (item->maybe_null)

13996

group->buff[-1]= (char) group->field->is_null();

13997

}

13998

if (!table->file->index_read_map(table->record[1],

13999

join->tmp_table_param.group_buff,

14000

HA_WHOLE_KEY,

14001

HA_READ_KEY_EXACT))

14002

{ /* Update old record */

14003

restore_record(table,record[1]);

14004

update_tmptable_sum_func(join->sum_funcs,table);

14005

if ((error=table->file->ha_update_row(table->record[1],

14006

table->record[0])))

14007

{

14008

table->file->print_error(error,MYF(0)); /* purecov: inspected */

14009

return(NESTED_LOOP_ERROR); /* purecov: inspected */

14010

}

14011

return(NESTED_LOOP_OK);

14012

}

14013

14014

14015

Copy null bits from group key to table

14016

We can't copy all data as the key may have different format

14017

as the row data (for example as with VARCHAR keys)

14018

14019

KEY_PART_INFO *key_part;

14020

for (group=table->group,key_part=table->key_info[0].key_part;

14021

group ;

14022

group=group->next,key_part++)

14023

{

14024

if (key_part->null_bit)

14025

memcpy(table->record[0]+key_part->offset, group->buff, 1);

14026

}

14027

init_tmptable_sum_functions(join->sum_funcs);

14028

copy_funcs(join->tmp_table_param.items_to_copy);

14029

if ((error=table->file->ha_write_row(table->record[0])))

14030

{

14031

if (create_myisam_from_heap(join->thd, table,

14032

join->tmp_table_param.start_recinfo,

14033

&join->tmp_table_param.recinfo,

14034

error, 0))

14035

return(NESTED_LOOP_ERROR); // Not a table_is_full error

14036

/* Change method to update rows */

14037

table->file->ha_index_init(0, 0);

14038

join->join_tab[join->tables-1].next_select=end_unique_update;

14039

}

14040

join->send_records++;

14041

return(NESTED_LOOP_OK);

14042

}

14043

14044

14045

/** Like end_update, but this is done with unique constraints instead of keys. */

14046

14047

static enum_nested_loop_state

14048

end_unique_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

14049

bool end_of_records)

14050

{

14051

TABLE *table=join->tmp_table;

14052

int error;

14053

14054

if (end_of_records)

14055

return(NESTED_LOOP_OK);

14056

if (join->thd->killed) // Aborted by user

14057

{

14058

join->thd->send_kill_message();

14059

return(NESTED_LOOP_KILLED); /* purecov: inspected */

14060

}

14061

14062

init_tmptable_sum_functions(join->sum_funcs);

14063

copy_fields(&join->tmp_table_param); // Groups are copied twice.

14064

copy_funcs(join->tmp_table_param.items_to_copy);

14065

14066

if (!(error=table->file->ha_write_row(table->record[0])))

14067

join->send_records++; // New group

14068

else

14069

{

14070

if ((int) table->file->get_dup_key(error) < 0)

14071

{

14072

table->file->print_error(error,MYF(0)); /* purecov: inspected */

14073

return(NESTED_LOOP_ERROR); /* purecov: inspected */

14074

}

14075

if (table->file->rnd_pos(table->record[1],table->file->dup_ref))

14076

{

14077

table->file->print_error(error,MYF(0)); /* purecov: inspected */

14078

return(NESTED_LOOP_ERROR); /* purecov: inspected */

14079

}

14080

restore_record(table,record[1]);

14081

update_tmptable_sum_func(join->sum_funcs,table);

14082

if ((error=table->file->ha_update_row(table->record[1],

14083

table->record[0])))

14084

{

14085

table->file->print_error(error,MYF(0)); /* purecov: inspected */

14086

return(NESTED_LOOP_ERROR); /* purecov: inspected */

14087

}

14088

}

14089

return(NESTED_LOOP_OK);

14090

}

14091

14092

14093

/* ARGSUSED */

14094

enum_nested_loop_state

14095

end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),

14096

bool end_of_records)

14097

{

14098

TABLE *table=join->tmp_table;

4193

enum_nested_loop_state end_write_group(JOIN *join, JoinTable *, bool end_of_records)

4194

{

4195

Table *table=join->tmp_table;

14099

4196

int idx= -1;

14100

4197

14101

if (join->thd->killed)

4198

if (join->session->killed)

14102

4199

{ // Aborted by user

14103

join->thd->send_kill_message();

14104

return(NESTED_LOOP_KILLED); /* purecov: inspected */

4200

join->session->send_kill_message();

4201

return NESTED_LOOP_KILLED;

14105

4202

}

14106

4203

if (!join->first_record || end_of_records ||

14107

4204

(idx=test_if_item_cache_changed(join->group_fields)) >= 0)

14111

4208

int send_group_parts= join->send_group_parts;

14112

4209

if (idx < send_group_parts)

14113

4210

{

14114

if (!join->first_record)

14115

{

14116

/* No matching rows for group function */

14117

join->clear();

14118

}

14119

copy_sum_funcs(join->sum_funcs,

14120

join->sum_funcs_end[send_group_parts]);

14121

if (!join->having || join->having->val_int())

14122

{

14123

int error= table->file->ha_write_row(table->record[0]);

14124

if (error && create_myisam_from_heap(join->thd, table,

14125

join->tmp_table_param.start_recinfo,

4211

if (!join->first_record)

4212

{

4213

/* No matching rows for group function */

4214

join->clear();

4215

}

4216

copy_sum_funcs(join->sum_funcs, join->sum_funcs_end[send_group_parts]);

4217

if (!join->having || join->having->val_int())

4218

{

4219

int error= table->cursor->ha_write_row(table->record[0]);

4220

if (error && create_myisam_from_heap(join->session, table,

4221

join->tmp_table_param.start_recinfo,

14126

4222

&join->tmp_table_param.recinfo,

14127

error, 0))

14128

return(NESTED_LOOP_ERROR);

4223

error, 0))

4224

return NESTED_LOOP_ERROR;

14129

4225

}

14130

4226

if (join->rollup.state != ROLLUP::STATE_NONE)

14131

{

14132

if (join->rollup_write_data((uint) (idx+1), table))

14133

return(NESTED_LOOP_ERROR);

14134

}

14135

if (end_of_records)

14136

return(NESTED_LOOP_OK);

4227

{

4228

if (join->rollup_write_data((uint32_t) (idx+1), table))

4229

return NESTED_LOOP_ERROR;

4230

}

4231

if (end_of_records)

4232

return NESTED_LOOP_OK;

14137

4233

}

14138

4234

}

14139

4235

else

14140

4236

{

14141

4237

if (end_of_records)

14142

return(NESTED_LOOP_OK);

4238

return NESTED_LOOP_OK;

14143

4239

join->first_record=1;

14144

VOID(test_if_item_cache_changed(join->group_fields));

4240

test_if_item_cache_changed(join->group_fields);

14145

4241

}

14146

4242

if (idx < (int) join->send_group_parts)

14147

4243

{

14148

4244

copy_fields(&join->tmp_table_param);

14149

4245

copy_funcs(join->tmp_table_param.items_to_copy);

14150

4246

if (init_sum_functions(join->sum_funcs, join->sum_funcs_end[idx+1]))

14151

return(NESTED_LOOP_ERROR);

14152

return(NESTED_LOOP_OK);

4247

return NESTED_LOOP_ERROR;

4248

return NESTED_LOOP_OK;

14153

4249

}

14154

4250

}

14155

4251

if (update_sum_func(join->sum_funcs))

14156

return(NESTED_LOOP_ERROR);

14157

return(NESTED_LOOP_OK);

4252

return NESTED_LOOP_ERROR;

4253

return NESTED_LOOP_OK;

14158

4254

}

14159

4255

14160

14161

4256

/*****************************************************************************

14162

4257

Remove calculation with tables that aren't yet read. Remove also tests

14163

4258

against fields that are read through key where the table is not a

14170

4265

@return

14171

4266

1 if right_item is used removable reference key on left_item

14172

4267

14173

14174

static bool test_if_ref(Item_field *left_item,Item *right_item)

4268

bool test_if_ref(Item_field *left_item,Item *right_item)

14175

4269

{

14176

4270

Field *field=left_item->field;

14177

4271

// No need to change const test. We also have to keep tests on LEFT JOIN

14182

4276

{

14183

4277

right_item= right_item->real_item();

14184

4278

if (right_item->type() == Item::FIELD_ITEM)

14185

return (field->eq_def(((Item_field *) right_item)->field));

4279

return (field->eq_def(((Item_field *) right_item)->field));

14186

4280

/* remove equalities injected by IN->EXISTS transformation */

14187

4281

else if (right_item->type() == Item::CACHE_ITEM)

14188

4282

return ((Item_cache *)right_item)->eq_def (field);

14189

4283

if (right_item->const_item() && !(right_item->is_null()))

14190

4284

{

14191

14192

We can remove binary fields and numerical fields except float,

14193

as float comparison isn't 100 % secure

14194

We have to keep normal strings to be able to check for end spaces

4285

4286

We can remove binary fields and numerical fields except float,

4287

as float comparison isn't 100 % secure

4288

We have to keep normal strings to be able to check for end spaces

14195

4289

14196

sergefp: the above seems to be too restrictive. Counterexample:

14197

create table t100 (v varchar(10), key(v)) default charset=latin1;

14198

insert into t100 values ('a'),('a ');

14199

explain select * from t100 where v='a';

14200

The EXPLAIN shows 'using Where'. Running the query returns both

14201

rows, so it seems there are no problems with endspace in the most

14202

frequent case?

14203

14204

if (field->binary() &&

14205

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

14206

field->decimals() == 0)

14207

{

14208

return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);

14209

}

4290

sergefp: the above seems to be too restrictive. Counterexample:

4291

create table t100 (v varchar(10), key(v)) default charset=latin1;

4292

insert into t100 values ('a'),('a ');

4293

explain select * from t100 where v='a';

4294

The EXPLAIN shows 'using Where'. Running the query returns both

4295

rows, so it seems there are no problems with endspace in the most

4296

frequent case?

4297

4298

if (field->binary() &&

4299

field->real_type() != DRIZZLE_TYPE_VARCHAR &&

4300

field->decimals() == 0)

4301

{

4302

return ! store_val_in_field(field, right_item, CHECK_FIELD_WARN);

4303

}

14210

4304

}

14211

4305

}

14212

4306

}

14213

return 0; // keep test

14214

}

14215

14216

/**

14217

@brief Replaces an expression destructively inside the expression tree of

14218

the WHERE clase.

14219

14220

@note Because of current requirements for semijoin flattening, we do not

14221

need to recurse here, hence this function will only examine the top-level

14222

AND conditions. (see JOIN::prepare, comment above the line

14223

'if (do_materialize)'

14224

14225

@param join The top-level query.

14226

@param old_cond The expression to be replaced.

14227

@param new_cond The expression to be substituted.

14228

@param do_fix_fields If true, Item::fix_fields(THD*, Item**) is called for

14229

the new expression.

14230

@return <code>true</code> if there was an error, <code>false</code> if

14231

successful.

14232

14233

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

14234

Item *new_cond, bool do_fix_fields)

14235

{

14236

if (join->conds == old_cond) {

14237

join->conds= new_cond;

14238

if (do_fix_fields)

14239

new_cond->fix_fields(join->thd, &join->conds);

14240

return false;

14241

}

14242

14243

if (join->conds->type() == Item::COND_ITEM) {

14244

List_iterator<Item> li(*((Item_cond*)join->conds)->argument_list());

14245

Item *item;

14246

while ((item= li++))

14247

if (item == old_cond)

14248

{

14249

li.replace(new_cond);

14250

if (do_fix_fields)

14251

new_cond->fix_fields(join->thd, li.ref());

14252

return false;

14253

}

14254

}

14255

14256

return true;

4307

return 0;

14257

4308

}

14258

4309

14259

4310

14260

4311

Extract a condition that can be checked after reading given table

14261

4312

14262

4313

SYNOPSIS

14263

4314

make_cond_for_table()

14264

4315

cond Condition to analyze

14265

4316

tables Tables for which "current field values" are available

14266

used_table Table that we're extracting the condition for (may

4317

used_table Table that we're extracting the condition for (may

14267

4318

also include PSEUDO_TABLE_BITS

14268

4319

14269

4320

DESCRIPTION

14273

4324

14274

4325

The function assumes that

14275

4326

- Constant parts of the condition has already been checked.

14276

- Condition that could be checked for tables in 'tables' has already

4327

- Condition that could be checked for tables in 'tables' has already

14277

4328

been checked.

14278

4329

14279

4330

The function takes into account that some parts of the condition are

14280

4331

guaranteed to be true by employed 'ref' access methods (the code that

14281

4332

does this is located at the end, search down for "EQ_FUNC").

14282

4333

14283

4334

14284