← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/row0sel.h

  • Committer: Vijay Samuel
  • Date: 2010-09-10 21:03:37 UTC
  • mto: (1757.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1758.
  • Revision ID: vijay@vijay-20100910210337-rf7c2ymawtqj6tkv
Merge added utf 8 tamil test case suite and test case for creating a database in tamil.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/row0sel.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1997, 2010, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/row0sel.h
21
 
Select
22
 
 
23
 
Created 12/19/1997 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef row0sel_h
27
 
#define row0sel_h
28
 
 
29
 
#include "univ.i"
30
 
#include "data0data.h"
31
 
#include "que0types.h"
32
 
#include "dict0types.h"
33
 
#include "trx0types.h"
34
 
#include "row0types.h"
35
 
#include "que0types.h"
36
 
#include "pars0sym.h"
37
 
#include "btr0pcur.h"
38
 
#include "read0read.h"
39
 
#include "row0mysql.h"
40
 
 
41
 
/*********************************************************************//**
42
 
Creates a select node struct.
43
 
@return own: select node struct */
44
 
UNIV_INTERN
45
 
sel_node_t*
46
 
sel_node_create(
47
 
/*============*/
48
 
        mem_heap_t*     heap);  /*!< in: memory heap where created */
49
 
/*********************************************************************//**
50
 
Frees the memory private to a select node when a query graph is freed,
51
 
does not free the heap where the node was originally created. */
52
 
UNIV_INTERN
53
 
void
54
 
sel_node_free_private(
55
 
/*==================*/
56
 
        sel_node_t*     node);  /*!< in: select node struct */
57
 
/*********************************************************************//**
58
 
Frees a prefetch buffer for a column, including the dynamically allocated
59
 
memory for data stored there. */
60
 
UNIV_INTERN
61
 
void
62
 
sel_col_prefetch_buf_free(
63
 
/*======================*/
64
 
        sel_buf_t*      prefetch_buf);  /*!< in, own: prefetch buffer */
65
 
/*********************************************************************//**
66
 
Gets the plan node for the nth table in a join.
67
 
@return plan node */
68
 
UNIV_INLINE
69
 
plan_t*
70
 
sel_node_get_nth_plan(
71
 
/*==================*/
72
 
        sel_node_t*     node,   /*!< in: select node */
73
 
        ulint           i);     /*!< in: get ith plan node */
74
 
/**********************************************************************//**
75
 
Performs a select step. This is a high-level function used in SQL execution
76
 
graphs.
77
 
@return query thread to run next or NULL */
78
 
UNIV_INTERN
79
 
que_thr_t*
80
 
row_sel_step(
81
 
/*=========*/
82
 
        que_thr_t*      thr);   /*!< in: query thread */
83
 
/**********************************************************************//**
84
 
Performs an execution step of an open or close cursor statement node.
85
 
@return query thread to run next or NULL */
86
 
UNIV_INLINE
87
 
que_thr_t*
88
 
open_step(
89
 
/*======*/
90
 
        que_thr_t*      thr);   /*!< in: query thread */
91
 
/**********************************************************************//**
92
 
Performs a fetch for a cursor.
93
 
@return query thread to run next or NULL */
94
 
UNIV_INTERN
95
 
que_thr_t*
96
 
fetch_step(
97
 
/*=======*/
98
 
        que_thr_t*      thr);   /*!< in: query thread */
99
 
/****************************************************************//**
100
 
Sample callback function for fetch that prints each row.
101
 
@return always returns non-NULL */
102
 
UNIV_INTERN
103
 
void*
104
 
row_fetch_print(
105
 
/*============*/
106
 
        void*   row,            /*!< in:  sel_node_t* */
107
 
        void*   user_arg);      /*!< in:  not used */
108
 
/***********************************************************//**
109
 
Prints a row in a select result.
110
 
@return query thread to run next or NULL */
111
 
UNIV_INTERN
112
 
que_thr_t*
113
 
row_printf_step(
114
 
/*============*/
115
 
        que_thr_t*      thr);   /*!< in: query thread */
116
 
/****************************************************************//**
117
 
Converts a key value stored in MySQL format to an Innobase dtuple. The last
118
 
field of the key value may be just a prefix of a fixed length field: hence
119
 
the parameter key_len. But currently we do not allow search keys where the
120
 
last field is only a prefix of the full key field len and print a warning if
121
 
such appears. */
122
 
UNIV_INTERN
123
 
void
124
 
row_sel_convert_mysql_key_to_innobase(
125
 
/*==================================*/
126
 
        dtuple_t*       tuple,          /*!< in/out: tuple where to build;
127
 
                                        NOTE: we assume that the type info
128
 
                                        in the tuple is already according
129
 
                                        to index! */
130
 
        byte*           buf,            /*!< in: buffer to use in field
131
 
                                        conversions */
132
 
        ulint           buf_len,        /*!< in: buffer length */
133
 
        dict_index_t*   index,          /*!< in: index of the key value */
134
 
        const byte*     key_ptr,        /*!< in: MySQL key value */
135
 
        ulint           key_len,        /*!< in: MySQL key value length */
136
 
        trx_t*          trx);           /*!< in: transaction */
137
 
/********************************************************************//**
138
 
Searches for rows in the database. This is used in the interface to
139
 
MySQL. This function opens a cursor, and also implements fetch next
140
 
and fetch prev. NOTE that if we do a search with a full key value
141
 
from a unique index (ROW_SEL_EXACT), then we will not store the cursor
142
 
position and fetch next or fetch prev must not be tried to the cursor!
143
 
@return DB_SUCCESS, DB_RECORD_NOT_FOUND, DB_END_OF_INDEX, DB_DEADLOCK,
144
 
DB_LOCK_TABLE_FULL, or DB_TOO_BIG_RECORD */
145
 
UNIV_INTERN
146
 
ulint
147
 
row_search_for_mysql(
148
 
/*=================*/
149
 
        byte*           buf,            /*!< in/out: buffer for the fetched
150
 
                                        row in the MySQL format */
151
 
        ulint           mode,           /*!< in: search mode PAGE_CUR_L, ... */
152
 
        row_prebuilt_t* prebuilt,       /*!< in: prebuilt struct for the
153
 
                                        table handle; this contains the info
154
 
                                        of search_tuple, index; if search
155
 
                                        tuple contains 0 fields then we
156
 
                                        position the cursor at the start or
157
 
                                        the end of the index, depending on
158
 
                                        'mode' */
159
 
        ulint           match_mode,     /*!< in: 0 or ROW_SEL_EXACT or
160
 
                                        ROW_SEL_EXACT_PREFIX */
161
 
        ulint           direction);     /*!< in: 0 or ROW_SEL_NEXT or
162
 
                                        ROW_SEL_PREV; NOTE: if this is != 0,
163
 
                                        then prebuilt must have a pcur
164
 
                                        with stored position! In opening of a
165
 
                                        cursor 'direction' should be 0. */
166
 
/*******************************************************************//**
167
 
Checks if MySQL at the moment is allowed for this table to retrieve a
168
 
consistent read result, or store it to the query cache.
169
 
@return TRUE if storing or retrieving from the query cache is permitted */
170
 
UNIV_INTERN
171
 
ibool
172
 
row_search_check_if_query_cache_permitted(
173
 
/*======================================*/
174
 
        trx_t*          trx,            /*!< in: transaction object */
175
 
        const char*     norm_name);     /*!< in: concatenation of database name,
176
 
                                        '/' char, table name */
177
 
/*******************************************************************//**
178
 
Read the max AUTOINC value from an index.
179
 
@return DB_SUCCESS if all OK else error code */
180
 
UNIV_INTERN
181
 
ulint
182
 
row_search_max_autoinc(
183
 
/*===================*/
184
 
        dict_index_t*   index,          /*!< in: index to search */
185
 
        const char*     col_name,       /*!< in: autoinc column name */
186
 
        ib_uint64_t*    value);         /*!< out: AUTOINC value read */
187
 
 
188
 
/** A structure for caching column values for prefetched rows */
189
 
struct sel_buf_struct{
190
 
        byte*           data;   /*!< data, or NULL; if not NULL, this field
191
 
                                has allocated memory which must be explicitly
192
 
                                freed; can be != NULL even when len is
193
 
                                UNIV_SQL_NULL */
194
 
        ulint           len;    /*!< data length or UNIV_SQL_NULL */
195
 
        ulint           val_buf_size;
196
 
                                /*!< size of memory buffer allocated for data:
197
 
                                this can be more than len; this is defined
198
 
                                when data != NULL */
199
 
};
200
 
 
201
 
/** Query plan */
202
 
struct plan_struct{
203
 
        dict_table_t*   table;          /*!< table struct in the dictionary
204
 
                                        cache */
205
 
        dict_index_t*   index;          /*!< table index used in the search */
206
 
        btr_pcur_t      pcur;           /*!< persistent cursor used to search
207
 
                                        the index */
208
 
        ibool           asc;            /*!< TRUE if cursor traveling upwards */
209
 
        ibool           pcur_is_open;   /*!< TRUE if pcur has been positioned
210
 
                                        and we can try to fetch new rows */
211
 
        ibool           cursor_at_end;  /*!< TRUE if the cursor is open but
212
 
                                        we know that there are no more
213
 
                                        qualifying rows left to retrieve from
214
 
                                        the index tree; NOTE though, that
215
 
                                        there may still be unprocessed rows in
216
 
                                        the prefetch stack; always FALSE when
217
 
                                        pcur_is_open is FALSE */
218
 
        ibool           stored_cursor_rec_processed;
219
 
                                        /*!< TRUE if the pcur position has been
220
 
                                        stored and the record it is positioned
221
 
                                        on has already been processed */
222
 
        que_node_t**    tuple_exps;     /*!< array of expressions
223
 
                                        which are used to calculate
224
 
                                        the field values in the search
225
 
                                        tuple: there is one expression
226
 
                                        for each field in the search
227
 
                                        tuple */
228
 
        dtuple_t*       tuple;          /*!< search tuple */
229
 
        ulint           mode;           /*!< search mode: PAGE_CUR_G, ... */
230
 
        ulint           n_exact_match;  /*!< number of first fields in
231
 
                                        the search tuple which must be
232
 
                                        exactly matched */
233
 
        ibool           unique_search;  /*!< TRUE if we are searching an
234
 
                                        index record with a unique key */
235
 
        ulint           n_rows_fetched; /*!< number of rows fetched using pcur
236
 
                                        after it was opened */
237
 
        ulint           n_rows_prefetched;/*!< number of prefetched rows cached
238
 
                                        for fetch: fetching several rows in
239
 
                                        the same mtr saves CPU time */
240
 
        ulint           first_prefetched;/*!< index of the first cached row in
241
 
                                        select buffer arrays for each column */
242
 
        ibool           no_prefetch;    /*!< no prefetch for this table */
243
 
        sym_node_list_t columns;        /*!< symbol table nodes for the columns
244
 
                                        to retrieve from the table */
245
 
        UT_LIST_BASE_NODE_T(func_node_t)
246
 
                        end_conds;      /*!< conditions which determine the
247
 
                                        fetch limit of the index segment we
248
 
                                        have to look at: when one of these
249
 
                                        fails, the result set has been
250
 
                                        exhausted for the cursor in this
251
 
                                        index; these conditions are normalized
252
 
                                        so that in a comparison the column
253
 
                                        for this table is the first argument */
254
 
        UT_LIST_BASE_NODE_T(func_node_t)
255
 
                        other_conds;    /*!< the rest of search conditions we can
256
 
                                        test at this table in a join */
257
 
        ibool           must_get_clust; /*!< TRUE if index is a non-clustered
258
 
                                        index and we must also fetch the
259
 
                                        clustered index record; this is the
260
 
                                        case if the non-clustered record does
261
 
                                        not contain all the needed columns, or
262
 
                                        if this is a single-table explicit
263
 
                                        cursor, or a searched update or
264
 
                                        delete */
265
 
        ulint*          clust_map;      /*!< map telling how clust_ref is built
266
 
                                        from the fields of a non-clustered
267
 
                                        record */
268
 
        dtuple_t*       clust_ref;      /*!< the reference to the clustered
269
 
                                        index entry is built here if index is
270
 
                                        a non-clustered index */
271
 
        btr_pcur_t      clust_pcur;     /*!< if index is non-clustered, we use
272
 
                                        this pcur to search the clustered
273
 
                                        index */
274
 
        mem_heap_t*     old_vers_heap;  /*!< memory heap used in building an old
275
 
                                        version of a row, or NULL */
276
 
};
277
 
 
278
 
/** Select node states */
279
 
enum sel_node_state {
280
 
        SEL_NODE_CLOSED,        /*!< it is a declared cursor which is not
281
 
                                currently open */
282
 
        SEL_NODE_OPEN,          /*!< intention locks not yet set on tables */
283
 
        SEL_NODE_FETCH,         /*!< intention locks have been set */
284
 
        SEL_NODE_NO_MORE_ROWS   /*!< cursor has reached the result set end */
285
 
};
286
 
 
287
 
/** Select statement node */
288
 
struct sel_node_struct{
289
 
        que_common_t    common;         /*!< node type: QUE_NODE_SELECT */
290
 
        enum sel_node_state
291
 
                        state;  /*!< node state */
292
 
        que_node_t*     select_list;    /*!< select list */
293
 
        sym_node_t*     into_list;      /*!< variables list or NULL */
294
 
        sym_node_t*     table_list;     /*!< table list */
295
 
        ibool           asc;            /*!< TRUE if the rows should be fetched
296
 
                                        in an ascending order */
297
 
        ibool           set_x_locks;    /*!< TRUE if the cursor is for update or
298
 
                                        delete, which means that a row x-lock
299
 
                                        should be placed on the cursor row */
300
 
        ulint           row_lock_mode;  /*!< LOCK_X or LOCK_S */
301
 
        ulint           n_tables;       /*!< number of tables */
302
 
        ulint           fetch_table;    /*!< number of the next table to access
303
 
                                        in the join */
304
 
        plan_t*         plans;          /*!< array of n_tables many plan nodes
305
 
                                        containing the search plan and the
306
 
                                        search data structures */
307
 
        que_node_t*     search_cond;    /*!< search condition */
308
 
        read_view_t*    read_view;      /*!< if the query is a non-locking
309
 
                                        consistent read, its read view is
310
 
                                        placed here, otherwise NULL */
311
 
        ibool           consistent_read;/*!< TRUE if the select is a consistent,
312
 
                                        non-locking read */
313
 
        order_node_t*   order_by;       /*!< order by column definition, or
314
 
                                        NULL */
315
 
        ibool           is_aggregate;   /*!< TRUE if the select list consists of
316
 
                                        aggregate functions */
317
 
        ibool           aggregate_already_fetched;
318
 
                                        /*!< TRUE if the aggregate row has
319
 
                                        already been fetched for the current
320
 
                                        cursor */
321
 
        ibool           can_get_updated;/*!< this is TRUE if the select
322
 
                                        is in a single-table explicit
323
 
                                        cursor which can get updated
324
 
                                        within the stored procedure,
325
 
                                        or in a searched update or
326
 
                                        delete; NOTE that to determine
327
 
                                        of an explicit cursor if it
328
 
                                        can get updated, the parser
329
 
                                        checks from a stored procedure
330
 
                                        if it contains positioned
331
 
                                        update or delete statements */
332
 
        sym_node_t*     explicit_cursor;/*!< not NULL if an explicit cursor */
333
 
        UT_LIST_BASE_NODE_T(sym_node_t)
334
 
                        copy_variables; /*!< variables whose values we have to
335
 
                                        copy when an explicit cursor is opened,
336
 
                                        so that they do not change between
337
 
                                        fetches */
338
 
};
339
 
 
340
 
/** Fetch statement node */
341
 
struct fetch_node_struct{
342
 
        que_common_t    common;         /*!< type: QUE_NODE_FETCH */
343
 
        sel_node_t*     cursor_def;     /*!< cursor definition */
344
 
        sym_node_t*     into_list;      /*!< variables to set */
345
 
 
346
 
        pars_user_func_t*
347
 
                        func;           /*!< User callback function or NULL.
348
 
                                        The first argument to the function
349
 
                                        is a sel_node_t*, containing the
350
 
                                        results of the SELECT operation for
351
 
                                        one row. If the function returns
352
 
                                        NULL, it is not interested in
353
 
                                        further rows and the cursor is
354
 
                                        modified so (cursor % NOTFOUND) is
355
 
                                        true. If it returns not-NULL,
356
 
                                        continue normally. See
357
 
                                        row_fetch_print() for an example
358
 
                                        (and a useful debugging tool). */
359
 
};
360
 
 
361
 
/** Open or close cursor operation type */
362
 
enum open_node_op {
363
 
        ROW_SEL_OPEN_CURSOR,    /*!< open cursor */
364
 
        ROW_SEL_CLOSE_CURSOR    /*!< close cursor */
365
 
};
366
 
 
367
 
/** Open or close cursor statement node */
368
 
struct open_node_struct{
369
 
        que_common_t    common;         /*!< type: QUE_NODE_OPEN */
370
 
        enum open_node_op
371
 
                        op_type;        /*!< operation type: open or
372
 
                                        close cursor */
373
 
        sel_node_t*     cursor_def;     /*!< cursor definition */
374
 
};
375
 
 
376
 
/** Row printf statement node */
377
 
struct row_printf_node_struct{
378
 
        que_common_t    common;         /*!< type: QUE_NODE_ROW_PRINTF */
379
 
        sel_node_t*     sel_node;       /*!< select */
380
 
};
381
 
 
382
 
/** Search direction for the MySQL interface */
383
 
enum row_sel_direction {
384
 
        ROW_SEL_NEXT = 1,       /*!< ascending direction */
385
 
        ROW_SEL_PREV = 2        /*!< descending direction */
386
 
};
387
 
 
388
 
/** Match mode for the MySQL interface */
389
 
enum row_sel_match_mode {
390
 
        ROW_SEL_EXACT = 1,      /*!< search using a complete key value */
391
 
        ROW_SEL_EXACT_PREFIX    /*!< search using a key prefix which
392
 
                                must match rows: the prefix may
393
 
                                contain an incomplete field (the last
394
 
                                field in prefix may be just a prefix
395
 
                                of a fixed length column) */
396
 
};
397
 
 
398
 
#ifndef UNIV_NONINL
399
 
#include "row0sel.ic"
400
 
#endif
401
 
 
402
 
#endif