← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-09-18 00:22:38 UTC
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: osullivan.padraig@gmail.com-20090918002238-zq7mui4r2yzoidz1
Extracted KeyUse into its own header file and placed it within the
drizzled::optimizer namespace.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
46
46
#include "drizzled/item/outer_ref.h"
47
47
#include "drizzled/index_hint.h"
48
48
 
49
 
#include <drizzled/sql_union.h>
50
 
#include <drizzled/optimizer/key_field.h>
51
 
#include <drizzled/optimizer/position.h>
52
 
#include <drizzled/optimizer/sargable_param.h>
 
49
#include "drizzled/sql_union.h"
 
50
#include "drizzled/optimizer/key_field.h"
 
51
#include "drizzled/optimizer/position.h"
 
52
#include "drizzled/optimizer/sargable_param.h"
 
53
#include "drizzled/optimizer/key_use.h"
53
54
 
54
55
#include <string>
55
56
#include <iostream>
76
77
  "index_merge"
77
78
};
78
79
 
79
 
static int sort_keyuse(KeyUse *a,KeyUse *b);
 
80
static int sort_keyuse(optimizer::KeyUse *a, optimizer::KeyUse *b);
80
81
static COND *build_equal_items(Session *session, COND *cond,
81
82
                               COND_EQUAL *inherited,
82
83
                               List<TableList> *join_list,
513
514
  return found;
514
515
}
515
516
 
516
 
static int sort_keyuse(KeyUse *a,KeyUse *b)
 
517
static int sort_keyuse(optimizer::KeyUse *a, optimizer::KeyUse *b)
517
518
{
518
519
  int res;
519
520
  if (a->table->tablenr != b->table->tablenr)
592
593
  and_level= 0;
593
594
  field= end= key_fields;
594
595
 
595
 
  if (my_init_dynamic_array(keyuse,sizeof(KeyUse),20,64))
 
596
  if (my_init_dynamic_array(keyuse,sizeof(optimizer::KeyUse),20,64))
596
597
    return true;
597
598
  if (cond)
598
599
  {
653
654
  */
654
655
  if (keyuse->elements)
655
656
  {
656
 
    KeyUse key_end,*prev,*save_pos,*use;
 
657
    optimizer::KeyUse key_end,*prev,*save_pos,*use;
657
658
 
658
 
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(KeyUse),
 
659
    my_qsort(keyuse->buffer,keyuse->elements,sizeof(optimizer::KeyUse),
659
660
          (qsort_cmp) sort_keyuse);
660
661
 
661
662
    memset(&key_end, 0, sizeof(key_end)); /* Add for easy testing */
662
663
    insert_dynamic(keyuse,(unsigned char*) &key_end);
663
664
 
664
 
    use=save_pos=dynamic_element(keyuse,0,KeyUse*);
 
665
    use=save_pos=dynamic_element(keyuse,0,optimizer::KeyUse*);
665
666
    prev= &key_end;
666
667
    found_eq_constant=0;
667
668
    for (i=0 ; i < keyuse->elements-1 ; i++,use++)
689
690
      use->table->reginfo.join_tab->checked_keys.set(use->key);
690
691
      save_pos++;
691
692
    }
692
 
    i=(uint32_t) (save_pos-(KeyUse*) keyuse->buffer);
 
693
    i=(uint32_t) (save_pos-(optimizer::KeyUse*) keyuse->buffer);
693
694
    set_dynamic(keyuse,(unsigned char*) &key_end,i);
694
695
    keyuse->elements=i;
695
696
  }
701
702
*/
702
703
void optimize_keyuse(JOIN *join, DYNAMIC_ARRAY *keyuse_array)
703
704
{
704
 
  KeyUse *end,*keyuse= dynamic_element(keyuse_array, 0, KeyUse*);
 
705
  optimizer::KeyUse *end,*keyuse= dynamic_element(keyuse_array, 
 
706
                                                  0, 
 
707
                                                  optimizer::KeyUse*);
705
708
 
706
709
  for (end= keyuse+ keyuse_array->elements ; keyuse < end ; keyuse++)
707
710
  {
886
889
}
887
890
 
888
891
StoredKey *get_store_key(Session *session,
889
 
                         KeyUse *keyuse,
 
892
                         optimizer::KeyUse *keyuse,
890
893
                         table_map used_tables,
891
894
                               KEY_PART_INFO *key_part,
892
895
                         unsigned char *key_buff,
962
965
    *e1= e2;
963
966
}
964
967
 
965
 
bool create_ref_for_key(JOIN *join, JoinTable *j, KeyUse *org_keyuse,
966
 
             table_map used_tables)
 
968
bool create_ref_for_key(JOIN *join, 
 
969
                        JoinTable *j, 
 
970
                        optimizer::KeyUse *org_keyuse,
 
971
                        table_map used_tables)
967
972
{
968
 
  KeyUse *keyuse=org_keyuse;
 
973
  optimizer::KeyUse *keyuse=org_keyuse;
969
974
  Session  *session= join->session;
970
975
  uint32_t keyparts,length,key;
971
976
  Table *table;
2579
2584
        if (possible_keys.any())
2580
2585
        {
2581
2586
          Table *field_tab= field->table;
2582
 
          KeyUse *use;
 
2587
          optimizer::KeyUse *use;
2583
2588
          for (use= stat->keyuse; use && use->table == field_tab; use++)
2584
2589
            if (possible_keys.test(use->key) &&
2585
2590
                field_tab->key_info[use->key].key_part[use->keypart].field ==
4860
4865
            "part1 = const1 AND part2=const2".
4861
4866
            So we build tab->ref from scratch here.
4862
4867
          */
4863
 
          KeyUse *keyuse= tab->keyuse;
 
4868
          optimizer::KeyUse *keyuse= tab->keyuse;
4864
4869
          while (keyuse->key != new_ref_key && keyuse->table == tab->table)
4865
4870
            keyuse++;
4866
4871