← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/position.h

  • Committer: Padraig O'Sullivan
  • Date: 2009-08-10 23:48:05 UTC
  • mto: (1115.3.10 captain)
  • mto: This revision was merged to the branch mainline in revision 1120.
  • Revision ID: osullivan.padraig@gmail.com-20090810234805-v6krkh1lh50c5xi5
Forgot to add the new sub-dir I created for my last commit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/position.h
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2009 Sun Microsystems
 
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; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#ifndef DRIZZLED_OPTIMIZER_POSITION_H
 
21
#define DRIZZLED_OPTIMIZER_POSITION_H
 
22
 
 
23
#include <drizzled/join_table.h>
 
24
 
 
25
namespace drizzled
 
26
{
 
27
namespace optimizer
 
28
{
 
29
 
 
30
/**
 
31
 * Information about a position of table within a join order. Used in join
 
32
 * optimization.
 
33
 */
 
34
class Position
 
35
{
 
36
public:
 
37
 
 
38
  Position()
 
39
    :
 
40
      records_read(0),
 
41
      read_time(0),
 
42
      table(NULL),
 
43
      key(NULL),
 
44
      ref_depend_map(0)
 
45
  {}
 
46
 
 
47
  Position(double in_records_read,
 
48
           double in_read_time,
 
49
           JoinTable *in_table,
 
50
           KeyUse *in_key,
 
51
           table_map in_ref_depend_map)
 
52
    :
 
53
      records_read(in_records_read),
 
54
      read_time(in_read_time),
 
55
      table(in_table),
 
56
      key(in_key),
 
57
      ref_depend_map(in_ref_depend_map)
 
58
  {}
 
59
 
 
60
  /**
 
61
   * Determine whether the table this particular position is representing in
 
62
   * the query plan is a const table or not. A constant table is defined as
 
63
   * (taken from the MySQL optimizer internals document on MySQL forge):
 
64
   *
 
65
   * 1) A table with zero rows, or with only one row
 
66
   * 2) A table expression that is restricted with a WHERE condition
 
67
   *
 
68
   * Based on the definition above, when records_read is set to 1.0 in the
 
69
   * Position class, it infers that this position in the partial plan
 
70
   * represents a const table.
 
71
   *
 
72
   * @return true if this position represents a const table; false otherwise
 
73
   */
 
74
  bool isConstTable() const
 
75
  {
 
76
    return (records_read < 2.0);
 
77
  }
 
78
 
 
79
  double getFanout() const
 
80
  {
 
81
    return records_read;
 
82
  }
 
83
 
 
84
  void setFanout(double in_records_read)
 
85
  {
 
86
    records_read= in_records_read;
 
87
  }
 
88
 
 
89
  double getCost() const
 
90
  {
 
91
    return read_time;
 
92
  }
 
93
 
 
94
  JoinTable *getJoinTable()
 
95
  {
 
96
    return table;
 
97
  }
 
98
 
 
99
  /**
 
100
   * Check to see if the table attached to the JoinTable for this position
 
101
   * has an index that can produce an ordering. 
 
102
   *
 
103
   * @return true if the table attached to the JoinTable for this position
 
104
   * does not have an index that can produce an ordering; false otherwise
 
105
   */
 
106
  bool hasTableForSorting(Table *cmp_table) const
 
107
  {
 
108
    return (cmp_table != table->table);
 
109
  }
 
110
 
 
111
  bool examinePosition(table_map found_ref)
 
112
  {
 
113
    if (table->table->map & found_ref)
 
114
    {
 
115
      return true;
 
116
    }
 
117
    return false;
 
118
  }
 
119
 
 
120
  KeyUse *getKeyUse()
 
121
  {
 
122
    return key;
 
123
  }
 
124
 
 
125
  table_map getRefDependMap()
 
126
  {
 
127
    return ref_depend_map;
 
128
  }
 
129
 
 
130
  void clearRefDependMap()
 
131
  {
 
132
    ref_depend_map= 0;
 
133
  }
 
134
 
 
135
private:
 
136
 
 
137
  /**
 
138
    The "fanout": number of output rows that will be produced (after
 
139
    pushed down selection condition is applied) per each row combination of
 
140
    previous tables. The value is an in-precise estimate.
 
141
  */
 
142
  double records_read;
 
143
 
 
144
  /**
 
145
    Cost accessing the table in course of the entire complete join execution,
 
146
    i.e. cost of one access method use (e.g. 'range' or 'ref' scan ) times
 
147
    number the access method will be invoked.
 
148
  */
 
149
  double read_time;
 
150
 
 
151
  JoinTable *table;
 
152
 
 
153
  /**
 
154
    NULL  -  'index' or 'range' or 'index_merge' or 'ALL' access is used.
 
155
    Other - [eq_]ref[_or_null] access is used. Pointer to {t.keypart1 = expr}
 
156
  */
 
157
  KeyUse *key;
 
158
 
 
159
  /** If ref-based access is used: bitmap of tables this table depends on  */
 
160
  table_map ref_depend_map;
 
161
 
 
162
};
 
163
 
 
164
} /* end namespace optimizer */
 
165
 
 
166
} /* end namespace drizzled */
 
167
 
 
168
#endif /* DRIZZLED_OPTIMIZER_POSITION_H */