~drizzle-trunk/drizzle/development

(!tab->const_keys.none() && (i == join->const_tables) && (join->unit->select_limit_cnt < join->best_positions[i].records_read) && ((join->select_options & OPTION_FOUND_ROWS) == false)))

5012

{

5013

/* Join with outer join condition */

5014

COND *orig_cond=sel->cond;

5015

sel->cond= and_conds(sel->cond, *tab->on_expr_ref);

5016

5017

5018

We can't call sel->cond->fix_fields,

5019

as it will break tab->on_expr if it's AND condition

5020

(fix_fields currently removes extra AND/OR levels).

5021

Yet attributes of the just built condition are not needed.

5022

Thus we call sel->cond->quick_fix_field for safety.

5023

5024

if (sel->cond && !sel->cond->fixed)

5025

sel->cond->quick_fix_field();

5026

5027

if (sel->test_quick_select(session, tab->keys,

5028

used_tables & ~ current_map,

5029

(join->select_options &

5030

OPTION_FOUND_ROWS ?

5031

HA_POS_ERROR :

5032

join->unit->select_limit_cnt), 0,

5033

false) < 0)

4721

5034

{

4722

4723

Before reporting "Impossible WHERE" for the whole query

4724

we have to check isn't it only "impossible ON" instead

4725

5035

5036

Before reporting "Impossible WHERE" for the whole query

5037

we have to check isn't it only "impossible ON" instead

5038

4726

5039

sel->cond=orig_cond;

4727

if (! *tab->on_expr_ref ||

5040

if (!*tab->on_expr_ref ||

4728

5041

sel->test_quick_select(session, tab->keys,

4729

used_tables & ~ current_map,

4730

(join->select_options &

4731

OPTION_FOUND_ROWS ?

4732

HA_POS_ERROR :

4733

join->unit->select_limit_cnt),0,

4734

false) < 0)

4735

return 1; // Impossible WHERE

5042

used_tables & ~ current_map,

5043

(join->select_options &

5044

OPTION_FOUND_ROWS ?

5045

HA_POS_ERROR :

5046

join->unit->select_limit_cnt),0,

5047

false) < 0)

5048

return(1); // Impossible WHERE

4736

5049

}

4737

5050

else

4738

sel->cond=orig_cond;

5051

sel->cond=orig_cond;

4739

5052

4740

/* Fix for EXPLAIN */

4741

if (sel->quick)

4742

{

4743

cur_pos= join->getPosFromOptimalPlan(i);

4744

cur_pos.setFanout(static_cast<double>(sel->quick->records));

4745

}

4746

}

4747

else

4748

{

4749

sel->needed_reg= tab->needed_reg;

4750

sel->quick_keys.reset();

4751

}

5053

/* Fix for EXPLAIN */

5054

if (sel->quick)

5055

join->best_positions[i].records_read= (double)sel->quick->records;

5056

}

5057

else

5058

{

5059

sel->needed_reg=tab->needed_reg;

5060

sel->quick_keys.reset();

5061

}

4752

5062

if (!((tab->checked_keys & sel->quick_keys) == sel->quick_keys) ||

4753

5063

!((tab->checked_keys & sel->needed_reg) == sel->needed_reg))

4754

{

4755

tab->keys= sel->quick_keys;

5064

{

5065

tab->keys= sel->quick_keys;

4756

5066

tab->keys|= sel->needed_reg;

4757

tab->use_quick= (!sel->needed_reg.none() &&

4758

(select->quick_keys.none() ||

4759

(select->quick &&

4760

(select->quick->records >= 100L)))) ?

4761

2 : 1;

4762

sel->read_tables= used_tables & ~current_map;

4763

}

4764

if (i != join->const_tables && tab->use_quick != 2)

4765

{ /* Read with cache */

4766

if (cond &&

5067

tab->use_quick= (!sel->needed_reg.none() &&

5068

(select->quick_keys.none() ||

5069

(select->quick &&

5070

(select->quick->records >= 100L)))) ?

5071

2 : 1;

5072

sel->read_tables= used_tables & ~current_map;

5073

}

5074

if (i != join->const_tables && tab->use_quick != 2)

5075

{ /* Read with cache */

5076

if (cond &&

4767

5077

(tmp=make_cond_for_table(cond,

4768

join->const_table_map |

4769

current_map,

4770

current_map, 0)))

4771

{

4772

tab->cache.select= (optimizer::SqlSelect*)

4773

session->memdup((unsigned char*) sel, sizeof(optimizer::SqlSelect));

4774

tab->cache.select->cond= tmp;

4775

tab->cache.select->read_tables= join->const_table_map;

4776

}

4777

}

4778

}

5078

join->const_table_map |

5079

current_map,

5080

current_map, 0)))

5081

{

5082

tab->cache.select=(SQL_SELECT*)

5083

session->memdup((unsigned char*) sel, sizeof(SQL_SELECT));

5084

tab->cache.select->cond=tmp;

5085

tab->cache.select->read_tables=join->const_table_map;

5086

}

5087

}

5088

}

4779

5089

}

4780

5090

4781

5091

4782

Push down conditions from all on expressions.

4783

Each of these conditions are guarded by a variable

4784

that turns if off just before null complemented row for

4785

outer joins is formed. Thus, the condition from an

4786

'on expression' are guaranteed not to be checked for

4787

the null complemented row.

4788

5092

Push down conditions from all on expressions.

5093

Each of these conditions are guarded by a variable

5094

that turns if off just before null complemented row for

5095

outer joins is formed. Thus, the condition from an

5096

'on expression' are guaranteed not to be checked for

5097

the null complemented row.

5098

4789

5099

4790

5100

/* First push down constant conditions from on expressions */

4791

for (JoinTable *join_tab= join->join_tab+join->const_tables;

4792

join_tab < join->join_tab+join->tables ; join_tab++)

5101

for (JOIN_TAB *join_tab= join->join_tab+join->const_tables;

5102

join_tab < join->join_tab+join->tables ; join_tab++)

4793

5103

{

4794

5104

if (*join_tab->on_expr_ref)

4795

5105

{

4796

JoinTable *cond_tab= join_tab->first_inner;

5106

JOIN_TAB *cond_tab= join_tab->first_inner;

4797

5107

tmp= make_cond_for_table(*join_tab->on_expr_ref,

4798

join->const_table_map,

4799

(table_map) 0, 0);

5108

join->const_table_map,

5109

(table_map) 0, 0);

4800

5110

if (!tmp)

4801

5111

continue;

4802

5112

tmp= new Item_func_trig_cond(tmp, &cond_tab->not_null_compl);

4803

if (! tmp)

4804

return 1;

5113

if (!tmp)

5114

return(1);

4805

5115

tmp->quick_fix_field();

4806

5116

cond_tab->select_cond= !cond_tab->select_cond ? tmp :

4807

new Item_cond_and(cond_tab->select_cond,tmp);

4808

if (! cond_tab->select_cond)

4809

return 1;

5117

new Item_cond_and(cond_tab->select_cond,tmp);

5118

if (!cond_tab->select_cond)

5119

return(1);

4810

5120

cond_tab->select_cond->quick_fix_field();

4811

5121

}

4812

5122

}

4813

5123

4814

5124

/* Push down non-constant conditions from on expressions */

4815

JoinTable *last_tab= tab;

5125

JOIN_TAB *last_tab= tab;

4816

5126

while (first_inner_tab && first_inner_tab->last_inner == last_tab)

4817

5127

{

4818

5128

4819

Table tab is the last inner table of an outer join.

4820

An on expression is always attached to it.

4821

5129

Table tab is the last inner table of an outer join.

5130

An on expression is always attached to it.

5131

4822

5132

COND *on_expr= *first_inner_tab->on_expr_ref;

4823

5133

4824

5134

table_map used_tables2= (join->const_table_map |

4825

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

4826

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

5135

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

5136

for (tab= join->join_tab+join->const_tables; tab <= last_tab ; tab++)

4827

5137

{

4828

5138

current_map= tab->table->map;

4829

5139

used_tables2|= current_map;

4830

5140

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

4831

current_map, 0);

5141

current_map, 0);

4832

5142

if (tmp_cond)

4833

5143

{

4834

JoinTable *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

5144

JOIN_TAB *cond_tab= tab < first_inner_tab ? first_inner_tab : tab;

4835

5145

4836

First add the guards for match variables of

4837

all embedding outer join operations.

4838

5146

First add the guards for match variables of

5147

all embedding outer join operations.

5148

4839

5149

if (!(tmp_cond= add_found_match_trig_cond(cond_tab->first_inner,

4840

tmp_cond,

4841

first_inner_tab)))

4842

return 1;

5150

tmp_cond,

5151

first_inner_tab)))

5152

return(1);

4843

5153

4844

Now add the guard turning the predicate off for

4845

the null complemented row.

4846

5154

Now add the guard turning the predicate off for

5155

the null complemented row.

5156

4847

5157

tmp_cond= new Item_func_trig_cond(tmp_cond,

4848

&first_inner_tab->

4849

not_null_compl);

5158

&first_inner_tab->

5159

not_null_compl);

4850

5160

if (tmp_cond)

4851

5161

tmp_cond->quick_fix_field();

4852

/* Add the predicate to other pushed down predicates */

5162

/* Add the predicate to other pushed down predicates */

4853

5163

cond_tab->select_cond= !cond_tab->select_cond ? tmp_cond :

4854

new Item_cond_and(cond_tab->select_cond,

4855

tmp_cond);

4856

if (! cond_tab->select_cond)

4857

return 1;

5164

new Item_cond_and(cond_tab->select_cond,

5165

tmp_cond);

5166

if (!cond_tab->select_cond)

5167

return(1);

4858

5168

cond_tab->select_cond->quick_fix_field();

4859

5169

}

4860

5170

}

4886

5196

false - OK

4887

5197

true - Out of memory

4888

5198

4889

static bool make_join_readinfo(Join *join)

5199

static bool make_join_readinfo(JOIN *join, uint64_t options, uint32_t no_jbuf_after)

4890

5200

{

4891

bool sorted= true;

5201

uint32_t i;

5202

bool statistics= test(!(join->select_options & SELECT_DESCRIBE));

5203

bool sorted= 1;

4892

5204

4893

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

5205

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

4894

5206

{

4895

JoinTable *tab=join->join_tab+i;

5207

JOIN_TAB *tab=join->join_tab+i;

4896

5208

Table *table=tab->table;

5209

bool using_join_cache;

4897

5210

tab->read_record.table= table;

4898

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

5211

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

4899

5212

tab->next_select=sub_select; /* normal select */

4900

5213

4901

5214

TODO: don't always instruct first table's ref/range access method to

4902

5215

produce sorted output.

4903

5216

4904

5217

tab->sorted= sorted;

4905

sorted= false; // only first must be sorted

4906

5218

sorted= 0; // only first must be sorted

4907

5219

if (tab->insideout_match_tab)

4908

5220

{

4909

if (! (tab->insideout_buf= (unsigned char*) join->session->alloc(tab->table->key_info

4910

[tab->index].

4911

key_length)))

5221

if (!(tab->insideout_buf= (unsigned char*)join->session->alloc(tab->table->key_info

5222

[tab->index].

5223

key_length)))

4912

5224

return true;

4913

5225

}

4914

4915

optimizer::AccessMethodFactory &factory= optimizer::AccessMethodFactory::singleton();

4916

boost::shared_ptr<optimizer::AccessMethod> access_method(factory.createAccessMethod(tab->type));

4917

4918

if (! access_method)

4919

{

4920

/**

4921

* @todo

4922

* Is abort() the correct thing to call here? I call this here because it was what was called in

4923

* the default case for the switch statement that used to be here.

4924

4925

abort();

5226

switch (tab->type) {

5227

case JT_SYSTEM: // Only happens with left join

5228

table->status=STATUS_NO_RECORD;

5229

tab->read_first_record= join_read_system;

5230

tab->read_record.read_record= join_no_more_records;

5231

break;

5232

case JT_CONST: // Only happens with left join

5233

table->status=STATUS_NO_RECORD;

5234

tab->read_first_record= join_read_const;

5235

tab->read_record.read_record= join_no_more_records;

5236

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

5237

!table->no_keyread)

5238

{

5239

table->key_read=1;

5240

table->file->extra(HA_EXTRA_KEYREAD);

5241

}

5242

break;

5243

case JT_EQ_REF:

5244

table->status=STATUS_NO_RECORD;

5245

if (tab->select)

5246

{

5247

delete tab->select->quick;

5248

tab->select->quick=0;

5249

}

5250

delete tab->quick;

5251

tab->quick=0;

5252

tab->read_first_record= join_read_key;

5253

tab->read_record.read_record= join_no_more_records;

5254

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

5255

{

5256

table->key_read=1;

5257

table->file->extra(HA_EXTRA_KEYREAD);

5258

}

5259

else

5260

push_index_cond(tab, tab->ref.key, true);

5261

break;

5262

case JT_REF_OR_NULL:

5263

case JT_REF:

5264

table->status=STATUS_NO_RECORD;

5265

if (tab->select)

5266

{

5267

delete tab->select->quick;

5268

tab->select->quick=0;

5269

}

5270

delete tab->quick;

5271

tab->quick=0;

5272

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

5273

{

5274

table->key_read=1;

5275

table->file->extra(HA_EXTRA_KEYREAD);

5276

}

5277

else

5278

push_index_cond(tab, tab->ref.key, true);

5279

if (tab->type == JT_REF)

5280

{

5281

tab->read_first_record= join_read_always_key;

5282

tab->read_record.read_record= tab->insideout_match_tab?

5283

join_read_next_same_diff : join_read_next_same;

5284

}

5285

else

5286

{

5287

tab->read_first_record= join_read_always_key_or_null;

5288

tab->read_record.read_record= join_read_next_same_or_null;

5289

}

5290

break;

5291

case JT_ALL:

5292

5293

If previous table use cache

5294

If the incoming data set is already sorted don't use cache.

5295

5296

table->status=STATUS_NO_RECORD;

5297

using_join_cache= false;

5298

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

5299

tab->use_quick != 2 && !tab->first_inner && i <= no_jbuf_after &&

5300

!tab->insideout_match_tab)

5301

{

5302

if ((options & SELECT_DESCRIBE) ||

5303

!join_init_cache(join->session,join->join_tab+join->const_tables,

5304

i-join->const_tables))

5305

{

5306

using_join_cache= true;

5307

tab[-1].next_select=sub_select_cache; /* Patch previous */

5308

}

5309

}

5310

/* These init changes read_record */

5311

if (tab->use_quick == 2)

5312

{

5313

join->session->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

5314

tab->read_first_record= join_init_quick_read_record;

5315

if (statistics)

5316

status_var_increment(join->session->status_var.select_range_check_count);

5317

}

5318

else

5319

{

5320

tab->read_first_record= join_init_read_record;

5321

if (i == join->const_tables)

5322

{

5323

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

5324

{

5325

if (statistics)

5326

status_var_increment(join->session->status_var.select_range_count);

5327

}

5328

else

5329

{

5330

join->session->server_status|=SERVER_QUERY_NO_INDEX_USED;

5331

if (statistics)

5332

status_var_increment(join->session->status_var.select_scan_count);

5333

}

5334

}

5335

else

5336

{

5337

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

5338

{

5339

if (statistics)

5340

status_var_increment(join->session->status_var.select_full_range_join_count);

5341

}

5342

else

5343

{

5344

join->session->server_status|=SERVER_QUERY_NO_INDEX_USED;

5345

if (statistics)

5346

status_var_increment(join->session->status_var.select_full_join_count);

5347

}

5348

}

5349

if (!table->no_keyread)

5350

{

5351

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

5352

tab->select->quick->index != MAX_KEY && //not index_merge

5353

table->covering_keys.test(tab->select->quick->index))

5354

{

5355

table->key_read=1;

5356

table->file->extra(HA_EXTRA_KEYREAD);

5357

}

5358

else if (!table->covering_keys.none() &&

5359

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

5360

{ // Only read index tree

5361

if (!tab->insideout_match_tab)

5362

{

5363

5364

See bug #26447: "Using the clustered index for a table scan

5365

is always faster than using a secondary index".

5366

5367

if (table->s->primary_key != MAX_KEY &&

5368

table->file->primary_key_is_clustered())

5369

tab->index= table->s->primary_key;

5370

else

5371

tab->index= table->find_shortest_key(&table->covering_keys);

5372

}

5373

tab->read_first_record= join_read_first;

5374

tab->type=JT_NEXT; // Read with index_first / index_next

5375

}

5376

}

5377

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

5378

tab->select->quick->index != MAX_KEY && ! tab->table->key_read)

5379

push_index_cond(tab, tab->select->quick->index, !using_join_cache);

5380

}

5381

break;

5382

default:

5383

break; /* purecov: deadcode */

5384

case JT_UNKNOWN:

5385

case JT_MAYBE_REF:

5386

abort(); /* purecov: deadcode */

4926

5387

}

4927

4928

access_method->getStats(table, tab);

4929

5388

}

4930

4931

join->join_tab[join->tables-1].next_select= NULL; /* Set by do_select */

4932

4933

return false;

5389

join->join_tab[join->tables-1].next_select=0; /* Set by do_select */

5390

return(false);

4934

5391

}

4935

5392

4936

5393

/** Update the dependency map for the tables. */

4937

static void update_depend_map(Join *join)

5394

static void update_depend_map(JOIN *join)

4938

5395

{

4939

JoinTable *join_tab=join->join_tab, *end=join_tab+join->tables;

5396

JOIN_TAB *join_tab=join->join_tab, *end=join_tab+join->tables;

4940

5397

4941

5398

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

4942

5399

{

4943

table_reference_st *ref= &join_tab->ref;

4944

table_map depend_map= 0;

5400

TABLE_REF *ref= &join_tab->ref;

5401

table_map depend_map=0;

4945

5402

Item **item=ref->items;

4946

5403

uint32_t i;

4947

5404

for (i=0 ; i < ref->key_parts ; i++,item++)

4948

5405

depend_map|=(*item)->used_tables();

4949

5406

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

4950

5407

depend_map&= ~OUTER_REF_TABLE_BIT;

4951

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

5408

for (JOIN_TAB **tab=join->map2table; depend_map; tab++,depend_map>>=1 )

4952

5409

{

4953

5410

if (depend_map & 1)

4954

5411

ref->depend_map|=(*tab)->ref.depend_map;

4957

5414

}

4958

5415

4959

5416

/** Update the dependency map for the sort order. */

4960

static void update_depend_map(Join *join, Order *order)

5417

static void update_depend_map(JOIN *join, order_st *order)

4961

5418

{

4962

5419

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

4963

5420

{

4968

5425

if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))

4969

5426

&& !order->item[0]->with_sum_func)

4970

5427

{

4971

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

5428

for (JOIN_TAB **tab=join->map2table; depend_map; tab++, depend_map>>=1)

4972

5429

{

4973

5430

if (depend_map & 1)

4974

5431

order->depend_map|=(*tab)->ref.depend_map;

4995

5452

@return

4996

5453

Returns new sort order

4997

5454

4998

static Order *remove_constants(Join *join,Order *first_order, COND *cond, bool change_list, bool *simple_order)

5455

static order_st *remove_constants(JOIN *join,order_st *first_order, COND *cond, bool change_list, bool *simple_order)

4999

5456

{

5000

5457

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

5001

5458

return change_list ? 0 : first_order; // No need to sort

5002

5459

5003

Order *order,**prev_ptr;

5460

order_st *order,**prev_ptr;

5004

5461

table_map first_table= join->join_tab[join->const_tables].table->map;

5005

5462

table_map not_const_tables= ~join->const_table_map;

5006

5463

table_map ref;

5055

5512

return(first_order);

5056

5513

}

5057

5514

5058

static int return_zero_rows(Join *join,

5515

static int return_zero_rows(JOIN *join,

5059

5516

select_result *result,

5060

5517

TableList *tables,

5061

5518

List<Item> &fields,

5066

5523

{

5067

5524

if (select_options & SELECT_DESCRIBE)

5068

5525

{

5069

optimizer::ExplainPlan planner(join,

5070

false,

5071

false,

5072

false,

5073

info);

5074

planner.printPlan();

5075

return 0;

5526

select_describe(join, false, false, false, info);

5527

return(0);

5076

5528

}

5077

5529

5078

5530

join->join_free();

5084

5536

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

5085

5537

send_row=0;

5086

5538

}

5087

if (! (result->send_fields(fields)))

5539

if (!(result->send_fields(fields, Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF)))

5088

5540

{

5089

5541

if (send_row)

5090

5542

{

5221

5673

- The new condition, if success

5222

5674

- 0, otherwise

5223

5675

5224

static COND *simplify_joins(Join *join, List<TableList> *join_list, COND *conds, bool top)

5676

static COND *simplify_joins(JOIN *join, List<TableList> *join_list, COND *conds, bool top, bool in_sj)

5225

5677

{

5226

5678

TableList *table;

5227

5679

nested_join_st *nested_join;

5237

5689

table_map used_tables;

5238

5690

table_map not_null_tables= (table_map) 0;

5239

5691

5240

if ((nested_join= table->getNestedJoin()))

5692

if ((nested_join= table->nested_join))

5241

5693

{

5242

5694

5243

5695

If the element of join_list is a nested join apply

5254

5706

the outer join is converted to an inner join and

5255

5707

the corresponding on expression is added to E.

5256

5708

5257

expr= simplify_joins(join, &nested_join->join_list, expr, false);

5709

expr= simplify_joins(join, &nested_join->join_list,

5710

expr, false, in_sj || table->sj_on_expr);

5258

5711

5259

5712

if (!table->prep_on_expr || expr != table->on_expr)

5260

5713

{

5266

5719

}

5267

5720

nested_join->used_tables= (table_map) 0;

5268

5721

nested_join->not_null_tables=(table_map) 0;

5269

conds= simplify_joins(join, &nested_join->join_list, conds, top);

5722

conds= simplify_joins(join, &nested_join->join_list, conds, top, in_sj || table->sj_on_expr);

5270

5723

used_tables= nested_join->used_tables;

5271

5724

not_null_tables= nested_join->not_null_tables;

5272

5725

}

5279

5732

not_null_tables= conds->not_null_tables();

5280

5733

}

5281

5734

5282

if (table->getEmbedding())

5735

if (table->embedding)

5283

5736

{

5284

table->getEmbedding()->getNestedJoin()->used_tables|= used_tables;

5285

table->getEmbedding()->getNestedJoin()->not_null_tables|= not_null_tables;

5737

table->embedding->nested_join->used_tables|= used_tables;

5738

table->embedding->nested_join->not_null_tables|= not_null_tables;

5286

5739

}

5287

5740

5288

5741

if (!table->outer_join || (used_tables & not_null_tables))

5318

5771

5319

5772

if (table->on_expr)

5320

5773

{

5321

table->setDepTables(table->getDepTables() | table->on_expr->used_tables());

5322

if (table->getEmbedding())

5774

table->dep_tables|= table->on_expr->used_tables();

5775

if (table->embedding)

5323

5776

{

5324

table->setDepTables(table->getDepTables() & ~table->getEmbedding()->getNestedJoin()->used_tables);

5777

table->dep_tables&= ~table->embedding->nested_join->used_tables;

5325

5778

5326

5779

Embedding table depends on tables used

5327

5780

in embedded on expressions.

5328

5781

5329

table->getEmbedding()->setOnExprDepTables(table->getEmbedding()->getOnExprDepTables() & table->on_expr->used_tables());

5782

table->embedding->on_expr_dep_tables|= table->on_expr->used_tables();

5330

5783

}

5331

5784

else

5332

table->setDepTables(table->getDepTables() & ~table->table->map);

5785

table->dep_tables&= ~table->table->map;

5333

5786

}

5334

5787

5335

5788

if (prev_table)

5336

5789

{

5337

//If this is straight join, set prev table to be dependent on all tables

5338

//from this nested join, so that correct join order is selected.

5339

if ((test(join->select_options & SELECT_STRAIGHT_JOIN)) ||

5340

prev_table->straight)

5341

prev_table->setDepTables(prev_table->getDepTables() | used_tables);

5790

/* The order of tables is reverse: prev_table follows table */

5791

if (prev_table->straight)

5792

prev_table->dep_tables|= used_tables;

5342

5793

if (prev_table->on_expr)

5343

5794

{

5344

prev_table->setDepTables(prev_table->getDepTables() | table->getOnExprDepTables());

5345

table_map prev_used_tables= prev_table->getNestedJoin() ?

5346

prev_table->getNestedJoin()->used_tables :

5795

prev_table->dep_tables|= table->on_expr_dep_tables;

5796

table_map prev_used_tables= prev_table->nested_join ?

5797

prev_table->nested_join->used_tables :

5347

5798

prev_table->table->map;

5348

5799

5349

5800

If on expression contains only references to inner tables

5352

5803

for them. Yet this is really a rare case.

5353

5804

5354

5805

if (!(prev_table->on_expr->used_tables() & ~prev_used_tables))

5355

prev_table->setDepTables(prev_table->getDepTables() | used_tables);

5806

prev_table->dep_tables|= used_tables;

5356

5807

}

5357

5808

}

5358

5809

prev_table= table;

5365

5816

li.rewind();

5366

5817

while ((table= li++))

5367

5818

{

5368

nested_join= table->getNestedJoin();

5369

if (nested_join && !table->on_expr)

5819

nested_join= table->nested_join;

5820

if (table->sj_on_expr && !in_sj)

5821

{

5822

5823

If this is a semi-join that is not contained within another semi-join,

5824

leave it intact (otherwise it is flattened)

5825

5826

join->select_lex->sj_nests.push_back(table);

5827

}

5828

else if (nested_join && !table->on_expr)

5370

5829

{

5371

5830

TableList *tbl;

5372

5831

List_iterator<TableList> it(nested_join->join_list);

5373

5832

while ((tbl= it++))

5374

5833

{

5375

tbl->setEmbedding(table->getEmbedding());

5376

tbl->setJoinList(table->getJoinList());

5834

tbl->embedding= table->embedding;

5835

tbl->join_list= table->join_list;

5377

5836

}

5378

5837

li.replace(nested_join->join_list);

5379

5838

}

5381

5840

return(conds);

5382

5841

}

5383

5842

5384

static int remove_duplicates(Join *join, Table *entry,List<Item> &fields, Item *having)

5843

static int remove_duplicates(JOIN *join, Table *entry,List<Item> &fields, Item *having)

5385

5844

{

5386

5845

int error;

5387

5846

uint32_t reclength,offset;

5405

5864

join->unit->select_limit_cnt= 1; // Only send first row

5406

5865

return(0);

5407

5866

}

5408

Field **first_field=entry->getFields() + entry->getShare()->sizeFields() - field_count;

5867

Field **first_field=entry->field+entry->s->fields - field_count;

5409

5868

offset= (field_count ?

5410

entry->getField(entry->getShare()->sizeFields() - field_count)->offset(entry->getInsertRecord()) : 0);

5411

reclength= entry->getShare()->getRecordLength() - offset;

5869

entry->field[entry->s->fields - field_count]->

5870

offset(entry->record[0]) : 0);

5871

reclength= entry->s->reclength-offset;

5412

5872

5413

entry->free_io_cache(); // Safety

5414

entry->cursor->info(HA_STATUS_VARIABLE);

5415

if (entry->getShare()->db_type() == heap_engine ||

5416

(!entry->getShare()->blob_fields &&

5417

((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->cursor->stats.records <

5418

session->variables.sortbuff_size)))

5419

{

5873

free_io_cache(entry); // Safety

5874

entry->file->info(HA_STATUS_VARIABLE);

5875

if (entry->s->db_type() == heap_engine ||

5876

(!entry->s->blob_fields &&

5877

((ALIGN_SIZE(reclength) + HASH_OVERHEAD) * entry->file->stats.records <

5878

session->variables.sortbuff_size)))

5420

5879

error= remove_dup_with_hash_index(join->session, entry,

5421

field_count, first_field,

5422

reclength, having);

5423

}

5880

field_count, first_field,

5881

reclength, having);

5424

5882

else

5425

{

5426

error= remove_dup_with_compare(join->session, entry, first_field, offset, having);

5427

}

5883

error= remove_dup_with_compare(join->session, entry, first_field, offset,

5884

having);

5428

5885

5429

5886

free_blobs(first_field);

5430

5431

5887

return(error);

5432

5888

}

5433

5889

5441

5897

List<Item> &fields,

5442

5898

List<Item> &all_fields,

5443

5899

COND **conds,

5444

Order *order,

5445

Order *group,

5900

order_st *order,

5901

order_st *group,

5446

5902

bool *hidden_group_fields)

5447

5903

{

5448

5904

int res;

5449

5905

nesting_map save_allow_sum_func=session->lex->allow_sum_func ;

5450

5906

5451

5907

session->lex->allow_sum_func&= ~(1 << session->lex->current_select->nest_level);

5452

res= session->setup_conds(tables, conds);

5908

res= setup_conds(session, tables, conds);

5453

5909

5454

5910

session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;

5455

5911

res= res || setup_order(session, ref_pointer_array, tables, fields, all_fields,

5469

5925

@retval

5470

5926

1 Fatal error

5471

5927

5472

static bool make_join_statistics(Join *join, TableList *tables, COND *conds, DYNAMIC_ARRAY *keyuse_array)

5928

static bool make_join_statistics(JOIN *join, TableList *tables, COND *conds, DYNAMIC_ARRAY *keyuse_array)

5473

5929

{

5474

5930

int error;

5475

5931

Table *table;

5476

uint32_t i;

5477

uint32_t table_count;

5478

uint32_t const_count;

5479

uint32_t key;

5480

table_map found_const_table_map;

5481

table_map all_table_map;

5482

table_map found_ref;

5483

table_map refs;

5484

key_map const_ref;

5485

key_map eq_part;

5486

Table **table_vector= NULL;

5487

JoinTable *stat= NULL;

5488

JoinTable *stat_end= NULL;

5489

JoinTable *s= NULL;

5490

JoinTable **stat_ref= NULL;

5491

optimizer::KeyUse *keyuse= NULL;

5492

optimizer::KeyUse *start_keyuse= NULL;

5493

table_map outer_join= 0;

5494

vector<optimizer::SargableParam> sargables;

5495

JoinTable *stat_vector[MAX_TABLES+1];

5496

optimizer::Position *partial_pos;

5932

uint32_t i,table_count,const_count,key;

5933

table_map found_const_table_map, all_table_map, found_ref, refs;

5934

key_map const_ref, eq_part;

5935

Table **table_vector;

5936

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

5937

KEYUSE *keyuse,*start_keyuse;

5938

table_map outer_join=0;

5939

SARGABLE_PARAM *sargables= 0;

5940

JOIN_TAB *stat_vector[MAX_TABLES+1];

5497

5941

5498

table_count= join->tables;

5499

stat= (JoinTable*) join->session->calloc(sizeof(JoinTable)*table_count);

5500

stat_ref= (JoinTable**) join->session->alloc(sizeof(JoinTable*)*MAX_TABLES);

5501

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

5502

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

5503

return 1;

5942

table_count=join->tables;

5943

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

5944

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

5945

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

5946

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

5947

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

5504

5948

5505

5949

join->best_ref=stat_vector;

5506

5950

5512

5956

tables;

5513

5957

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

5514

5958

{

5515

TableList *embedding= tables->getEmbedding();

5959

TableList *embedding= tables->embedding;

5516

5960

stat_vector[i]=s;

5517

5961

s->keys.reset();

5518

5962

s->const_keys.reset();

5520

5964

s->needed_reg.reset();

5521

5965

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

5522

5966

table->pos_in_table_list= tables;

5523

assert(table->cursor);

5524

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

5525

if (error)

5967

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

5968

if(error)

5526

5969

{

5527

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

5528

return 1;

5970

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

5971

return(1);

5529

5972

}

5530

5973

table->quick_keys.reset();

5531

5974

table->reginfo.join_tab=s;

5532

5975

table->reginfo.not_exists_optimize=0;

5533

5976

memset(table->const_key_parts, 0,

5534

sizeof(key_part_map)*table->getShare()->sizeKeys());

5977

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

5535

5978

all_table_map|= table->map;

5536

5979

s->join=join;

5537

5980

s->info=0; // For describe

5538

5981

5539

s->dependent= tables->getDepTables();

5982

s->dependent= tables->dep_tables;

5540

5983

s->key_dependent= 0;

5541

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

5984

if (tables->schema_table)

5985

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

5986

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

5542

5987

5543

5988

s->on_expr_ref= &tables->on_expr;

5544

5989

if (*s->on_expr_ref)

5545

5990

{

5546

5991

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

5547

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

5992

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

5548

5993

{ // Empty table

5549

5994

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

5550

set_position(join, const_count++, s, (optimizer::KeyUse*) 0);

5995

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

5551

5996

continue;

5552

5997

}

5553

5998

outer_join|= table->map;

5554

s->embedding_map.reset();

5555

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

5556

s->embedding_map|= embedding->getNestedJoin()->nj_map;

5999

s->embedding_map= 0;

6000

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

6001

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

5557

6002

continue;

5558

6003

}

5559

if (embedding && !(false && ! embedding->getEmbedding()))

6004

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

5560

6005

{

5561

6006

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

5562

s->embedding_map.reset();

6007

s->embedding_map= 0;

5563

6008

5564

6009

{

5565

nested_join_st *nested_join= embedding->getNestedJoin();

5566

s->embedding_map|= nested_join->nj_map;

5567

s->dependent|= embedding->getDepTables();

5568

embedding= embedding->getEmbedding();

6010

nested_join_st *nested_join= embedding->nested_join;

6011

s->embedding_map|=nested_join->nj_map;

6012

s->dependent|= embedding->dep_tables;

6013

embedding= embedding->embedding;

5569

6014

outer_join|= nested_join->used_tables;

5570

6015

}

5571

6016

while (embedding);

5572

6017

continue;

5573

6018

}

5574

if ((table->cursor->stats.records <= 1) && !s->dependent &&

5575

(table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&

6019

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

6020

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

5576

6021

!join->no_const_tables)

5577

6022

{

5578

set_position(join, const_count++, s, (optimizer::KeyUse*) 0);

6023

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

5579

6024

}

5580

6025

}

5581

6026

stat_vector[i]=0;

5609

6054

{

5610

6055

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

5611

6056

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

5612

return 1;

6057

return(1);

5613

6058

}

5614

6059

s->key_dependent= s->dependent;

5615

6060

}

5618

6063

if (conds || outer_join)

5619

6064

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

5620

6065

conds, join->cond_equal,

5621

~outer_join, join->select_lex, sargables))

5622

return 1;

6066

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

6067

return(1);

5623

6068

5624

6069

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

5625

6070

join->const_table_map= 0;

5626

6071

5627

optimizer::Position *p_pos= join->getFirstPosInPartialPlan();

5628

optimizer::Position *p_end= join->getSpecificPosInPartialPlan(const_count);

5629

while (p_pos < p_end)

6072

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

6073

p_pos < p_end ;

6074

p_pos++)

5630

6075

{

5631

6076

int tmp;

5632

s= p_pos->getJoinTable();

5633

s->type= AM_SYSTEM;

6077

s= p_pos->table;

6078

s->type=JT_SYSTEM;

5634

6079

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

5635

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

6080

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

5636

6081

{

5637

6082

if (tmp > 0)

5638

return 1; // Fatal error

6083

return(1); // Fatal error

5639

6084

}

5640

6085

else

5641

6086

found_const_table_map|= s->table->map;

5642

p_pos++;

5643

6087

}

5644

6088

5645

6089

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

5655

6099

set_position() will move all const_tables first in stat_vector

5656

6100

5657

6101

5658

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

6102

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

5659

6103

{

5660

table= s->table;

6104

table=s->table;

5661

6105

5662

6106

5663

6107

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

5664

6108

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

5665

6109

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

5666

6110

5667

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

6111

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

5668

6112

{

5669

6113

5670

6114

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

5676

6120

TODO. Apply single row substitution to null complemented inner tables

5677

6121

for nested outer join operations.

5678

6122

5679

while (keyuse->getTable() == table)

6123

while (keyuse->table == table)

5680

6124

{

5681

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

5682

keyuse->getVal()->is_null() && keyuse->isNullRejected())

6125

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

6126

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

5683

6127

{

5684

s->type= AM_CONST;

6128

s->type= JT_CONST;

5685

6129

table->mark_as_null_row();

5686

6130

found_const_table_map|= table->map;

5687

6131

join->const_table_map|= table->map;

5688

set_position(join, const_count++, s, (optimizer::KeyUse*) 0);

6132

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

5689

6133

goto more_const_tables_found;

5690

6134

}

5691

6135

keyuse++;

5697

6141

// All dep. must be constants

5698

6142

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

5699

6143

continue;

5700

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

5701

(table->cursor->getEngine()->check_flag(HTON_BIT_STATS_RECORDS_IS_EXACT)) &&

5702

!table->pos_in_table_list->getEmbedding())

6144

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

6145

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

6146

!table->pos_in_table_list->embedding)

5703

6147

{ // system table

5704

6148

int tmp= 0;

5705

s->type= AM_SYSTEM;

6149

s->type=JT_SYSTEM;

5706

6150

join->const_table_map|=table->map;

5707

set_position(join, const_count++, s, (optimizer::KeyUse*) 0);

5708

partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);

5709

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

6151

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

6152

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

5710

6153

{

5711

6154

if (tmp > 0)

5712

return 1; // Fatal error

6155

return(1); // Fatal error

5713

6156

}

5714

6157

else

5715

6158

found_const_table_map|= table->map;

5719

6162

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

5720

6163

if ((keyuse=s->keyuse))

5721

6164

{

5722

s->type= AM_REF;

5723

while (keyuse->getTable() == table)

6165

s->type= JT_REF;

6166

while (keyuse->table == table)

5724

6167

{

5725

start_keyuse= keyuse;

5726

key= keyuse->getKey();

6168

start_keyuse=keyuse;

6169

key=keyuse->key;

5727

6170

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

5728

6171

5729

refs= 0;

5730

const_ref.reset();

6172

refs=0;

6173

const_ref.reset();

5731

6174

eq_part.reset();

5732

6175

5733

6176

{

5734

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

5735

! keyuse->getOptimizeFlags())

6177

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

5736

6178

{

5737

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

5738

const_ref.set(keyuse->getKeypart());

6179

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

6180

const_ref.set(keyuse->keypart);

5739

6181

else

5740

refs|= keyuse->getUsedTables();

5741

eq_part.set(keyuse->getKeypart());

6182

refs|=keyuse->used_tables;

6183

eq_part.set(keyuse->keypart);

5742

6184

}

5743

6185

keyuse++;

5744

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

6186

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

5745

6187

5746

6188

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

5747

! table->pos_in_table_list->getEmbedding())

6189

!table->pos_in_table_list->embedding)

5748

6190

{

5749

6191

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

5750

6192

{

5752

6194

{ // Found everything for ref.

5753

6195

int tmp;

5754

6196

ref_changed = 1;

5755

s->type= AM_CONST;

6197

s->type= JT_CONST;

5756

6198

join->const_table_map|= table->map;

5757

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

6199

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

5758

6200

if (create_ref_for_key(join, s, start_keyuse, found_const_table_map))

5759

return 1;

5760

partial_pos= join->getSpecificPosInPartialPlan(const_count - 1);

5761

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

6201

return(1);

6202

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

5762

6203

{

5763

6204

if (tmp > 0)

5764

return 1; // Fatal error

6205

return(1); // Fatal error

5765

6206

}

5766

6207

else

5767

6208

found_const_table_map|= table->map;

5782

6223

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

5783

6224

reading const tables may has added new sargable predicates.

5784

6225

5785

if (const_count && ! sargables.empty())

6226

if (const_count && sargables)

5786

6227

{

5787

vector<optimizer::SargableParam>::iterator iter= sargables.begin();

5788

while (iter != sargables.end())

6228

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

5789

6229

{

5790

Field *field= (*iter).getField();

5791

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

6230

Field *field= sargables->field;

6231

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

5792

6232

key_map possible_keys= field->key_start;

5793

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

5794

bool is_const= true;

5795

for (uint32_t j= 0; j < (*iter).getNumValues(); j++)

5796

is_const&= (*iter).isConstItem(j);

6233

possible_keys&= field->table->keys_in_use_for_query;

6234

bool is_const= 1;

6235

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

6236

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

5797

6237

if (is_const)

5798

6238

join_tab[0].const_keys|= possible_keys;

5799

++iter;

5800

6239

}

5801

6240

}

5802

6241

6242

if (pull_out_semijoin_tables(join))

6243

return(true);

6244

5803

6245

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

5804

6246

5805

6247

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

5806

6248

{

5807

if (s->type == AM_SYSTEM || s->type == AM_CONST)

6249

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

5808

6250

{

5809

6251

/* Only one matching row */

5810

6252

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

5811

6253

continue;

5812

6254

}

5813

6255

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

5814

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

5815

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

6256

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

6257

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

5816

6258

5817

6259

5818

6260

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

5819

6261

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

5820

6262

table scan.

5821

6263

5822

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

5823

(double) s->read_time*3);

6264

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

6265

(double) s->read_time*3);

5824

6266

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

5825

6267

s->worst_seeks=2.0;

5826

6268

5831

6273

add_group_and_distinct_keys(join, s);

5832

6274

5833

6275

if (s->const_keys.any() &&

5834

!s->table->pos_in_table_list->getEmbedding())

6276

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

5835

6277

{

5836

6278

ha_rows records;

5837

optimizer::SqlSelect *select= NULL;

5838

select= optimizer::make_select(s->table, found_const_table_map, found_const_table_map, *s->on_expr_ref ? *s->on_expr_ref : conds, 1, &error);

6279

SQL_SELECT *select;

6280

select= make_select(s->table, found_const_table_map, found_const_table_map, *s->on_expr_ref ? *s->on_expr_ref : conds, 1, &error);

5839

6281

if (! select)

5840

return 1;

6282

return(1);

5841

6283

records= get_quick_record_count(join->session, select, s->table, &s->const_keys, join->row_limit);

5842

6284

s->quick=select->quick;

5843

6285

s->needed_reg=select->needed_reg;

5851

6293

caller to abort with a zero row result.

5852

6294

5853

6295

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

5854

set_position(join, const_count++, s, (optimizer::KeyUse*) 0);

5855

s->type= AM_CONST;

6296

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

6297

s->type= JT_CONST;

5856

6298

if (*s->on_expr_ref)

5857

6299

{

5858

6300

/* Generate empty row */

5859

6301

s->info= "Impossible ON condition";

5860

6302

found_const_table_map|= s->table->map;

5861

s->type= AM_CONST;

6303

s->type= JT_CONST;

5862

6304

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

5863

6305

}

5864

6306

}

5881

6323

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

5882

6324

{

5883

6325

optimize_keyuse(join, keyuse_array);

5884

// @note c_str() is not likely to be valid here if dtrace expects it to

5885

// exist for any period of time.

5886

DRIZZLE_QUERY_OPT_CHOOSE_PLAN_START(join->session->getQueryString()->c_str(), join->session->thread_id);

5887

bool res= choose_plan(join, all_table_map & ~join->const_table_map);

5888

DRIZZLE_QUERY_OPT_CHOOSE_PLAN_DONE(res ? 1 : 0);

5889

if (res)

5890

return true;

6326

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

6327

return(true);

5891

6328

}

5892

6329

else

5893

6330

{

5894

join->copyPartialPlanIntoOptimalPlan(join->const_tables);

6331

memcpy(join->best_positions, join->positions, sizeof(POSITION)*join->const_tables);

5895

6332

join->best_read= 1.0;

5896

6333

}

5897

6334

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

5898

return (join->session->getKilled() || get_best_combination(join));

6335

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

5899

6336

}

5900

6337

5901

6338

/**

5902

Assign each nested join structure a bit in the nested join bitset.

6339

Assign each nested join structure a bit in nested_join_map.

5903

6340

5904

6341

Assign each nested join structure (except "confluent" ones - those that

5905

embed only one element) a bit in the nested join bitset.

6342

embed only one element) a bit in nested_join_map.

5906

6343

5907

6344

@param join Join being processed

5908

6345

@param join_list List of tables

5909

@param first_unused Number of first unused bit in the nest joing bitset before the

6346

@param first_unused Number of first unused bit in nested_join_map before the

5910

6347

call

5911

6348

5912

6349

@note

5913

6350

This function is called after simplify_joins(), when there are no

5914

6351

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

5915

we will not run out of bits in the nested join bitset.

6352

we will not run out of bits in nested_join_map.

5916

6353

5917

6354

@return

5918

First unused bit in the nest join bitset after the call.

6355

First unused bit in nested_join_map after the call.

5919

6356

5920

6357

static uint32_t build_bitmap_for_nested_joins(List<TableList> *join_list, uint32_t first_unused)

5921

6358

{

5924

6361

while ((table= li++))

5925

6362

{

5926

6363

nested_join_st *nested_join;

5927

if ((nested_join= table->getNestedJoin()))

6364

if ((nested_join= table->nested_join))

5928

6365

{

5929

6366

5930

6367

It is guaranteed by simplify_joins() function that a nested join

5935

6372

We don't assign bits to such sj-nests because

5936

6373

1. it is redundant (a "sequence" of one table cannot be interleaved

5937

6374

with anything)

5938

2. we could run out of bits in the nested join bitset otherwise.

6375

2. we could run out bits in nested_join_map otherwise.

5939

6376

5940

6377

if (nested_join->join_list.elements != 1)

5941

6378

{

5942

6379

/* Don't assign bits to sj-nests */

5943

6380

if (table->on_expr)

5944

nested_join->nj_map.set(first_unused++);

6381

nested_join->nj_map= (nested_join_map) 1 << first_unused++;

5945

6382

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

5946

6383

first_unused);

5947

6384

}

5955

6392

Return table number if there is only one table in sort order

5956

6393

and group and order is compatible, else return 0.

5957

6394

5958

static Table *get_sort_by_table(Order *a, Order *b,TableList *tables)

6395

static Table *get_sort_by_table(order_st *a,order_st *b,TableList *tables)

5959

6396

{

5960

6397

table_map map= (table_map) 0;

5961

6398

5995

6432

while ((table= li++))

5996

6433

{

5997

6434

nested_join_st *nested_join;

5998

if ((nested_join= table->getNestedJoin()))

6435

if ((nested_join= table->nested_join))

5999

6436

{

6000

6437

nested_join->counter_= 0;

6001

6438

reset_nj_counters(&nested_join->join_list);

6010

6447

If first parts has different direction, change it to second part

6011

6448

(group is sorted like order)

6012

6449

6013

static bool test_if_subpart(Order *a, Order *b)

6450

static bool test_if_subpart(order_st *a,order_st *b)

6014

6451

{

6015

6452

for (; a && b; a=a->next,b=b->next)

6016

6453

{

6025

6462

/**

6026

6463

Nested joins perspective: Remove the last table from the join order.

6027

6464

6028

The algorithm is the reciprocal of check_interleaving_with_nj(), hence

6029

parent join nest nodes are updated only when the last table in its child

6030

node is removed. The ASCII graphic below will clarify.

6031

6032

%A table nesting such as <tt> t1 x [ ( t2 x t3 ) x ( t4 x t5 ) ] </tt>is

6033

represented by the below join nest tree.

6034

6035

@verbatim

6036

NJ1

6037

_/ / \

6038

_/ / NJ2

6039

_/ / / \

6040

/ / / \

6041

t1 x [ (t2 x t3) x (t4 x t5) ]

6042

@endverbatim

6043

6044

At the point in time when check_interleaving_with_nj() adds the table t5 to

6045

the query execution plan, QEP, it also directs the node named NJ2 to mark

6046

the table as covered. NJ2 does so by incrementing its @c counter

6047

member. Since all of NJ2's tables are now covered by the QEP, the algorithm

6048

proceeds up the tree to NJ1, incrementing its counter as well. All join

6049

nests are now completely covered by the QEP.

6050

6051

restore_prev_nj_state() does the above in reverse. As seen above, the node

6052

NJ1 contains the nodes t2, t3, and NJ2. Its counter being equal to 3 means

6053

that the plan covers t2, t3, and NJ2, @e and that the sub-plan (t4 x t5)

6054

completely covers NJ2. The removal of t5 from the partial plan will first

6055

decrement NJ2's counter to 1. It will then detect that NJ2 went from being

6056

completely to partially covered, and hence the algorithm must continue

6057

upwards to NJ1 and decrement its counter to 2. %A subsequent removal of t4

6058

will however not influence NJ1 since it did not un-cover the last table in

6059

NJ2.

6060

6061

SYNOPSIS

6062

restore_prev_nj_state()

6063

last join table to remove, it is assumed to be the last in current

6064

partial join order.

6065

6066

DESCRIPTION

6067

6068

6465

Remove the last table from the partial join order and update the nested

6069

joins counters and join->cur_embedding_map. It is ok to call this

6070

function for the first table in join order (for which

6466

joins counters and join->cur_embedding_map. It is ok to call this

6467

function for the first table in join order (for which

6071

6468

check_interleaving_with_nj has not been called)

6072

6469

6073

6470

@param last join table to remove, it is assumed to be the last in current

6074

6471

partial join order.

6075

6472

6076

6077

static void restore_prev_nj_state(JoinTable *last)

6078

{

6079

TableList *last_emb= last->table->pos_in_table_list->getEmbedding();

6080

Join *join= last->join;

6081

for (;last_emb != NULL; last_emb= last_emb->getEmbedding())

6082

{

6083

nested_join_st *nest= last_emb->getNestedJoin();

6084

6085

bool was_fully_covered= nest->is_fully_covered();

6086

6087

if (--nest->counter_ == 0)

6088

join->cur_embedding_map&= ~nest->nj_map;

6089

6090

if (!was_fully_covered)

6473

static void restore_prev_nj_state(JOIN_TAB *last)

6474

{

6475

TableList *last_emb= last->table->pos_in_table_list->embedding;

6476

JOIN *join= last->join;

6477

while (last_emb)

6478

{

6479

if (last_emb->on_expr)

6480

{

6481

if (!(--last_emb->nested_join->counter_))

6482

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

6483

else if (last_emb->nested_join->join_list.elements-1 ==

6484

last_emb->nested_join->counter_)

6485

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

6486

else

6487

break;

6488

}

6489

last_emb= last_emb->embedding;

6490

}

6491

}

6492

6493

/**

6494

Determine if the set is already ordered for order_st BY, so it can

6495

disable join cache because it will change the ordering of the results.

6496

Code handles sort table that is at any location (not only first after

6497

the const tables) despite the fact that it's currently prohibited.

6498

We must disable join cache if the first non-const table alone is

6499

ordered. If there is a temp table the ordering is done as a last

6500

operation and doesn't prevent join cache usage.

6501

6502

static uint32_t make_join_orderinfo(JOIN *join)

6503

{

6504

uint32_t i;

6505

if (join->need_tmp)

6506

return join->tables;

6507

6508

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

6509

{

6510

JOIN_TAB *tab= join->join_tab+i;

6511

Table *table= tab->table;

6512

if ((table == join->sort_by_table &&

6513

(!join->order || join->skip_sort_order)) ||

6514

(join->sort_by_table == (Table *) 1 && i != join->const_tables))

6515

{

6091

6516

break;

6092

6093

join->cur_embedding_map|= nest->nj_map;

6094

}

6517

}

6518

}

6519

return i;

6520

}

6521

6522

/**

6523

Setup the strategies to eliminate semi-join duplicates.

6524

6525

SYNOPSIS

6526

setup_semijoin_dups_elimination()

6527

join Join to process

6528

options Join options (needed to see if join buffering will be

6529

used or not)

6530

no_jbuf_after Another bit of information re where join buffering will

6531

be used.

6532

6533

DESCRIPTION

6534

Setup the strategies to eliminate semi-join duplicates. ATM there are 3

6535

strategies:

6536

6537

1. DuplicateWeedout (use of temptable to remove duplicates based on rowids

6538

of row combinations)

6539

2. FirstMatch (pick only the 1st matching row combination of inner tables)

6540

3. InsideOut (scanning the sj-inner table in a way that groups duplicates

6541

together and picking the 1st one)

6542

6543

The join order has "duplicate-generating ranges", and every range is

6544

served by one strategy or a combination of FirstMatch with with some

6545

other strategy.

6546

6547

"Duplicate-generating range" is defined as a range within the join order

6548

that contains all of the inner tables of a semi-join. All ranges must be

6549

disjoint, if tables of several semi-joins are interleaved, then the ranges

6550

are joined together, which is equivalent to converting

6551

SELECT ... WHERE oe1 IN (SELECT ie1 ...) AND oe2 IN (SELECT ie2 )

6552

6553

SELECT ... WHERE (oe1, oe2) IN (SELECT ie1, ie2 ... ...)

6554

6555

6556

Applicability conditions are as follows:

6557

6558

DuplicateWeedout strategy

6559

~~~~~~~~~~~~~~~~~~~~~~~~~

6560

6561

(ot|nt)* [ it ((it|ot|nt)* (it|ot))] (nt)*

6562

+------+ +=========================+ +---+

6563

(1) (2) (3)

6564

6565

(1) - Prefix of OuterTables (those that participate in

6566

IN-equality and/or are correlated with subquery) and outer

6567

Noncorrelated Tables.

6568

(2) - The handled range. The range starts with the first sj-inner

6569

table, and covers all sj-inner and outer tables

6570

Within the range, Inner, Outer, outer Noncorrelated tables

6571

may follow in any order.

6572

(3) - The suffix of outer Noncorrelated tables.

6573

6574

FirstMatch strategy

6575

~~~~~~~~~~~~~~~~~~~

6576

6577

(ot|nt)* [ it ((it|nt)* it) ] (nt)*

6578

+------+ +==================+ +---+

6579

(1) (2) (3)

6580

6581

(1) - Prefix of outer and non-correlated tables

6582

(2) - The handled range, which may contain only inner and

6583

non-correlated tables.

6584

(3) - The suffix of outer Noncorrelated tables.

6585

6586

InsideOut strategy

6587

~~~~~~~~~~~~~~~~~~

6588

6589

(ot|ct|nt) [ insideout_tbl (ot|nt|it)* it ] (ot|nt)*

6590

+--------+ +===========+ +=============+ +------+

6591

(1) (2) (3) (4)

6592

6593

(1) - Prefix that may contain any outer tables. The prefix must contain

6594

all the non-trivially correlated outer tables. (non-trivially means

6595

that the correlation is not just through the IN-equality).

6596

6597

(2) - Inner table for which the InsideOut scan is performed.

6598

6599

(3) - The remainder of the duplicate-generating range. It is served by

6600

application of FirstMatch strategy, with the exception that

6601

outer IN-correlated tables are considered to be non-correlated.

6602

6603

(4) - THe suffix of outer and outer non-correlated tables.

6604

6605

If several strategies are applicable, their relative priorities are:

6606

1. InsideOut

6607

2. FirstMatch

6608

3. DuplicateWeedout

6609

6610

This function walks over the join order and sets up the strategies by

6611

setting appropriate members in join_tab structures.

6612

6613

RETURN

6614

false OK

6615

true Out of memory error

6616

6617

static int setup_semijoin_dups_elimination(JOIN *join, uint64_t options, uint32_t no_jbuf_after)

6618

{

6619

table_map cur_map= join->const_table_map | PSEUDO_TABLE_BITS;

6620

struct {

6621

6622

0 - invalid (EOF marker),

6623

1 - InsideOut,

6624

2 - Temptable (maybe confluent),

6625

3 - Temptable with join buffering

6626

6627

uint32_t strategy;

6628

uint32_t start_idx; /* Left range bound */

6629

uint32_t end_idx; /* Right range bound */

6630

6631

For Temptable strategy: Bitmap of all outer and correlated tables from

6632

all involved join nests.

6633

6634

table_map outer_tables;

6635

} dups_ranges [MAX_TABLES];

6636

6637

TableList *emb_insideout_nest= NULL;

6638

table_map emb_sj_map= 0; /* A bitmap of sj-nests (that is, their sj-inner

6639

tables) whose ranges we're in */

6640

table_map emb_outer_tables= 0; /* sj-outer tables for those sj-nests */

6641

table_map range_start_map= 0; /* table_map at current range start */

6642

bool dealing_with_jbuf= false; /* true <=> table within cur range uses join buf */

6643

int cur_range= 0;

6644

uint32_t i;

6645

6646

6647

First pass: locate the duplicate-generating ranges and pick the strategies.

6648

6649

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

6650

{

6651

JOIN_TAB *tab=join->join_tab+i;

6652

Table *table=tab->table;

6653

cur_map |= table->map;

6654

6655

if (tab->emb_sj_nest) // Encountered an sj-inner table

6656

{

6657

if (!emb_sj_map)

6658

{

6659

dups_ranges[cur_range].start_idx= i;

6660

range_start_map= cur_map & ~table->map;

6661

6662

Remember if this is a possible start of range that is covered by

6663

the InsideOut strategy (the reason that it is not covered could

6664

be that it overlaps with anther semi-join's range. we don't

6665

support InsideOut for joined ranges)

6666

6667

if (join->best_positions[i].use_insideout_scan)

6668

emb_insideout_nest= tab->emb_sj_nest;

6669

}

6670

6671

emb_sj_map |= tab->emb_sj_nest->sj_inner_tables;

6672

emb_outer_tables |= tab->emb_sj_nest->nested_join->sj_depends_on;

6673

6674

if (tab->emb_sj_nest != emb_insideout_nest)

6675

{

6676

6677

Two different semi-joins interleave. This cannot be handled by

6678

InsideOut strategy.

6679

6680

emb_insideout_nest= NULL;

6681

}

6682

}

6683

6684

if (emb_sj_map) /* We're in duplicate-generating range */

6685

{

6686

if (i != join->const_tables && !(options & SELECT_NO_JOIN_CACHE) &&

6687

tab->type == JT_ALL && tab->use_quick != 2 && !tab->first_inner &&

6688

i <= no_jbuf_after && !dealing_with_jbuf)

6689

{

6690

6691

This table uses join buffering, which makes use of FirstMatch or

6692

InsideOut strategies impossible for the current and (we assume)

6693

preceding duplicate-producing ranges.

6694

That is, for the join order:

6695

6696

x x [ x x] x [x x x] x [x x X* x] x

6697

| | | | | \

6698

+-----+ +-----+ | join buffering use

6699

r1 r2 we're here

6700

6701

we'll have to remove r1 and r2 and use duplicate-elimination

6702

strategy that spans all the tables, starting from the very 1st

6703

one.

6704

6705

dealing_with_jbuf= true;

6706

emb_insideout_nest= false;

6707

6708

6709

Absorb all preceding duplicate-eliminating ranges. Their strategies

6710

do not matter:

6711

6712

for (int prev_range= 0; prev_range < cur_range; prev_range++)

6713

{

6714

dups_ranges[cur_range].outer_tables |=

6715

dups_ranges[prev_range].outer_tables;

6716

}

6717

dups_ranges[0].start_idx= 0; /* Will need to start from the 1st table */

6718

dups_ranges[0].outer_tables= dups_ranges[cur_range].outer_tables;

6719

cur_range= 0;

6720

}

6721

6722

6723

Check if we are at the end of duplicate-producing range. We are if

6724

6725

1. It's an InsideOut range (which presumes all correlated tables are

6726

in the prefix), and all inner tables are in the join order prefix,

6727

6728

2. It's a DuplicateElimination range (possibly covering several

6729

SJ-nests), and all inner, outer, and correlated tables of all

6730

sj-nests are in the join order prefix.

6731

6732

bool end_of_range= false;

6733

if (emb_insideout_nest &&

6734

bitmap_covers(cur_map, emb_insideout_nest->sj_inner_tables))

6735

{

6736

/* Save that this range is handled with InsideOut: */

6737

dups_ranges[cur_range].strategy= 1;

6738

end_of_range= true;

6739

}

6740

else if (bitmap_covers(cur_map, emb_outer_tables | emb_sj_map))

6741

{

6742

6743

This is a complete range to be handled with either DuplicateWeedout

6744

or FirstMatch

6745

6746

dups_ranges[cur_range].strategy= dealing_with_jbuf? 3 : 2;

6747

6748

This will hold tables from within the range that need to be put

6749

into the join buffer before we can use the FirstMatch on its tail.

6750

6751

dups_ranges[cur_range].outer_tables= emb_outer_tables &

6752

~range_start_map;

6753

end_of_range= true;

6754

}

6755

6756

if (end_of_range)

6757

{

6758

dups_ranges[cur_range].end_idx= i+1;

6759

emb_sj_map= emb_outer_tables= 0;

6760

emb_insideout_nest= NULL;

6761

dealing_with_jbuf= false;

6762

dups_ranges[++cur_range].strategy= 0;

6763

}

6764

}

6765

}

6766

6767

Session *session= join->session;

6768

SJ_TMP_TABLE **next_sjtbl_ptr= &join->sj_tmp_tables;

6769

6770

Second pass: setup the chosen strategies

6771

6772

for (int j= 0; j < cur_range; j++)

6773

{

6774

JOIN_TAB *tab=join->join_tab + dups_ranges[j].start_idx;

6775

JOIN_TAB *jump_to;

6776

if (dups_ranges[j].strategy == 1) // InsideOut strategy

6777

{

6778

tab->insideout_match_tab= join->join_tab + dups_ranges[j].end_idx - 1;

6779

jump_to= tab++;

6780

}

6781

else // DuplicateWeedout strategy

6782

{

6783

SJ_TMP_TABLE::TAB sjtabs[MAX_TABLES];

6784

table_map weed_cur_map= join->const_table_map | PSEUDO_TABLE_BITS;

6785

uint32_t jt_rowid_offset= 0; // # tuple bytes are already occupied (w/o NULL bytes)

6786

uint32_t jt_null_bits= 0; // # null bits in tuple bytes

6787

SJ_TMP_TABLE::TAB *last_tab= sjtabs;

6788

uint32_t rowid_keep_flags= JOIN_TAB::CALL_POSITION | JOIN_TAB::KEEP_ROWID;

6789

JOIN_TAB *last_outer_tab= tab - 1;

6790

6791

Walk through the range and remember

6792

- tables that need their rowids to be put into temptable

6793

- the last outer table

6794

6795

for (; tab < join->join_tab + dups_ranges[j].end_idx; tab++)

6796

{

6797

if (sj_table_is_included(join, tab))

6798

{

6799

last_tab->join_tab= tab;

6800

last_tab->rowid_offset= jt_rowid_offset;

6801

jt_rowid_offset += tab->table->file->ref_length;

6802

if (tab->table->maybe_null)

6803

{

6804

last_tab->null_byte= jt_null_bits / 8;

6805

last_tab->null_bit= jt_null_bits++;

6806

}

6807

last_tab++;

6808

tab->table->prepare_for_position();

6809

tab->rowid_keep_flags= rowid_keep_flags;

6810

}

6811

weed_cur_map |= tab->table->map;

6812

if (!tab->emb_sj_nest && bitmap_covers(weed_cur_map,

6813

dups_ranges[j].outer_tables))

6814

last_outer_tab= tab;

6815

}

6816

6817

if (jt_rowid_offset) /* Temptable has at least one rowid */

6818

{

6819

SJ_TMP_TABLE *sjtbl;

6820

uint32_t tabs_size= (last_tab - sjtabs) * sizeof(SJ_TMP_TABLE::TAB);

6821

if (!(sjtbl= (SJ_TMP_TABLE*)session->alloc(sizeof(SJ_TMP_TABLE))) ||

6822

!(sjtbl->tabs= (SJ_TMP_TABLE::TAB*) session->alloc(tabs_size)))

6823

return(true);

6824

memcpy(sjtbl->tabs, sjtabs, tabs_size);

6825

sjtbl->tabs_end= sjtbl->tabs + (last_tab - sjtabs);

6826

sjtbl->rowid_len= jt_rowid_offset;

6827

sjtbl->null_bits= jt_null_bits;

6828

sjtbl->null_bytes= (jt_null_bits + 7)/8;

6829

6830

*next_sjtbl_ptr= sjtbl;

6831

next_sjtbl_ptr= &(sjtbl->next);

6832

sjtbl->next= NULL;

6833

6834

sjtbl->tmp_table=

6835

create_duplicate_weedout_tmp_table(session,

6836

sjtbl->rowid_len +

6837

sjtbl->null_bytes,

6838

sjtbl);

6839

6840

join->join_tab[dups_ranges[j].start_idx].flush_weedout_table= sjtbl;

6841

join->join_tab[dups_ranges[j].end_idx - 1].check_weed_out_table= sjtbl;

6842

}

6843

tab= last_outer_tab + 1;

6844

jump_to= last_outer_tab;

6845

}

6846

6847

/* Create the FirstMatch tail */

6848

for (; tab < join->join_tab + dups_ranges[j].end_idx; tab++)

6849

{

6850

if (tab->emb_sj_nest)

6851

tab->do_firstmatch= jump_to;

6852

else

6853

jump_to= tab;

6854

}

6855

}

6856

return(false);

6857

}

6858

6859

static void cleanup_sj_tmp_tables(JOIN *join)

6860

{

6861

for (SJ_TMP_TABLE *sj_tbl= join->sj_tmp_tables; sj_tbl;

6862

sj_tbl= sj_tbl->next)

6863

{

6864

if (sj_tbl->tmp_table)

6865

{

6866

sj_tbl->tmp_table->free_tmp_table(join->session);

6867

}

6868

}

6869

join->sj_tmp_tables= NULL;

6095

6870

}

6096

6871

6097

6872

/**

6098

6873

Create a condition for a const reference and add this to the

6099

6874

currenct select for the table.

6100

6875

6101

static bool add_ref_to_table_cond(Session *session, JoinTable *join_tab)

6876

static bool add_ref_to_table_cond(Session *session, JOIN_TAB *join_tab)

6102

6877

{

6103

6878

if (!join_tab->ref.key_parts)

6104

6879

return(false);

6111

6886

6112

6887

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

6113

6888

{

6114

Field *field=table->getField(table->key_info[join_tab->ref.key].key_part[i].fieldnr - 1);

6889

Field *field=table->field[table->key_info[join_tab->ref.key].key_part[i].

6890

fieldnr-1];

6115

6891

Item *value=join_tab->ref.items[i];

6116

6892

cond->add(new Item_func_equal(new Item_field(field), value));

6117

6893

}

6125

6901

error=(int) cond->add(join_tab->select->cond);

6126

6902

join_tab->select_cond=join_tab->select->cond=cond;

6127

6903

}

6128

else if ((join_tab->select= optimizer::make_select(join_tab->table, 0, 0, cond, 0,

6129

&error)))

6904

else if ((join_tab->select= make_select(join_tab->table, 0, 0, cond, 0,

6905

&error)))

6130

6906

join_tab->select_cond=cond;

6131

6907

6132

6908

return(error ? true : false);

6133

6909

}

6134

6910

6911

/**

6912

@brief Replaces an expression destructively inside the expression tree of

6913

the WHERE clase.

6914

6915

@note Because of current requirements for semijoin flattening, we do not

6916

need to recurse here, hence this function will only examine the top-level

6917

AND conditions. (see JOIN::prepare, comment above the line

6918

'if (do_materialize)'

6919

6920

@param join The top-level query.

6921

@param old_cond The expression to be replaced.

6922

@param new_cond The expression to be substituted.

6923

@param do_fix_fields If true, Item::fix_fields(Session*, Item**) is called for

6924

the new expression.

6925

@return <code>true</code> if there was an error, <code>false</code> if

6926

successful.

6927

6928

static bool replace_where_subcondition(JOIN *join, Item *old_cond,

6929

Item *new_cond, bool do_fix_fields)

6930

{

6931

if (join->conds == old_cond) {

6932

join->conds= new_cond;

6933

if (do_fix_fields)

6934

new_cond->fix_fields(join->session, &join->conds);

6935

return false;

6936

}

6937

6938

if (join->conds->type() == Item::COND_ITEM) {

6939

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

6940

Item *item;

6941

while ((item= li++))

6942

if (item == old_cond)

6943

{

6944

li.replace(new_cond);

6945

if (do_fix_fields)

6946

new_cond->fix_fields(join->session, li.ref());

6947

return false;

6948

}

6949

}

6950

6951

return true;

6952

}

6953

6954

6955

Pull tables out of semi-join nests, if possible

6956

6957

SYNOPSIS

6958

pull_out_semijoin_tables()

6959

join The join where to do the semi-join flattening

6960

6961

DESCRIPTION

6962

Try to pull tables out of semi-join nests.

6963

6964

PRECONDITIONS

6965

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

6966

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

6967

one semi-join nest does not contain another.

6968

6969

ACTION

6970

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

6971

- It is a constant table

6972

- It is accessed

6973

6974

POSTCONDITIONS

6975

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

6976

tables)

6977

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

6978

* Semi-join nests TableList::sj_inner_tables

6979

6980

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

6981

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

6982

6983

RETURN

6984

0 - OK

6985

1 - Out of memory error

6986

6987

static int pull_out_semijoin_tables(JOIN *join)

6988

{

6989

TableList *sj_nest;

6990

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

6991

6992

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

6993

while ((sj_nest= sj_list_it++))

6994

{

6995

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

6996

table_map pulled_tables= 0;

6997

6998

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

6999

TableList *tbl;

7000

while ((tbl= child_li++))

7001

{

7002

if (tbl->table)

7003

{

7004

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

7005

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

7006

{

7007

pulled_tables |= tbl->table->map;

7008

}

7009

}

7010

}

7011

7012

7013

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

7014

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

7015

us to pull out some other tables too.

7016

7017

bool pulled_a_table;

7018

7019

{

7020

pulled_a_table= false;

7021

child_li.rewind();

7022

while ((tbl= child_li++))

7023

{

7024

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

7025

{

7026

if (find_eq_ref_candidate(tbl->table,

7027

sj_nest->nested_join->used_tables &

7028

~pulled_tables))

7029

{

7030

pulled_a_table= true;

7031

pulled_tables |= tbl->table->map;

7032

}

7033

}

7034

}

7035

} while (pulled_a_table);

7036

7037

child_li.rewind();

7038

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

7039

{

7040

(sj_nest)->sj_inner_tables= 0;

7041

while ((tbl= child_li++))

7042

{

7043

if (tbl->table)

7044

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

7045

}

7046

}

7047

else

7048

{

7049

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

7050

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

7051

~pulled_tables;

7052

(sj_nest)->sj_inner_tables= inner_tables;

7053

while ((tbl= child_li++))

7054

{

7055

if (tbl->table)

7056

{

7057

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

7058

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

7059

else

7060

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

7061

}

7062

}

7063

}

7064

}

7065

return(0);

7066

}

7067

7068

7069

SemiJoinDuplicateElimination: Weed out duplicate row combinations

7070

7071

SYNPOSIS

7072

do_sj_dups_weedout()

7073

7074

RETURN

7075

-1 Error

7076

1 The row combination is a duplicate (discard it)

7077

0 The row combination is not a duplicate (continue)

7078

7079

static int do_sj_dups_weedout(Session *session, SJ_TMP_TABLE *sjtbl)

7080

{

7081

int error;

7082

SJ_TMP_TABLE::TAB *tab= sjtbl->tabs;

7083

SJ_TMP_TABLE::TAB *tab_end= sjtbl->tabs_end;

7084

unsigned char *ptr= sjtbl->tmp_table->record[0] + 1;

7085

unsigned char *nulls_ptr= ptr;

7086

7087

/* Put the the rowids tuple into table->record[0]: */

7088

7089

// 1. Store the length

7090

if (((Field_varstring*)(sjtbl->tmp_table->field[0]))->length_bytes == 1)

7091

{

7092

*ptr= (unsigned char)(sjtbl->rowid_len + sjtbl->null_bytes);

7093

ptr++;

7094

}

7095

else

7096

{

7097

int2store(ptr, sjtbl->rowid_len + sjtbl->null_bytes);

7098

ptr += 2;

7099

}

7100

7101

// 2. Zero the null bytes

7102

if (sjtbl->null_bytes)

7103

{

7104

memset(ptr, 0, sjtbl->null_bytes);

7105

ptr += sjtbl->null_bytes;

7106

}

7107

7108

// 3. Put the rowids

7109

for (uint32_t i=0; tab != tab_end; tab++, i++)

7110

{

7111

handler *h= tab->join_tab->table->file;

7112

if (tab->join_tab->table->maybe_null && tab->join_tab->table->null_row)

7113

{

7114

/* It's a NULL-complemented row */

7115

*(nulls_ptr + tab->null_byte) |= tab->null_bit;

7116

memset(ptr + tab->rowid_offset, 0, h->ref_length);

7117

}

7118

else

7119

{

7120

/* Copy the rowid value */

7121

if (tab->join_tab->rowid_keep_flags & JOIN_TAB::CALL_POSITION)

7122

h->position(tab->join_tab->table->record[0]);

7123

memcpy(ptr + tab->rowid_offset, h->ref, h->ref_length);

7124

}

7125

}

7126

7127

error= sjtbl->tmp_table->file->ha_write_row(sjtbl->tmp_table->record[0]);

7128

if (error)

7129

{

7130

/* create_myisam_from_heap will generate error if needed */

7131

if (sjtbl->tmp_table->file->is_fatal_error(error, HA_CHECK_DUP) &&

7132

create_myisam_from_heap(session, sjtbl->tmp_table, sjtbl->start_recinfo,

7133

&sjtbl->recinfo, error, 1))

7134

return -1;

7135

//return (error == HA_ERR_FOUND_DUPP_KEY || error== HA_ERR_FOUND_DUPP_UNIQUE) ? 1: -1;

7136

return 1;

7137

}

7138

return 0;

7139

}

7140

6135

7141

static void free_blobs(Field **ptr)

6136

7142

{

6137

7143

for (; *ptr ; ptr++)

6141

7147

}

6142

7148

}

6143

7149

7150

static bool bitmap_covers(const table_map x, const table_map y)

7151

{

7152

return !test(y & ~x);

7153

}

7154

7155

7156

Check if the table's rowid is included in the temptable

7157

7158

SYNOPSIS

7159

sj_table_is_included()

7160

join The join

7161

join_tab The table to be checked

7162

7163

DESCRIPTION

7164

SemiJoinDuplicateElimination: check the table's rowid should be included

7165

in the temptable. This is so if

7166

7167

1. The table is not embedded within some semi-join nest

7168

2. The has been pulled out of a semi-join nest, or

7169

7170

3. The table is functionally dependent on some previous table

7171

7172

[4. This is also true for constant tables that can't be

7173

NULL-complemented but this function is not called for such tables]

7174

7175

RETURN

7176

true - Include table's rowid

7177

false - Don't

7178

7179

static bool sj_table_is_included(JOIN *join, JOIN_TAB *join_tab)

7180

{

7181

if (join_tab->emb_sj_nest)

7182

return false;

7183

7184

/* Check if this table is functionally dependent on the tables that

7185

are within the same outer join nest

7186

7187

TableList *embedding= join_tab->table->pos_in_table_list->embedding;

7188

if (join_tab->type == JT_EQ_REF)

7189

{

7190

Table_map_iterator it(join_tab->ref.depend_map & ~PSEUDO_TABLE_BITS);

7191

uint32_t idx;

7192

while ((idx= it.next_bit())!=Table_map_iterator::BITMAP_END)

7193

{

7194

JOIN_TAB *ref_tab= join->join_tab + idx;

7195

if (embedding == ref_tab->table->pos_in_table_list->embedding)

7196

return true;

7197

}

7198

/* Ok, functionally dependent */

7199

return false;

7200

}

7201

/* Not functionally dependent => need to include*/

7202

return true;

7203

}

7204

6144

7205

/**

6145

7206

@} (end of group Query_Optimizer)

6146

7207

6147

6148

} /* namespace drizzled */

Older »