← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/key_field.cc

  • Committer: Jay Pipes
  • Date: 2010-03-09 20:02:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1339.
  • Revision ID: jpipes@serialcoder-20100309200229-dfrliy4fads9vyf4
https://launchpad.net/bugs/535296
Fixes Bug #535296 by only incrementing ha_commit_count when its a normal transaction commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/key_field.cc
1
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008-2009 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include <config.h>
22
 
 
 
21
#include "config.h"
23
22
#include <drizzled/sql_select.h>
24
23
#include <drizzled/nested_join.h>
25
24
#include <drizzled/item/cmpfunc.h>
26
 
#include <drizzled/table.h>
27
 
#include <drizzled/optimizer/key_field.h>
28
 
#include <drizzled/optimizer/key_use.h>
29
 
#include <drizzled/sql_lex.h>
 
25
#include "drizzled/optimizer/key_field.h"
 
26
#include "drizzled/optimizer/key_use.h"
30
27
 
31
28
#include <vector>
32
29
 
39
36
                             optimizer::KeyField *key_field)
40
37
{
41
38
  Field *field= key_field->getField();
42
 
  Table *form= field->getTable();
 
39
  Table *form= field->table;
43
40
 
44
41
  if (key_field->isEqualityCondition() &&
45
42
      ! (key_field->getOptimizeFlags() & KEY_OPTIMIZE_EXISTS))
54
51
      {
55
52
        if (field->eq(form->key_info[key].key_part[part].field))
56
53
        {
57
 
          optimizer::KeyUse keyuse(field->getTable(),
 
54
          optimizer::KeyUse keyuse(field->table,
58
55
                                   key_field->getValue(),
59
56
                                   key_field->getValue()->used_tables(),
60
57
                                   key,
71
68
  }
72
69
}
73
70
 
74
 
void optimizer::add_key_fields_for_nj(Join *join,
 
71
void optimizer::add_key_fields_for_nj(JOIN *join,
75
72
                                      TableList *nested_join_table,
76
73
                                      optimizer::KeyField **end,
77
74
                                      uint32_t *and_level,
78
75
                                      vector<optimizer::SargableParam> &sargables)
79
76
{
80
 
  List<TableList>::iterator li(nested_join_table->getNestedJoin()->join_list.begin());
81
 
  List<TableList>::iterator li2(nested_join_table->getNestedJoin()->join_list.begin());
 
77
  List_iterator<TableList> li(nested_join_table->nested_join->join_list);
 
78
  List_iterator<TableList> li2(nested_join_table->nested_join->join_list);
82
79
  bool have_another= false;
83
80
  table_map tables= 0;
84
81
  TableList *table;
85
 
  assert(nested_join_table->getNestedJoin());
 
82
  assert(nested_join_table->nested_join);
86
83
 
87
84
  while ((table= li++) || (have_another && (li=li2, have_another=false,
88
85
                                            (table= li++))))
89
86
  {
90
 
    if (table->getNestedJoin())
 
87
    if (table->nested_join)
91
88
    {
92
89
      if (! table->on_expr)
93
90
      {
94
91
        /* It's a semi-join nest. Walk into it as if it wasn't a nest */
95
92
        have_another= true;
96
93
        li2= li;
97
 
        li= List<TableList>::iterator(table->getNestedJoin()->join_list.begin());
 
94
        li= List_iterator<TableList>(table->nested_join->join_list);
98
95
      }
99
96
      else
100
97
        add_key_fields_for_nj(join, table, end, and_level, sargables);
247
244
  {
248
245
    // Don't remove column IS NULL on a LEFT JOIN table
249
246
    if (! eq_func || (*value)->type() != Item::NULL_ITEM ||
250
 
        ! field->getTable()->maybe_null || field->null_ptr)
 
247
        ! field->table->maybe_null || field->null_ptr)
251
248
      return;                                   // Not a key. Skip it
252
249
    exists_optimize= KEY_OPTIMIZE_EXISTS;
253
250
    assert(num_values == 1);
259
256
    for (uint32_t i= 0; i < num_values; i++)
260
257
    {
261
258
      used_tables|= (value[i])->used_tables();
262
 
      if (! ((value[i])->used_tables() & (field->getTable()->map | RAND_TABLE_BIT)))
 
259
      if (! ((value[i])->used_tables() & (field->table->map | RAND_TABLE_BIT)))
263
260
        optimizable= 1;
264
261
    }
265
262
    if (! optimizable)
266
263
      return;
267
 
    if (! (usable_tables & field->getTable()->map))
 
264
    if (! (usable_tables & field->table->map))
268
265
    {
269
266
      if (! eq_func || (*value)->type() != Item::NULL_ITEM ||
270
 
          ! field->getTable()->maybe_null || field->null_ptr)
 
267
          ! field->table->maybe_null || field->null_ptr)
271
268
        return;                                 // Can't use left join optimize
272
269
      exists_optimize= KEY_OPTIMIZE_EXISTS;
273
270
    }
274
271
    else
275
272
    {
276
 
      JoinTable *stat= field->getTable()->reginfo.join_tab;
 
273
      JoinTable *stat= field->table->reginfo.join_tab;
277
274
      key_map possible_keys= field->key_start;
278
 
      possible_keys&= field->getTable()->keys_in_use_for_query;
 
275
      possible_keys&= field->table->keys_in_use_for_query;
279
276
      stat[0].keys|= possible_keys;             // Add possible keys
280
277
 
281
278
      /*
416
413
  }
417
414
}
418
415
 
419
 
void optimizer::add_key_fields(Join *join,
 
416
void optimizer::add_key_fields(JOIN *join,
420
417
                               optimizer::KeyField **key_fields,
421
418
                               uint32_t *and_level,
422
419
                               COND *cond,
425
422
{
426
423
  if (cond->type() == Item_func::COND_ITEM)
427
424
  {
428
 
    List<Item>::iterator li(((Item_cond*) cond)->argument_list()->begin());
 
425
    List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
429
426
    optimizer::KeyField *org_key_fields= *key_fields;
430
427
 
431
428
    if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
626
623
                          sargables);
627
624
          }
628
625
        }
629
 
        it= *item_equal;
 
626
        it.rewind();
630
627
      }
631
628
    }
632
629
    break;