← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
455
455
  {
456
456
    if (table->on_expr)
457
457
      table->on_expr->fix_after_pullout(new_parent, &table->on_expr);
458
 
    if (table->nested_join)
459
 
      fix_list_after_tbl_changes(new_parent, &table->nested_join->join_list);
 
458
    if (table->getNestedJoin())
 
459
      fix_list_after_tbl_changes(new_parent, &table->getNestedJoin()->join_list);
460
460
  }
461
461
}
462
462
 
555
555
                         Select_Lex *select_lex,
556
556
                         vector<optimizer::SargableParam> &sargables)
557
557
{
558
 
  uint  and_level,i,found_eq_constant;
 
558
  uint  and_level,found_eq_constant;
559
559
  optimizer::KeyField *key_fields, *end, *field;
560
560
  uint32_t sz;
561
561
  uint32_t m= max(select_lex->max_equal_elems,(uint32_t)1);
578
578
    substitutions.
579
579
  */
580
580
  sz= sizeof(optimizer::KeyField) *
581
 
      (((session->lex->current_select->cond_count+1) +
 
581
      (((session->lex->current_select->cond_count+1)*2 +
582
582
        session->lex->current_select->between_count)*m+1);
583
583
  if (! (key_fields= (optimizer::KeyField*) session->alloc(sz)))
584
584
    return true;
602
602
      }
603
603
    }
604
604
  }
605
 
  for (i= 0; i < tables; i++)
 
605
  for (uint32_t i= 0; i < tables; i++)
606
606
  {
607
607
    /*
608
608
      Block the creation of keys for inner tables of outer joins.
625
625
    TableList *table;
626
626
    while ((table= li++))
627
627
    {
628
 
      if (table->nested_join)
 
628
      if (table->getNestedJoin())
629
629
        add_key_fields_for_nj(join_tab->join, table, &end, &and_level,
630
630
                              sargables);
631
631
    }
657
657
    use= save_pos= dynamic_element(keyuse, 0, optimizer::KeyUse*);
658
658
    prev= &key_end;
659
659
    found_eq_constant= 0;
660
 
    for (i= 0; i < keyuse->elements-1; i++, use++)
661
660
    {
662
 
      if (! use->getUsedTables() && use->getOptimizeFlags() != KEY_OPTIMIZE_REF_OR_NULL)
663
 
        use->getTable()->const_key_parts[use->getKey()]|= use->getKeypartMap();
664
 
      if (use->getKey() == prev->getKey() && use->getTable() == prev->getTable())
 
661
      uint32_t i;
 
662
 
 
663
      for (i= 0; i < keyuse->elements-1; i++, use++)
665
664
      {
666
 
        if (prev->getKeypart() + 1 < use->getKeypart() || 
667
 
            ((prev->getKeypart() == use->getKeypart()) && found_eq_constant))
668
 
          continue;                             /* remove */
669
 
      }
670
 
      else if (use->getKeypart() != 0)          // First found must be 0
671
 
        continue;
 
665
        if (! use->getUsedTables() && use->getOptimizeFlags() != KEY_OPTIMIZE_REF_OR_NULL)
 
666
          use->getTable()->const_key_parts[use->getKey()]|= use->getKeypartMap();
 
667
        if (use->getKey() == prev->getKey() && use->getTable() == prev->getTable())
 
668
        {
 
669
          if (prev->getKeypart() + 1 < use->getKeypart() || 
 
670
              ((prev->getKeypart() == use->getKeypart()) && found_eq_constant))
 
671
            continue;                           /* remove */
 
672
        }
 
673
        else if (use->getKeypart() != 0)                // First found must be 0
 
674
          continue;
672
675
 
673
676
#ifdef HAVE_purify
674
 
      /* Valgrind complains about overlapped memcpy when save_pos==use. */
675
 
      if (save_pos != use)
 
677
        /* Valgrind complains about overlapped memcpy when save_pos==use. */
 
678
        if (save_pos != use)
676
679
#endif
677
 
        *save_pos= *use;
678
 
      prev=use;
679
 
      found_eq_constant= ! use->getUsedTables();
680
 
      /* Save ptr to first use */
681
 
      if (! use->getTable()->reginfo.join_tab->keyuse)
682
 
        use->getTable()->reginfo.join_tab->keyuse= save_pos;
683
 
      use->getTable()->reginfo.join_tab->checked_keys.set(use->getKey());
684
 
      save_pos++;
 
680
          *save_pos= *use;
 
681
        prev=use;
 
682
        found_eq_constant= ! use->getUsedTables();
 
683
        /* Save ptr to first use */
 
684
        if (! use->getTable()->reginfo.join_tab->keyuse)
 
685
          use->getTable()->reginfo.join_tab->keyuse= save_pos;
 
686
        use->getTable()->reginfo.join_tab->checked_keys.set(use->getKey());
 
687
        save_pos++;
 
688
      }
 
689
      i= (uint32_t) (save_pos - (optimizer::KeyUse*) keyuse->buffer);
 
690
      set_dynamic(keyuse, (unsigned char*) &key_end, i);
 
691
      keyuse->elements= i;
685
692
    }
686
 
    i= (uint32_t) (save_pos - (optimizer::KeyUse*) keyuse->buffer);
687
 
    set_dynamic(keyuse, (unsigned char*) &key_end, i);
688
 
    keyuse->elements= i;
689
693
  }
690
694
  return false;
691
695
}
2266
2270
    {
2267
2271
      if (table->on_expr)
2268
2272
      {
2269
 
        List<TableList> *nested_join_list= table->nested_join ?
2270
 
          &table->nested_join->join_list : NULL;
 
2273
        List<TableList> *nested_join_list= table->getNestedJoin() ?
 
2274
          &table->getNestedJoin()->join_list : NULL;
2271
2275
        /*
2272
2276
          We can modify table->on_expr because its old value will
2273
2277
          be restored before re-execution of PS/SP.
2858
2862
*/
2859
2863
bool check_interleaving_with_nj(JoinTable *last_tab, JoinTable *next_tab)
2860
2864
{
2861
 
  TableList *next_emb= next_tab->table->pos_in_table_list->embedding;
 
2865
  TableList *next_emb= next_tab->table->pos_in_table_list->getEmbedding();
2862
2866
  Join *join= last_tab->join;
2863
2867
 
2864
2868
  if ((join->cur_embedding_map & ~next_tab->embedding_map).any())
2874
2878
    Do update counters for "pairs of brackets" that we've left (marked as
2875
2879
    X,Y,Z in the above picture)
2876
2880
  */
2877
 
  for (;next_emb; next_emb= next_emb->embedding)
 
2881
  for (;next_emb; next_emb= next_emb->getEmbedding())
2878
2882
  {
2879
 
    next_emb->nested_join->counter_++;
2880
 
    if (next_emb->nested_join->counter_ == 1)
 
2883
    next_emb->getNestedJoin()->counter_++;
 
2884
    if (next_emb->getNestedJoin()->counter_ == 1)
2881
2885
    {
2882
2886
      /*
2883
2887
        next_emb is the first table inside a nested join we've "entered". In
2884
2888
        the picture above, we're looking at the 'X' bracket. Don't exit yet as
2885
2889
        X bracket might have Y pair bracket.
2886
2890
      */
2887
 
      join->cur_embedding_map |= next_emb->nested_join->nj_map;
 
2891
      join->cur_embedding_map |= next_emb->getNestedJoin()->nj_map;
2888
2892
    }
2889
2893
 
2890
 
    if (next_emb->nested_join->join_list.elements !=
2891
 
        next_emb->nested_join->counter_)
 
2894
    if (next_emb->getNestedJoin()->join_list.elements !=
 
2895
        next_emb->getNestedJoin()->counter_)
2892
2896
      break;
2893
2897
 
2894
2898
    /*
2895
2899
      We're currently at Y or Z-bracket as depicted in the above picture.
2896
2900
      Mark that we've left it and continue walking up the brackets hierarchy.
2897
2901
    */
2898
 
    join->cur_embedding_map &= ~next_emb->nested_join->nj_map;
 
2902
    join->cur_embedding_map &= ~next_emb->getNestedJoin()->nj_map;
2899
2903
  }
2900
2904
  return false;
2901
2905
}
3664
3668
      embedded= embedding;
3665
3669
      if (embedded->on_expr)
3666
3670
         update_const_equal_items(embedded->on_expr, tab);
3667
 
      embedding= embedded->embedding;
 
3671
      embedding= embedded->getEmbedding();
3668
3672
    }
3669
3673
    while (embedding &&
3670
 
           embedding->nested_join->join_list.head() == embedded);
 
3674
           embedding->getNestedJoin()->join_list.head() == embedded);
3671
3675
  }
3672
3676
 
3673
3677
  return(0);