← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/access_method/scan.cc

  • Committer: Mark Atwood
  • Date: 2009-03-04 01:02:00 UTC
  • mto: (968.2.20 mordred)
  • mto: This revision was merged to the branch mainline in revision 971.
  • Revision ID: me@mark.atwood.name-20090304010200-t1n4xxdoil2yae9a
add gearman logging plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/access_method/scan.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2010 Padraig O'Sullivan
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#include <config.h>
22
 
#include <drizzled/session.h>
23
 
#include <drizzled/join_table.h>
24
 
#include <drizzled/table.h>
25
 
#include <drizzled/sql_select.h>
26
 
#include <drizzled/internal/my_sys.h>
27
 
#include <drizzled/optimizer/access_method/scan.h>
28
 
 
29
 
using namespace drizzled;
30
 
 
31
 
static uint32_t make_join_orderinfo(Join *join);
32
 
 
33
 
bool optimizer::Scan::getStats(Table *table,
34
 
                               JoinTable *join_tab)
35
 
{
36
 
  Join *join= join_tab->join;
37
 
  bool statistics= test(! (join->select_options & SELECT_DESCRIBE));
38
 
  uint64_t options= (join->select_options &
39
 
                     (SELECT_DESCRIBE | SELECT_NO_JOIN_CACHE)) |
40
 
                     (0);
41
 
  uint32_t no_jbuf_after= make_join_orderinfo(join);
42
 
  uint32_t index= join_tab - join->join_tab;
43
 
 
44
 
  /*
45
 
   * If previous table use cache
46
 
   * If the incoming data set is already sorted don't use cache.
47
 
   */
48
 
  table->status= STATUS_NO_RECORD;
49
 
 
50
 
  if (index != join->const_tables && 
51
 
      ! (options & SELECT_NO_JOIN_CACHE) &&
52
 
      join_tab->use_quick != 2 && 
53
 
      ! join_tab->first_inner && 
54
 
      index <= no_jbuf_after &&
55
 
      ! join_tab->insideout_match_tab)
56
 
  {
57
 
    if ((options & SELECT_DESCRIBE) ||
58
 
        ! join_init_cache(join->session,
59
 
                          join->join_tab + join->const_tables,
60
 
                          index - join->const_tables))
61
 
    {
62
 
      join_tab[-1].next_select= sub_select_cache; /* Patch previous */
63
 
    }
64
 
  }
65
 
 
66
 
  /* These init changes read_record */
67
 
  if (join_tab->use_quick == 2)
68
 
  {
69
 
    join->session->server_status|= SERVER_QUERY_NO_GOOD_INDEX_USED;
70
 
    join_tab->read_first_record= join_init_quick_read_record;
71
 
    if (statistics)
72
 
    {
73
 
      join->session->status_var.select_range_check_count++;
74
 
    }
75
 
  }
76
 
  else
77
 
  {
78
 
    join_tab->read_first_record= join_init_read_record;
79
 
    if (index == join->const_tables)
80
 
    {
81
 
      if (join_tab->select && join_tab->select->quick)
82
 
      {
83
 
        if (statistics)
84
 
        {
85
 
          join->session->status_var.select_range_count++;
86
 
        }
87
 
      }
88
 
      else
89
 
      {
90
 
        join->session->server_status|= SERVER_QUERY_NO_INDEX_USED;
91
 
        if (statistics)
92
 
        {
93
 
          join->session->status_var.select_scan_count++;
94
 
        }
95
 
      }
96
 
    }
97
 
    else
98
 
    {
99
 
      if (join_tab->select && join_tab->select->quick)
100
 
      {
101
 
        if (statistics)
102
 
        {
103
 
          join->session->status_var.select_full_range_join_count++;
104
 
        }
105
 
      }
106
 
      else
107
 
      {
108
 
        join->session->server_status|= SERVER_QUERY_NO_INDEX_USED;
109
 
        if (statistics)
110
 
        {
111
 
          join->session->status_var.select_full_join_count++;
112
 
        }
113
 
      }
114
 
    }
115
 
    if (! table->no_keyread)
116
 
    {
117
 
      if (join_tab->select && 
118
 
          join_tab->select->quick &&
119
 
          join_tab->select->quick->index != MAX_KEY && //not index_merge
120
 
          table->covering_keys.test(join_tab->select->quick->index))
121
 
      {
122
 
        table->key_read= 1;
123
 
        table->cursor->extra(HA_EXTRA_KEYREAD);
124
 
      }
125
 
      else if (! table->covering_keys.none() &&
126
 
               ! (join_tab->select && join_tab->select->quick))
127
 
      { // Only read index tree
128
 
        if (! join_tab->insideout_match_tab)
129
 
        {
130
 
          /*
131
 
             See bug #26447: "Using the clustered index for a table scan
132
 
             is always faster than using a secondary index".
133
 
           */
134
 
          if (table->getShare()->hasPrimaryKey() &&
135
 
              table->cursor->primary_key_is_clustered())
136
 
          {
137
 
            join_tab->index= table->getShare()->getPrimaryKey();
138
 
          }
139
 
          else
140
 
          {
141
 
            join_tab->index= table->find_shortest_key(&table->covering_keys);
142
 
          }
143
 
        }
144
 
        join_tab->read_first_record= join_read_first;
145
 
        join_tab->type= AM_NEXT; // Read with index_first / index_next
146
 
      }
147
 
    }
148
 
  }
149
 
 
150
 
  return false;
151
 
}
152
 
 
153
 
/**
154
 
  Determine if the set is already ordered for order_st BY, so it can
155
 
  disable join cache because it will change the ordering of the results.
156
 
  Code handles sort table that is at any location (not only first after
157
 
  the const tables) despite the fact that it's currently prohibited.
158
 
  We must disable join cache if the first non-const table alone is
159
 
  ordered. If there is a temp table the ordering is done as a last
160
 
  operation and doesn't prevent join cache usage.
161
 
*/
162
 
static uint32_t make_join_orderinfo(Join *join)
163
 
{
164
 
  uint32_t i= 0;
165
 
  if (join->need_tmp)
166
 
  {
167
 
    return join->tables;
168
 
  }
169
 
 
170
 
  for (i= join->const_tables ; i < join->tables ; i++)
171
 
  {
172
 
    JoinTable *tab= join->join_tab + i;
173
 
    Table *table= tab->table;
174
 
    if ((table == join->sort_by_table &&
175
 
        (! join->order || join->skip_sort_order)) ||
176
 
        (join->sort_by_table == (Table *) 1 &&  i != join->const_tables))
177
 
    {
178
 
      break;
179
 
    }
180
 
  }
181
 
  return i;
182
 
}