~drizzle-trunk/drizzle/development : revision 1641

4454

JoinTable *tab=join->join_tab+i;

4455

Table *table=tab->table;

4456

TableList *tbl= table->pos_in_table_list;

4457

TableList *embedding= tbl->embedding;

4457

TableList *embedding= tbl->getEmbedding();

4458

4459

if (tbl->outer_join)

4460

{

4467

tab->on_expr_ref= &tbl->on_expr;

4468

tab->cond_equal= tbl->cond_equal;

4469

if (embedding)

4470

tab->first_upper= embedding->nested_join->first_nested;

4470

tab->first_upper= embedding->getNestedJoin()->first_nested;

4471

}

4472

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

4472

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

4473

{

4474

/* Ignore sj-nests: */

4475

if (!embedding->on_expr)

4476

continue;

4477

nested_join_st *nested_join= embedding->nested_join;

4477

nested_join_st *nested_join= embedding->getNestedJoin();

4478

if (!nested_join->counter_)

4479

{

4480

/*

4484

nested_join->first_nested= tab;

4485

tab->on_expr_ref= &embedding->on_expr;

4486

tab->cond_equal= tbl->cond_equal;

4487

if (embedding->embedding)

4488

tab->first_upper= embedding->embedding->nested_join->first_nested;

4487

if (embedding->getEmbedding())

4488

tab->first_upper= embedding->getEmbedding()->getNestedJoin()->first_nested;

4489

}

4490

if (!tab->first_inner)

4491

tab->first_inner= nested_join->first_nested;

5227

table_map used_tables;

5228

table_map not_null_tables= (table_map) 0;

5229

5230

if ((nested_join= table->nested_join))

5230

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

5231

{

5232

/*

5233

If the element of join_list is a nested join apply

5269

not_null_tables= conds->not_null_tables();

5270

}

5271

5272

if (table->embedding)

5272

if (table->getEmbedding())

5273

{

5274

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

5275

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

5274

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

5275

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

5276

}

5277

5278

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

5308

*/

5309

if (table->on_expr)

5310

{

5311

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

5312

if (table->embedding)

5311

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

5312

if (table->getEmbedding())

5313

{

5314

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

5314

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

5315

/*

5316

Embedding table depends on tables used

5317

in embedded on expressions.

5318

*/

5319

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

5319

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

5320

}

5321

else

5322

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

5322

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

5323

}

5324

5325

if (prev_table)

5326

{

5327

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

5328

if (prev_table->straight)

5329

prev_table->dep_tables|= used_tables;

5329

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

5330

if (prev_table->on_expr)

5331

{

5332

prev_table->dep_tables|= table->on_expr_dep_tables;

5333

table_map prev_used_tables= prev_table->nested_join ?

5334

prev_table->nested_join->used_tables :

5332

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

5333

table_map prev_used_tables= prev_table->getNestedJoin() ?

5334

prev_table->getNestedJoin()->used_tables :

5335

prev_table->table->map;

5336

/*

5337

If on expression contains only references to inner tables

5340

for them. Yet this is really a rare case.

5341

*/

5342

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

5343

prev_table->dep_tables|= used_tables;

5343

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

5344

}

5345

}

5346

prev_table= table;

5353

li.rewind();

5354

while ((table= li++))

5355

{

5356

nested_join= table->nested_join;

5356

nested_join= table->getNestedJoin();

5357

if (nested_join && !table->on_expr)

5358

{

5359

TableList *tbl;

5360

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

5361

while ((tbl= it++))

5362

{

5363

tbl->embedding= table->embedding;

5364

tbl->join_list= table->join_list;

5363

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

5364

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

5365

}

5366

li.replace(nested_join->join_list);

5367

}

5500

tables;

5501

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

5502

{

5503

TableList *embedding= tables->embedding;

5503

TableList *embedding= tables->getEmbedding();

5504

stat_vector[i]=s;

5505

s->keys.reset();

5506

s->const_keys.reset();

5523

s->join=join;

5524

s->info=0; // For describe

5525

5526

s->dependent= tables->dep_tables;

5526

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

5527

s->key_dependent= 0;

5528

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

5529

5539

}

5540

outer_join|= table->map;

5541

s->embedding_map.reset();

5542

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

5543

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

5542

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

5543

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

5544

continue;

5545

}

5546

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

5546

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

5547

{

5548

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

5549

s->embedding_map.reset();

5550

do

5551

{

5552

nested_join_st *nested_join= embedding->nested_join;

5552

nested_join_st *nested_join= embedding->getNestedJoin();

5553

s->embedding_map|= nested_join->nj_map;

5554

s->dependent|= embedding->dep_tables;

5555

embedding= embedding->embedding;

5554

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

5555

embedding= embedding->getEmbedding();

5556

outer_join|= nested_join->used_tables;

5557

}

5558

while (embedding);

5686

continue;

5687

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

5688

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

5689

!table->pos_in_table_list->embedding)

5689

!table->pos_in_table_list->getEmbedding())

5690

{ // system table

5691

int tmp= 0;

5692

s->type= AM_SYSTEM;

5731

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

5732

5733

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

5734

! table->pos_in_table_list->embedding)

5734

! table->pos_in_table_list->getEmbedding())

5735

{

5736

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

5737

{

5818

add_group_and_distinct_keys(join, s);

5819

5820

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

5821

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

5821

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

5822

{

5823

ha_rows records;

5824

optimizer::SqlSelect *select= NULL;

5909

while ((table= li++))

5910

{

5911

nested_join_st *nested_join;

5912

if ((nested_join= table->nested_join))

5912

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

5913

{

5914

/*

5915

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

5980

while ((table= li++))

5981

{

5982

nested_join_st *nested_join;

5983

if ((nested_join= table->nested_join))

5983

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

5984

{

5985

nested_join->counter_= 0;

5986

reset_nj_counters(&nested_join->join_list);

6020

*/

6021

static void restore_prev_nj_state(JoinTable *last)

6022

{

6023

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

6023

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

6024

Join *join= last->join;

6025

while (last_emb)

6026

{

6027

if (last_emb->on_expr)

6028

{

6029

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

6030

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

6031

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

6032

last_emb->nested_join->counter_)

6033

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

6029

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

6030

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

6031

else if (last_emb->getNestedJoin()->join_list.elements-1 ==

6032

last_emb->getNestedJoin()->counter_)

6033

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

6034

else

6035

break;

6036

}

6037

last_emb= last_emb->embedding;

6037

last_emb= last_emb->getEmbedding();

6038

}

6039

}

6040