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