← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/key_field.cc

  • Committer: Brian Aker
  • Date: 2010-10-20 20:25:52 UTC
  • mto: (1864.2.1 merge)
  • mto: This revision was merged to the branch mainline in revision 1865.
  • Revision ID: brian@tangent.org-20101020202552-51y5sz5ledoxbp7t
Add support for --with-valgrind

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/key_field.cc
36
36
                             optimizer::KeyField *key_field)
37
37
{
38
38
  Field *field= key_field->getField();
39
 
  Table *form= field->table;
 
39
  Table *form= field->getTable();
40
40
 
41
41
  if (key_field->isEqualityCondition() &&
42
42
      ! (key_field->getOptimizeFlags() & KEY_OPTIMIZE_EXISTS))
51
51
      {
52
52
        if (field->eq(form->key_info[key].key_part[part].field))
53
53
        {
54
 
          optimizer::KeyUse keyuse(field->table,
 
54
          optimizer::KeyUse keyuse(field->getTable(),
55
55
                                   key_field->getValue(),
56
56
                                   key_field->getValue()->used_tables(),
57
57
                                   key,
68
68
  }
69
69
}
70
70
 
71
 
void optimizer::add_key_fields_for_nj(JOIN *join,
 
71
void optimizer::add_key_fields_for_nj(Join *join,
72
72
                                      TableList *nested_join_table,
73
73
                                      optimizer::KeyField **end,
74
74
                                      uint32_t *and_level,
75
75
                                      vector<optimizer::SargableParam> &sargables)
76
76
{
77
 
  List_iterator<TableList> li(nested_join_table->nested_join->join_list);
78
 
  List_iterator<TableList> li2(nested_join_table->nested_join->join_list);
 
77
  List_iterator<TableList> li(nested_join_table->getNestedJoin()->join_list);
 
78
  List_iterator<TableList> li2(nested_join_table->getNestedJoin()->join_list);
79
79
  bool have_another= false;
80
80
  table_map tables= 0;
81
81
  TableList *table;
82
 
  assert(nested_join_table->nested_join);
 
82
  assert(nested_join_table->getNestedJoin());
83
83
 
84
84
  while ((table= li++) || (have_another && (li=li2, have_another=false,
85
85
                                            (table= li++))))
86
86
  {
87
 
    if (table->nested_join)
 
87
    if (table->getNestedJoin())
88
88
    {
89
89
      if (! table->on_expr)
90
90
      {
91
91
        /* It's a semi-join nest. Walk into it as if it wasn't a nest */
92
92
        have_another= true;
93
93
        li2= li;
94
 
        li= List_iterator<TableList>(table->nested_join->join_list);
 
94
        li= List_iterator<TableList>(table->getNestedJoin()->join_list);
95
95
      }
96
96
      else
97
97
        add_key_fields_for_nj(join, table, end, and_level, sargables);
244
244
  {
245
245
    // Don't remove column IS NULL on a LEFT JOIN table
246
246
    if (! eq_func || (*value)->type() != Item::NULL_ITEM ||
247
 
        ! field->table->maybe_null || field->null_ptr)
 
247
        ! field->getTable()->maybe_null || field->null_ptr)
248
248
      return;                                   // Not a key. Skip it
249
249
    exists_optimize= KEY_OPTIMIZE_EXISTS;
250
250
    assert(num_values == 1);
256
256
    for (uint32_t i= 0; i < num_values; i++)
257
257
    {
258
258
      used_tables|= (value[i])->used_tables();
259
 
      if (! ((value[i])->used_tables() & (field->table->map | RAND_TABLE_BIT)))
 
259
      if (! ((value[i])->used_tables() & (field->getTable()->map | RAND_TABLE_BIT)))
260
260
        optimizable= 1;
261
261
    }
262
262
    if (! optimizable)
263
263
      return;
264
 
    if (! (usable_tables & field->table->map))
 
264
    if (! (usable_tables & field->getTable()->map))
265
265
    {
266
266
      if (! eq_func || (*value)->type() != Item::NULL_ITEM ||
267
 
          ! field->table->maybe_null || field->null_ptr)
 
267
          ! field->getTable()->maybe_null || field->null_ptr)
268
268
        return;                                 // Can't use left join optimize
269
269
      exists_optimize= KEY_OPTIMIZE_EXISTS;
270
270
    }
271
271
    else
272
272
    {
273
 
      JoinTable *stat= field->table->reginfo.join_tab;
 
273
      JoinTable *stat= field->getTable()->reginfo.join_tab;
274
274
      key_map possible_keys= field->key_start;
275
 
      possible_keys&= field->table->keys_in_use_for_query;
 
275
      possible_keys&= field->getTable()->keys_in_use_for_query;
276
276
      stat[0].keys|= possible_keys;             // Add possible keys
277
277
 
278
278
      /*
413
413
  }
414
414
}
415
415
 
416
 
void optimizer::add_key_fields(JOIN *join,
 
416
void optimizer::add_key_fields(Join *join,
417
417
                               optimizer::KeyField **key_fields,
418
418
                               uint32_t *and_level,
419
419
                               COND *cond,