← 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-11-16 05:36:13 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116053613-bld4rqxhlkb49c02
Split out cache_row and type_holder.

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 an AUTO_INC type lock possibly reserved by trx. */
 
167
UNIV_INTERN
 
168
void
 
169
row_unlock_table_autoinc_for_mysql(
 
170
/*===============================*/
 
171
        trx_t*  trx);   /* in: 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: table definition */
 
343
        trx_t*          trx);           /* in: transaction handle */
 
344
/*************************************************************************
 
345
Does an index creation operation for MySQL. TODO: currently failure
 
346
to create an index results in dropping the whole table! This is no problem
 
347
currently as all indexes must be created at the same time as the table. */
 
348
UNIV_INTERN
 
349
int
 
350
row_create_index_for_mysql(
 
351
/*=======================*/
 
352
                                        /* out: error number or DB_SUCCESS */
 
353
        dict_index_t*   index,          /* in: index definition */
 
354
        trx_t*          trx,            /* in: transaction handle */
 
355
        const ulint*    field_lengths); /* in: if not NULL, must contain
 
356
                                        dict_index_get_n_fields(index)
 
357
                                        actual field lengths for the
 
358
                                        index columns, which are
 
359
                                        then checked for not being too
 
360
                                        large. */
 
361
/*************************************************************************
 
362
Scans a table create SQL string and adds to the data dictionary
 
363
the foreign key constraints declared in the string. This function
 
364
should be called after the indexes for a table have been created.
 
365
Each foreign key constraint must be accompanied with indexes in
 
366
bot participating tables. The indexes are allowed to contain more
 
367
fields than mentioned in the constraint. */
 
368
UNIV_INTERN
 
369
int
 
370
row_table_add_foreign_constraints(
 
371
/*==============================*/
 
372
                                        /* out: error code or DB_SUCCESS */
 
373
        trx_t*          trx,            /* in: transaction */
 
374
        const char*     sql_string,     /* in: table create statement where
 
375
                                        foreign keys are declared like:
 
376
                                FOREIGN KEY (a, b) REFERENCES table2(c, d),
 
377
                                        table2 can be written also with the
 
378
                                        database name before it: test.table2 */
 
379
        const char*     name,           /* in: table full name in the
 
380
                                        normalized form
 
381
                                        database_name/table_name */
 
382
        ibool           reject_fks);    /* in: if TRUE, fail with error
 
383
                                        code DB_CANNOT_ADD_CONSTRAINT if
 
384
                                        any foreign keys are found. */
 
385
 
 
386
/*************************************************************************
 
387
The master thread in srv0srv.c calls this regularly to drop tables which
 
388
we must drop in background after queries to them have ended. Such lazy
 
389
dropping of tables is needed in ALTER TABLE on Unix. */
 
390
UNIV_INTERN
 
391
ulint
 
392
row_drop_tables_for_mysql_in_background(void);
 
393
/*=========================================*/
 
394
                                        /* out: how many tables dropped
 
395
                                        + remaining tables in list */
 
396
/*************************************************************************
 
397
Get the background drop list length. NOTE: the caller must own the kernel
 
398
mutex! */
 
399
UNIV_INTERN
 
400
ulint
 
401
row_get_background_drop_list_len_low(void);
 
402
/*======================================*/
 
403
                                        /* out: how many tables in list */
 
404
/*************************************************************************
 
405
Truncates a table for MySQL. */
 
406
UNIV_INTERN
 
407
int
 
408
row_truncate_table_for_mysql(
 
409
/*=========================*/
 
410
                                /* out: error code or DB_SUCCESS */
 
411
        dict_table_t*   table,  /* in: table handle */
 
412
        trx_t*          trx);   /* in: transaction handle */
 
413
/*************************************************************************
 
414
Drops a table for MySQL. If the name of the dropped table ends in
 
415
one of "innodb_monitor", "innodb_lock_monitor", "innodb_tablespace_monitor",
 
416
"innodb_table_monitor", then this will also stop the printing of monitor
 
417
output by the master thread. */
 
418
UNIV_INTERN
 
419
int
 
420
row_drop_table_for_mysql(
 
421
/*=====================*/
 
422
                                /* out: error code or DB_SUCCESS */
 
423
        const char*     name,   /* in: table name */
 
424
        trx_t*          trx,    /* in: transaction handle */
 
425
        ibool           drop_db);/* in: TRUE=dropping whole database */
 
426
 
 
427
/*************************************************************************
 
428
Drops a table for MySQL but does not commit the transaction.  If the
 
429
name of the dropped table ends in one of "innodb_monitor",
 
430
"innodb_lock_monitor", "innodb_tablespace_monitor",
 
431
"innodb_table_monitor", then this will also stop the printing of
 
432
monitor output by the master thread. */
 
433
UNIV_INTERN
 
434
int
 
435
row_drop_table_for_mysql_no_commit(
 
436
/*===============================*/
 
437
                                /* out: error code or DB_SUCCESS */
 
438
        const char*     name,   /* in: table name */
 
439
        trx_t*          trx,    /* in: transaction handle */
 
440
        ibool           drop_db);/* in: TRUE=dropping whole database */
 
441
/*************************************************************************
 
442
Discards the tablespace of a table which stored in an .ibd file. Discarding
 
443
means that this function deletes the .ibd file and assigns a new table id for
 
444
the table. Also the flag table->ibd_file_missing is set TRUE. */
 
445
UNIV_INTERN
 
446
int
 
447
row_discard_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
Imports a tablespace. The space id in the .ibd file must match the space id
 
454
of the table in the data dictionary. */
 
455
UNIV_INTERN
 
456
int
 
457
row_import_tablespace_for_mysql(
 
458
/*============================*/
 
459
                                /* out: error code or DB_SUCCESS */
 
460
        const char*     name,   /* in: table name */
 
461
        trx_t*          trx);   /* in: transaction handle */
 
462
/*************************************************************************
 
463
Drops a database for MySQL. */
 
464
UNIV_INTERN
 
465
int
 
466
row_drop_database_for_mysql(
 
467
/*========================*/
 
468
                                /* out: error code or DB_SUCCESS */
 
469
        const char*     name,   /* in: database name which ends to '/' */
 
470
        trx_t*          trx);   /* in: transaction handle */
 
471
/*************************************************************************
 
472
Renames a table for MySQL. */
 
473
UNIV_INTERN
 
474
ulint
 
475
row_rename_table_for_mysql(
 
476
/*=======================*/
 
477
                                        /* out: error code or DB_SUCCESS */
 
478
        const char*     old_name,       /* in: old table name */
 
479
        const char*     new_name,       /* in: new table name */
 
480
        trx_t*          trx,            /* in: transaction handle */
 
481
        ibool           commit);        /* in: if TRUE then commit trx */
 
482
/*************************************************************************
 
483
Checks a table for corruption. */
 
484
UNIV_INTERN
 
485
ulint
 
486
row_check_table_for_mysql(
 
487
/*======================*/
 
488
                                        /* out: DB_ERROR or DB_SUCCESS */
 
489
        row_prebuilt_t* prebuilt);      /* in: prebuilt struct in MySQL
 
490
                                        handle */
 
491
#endif /* !UNIV_HOTBACKUP */
 
492
 
 
493
/*************************************************************************
 
494
Determines if a table is a magic monitor table. */
 
495
UNIV_INTERN
 
496
ibool
 
497
row_is_magic_monitor_table(
 
498
/*=======================*/
 
499
                                        /* out: TRUE if monitor table */
 
500
        const char*     table_name);    /* in: name of the table, in the
 
501
                                        form database/table_name */
 
502
 
 
503
/* A struct describing a place for an individual column in the MySQL
 
504
row format which is presented to the table handler in ha_innobase.
 
505
This template struct is used to speed up row transformations between
 
506
Innobase and MySQL. */
 
507
 
 
508
typedef struct mysql_row_templ_struct mysql_row_templ_t;
 
509
struct mysql_row_templ_struct {
 
510
        ulint   col_no;                 /* column number of the column */
 
511
        ulint   rec_field_no;           /* field number of the column in an
 
512
                                        Innobase record in the current index;
 
513
                                        not defined if template_type is
 
514
                                        ROW_MYSQL_WHOLE_ROW */
 
515
        ulint   mysql_col_offset;       /* offset of the column in the MySQL
 
516
                                        row format */
 
517
        ulint   mysql_col_len;          /* length of the column in the MySQL
 
518
                                        row format */
 
519
        ulint   mysql_null_byte_offset; /* MySQL NULL bit byte offset in a
 
520
                                        MySQL record */
 
521
        ulint   mysql_null_bit_mask;    /* bit mask to get the NULL bit,
 
522
                                        zero if column cannot be NULL */
 
523
        ulint   type;                   /* column type in Innobase mtype
 
524
                                        numbers DATA_CHAR... */
 
525
        ulint   mysql_type;             /* MySQL type code; this is always
 
526
                                        < 256 */
 
527
        ulint   mysql_length_bytes;     /* if mysql_type
 
528
                                        == DATA_MYSQL_TRUE_VARCHAR, this tells
 
529
                                        whether we should use 1 or 2 bytes to
 
530
                                        store the MySQL true VARCHAR data
 
531
                                        length at the start of row in the MySQL
 
532
                                        format (NOTE that the MySQL key value
 
533
                                        format always uses 2 bytes for the data
 
534
                                        len) */
 
535
        ulint   charset;                /* MySQL charset-collation code
 
536
                                        of the column, or zero */
 
537
        ulint   mbminlen;               /* minimum length of a char, in bytes,
 
538
                                        or zero if not a char type */
 
539
        ulint   mbmaxlen;               /* maximum length of a char, in bytes,
 
540
                                        or zero if not a char type */
 
541
        ulint   is_unsigned;            /* if a column type is an integer
 
542
                                        type and this field is != 0, then
 
543
                                        it is an unsigned integer type */
 
544
};
 
545
 
 
546
#define MYSQL_FETCH_CACHE_SIZE          8
 
547
/* After fetching this many rows, we start caching them in fetch_cache */
 
548
#define MYSQL_FETCH_CACHE_THRESHOLD     4
 
549
 
 
550
#define ROW_PREBUILT_ALLOCATED  78540783
 
551
#define ROW_PREBUILT_FREED      26423527
 
552
 
 
553
typedef int64_t (*index_cond_func_t)(void *param);
 
554
 
 
555
/* A struct for (sometimes lazily) prebuilt structures in an Innobase table
 
556
handle used within MySQL; these are used to save CPU time. */
 
557
 
 
558
struct row_prebuilt_struct {
 
559
        ulint           magic_n;        /* this magic number is set to
 
560
                                        ROW_PREBUILT_ALLOCATED when created,
 
561
                                        or ROW_PREBUILT_FREED when the
 
562
                                        struct has been freed */
 
563
        dict_table_t*   table;          /* Innobase table handle */
 
564
        trx_t*          trx;            /* current transaction handle */
 
565
        ibool           sql_stat_start; /* TRUE when we start processing of
 
566
                                        an SQL statement: we may have to set
 
567
                                        an intention lock on the table,
 
568
                                        create a consistent read view etc. */
 
569
        ibool           mysql_has_locked; /* this is set TRUE when MySQL
 
570
                                        calls external_lock on this handle
 
571
                                        with a lock flag, and set FALSE when
 
572
                                        with the F_UNLOCK flag */
 
573
        ibool           clust_index_was_generated;
 
574
                                        /* if the user did not define a
 
575
                                        primary key in MySQL, then Innobase
 
576
                                        automatically generated a clustered
 
577
                                        index where the ordering column is
 
578
                                        the row id: in this case this flag
 
579
                                        is set to TRUE */
 
580
        dict_index_t*   index;          /* current index for a search, if
 
581
                                        any */
 
582
        ulint           read_just_key;  /* set to 1 when MySQL calls
 
583
                                        ha_innobase::extra with the
 
584
                                        argument HA_EXTRA_KEYREAD; it is enough
 
585
                                        to read just columns defined in
 
586
                                        the index (i.e., no read of the
 
587
                                        clustered index record necessary) */
 
588
        ibool           used_in_HANDLER;/* TRUE if we have been using this
 
589
                                        handle in a MySQL HANDLER low level
 
590
                                        index cursor command: then we must
 
591
                                        store the pcur position even in a
 
592
                                        unique search from a clustered index,
 
593
                                        because HANDLER allows NEXT and PREV
 
594
                                        in such a situation */
 
595
        ulint           template_type;  /* ROW_MYSQL_WHOLE_ROW,
 
596
                                        ROW_MYSQL_REC_FIELDS,
 
597
                                        ROW_MYSQL_DUMMY_TEMPLATE, or
 
598
                                        ROW_MYSQL_NO_TEMPLATE */
 
599
        ulint           n_template;     /* number of elements in the
 
600
                                        template */
 
601
        ulint           null_bitmap_len;/* number of bytes in the SQL NULL
 
602
                                        bitmap at the start of a row in the
 
603
                                        MySQL format */
 
604
        ibool           need_to_access_clustered; /* if we are fetching
 
605
                                        columns through a secondary index
 
606
                                        and at least one column is not in
 
607
                                        the secondary index, then this is
 
608
                                        set to TRUE */
 
609
        ibool           templ_contains_blob;/* TRUE if the template contains
 
610
                                        BLOB column(s) */
 
611
        mysql_row_templ_t* mysql_template;/* template used to transform
 
612
                                        rows fast between MySQL and Innobase
 
613
                                        formats; memory for this template
 
614
                                        is not allocated from 'heap' */
 
615
        mem_heap_t*     heap;           /* memory heap from which
 
616
                                        these auxiliary structures are
 
617
                                        allocated when needed */
 
618
        ins_node_t*     ins_node;       /* Innobase SQL insert node
 
619
                                        used to perform inserts
 
620
                                        to the table */
 
621
        byte*           ins_upd_rec_buff;/* buffer for storing data converted
 
622
                                        to the Innobase format from the MySQL
 
623
                                        format */
 
624
        ulint           hint_need_to_fetch_extra_cols;
 
625
                                        /* normally this is set to 0; if this
 
626
                                        is set to ROW_RETRIEVE_PRIMARY_KEY,
 
627
                                        then we should at least retrieve all
 
628
                                        columns in the primary key; if this
 
629
                                        is set to ROW_RETRIEVE_ALL_COLS, then
 
630
                                        we must retrieve all columns in the
 
631
                                        key (if read_just_key == 1), or all
 
632
                                        columns in the table */
 
633
        upd_node_t*     upd_node;       /* Innobase SQL update node used
 
634
                                        to perform updates and deletes */
 
635
        que_fork_t*     ins_graph;      /* Innobase SQL query graph used
 
636
                                        in inserts */
 
637
        que_fork_t*     upd_graph;      /* Innobase SQL query graph used
 
638
                                        in updates or deletes */
 
639
        btr_pcur_t*     pcur;           /* persistent cursor used in selects
 
640
                                        and updates */
 
641
        btr_pcur_t*     clust_pcur;     /* persistent cursor used in
 
642
                                        some selects and updates */
 
643
        que_fork_t*     sel_graph;      /* dummy query graph used in
 
644
                                        selects */
 
645
        dtuple_t*       search_tuple;   /* prebuilt dtuple used in selects */
 
646
        byte            row_id[DATA_ROW_ID_LEN];
 
647
                                        /* if the clustered index was
 
648
                                        generated, the row id of the
 
649
                                        last row fetched is stored
 
650
                                        here */
 
651
        dtuple_t*       clust_ref;      /* prebuilt dtuple used in
 
652
                                        sel/upd/del */
 
653
        ulint           select_lock_type;/* LOCK_NONE, LOCK_S, or LOCK_X */
 
654
        ulint           stored_select_lock_type;/* this field is used to
 
655
                                        remember the original select_lock_type
 
656
                                        that was decided in ha_innodb.cc,
 
657
                                        ::store_lock(), ::external_lock(),
 
658
                                        etc. */
 
659
        ulint           row_read_type;  /* ROW_READ_WITH_LOCKS if row locks
 
660
                                        should be the obtained for records
 
661
                                        under an UPDATE or DELETE cursor.
 
662
                                        If innodb_locks_unsafe_for_binlog
 
663
                                        is TRUE, this can be set to
 
664
                                        ROW_READ_TRY_SEMI_CONSISTENT, so that
 
665
                                        if the row under an UPDATE or DELETE
 
666
                                        cursor was locked by another
 
667
                                        transaction, InnoDB will resort
 
668
                                        to reading the last committed value
 
669
                                        ('semi-consistent read').  Then,
 
670
                                        this field will be set to
 
671
                                        ROW_READ_DID_SEMI_CONSISTENT to
 
672
                                        indicate that.  If the row does not
 
673
                                        match the WHERE condition, MySQL will
 
674
                                        invoke handler::unlock_row() to
 
675
                                        clear the flag back to
 
676
                                        ROW_READ_TRY_SEMI_CONSISTENT and
 
677
                                        to simply skip the row.  If
 
678
                                        the row matches, the next call to
 
679
                                        row_search_for_mysql() will lock
 
680
                                        the row.
 
681
                                        This eliminates lock waits in some
 
682
                                        cases; note that this breaks
 
683
                                        serializability. */
 
684
        ulint           mysql_prefix_len;/* byte offset of the end of
 
685
                                        the last requested column */
 
686
        ulint           mysql_row_len;  /* length in bytes of a row in the
 
687
                                        MySQL format */
 
688
        ulint           n_rows_fetched; /* number of rows fetched after
 
689
                                        positioning the current cursor */
 
690
        ulint           fetch_direction;/* ROW_SEL_NEXT or ROW_SEL_PREV */
 
691
        byte*           fetch_cache[MYSQL_FETCH_CACHE_SIZE];
 
692
                                        /* a cache for fetched rows if we
 
693
                                        fetch many rows from the same cursor:
 
694
                                        it saves CPU time to fetch them in a
 
695
                                        batch; we reserve mysql_row_len
 
696
                                        bytes for each such row; these
 
697
                                        pointers point 4 bytes past the
 
698
                                        allocated mem buf start, because
 
699
                                        there is a 4 byte magic number at the
 
700
                                        start and at the end */
 
701
        ibool           keep_other_fields_on_keyread; /* when using fetch
 
702
                                        cache with HA_EXTRA_KEYREAD, don't
 
703
                                        overwrite other fields in mysql row
 
704
                                        row buffer.*/
 
705
        ulint           fetch_cache_first;/* position of the first not yet
 
706
                                        fetched row in fetch_cache */
 
707
        ulint           n_fetch_cached; /* number of not yet fetched rows
 
708
                                        in fetch_cache */
 
709
        mem_heap_t*     blob_heap;      /* in SELECTS BLOB fields are copied
 
710
                                        to this heap */
 
711
        mem_heap_t*     old_vers_heap;  /* memory heap where a previous
 
712
                                        version is built in consistent read */
 
713
        ib_uint64_t     last_value;     /* last value of AUTO-INC interval */
 
714
        UT_LIST_NODE_T(row_prebuilt_t)  prebuilts;
 
715
                                        /* list node of table->prebuilts */
 
716
        index_cond_func_t idx_cond_func;/* Index Condition Pushdown function,
 
717
                                        or NULL if there is none set */
 
718
        void*           idx_cond_func_arg;/* ICP function  argument */
 
719
        ulint           n_index_fields; /* Number of fields at the start of
 
720
                                        mysql_template. Valid only when using
 
721
                                        ICP. */
 
722
        ulint           magic_n2;       /* this should be the same as
 
723
                                        magic_n */
 
724
};
 
725
 
 
726
#define ROW_PREBUILT_FETCH_MAGIC_N      465765687
 
727
 
 
728
#define ROW_MYSQL_WHOLE_ROW     0
 
729
#define ROW_MYSQL_REC_FIELDS    1
 
730
#define ROW_MYSQL_NO_TEMPLATE   2
 
731
#define ROW_MYSQL_DUMMY_TEMPLATE 3      /* dummy template used in
 
732
                                        row_scan_and_check_index */
 
733
 
 
734
/* Values for hint_need_to_fetch_extra_cols */
 
735
#define ROW_RETRIEVE_PRIMARY_KEY        1
 
736
#define ROW_RETRIEVE_ALL_COLS           2
 
737
 
 
738
/* Values for row_read_type */
 
739
#define ROW_READ_WITH_LOCKS             0
 
740
#define ROW_READ_TRY_SEMI_CONSISTENT    1
 
741
#define ROW_READ_DID_SEMI_CONSISTENT    2
 
742
 
 
743
#ifndef UNIV_NONINL
 
744
#include "row0mysql.ic"
 
745
#endif
 
746
 
 
747
#endif