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

5011

{

5012

/* Join with outer join condition */

5013

COND *orig_cond=sel->cond;

5014

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

5015

5016

5017

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

5018

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

5019

(fix_fields currently removes extra AND/OR levels).

5020

Yet attributes of the just built condition are not needed.

5021

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

5022

5023

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

5024

sel->cond->quick_fix_field();

5025

5026

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

5027

used_tables & ~ current_map,

5028

(join->select_options &

5029

OPTION_FOUND_ROWS ?

5030

HA_POS_ERROR :

5031

join->unit->select_limit_cnt), 0,

5032

false) < 0)

4721

5033

{

4722

4723

Before reporting "Impossible WHERE" for the whole query

4724

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

4725

5034

5035

Before reporting "Impossible WHERE" for the whole query

5036

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

5037

4726

5038

sel->cond=orig_cond;

4727

if (! *tab->on_expr_ref ||

5039

if (!*tab->on_expr_ref ||

4728

5040

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

5041

used_tables & ~ current_map,

5042

(join->select_options &

5043

OPTION_FOUND_ROWS ?

5044

HA_POS_ERROR :

5045

join->unit->select_limit_cnt),0,

5046

false) < 0)

5047

return(1); // Impossible WHERE

4736

5048

}

4737

5049

else

4738

sel->cond=orig_cond;

5050

sel->cond=orig_cond;

4739

5051

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

}

5052

/* Fix for EXPLAIN */

5053

if (sel->quick)

5054

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

5055

}

5056

else

5057

{

5058

sel->needed_reg=tab->needed_reg;

5059

sel->quick_keys.reset();

5060

}

4752

5061

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

4753

5062

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

4754

{

4755

tab->keys= sel->quick_keys;

5063

{

5064

tab->keys= sel->quick_keys;

4756

5065

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

5066

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

5067

(select->quick_keys.none() ||

5068

(select->quick &&

5069

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

5070

2 : 1;

5071

sel->read_tables= used_tables & ~current_map;

5072

}

5073

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

5074

{ /* Read with cache */

5075

if (cond &&

4767

5076

(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

}

5077

join->const_table_map |

5078

current_map,

5079

current_map, 0)))

5080

{

5081

tab->cache.select=(SQL_SELECT*)

5082

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

5083

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

5084

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

5085

}

5086

}

5087

}

4779

5088

}

4780

5089

4781

5090

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

5091

Push down conditions from all on expressions.

5092

Each of these conditions are guarded by a variable

5093

that turns if off just before null complemented row for

5094

outer joins is formed. Thus, the condition from an

5095

'on expression' are guaranteed not to be checked for

5096

the null complemented row.

5097

4789

5098

4790

5099

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

5100

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

5101

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

4793

5102

{

4794

5103

if (*join_tab->on_expr_ref)

4795

5104

{

4796

JoinTable *cond_tab= join_tab->first_inner;

5105

JOIN_TAB *cond_tab= join_tab->first_inner;

4797

5106

tmp= make_cond_for_table(*join_tab->on_expr_ref,

4798

join->const_table_map,

4799

(table_map) 0, 0);

5107

join->const_table_map,

5108

(table_map) 0, 0);

4800

5109

if (!tmp)

4801

5110

continue;

4802

5111

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

4803

if (! tmp)

4804

return 1;

5112

if (!tmp)

5113

return(1);

4805

5114

tmp->quick_fix_field();

4806

5115

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;

5116

new Item_cond_and(cond_tab->select_cond,tmp);

5117

if (!cond_tab->select_cond)

5118

return(1);

4810

5119

cond_tab->select_cond->quick_fix_field();

4811

5120

}

4812

5121

}

4813

5122

4814

5123

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

4815

JoinTable *last_tab= tab;

5124

JOIN_TAB *last_tab= tab;

4816

5125

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

4817

5126

{

4818

5127

4819

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

4820

An on expression is always attached to it.

4821

5128

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

5129

An on expression is always attached to it.

5130

4822

5131

COND *on_expr= *first_inner_tab->on_expr_ref;

4823

5132

4824

5133

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

5134

OUTER_REF_TABLE_BIT | RAND_TABLE_BIT);

5135

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

4827

5136

{

4828

5137

current_map= tab->table->map;

4829

5138

used_tables2|= current_map;

4830

5139

COND *tmp_cond= make_cond_for_table(on_expr, used_tables2,

4831

current_map, 0);

5140

current_map, 0);

4832

5141

if (tmp_cond)

4833

5142

{

4834

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

5143

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

4835

5144

4836

First add the guards for match variables of

4837

all embedding outer join operations.

4838

5145

First add the guards for match variables of

5146

all embedding outer join operations.

5147

4839

5148

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

4840

tmp_cond,

4841

first_inner_tab)))

4842

return 1;

5149

tmp_cond,

5150

first_inner_tab)))

5151

return(1);

4843

5152

4844

Now add the guard turning the predicate off for

4845

the null complemented row.

4846

5153

Now add the guard turning the predicate off for

5154

the null complemented row.

5155

4847

5156

tmp_cond= new Item_func_trig_cond(tmp_cond,

4848

&first_inner_tab->

4849

not_null_compl);

5157

&first_inner_tab->

5158

not_null_compl);

4850

5159

if (tmp_cond)

4851

5160

tmp_cond->quick_fix_field();

4852

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

5161

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

4853

5162

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;

5163

new Item_cond_and(cond_tab->select_cond,

5164

tmp_cond);

5165

if (!cond_tab->select_cond)

5166

return(1);

4858

5167

cond_tab->select_cond->quick_fix_field();

4859

5168

}

4860

5169

}

4886

5195

false - OK

4887

5196

true - Out of memory

4888

5197

4889

static bool make_join_readinfo(Join *join)

5198

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

4890

5199

{

4891

bool sorted= true;

5200

uint32_t i;

5201

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

5202

bool sorted= 1;

4892

5203

4893

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

5204

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

4894

5205

{

4895

JoinTable *tab=join->join_tab+i;

5206

JOIN_TAB *tab=join->join_tab+i;

4896

5207

Table *table=tab->table;

5208

bool using_join_cache;

4897

5209

tab->read_record.table= table;

4898

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

5210

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

4899

5211

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

4900

5212

4901

5213

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

4902

5214

produce sorted output.

4903

5215

4904

5216

tab->sorted= sorted;

4905

sorted= false; // only first must be sorted

4906

5217

sorted= 0; // only first must be sorted

4907

5218

if (tab->insideout_match_tab)

4908

5219

{

4909

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

4910

[tab->index].

4911

key_length)))

5220

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

5221

[tab->index].

5222

key_length)))

4912

5223

return true;

4913

5224

}

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

5225

switch (tab->type) {

5226

case JT_SYSTEM: // Only happens with left join

5227

table->status=STATUS_NO_RECORD;

5228

tab->read_first_record= join_read_system;

5229

tab->read_record.read_record= join_no_more_records;

5230

break;

5231

case JT_CONST: // Only happens with left join

5232

table->status=STATUS_NO_RECORD;

5233

tab->read_first_record= join_read_const;

5234

tab->read_record.read_record= join_no_more_records;

5235

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

5236

!table->no_keyread)

5237

{

5238

table->key_read=1;

5239

table->file->extra(HA_EXTRA_KEYREAD);

5240

}

5241

break;

5242

case JT_EQ_REF:

5243

table->status=STATUS_NO_RECORD;

5244

if (tab->select)

5245

{

5246

delete tab->select->quick;

5247

tab->select->quick=0;

5248

}

5249

delete tab->quick;

5250

tab->quick=0;

5251

tab->read_first_record= join_read_key;

5252

tab->read_record.read_record= join_no_more_records;

5253

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

5254

{

5255

table->key_read=1;

5256

table->file->extra(HA_EXTRA_KEYREAD);

5257

}

5258

else

5259

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

5260

break;

5261

case JT_REF_OR_NULL:

5262

case JT_REF:

5263

table->status=STATUS_NO_RECORD;

5264

if (tab->select)

5265

{

5266

delete tab->select->quick;

5267

tab->select->quick=0;

5268

}

5269

delete tab->quick;

5270

tab->quick=0;

5271

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

5272

{

5273

table->key_read=1;

5274

table->file->extra(HA_EXTRA_KEYREAD);

5275

}

5276

else

5277

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

5278

if (tab->type == JT_REF)

5279

{

5280

tab->read_first_record= join_read_always_key;

5281

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

5282

join_read_next_same_diff : join_read_next_same;

5283

}

5284

else

5285

{

5286

tab->read_first_record= join_read_always_key_or_null;

5287

tab->read_record.read_record= join_read_next_same_or_null;

5288

}

5289

break;

5290

case JT_ALL:

5291

5292

If previous table use cache

5293

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

5294

5295

table->status=STATUS_NO_RECORD;

5296

using_join_cache= false;

5297

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

5298

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

5299

!tab->insideout_match_tab)

5300

{

5301

if ((options & SELECT_DESCRIBE) ||

5302

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

5303

i-join->const_tables))

5304

{

5305

using_join_cache= true;

5306

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

5307

}

5308

}

5309

/* These init changes read_record */

5310

if (tab->use_quick == 2)

5311

{

5312

join->session->server_status|=SERVER_QUERY_NO_GOOD_INDEX_USED;

5313

tab->read_first_record= join_init_quick_read_record;

5314

if (statistics)

5315

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

5316

}

5317

else

5318

{

5319

tab->read_first_record= join_init_read_record;

5320

if (i == join->const_tables)

5321

{

5322

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

5323

{

5324

if (statistics)

5325

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

5326

}

5327

else

5328

{

5329

join->session->server_status|=SERVER_QUERY_NO_INDEX_USED;

5330

if (statistics)

5331

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

5332

}

5333

}

5334

else

5335

{

5336

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

5337

{

5338

if (statistics)

5339

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

5340

}

5341

else

5342

{

5343

join->session->server_status|=SERVER_QUERY_NO_INDEX_USED;

5344

if (statistics)

5345

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

5346

}

5347

}

5348

if (!table->no_keyread)

5349

{

5350

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

5351

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

5352

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

5353

{

5354

table->key_read=1;

5355

table->file->extra(HA_EXTRA_KEYREAD);

5356

}

5357

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

5358

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

5359

{ // Only read index tree

5360

if (!tab->insideout_match_tab)

5361

{

5362

5363

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

5364

is always faster than using a secondary index".

5365

5366

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

5367

table->file->primary_key_is_clustered())

5368

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

5369

else

5370

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

5371

}

5372

tab->read_first_record= join_read_first;

5373

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

5374

}

5375

}

5376

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

5377

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

5378

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

5379

}

5380

break;

5381

default:

5382

break; /* purecov: deadcode */

5383

case JT_UNKNOWN:

5384

case JT_MAYBE_REF:

5385

abort(); /* purecov: deadcode */

4926

5386

}

4927

4928

access_method->getStats(table, tab);

4929

5387

}

4930

4931

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

4932

4933

return false;

5388

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

5389

return(false);

4934

5390

}

4935

5391

4936

5392

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

4937

static void update_depend_map(Join *join)

5393

static void update_depend_map(JOIN *join)

4938

5394

{

4939

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

5395

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

4940

5396

4941

5397

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

4942

5398

{

4943

table_reference_st *ref= &join_tab->ref;

4944

table_map depend_map= 0;

5399

TABLE_REF *ref= &join_tab->ref;

5400

table_map depend_map=0;

4945

5401

Item **item=ref->items;

4946

5402

uint32_t i;

4947

5403

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

4948

5404

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

4949

5405

ref->depend_map=depend_map & ~OUTER_REF_TABLE_BIT;

4950

5406

depend_map&= ~OUTER_REF_TABLE_BIT;

4951

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

5407

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

4952

5408

{

4953

5409

if (depend_map & 1)

4954

5410

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

4957

5413

}

4958

5414

4959

5415

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

4960

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

5416

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

4961

5417

{

4962

5418

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

4963

5419

{

4968

5424

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

4969

5425

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

4970

5426

{

4971

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

5427

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

4972

5428

{

4973

5429

if (depend_map & 1)

4974

5430

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

4995

5451

@return

4996

5452

Returns new sort order

4997

5453

4998

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

5454

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

4999

5455

{

5000

5456

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

5001

5457

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

5002

5458

5003

Order *order,**prev_ptr;

5459

order_st *order,**prev_ptr;

5004

5460

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

5005

5461

table_map not_const_tables= ~join->const_table_map;

5006

5462

table_map ref;

5055

5511

return(first_order);

5056

5512

}

5057

5513

5058

static int return_zero_rows(Join *join,

5514

static int return_zero_rows(JOIN *join,

5059

5515

select_result *result,

5060

5516

TableList *tables,

5061

5517

List<Item> &fields,

5066

5522

{

5067

5523

if (select_options & SELECT_DESCRIBE)

5068

5524

{

5069

optimizer::ExplainPlan planner(join,

5070

false,

5071

false,

5072

false,

5073

info);

5074

planner.printPlan();

5075

return 0;

5525

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

5526

return(0);

5076

5527

}

5077

5528

5078

5529

join->join_free();

5084

5535

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

5085

5536

send_row=0;

5086

5537

}

5087

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

5538

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

5088

5539

{

5089

5540

if (send_row)

5090

5541

{

5221

5672

- The new condition, if success

5222

5673

- 0, otherwise

5223

5674

5224

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

5675

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

5225

5676

{

5226

5677

TableList *table;

5227

5678

nested_join_st *nested_join;

5237

5688

table_map used_tables;

5238

5689

table_map not_null_tables= (table_map) 0;

5239

5690

5240

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

5691

if ((nested_join= table->nested_join))

5241

5692

{

5242

5693

5243

5694

If the element of join_list is a nested join apply

5254

5705

the outer join is converted to an inner join and

5255

5706

the corresponding on expression is added to E.

5256

5707

5257

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

5708

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

5709

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

5258

5710

5259

5711

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

5260

5712

{

5266

5718

}

5267

5719

nested_join->used_tables= (table_map) 0;

5268

5720

nested_join->not_null_tables=(table_map) 0;

5269

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

5721

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

5270

5722

used_tables= nested_join->used_tables;

5271

5723

not_null_tables= nested_join->not_null_tables;

5272

5724

}

5279

5731

not_null_tables= conds->not_null_tables();

5280

5732

}

5281

5733

5282

if (table->getEmbedding())

5734

if (table->embedding)

5283

5735

{

5284

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

5285

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

5736

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

5737

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

5286

5738

}

5287

5739

5288

5740

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

5318

5770

5319

5771

if (table->on_expr)

5320

5772

{

5321

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

5322

if (table->getEmbedding())

5773

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

5774

if (table->embedding)

5323

5775

{

5324

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

5776

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

5325

5777

5326

5778

Embedding table depends on tables used

5327

5779

in embedded on expressions.

5328

5780

5329

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

5781

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

5330

5782

}

5331

5783

else

5332

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

5784

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

5333

5785

}

5334

5786

5335

5787

if (prev_table)

5336

5788

{

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

5789

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

5790

if (prev_table->straight)

5791

prev_table->dep_tables|= used_tables;

5342

5792

if (prev_table->on_expr)

5343

5793

{

5344

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

5345

table_map prev_used_tables= prev_table->getNestedJoin() ?

5346

prev_table->getNestedJoin()->used_tables :

5794

prev_table->dep_tables|= table->on_expr_dep_tables;

5795

table_map prev_used_tables= prev_table->nested_join ?

5796

prev_table->nested_join->used_tables :

5347

5797

prev_table->table->map;

5348

5798

5349

5799

If on expression contains only references to inner tables

5352

5802

for them. Yet this is really a rare case.

5353

5803

5354

5804

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

5355

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

5805

prev_table->dep_tables|= used_tables;

5356

5806

}

5357

5807

}

5358

5808

prev_table= table;

5365

5815

li.rewind();

5366

5816

while ((table= li++))

5367

5817

{

5368

nested_join= table->getNestedJoin();

5369

if (nested_join && !table->on_expr)

5818

nested_join= table->nested_join;

5819

if (table->sj_on_expr && !in_sj)

5820

{

5821

5822

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

5823

leave it intact (otherwise it is flattened)

5824

5825

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

5826

}

5827

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

5370

5828

{

5371

5829

TableList *tbl;

5372

5830

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

5373

5831

while ((tbl= it++))

5374

5832

{

5375

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

5376

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

5833

tbl->embedding= table->embedding;

5834

tbl->join_list= table->join_list;

5377

5835

}

5378

5836

li.replace(nested_join->join_list);

5379

5837

}

5381

5839

return(conds);

5382

5840

}

5383

5841

5384

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

5842

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

5385

5843

{

5386

5844

int error;

5387

5845

uint32_t reclength,offset;

5405

5863

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

5406

5864

return(0);

5407

5865

}

5408

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

5866

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

5409

5867

offset= (field_count ?

5410

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

5411

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

5868

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

5869

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

5870

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

5412

5871

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

{

5872

free_io_cache(entry); // Safety

5873

entry->file->info(HA_STATUS_VARIABLE);

5874

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

5875

(!entry->s->blob_fields &&

5876

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

5877

session->variables.sortbuff_size)))

5420

5878

error= remove_dup_with_hash_index(join->session, entry,

5421

field_count, first_field,

5422

reclength, having);

5423

}

5879

field_count, first_field,

5880

reclength, having);

5424

5881

else

5425

{

5426

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

5427

}

5882

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

5883

having);

5428

5884

5429

5885

free_blobs(first_field);

5430

5431

5886

return(error);

5432

5887

}

5433

5888

5441

5896

List<Item> &fields,

5442

5897

List<Item> &all_fields,

5443

5898

COND **conds,

5444

Order *order,

5445

Order *group,

5899

order_st *order,

5900

order_st *group,

5446

5901

bool *hidden_group_fields)

5447

5902

{

5448

5903

int res;

5449

5904

nesting_map save_allow_sum_func=session->lex->allow_sum_func ;

5450

5905

5451

5906

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

5452

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

5907

res= setup_conds(session, tables, conds);

5453

5908

5454

5909

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

5455

5910

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

5469

5924

@retval

5470

5925

1 Fatal error

5471

5926

5472

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

5927

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

5473

5928

{

5474

5929

int error;

5475

5930

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;

5931

uint32_t i,table_count,const_count,key;

5932

table_map found_const_table_map, all_table_map, found_ref, refs;

5933

key_map const_ref, eq_part;

5934

Table **table_vector;

5935

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

5936

KEYUSE *keyuse,*start_keyuse;

5937

table_map outer_join=0;

5938

SARGABLE_PARAM *sargables= 0;

5939

JOIN_TAB *stat_vector[MAX_TABLES+1];

5497

5940

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;

5941

table_count=join->tables;

5942

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

5943

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

5944

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

5945

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

5946

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

5504

5947

5505

5948

join->best_ref=stat_vector;

5506

5949

5512

5955

tables;

5513

5956

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

5514

5957

{

5515

TableList *embedding= tables->getEmbedding();

5958

TableList *embedding= tables->embedding;

5516

5959

stat_vector[i]=s;

5517

5960

s->keys.reset();

5518

5961

s->const_keys.reset();

5520

5963

s->needed_reg.reset();

5521

5964

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

5522

5965

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)

5966

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

5967

if(error)

5526

5968

{

5527

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

5528

return 1;

5969

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

5970

return(1);

5529

5971

}

5530

5972

table->quick_keys.reset();

5531

5973

table->reginfo.join_tab=s;

5532

5974

table->reginfo.not_exists_optimize=0;

5533

5975

memset(table->const_key_parts, 0,

5534

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

5976

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

5535

5977

all_table_map|= table->map;

5536

5978

s->join=join;

5537

5979

s->info=0; // For describe

5538

5980

5539

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

5981

s->dependent= tables->dep_tables;

5540

5982

s->key_dependent= 0;

5541

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

5983

if (tables->schema_table)

5984

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

5985

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

5542

5986

5543

5987

s->on_expr_ref= &tables->on_expr;

5544

5988

if (*s->on_expr_ref)

5545

5989

{

5546

5990

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

5547

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

5991

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

5548

5992

{ // Empty table

5549

5993

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

5550

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

5994

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

5551

5995

continue;

5552

5996

}

5553

5997

outer_join|= table->map;

5554

s->embedding_map.reset();

5555

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

5556

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

5998

s->embedding_map= 0;

5999

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

6000

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

5557

6001

continue;

5558

6002

}

5559

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

6003

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

5560

6004

{

5561

6005

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

5562

s->embedding_map.reset();

6006

s->embedding_map= 0;

5563

6007

5564

6008

{

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

6009

nested_join_st *nested_join= embedding->nested_join;

6010

s->embedding_map|=nested_join->nj_map;

6011

s->dependent|= embedding->dep_tables;

6012

embedding= embedding->embedding;

5569

6013

outer_join|= nested_join->used_tables;

5570

6014

}

5571

6015

while (embedding);

5572

6016

continue;

5573

6017

}

5574

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

5575

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

6018

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

6019

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

5576

6020

!join->no_const_tables)

5577

6021

{

5578

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

6022

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

5579

6023

}

5580

6024

}

5581

6025

stat_vector[i]=0;

5609

6053

{

5610

6054

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

5611

6055

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

5612

return 1;

6056

return(1);

5613

6057

}

5614

6058

s->key_dependent= s->dependent;

5615

6059

}

5618

6062

if (conds || outer_join)

5619

6063

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

5620

6064

conds, join->cond_equal,

5621

~outer_join, join->select_lex, sargables))

5622

return 1;

6065

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

6066

return(1);

5623

6067

5624

6068

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

5625

6069

join->const_table_map= 0;

5626

6070

5627

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

5628

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

5629

while (p_pos < p_end)

6071

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

6072

p_pos < p_end ;

6073

p_pos++)

5630

6074

{

5631

6075

int tmp;

5632

s= p_pos->getJoinTable();

5633

s->type= AM_SYSTEM;

6076

s= p_pos->table;

6077

s->type=JT_SYSTEM;

5634

6078

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

5635

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

6079

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

5636

6080

{

5637

6081

if (tmp > 0)

5638

return 1; // Fatal error

6082

return(1); // Fatal error

5639

6083

}

5640

6084

else

5641

6085

found_const_table_map|= s->table->map;

5642

p_pos++;

5643

6086

}

5644

6087

5645

6088

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

5655

6098

set_position() will move all const_tables first in stat_vector

5656

6099

5657

6100

5658

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

6101

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

5659

6102

{

5660

table= s->table;

6103

table=s->table;

5661

6104

5662

6105

5663

6106

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

5664

6107

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

5665

6108

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

5666

6109

5667

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

6110

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

5668

6111

{

5669

6112

5670

6113

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

5676

6119

TODO. Apply single row substitution to null complemented inner tables

5677

6120

for nested outer join operations.

5678

6121

5679

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

6122

while (keyuse->table == table)

5680

6123

{

5681

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

5682

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

6124

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

6125

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

5683

6126

{

5684

s->type= AM_CONST;

6127

s->type= JT_CONST;

5685

6128

table->mark_as_null_row();

5686

6129

found_const_table_map|= table->map;

5687

6130

join->const_table_map|= table->map;

5688

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

6131

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

5689

6132

goto more_const_tables_found;

5690

6133

}

5691

6134

keyuse++;

5697

6140

// All dep. must be constants

5698

6141

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

5699

6142

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

6143

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

6144

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

6145

!table->pos_in_table_list->embedding)

5703

6146

{ // system table

5704

6147

int tmp= 0;

5705

s->type= AM_SYSTEM;

6148

s->type=JT_SYSTEM;

5706

6149

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

6150

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

6151

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

5710

6152

{

5711

6153

if (tmp > 0)

5712

return 1; // Fatal error

6154

return(1); // Fatal error

5713

6155

}

5714

6156

else

5715

6157

found_const_table_map|= table->map;

5719

6161

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

5720

6162

if ((keyuse=s->keyuse))

5721

6163

{

5722

s->type= AM_REF;

5723

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

6164

s->type= JT_REF;

6165

while (keyuse->table == table)

5724

6166

{

5725

start_keyuse= keyuse;

5726

key= keyuse->getKey();

6167

start_keyuse=keyuse;

6168

key=keyuse->key;

5727

6169

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

5728

6170

5729

refs= 0;

5730

const_ref.reset();

6171

refs=0;

6172

const_ref.reset();

5731

6173

eq_part.reset();

5732

6174

5733

6175

{

5734

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

5735

! keyuse->getOptimizeFlags())

6176

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

5736

6177

{

5737

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

5738

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

6178

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

6179

const_ref.set(keyuse->keypart);

5739

6180

else

5740

refs|= keyuse->getUsedTables();

5741

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

6181

refs|=keyuse->used_tables;

6182

eq_part.set(keyuse->keypart);

5742

6183

}

5743

6184

keyuse++;

5744

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

6185

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

5745

6186

5746

6187

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

5747

! table->pos_in_table_list->getEmbedding())

6188

!table->pos_in_table_list->embedding)

5748

6189

{

5749

6190

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

5750

6191

{

5752

6193

{ // Found everything for ref.

5753

6194

int tmp;

5754

6195

ref_changed = 1;

5755

s->type= AM_CONST;

6196

s->type= JT_CONST;

5756

6197

join->const_table_map|= table->map;

5757

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

6198

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

5758

6199

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

6200

return(1);

6201

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

5762

6202

{

5763

6203

if (tmp > 0)

5764

return 1; // Fatal error

6204

return(1); // Fatal error

5765

6205

}

5766

6206

else

5767

6207

found_const_table_map|= table->map;

5782

6222

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

5783

6223

reading const tables may has added new sargable predicates.

5784

6224

5785

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

6225

if (const_count && sargables)

5786

6226

{

5787

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

5788

while (iter != sargables.end())

6227

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

5789

6228

{

5790

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

5791

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

6229

Field *field= sargables->field;

6230

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

5792

6231

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

6232

possible_keys&= field->table->keys_in_use_for_query;

6233

bool is_const= 1;

6234

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

6235

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

5797

6236

if (is_const)

5798

6237

join_tab[0].const_keys|= possible_keys;

5799

++iter;

5800

6238

}

5801

6239

}

5802

6240

6241

if (pull_out_semijoin_tables(join))

6242

return(true);

6243

5803

6244

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

5804

6245

5805

6246

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

5806

6247

{

5807

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

6248

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

5808

6249

{

5809

6250

/* Only one matching row */

5810

6251

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

5811

6252

continue;

5812

6253

}

5813

6254

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

6255

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

6256

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

5816

6257

5817

6258

5818

6259

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

5819

6260

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

5820

6261

table scan.

5821

6262

5822

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

5823

(double) s->read_time*3);

6263

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

6264

(double) s->read_time*3);

5824

6265

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

5825

6266

s->worst_seeks=2.0;

5826

6267

5831

6272

add_group_and_distinct_keys(join, s);

5832

6273

5833

6274

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

5834

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

6275

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

5835

6276

{

5836

6277

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

6278

SQL_SELECT *select;

6279

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

6280

if (! select)

5840

return 1;

6281

return(1);

5841

6282

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

5842

6283

s->quick=select->quick;

5843

6284

s->needed_reg=select->needed_reg;

5851

6292

caller to abort with a zero row result.

5852

6293

5853

6294

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

5854

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

5855

s->type= AM_CONST;

6295

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

6296

s->type= JT_CONST;

5856

6297

if (*s->on_expr_ref)

5857

6298

{

5858

6299

/* Generate empty row */

5859

6300

s->info= "Impossible ON condition";

5860

6301

found_const_table_map|= s->table->map;

5861

s->type= AM_CONST;

6302

s->type= JT_CONST;

5862

6303

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

5863

6304

}

5864

6305

}

5881

6322

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

5882

6323

{

5883

6324

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;

6325

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

6326

return(true);

5891

6327

}

5892

6328

else

5893

6329

{

5894

join->copyPartialPlanIntoOptimalPlan(join->const_tables);

6330

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

5895

6331

join->best_read= 1.0;

5896

6332

}

5897

6333

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

5898

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

6334

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

5899

6335

}

5900

6336

5901

6337

/**

5902

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

6338

Assign each nested join structure a bit in nested_join_map.

5903

6339

5904

6340

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

5905

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

6341

embed only one element) a bit in nested_join_map.

5906

6342

5907

6343

@param join Join being processed

5908

6344

@param join_list List of tables

5909

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

6345

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

5910

6346

call

5911

6347

5912

6348

@note

5913

6349

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

5914

6350

redundant nested joins, #non_confluent_nested_joins <= #tables_in_join so

5915

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

6351

we will not run out of bits in nested_join_map.

5916

6352

5917

6353

@return

5918

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

6354

First unused bit in nested_join_map after the call.

5919

6355

5920

6356

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

5921

6357

{

5924

6360

while ((table= li++))

5925

6361

{

5926

6362

nested_join_st *nested_join;

5927

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

6363

if ((nested_join= table->nested_join))

5928

6364

{

5929

6365

5930

6366

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

5935

6371

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

5936

6372

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

5937

6373

with anything)

5938

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

6374

2. we could run out bits in nested_join_map otherwise.

5939

6375

5940

6376

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

5941

6377

{

5942

6378

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

5943

6379

if (table->on_expr)

5944

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

6380

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

5945

6381

first_unused= build_bitmap_for_nested_joins(&nested_join->join_list,

5946

6382

first_unused);

5947

6383

}

5955

6391

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

5956

6392

and group and order is compatible, else return 0.

5957

6393

5958

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

6394

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

5959

6395

{

5960

6396

table_map map= (table_map) 0;

5961

6397

5995

6431

while ((table= li++))

5996

6432

{

5997

6433

nested_join_st *nested_join;

5998

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

6434

if ((nested_join= table->nested_join))

5999

6435

{

6000

6436

nested_join->counter_= 0;

6001

6437

reset_nj_counters(&nested_join->join_list);

6010

6446

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

6011

6447

(group is sorted like order)

6012

6448

6013

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

6449

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

6014

6450

{

6015

6451

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

6016

6452

{

6025

6461

/**

6026

6462

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

6027

6463

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

6464

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

6465

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

6466

function for the first table in join order (for which

6071

6467

check_interleaving_with_nj has not been called)

6072

6468

6073

6469

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

6074

6470

partial join order.

6075

6471

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)

6472

static void restore_prev_nj_state(JOIN_TAB *last)

6473

{

6474

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

6475

JOIN *join= last->join;

6476

while (last_emb)

6477

{

6478

if (last_emb->on_expr)

6479

{

6480

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

6481

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

6482

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

6483

last_emb->nested_join->counter_)

6484

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

6485

else

6486

break;

6487

}

6488

last_emb= last_emb->embedding;

6489

}

6490

}

6491

6492

/**

6493

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

6494

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

6495

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

6496

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

6497

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

6498

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

6499

operation and doesn't prevent join cache usage.

6500

6501

static uint32_t make_join_orderinfo(JOIN *join)

6502

{

6503

uint32_t i;

6504

if (join->need_tmp)

6505

return join->tables;

6506

6507

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

6508

{

6509

JOIN_TAB *tab= join->join_tab+i;

6510

Table *table= tab->table;

6511

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

6512

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

6513

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

6514

{

6091

6515

break;

6092

6093

join->cur_embedding_map|= nest->nj_map;

6094

}

6516

}

6517

}

6518

return i;

6519

}

6520

6521

/**

6522

Setup the strategies to eliminate semi-join duplicates.

6523

6524

SYNOPSIS

6525

setup_semijoin_dups_elimination()

6526

join Join to process

6527

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

6528

used or not)

6529

no_jbuf_after Another bit of information re where join buffering will

6530

be used.

6531

6532

DESCRIPTION

6533

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

6534

strategies:

6535

6536

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

6537

of row combinations)

6538

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

6539

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

6540

together and picking the 1st one)

6541

6542

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

6543

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

6544

other strategy.

6545

6546

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

6547

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

6548

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

6549

are joined together, which is equivalent to converting

6550

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

6551

6552

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

6553

6554

6555

Applicability conditions are as follows:

6556

6557

DuplicateWeedout strategy

6558

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

6559

6560

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

6561

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

6562

(1) (2) (3)

6563

6564

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

6565

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

6566

Noncorrelated Tables.

6567

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

6568

table, and covers all sj-inner and outer tables

6569

Within the range, Inner, Outer, outer Noncorrelated tables

6570

may follow in any order.

6571

(3) - The suffix of outer Noncorrelated tables.

6572

6573

FirstMatch strategy

6574

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

6575

6576

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

6577

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

6578

(1) (2) (3)

6579

6580

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

6581

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

6582

non-correlated tables.

6583

(3) - The suffix of outer Noncorrelated tables.

6584

6585

InsideOut strategy

6586

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

6587

6588

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

6589

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

6590

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

6591

6592

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

6593

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

6594

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

6595

6596

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

6597

6598

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

6599

application of FirstMatch strategy, with the exception that

6600

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

6601

6602

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

6603

6604

If several strategies are applicable, their relative priorities are:

6605

1. InsideOut

6606

2. FirstMatch

6607

3. DuplicateWeedout

6608

6609

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

6610

setting appropriate members in join_tab structures.

6611

6612

RETURN

6613

false OK

6614

true Out of memory error

6615

6616

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

6617

{

6618

table_map cur_map= join->const_table_map | PSEUDO_TABLE_BITS;

6619

struct {

6620

6621

0 - invalid (EOF marker),

6622

1 - InsideOut,

6623

2 - Temptable (maybe confluent),

6624

3 - Temptable with join buffering

6625

6626

uint32_t strategy;

6627

uint32_t start_idx; /* Left range bound */

6628

uint32_t end_idx; /* Right range bound */

6629

6630

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

6631

all involved join nests.

6632

6633

table_map outer_tables;

6634

} dups_ranges [MAX_TABLES];

6635

6636

TableList *emb_insideout_nest= NULL;

6637

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

6638

tables) whose ranges we're in */

6639

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

6640

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

6641

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

6642

int cur_range= 0;

6643

uint32_t i;

6644

6645

6646

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

6647

6648

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

6649

{

6650

JOIN_TAB *tab=join->join_tab+i;

6651

Table *table=tab->table;

6652

cur_map |= table->map;

6653

6654

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

6655

{

6656

if (!emb_sj_map)

6657

{

6658

dups_ranges[cur_range].start_idx= i;

6659

range_start_map= cur_map & ~table->map;

6660

6661

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

6662

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

6663

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

6664

support InsideOut for joined ranges)

6665

6666

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

6667

emb_insideout_nest= tab->emb_sj_nest;

6668

}

6669

6670

emb_sj_map |= tab->emb_sj_nest->sj_inner_tables;

6671

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

6672

6673

if (tab->emb_sj_nest != emb_insideout_nest)

6674

{

6675

6676

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

6677

InsideOut strategy.

6678

6679

emb_insideout_nest= NULL;

6680

}

6681

}

6682

6683

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

6684

{

6685

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

6686

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

6687

i <= no_jbuf_after && !dealing_with_jbuf)

6688

{

6689

6690

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

6691

InsideOut strategies impossible for the current and (we assume)

6692

preceding duplicate-producing ranges.

6693

That is, for the join order:

6694

6695

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

6696

| | | | | \

6697

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

6698

r1 r2 we're here

6699

6700

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

6701

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

6702

one.

6703

6704

dealing_with_jbuf= true;

6705

emb_insideout_nest= false;

6706

6707

6708

Absorb all preceding duplicate-eliminating ranges. Their strategies

6709

do not matter:

6710

6711

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

6712

{

6713

dups_ranges[cur_range].outer_tables |=

6714

dups_ranges[prev_range].outer_tables;

6715

}

6716

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

6717

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

6718

cur_range= 0;

6719

}

6720

6721

6722

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

6723

6724

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

6725

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

6726

6727

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

6728

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

6729

sj-nests are in the join order prefix.

6730

6731

bool end_of_range= false;

6732

if (emb_insideout_nest &&

6733

bitmap_covers(cur_map, emb_insideout_nest->sj_inner_tables))

6734

{

6735

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

6736

dups_ranges[cur_range].strategy= 1;

6737

end_of_range= true;

6738

}

6739

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

6740

{

6741

6742

This is a complete range to be handled with either DuplicateWeedout

6743

or FirstMatch

6744

6745

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

6746

6747

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

6748

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

6749

6750

dups_ranges[cur_range].outer_tables= emb_outer_tables &

6751

~range_start_map;

6752

end_of_range= true;

6753

}

6754

6755

if (end_of_range)

6756

{

6757

dups_ranges[cur_range].end_idx= i+1;

6758

emb_sj_map= emb_outer_tables= 0;

6759

emb_insideout_nest= NULL;

6760

dealing_with_jbuf= false;

6761

dups_ranges[++cur_range].strategy= 0;

6762

}

6763

}

6764

}

6765

6766

Session *session= join->session;

6767

SJ_TMP_TABLE **next_sjtbl_ptr= &join->sj_tmp_tables;

6768

6769

Second pass: setup the chosen strategies

6770

6771

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

6772

{

6773

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

6774

JOIN_TAB *jump_to;

6775

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

6776

{

6777

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

6778

jump_to= tab++;

6779

}

6780

else // DuplicateWeedout strategy

6781

{

6782

SJ_TMP_TABLE::TAB sjtabs[MAX_TABLES];

6783

table_map weed_cur_map= join->const_table_map | PSEUDO_TABLE_BITS;

6784

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

6785

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

6786

SJ_TMP_TABLE::TAB *last_tab= sjtabs;

6787

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

6788

JOIN_TAB *last_outer_tab= tab - 1;

6789

6790

Walk through the range and remember

6791

- tables that need their rowids to be put into temptable

6792

- the last outer table

6793

6794

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

6795

{

6796

if (sj_table_is_included(join, tab))

6797

{

6798

last_tab->join_tab= tab;

6799

last_tab->rowid_offset= jt_rowid_offset;

6800

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

6801

if (tab->table->maybe_null)

6802

{

6803

last_tab->null_byte= jt_null_bits / 8;

6804

last_tab->null_bit= jt_null_bits++;

6805

}

6806

last_tab++;

6807

tab->table->prepare_for_position();

6808

tab->rowid_keep_flags= rowid_keep_flags;

6809

}

6810

weed_cur_map |= tab->table->map;

6811

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

6812

dups_ranges[j].outer_tables))

6813

last_outer_tab= tab;

6814

}

6815

6816

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

6817

{

6818

SJ_TMP_TABLE *sjtbl;

6819

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

6820

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

6821

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

6822

return(true);

6823

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

6824

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

6825

sjtbl->rowid_len= jt_rowid_offset;

6826

sjtbl->null_bits= jt_null_bits;

6827

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

6828

6829

*next_sjtbl_ptr= sjtbl;

6830

next_sjtbl_ptr= &(sjtbl->next);

6831

sjtbl->next= NULL;

6832

6833

sjtbl->tmp_table=

6834

create_duplicate_weedout_tmp_table(session,

6835

sjtbl->rowid_len +

6836

sjtbl->null_bytes,

6837

sjtbl);

6838

6839

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

6840

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

6841

}

6842

tab= last_outer_tab + 1;

6843

jump_to= last_outer_tab;

6844

}

6845

6846

/* Create the FirstMatch tail */

6847

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

6848

{

6849

if (tab->emb_sj_nest)

6850

tab->do_firstmatch= jump_to;

6851

else

6852

jump_to= tab;

6853

}

6854

}

6855

return(false);

6856

}

6857

6858

static void cleanup_sj_tmp_tables(JOIN *join)

6859

{

6860

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

6861

sj_tbl= sj_tbl->next)

6862

{

6863

if (sj_tbl->tmp_table)

6864

{

6865

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

6866

}

6867

}

6868

join->sj_tmp_tables= NULL;

6095

6869

}

6096

6870

6097

6871

/**

6098

6872

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

6099

6873

currenct select for the table.

6100

6874

6101

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

6875

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

6102

6876

{

6103

6877

if (!join_tab->ref.key_parts)

6104

6878

return(false);

6111

6885

6112

6886

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

6113

6887

{

6114

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

6888

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

6889

fieldnr-1];

6115

6890

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

6116

6891

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

6117

6892

}

6125

6900

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

6126

6901

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

6127

6902

}

6128

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

6129

&error)))

6903

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

6904

&error)))

6130

6905

join_tab->select_cond=cond;

6131

6906

6132

6907

return(error ? true : false);

6133

6908

}

6134

6909

6910

/**

6911

@brief Replaces an expression destructively inside the expression tree of

6912

the WHERE clase.

6913

6914

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

6915

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

6916

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

6917

'if (do_materialize)'

6918

6919

@param join The top-level query.

6920

@param old_cond The expression to be replaced.

6921

@param new_cond The expression to be substituted.

6922

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

6923

the new expression.

6924

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

6925

successful.

6926

6927

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

6928

Item *new_cond, bool do_fix_fields)

6929

{

6930

if (join->conds == old_cond) {

6931

join->conds= new_cond;

6932

if (do_fix_fields)

6933

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

6934

return false;

6935

}

6936

6937

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

6938

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

6939

Item *item;

6940

while ((item= li++))

6941

if (item == old_cond)

6942

{

6943

li.replace(new_cond);

6944

if (do_fix_fields)

6945

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

6946

return false;

6947

}

6948

}

6949

6950

return true;

6951

}

6952

6953

6954

Pull tables out of semi-join nests, if possible

6955

6956

SYNOPSIS

6957

pull_out_semijoin_tables()

6958

join The join where to do the semi-join flattening

6959

6960

DESCRIPTION

6961

Try to pull tables out of semi-join nests.

6962

6963

PRECONDITIONS

6964

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

6965

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

6966

one semi-join nest does not contain another.

6967

6968

ACTION

6969

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

6970

- It is a constant table

6971

- It is accessed

6972

6973

POSTCONDITIONS

6974

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

6975

tables)

6976

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

6977

* Semi-join nests TableList::sj_inner_tables

6978

6979

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

6980

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

6981

6982

RETURN

6983

0 - OK

6984

1 - Out of memory error

6985

6986

static int pull_out_semijoin_tables(JOIN *join)

6987

{

6988

TableList *sj_nest;

6989

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

6990

6991

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

6992

while ((sj_nest= sj_list_it++))

6993

{

6994

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

6995

table_map pulled_tables= 0;

6996

6997

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

6998

TableList *tbl;

6999

while ((tbl= child_li++))

7000

{

7001

if (tbl->table)

7002

{

7003

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

7004

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

7005

{

7006

pulled_tables |= tbl->table->map;

7007

}

7008

}

7009

}

7010

7011

7012

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

7013

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

7014

us to pull out some other tables too.

7015

7016

bool pulled_a_table;

7017

7018

{

7019

pulled_a_table= false;

7020

child_li.rewind();

7021

while ((tbl= child_li++))

7022

{

7023

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

7024

{

7025

if (find_eq_ref_candidate(tbl->table,

7026

sj_nest->nested_join->used_tables &

7027

~pulled_tables))

7028

{

7029

pulled_a_table= true;

7030

pulled_tables |= tbl->table->map;

7031

}

7032

}

7033

}

7034

} while (pulled_a_table);

7035

7036

child_li.rewind();

7037

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

7038

{

7039

(sj_nest)->sj_inner_tables= 0;

7040

while ((tbl= child_li++))

7041

{

7042

if (tbl->table)

7043

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

7044

}

7045

}

7046

else

7047

{

7048

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

7049

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

7050

~pulled_tables;

7051

(sj_nest)->sj_inner_tables= inner_tables;

7052

while ((tbl= child_li++))

7053

{

7054

if (tbl->table)

7055

{

7056

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

7057

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

7058

else

7059

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

7060

}

7061

}

7062

}

7063

}

7064

return(0);

7065

}

7066

7067

7068

SemiJoinDuplicateElimination: Weed out duplicate row combinations

7069

7070

SYNPOSIS

7071

do_sj_dups_weedout()

7072

7073

RETURN

7074

-1 Error

7075

1 The row combination is a duplicate (discard it)

7076

0 The row combination is not a duplicate (continue)

7077

7078

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

7079

{

7080

int error;

7081

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

7082

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

7083

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

7084

unsigned char *nulls_ptr= ptr;

7085

7086

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

7087

7088

// 1. Store the length

7089

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

7090

{

7091

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

7092

ptr++;

7093

}

7094

else

7095

{

7096

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

7097

ptr += 2;

7098

}

7099

7100

// 2. Zero the null bytes

7101

if (sjtbl->null_bytes)

7102

{

7103

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

7104

ptr += sjtbl->null_bytes;

7105

}

7106

7107

// 3. Put the rowids

7108

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

7109

{

7110

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

7111

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

7112

{

7113

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

7114

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

7115

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

7116

}

7117

else

7118

{

7119

/* Copy the rowid value */

7120

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

7121

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

7122

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

7123

}

7124

}

7125

7126

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

7127

if (error)

7128

{

7129

/* create_myisam_from_heap will generate error if needed */

7130

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

7131

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

7132

&sjtbl->recinfo, error, 1))

7133

return -1;

7134

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

7135

return 1;

7136

}

7137

return 0;

7138

}

7139

6135

7140

static void free_blobs(Field **ptr)

6136

7141

{

6137

7142

for (; *ptr ; ptr++)

6141

7146

}

6142

7147

}

6143

7148

7149

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

7150

{

7151

return !test(y & ~x);

7152

}

7153

7154

7155

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

7156

7157

SYNOPSIS

7158

sj_table_is_included()

7159

join The join

7160

join_tab The table to be checked

7161

7162

DESCRIPTION

7163

SemiJoinDuplicateElimination: check the table's rowid should be included

7164

in the temptable. This is so if

7165

7166

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

7167

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

7168

7169

3. The table is functionally dependent on some previous table

7170

7171

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

7172

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

7173

7174

RETURN

7175

true - Include table's rowid

7176

false - Don't

7177

7178

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

7179

{

7180

if (join_tab->emb_sj_nest)

7181

return false;

7182

7183

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

7184

are within the same outer join nest

7185

7186

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

7187

if (join_tab->type == JT_EQ_REF)

7188

{

7189

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

7190

uint32_t idx;

7191

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

7192

{

7193

JOIN_TAB *ref_tab= join->join_tab + idx;

7194

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

7195

return true;

7196

}

7197

/* Ok, functionally dependent */

7198

return false;

7199

}

7200

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

7201

return true;

7202

}

7203

6144

7204

/**

6145

7205

@} (end of group Query_Optimizer)

6146

7206

6147

6148

} /* namespace drizzled */

Older »