← Back to branch summary

~ubuntu-branches/ubuntu/saucy/drizzle/saucy-proposed

« back to all changes in this revision

Viewing changes to drizzled/optimizer/key_field.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-03-18 12:12:31 UTC
  • Revision ID: james.westby@ubuntu.com-20100318121231-k6g1xe6cshbwa0f8
Tags: upstream-2010.03.1347
Import upstream version 2010.03.1347

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/key_field.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_KEY_FIELD_H
 
21
#define DRIZZLED_OPTIMIZER_KEY_FIELD_H
 
22
 
 
23
#include <drizzled/sql_select.h>
 
24
 
 
25
#include <vector>
 
26
 
 
27
namespace drizzled
 
28
{
 
29
namespace optimizer
 
30
{
 
31
 
 
32
/**
 
33
 * Class used when finding key fields
 
34
 */
 
35
class KeyField
 
36
{
 
37
public:
 
38
 
 
39
  KeyField()
 
40
    :
 
41
      field(NULL),
 
42
      val(NULL),
 
43
      level(0),
 
44
      optimize(0),
 
45
      eq_func(false),
 
46
      null_rejecting(false),
 
47
      cond_guard(NULL)
 
48
  {}
 
49
 
 
50
  KeyField(Field *in_field,
 
51
           Item *in_val,
 
52
           uint32_t in_level,
 
53
           uint32_t in_optimize,
 
54
           bool in_eq_func,
 
55
           bool in_null_rejecting,
 
56
           bool *in_cond_guard)
 
57
    :
 
58
      field(in_field),
 
59
      val(in_val),
 
60
      level(in_level),
 
61
      optimize(in_optimize),
 
62
      eq_func(in_eq_func),
 
63
      null_rejecting(in_null_rejecting),
 
64
      cond_guard(in_cond_guard)
 
65
  {}
 
66
 
 
67
  Field *getField()
 
68
  {
 
69
    return field;
 
70
  }
 
71
 
 
72
  void setField(Field *in_field)
 
73
  {
 
74
    field= in_field;
 
75
  }
 
76
 
 
77
  Item *getValue()
 
78
  {
 
79
    return val;
 
80
  }
 
81
 
 
82
  void setValue(Item *in_val)
 
83
  {
 
84
    val= in_val;
 
85
  }
 
86
 
 
87
  uint32_t getLevel()
 
88
  {
 
89
    return level;
 
90
  }
 
91
 
 
92
  void setLevel(uint32_t in_level)
 
93
  {
 
94
    level= in_level;
 
95
  }
 
96
 
 
97
  uint32_t getOptimizeFlags()
 
98
  {
 
99
    return optimize;
 
100
  }
 
101
 
 
102
  void setOptimizeFlags(uint32_t in_opt)
 
103
  {
 
104
    optimize= in_opt;
 
105
  }
 
106
 
 
107
  bool isEqualityCondition() const
 
108
  {
 
109
    return eq_func;
 
110
  }
 
111
 
 
112
  void setEqualityConditionUsed(bool in_val)
 
113
  {
 
114
    eq_func= in_val;
 
115
  }
 
116
 
 
117
  bool rejectNullValues() const
 
118
  {
 
119
    return null_rejecting;
 
120
  }
 
121
 
 
122
  void setRejectNullValues(bool in_val)
 
123
  {
 
124
    null_rejecting= in_val;
 
125
  }
 
126
 
 
127
  bool *getConditionalGuard()
 
128
  {
 
129
    return cond_guard;
 
130
  }
 
131
 
 
132
  void setConditionalGuard(bool *in_cond_guard)
 
133
  {
 
134
    cond_guard= in_cond_guard;
 
135
  }
 
136
 
 
137
private:
 
138
 
 
139
  Field *field;
 
140
  Item *val; /**< May be empty if diff constant */
 
141
  uint32_t level;
 
142
  uint32_t optimize; /**< KEY_OPTIMIZE_* */
 
143
  bool eq_func;
 
144
  /**
 
145
    If true, the condition this class represents will not be satisfied
 
146
    when val IS NULL.
 
147
  */
 
148
  bool null_rejecting;
 
149
  bool *cond_guard; /**< @see KeyUse::cond_guard */
 
150
 
 
151
};
 
152
 
 
153
void add_key_fields(JOIN *join, 
 
154
                    KeyField **key_fields,
 
155
                    uint32_t *and_level,
 
156
                    COND *cond,
 
157
                    table_map usable_tables,
 
158
                    std::vector<SargableParam> &sargables);
 
159
 
 
160
void add_key_part(DYNAMIC_ARRAY *keyuse_array, KeyField *key_field);
 
161
 
 
162
/**
 
163
 * Add to KeyField array all 'ref' access candidates within nested join.
 
164
 *
 
165
 * This function populates KeyField array with entries generated from the
 
166
 * ON condition of the given nested join, and does the same for nested joins
 
167
 * contained within this nested join.
 
168
 *
 
169
 * @param[in]      nested_join_table   Nested join pseudo-table to process
 
170
 * @param[in,out]  end                 End of the key field array
 
171
 * @param[in,out]  and_level           And-level
 
172
 * @param[in,out]  sargables           std::vector of found sargable candidates
 
173
 *
 
174
 *
 
175
 * @note
 
176
 *   We can add accesses to the tables that are direct children of this nested
 
177
 *   join (1), and are not inner tables w.r.t their neighbours (2).
 
178
 *
 
179
 *   Example for #1 (outer brackets pair denotes nested join this function is
 
180
 *   invoked for):
 
181
 *   @code
 
182
 *    ... LEFT JOIN (t1 LEFT JOIN (t2 ... ) ) ON cond
 
183
 *   @endcode
 
184
 *   Example for #2:
 
185
 *   @code
 
186
 *    ... LEFT JOIN (t1 LEFT JOIN t2 ) ON cond
 
187
 *   @endcode
 
188
 *   In examples 1-2 for condition cond, we can add 'ref' access candidates to
 
189
 *   t1 only.
 
190
 *   Example #3:
 
191
 *   @code
 
192
 *    ... LEFT JOIN (t1, t2 LEFT JOIN t3 ON inner_cond) ON cond
 
193
 *   @endcode
 
194
 *   Here we can add 'ref' access candidates for t1 and t2, but not for t3.
 
195
 */
 
196
void add_key_fields_for_nj(JOIN *join,
 
197
                           TableList *nested_join_table,
 
198
                           KeyField **end,
 
199
                           uint32_t *and_level,
 
200
                           std::vector<SargableParam> &sargables);
 
201
 
 
202
/**
 
203
 * Merge new key definitions to old ones, remove those not used in both.
 
204
 *
 
205
 * This is called for OR between different levels.
 
206
 *
 
207
 * To be able to do 'ref_or_null' we merge a comparison of a column
 
208
 * and 'column IS NULL' to one test.  This is useful for sub select queries
 
209
 * that are internally transformed to something like:.
 
210
 *
 
211
 * @code
 
212
 * SELECT * FROM t1 WHERE t1.key=outer_ref_field or t1.key IS NULL
 
213
 * @endcode
 
214
 *
 
215
 * KeyField::null_rejecting is processed as follows: @n
 
216
 * result has null_rejecting=true if it is set for both ORed references.
 
217
 * for example:
 
218
 * -   (t2.key = t1.field OR t2.key  =  t1.field) -> null_rejecting=true
 
219
 * -   (t2.key = t1.field OR t2.key <=> t1.field) -> null_rejecting=false
 
220
 *
 
221
 * @todo
 
222
 *   The result of this is that we're missing some 'ref' accesses.
 
223
 *   OptimizerTeam: Fix this
 
224
 */
 
225
KeyField *merge_key_fields(KeyField *start,
 
226
                            KeyField *new_fields,
 
227
                            KeyField *end, 
 
228
                            uint32_t and_level);
 
229
 
 
230
/**
 
231
 * Add a possible key to array of possible keys if it's usable as a key
 
232
 *
 
233
 * @param key_fields      Pointer to add key, if usable
 
234
 * @param and_level       And level, to be stored in KeyField
 
235
 * @param cond            Condition predicate
 
236
 * @param field           Field used in comparision
 
237
 * @param eq_func         True if we used =, <=> or IS NULL
 
238
 * @param value           Value used for comparison with field
 
239
 * @param usable_tables   Tables which can be used for key optimization
 
240
 * @param sargables       IN/OUT std::vector of found sargable candidates
 
241
 *
 
242
 * @note
 
243
 *  If we are doing a NOT NULL comparison on a NOT NULL field in a outer join
 
244
 *  table, we store this to be able to do not exists optimization later.
 
245
 *
 
246
 * @returns
 
247
 *  *key_fields is incremented if we stored a key in the array
 
248
 */
 
249
void add_key_field(KeyField **key_fields,
 
250
                   uint32_t and_level,
 
251
                   Item_func *cond,
 
252
                   Field *field,
 
253
                   bool eq_func,
 
254
                   Item **value,
 
255
                   uint32_t num_values,
 
256
                   table_map usable_tables,
 
257
                   std::vector<SargableParam> &sargables);
 
258
 
 
259
/**
 
260
 * Add possible keys to array of possible keys originated from a simple
 
261
 * predicate.
 
262
 *
 
263
 * @param  key_fields     Pointer to add key, if usable
 
264
 * @param  and_level      And level, to be stored in KeyField
 
265
 * @param  cond           Condition predicate
 
266
 * @param  field          Field used in comparision
 
267
 * @param  eq_func        True if we used =, <=> or IS NULL
 
268
 * @param  value          Value used for comparison with field
 
269
 *                        Is NULL for BETWEEN and IN
 
270
 * @param  usable_tables  Tables which can be used for key optimization
 
271
 * @param  sargables      IN/OUT std::vector of found sargable candidates
 
272
 *
 
273
 * @note
 
274
 *  If field items f1 and f2 belong to the same multiple equality and
 
275
 *  a key is added for f1, the the same key is added for f2.
 
276
 *
 
277
 * @returns
 
278
 *  *key_fields is incremented if we stored a key in the array
 
279
*/
 
280
void add_key_equal_fields(KeyField **key_fields,
 
281
                          uint32_t and_level,
 
282
                          Item_func *cond,
 
283
                          Item_field *field_item,
 
284
                          bool eq_func,
 
285
                          Item **val,
 
286
                          uint32_t num_values,
 
287
                          table_map usable_tables,
 
288
                          std::vector<SargableParam> &sargables);
 
289
 
 
290
} /* end namespace optimizer */
 
291
 
 
292
} /* end namespace drizzled */
 
293
 
 
294
#endif /* DRIZZLED_OPTIMIZER_KEY_FIELD_H */