← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_list.cc

  • Committer: Brian Aker
  • Date: 2009-08-18 07:20:29 UTC
  • mfrom: (1117.1.9 merge)
  • Revision ID: brian@gaz-20090818072029-s9ch5lcmltxwidn7
Merge of Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table_list.cc
1
 
/* Copyright (C) 2009 Sun Microsystems, Inc.
 
1
/* Copyright (C) 2009 Sun Microsystems
2
2
 
3
3
  This program is free software; you can redistribute it and/or modify
4
4
  it under the terms of the GNU General Public License as published by
11
11
 
12
12
  You should have received a copy of the GNU General Public License
13
13
  along with this program; if not, write to the Free Software
14
 
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
#include <config.h>
17
 
 
18
 
#include <string>
 
14
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
19
15
 
20
16
#include <drizzled/error.h>
21
17
#include <drizzled/table_list.h>
23
19
#include <drizzled/item/field.h>
24
20
#include <drizzled/nested_join.h>
25
21
#include <drizzled/sql_lex.h>
 
22
#include <drizzled/server_includes.h>
26
23
#include <drizzled/sql_select.h>
27
 
#include <drizzled/strfunc.h>
 
24
 
 
25
#include <string>
28
26
 
29
27
using namespace std;
30
28
 
31
 
namespace drizzled
32
 
{
33
 
 
34
29
class Item;
35
30
class Item_field;
36
31
 
37
 
bool TableList::set_insert_values(memory::Root *)
 
32
/*
 
33
  Create a table cache key
 
34
 
 
35
  SYNOPSIS
 
36
  create_table_def_key()
 
37
  key                   Create key here (must be of size MAX_DBKEY_LENGTH)
 
38
  table_list            Table definition
 
39
 
 
40
  IMPLEMENTATION
 
41
  The table cache_key is created from:
 
42
  db_name + \0
 
43
  table_name + \0
 
44
 
 
45
  if the table is a tmp table, we add the following to make each tmp table
 
46
  unique on the slave:
 
47
 
 
48
  4 bytes for master thread id
 
49
  4 bytes pseudo thread id
 
50
 
 
51
  RETURN
 
52
  Length of key
 
53
*/
 
54
 
 
55
uint32_t TableList::create_table_def_key(char *key)
 
56
{
 
57
  return TableShare::createKey(key, db, table_name);
 
58
}
 
59
 
 
60
 
 
61
/*
 
62
  Set insert_values buffer
 
63
 
 
64
  SYNOPSIS
 
65
    set_insert_values()
 
66
    mem_root   memory pool for allocating
 
67
 
 
68
  RETURN
 
69
    false - OK
 
70
    TRUE  - out of memory
 
71
*/
 
72
 
 
73
bool TableList::set_insert_values(MEM_ROOT *mem_root)
38
74
{
39
75
  if (table)
40
76
  {
41
 
    table->insert_values.resize(table->getShare()->rec_buff_length);
 
77
    if (!table->insert_values &&
 
78
        !(table->insert_values= (unsigned char *)alloc_root(mem_root,
 
79
                                                   table->s->rec_buff_length)))
 
80
      return true;
42
81
  }
43
82
 
44
83
  return false;
45
84
}
46
85
 
 
86
 
 
87
/*
 
88
  Test if this is a leaf with respect to name resolution.
 
89
 
 
90
  SYNOPSIS
 
91
    TableList::is_leaf_for_name_resolution()
 
92
 
 
93
  DESCRIPTION
 
94
    A table reference is a leaf with respect to name resolution if
 
95
    it is either a leaf node in a nested join tree (table, view,
 
96
    schema table, subquery), or an inner node that represents a
 
97
    NATURAL/USING join, or a nested join with materialized join
 
98
    columns.
 
99
 
 
100
  RETURN
 
101
    TRUE if a leaf, false otherwise.
 
102
*/
47
103
bool TableList::is_leaf_for_name_resolution()
48
104
{
49
105
  return (is_natural_join || is_join_columns_complete || !nested_join);
50
106
}
51
107
 
 
108
 
 
109
 
 
110
/*
 
111
  Create Item_field for each column in the table.
 
112
 
 
113
  SYNPOSIS
 
114
    Table::fill_item_list()
 
115
      item_list          a pointer to an empty list used to store items
 
116
 
 
117
  DESCRIPTION
 
118
    Create Item_field object for each column in the table and
 
119
    initialize it with the corresponding Field. New items are
 
120
    created in the current Session memory root.
 
121
 
 
122
  RETURN VALUE
 
123
    0                    success
 
124
    1                    out of memory
 
125
*/
 
126
 
 
127
bool Table::fill_item_list(List<Item> *item_list) const
 
128
{
 
129
  /*
 
130
    All Item_field's created using a direct pointer to a field
 
131
    are fixed in Item_field constructor.
 
132
  */
 
133
  for (Field **ptr= field; *ptr; ptr++)
 
134
  {
 
135
    Item_field *item= new Item_field(*ptr);
 
136
    if (!item || item_list->push_back(item))
 
137
      return true;
 
138
  }
 
139
  return false;
 
140
}
 
141
 
 
142
 
 
143
/*
 
144
  Find underlying base tables (TableList) which represent given
 
145
  table_to_find (Table)
 
146
 
 
147
  SYNOPSIS
 
148
    TableList::find_underlying_table()
 
149
    table_to_find table to find
 
150
 
 
151
  RETURN
 
152
    0  table is not found
 
153
    found table reference
 
154
*/
 
155
 
52
156
TableList *TableList::find_underlying_table(Table *table_to_find)
53
157
{
54
158
  /* is this real table and table which we are looking for? */
58
162
  return NULL;
59
163
}
60
164
 
61
 
bool TableList::isCartesian() const
62
 
{
63
 
  return false;
64
 
}
65
165
 
66
166
bool TableList::placeholder()
67
167
{
68
 
  return derived || (create && !table->getDBStat()) || !table;
 
168
  return derived || schema_table || (create && !table->getDBStat()) || !table;
69
169
}
70
170
 
 
171
 
71
172
/*
72
 
 * The right-most child of a nested table reference is the first
73
 
 * element in the list of children because the children are inserted
74
 
 * in reverse order.
75
 
 */
 
173
  Retrieve the last (right-most) leaf in a nested join tree with
 
174
  respect to name resolution.
 
175
 
 
176
  SYNOPSIS
 
177
    TableList::last_leaf_for_name_resolution()
 
178
 
 
179
  DESCRIPTION
 
180
    Given that 'this' is a nested table reference, recursively walk
 
181
    down the right-most children of 'this' until we reach a leaf
 
182
    table reference with respect to name resolution.
 
183
 
 
184
  IMPLEMENTATION
 
185
    The right-most child of a nested table reference is the first
 
186
    element in the list of children because the children are inserted
 
187
    in reverse order.
 
188
 
 
189
  RETURN
 
190
    - If 'this' is a nested table reference - the right-most child of
 
191
      the tree rooted in 'this',
 
192
    - else - 'this'
 
193
*/
 
194
 
76
195
TableList *TableList::last_leaf_for_name_resolution()
77
196
{
78
197
  TableList *cur_table_ref= this;
79
 
  NestedJoin *cur_nested_join;
 
198
  nested_join_st *cur_nested_join;
80
199
 
81
200
  if (is_leaf_for_name_resolution())
82
201
    return this;
94
213
    */
95
214
    if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
96
215
    {
97
 
      List<TableList>::iterator it(cur_nested_join->join_list.begin());
 
216
      List_iterator_fast<TableList> it(cur_nested_join->join_list);
98
217
      TableList *next;
99
218
      cur_table_ref= it++;
100
219
      while ((next= it++))
106
225
  return cur_table_ref;
107
226
}
108
227
 
 
228
 
109
229
/*
110
 
 * The left-most child of a nested table reference is the last element
111
 
 * in the list of children because the children are inserted in
112
 
 * reverse order.
113
 
 */
 
230
  Retrieve the first (left-most) leaf in a nested join tree with
 
231
  respect to name resolution.
 
232
 
 
233
  SYNOPSIS
 
234
    TableList::first_leaf_for_name_resolution()
 
235
 
 
236
  DESCRIPTION
 
237
    Given that 'this' is a nested table reference, recursively walk
 
238
    down the left-most children of 'this' until we reach a leaf
 
239
    table reference with respect to name resolution.
 
240
 
 
241
  IMPLEMENTATION
 
242
    The left-most child of a nested table reference is the last element
 
243
    in the list of children because the children are inserted in
 
244
    reverse order.
 
245
 
 
246
  RETURN
 
247
    If 'this' is a nested table reference - the left-most child of
 
248
      the tree rooted in 'this',
 
249
    else return 'this'
 
250
*/
 
251
 
114
252
TableList *TableList::first_leaf_for_name_resolution()
115
253
{
116
254
  TableList *cur_table_ref= NULL;
117
 
  NestedJoin *cur_nested_join;
 
255
  nested_join_st *cur_nested_join;
118
256
 
119
257
  if (is_leaf_for_name_resolution())
120
258
    return this;
124
262
       cur_nested_join;
125
263
       cur_nested_join= cur_table_ref->nested_join)
126
264
  {
127
 
    List<TableList>::iterator it(cur_nested_join->join_list.begin());
 
265
    List_iterator_fast<TableList> it(cur_nested_join->join_list);
128
266
    cur_table_ref= it++;
129
267
    /*
130
268
      If the current nested join is a RIGHT JOIN, the operands in
144
282
  return cur_table_ref;
145
283
}
146
284
 
 
285
 
 
286
/*
 
287
  Return subselect that contains the FROM list this table is taken from
 
288
 
 
289
  SYNOPSIS
 
290
    TableList::containing_subselect()
 
291
 
 
292
  RETURN
 
293
    Subselect item for the subquery that contains the FROM list
 
294
    this table is taken from if there is any
 
295
    0 - otherwise
 
296
 
 
297
*/
 
298
 
147
299
Item_subselect *TableList::containing_subselect()
148
300
{
149
301
  return (select_lex ? select_lex->master_unit()->item : 0);
150
302
}
151
303
 
 
304
 
 
305
/*
 
306
  Compiles the tagged hints list and fills up the bitmasks.
 
307
 
 
308
  SYNOPSIS
 
309
    process_index_hints()
 
310
      table         the Table to operate on.
 
311
 
 
312
  DESCRIPTION
 
313
    The parser collects the index hints for each table in a "tagged list"
 
314
    (TableList::index_hints). Using the information in this tagged list
 
315
    this function sets the members Table::keys_in_use_for_query,
 
316
    Table::keys_in_use_for_group_by, Table::keys_in_use_for_order_by,
 
317
    Table::force_index and Table::covering_keys.
 
318
 
 
319
    Current implementation of the runtime does not allow mixing FORCE INDEX
 
320
    and USE INDEX, so this is checked here. Then the FORCE INDEX list
 
321
    (if non-empty) is appended to the USE INDEX list and a flag is set.
 
322
 
 
323
    Multiple hints of the same kind are processed so that each clause
 
324
    is applied to what is computed in the previous clause.
 
325
    For example:
 
326
        USE INDEX (i1) USE INDEX (i2)
 
327
    is equivalent to
 
328
        USE INDEX (i1,i2)
 
329
    and means "consider only i1 and i2".
 
330
 
 
331
    Similarly
 
332
        USE INDEX () USE INDEX (i1)
 
333
    is equivalent to
 
334
        USE INDEX (i1)
 
335
    and means "consider only the index i1"
 
336
 
 
337
    It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
 
338
    not an error.
 
339
 
 
340
    Different kind of hints (USE/FORCE/IGNORE) are processed in the following
 
341
    order:
 
342
      1. All indexes in USE (or FORCE) INDEX are added to the mask.
 
343
      2. All IGNORE INDEX
 
344
 
 
345
    e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
 
346
    as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".
 
347
 
 
348
    As an optimization if there is a covering index, and we have
 
349
    IGNORE INDEX FOR GROUP/order_st, and this index is used for the JOIN part,
 
350
    then we have to ignore the IGNORE INDEX FROM GROUP/order_st.
 
351
 
 
352
  RETURN VALUE
 
353
    false                no errors found
 
354
    TRUE                 found and reported an error.
 
355
*/
152
356
bool TableList::process_index_hints(Table *tbl)
153
357
{
154
358
  /* initialize the result variables */
155
359
  tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by=
156
 
    tbl->keys_in_use_for_order_by= tbl->getShare()->keys_in_use;
 
360
    tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
157
361
 
158
362
  /* index hint list processing */
159
363
  if (index_hints)
165
369
    int type;
166
370
    bool have_empty_use_join= false, have_empty_use_order= false,
167
371
         have_empty_use_group= false;
168
 
    List_iterator <Index_hint> iter(index_hints->begin());
 
372
    List_iterator <Index_hint> iter(*index_hints);
169
373
 
170
374
    /* initialize temporary variables used to collect hints of each kind */
171
375
    for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)
178
382
    /* iterate over the hints list */
179
383
    while ((hint= iter++))
180
384
    {
181
 
      uint32_t pos= 0;
 
385
      uint32_t pos;
182
386
 
183
387
      /* process empty USE INDEX () */
184
388
      if (hint->type == INDEX_HINT_USE && !hint->key_name.str)
205
409
        Check if an index with the given name exists and get his offset in
206
410
        the keys bitmask for the table
207
411
      */
208
 
      if (not tbl->getShare()->doesKeyNameExist(hint->key_name.str, hint->key_name.length, pos))
 
412
      if (tbl->s->keynames.type_names == 0 ||
 
413
          (pos= find_type(&tbl->s->keynames, hint->key_name.str,
 
414
                          hint->key_name.length, 1)) <= 0)
209
415
      {
210
416
        my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
211
417
        return 1;
212
418
      }
 
419
 
 
420
      pos--;
 
421
 
213
422
      /* add to the appropriate clause mask */
214
423
      if (hint->clause & INDEX_HINT_MASK_JOIN)
215
424
        index_join[hint->type].set(pos);
262
471
  return 0;
263
472
}
264
473
 
 
474
 
 
475
/**
 
476
  Print table as it should be in join list.
 
477
 
 
478
  @param str   string where table should be printed
 
479
*/
265
480
void TableList::print(Session *session, String *str, enum_query_type query_type)
266
481
{
267
482
  if (nested_join)
288
503
        str->append_identifier(db, db_length);
289
504
        str->append('.');
290
505
      }
291
 
      str->append_identifier(table_name, table_name_length);
292
 
      cmp_name= table_name;
 
506
      if (schema_table)
 
507
      {
 
508
        str->append_identifier(schema_table_name, strlen(schema_table_name));
 
509
        cmp_name= schema_table_name;
 
510
      }
 
511
      else
 
512
      {
 
513
        str->append_identifier(table_name, table_name_length);
 
514
        cmp_name= table_name;
 
515
      }
293
516
    }
294
517
    if (my_strcasecmp(table_alias_charset, cmp_name, alias))
295
518
    {
309
532
 
310
533
    if (index_hints)
311
534
    {
312
 
      List<Index_hint>::iterator it(index_hints->begin());
 
535
      List_iterator<Index_hint> it(*index_hints);
313
536
      Index_hint *hint;
314
537
 
315
538
      while ((hint= it++))
320
543
    }
321
544
  }
322
545
}
323
 
 
324
 
} /* namespace drizzled */