MySQL  8.0.22
Source Code Documentation
row0mysql.h
Go to the documentation of this file.
1 /*****************************************************************************
2 
3 Copyright (c) 2000, 2020, Oracle and/or its affiliates. All Rights Reserved.
4 
5 This program is free software; you can redistribute it and/or modify it under
6 the terms of the GNU General Public License, version 2.0, as published by the
7 Free Software Foundation.
8 
9 This program is also distributed with certain software (including but not
10 limited to OpenSSL) that is licensed under separate terms, as designated in a
11 particular file or component or in included license documentation. The authors
12 of MySQL hereby grant you an additional permission to link the program and
13 your derivative works with the separately licensed software that they have
14 included with MySQL.
15 
16 This program is distributed in the hope that it will be useful, but WITHOUT
17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18 FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19 for more details.
20 
21 You should have received a copy of the GNU General Public License along with
22 this program; if not, write to the Free Software Foundation, Inc.,
23 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 
25 *****************************************************************************/
26 
27 /** @file include/row0mysql.h
28  Interface between Innobase row operations and MySQL.
29  Contains also create table and other data dictionary operations.
30 
31  Created 9/17/2000 Heikki Tuuri
32  *******************************************************/
33 
34 #ifndef row0mysql_h
35 #define row0mysql_h
36 
37 #ifndef UNIV_HOTBACKUP
38 #include "ha_prototypes.h"
39 #endif /* !UNIV_HOTBACKUP */
40 
41 #include <stddef.h>
42 #include <sys/types.h>
43 
44 #include "btr0pcur.h"
45 #include "data0data.h"
46 #include "data0type.h"
47 #include "db0err.h"
48 #include "dict0types.h"
49 #include "fts0fts.h"
50 #include "gis0type.h"
51 #include "lob0undo.h"
52 #include "lock0types.h"
53 #include "mem0mem.h"
54 #include "my_compiler.h"
55 #include "my_inttypes.h"
56 #include "que0types.h"
57 #include "rem0types.h"
58 #include "row0types.h"
59 #include "sess0sess.h"
60 #include "sql_cmd.h"
61 #include "trx0types.h"
62 #include "univ.i"
63 #include "ut0bool_scope_guard.h"
64 
65 // Forward declarations
66 class THD;
67 class ha_innobase;
68 class innodb_session_t;
69 namespace dd {
70 class Table;
71 }
72 struct TABLE;
73 struct btr_pcur_t;
74 struct dfield_t;
75 struct dict_field_t;
76 struct dict_foreign_t;
77 struct dict_index_t;
78 struct dict_table_t;
79 struct dict_v_col_t;
80 struct dtuple_t;
81 struct ins_node_t;
82 struct mtr_t;
83 struct que_fork_t;
84 struct que_thr_t;
85 struct trx_t;
86 struct upd_node_t;
87 struct upd_t;
88 
89 #ifndef UNIV_HOTBACKUP
90 extern ibool row_rollback_on_timeout;
91 
92 struct row_prebuilt_t;
93 
94 /** Frees the blob heap in prebuilt when no longer needed. */
96  row_prebuilt_t *prebuilt); /*!< in: prebuilt struct of a
97  ha_innobase:: table handle */
98 /** Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row
99  format.
100  @return pointer to the data, we skip the 1 or 2 bytes at the start
101  that are used to store the len */
103  byte *dest, /*!< in: where to store */
104  ulint len, /*!< in: length, must fit in two bytes */
105  ulint lenlen); /*!< in: storage length of len: either 1 or 2 bytes */
106 /** Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and
107  returns a pointer to the data.
108  @return pointer to the data, we skip the 1 or 2 bytes at the start
109  that are used to store the len */
111  ulint *len, /*!< out: variable-length field length */
112  const byte *field, /*!< in: field in the MySQL format */
113  ulint lenlen); /*!< in: storage length of len: either 1
114  or 2 bytes */
115 
116 /** Stores a reference to a BLOB in the MySQL format.
117 @param[in] dest Where to store
118 @param[in,out] col_len Dest buffer size: determines into how many bytes the blob
119 length is stored, the space for the length may vary from 1 to 4 bytes
120 @param[in] data Blob data; if the value to store is sql null this should be null
121 pointer
122 @param[in] len Blob length; if the value to store is sql null this should be 0;
123 remember also to set the null bit in the mysql record header! */
124 void row_mysql_store_blob_ref(byte *dest, ulint col_len, const void *data,
125  ulint len);
126 
127 /** Reads a reference to a BLOB in the MySQL format.
128 @param[out] len BLOB length.
129 @param[in] ref BLOB reference in the MySQL format.
130 @param[in] col_len BLOB reference length (not BLOB length).
131 @return pointer to BLOB data */
132 const byte *row_mysql_read_blob_ref(ulint *len, const byte *ref, ulint col_len);
133 
134 /** Converts InnoDB geometry data format to MySQL data format. */
136  byte *dest, /*!< in/out: where to store */
137  ulint dest_len, /*!< in: dest buffer size: determines into
138  how many bytes the geometry length is stored,
139  the space for the length may vary from 1
140  to 4 bytes */
141  const byte *src, /*!< in: geometry data; if the value to store
142  is SQL NULL this should be NULL pointer */
143  ulint src_len); /*!< in: geometry length; if the value to store
144  is SQL NULL this should be 0; remember
145  also to set the NULL bit in the MySQL record
146  header! */
147 
148 /** Pad a column with spaces.
149 @param[in] mbminlen Minimum size of a character, in bytes
150 @param[out] pad Padded buffer
151 @param[in] len Number of bytes to pad */
152 void row_mysql_pad_col(ulint mbminlen, byte *pad, ulint len);
153 
154 /** Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.
155  The counterpart of this function is row_sel_field_store_in_mysql_format() in
156  row0sel.cc.
157  @return up to which byte we used buf in the conversion */
159  dfield_t *dfield, /*!< in/out: dfield where dtype
160  information must be already set when
161  this function is called! */
162  byte *buf, /*!< in/out: buffer for a converted
163  integer value; this must be at least
164  col_len long then! NOTE that dfield
165  may also get a pointer to 'buf',
166  therefore do not discard this as long
167  as dfield is used! */
168  ibool row_format_col, /*!< TRUE if the mysql_data is from
169  a MySQL row, FALSE if from a MySQL
170  key value;
171  in MySQL, a true VARCHAR storage
172  format differs in a row and in a
173  key value: in a key value the length
174  is always stored in 2 bytes! */
175  const byte *mysql_data, /*!< in: MySQL column value, not
176  SQL NULL; NOTE that dfield may also
177  get a pointer to mysql_data,
178  therefore do not discard this as long
179  as dfield is used! */
180  ulint col_len, /*!< in: MySQL column length; NOTE that
181  this is the storage length of the
182  column in the MySQL format row, not
183  necessarily the length of the actual
184  payload data; if the column is a true
185  VARCHAR then this is irrelevant */
186  ulint comp); /*!< in: nonzero=compact format */
187 /** Handles user errors and lock waits detected by the database engine.
188  @return true if it was a lock wait and we should continue running the
189  query thread */
191  dberr_t *new_err, /*!< out: possible new error encountered in
192  rollback, or the old error which was
193  during the function entry */
194  trx_t *trx, /*!< in: transaction */
195  que_thr_t *thr, /*!< in: query thread, or NULL */
196  trx_savept_t *savept); /*!< in: savepoint, or NULL */
197 /** Create a prebuilt struct for a MySQL table handle.
198  @return own: a prebuilt struct */
200  dict_table_t *table, /*!< in: Innobase table handle */
201  ulint mysql_row_len); /*!< in: length in bytes of a row in
202  the MySQL format */
203 
204 /** Free a prebuilt struct for a MySQL table handle.
205 @param[in,out] prebuilt Prebuilt struct
206 @param[in] dict_locked True=data dictionary locked */
207 void row_prebuilt_free(row_prebuilt_t *prebuilt, ibool dict_locked);
208 
209 /** Updates the transaction pointers in query graphs stored in the prebuilt
210 struct.
211 @param[in,out] prebuilt Prebuilt struct in MySQL handle.
212 @param[in,out] trx Transaction handle. */
214 
215 /** Sets an AUTO_INC type lock on the table mentioned in prebuilt. The
216  AUTO_INC lock gives exclusive access to the auto-inc counter of the
217  table. The lock is reserved only for the duration of an SQL statement.
218  It is not compatible with another AUTO_INC or exclusive lock on the
219  table.
220  @return error code or DB_SUCCESS */
222  row_prebuilt_t *prebuilt) /*!< in: prebuilt struct in the MySQL
223  table handle */
224  MY_ATTRIBUTE((warn_unused_result));
225 
226 /** Sets a table lock on the table mentioned in prebuilt.
227 @param[in,out] prebuilt table handle
228 @return error code or DB_SUCCESS */
230 
231 /** Does an insert for MySQL.
232 @param[in] mysql_rec row in the MySQL format
233 @param[in,out] prebuilt prebuilt struct in MySQL handle
234 @return error code or DB_SUCCESS*/
235 dberr_t row_insert_for_mysql(const byte *mysql_rec, row_prebuilt_t *prebuilt)
236  MY_ATTRIBUTE((warn_unused_result));
237 
238 /** Builds a dummy query graph used in selects. */
239 void row_prebuild_sel_graph(row_prebuilt_t *prebuilt); /*!< in: prebuilt struct
240  in MySQL handle */
241 /** Gets pointer to a prebuilt update vector used in updates. If the update
242  graph has not yet been built in the prebuilt struct, then this function
243  first builds it.
244  @return prebuilt update vector */
246  row_prebuilt_t *prebuilt); /*!< in: prebuilt struct in MySQL
247  handle */
248 /** Checks if a table is such that we automatically created a clustered
249  index on it (on row id).
250  @return true if the clustered index was generated automatically */
252  const dict_table_t *table); /*!< in: table */
253 
254 /** Does an update or delete of a row for MySQL.
255 @param[in] mysql_rec row in the MySQL format
256 @param[in,out] prebuilt prebuilt struct in MySQL handle
257 @return error code or DB_SUCCESS */
258 dberr_t row_update_for_mysql(const byte *mysql_rec, row_prebuilt_t *prebuilt)
259  MY_ATTRIBUTE((warn_unused_result));
260 
261 /** Delete all rows for the given table by freeing/truncating indexes.
262 @param[in,out] table table handler */
264 
265 /** This can only be used when this session is using a READ COMMITTED or READ
266 UNCOMMITTED isolation level. Before calling this function
267 row_search_for_mysql() must have initialized prebuilt->new_rec_locks to store
268 the information which new record locks really were set. This function removes
269 a newly set clustered index record lock under prebuilt->pcur or
270 prebuilt->clust_pcur. Thus, this implements a 'mini-rollback' that releases
271 the latest clustered index record lock we set.
272 
273 @param[in,out] prebuilt prebuilt struct in MySQL handle
274 @param[in] has_latches_on_recs TRUE if called so that we have the
275  latches on the records under pcur
276  and clust_pcur, and we do not need
277  to reposition the cursors. */
278 void row_unlock_for_mysql(row_prebuilt_t *prebuilt, ibool has_latches_on_recs);
279 #endif /* !UNIV_HOTBACKUP */
280 
281 /** Checks if a table name contains the string "/#sql" which denotes temporary
282  tables in MySQL.
283  @return true if temporary table */
284 bool row_is_mysql_tmp_table_name(const char *name)
285  MY_ATTRIBUTE((warn_unused_result));
286 /*!< in: table name in the form
287 'database/tablename' */
288 
289 #ifndef UNIV_HOTBACKUP
290 /** Creates an query graph node of 'update' type to be used in the MySQL
291  interface.
292  @return own: update node */
294  dict_table_t *table, /*!< in: table to update */
295  mem_heap_t *heap); /*!< in: mem heap from which allocated */
296 /** Does a cascaded delete or set null in a foreign key operation.
297  @return error code or DB_SUCCESS */
299  que_thr_t *thr, /*!< in: query thread */
300  upd_node_t *node, /*!< in: update node used in the cascade
301  or set null operation */
302  dict_table_t *table) /*!< in: table where we do the operation */
303  MY_ATTRIBUTE((nonnull, warn_unused_result));
304 
305 /** Locks the data dictionary exclusively for performing a table create or other
306  data dictionary modification operation.
307 @param[in,out] trx Transaction
308 @param[in] file File name
309 @param[in] line Line number */
311  ulint line);
312 
313 #define row_mysql_lock_data_dictionary(trx) \
314  row_mysql_lock_data_dictionary_func(trx, __FILE__, __LINE__)
315 /** Unlocks the data dictionary exclusive lock. */
316 void row_mysql_unlock_data_dictionary(trx_t *trx); /*!< in/out: transaction */
317 
318 /** Locks the data dictionary in shared mode from modifications, for performing
319  foreign key check, rollback, or other operation invisible to MySQL.
320 @param[in,out] trx Transaction
321 @param[in] file File name
322 @param[in] line Line number */
324  ulint line);
325 
326 #define row_mysql_freeze_data_dictionary(trx) \
327  row_mysql_freeze_data_dictionary_func(trx, __FILE__, __LINE__)
328 /** Unlocks the data dictionary shared lock. */
329 void row_mysql_unfreeze_data_dictionary(trx_t *trx); /*!< in/out: transaction */
330 
331 /** Creates a table for MySQL. On success the in-memory table could be
332 kept in non-LRU list while on failure the 'table' object will be freed.
333 @param[in] table table definition(will be freed, or on
334  DB_SUCCESS added to the data dictionary cache)
335 @param[in] compression compression algorithm to use, can be nullptr
336 @param[in,out] trx transaction
337 @return error code or DB_SUCCESS */
338 dberr_t row_create_table_for_mysql(dict_table_t *table, const char *compression,
339  trx_t *trx)
340  MY_ATTRIBUTE((warn_unused_result));
341 
342 /** Does an index creation operation for MySQL. TODO: currently failure
343  to create an index results in dropping the whole table! This is no problem
344  currently as all indexes must be created at the same time as the table.
345  @return error number or DB_SUCCESS */
347  dict_index_t *index, /*!< in, own: index definition
348  (will be freed) */
349  trx_t *trx, /*!< in: transaction handle */
350  const ulint *field_lengths, /*!< in: if not NULL, must contain
351  dict_index_get_n_fields(index)
352  actual field lengths for the
353  index columns, which are
354  then checked for not being too
355  large. */
356  dict_table_t *handler) /* ! in/out: table handler. */
357  MY_ATTRIBUTE((warn_unused_result));
358 
359 /** Loads foreign key constraints for the table being created. This
360  function should be called after the indexes for a table have been
361  created. Each foreign key constraint must be accompanied with indexes
362  in both participating tables. The indexes are allowed to contain more
363  fields than mentioned in the constraint.
364 
365  @param[in] trx transaction
366  @param[in] name table full name in normalized form
367  @param[in] dd_table MySQL dd::Table for the table
368  @return error code or DB_SUCCESS */
370  const dd::Table *dd_table)
371  MY_ATTRIBUTE((warn_unused_result));
372 
373 /** The master thread in srv0srv.cc calls this regularly to drop tables which
374  we must drop in background after queries to them have ended. Such lazy
375  dropping of tables is needed in ALTER TABLE on Unix.
376  @return how many tables dropped + remaining tables in list */
378 /** Get the background drop list length. NOTE: the caller must own the kernel
379  mutex!
380  @return how many tables in list */
382 
383 /** Sets an exclusive lock on a table.
384  @return error code or DB_SUCCESS */
386  trx_t *trx, /*!< in/out: transaction */
387  dict_table_t *table, /*!< in: table to lock */
388  enum lock_mode mode, /*!< in: LOCK_X or LOCK_S */
389  const char *op_info) /*!< in: string for trx->op_info */
390  MY_ATTRIBUTE((warn_unused_result));
391 
392 /** Drop a tablespace as part of dropping or renaming a table.
393 This deletes the fil_space_t if found and the file on disk.
394 @param[in] space_id Tablespace ID
395 @param[in] filepath File path of tablespace to delete
396 @return error code or DB_SUCCESS */
397 dberr_t row_drop_tablespace(space_id_t space_id, const char *filepath);
398 
399 /** Drop a table for MySQL. If the data dictionary was not already locked
400 by the transaction, the transaction will be committed. Otherwise, the
401 data dictionary will remain locked.
402 @param[in] name Table name
403 @param[in] trx Transaction handle
404 @param[in] nonatomic Whether it is permitted to release
405 and reacquire dict_operation_lock
406 @param[in,out] handler Table handler or NULL
407 @return error code or DB_SUCCESS */
408 dberr_t row_drop_table_for_mysql(const char *name, trx_t *trx, bool nonatomic,
409  dict_table_t *handler = nullptr);
410 /** Drop a table for MySQL. If the data dictionary was not already locked
411 by the transaction, the transaction will be committed. Otherwise, the
412 data dictionary will remain locked.
413 @param[in] name table name
414 @param[in,out] trx data dictionary transaction
415 @return error code or DB_SUCCESS */
417  return (row_drop_table_for_mysql(name, trx, true, nullptr));
418 }
419 
420 /** Discards the tablespace of a table which stored in an .ibd file. Discarding
421  means that this function deletes the .ibd file and assigns a new table id for
422  the table. Also the flag table->ibd_file_missing is set TRUE.
423  @return error code or DB_SUCCESS */
425  const char *name, /*!< in: table name */
426  trx_t *trx) /*!< in: transaction handle */
427  MY_ATTRIBUTE((warn_unused_result));
428 /** Imports a tablespace. The space id in the .ibd file must match the space id
429  of the table in the data dictionary.
430  @return error code or DB_SUCCESS */
432  dict_table_t *table, /*!< in/out: table */
433  row_prebuilt_t *prebuilt) /*!< in: prebuilt struct in MySQL */
434  MY_ATTRIBUTE((warn_unused_result));
435 
436 /** Drop a database for MySQL.
437 @param[in] name database name which ends at '/'
438 @param[in] trx transaction handle
439 @param[out] found number of dropped tables
440 @return error code or DB_SUCCESS */
441 dberr_t row_drop_database_for_mysql(const char *name, trx_t *trx, ulint *found);
442 
443 /** Renames a table for MySQL.
444 @param[in] old_name old table name
445 @param[in] new_name new table name
446 @param[in] dd_table dd::Table for new table
447 @param[in,out] trx transaction
448 @param[in] replay whether in replay stage
449 @return error code or DB_SUCCESS */
450 dberr_t row_rename_table_for_mysql(const char *old_name, const char *new_name,
451  const dd::Table *dd_table, trx_t *trx,
452  bool replay)
453  MY_ATTRIBUTE((warn_unused_result));
454 
455 /** Read the total number of records in a consistent view.
456 @param[in,out] trx Covering transaction.
457 @param[in] indexes Indexes to scan.
458 @param[in] max_threads Maximum number of threads to use.
459 @param[out] n_rows Number of rows seen.
460 @return DB_SUCCESS or error code. */
462  trx_t *trx, std::vector<dict_index_t *> &indexes, size_t max_threads,
463  ulint *n_rows);
464 
465 /** Scans an index for either COUNT(*) or CHECK TABLE.
466 If CHECK TABLE; Checks that the index contains entries in an ascending order,
467 unique constraint is not broken, and calculates the number of index entries
468 in the read view of the current transaction.
469 @param[in,out] prebuilt Prebuilt struct in MySQL handle.
470 @param[in,out] index Index to scan.
471 @param[in] n_threads Number of threads to use for the scan
472 @param[in] check_keys True if called form check table.
473 @param[out] n_rows Number of entries seen in the consistent read.
474 @return DB_SUCCESS or other error */
476  size_t n_threads, bool check_keys,
477  ulint *n_rows)
478  MY_ATTRIBUTE((warn_unused_result));
479 /** Initialize this module */
480 void row_mysql_init(void);
481 
482 /** Close this module */
483 void row_mysql_close(void);
484 
485 /* A struct describing a place for an individual column in the MySQL
486 row format which is presented to the table handler in ha_innobase.
487 This template struct is used to speed up row transformations between
488 Innobase and MySQL. */
489 
491  ulint col_no; /*!< column number of the column */
492  ulint rec_field_no; /*!< field number of the column in an
493  Innobase record in the current index;
494  not defined if template_type is
495  ROW_MYSQL_WHOLE_ROW */
496  ulint clust_rec_field_no; /*!< field number of the column in an
497  Innobase record in the clustered index;
498  not defined if template_type is
499  ROW_MYSQL_WHOLE_ROW */
500  ulint icp_rec_field_no; /*!< field number of the column in an
501  Innobase record in the current index;
502  only defined for columns that could be
503  used to evaluate a pushed down index
504  condition and/or end-range condition */
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_mvidx_len; /*!< index length on multi-value array */
510  ulint mysql_null_byte_offset; /*!< MySQL NULL bit byte offset in a
511  MySQL record */
512  ulint mysql_null_bit_mask; /*!< bit mask to get the NULL bit,
513  zero if column cannot be NULL */
514  ulint type; /*!< column type in Innobase mtype
515  numbers DATA_CHAR... */
516  ulint mysql_type; /*!< MySQL type code; this is always
517  < 256 */
518  ulint mysql_length_bytes; /*!< if mysql_type
519  == DATA_MYSQL_TRUE_VARCHAR, this tells
520  whether we should use 1 or 2 bytes to
521  store the MySQL true VARCHAR data
522  length at the start of row in the MySQL
523  format (NOTE that the MySQL key value
524  format always uses 2 bytes for the data
525  len) */
526  ulint charset; /*!< MySQL charset-collation code
527  of the column, or zero */
528  ulint mbminlen; /*!< minimum length of a char, in bytes,
529  or zero if not a char type */
530  ulint mbmaxlen; /*!< maximum length of a char, in bytes,
531  or zero if not a char type */
532  ulint is_unsigned; /*!< if a column type is an integer
533  type and this field is != 0, then
534  it is an unsigned integer type */
535  ulint is_virtual; /*!< if a column is a virtual column */
536  ulint is_multi_val; /*!< if a column is a Multi-Value Array virtual
537  column */
538 };
539 
540 #define MYSQL_FETCH_CACHE_SIZE 8
541 /* After fetching this many rows, we start caching them in fetch_cache */
542 #define MYSQL_FETCH_CACHE_THRESHOLD 4
543 
544 #define ROW_PREBUILT_ALLOCATED 78540783
545 #define ROW_PREBUILT_FREED 26423527
546 
547 /** A struct for (sometimes lazily) prebuilt structures in an Innobase table
548 handle used within MySQL; these are used to save CPU time. */
549 
551  ulint magic_n; /*!< this magic number is set to
552  ROW_PREBUILT_ALLOCATED when created,
553  or ROW_PREBUILT_FREED when the
554  struct has been freed */
555  dict_table_t *table; /*!< Innobase table handle */
556  dict_index_t *index; /*!< current index for a search, if
557  any */
558  trx_t *trx; /*!< current transaction handle */
559  unsigned sql_stat_start : 1; /*!< TRUE when we start processing of
560  an SQL statement: we may have to set
561  an intention lock on the table,
562  create a consistent read view etc. */
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  unsigned index_usable : 1; /*!< caches the value of
571  index->is_usable(trx) */
572  unsigned read_just_key : 1; /*!< 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  unsigned used_in_HANDLER : 1; /*!< 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  unsigned template_type : 2; /*!< ROW_MYSQL_WHOLE_ROW,
586  ROW_MYSQL_REC_FIELDS,
587  ROW_MYSQL_DUMMY_TEMPLATE, or
588  ROW_MYSQL_NO_TEMPLATE */
589  unsigned n_template : 10; /*!< number of elements in the
590  template */
591  unsigned null_bitmap_len : 10; /*!< number of bytes in the SQL NULL
592  bitmap at the start of a row in the
593  MySQL format */
594  unsigned need_to_access_clustered : 1; /*!< 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  unsigned templ_contains_blob : 1; /*!< TRUE if the template contains
600  a column with DATA_LARGE_MTYPE(
601  get_innobase_type_from_mysql_type())
602  is TRUE;
603  not to be confused with InnoDB
604  externally stored columns
605  (VARCHAR can be off-page too) */
606  unsigned templ_contains_fixed_point : 1; /*!< TRUE if the
607  template contains a column with
608  DATA_POINT. Since InnoDB regards
609  DATA_POINT as non-BLOB type, the
610  templ_contains_blob can't tell us
611  if there is DATA_POINT */
612 
613  /** 1 if extra(HA_EXTRA_INSERT_WITH_UPDATE) was requested, which happens
614  when ON DUPLICATE KEY UPDATE clause is present, 0 otherwise */
616 
617  /** 1 if extra(HA_EXTRA_WRITE_CAN_REPLACE) was requested, which happen when
618  REPLACE is done instead of regular INSERT, 0 otherwise */
619  unsigned replace : 1;
620 
621  /** template used to transform rows fast between MySQL and Innobase formats;
622  memory for this template is not allocated from 'heap' */
624 
625  /** memory heap from which these auxiliary structures are allocated when
626  needed */
628 
629  /** memory heap from which innodb_api_buf is allocated per session */
631 
632  /** Innobase SQL insert node used to perform inserts to the table */
634 
635  /** buffer for storing data converted to the Innobase format from the MySQL
636  format */
638 
639  /* buffer for converting data format for multi-value virtual columns */
641  const byte *default_rec; /*!< the default values of all columns
642  (a "default row") in MySQL format */
644  /*!< normally this is set to 0; if this
645  is set to ROW_RETRIEVE_PRIMARY_KEY,
646  then we should at least retrieve all
647  columns in the primary key; if this
648  is set to ROW_RETRIEVE_ALL_COLS, then
649  we must retrieve all columns in the
650  key (if read_just_key == 1), or all
651  columns in the table */
652  upd_node_t *upd_node; /*!< Innobase SQL update node used
653  to perform updates and deletes */
654  trx_id_t trx_id; /*!< The table->def_trx_id when
655  ins_graph was built */
656  que_fork_t *ins_graph; /*!< Innobase SQL query graph used
657  in inserts. Will be rebuilt on
658  trx_id or n_indexes mismatch. */
659  que_fork_t *upd_graph; /*!< Innobase SQL query graph used
660  in updates or deletes */
661  btr_pcur_t *pcur; /*!< persistent cursor used in selects
662  and updates */
663  btr_pcur_t *clust_pcur; /*!< persistent cursor used in
664  some selects and updates */
665  que_fork_t *sel_graph; /*!< dummy query graph used in
666  selects */
667  dtuple_t *search_tuple; /*!< prebuilt dtuple used in selects */
668 
669  /** prebuilt dtuple used in selects where the end of range is known */
671 
672  /** Set to true in row_search_mvcc when a row matching exactly the length and
673  value of stop_tuple was found, so that the next iteration of row_search_mvcc
674  knows it can simply return DB_RECORD_NOT_FOUND. If true, then for sure, at
675  least one such matching row was seen. If false, it might be false negative, as
676  not all control paths lead to setting this field to true in case a matching
677  row is visited. */
679 
680  private:
681  /** Set to true iff we are inside read_range_first() or read_range_next() */
683 
684  public:
685  bool is_reading_range() const { return m_is_reading_range; }
686 
688  public:
690  : ut::bool_scope_guard_t(prebuilt.m_is_reading_range) {}
691  };
692 
694  /* We implement row_is_reading_range_guard_t as a simple bool_scope_guard_t
695  because we trust that scopes are never nested and thus we don't need to
696  count their "openings" and "closings", so we assert that.*/
697  ut_ad(!m_is_reading_range);
698  return row_is_reading_range_guard_t(*this);
699  }
700 
702  /*!< if the clustered index was
703  generated, the row id of the
704  last row fetched is stored
705  here */
706  doc_id_t fts_doc_id; /* if the table has an FTS index on
707  it then we fetch the doc_id.
708  FTS-FIXME: Currently we fetch it always
709  but in the future we must only fetch
710  it when FTS columns are being
711  updated */
712  dtuple_t *clust_ref; /*!< prebuilt dtuple used in
713  sel/upd/del */
714  ulint select_lock_type; /*!< LOCK_NONE, LOCK_S, or LOCK_X */
715  enum select_mode select_mode; /*!< SELECT_ORDINARY,
716  SELECT_SKIP_LOKCED, or SELECT_NO_WAIT */
717  ulint row_read_type; /*!< ROW_READ_WITH_LOCKS if row locks
718  should be the obtained for records
719  under an UPDATE or DELETE cursor.
720  If trx_t::allow_semi_consistent()
721  returns true, this can be set to
722  ROW_READ_TRY_SEMI_CONSISTENT, so that
723  if the row under an UPDATE or DELETE
724  cursor was locked by another
725  transaction, InnoDB will resort
726  to reading the last committed value
727  ('semi-consistent read'). Then,
728  this field will be set to
729  ROW_READ_DID_SEMI_CONSISTENT to
730  indicate that. If the row does not
731  match the WHERE condition, MySQL will
732  invoke handler::unlock_row() to
733  clear the flag back to
734  ROW_READ_TRY_SEMI_CONSISTENT and
735  to simply skip the row. If
736  the row matches, the next call to
737  row_search_for_mysql() will lock
738  the row.
739  This eliminates lock waits in some
740  cases; note that this breaks
741  serializability. */
742 
743  enum {
747  };
748 
749  bool new_rec_lock[LOCK_COUNT]; /*!< normally false; if
750  session is using READ COMMITTED or READ UNCOMMITTED
751  isolation level, set in row_search_for_mysql() if we set
752  a new record lock on the secondary or clustered index;
753  this is used in row_unlock_for_mysql() when releasing
754  the lock under the cursor if we determine after
755  retrieving the row that it does not need to be locked
756  ('mini-rollback')
757  [LOCK_PCUR] corresponds to pcur, the first index we
758  looked up (can be secondary or clustered!)
759 
760  [LOCK_CLUST_PCUR] corresponds to clust_pcur, which if
761  used at all, is always the clustered index.
762 
763  The meaning of these booleans is:
764  true = we've created a rec lock, which we might
765  release as we "own" it
766  false = we should not release any lock for this
767  index as we either reused some existing
768  lock, or there is some other reason, we
769  should keep it
770  */
771  ulint mysql_prefix_len; /*!< byte offset of the end of
772  the last requested column */
773  ulint mysql_row_len; /*!< length in bytes of a row in the
774  MySQL format */
775  ulint n_rows_fetched; /*!< number of rows fetched after
776  positioning the current cursor */
777  ulint fetch_direction; /*!< ROW_SEL_NEXT or ROW_SEL_PREV */
778 
780  /*!< a cache for fetched rows if we
781  fetch many rows from the same cursor:
782  it saves CPU time to fetch them in a
783  batch; we reserve mysql_row_len
784  bytes for each such row; these
785  pointers point 4 bytes past the
786  allocated mem buf start, because
787  there is a 4 byte magic number at the
788  start and at the end */
789  ibool keep_other_fields_on_keyread; /*!< when using fetch
790  cache with HA_EXTRA_KEYREAD, don't
791  overwrite other fields in mysql row
792  row buffer.*/
793  ulint fetch_cache_first; /*!< position of the first not yet
794  fetched row in fetch_cache */
795  ulint n_fetch_cached; /*!< number of not yet fetched rows
796  in fetch_cache */
797  mem_heap_t *blob_heap; /*!< in SELECTS BLOB fields are copied
798  to this heap */
799  mem_heap_t *old_vers_heap; /*!< memory heap where a previous
800  version is built in consistent read */
801  bool in_fts_query; /*!< Whether we are in a FTS query */
802  bool fts_doc_id_in_read_set; /*!< true if table has externally
803  defined FTS_DOC_ID coulmn. */
804  /*----------------------*/
806  /*!< last value of AUTO-INC interval */
807  ulonglong autoinc_increment; /*!< The increment step of the auto
808  increment column. Value must be
809  greater than or equal to 1. Required to
810  calculate the next value */
811  ulonglong autoinc_offset; /*!< The offset passed to
812  get_auto_increment() by MySQL. Required
813  to calculate the next value */
814  dberr_t autoinc_error; /*!< The actual error code encountered
815  while trying to init or read the
816  autoinc value from the table. We
817  store it here so that we can return
818  it to MySQL */
819  /*----------------------*/
820  bool idx_cond; /*!< True if index condition pushdown
821  is used, false otherwise. */
822  ulint idx_cond_n_cols; /*!< Number of fields in idx_cond_cols.
823  0 if and only if idx_cond == false. */
824  /*----------------------*/
825  unsigned innodb_api : 1; /*!< whether this is a InnoDB API
826  query */
827  const rec_t *innodb_api_rec; /*!< InnoDB API search result */
828  void *innodb_api_buf; /*!< Buffer holding copy of the physical
829  Innodb API search record */
830  ulint innodb_api_rec_size; /*!< Size of the Innodb API record */
831  /*----------------------*/
832 
833  /*----------------------*/
834  rtr_info_t *rtr_info; /*!< R-tree Search Info */
835  /*----------------------*/
836 
837  ulint magic_n2; /*!< this should be the same as
838  magic_n */
839 
840  bool ins_sel_stmt; /*!< if true then ins_sel_statement. */
841 
842  innodb_session_t *session; /*!< InnoDB session handler. */
843  byte *srch_key_val1; /*!< buffer used in converting
844  search key values from MySQL format
845  to InnoDB format.*/
846  byte *srch_key_val2; /*!< buffer used in converting
847  search key values from MySQL format
848  to InnoDB format.*/
849  uint srch_key_val_len; /*!< Size of search key */
850  /** Disable prefetch. */
852 
853  /** true, if server has called ha_extra(HA_EXTRA_NO_READ_LOCKING) */
855 
856  /** true, if we were asked to skip AUTOINC locking for the table. */
858 
859  /** Return materialized key for secondary index scan */
861 
862  /** Whether this is a temporary(intrinsic) table read to keep the position
863  for this MySQL TABLE object */
865 
866  /** Whether tree modifying operation happened on a temporary (intrinsic)
867  table index tree. In this case, it could be split, but no shrink. */
869 
870  /** The MySQL table object */
872 
873  /** The MySQL handler object. */
875 
876  /** limit value to avoid fts result overflow */
878 
879  /** True if exceeded the end_range while filling the prefetch cache. */
881 
882  /** Undo information for LOB mvcc */
884 
885  lob::undo_vers_t *get_lob_undo() { return (&m_lob_undo); }
886 
887  void lob_undo_reset() { m_lob_undo.reset(); }
888 
889  /** Can a record buffer or a prefetch cache be utilized for prefetching
890  records in this scan?
891  @retval true if records can be prefetched
892  @retval false if records cannot be prefetched */
893  bool can_prefetch_records() const;
894 
895  /** Determines if the query is REPLACE or ON DUPLICATE KEY UPDATE in which
896  case duplicate values should be allowed (and further processed) instead of
897  causing an error.
898  @return true iff duplicated values should be allowed */
899  bool allow_duplicates() { return (replace || on_duplicate_key_update); }
900 
901  private:
902  /** A helper function for init_search_tuples_types() which prepares the shape
903  of the tuple to match the index
904  @param[in] tuple this->search_tuple or this->m_stop_tuple */
905  void init_tuple_types(dtuple_t *tuple) {
906  dtuple_set_n_fields(tuple, index->n_fields);
907  dict_index_copy_types(tuple, index, index->n_fields);
908  }
909 
910  public:
911  /** Initializes search_tuple and m_stop_tuple shape so they match the index */
913  init_tuple_types(search_tuple);
914  init_tuple_types(m_stop_tuple);
915  }
916 
917  /** Resets both search_tuple and m_stop_tuple */
919  dtuple_set_n_fields(search_tuple, 0);
920  dtuple_set_n_fields(m_stop_tuple, 0);
921  }
922 
923  /** @return true iff the operation can skip concurrency ticket. */
924  bool skip_concurrency_ticket() const;
925 
926  /** It is unsafe to copy this struct, and moving it would be non-trivial,
927  because we want to keep in sync with row_is_reading_range_guard_t. Therefore
928  it is much safer/easier to just forbid such operations. */
929  row_prebuilt_t(row_prebuilt_t const &) = delete;
930  row_prebuilt_t &operator=(row_prebuilt_t const &) = delete;
931  row_prebuilt_t &operator=(row_prebuilt_t &&) = delete;
932  row_prebuilt_t(row_prebuilt_t &&) = delete;
933 };
934 
935 /** Callback for row_mysql_sys_index_iterate() */
937  virtual ~SysIndexCallback() {}
938 
939  /** Callback method
940  @param mtr current mini-transaction
941  @param pcur persistent cursor. */
942  virtual void operator()(mtr_t *mtr, btr_pcur_t *pcur) noexcept = 0;
943 };
944 
945 /** Get the computed value by supplying the base column values.
946 @param[in,out] row the data row
947 @param[in] col virtual column
948 @param[in] index index on the virtual column
949 @param[in,out] local_heap heap memory for processing large data etc.
950 @param[in,out] heap memory heap that copies the actual index row
951 @param[in] ifield index field
952 @param[in] thd MySQL thread handle
953 @param[in,out] mysql_table mysql table object
954 @param[in] old_table during ALTER TABLE, this is the old table
955  or NULL.
956 @param[in] parent_update update vector for the parent row
957 @param[in] foreign foreign key information
958 @return the field filled with computed value, or NULL if just want
959 to store the value in passed in "my_rec" */
961  const dtuple_t *row, const dict_v_col_t *col, const dict_index_t *index,
962  mem_heap_t **local_heap, mem_heap_t *heap, const dict_field_t *ifield,
963  THD *thd, TABLE *mysql_table, const dict_table_t *old_table,
964  upd_t *parent_update, dict_foreign_t *foreign);
965 
966 /** Parse out multi-values from a MySQL record
967 @param[in] mysql_table MySQL table structure
968 @param[in] f_idx field index of the multi-value column
969 @param[in,out] dfield field structure to store parsed multi-value
970 @param[in,out] value nullptr or the multi-value structure
971  to store the parsed values
972 @param[in] old_val old value if exists
973 @param[in] comp true if InnoDB table uses compact row format
974 @param[in,out] heap memory heap */
975 void innobase_get_multi_value(const TABLE *mysql_table, ulint f_idx,
976  dfield_t *dfield, multi_value_data *value,
977  uint old_val, ulint comp, mem_heap_t *heap);
978 
979 /** Get the computed value by supplying the base column values.
980 @param[in,out] table the table whose virtual column template to be built */
982 
983 /** Change dbname and table name in table->vc_templ.
984 @param[in,out] table the table whose virtual column template
985 dbname and tbname to be renamed. */
987 
988 #define ROW_PREBUILT_FETCH_MAGIC_N 465765687
989 
990 #define ROW_MYSQL_WHOLE_ROW 0
991 #define ROW_MYSQL_REC_FIELDS 1
992 #define ROW_MYSQL_NO_TEMPLATE 2
993 #define ROW_MYSQL_DUMMY_TEMPLATE \
994  3 /* dummy template used in \
995  row_scan_and_check_index */
996 
997 /* Values for hint_need_to_fetch_extra_cols */
998 #define ROW_RETRIEVE_PRIMARY_KEY 1
999 #define ROW_RETRIEVE_ALL_COLS 2
1000 
1001 /* Values for row_read_type */
1002 #define ROW_READ_WITH_LOCKS 0
1003 #define ROW_READ_TRY_SEMI_CONSISTENT 1
1004 #define ROW_READ_DID_SEMI_CONSISTENT 2
1005 
1006 #ifdef UNIV_DEBUG
1007 /** Wait for the background drop list to become empty. */
1009 #endif /* UNIV_DEBUG */
1010 #endif /* !UNIV_HOTBACKUP */
1011 
1012 #endif /* row0mysql.h */
que_fork_t * sel_graph
dummy query graph used in selects
Definition: row0mysql.h:665
upd_node_t * upd_node
Innobase SQL update node used to perform updates and deletes.
Definition: row0mysql.h:652
dberr_t row_mysql_parallel_select_count_star(trx_t *trx, std::vector< dict_index_t *> &indexes, size_t max_threads, ulint *n_rows)
Read the total number of records in a consistent view.
Definition: row0mysql.cc:4403
static bool replace
Definition: mysqlimport.cc:65
void innobase_rename_vc_templ(dict_table_t *table)
Change dbname and table name in table->vc_templ.
Definition: ha_innodb.cc:22575
void row_prebuild_sel_graph(row_prebuilt_t *prebuilt)
Builds a dummy query graph used in selects.
Definition: row0mysql.cc:1715
unsigned n_template
number of elements in the template
Definition: row0mysql.h:589
lob::undo_vers_t m_lob_undo
Undo information for LOB mvcc.
Definition: row0mysql.h:883
Record manager global types.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
InnoDB session state tracker.
bool m_read_virtual_key
Return materialized key for secondary index scan.
Definition: row0mysql.h:860
Data types.
dberr_t row_discard_tablespace_for_mysql(const char *name, trx_t *trx)
Discards the tablespace of a table which stored in an .ibd file.
Definition: row0mysql.cc:3572
bool m_is_reading_range
Set to true iff we are inside read_range_first() or read_range_next()
Definition: row0mysql.h:682
unsigned null_bitmap_len
number of bytes in the SQL NULL bitmap at the start of a row in the MySQL format
Definition: row0mysql.h:591
unsigned used_in_HANDLER
TRUE if we have been using this handle in a MySQL HANDLER low level index cursor command: then we mus...
Definition: row0mysql.h:578
virtual ~SysIndexCallback()
Definition: row0mysql.h:937
row_prebuilt_t * row_create_prebuilt(dict_table_t *table, ulint mysql_row_len)
Create a prebuilt struct for a MySQL table handle.
Definition: row0mysql.cc:768
que_fork_t * ins_graph
Innobase SQL query graph used in inserts.
Definition: row0mysql.h:656
ulint type
column type in Innobase mtype numbers DATA_CHAR...
Definition: row0mysql.h:514
ulint row_get_background_drop_list_len_low(void)
Get the background drop list length.
Definition: row0mysql.cc:3263
dberr_t row_scan_index_for_mysql(row_prebuilt_t *prebuilt, dict_index_t *index, size_t n_threads, bool check_keys, ulint *n_rows)
Scans an index for either COUNT(*) or CHECK TABLE.
Definition: row0mysql.cc:4639
R-tree header file.
lob::undo_vers_t * get_lob_undo()
Definition: row0mysql.h:885
Undo logging small changes to BLOBs.
Prototypes for global functions in ha_innodb.cc that are called by InnoDB C code. ...
void reset()
Empty the collected LOB undo information from cache.
Definition: lob0undo.h:186
Global error codes for the database.
ulonglong autoinc_increment
The increment step of the auto increment column.
Definition: row0mysql.h:807
ulint mysql_col_len
length of the column in the MySQL row format
Definition: row0mysql.h:507
#define DATA_ROW_ID_LEN
Definition: data0type.h:174
bool m_temp_read_shared
Whether this is a temporary(intrinsic) table read to keep the position for this MySQL TABLE object...
Definition: row0mysql.h:864
ulint mbmaxlen
maximum length of a char, in bytes, or zero if not a char type
Definition: row0mysql.h:530
ulint mysql_type
MySQL type code; this is always < 256.
Definition: row0mysql.h:516
Some integer typedefs for easier portability.
Definition: trx0trx.h:833
byte * srch_key_val2
buffer used in converting search key values from MySQL format to InnoDB format.
Definition: row0mysql.h:846
bool m_no_prefetch
Disable prefetch.
Definition: row0mysql.h:851
void row_mysql_unlock_data_dictionary(trx_t *trx)
Unlocks the data dictionary exclusive lock.
Definition: row0mysql.cc:2741
ulint mysql_null_byte_offset
MySQL NULL bit byte offset in a MySQL record.
Definition: row0mysql.h:510
void row_update_prebuilt_trx(row_prebuilt_t *prebuilt, trx_t *trx)
Updates the transaction pointers in query graphs stored in the prebuilt struct.
Definition: row0mysql.cc:999
void row_prebuilt_free(row_prebuilt_t *prebuilt, ibool dict_locked)
Free a prebuilt struct for a MySQL table handle.
Definition: row0mysql.cc:926
unsigned template_type
ROW_MYSQL_WHOLE_ROW, ROW_MYSQL_REC_FIELDS, ROW_MYSQL_DUMMY_TEMPLATE, or ROW_MYSQL_NO_TEMPLATE.
Definition: row0mysql.h:585
dtuple_t * m_stop_tuple
prebuilt dtuple used in selects where the end of range is known
Definition: row0mysql.h:670
The transaction lock system global types.
unsigned on_duplicate_key_update
1 if extra(HA_EXTRA_INSERT_WITH_UPDATE) was requested, which happens when ON DUPLICATE KEY UPDATE cla...
Definition: row0mysql.h:615
trx_t * trx
current transaction handle
Definition: row0mysql.h:558
dict_index_t * index
current index for a search, if any
Definition: row0mysql.h:556
ulint mysql_prefix_len
byte offset of the end of the last requested column
Definition: row0mysql.h:771
dberr_t row_table_load_foreign_constraints(trx_t *trx, const char *name, const dd::Table *dd_table)
Loads foreign key constraints for the table being created.
Definition: row0mysql.cc:3062
mode
Definition: file_handle.h:59
ibool row_rollback_on_timeout
Provide optional 4.x backwards compatibility for 5.0 and above.
Definition: row0mysql.cc:92
doc_id_t fts_doc_id
Definition: row0mysql.h:706
select_mode
Definition: lock0types.h:44
Data structure for a database table.
Definition: dict0mem.h:1532
ulint hint_need_to_fetch_extra_cols
normally this is set to 0; if this is set to ROW_RETRIEVE_PRIMARY_KEY, then we should at least retrie...
Definition: row0mysql.h:643
unsigned templ_contains_blob
TRUE if the template contains a column with DATA_LARGE_MTYPE( get_innobase_type_from_mysql_type()) is...
Definition: row0mysql.h:599
Definition: row0ins.h:169
dict_table_t * table
Innobase table handle.
Definition: row0mysql.h:555
void row_mysql_store_blob_ref(byte *dest, ulint col_len, const void *data, ulint len)
Stores a reference to a BLOB in the MySQL format.
Definition: row0mysql.cc:209
void row_mysql_close(void)
Close this module.
Definition: row0mysql.cc:4841
Representation of an SQL command.
void row_mysql_init(void)
Initialize this module.
Definition: row0mysql.cc:4832
dberr_t row_lock_table_autoinc_for_mysql(row_prebuilt_t *prebuilt)
Sets an AUTO_INC type lock on the table mentioned in prebuilt.
Definition: row0mysql.cc:1138
Definition: sess0sess.h:70
dberr_t row_lock_table(row_prebuilt_t *prebuilt)
Sets a table lock on the table mentioned in prebuilt.
Definition: row0mysql.cc:1208
Data structure for a foreign key constraint; an example: FOREIGN KEY (A, B) REFERENCES TABLE2 (C...
Definition: dict0mem.h:1299
The handler class is the interface for dynamically loadable storage engines.
Definition: handler.h:4032
ulint col_no
column number of the column
Definition: row0mysql.h:491
Definition: buf0block_hint.cc:29
void row_unlock_for_mysql(row_prebuilt_t *prebuilt, ibool has_latches_on_recs)
This can only be used when this session is using a READ COMMITTED or READ UNCOMMITTED isolation level...
Definition: row0mysql.cc:2496
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:349
unsigned innodb_api
whether this is a InnoDB API query
Definition: row0mysql.h:825
void row_mysql_store_geometry(byte *dest, ulint dest_len, const byte *src, ulint src_len)
Converts InnoDB geometry data format to MySQL data format.
Definition: row0mysql.cc:242
void row_mysql_pad_col(ulint mbminlen, byte *pad, ulint len)
Pad a column with spaces.
Definition: row0mysql.cc:335
ulint mysql_null_bit_mask
bit mask to get the NULL bit, zero if column cannot be NULL
Definition: row0mysql.h:512
Definition: btr0pcur.h:178
unsigned replace
1 if extra(HA_EXTRA_WRITE_CAN_REPLACE) was requested, which happen when REPLACE is done instead of re...
Definition: row0mysql.h:619
byte * row_mysql_store_true_var_len(byte *dest, ulint len, ulint lenlen)
Stores a >= 5.0.3 format true VARCHAR length to dest, in the MySQL row format.
Definition: row0mysql.cc:157
SQL data field and tuple.
ibool row_table_got_default_clust_index(const dict_table_t *table)
Checks if a table is such that we automatically created a clustered index on it (on row id)...
Definition: row0mysql.cc:2687
Definition: table.h:1363
unsigned index_usable
caches the value of index->is_usable(trx)
Definition: row0mysql.h:570
bool in_fts_query
Whether we are in a FTS query.
Definition: row0mysql.h:801
Definition: que0que.h:310
Transaction savepoint.
Definition: trx0types.h:154
btr_pcur_t * pcur
persistent cursor used in selects and updates
Definition: row0mysql.h:661
ulint is_virtual
if a column is a virtual column
Definition: row0mysql.h:535
Definition: row0mysql.h:490
ha_innobase * m_mysql_handler
The MySQL handler object.
Definition: row0mysql.h:874
Query graph global types.
Full text search header file.
btr_pcur_t * clust_pcur
persistent cursor used in some selects and updates
Definition: row0mysql.h:663
ulint mysql_row_len
length in bytes of a row in the MySQL format
Definition: row0mysql.h:773
dtuple_t * search_tuple
prebuilt dtuple used in selects
Definition: row0mysql.h:667
ulint mysql_mvidx_len
index length on multi-value array
Definition: row0mysql.h:509
bool fts_doc_id_in_read_set
true if table has externally defined FTS_DOC_ID coulmn.
Definition: row0mysql.h:802
ulint magic_n
this magic number is set to ROW_PREBUILT_ALLOCATED when created, or ROW_PREBUILT_FREED when the struc...
Definition: row0mysql.h:551
The ut_bool_scope_guard class which sets boolean to true for the duration of scope.
static const char * filepath
Definition: myisamlog.cc:93
bool allow_duplicates()
Determines if the query is REPLACE or ON DUPLICATE KEY UPDATE in which case duplicate values should b...
Definition: row0mysql.h:899
row_is_reading_range_guard_t(row_prebuilt_t &prebuilt)
Definition: row0mysql.h:689
dberr_t row_mysql_lock_table(trx_t *trx, dict_table_t *table, enum lock_mode mode, const char *op_info)
Sets an exclusive lock on a table.
Definition: row0mysql.cc:3627
void row_mysql_freeze_data_dictionary_func(trx_t *trx, const char *file, ulint line)
Locks the data dictionary in shared mode from modifications, for performing foreign key check...
Definition: row0mysql.cc:2702
A struct for (sometimes lazily) prebuilt structures in an Innobase table handle used within MySQL; th...
Definition: row0mysql.h:550
multi_value_data * mv_data
Definition: row0mysql.h:640
unsigned templ_contains_fixed_point
TRUE if the template contains a column with DATA_POINT.
Definition: row0mysql.h:606
dtuple_t * clust_ref
prebuilt dtuple used in sel/upd/del
Definition: row0mysql.h:712
ib_uint64_t doc_id_t
Document id type.
Definition: fts0fts.h:76
Data dictionary global types.
const byte * row_mysql_read_true_varchar(ulint *len, const byte *field, ulint lenlen)
Reads a >= 5.0.3 format true VARCHAR length, in the MySQL row format, and returns a pointer to the da...
Definition: row0mysql.cc:182
mem_heap_t * heap
memory heap from which these auxiliary structures are allocated when needed
Definition: row0mysql.h:627
bool idx_cond
True if index condition pushdown is used, false otherwise.
Definition: row0mysql.h:820
que_fork_t * upd_graph
Innobase SQL query graph used in updates or deletes.
Definition: row0mysql.h:659
innodb_session_t * session
InnoDB session handler.
Definition: row0mysql.h:842
bool row_mysql_handle_errors(dberr_t *new_err, trx_t *trx, que_thr_t *thr, trx_savept_t *savept)
Handles user errors and lock waits detected by the database engine.
Definition: row0mysql.cc:647
void init_search_tuples_types()
Initializes search_tuple and m_stop_tuple shape so they match the index.
Definition: row0mysql.h:912
row_is_reading_range_guard_t get_is_reading_range_guard()
Definition: row0mysql.h:693
ulint mysql_col_offset
offset of the column in the MySQL row format
Definition: row0mysql.h:505
bool no_read_locking
true, if server has called ha_extra(HA_EXTRA_NO_READ_LOCKING)
Definition: row0mysql.h:854
Definition: row0mysql.h:746
byte rec_t
Definition: rem0types.h:39
Structure for an SQL data tuple of fields (logical record)
Definition: data0data.h:711
ulint row_read_type
ROW_READ_WITH_LOCKS if row locks should be the obtained for records under an UPDATE or DELETE cursor...
Definition: row0mysql.h:717
ulint n_fetch_cached
number of not yet fetched rows in fetch_cache
Definition: row0mysql.h:795
byte * row_mysql_store_col_in_innobase_format(dfield_t *dfield, byte *buf, ibool row_format_col, const byte *mysql_data, ulint col_len, ulint comp)
Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.
Definition: row0mysql.cc:372
dberr_t
Definition: db0err.h:38
bool ins_sel_stmt
if true then ins_sel_statement.
Definition: row0mysql.h:840
ulint rec_field_no
field number of the column in an Innobase record in the current index; not defined if template_type i...
Definition: row0mysql.h:492
Header for compiler-dependent features.
bool m_end_range
True if exceeded the end_range while filling the prefetch cache.
Definition: row0mysql.h:880
A RAII-style class, which sets a given boolean to true in constructor, and to false in destructor...
Definition: ut0bool_scope_guard.h:38
bool row_is_mysql_tmp_table_name(const char *name)
Checks if a table name contains the string "/#sql" which denotes temporary tables in MySQL...
Definition: row0mysql.cc:4181
Row operation global types.
unsigned n_fields
number of fields in the index
Definition: dict0mem.h:932
ulint select_lock_type
LOCK_NONE, LOCK_S, or LOCK_X.
Definition: row0mysql.h:714
dberr_t row_create_index_for_mysql(dict_index_t *index, trx_t *trx, const ulint *field_lengths, dict_table_t *handler)
Does an index creation operation for MySQL.
Definition: row0mysql.cc:2901
Data structure for a field in an index.
Definition: dict0mem.h:725
ulonglong autoinc_offset
The offset passed to get_auto_increment() by MySQL.
Definition: row0mysql.h:811
Definition: que0que.h:251
unsigned int uint
Definition: uca-dump.cc:29
case opt name
Definition: sslopt-case.h:32
dberr_t autoinc_error
The actual error code encountered while trying to init or read the autoinc value from the table...
Definition: row0mysql.h:814
The class defining a handle to an InnoDB table.
Definition: ha_innodb.h:79
unsigned sql_stat_start
TRUE when we start processing of an SQL statement: we may have to set an intention lock on the table...
Definition: row0mysql.h:559
void innobase_get_multi_value(const TABLE *mysql_table, ulint f_idx, dfield_t *dfield, multi_value_data *value, uint old_val, ulint comp, mem_heap_t *heap)
Parse out multi-values from a MySQL record.
Definition: ha_innodb.cc:8464
Definition: ut0bool_scope_guard.h:34
const rec_t * innodb_api_rec
InnoDB API search result.
Definition: row0mysql.h:827
Structure for an SQL data field.
Definition: data0data.h:639
dberr_t row_update_for_mysql(const byte *mysql_rec, row_prebuilt_t *prebuilt)
Does an update or delete of a row for MySQL.
Definition: row0mysql.cc:2437
ulint n_rows_fetched
number of rows fetched after positioning the current cursor
Definition: row0mysql.h:775
ulonglong autoinc_last_value
last value of AUTO-INC interval
Definition: row0mysql.h:805
The index tree persistent cursor.
dberr_t row_drop_tablespace(space_id_t space_id, const char *filepath)
Drop a tablespace as part of dropping or renaming a table.
Definition: row0mysql.cc:3755
Transaction system global type definitions.
mem_heap_t * old_vers_heap
memory heap where a previous version is built in consistent read
Definition: row0mysql.h:799
dberr_t row_drop_table_for_mysql(const char *name, trx_t *trx, bool nonatomic, dict_table_t *handler=nullptr)
Drop a table for MySQL.
Definition: row0mysql.cc:3791
bool is_reading_range() const
Definition: row0mysql.h:685
ulonglong m_fts_limit
limit value to avoid fts result overflow
Definition: row0mysql.h:877
ulint icp_rec_field_no
field number of the column in an Innobase record in the current index; only defined for columns that ...
Definition: row0mysql.h:500
mem_heap_t * cursor_heap
memory heap from which innodb_api_buf is allocated per session
Definition: row0mysql.h:630
rtr_info_t * rtr_info
R-tree Search Info.
Definition: row0mysql.h:834
upd_node_t * row_create_update_node_for_mysql(dict_table_t *table, mem_heap_t *heap)
Creates an query graph node of &#39;update&#39; type to be used in the MySQL interface.
Definition: row0mysql.cc:1734
void innobase_init_vc_templ(dict_table_t *table)
Get the computed value by supplying the base column values.
Definition: ha_innodb.cc:22542
dberr_t row_create_table_for_mysql(dict_table_t *table, const char *compression, trx_t *trx)
Creates a table for MySQL.
Definition: row0mysql.cc:2761
The memory management.
uint32 space_id_t
Tablespace identifier.
Definition: api0api.h:59
ulint is_unsigned
if a column type is an integer type and this field is != 0, then it is an unsigned integer type ...
Definition: row0mysql.h:532
bool m_stop_tuple_found
Set to true in row_search_mvcc when a row matching exactly the length and value of stop_tuple was fou...
Definition: row0mysql.h:678
dberr_t row_update_cascade_for_mysql(que_thr_t *thr, upd_node_t *node, dict_table_t *table)
Does a cascaded delete or set null in a foreign key operation.
Definition: row0mysql.cc:2595
void * innodb_api_buf
Buffer holding copy of the physical Innodb API search record.
Definition: row0mysql.h:828
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:66
unsigned read_just_key
set to 1 when MySQL calls ha_innobase::extra with the argument HA_EXTRA_KEYREAD; it is enough to read...
Definition: row0mysql.h:572
byte * srch_key_val1
buffer used in converting search key values from MySQL format to InnoDB format.
Definition: row0mysql.h:843
ibool keep_other_fields_on_keyread
when using fetch cache with HA_EXTRA_KEYREAD, don&#39;t overwrite other fields in mysql row row buffer...
Definition: row0mysql.h:789
upd_t * row_get_prebuilt_update_vector(row_prebuilt_t *prebuilt)
Gets pointer to a prebuilt update vector used in updates.
Definition: row0mysql.cc:1779
void init_tuple_types(dtuple_t *tuple)
A helper function for init_search_tuples_types() which prepares the shape of the tuple to match the i...
Definition: row0mysql.h:905
uint srch_key_val_len
Size of search key.
Definition: row0mysql.h:849
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:144
Vectors holding the matching internal pages/nodes and leaf records.
Definition: gis0type.h:108
const byte * default_rec
the default values of all columns (a "default row") in MySQL format
Definition: row0mysql.h:641
ins_node_t * ins_node
Innobase SQL insert node used to perform inserts to the table.
Definition: row0mysql.h:633
dberr_t row_rename_table_for_mysql(const char *old_name, const char *new_name, const dd::Table *dd_table, trx_t *trx, bool replay)
Renames a table for MySQL.
Definition: row0mysql.cc:4193
ulint magic_n2
this should be the same as magic_n
Definition: row0mysql.h:837
ulint idx_cond_n_cols
Number of fields in idx_cond_cols.
Definition: row0mysql.h:822
Definition: row0upd.h:683
ulint mysql_length_bytes
if mysql_type == DATA_MYSQL_TRUE_VARCHAR, this tells whether we should use 1 or 2 bytes to store the ...
Definition: row0mysql.h:518
Structure to hold number of multiple values.
Definition: data0data.h:418
Data structure for a virtual column in a table.
Definition: dict0mem.h:649
void lob_undo_reset()
Definition: row0mysql.h:887
trx_id_t trx_id
The table->def_trx_id when ins_graph was built.
Definition: row0mysql.h:654
byte * ins_upd_rec_buff
buffer for storing data converted to the Innobase format from the MySQL format
Definition: row0mysql.h:637
dfield_t * innobase_get_computed_value(const dtuple_t *row, const dict_v_col_t *col, const dict_index_t *index, mem_heap_t **local_heap, mem_heap_t *heap, const dict_field_t *ifield, THD *thd, TABLE *mysql_table, const dict_table_t *old_table, upd_t *parent_update, dict_foreign_t *foreign)
Get the computed value by supplying the base column values.
Definition: ha_innodb.cc:22634
void row_delete_all_rows(dict_table_t *table)
Delete all rows for the given table by freeing/truncating indexes.
Definition: row0mysql.cc:2448
unsigned need_to_access_clustered
if we are fetching columns through a secondary index and at least one column is not in the secondary ...
Definition: row0mysql.h:594
void row_mysql_lock_data_dictionary_func(trx_t *trx, const char *file, ulint line)
Locks the data dictionary exclusively for performing a table create or other data dictionary modifica...
Definition: row0mysql.cc:2726
unsigned clust_index_was_generated
if the user did not define a primary key in MySQL, then Innobase automatically generated a clustered ...
Definition: row0mysql.h:563
dberr_t row_import_tablespace_for_mysql(dict_table_t *table, row_prebuilt_t *prebuilt)
Imports a tablespace.
ulint mbminlen
minimum length of a char, in bytes, or zero if not a char type
Definition: row0mysql.h:528
Definition: os0file.h:85
void row_wait_for_background_drop_list_empty()
Wait for the background drop list to become empty.
Definition: row0mysql.cc:125
ulint fetch_direction
ROW_SEL_NEXT or ROW_SEL_PREV.
Definition: row0mysql.h:777
Definition: test_sql_stmt.cc:150
Callback for row_mysql_sys_index_iterate()
Definition: row0mysql.h:936
TABLE * m_mysql_table
The MySQL table object.
Definition: row0mysql.h:871
mem_heap_t * blob_heap
in SELECTS BLOB fields are copied to this heap
Definition: row0mysql.h:797
const string value("\alue\)
void row_mysql_prebuilt_free_blob_heap(row_prebuilt_t *prebuilt)
Frees the blob heap in prebuilt when no longer needed.
Definition: row0mysql.cc:143
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:40
void clear_search_tuples()
Resets both search_tuple and m_stop_tuple.
Definition: row0mysql.h:918
Definition: row0mysql.h:744
void row_mysql_unfreeze_data_dictionary(trx_t *trx)
Unlocks the data dictionary shared lock.
Definition: row0mysql.cc:2712
The list of modifications to be applied on LOBs to get older versions.
Definition: lob0undo.h:144
mysql_row_templ_t * mysql_template
template used to transform rows fast between MySQL and Innobase formats; memory for this template is ...
Definition: row0mysql.h:623
unsigned char byte
Blob class.
Definition: common.h:159
#define MYSQL_FETCH_CACHE_SIZE
Definition: row0mysql.h:540
ulint is_multi_val
if a column is a Multi-Value Array virtual column
Definition: row0mysql.h:536
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:169
dberr_t row_drop_database_for_mysql(const char *name, trx_t *trx, ulint *found)
Drop a database for MySQL.
lock_mode
Definition: lock0types.h:51
void dtuple_set_n_fields(dtuple_t *tuple, ulint n_fields)
Sets number of fields used in a tuple.
Definition: data0data.cc:95
Definition: row0mysql.h:745
Definition: table.h:46
const byte * row_mysql_read_blob_ref(ulint *len, const byte *ref, ulint col_len)
Reads a reference to a BLOB in the MySQL format.
Definition: row0mysql.cc:230
ulint innodb_api_rec_size
Size of the Innodb API record.
Definition: row0mysql.h:830
ulint clust_rec_field_no
field number of the column in an Innobase record in the clustered index; not defined if template_type...
Definition: row0mysql.h:496
void dict_index_copy_types(dtuple_t *tuple, const dict_index_t *index, ulint n_fields)
Copies types of fields contained in index to tuple.
Definition: dict0dict.cc:2807
ulint fetch_cache_first
position of the first not yet fetched row in fetch_cache
Definition: row0mysql.h:793
dberr_t row_insert_for_mysql(const byte *mysql_rec, row_prebuilt_t *prebuilt)
Does an insert for MySQL.
Definition: row0mysql.cc:1704
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:803
Definition: row0upd.h:580
bool no_autoinc_locking
true, if we were asked to skip AUTOINC locking for the table.
Definition: row0mysql.h:857
bool m_temp_tree_modified
Whether tree modifying operation happened on a temporary (intrinsic) table index tree.
Definition: row0mysql.h:868
ulint charset
MySQL charset-collation code of the column, or zero.
Definition: row0mysql.h:526
ulint row_drop_tables_for_mysql_in_background(void)
The master thread in srv0srv.cc calls this regularly to drop tables which we must drop in background ...
Definition: row0mysql.cc:3167
Data structure for an index.
Definition: dict0mem.h:886