← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/row0mysql.h

  • Committer: Monty Taylor
  • Date: 2008-12-24 01:49:53 UTC
  • mto: This revision was merged to the branch mainline in revision 751.
  • Revision ID: mordred@inaugust.com-20081224014953-rc9p7a162p74y889
Fixed connect.test.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/row0mysql.h
 
1
/******************************************************
 
2
Interface between Innobase row operations and MySQL.
 
3
Contains also create table and other data dictionary operations.
 
4
 
 
5
(c) 2000 Innobase Oy
 
6
 
 
7
Created 9/17/2000 Heikki Tuuri
 
8
*******************************************************/
 
9
 
 
10
#ifndef row0mysql_h
 
11
#define row0mysql_h
 
12
 
 
13
#include "univ.i"
 
14
#include "data0data.h"
 
15
#include "que0types.h"
 
16
#include "dict0types.h"
 
17
#include "trx0types.h"
 
18
#include "row0types.h"
 
19
#include "btr0pcur.h"
 
20
#include "trx0types.h"
 
21
 
 
22
extern ibool row_rollback_on_timeout;
 
23
 
 
24
typedef struct row_prebuilt_struct row_prebuilt_t;
 
25
 
 
26
/***********************************************************************
 
27
Frees the blob heap in prebuilt when no longer needed. */
 
28
UNIV_INTERN
 
29
void
 
30
row_mysql_prebuilt_free_blob_heap(
 
31
/*==============================*/
 
32
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct of a
 
33
                                        ha_innobase:: table handle */
 
34
/***********************************************************************
 
35
Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row
 
36
format. */
 
37
UNIV_INTERN
 
38
byte*
 
39
row_mysql_store_true_var_len(
 
40
/*=========================*/
 
41
                        /* out: pointer to the data, we skip the 1 or 2 bytes
 
42
                        at the start that are used to store the len */
 
43
        byte*   dest,   /* in: where to store */
 
44
        ulint   len,    /* in: length, must fit in two bytes */
 
45
        ulint   lenlen);/* in: storage length of len: either 1 or 2 bytes */
 
46
/***********************************************************************
 
47
Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and
 
48
returns a pointer to the data. */
 
49
 
 
50
const byte*
 
51
row_mysql_read_true_varchar(
 
52
/*========================*/
 
53
                                /* out: pointer to the data, we skip
 
54
                                the 1 or 2 bytes at the start that are
 
55
                                used to store the len */
 
56
        ulint*          len,    /* out: variable-length field length */
 
57
        const byte*     field,  /* in: field in the MySQL format */
 
58
        ulint           lenlen);/* in: storage length of len: either 1
 
59
                                or 2 bytes */
 
60
/***********************************************************************
 
61
Stores a reference to a BLOB in the MySQL format. */
 
62
UNIV_INTERN
 
63
void
 
64
row_mysql_store_blob_ref(
 
65
/*=====================*/
 
66
        byte*           dest,   /* in: where to store */
 
67
        ulint           col_len,/* in: dest buffer size: determines into
 
68
                                how many bytes the BLOB length is stored,
 
69
                                the space for the length may vary from 1
 
70
                                to 4 bytes */
 
71
        const void*     data,   /* in: BLOB data; if the value to store
 
72
                                is SQL NULL this should be NULL pointer */
 
73
        ulint           len);   /* in: BLOB length; if the value to store
 
74
                                is SQL NULL this should be 0; remember
 
75
                                also to set the NULL bit in the MySQL record
 
76
                                header! */
 
77
/***********************************************************************
 
78
Reads a reference to a BLOB in the MySQL format. */
 
79
 
 
80
const byte*
 
81
row_mysql_read_blob_ref(
 
82
/*====================*/
 
83
                                        /* out: pointer to BLOB data */
 
84
        ulint*          len,            /* out: BLOB length */
 
85
        const byte*     ref,            /* in: BLOB reference in the
 
86
                                        MySQL format */
 
87
        ulint           col_len);       /* in: BLOB reference length
 
88
                                        (not BLOB length) */
 
89
/******************************************************************
 
90
Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.
 
91
The counterpart of this function is row_sel_field_store_in_mysql_format() in
 
92
row0sel.c. */
 
93
UNIV_INTERN
 
94
byte*
 
95
row_mysql_store_col_in_innobase_format(
 
96
/*===================================*/
 
97
                                        /* out: up to which byte we used
 
98
                                        buf in the conversion */
 
99
        dfield_t*       dfield,         /* in/out: dfield where dtype
 
100
                                        information must be already set when
 
101
                                        this function is called! */
 
102
        byte*           buf,            /* in/out: buffer for a converted
 
103
                                        integer value; this must be at least
 
104
                                        col_len long then! */
 
105
        ibool           row_format_col, /* TRUE if the mysql_data is from
 
106
                                        a MySQL row, FALSE if from a MySQL
 
107
                                        key value;
 
108
                                        in MySQL, a true VARCHAR storage
 
109
                                        format differs in a row and in a
 
110
                                        key value: in a key value the length
 
111
                                        is always stored in 2 bytes! */
 
112
        const byte*     mysql_data,     /* in: MySQL column value, not
 
113
                                        SQL NULL; NOTE that dfield may also
 
114
                                        get a pointer to mysql_data,
 
115
                                        therefore do not discard this as long
 
116
                                        as dfield is used! */
 
117
        ulint           col_len,        /* in: MySQL column length; NOTE that
 
118
                                        this is the storage length of the
 
119
                                        column in the MySQL format row, not
 
120
                                        necessarily the length of the actual
 
121
                                        payload data; if the column is a true
 
122
                                        VARCHAR then this is irrelevant */
 
123
        ulint           comp);          /* in: nonzero=compact format */
 
124
/********************************************************************
 
125
Handles user errors and lock waits detected by the database engine. */
 
126
UNIV_INTERN
 
127
ibool
 
128
row_mysql_handle_errors(
 
129
/*====================*/
 
130
                                /* out: TRUE if it was a lock wait and
 
131
                                we should continue running the query thread */
 
132
        ulint*          new_err,/* out: possible new error encountered in
 
133
                                rollback, or the old error which was
 
134
                                during the function entry */
 
135
        trx_t*          trx,    /* in: transaction */
 
136
        que_thr_t*      thr,    /* in: query thread */
 
137
        trx_savept_t*   savept);/* in: savepoint */
 
138
/************************************************************************
 
139
Create a prebuilt struct for a MySQL table handle. */
 
140
UNIV_INTERN
 
141
row_prebuilt_t*
 
142
row_create_prebuilt(
 
143
/*================*/
 
144
                                /* out, own: a prebuilt struct */
 
145
        dict_table_t*   table); /* in: Innobase table handle */
 
146
/************************************************************************
 
147
Free a prebuilt struct for a MySQL table handle. */
 
148
UNIV_INTERN
 
149
void
 
150
row_prebuilt_free(
 
151
/*==============*/
 
152
        row_prebuilt_t* prebuilt,       /* in, own: prebuilt struct */
 
153
        ibool           dict_locked);   /* in: TRUE=data dictionary locked */
 
154
/*************************************************************************
 
155
Updates the transaction pointers in query graphs stored in the prebuilt
 
156
struct. */
 
157
UNIV_INTERN
 
158
void
 
159
row_update_prebuilt_trx(
 
160
/*====================*/
 
161
                                        /* out: prebuilt dtuple */
 
162
        row_prebuilt_t* prebuilt,       /* in: prebuilt struct in MySQL
 
163
                                        handle */
 
164
        trx_t*          trx);           /* in: transaction handle */
 
165
/*************************************************************************
 
166
Unlocks AUTO_INC type locks that were possibly reserved by a trx. */
 
167
UNIV_INTERN
 
168
void
 
169
row_unlock_table_autoinc_for_mysql(
 
170
/*===============================*/
 
171
        trx_t*  trx);                   /* in/out: transaction */
 
172
/*************************************************************************
 
173
Sets an AUTO_INC type lock on the table mentioned in prebuilt. The
 
174
AUTO_INC lock gives exclusive access to the auto-inc counter of the
 
175
table. The lock is reserved only for the duration of an SQL statement.
 
176
It is not compatible with another AUTO_INC or exclusive lock on the
 
177
table. */
 
178
UNIV_INTERN
 
179
int
 
180
row_lock_table_autoinc_for_mysql(
 
181
/*=============================*/
 
182
                                        /* out: error code or DB_SUCCESS */
 
183
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in the MySQL
 
184
                                        table handle */
 
185
/*************************************************************************
 
186
Sets a table lock on the table mentioned in prebuilt. */
 
187
UNIV_INTERN
 
188
int
 
189
row_lock_table_for_mysql(
 
190
/*=====================*/
 
191
                                        /* out: error code or DB_SUCCESS */
 
192
        row_prebuilt_t* prebuilt,       /* in: prebuilt struct in the MySQL
 
193
                                        table handle */
 
194
        dict_table_t*   table,          /* in: table to lock, or NULL
 
195
                                        if prebuilt->table should be
 
196
                                        locked as
 
197
                                        prebuilt->select_lock_type */
 
198
        ulint           mode);          /* in: lock mode of table
 
199
                                        (ignored if table==NULL) */
 
200
 
 
201
/*************************************************************************
 
202
Does an insert for MySQL. */
 
203
UNIV_INTERN
 
204
int
 
205
row_insert_for_mysql(
 
206
/*=================*/
 
207
                                        /* out: error code or DB_SUCCESS */
 
208
        byte*           mysql_rec,      /* in: row in the MySQL format */
 
209
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
210
                                        handle */
 
211
/*************************************************************************
 
212
Builds a dummy query graph used in selects. */
 
213
UNIV_INTERN
 
214
void
 
215
row_prebuild_sel_graph(
 
216
/*===================*/
 
217
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
218
                                        handle */
 
219
/*************************************************************************
 
220
Gets pointer to a prebuilt update vector used in updates. If the update
 
221
graph has not yet been built in the prebuilt struct, then this function
 
222
first builds it. */
 
223
UNIV_INTERN
 
224
upd_t*
 
225
row_get_prebuilt_update_vector(
 
226
/*===========================*/
 
227
                                        /* out: prebuilt update vector */
 
228
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
229
                                        handle */
 
230
/*************************************************************************
 
231
Checks if a table is such that we automatically created a clustered
 
232
index on it (on row id). */
 
233
UNIV_INTERN
 
234
ibool
 
235
row_table_got_default_clust_index(
 
236
/*==============================*/
 
237
        const dict_table_t*     table);
 
238
/*************************************************************************
 
239
Calculates the key number used inside MySQL for an Innobase index. We have
 
240
to take into account if we generated a default clustered index for the table */
 
241
UNIV_INTERN
 
242
ulint
 
243
row_get_mysql_key_number_for_index(
 
244
/*===============================*/
 
245
        const dict_index_t*     index);
 
246
/*************************************************************************
 
247
Does an update or delete of a row for MySQL. */
 
248
UNIV_INTERN
 
249
int
 
250
row_update_for_mysql(
 
251
/*=================*/
 
252
                                        /* out: error code or DB_SUCCESS */
 
253
        byte*           mysql_rec,      /* in: the row to be updated, in
 
254
                                        the MySQL format */
 
255
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
256
                                        handle */
 
257
/*************************************************************************
 
258
This can only be used when srv_locks_unsafe_for_binlog is TRUE or
 
259
session is using a READ COMMITTED isolation level. Before
 
260
calling this function we must use trx_reset_new_rec_lock_info() and
 
261
trx_register_new_rec_lock() to store the information which new record locks
 
262
really were set. This function removes a newly set lock under prebuilt->pcur,
 
263
and also under prebuilt->clust_pcur. Currently, this is only used and tested
 
264
in the case of an UPDATE or a DELETE statement, where the row lock is of the
 
265
LOCK_X type.
 
266
Thus, this implements a 'mini-rollback' that releases the latest record
 
267
locks we set. */
 
268
UNIV_INTERN
 
269
int
 
270
row_unlock_for_mysql(
 
271
/*=================*/
 
272
                                        /* out: error code or DB_SUCCESS */
 
273
        row_prebuilt_t* prebuilt,       /* in: prebuilt struct in MySQL
 
274
                                        handle */
 
275
        ibool           has_latches_on_recs);/* TRUE if called so that we have
 
276
                                        the latches on the records under pcur
 
277
                                        and clust_pcur, and we do not need to
 
278
                                        reposition the cursors. */
 
279
/*************************************************************************
 
280
Creates an query graph node of 'update' type to be used in the MySQL
 
281
interface. */
 
282
UNIV_INTERN
 
283
upd_node_t*
 
284
row_create_update_node_for_mysql(
 
285
/*=============================*/
 
286
                                /* out, own: update node */
 
287
        dict_table_t*   table,  /* in: table to update */
 
288
        mem_heap_t*     heap);  /* in: mem heap from which allocated */
 
289
/**************************************************************************
 
290
Does a cascaded delete or set null in a foreign key operation. */
 
291
UNIV_INTERN
 
292
ulint
 
293
row_update_cascade_for_mysql(
 
294
/*=========================*/
 
295
                                /* out: error code or DB_SUCCESS */
 
296
        que_thr_t*      thr,    /* in: query thread */
 
297
        upd_node_t*     node,   /* in: update node used in the cascade
 
298
                                or set null operation */
 
299
        dict_table_t*   table); /* in: table where we do the operation */
 
300
/*************************************************************************
 
301
Locks the data dictionary exclusively for performing a table create or other
 
302
data dictionary modification operation. */
 
303
UNIV_INTERN
 
304
void
 
305
row_mysql_lock_data_dictionary(
 
306
/*===========================*/
 
307
        trx_t*  trx);   /* in: transaction */
 
308
/*************************************************************************
 
309
Unlocks the data dictionary exclusive lock. */
 
310
UNIV_INTERN
 
311
void
 
312
row_mysql_unlock_data_dictionary(
 
313
/*=============================*/
 
314
        trx_t*  trx);   /* in: transaction */
 
315
/*************************************************************************
 
316
Locks the data dictionary in shared mode from modifications, for performing
 
317
foreign key check, rollback, or other operation invisible to MySQL. */
 
318
UNIV_INTERN
 
319
void
 
320
row_mysql_freeze_data_dictionary(
 
321
/*=============================*/
 
322
        trx_t*  trx);   /* in: transaction */
 
323
/*************************************************************************
 
324
Unlocks the data dictionary shared lock. */
 
325
UNIV_INTERN
 
326
void
 
327
row_mysql_unfreeze_data_dictionary(
 
328
/*===============================*/
 
329
        trx_t*  trx);   /* in: transaction */
 
330
#ifndef UNIV_HOTBACKUP
 
331
/*************************************************************************
 
332
Creates a table for MySQL. If the name of the table ends in
 
333
one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor",
 
334
"innodb_table_monitor", then this will also start the printing of monitor
 
335
output by the master thread. If the table name ends in "innodb_mem_validate",
 
336
InnoDB will try to invoke mem_validate(). */
 
337
UNIV_INTERN
 
338
int
 
339
row_create_table_for_mysql(
 
340
/*=======================*/
 
341
                                        /* out: error code or DB_SUCCESS */
 
342
        dict_table_t*   table,          /* in, own: table definition
 
343
                                        (will be freed) */
 
344
        trx_t*          trx);           /* in: transaction handle */
 
345
/*************************************************************************
 
346
Does an index creation operation for MySQL. TODO: currently failure
 
347
to create an index results in dropping the whole table! This is no problem
 
348
currently as all indexes must be created at the same time as the table. */
 
349
UNIV_INTERN
 
350
int
 
351
row_create_index_for_mysql(
 
352
/*=======================*/
 
353
                                        /* out: error number or DB_SUCCESS */
 
354
        dict_index_t*   index,          /* in, own: index definition
 
355
                                        (will be freed) */
 
356
        trx_t*          trx,            /* in: transaction handle */
 
357
        const ulint*    field_lengths); /* in: if not NULL, must contain
 
358
                                        dict_index_get_n_fields(index)
 
359
                                        actual field lengths for the
 
360
                                        index columns, which are
 
361
                                        then checked for not being too
 
362
                                        large. */
 
363
/*************************************************************************
 
364
Scans a table create SQL string and adds to the data dictionary
 
365
the foreign key constraints declared in the string. This function
 
366
should be called after the indexes for a table have been created.
 
367
Each foreign key constraint must be accompanied with indexes in
 
368
bot participating tables. The indexes are allowed to contain more
 
369
fields than mentioned in the constraint. */
 
370
UNIV_INTERN
 
371
int
 
372
row_table_add_foreign_constraints(
 
373
/*==============================*/
 
374
                                        /* out: error code or DB_SUCCESS */
 
375
        trx_t*          trx,            /* in: transaction */
 
376
        const char*     sql_string,     /* in: table create statement where
 
377
                                        foreign keys are declared like:
 
378
                                FOREIGN KEY (a, b) REFERENCES table2(c, d),
 
379
                                        table2 can be written also with the
 
380
                                        database name before it: test.table2 */
 
381
        const char*     name,           /* in: table full name in the
 
382
                                        normalized form
 
383
                                        database_name/table_name */
 
384
        ibool           reject_fks);    /* in: if TRUE, fail with error
 
385
                                        code DB_CANNOT_ADD_CONSTRAINT if
 
386
                                        any foreign keys are found. */
 
387
 
 
388
/*************************************************************************
 
389
The master thread in srv0srv.c calls this regularly to drop tables which
 
390
we must drop in background after queries to them have ended. Such lazy
 
391
dropping of tables is needed in ALTER TABLE on Unix. */
 
392
UNIV_INTERN
 
393
ulint
 
394
row_drop_tables_for_mysql_in_background(void);
 
395
/*=========================================*/
 
396
                                        /* out: how many tables dropped
 
397
                                        + remaining tables in list */
 
398
/*************************************************************************
 
399
Get the background drop list length. NOTE: the caller must own the kernel
 
400
mutex! */
 
401
UNIV_INTERN
 
402
ulint
 
403
row_get_background_drop_list_len_low(void);
 
404
/*======================================*/
 
405
                                        /* out: how many tables in list */
 
406
/*************************************************************************
 
407
Truncates a table for MySQL. */
 
408
UNIV_INTERN
 
409
int
 
410
row_truncate_table_for_mysql(
 
411
/*=========================*/
 
412
                                /* out: error code or DB_SUCCESS */
 
413
        dict_table_t*   table,  /* in: table handle */
 
414
        trx_t*          trx);   /* in: transaction handle */
 
415
/*************************************************************************
 
416
Drops a table for MySQL.  If the name of the dropped table ends in
 
417
one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor",
 
418
"innodb_table_monitor", then this will also stop the printing of monitor
 
419
output by the master thread.  If the data dictionary was not already locked
 
420
by the transaction, the transaction will be committed.  Otherwise, the
 
421
data dictionary will remain locked. */
 
422
UNIV_INTERN
 
423
int
 
424
row_drop_table_for_mysql(
 
425
/*=====================*/
 
426
                                /* out: error code or DB_SUCCESS */
 
427
        const char*     name,   /* in: table name */
 
428
        trx_t*          trx,    /* in: transaction handle */
 
429
        ibool           drop_db);/* in: TRUE=dropping whole database */
 
430
 
 
431
/*************************************************************************
 
432
Discards the tablespace of a table which stored in an .ibd file. Discarding
 
433
means that this function deletes the .ibd file and assigns a new table id for
 
434
the table. Also the flag table->ibd_file_missing is set TRUE. */
 
435
UNIV_INTERN
 
436
int
 
437
row_discard_tablespace_for_mysql(
 
438
/*=============================*/
 
439
                                /* out: error code or DB_SUCCESS */
 
440
        const char*     name,   /* in: table name */
 
441
        trx_t*          trx);   /* in: transaction handle */
 
442
/*********************************************************************
 
443
Imports a tablespace. The space id in the .ibd file must match the space id
 
444
of the table in the data dictionary. */
 
445
UNIV_INTERN
 
446
int
 
447
row_import_tablespace_for_mysql(
 
448
/*============================*/
 
449
                                /* out: error code or DB_SUCCESS */
 
450
        const char*     name,   /* in: table name */
 
451
        trx_t*          trx);   /* in: transaction handle */
 
452
/*************************************************************************
 
453
Drops a database for MySQL. */
 
454
UNIV_INTERN
 
455
int
 
456
row_drop_database_for_mysql(
 
457
/*========================*/
 
458
                                /* out: error code or DB_SUCCESS */
 
459
        const char*     name,   /* in: database name which ends to '/' */
 
460
        trx_t*          trx);   /* in: transaction handle */
 
461
/*************************************************************************
 
462
Renames a table for MySQL. */
 
463
UNIV_INTERN
 
464
ulint
 
465
row_rename_table_for_mysql(
 
466
/*=======================*/
 
467
                                        /* out: error code or DB_SUCCESS */
 
468
        const char*     old_name,       /* in: old table name */
 
469
        const char*     new_name,       /* in: new table name */
 
470
        trx_t*          trx,            /* in: transaction handle */
 
471
        ibool           commit);        /* in: if TRUE then commit trx */
 
472
/*************************************************************************
 
473
Checks a table for corruption. */
 
474
UNIV_INTERN
 
475
ulint
 
476
row_check_table_for_mysql(
 
477
/*======================*/
 
478
                                        /* out: DB_ERROR or DB_SUCCESS */
 
479
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
480
                                        handle */
 
481
#endif /* !UNIV_HOTBACKUP */
 
482
 
 
483
/*************************************************************************
 
484
Determines if a table is a magic monitor table. */
 
485
UNIV_INTERN
 
486
ibool
 
487
row_is_magic_monitor_table(
 
488
/*=======================*/
 
489
                                        /* out: TRUE if monitor table */
 
490
        const char*     table_name);    /* in: name of the table, in the
 
491
                                        form database/table_name */
 
492
 
 
493
/* A struct describing a place for an individual column in the MySQL
 
494
row format which is presented to the table handler in ha_innobase.
 
495
This template struct is used to speed up row transformations between
 
496
Innobase and MySQL. */
 
497
 
 
498
typedef struct mysql_row_templ_struct mysql_row_templ_t;
 
499
struct mysql_row_templ_struct {
 
500
        ulint   col_no;                 /* column number of the column */
 
501
        ulint   rec_field_no;           /* field number of the column in an
 
502
                                        Innobase record in the current index;
 
503
                                        not defined if template_type is
 
504
                                        ROW_MYSQL_WHOLE_ROW */
 
505
        ulint   mysql_col_offset;       /* offset of the column in the MySQL
 
506
                                        row format */
 
507
        ulint   mysql_col_len;          /* length of the column in the MySQL
 
508
                                        row format */
 
509
        ulint   mysql_null_byte_offset; /* MySQL NULL bit byte offset in a
 
510
                                        MySQL record */
 
511
        ulint   mysql_null_bit_mask;    /* bit mask to get the NULL bit,
 
512
                                        zero if column cannot be NULL */
 
513
        ulint   type;                   /* column type in Innobase mtype
 
514
                                        numbers DATA_CHAR... */
 
515
        ulint   mysql_type;             /* MySQL type code; this is always
 
516
                                        < 256 */
 
517
        ulint   mysql_length_bytes;     /* if mysql_type
 
518
                                        == DATA_MYSQL_TRUE_VARCHAR, this tells
 
519
                                        whether we should use 1 or 2 bytes to
 
520
                                        store the MySQL true VARCHAR data
 
521
                                        length at the start of row in the MySQL
 
522
                                        format (NOTE that the MySQL key value
 
523
                                        format always uses 2 bytes for the data
 
524
                                        len) */
 
525
        ulint   charset;                /* MySQL charset-collation code
 
526
                                        of the column, or zero */
 
527
        ulint   mbminlen;               /* minimum length of a char, in bytes,
 
528
                                        or zero if not a char type */
 
529
        ulint   mbmaxlen;               /* maximum length of a char, in bytes,
 
530
                                        or zero if not a char type */
 
531
        ulint   is_unsigned;            /* if a column type is an integer
 
532
                                        type and this field is != 0, then
 
533
                                        it is an unsigned integer type */
 
534
};
 
535
 
 
536
#define MYSQL_FETCH_CACHE_SIZE          8
 
537
/* After fetching this many rows, we start caching them in fetch_cache */
 
538
#define MYSQL_FETCH_CACHE_THRESHOLD     4
 
539
 
 
540
#define ROW_PREBUILT_ALLOCATED  78540783
 
541
#define ROW_PREBUILT_FREED      26423527
 
542
 
 
543
typedef int64_t (*index_cond_func_t)(void *param);
 
544
 
 
545
/* A struct for (sometimes lazily) prebuilt structures in an Innobase table
 
546
handle used within MySQL; these are used to save CPU time. */
 
547
 
 
548
struct row_prebuilt_struct {
 
549
        ulint           magic_n;        /* this magic number is set to
 
550
                                        ROW_PREBUILT_ALLOCATED when created,
 
551
                                        or ROW_PREBUILT_FREED when the
 
552
                                        struct has been freed */
 
553
        dict_table_t*   table;          /* Innobase table handle */
 
554
        trx_t*          trx;            /* current transaction handle */
 
555
        ibool           sql_stat_start; /* TRUE when we start processing of
 
556
                                        an SQL statement: we may have to set
 
557
                                        an intention lock on the table,
 
558
                                        create a consistent read view etc. */
 
559
        ibool           mysql_has_locked; /* this is set TRUE when MySQL
 
560
                                        calls external_lock on this handle
 
561
                                        with a lock flag, and set FALSE when
 
562
                                        with the F_UNLOCK flag */
 
563
        ibool           clust_index_was_generated;
 
564
                                        /* if the user did not define a
 
565
                                        primary key in MySQL, then Innobase
 
566
                                        automatically generated a clustered
 
567
                                        index where the ordering column is
 
568
                                        the row id: in this case this flag
 
569
                                        is set to TRUE */
 
570
        dict_index_t*   index;          /* current index for a search, if
 
571
                                        any */
 
572
        ulint           read_just_key;  /* set to 1 when MySQL calls
 
573
                                        ha_innobase::extra with the
 
574
                                        argument HA_EXTRA_KEYREAD; it is enough
 
575
                                        to read just columns defined in
 
576
                                        the index (i.e., no read of the
 
577
                                        clustered index record necessary) */
 
578
        ibool           used_in_HANDLER;/* TRUE if we have been using this
 
579
                                        handle in a MySQL HANDLER low level
 
580
                                        index cursor command: then we must
 
581
                                        store the pcur position even in a
 
582
                                        unique search from a clustered index,
 
583
                                        because HANDLER allows NEXT and PREV
 
584
                                        in such a situation */
 
585
        ulint           template_type;  /* ROW_MYSQL_WHOLE_ROW,
 
586
                                        ROW_MYSQL_REC_FIELDS,
 
587
                                        ROW_MYSQL_DUMMY_TEMPLATE, or
 
588
                                        ROW_MYSQL_NO_TEMPLATE */
 
589
        ulint           n_template;     /* number of elements in the
 
590
                                        template */
 
591
        ulint           null_bitmap_len;/* number of bytes in the SQL NULL
 
592
                                        bitmap at the start of a row in the
 
593
                                        MySQL format */
 
594
        ibool           need_to_access_clustered; /* if we are fetching
 
595
                                        columns through a secondary index
 
596
                                        and at least one column is not in
 
597
                                        the secondary index, then this is
 
598
                                        set to TRUE */
 
599
        ibool           templ_contains_blob;/* TRUE if the template contains
 
600
                                        BLOB column(s) */
 
601
        mysql_row_templ_t* mysql_template;/* template used to transform
 
602
                                        rows fast between MySQL and Innobase
 
603
                                        formats; memory for this template
 
604
                                        is not allocated from 'heap' */
 
605
        mem_heap_t*     heap;           /* memory heap from which
 
606
                                        these auxiliary structures are
 
607
                                        allocated when needed */
 
608
        ins_node_t*     ins_node;       /* Innobase SQL insert node
 
609
                                        used to perform inserts
 
610
                                        to the table */
 
611
        byte*           ins_upd_rec_buff;/* buffer for storing data converted
 
612
                                        to the Innobase format from the MySQL
 
613
                                        format */
 
614
        ulint           hint_need_to_fetch_extra_cols;
 
615
                                        /* normally this is set to 0; if this
 
616
                                        is set to ROW_RETRIEVE_PRIMARY_KEY,
 
617
                                        then we should at least retrieve all
 
618
                                        columns in the primary key; if this
 
619
                                        is set to ROW_RETRIEVE_ALL_COLS, then
 
620
                                        we must retrieve all columns in the
 
621
                                        key (if read_just_key == 1), or all
 
622
                                        columns in the table */
 
623
        upd_node_t*     upd_node;       /* Innobase SQL update node used
 
624
                                        to perform updates and deletes */
 
625
        que_fork_t*     ins_graph;      /* Innobase SQL query graph used
 
626
                                        in inserts */
 
627
        que_fork_t*     upd_graph;      /* Innobase SQL query graph used
 
628
                                        in updates or deletes */
 
629
        btr_pcur_t*     pcur;           /* persistent cursor used in selects
 
630
                                        and updates */
 
631
        btr_pcur_t*     clust_pcur;     /* persistent cursor used in
 
632
                                        some selects and updates */
 
633
        que_fork_t*     sel_graph;      /* dummy query graph used in
 
634
                                        selects */
 
635
        dtuple_t*       search_tuple;   /* prebuilt dtuple used in selects */
 
636
        byte            row_id[DATA_ROW_ID_LEN];
 
637
                                        /* if the clustered index was
 
638
                                        generated, the row id of the
 
639
                                        last row fetched is stored
 
640
                                        here */
 
641
        dtuple_t*       clust_ref;      /* prebuilt dtuple used in
 
642
                                        sel/upd/del */
 
643
        ulint           select_lock_type;/* LOCK_NONE, LOCK_S, or LOCK_X */
 
644
        ulint           stored_select_lock_type;/* this field is used to
 
645
                                        remember the original select_lock_type
 
646
                                        that was decided in ha_innodb.cc,
 
647
                                        ::store_lock(), ::external_lock(),
 
648
                                        etc. */
 
649
        ulint           row_read_type;  /* ROW_READ_WITH_LOCKS if row locks
 
650
                                        should be the obtained for records
 
651
                                        under an UPDATE or DELETE cursor.
 
652
                                        If innodb_locks_unsafe_for_binlog
 
653
                                        is TRUE, this can be set to
 
654
                                        ROW_READ_TRY_SEMI_CONSISTENT, so that
 
655
                                        if the row under an UPDATE or DELETE
 
656
                                        cursor was locked by another
 
657
                                        transaction, InnoDB will resort
 
658
                                        to reading the last committed value
 
659
                                        ('semi-consistent read').  Then,
 
660
                                        this field will be set to
 
661
                                        ROW_READ_DID_SEMI_CONSISTENT to
 
662
                                        indicate that.  If the row does not
 
663
                                        match the WHERE condition, MySQL will
 
664
                                        invoke handler::unlock_row() to
 
665
                                        clear the flag back to
 
666
                                        ROW_READ_TRY_SEMI_CONSISTENT and
 
667
                                        to simply skip the row.  If
 
668
                                        the row matches, the next call to
 
669
                                        row_search_for_mysql() will lock
 
670
                                        the row.
 
671
                                        This eliminates lock waits in some
 
672
                                        cases; note that this breaks
 
673
                                        serializability. */
 
674
        ulint           mysql_prefix_len;/* byte offset of the end of
 
675
                                        the last requested column */
 
676
        ulint           mysql_row_len;  /* length in bytes of a row in the
 
677
                                        MySQL format */
 
678
        ulint           n_rows_fetched; /* number of rows fetched after
 
679
                                        positioning the current cursor */
 
680
        ulint           fetch_direction;/* ROW_SEL_NEXT or ROW_SEL_PREV */
 
681
        byte*           fetch_cache[MYSQL_FETCH_CACHE_SIZE];
 
682
                                        /* a cache for fetched rows if we
 
683
                                        fetch many rows from the same cursor:
 
684
                                        it saves CPU time to fetch them in a
 
685
                                        batch; we reserve mysql_row_len
 
686
                                        bytes for each such row; these
 
687
                                        pointers point 4 bytes past the
 
688
                                        allocated mem buf start, because
 
689
                                        there is a 4 byte magic number at the
 
690
                                        start and at the end */
 
691
        ibool           keep_other_fields_on_keyread; /* when using fetch
 
692
                                        cache with HA_EXTRA_KEYREAD, don't
 
693
                                        overwrite other fields in mysql row
 
694
                                        row buffer.*/
 
695
        ulint           fetch_cache_first;/* position of the first not yet
 
696
                                        fetched row in fetch_cache */
 
697
        ulint           n_fetch_cached; /* number of not yet fetched rows
 
698
                                        in fetch_cache */
 
699
        mem_heap_t*     blob_heap;      /* in SELECTS BLOB fields are copied
 
700
                                        to this heap */
 
701
        mem_heap_t*     old_vers_heap;  /* memory heap where a previous
 
702
                                        version is built in consistent read */
 
703
        /*----------------------*/
 
704
        ib_uint64_t     autoinc_last_value;/* last value of AUTO-INC interval */
 
705
        ib_uint64_t     autoinc_increment;/* The increment step of the auto 
 
706
                                        increment column. Value must be
 
707
                                        greater than or equal to 1. Required to
 
708
                                        calculate the next value */
 
709
        ib_uint64_t     autoinc_offset; /* The offset passed to
 
710
                                        get_auto_increment() by MySQL. Required
 
711
                                        to calculate the next value */
 
712
        ulint           autoinc_error;  /* The actual error code encountered
 
713
                                        while trying to init or read the
 
714
                                        autoinc value from the table. We
 
715
                                        store it here so that we can return
 
716
                                        it to MySQL */
 
717
        /*----------------------*/
 
718
        UT_LIST_NODE_T(row_prebuilt_t)  prebuilts;
 
719
                                        /* list node of table->prebuilts */
 
720
        index_cond_func_t idx_cond_func;/* Index Condition Pushdown function,
 
721
                                        or NULL if there is none set */
 
722
        void*           idx_cond_func_arg;/* ICP function  argument */
 
723
        ulint           n_index_fields; /* Number of fields at the start of
 
724
                                        mysql_template. Valid only when using
 
725
                                        ICP. */
 
726
        ulint           magic_n2;       /* this should be the same as
 
727
                                        magic_n */
 
728
};
 
729
 
 
730
#define ROW_PREBUILT_FETCH_MAGIC_N      465765687
 
731
 
 
732
#define ROW_MYSQL_WHOLE_ROW     0
 
733
#define ROW_MYSQL_REC_FIELDS    1
 
734
#define ROW_MYSQL_NO_TEMPLATE   2
 
735
#define ROW_MYSQL_DUMMY_TEMPLATE 3      /* dummy template used in
 
736
                                        row_scan_and_check_index */
 
737
 
 
738
/* Values for hint_need_to_fetch_extra_cols */
 
739
#define ROW_RETRIEVE_PRIMARY_KEY        1
 
740
#define ROW_RETRIEVE_ALL_COLS           2
 
741
 
 
742
/* Values for row_read_type */
 
743
#define ROW_READ_WITH_LOCKS             0
 
744
#define ROW_READ_TRY_SEMI_CONSISTENT    1
 
745
#define ROW_READ_DID_SEMI_CONSISTENT    2
 
746
 
 
747
#ifndef UNIV_NONINL
 
748
#include "row0mysql.ic"
 
749
#endif
 
750
 
 
751
#endif