MySQL 9.3.0
Source Code Documentation
handler.h
Go to the documentation of this file.
1#ifndef HANDLER_INCLUDED
2#define HANDLER_INCLUDED
3
4/*
5 Copyright (c) 2000, 2025, Oracle and/or its affiliates.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License, version 2.0,
9 as published by the Free Software Foundation.
10
11 This program is designed to work with certain software (including
12 but not limited to OpenSSL) that is licensed under separate terms,
13 as designated in a particular file or component or in included license
14 documentation. The authors of MySQL hereby grant you an additional
15 permission to link the program and your derivative works with the
16 separately licensed software that they have either included with
17 the program or referenced in the documentation.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License, version 2.0, for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
27*/
28
29/* Definitions for parameters to do with handler-routines */
30
31#include <fcntl.h>
32#include <float.h>
33#include <string.h>
34#include <sys/types.h>
35#include <time.h>
36#include <algorithm>
37#include <atomic>
38#include <bitset>
39#include <functional>
40#include <map>
41#include <memory>
42#include <optional>
43#include <random> // std::mt19937
44#include <set>
45#include <string>
46#include <string_view>
47
50#include "ft_global.h" // ft_hints
51#include "lex_string.h"
52#include "map_helpers.h"
53#include "my_alloc.h"
54#include "my_base.h"
55#include "my_bitmap.h"
56#include "my_checksum.h" // ha_checksum
57#include "my_compiler.h"
58#include "my_dbug.h"
59#include "my_double2ulonglong.h"
60#include "my_inttypes.h"
61#include "my_io.h"
62#include "my_sys.h"
63#include "my_table_map.h"
64#include "my_thread_local.h" // my_errno
67#include "sql/dd/object_id.h" // dd::Object_id
68#include "sql/dd/string_type.h"
69#include "sql/dd/types/object_table.h" // dd::Object_table
70#include "sql/discrete_interval.h" // Discrete_interval
71#include "sql/key.h"
72#include "sql/sql_const.h" // SHOW_COMP_OPTION
73#include "sql/sql_list.h" // SQL_I_List
74#include "sql/sql_plugin_ref.h" // plugin_ref
75#include "string_with_len.h" // STRING_WITH_LEN
76#include "thr_lock.h" // thr_lock_type
77#include "typelib.h"
78
79class Alter_info;
80class Create_field;
81class Field;
82class Item;
83class JOIN;
84class Json_dom;
86class Plugin_table;
88class Record_buffer;
89class SE_cost_constants; // see opt_costconstants.h
90class String;
91class THD;
92class handler;
93class partition_info;
95
96namespace dd {
97class Properties;
98} // namespace dd
99struct AccessPath;
100struct JoinHypergraph;
101struct KEY_CACHE;
102struct LEX;
103struct MY_BITMAP;
104struct SAVEPOINT;
105struct TABLE;
106class Table_ref;
107struct TABLE_SHARE;
108struct Tablespace_options;
109struct handlerton;
110
111typedef struct xid_t XID;
113struct MDL_key;
114
115namespace dd {
116enum class enum_column_types;
117class Table;
118class Tablespace;
119} // namespace dd
120
121constexpr const ha_rows EXTRA_RECORDS{10};
122
123/** Id for identifying Table SDIs */
124constexpr const uint32 SDI_TYPE_TABLE = 1;
125
126/** Id for identifying Tablespace SDIs */
127constexpr const uint32 SDI_TYPE_TABLESPACE = 2;
128
129/** Key to identify a dictionary object */
130struct sdi_key_t {
131 /** Type of Object, For ex: column, index, etc */
133
134 /** Object id which should be unique in tablespsace */
136};
137
138using sdi_container = std::vector<sdi_key_t>;
141};
142
143typedef bool (*qc_engine_callback)(THD *thd, const char *table_key,
144 uint key_length, ulonglong *engine_data);
145
146typedef bool(stat_print_fn)(THD *thd, const char *type, size_t type_len,
147 const char *file, size_t file_len,
148 const char *status, size_t status_len);
149
150class ha_statistics;
153class Unique_on_insert;
154
155extern ulong savepoint_alloc_size;
156
157/// Maps from slot to plugin. May return NULL if plugin has been unloaded.
158st_plugin_int *hton2plugin(uint slot);
159/// Returns the size of the array holding pointers to plugins.
160size_t num_hton2plugins();
161
162/**
163 For unit testing.
164 Insert plugin into arbitrary slot in array.
165 Remove plugin from arbitrary slot in array.
166*/
169
170extern const char *ha_row_type[];
171extern const char *tx_isolation_names[];
172extern const char *binlog_format_names[];
174extern ulong total_ha_2pc;
175
176// the following is for checking tables
177
178#define HA_ADMIN_ALREADY_DONE 1
179#define HA_ADMIN_OK 0
180#define HA_ADMIN_NOT_IMPLEMENTED -1
181#define HA_ADMIN_FAILED -2
182#define HA_ADMIN_CORRUPT -3
183#define HA_ADMIN_INTERNAL_ERROR -4
184#define HA_ADMIN_INVALID -5
185#define HA_ADMIN_REJECT -6
186#define HA_ADMIN_TRY_ALTER -7
187#define HA_ADMIN_WRONG_CHECKSUM -8
188#define HA_ADMIN_NOT_BASE_TABLE -9
189#define HA_ADMIN_NEEDS_UPGRADE -10
190#define HA_ADMIN_NEEDS_ALTER -11
191#define HA_ADMIN_NEEDS_CHECK -12
192#define HA_ADMIN_STATS_UPD_ERR -13
193/** User needs to dump and re-create table to fix pre 5.0 decimal types */
194#define HA_ADMIN_NEEDS_DUMP_UPGRADE -14
195
196/**
197 Return values for check_if_supported_inplace_alter().
198
199 @see check_if_supported_inplace_alter() for description of
200 the individual values.
201*/
212
213/**
214 * Used to identify which engine executed a SELECT query.
215 */
217
218/* Bits in table_flags() to show what database can do */
219
220#define HA_NO_TRANSACTIONS (1 << 0) /* Doesn't support transactions */
221#define HA_PARTIAL_COLUMN_READ (1 << 1) /* read may not return all columns */
222/*
223 Used to avoid scanning full tables on an index. If this flag is set then
224 the handler always has a primary key (hidden if not defined) and this
225 index is used for scanning rather than a full table scan in all
226 situations. No separate data/index file.
227*/
228#define HA_TABLE_SCAN_ON_INDEX (1 << 2)
229
230/// Not in use.
231#define HA_UNUSED3 (1 << 3)
232
233/*
234 Can the storage engine handle spatial data.
235 Used to check that no spatial attributes are declared unless
236 the storage engine is capable of handling it.
237*/
238#define HA_CAN_GEOMETRY (1 << 4)
239/*
240 Reading keys in random order is as fast as reading keys in sort order
241 (Used by filesort to decide if we should sort key + data or key +
242 pointer-to-row.)
243*/
244#define HA_FAST_KEY_READ (1 << 5)
245/*
246 Set the following flag if we on delete should force all key to be read
247 and on update read all keys that changes
248*/
249#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1 << 6)
250/*
251 Is NULL values allowed in indexes.
252 If this is not allowed then it is not possible to use an index on a
253 NULLable field.
254*/
255#define HA_NULL_IN_KEY (1 << 7)
256/*
257 Tells that we can the position for the conflicting duplicate key
258 record is stored in table->file->dupp_ref. (insert uses rnd_pos() on
259 this to find the duplicated row)
260*/
261#define HA_DUPLICATE_POS (1 << 8)
262#define HA_NO_BLOBS (1 << 9) /* Doesn't support blobs */
263/*
264 Is the storage engine capable of defining an index of a prefix on
265 a BLOB attribute.
266*/
267#define HA_CAN_INDEX_BLOBS (1 << 10)
268/*
269 Auto increment fields can be part of a multi-part key. For second part
270 auto-increment keys, the auto_incrementing is done in handler.cc
271*/
272#define HA_AUTO_PART_KEY (1 << 11)
273/*
274 Can't define a table without primary key (and cannot handle a table
275 with hidden primary key)
276*/
277#define HA_REQUIRE_PRIMARY_KEY (1 << 12)
278/*
279 Does the counter of records after the info call specify an exact
280 value or not. If it does this flag is set.
281*/
282#define HA_STATS_RECORDS_IS_EXACT (1 << 13)
283/// Not in use.
284#define HA_UNUSED14 (1 << 14)
285/*
286 This parameter is set when the handler will also return the primary key
287 when doing read-only-key on another index, i.e., if we get the primary
288 key columns for free when we do an index read (usually, it also implies
289 that HA_PRIMARY_KEY_REQUIRED_FOR_POSITION flag is set).
290*/
291#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
292/*
293 If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, it means that to position()
294 uses a primary key given by the record argument.
295 Without primary key, we can't call position().
296 If not set, the position is returned as the current rows position
297 regardless of what argument is given.
298*/
299#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1 << 16)
300#define HA_CAN_RTREEKEYS (1 << 17)
301/// Not in use.
302#define HA_UNUSED18
303/*
304 The following is we need to a primary key to delete (and update) a row.
305 If there is no primary key, all columns needs to be read on update and delete
306*/
307#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1 << 19)
308/*
309 Indexes on prefixes of character fields are not allowed.
310*/
311#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)
312/*
313 Does the storage engine support fulltext indexes.
314*/
315#define HA_CAN_FULLTEXT (1 << 21)
316/*
317 Can the HANDLER interface in the MySQL API be used towards this
318 storage engine.
319*/
320#define HA_CAN_SQL_HANDLER (1 << 22)
321/*
322 Set if the storage engine does not support auto increment fields.
323*/
324#define HA_NO_AUTO_INCREMENT (1 << 23)
325/*
326 Supports CHECKSUM option in CREATE TABLE (MyISAM feature).
327*/
328#define HA_HAS_CHECKSUM (1 << 24)
329/*
330 Table data are stored in separate files (for lower_case_table_names).
331 Should file names always be in lower case (used by engines that map
332 table names to file names.
333*/
334#define HA_FILE_BASED (1 << 26)
335#define HA_NO_VARCHAR (1 << 27)
336/*
337 Is the storage engine capable of handling bit fields.
338*/
339#define HA_CAN_BIT_FIELD (1 << 28)
340#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
341#define HA_NO_COPY_ON_ALTER (1LL << 31)
342#define HA_COUNT_ROWS_INSTANT (1LL << 32) /* records() gives exact count*/
343/* Has it's own method of binlog logging */
344#define HA_HAS_OWN_BINLOGGING (1LL << 33)
345/*
346 Engine is capable of row-format and statement-format logging,
347 respectively
348*/
349#define HA_BINLOG_ROW_CAPABLE (1LL << 34)
350#define HA_BINLOG_STMT_CAPABLE (1LL << 35)
351/*
352 When a multiple key conflict happens in a REPLACE command mysql
353 expects the conflicts to be reported in the ascending order of
354 key names.
355
356 For e.g.
357
358 CREATE TABLE t1 (a INT, UNIQUE (a), b INT NOT NULL, UNIQUE (b), c INT NOT
359 NULL, INDEX(c));
360
361 REPLACE INTO t1 VALUES (1,1,1),(2,2,2),(2,1,3);
362
363 MySQL expects the conflict with 'a' to be reported before the conflict with
364 'b'.
365
366 If the underlying storage engine does not report the conflicting keys in
367 ascending order, it causes unexpected errors when the REPLACE command is
368 executed.
369
370 This flag helps the underlying SE to inform the server that the keys are not
371 ordered.
372*/
373#define HA_DUPLICATE_KEY_NOT_IN_ORDER (1LL << 36)
374/*
375 Engine supports REPAIR TABLE. Used by CHECK TABLE FOR UPGRADE if an
376 incompatible table is detected. If this flag is set, CHECK TABLE FOR UPGRADE
377 will report ER_TABLE_NEEDS_UPGRADE, otherwise ER_TABLE_NEED_REBUILD.
378*/
379#define HA_CAN_REPAIR (1LL << 37)
380
381/*
382 Set of all binlog flags. Currently only contain the capabilities
383 flags.
384 */
385#define HA_BINLOG_FLAGS (HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE)
386
387/**
388 The handler supports read before write removal optimization
389
390 Read before write removal may be used for storage engines which support
391 write without previous read of the row to be updated. Handler returning
392 this flag must implement start_read_removal() and end_read_removal().
393 The handler may return "fake" rows constructed from the key of the row
394 asked for. This is used to optimize UPDATE and DELETE by reducing the
395 number of round-trips between handler and storage engine.
396
397 Example:
398 UPDATE a=1 WHERE pk IN (@<keys@>)
399
400 @verbatim
401 mysql_update()
402 {
403 if (<conditions for starting read removal>)
404 start_read_removal()
405 -> handler returns true if read removal supported for this table/query
406
407 while(read_record("pk=<key>"))
408 -> handler returns fake row with column "pk" set to <key>
409
410 ha_update_row()
411 -> handler sends write "a=1" for row with "pk=<key>"
412
413 end_read_removal()
414 -> handler returns the number of rows actually written
415 }
416 @endverbatim
417
418 @note This optimization in combination with batching may be used to
419 remove even more round-trips.
420*/
421#define HA_READ_BEFORE_WRITE_REMOVAL (1LL << 38)
422
423/*
424 Engine supports extended fulltext API
425 */
426#define HA_CAN_FULLTEXT_EXT (1LL << 39)
427
428/*
429 Storage engine doesn't synchronize result set with expected table contents.
430 Used by replication slave to check if it is possible to retrieve rows from
431 the table when deciding whether to do a full table scan, index scan or hash
432 scan while applying a row event.
433 */
434#define HA_READ_OUT_OF_SYNC (1LL << 40)
435
436/*
437 Storage engine supports table export using the
438 FLUSH TABLE <table_list> FOR EXPORT statement.
439 */
440#define HA_CAN_EXPORT (1LL << 41)
441
442/*
443 The handler don't want accesses to this table to
444 be const-table optimized
445*/
446#define HA_BLOCK_CONST_TABLE (1LL << 42)
447
448/*
449 Handler supports FULLTEXT hints
450*/
451#define HA_CAN_FULLTEXT_HINTS (1LL << 43)
452
453/**
454 Storage engine doesn't support LOCK TABLE ... READ LOCAL locks
455 but doesn't want to use handler::store_lock() API for upgrading
456 them to LOCK TABLE ... READ locks, for example, because it doesn't
457 use THR_LOCK locks at all.
458*/
459#define HA_NO_READ_LOCAL_LOCK (1LL << 44)
460
461/**
462 A storage engine is compatible with the attachable transaction requirements
463 means that
464
465 - either SE detects the fact that THD::ha_data was reset and starts a new
466 attachable transaction, closes attachable transaction on close_connection
467 and resumes regular (outer) transaction when THD::ha_data is restored;
468
469 - or SE completely ignores THD::ha_data and close_connection like MyISAM
470 does.
471*/
472#define HA_ATTACHABLE_TRX_COMPATIBLE (1LL << 45)
473
474/**
475 Handler supports Generated Columns
476*/
477#define HA_GENERATED_COLUMNS (1LL << 46)
478
479/**
480 Supports index on virtual generated column
481*/
482#define HA_CAN_INDEX_VIRTUAL_GENERATED_COLUMN (1LL << 47)
483
484/**
485 Supports descending indexes
486*/
487#define HA_DESCENDING_INDEX (1LL << 48)
488
489/**
490 Supports partial update of BLOB columns.
491*/
492#define HA_BLOB_PARTIAL_UPDATE (1LL << 49)
493
494/**
495 If this isn't defined, only columns/indexes with Cartesian coordinate systems
496 (projected SRS or SRID 0) is supported. Columns/indexes without SRID
497 restriction is also supported if this isn't defined.
498*/
499#define HA_SUPPORTS_GEOGRAPHIC_GEOMETRY_COLUMN (1LL << 50)
500
501/**
502 Handler supports expressions as DEFAULT for a column.
503*/
504#define HA_SUPPORTS_DEFAULT_EXPRESSION (1LL << 51)
505
506/**
507 Handlers with this flag set do not support UPDATE operations.
508*/
509#define HA_UPDATE_NOT_SUPPORTED (1LL << 52)
510
511/**
512 Handlers with this flag set do not support DELETE operations.
513*/
514#define HA_DELETE_NOT_SUPPORTED (1LL << 53)
515
516/**
517 The storage engine does not support using indexes for access. Indexes can only
518 be used for estimating cost.
519*/
520#define HA_NO_INDEX_ACCESS (1LL << 54)
521
522/**
523 Supports multi-valued index
524*/
525#define HA_MULTI_VALUED_KEY_SUPPORT (1LL << 55)
526
527/*
528 Bits in index_flags(index_number) for what you can do with index.
529 If you do not implement indexes, just return zero here.
530*/
531/*
532 Does the index support read next, this is assumed in the server
533 code and never checked so all indexes must support this.
534 Note that the handler can be used even if it doesn't have any index.
535*/
536#define HA_READ_NEXT 1 /* TODO really use this flag */
537/*
538 Can the index be used to scan backwards (supports ::index_prev).
539*/
540#define HA_READ_PREV 2
541/*
542 Can the index deliver its record in index order. Typically true for
543 all ordered indexes and not true for hash indexes. Used to set keymap
544 part_of_sortkey.
545 This keymap is only used to find indexes usable for resolving an ORDER BY
546 in the query. Thus in most cases index_read will work just fine without
547 order in result production. When this flag is set it is however safe to
548 order all output started by index_read since most engines do this. With
549 read_multi_range calls there is a specific flag setting order or not
550 order so in those cases ordering of index output can be avoided.
551*/
552#define HA_READ_ORDER 4
553/*
554 Specify whether index can handle ranges, typically true for all
555 ordered indexes and not true for hash indexes.
556 Used by optimiser to check if ranges (as key >= 5) can be optimised
557 by index.
558*/
559#define HA_READ_RANGE 8
560/*
561 Can't use part key searches. This is typically true for hash indexes
562 and typically not true for ordered indexes.
563*/
564#define HA_ONLY_WHOLE_INDEX 16
565/*
566 Index does not store NULL values, even if the column is nullable.
567 (KEY::flags may still contain HA_NULL_PART_KEY)
568 If the key has a NULL-value, the handler need to do a full table scan
569 instead of using this key. This is typically true for NDB hash indexes.
570*/
571#define HA_TABLE_SCAN_ON_NULL 32
572/*
573 Does the storage engine support index-only scans on this index.
574 Enables use of HA_EXTRA_KEYREAD and HA_EXTRA_NO_KEYREAD
575 Used to set Key_map keys_for_keyread and to check in optimiser for
576 index-only scans. When doing a read under HA_EXTRA_KEYREAD the handler
577 only have to fill in the columns the key covers. If
578 HA_PRIMARY_KEY_IN_READ_INDEX is set then also the PRIMARY KEY columns
579 must be updated in the row.
580*/
581#define HA_KEYREAD_ONLY 64
582/*
583 Index scan will not return records in rowid order. Not guaranteed to be
584 set for unordered (e.g. HASH) indexes.
585*/
586#define HA_KEY_SCAN_NOT_ROR 128
587#define HA_DO_INDEX_COND_PUSHDOWN 256 /* Supports Index Condition Pushdown */
588
589/* operations for disable/enable indexes */
590#define HA_KEY_SWITCH_NONUNIQ 0
591#define HA_KEY_SWITCH_ALL 1
592#define HA_KEY_SWITCH_NONUNIQ_SAVE 2
593#define HA_KEY_SWITCH_ALL_SAVE 3
594
595/*
596 Use this instead of 0 as the initial value for the slot number of
597 handlerton, so that we can distinguish uninitialized slot number
598 from slot 0.
599*/
600#define HA_SLOT_UNDEF ((uint)-1)
601
602/*
603 Parameters for open() (in register form->filestat)
604 HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
605*/
606
607#define HA_OPEN_KEYFILE 1
608#define HA_OPEN_RNDFILE 2
609#define HA_GET_INDEX 4
610#define HA_GET_INFO 8 /* do a handler::info() after open */
611#define HA_READ_ONLY 16 /* File opened as readonly */
612/* Try readonly if can't open with read and write */
613#define HA_TRY_READ_ONLY 32
614#define HA_WAIT_IF_LOCKED 64 /* Wait if locked on open */
615#define HA_ABORT_IF_LOCKED 128 /* skip if locked on open.*/
616#define HA_BLOCK_LOCK 256 /* unlock when reading some records */
617#define HA_OPEN_TEMPORARY 512
618
619/* Some key definitions */
620#define HA_KEY_NULL_LENGTH 1
621#define HA_KEY_BLOB_LENGTH 2
622
623#define HA_LEX_CREATE_TMP_TABLE 1
624#define HA_LEX_CREATE_IF_NOT_EXISTS 2
625#define HA_LEX_CREATE_TABLE_LIKE 4
626#define HA_LEX_CREATE_INTERNAL_TMP_TABLE 8
627#define HA_MAX_REC_LENGTH 65535U
628
629/**
630 Options for the START TRANSACTION statement.
631
632 Note that READ ONLY and READ WRITE are logically mutually exclusive.
633 This is enforced by the parser and depended upon by trans_begin().
634
635 We need two flags instead of one in order to differentiate between
636 situation when no READ WRITE/ONLY clause were given and thus transaction
637 is implicitly READ WRITE and the case when READ WRITE clause was used
638 explicitly.
639*/
640
641// WITH CONSISTENT SNAPSHOT option
643// READ ONLY option
645// READ WRITE option
647// HIGH PRIORITY option
649
671 DB_TYPE_PARTITION_DB, // No longer used.
676 DB_TYPE_MEMCACHE [[deprecated]],
679 /** Performance schema engine. */
683 DB_TYPE_DEFAULT = 127 // Must be last
685
686enum row_type : int {
694 /** Unused. Reserved for future versions. */
697
706
715};
716
718
719/* Bits in used_fields */
720#define HA_CREATE_USED_AUTO (1L << 0)
721#define HA_CREATE_USED_RAID (1L << 1) // RAID is no longer available
722#define HA_CREATE_USED_UNION (1L << 2)
723#define HA_CREATE_USED_INSERT_METHOD (1L << 3)
724#define HA_CREATE_USED_MIN_ROWS (1L << 4)
725#define HA_CREATE_USED_MAX_ROWS (1L << 5)
726#define HA_CREATE_USED_AVG_ROW_LENGTH (1L << 6)
727#define HA_CREATE_USED_PACK_KEYS (1L << 7)
728#define HA_CREATE_USED_CHARSET (1L << 8)
729#define HA_CREATE_USED_DEFAULT_CHARSET (1L << 9)
730#define HA_CREATE_USED_DATADIR (1L << 10)
731#define HA_CREATE_USED_INDEXDIR (1L << 11)
732#define HA_CREATE_USED_ENGINE (1L << 12)
733#define HA_CREATE_USED_CHECKSUM (1L << 13)
734#define HA_CREATE_USED_DELAY_KEY_WRITE (1L << 14)
735#define HA_CREATE_USED_ROW_FORMAT (1L << 15)
736#define HA_CREATE_USED_COMMENT (1L << 16)
737#define HA_CREATE_USED_PASSWORD (1L << 17)
738#define HA_CREATE_USED_CONNECTION (1L << 18)
739#define HA_CREATE_USED_KEY_BLOCK_SIZE (1L << 19)
740/** Unused. Reserved for future versions. */
741#define HA_CREATE_USED_TRANSACTIONAL (1L << 20)
742/** Unused. Reserved for future versions. */
743#define HA_CREATE_USED_PAGE_CHECKSUM (1L << 21)
744/** This is set whenever STATS_PERSISTENT=0|1|default has been
745specified in CREATE/ALTER TABLE. See also HA_OPTION_STATS_PERSISTENT in
746include/my_base.h. It is possible to distinguish whether
747STATS_PERSISTENT=default has been specified or no STATS_PERSISTENT= is
748given at all. */
749#define HA_CREATE_USED_STATS_PERSISTENT (1L << 22)
750/**
751 This is set whenever STATS_AUTO_RECALC=0|1|default has been
752 specified in CREATE/ALTER TABLE. See enum_stats_auto_recalc.
753 It is possible to distinguish whether STATS_AUTO_RECALC=default
754 has been specified or no STATS_AUTO_RECALC= is given at all.
755*/
756#define HA_CREATE_USED_STATS_AUTO_RECALC (1L << 23)
757/**
758 This is set whenever STATS_SAMPLE_PAGES=N|default has been
759 specified in CREATE/ALTER TABLE. It is possible to distinguish whether
760 STATS_SAMPLE_PAGES=default has been specified or no STATS_SAMPLE_PAGES= is
761 given at all.
762*/
763#define HA_CREATE_USED_STATS_SAMPLE_PAGES (1L << 24)
764
765/**
766 This is set whenever a 'TABLESPACE=...' phrase is used on CREATE TABLE
767*/
768#define HA_CREATE_USED_TABLESPACE (1L << 25)
769
770/** COMPRESSION="zlib|lz4|none" used during table create. */
771#define HA_CREATE_USED_COMPRESS (1L << 26)
772
773/** ENCRYPTION="Y" used during table create. */
774#define HA_CREATE_USED_ENCRYPT (1L << 27)
775
776/**
777 CREATE|ALTER SCHEMA|DATABASE|TABLE has an explicit COLLATE clause.
778
779 Implies HA_CREATE_USED_DEFAULT_CHARSET.
780*/
781#define HA_CREATE_USED_DEFAULT_COLLATE (1L << 28)
782
783/** SECONDARY_ENGINE used during table create. */
784#define HA_CREATE_USED_SECONDARY_ENGINE (1L << 29)
785
786/**
787 CREATE|ALTER SCHEMA|DATABASE has an explicit ENCRYPTION clause.
788
789 Implies HA_CREATE_USED_DEFAULT_ENCRYPTION.
790*/
791#define HA_CREATE_USED_DEFAULT_ENCRYPTION (1L << 30)
792
793/**
794 This option is used to convey that the create table should not
795 commit the operation and keep the transaction started.
796*/
797constexpr const uint64_t HA_CREATE_USED_START_TRANSACTION{1ULL << 31};
798
799constexpr const uint64_t HA_CREATE_USED_ENGINE_ATTRIBUTE{1ULL << 32};
800constexpr const uint64_t HA_CREATE_USED_SECONDARY_ENGINE_ATTRIBUTE{1ULL << 33};
801
802/**
803 ALTER SCHEMA|DATABASE has an explicit READ_ONLY clause.
804
805 Implies HA_CREATE_USED_READ_ONLY.
806*/
807constexpr const uint64_t HA_CREATE_USED_READ_ONLY{1ULL << 34};
808
809/**
810 These flags convey that the options AUTOEXTEND_SIZE has been
811 specified in the CREATE TABLE statement
812*/
813constexpr const uint64_t HA_CREATE_USED_AUTOEXTEND_SIZE{1ULL << 35};
814
815/*
816 End of bits used in used_fields
817*/
818
819/*
820 Structure to hold list of database_name.table_name.
821 This is used at both mysqld and storage engine layer.
822*/
824 const char *db;
825 const char *tablename;
826};
827
828#define MAXGTRIDSIZE 64
829#define MAXBQUALSIZE 64
830
831#define COMPATIBLE_DATA_YES 0
832#define COMPATIBLE_DATA_NO 1
833
834/*
835 These structures are used to pass information from a set of SQL commands
836 on add/drop/change tablespace definitions to the proper hton.
837*/
838#define UNDEF_NODEGROUP 65535
839
840// FUTURE: Combine these two enums into one enum class
855
865
866/**
867 Legacy struct for passing tablespace information to SEs.
868
869 FUTURE: Pass all info through dd objects
870 */
872 public:
873 const char *tablespace_name = nullptr;
874 const char *logfile_group_name = nullptr;
878 const char *data_file_name = nullptr;
879 const char *undo_file_name = nullptr;
880 ulonglong extent_size = 1024 * 1024; // Default 1 MByte
881 ulonglong undo_buffer_size = 8 * 1024 * 1024; // Default 8 MByte
882 ulonglong redo_buffer_size = 8 * 1024 * 1024; // Default 8 MByte
883 ulonglong initial_size = 128 * 1024 * 1024; // Default 128 MByte
884 std::optional<ulonglong> autoextend_size; // No autoextension as default
885 ulonglong max_size = 0; // Max size == initial size => no extension
886 ulonglong file_block_size = 0; // 0=default or must be a valid Page Size
889 const char *ts_comment = nullptr;
890 const char *encryption = nullptr;
891
893 return ts_cmd_type == CREATE_TABLESPACE ||
897 }
898
899 /**
900 Proper constructor even for all-public class simplifies initialization and
901 allows members to be const.
902
903 FUTURE: With constructor all members can be made const, and do not need
904 default initializers.
905
906 @param tablespace name of tabelspace (nullptr for logfile group statements)
907 @param logfile_group name of logfile group or nullptr
908 @param cmd main statement type
909 @param alter_tablespace_cmd subcommand type for ALTER TABLESPACE
910 @param datafile tablespace file for CREATE and ALTER ... ADD ...
911 @param undofile only applies to logfile group statements. nullptr otherwise.
912 @param opts options provided by parser
913 */
914 st_alter_tablespace(const char *tablespace, const char *logfile_group,
915 ts_command_type cmd,
916 enum ts_alter_tablespace_type alter_tablespace_cmd,
917 const char *datafile, const char *undofile,
918 const Tablespace_options &opts);
919};
920
921/*
922 Make sure that the order of schema_tables and enum_schema_tables are the same.
923*/
940
943enum ha_ddl_type : int {
949
950/** Clone start operation mode */
952 /** Start a new clone operation */
954
955 /** Re-start a clone operation after failure */
957
958 /** Add a new task to a running clone operation */
960
961 /** Get version for transfer data format */
963
964 /** Max value for clone mode */
967
968/** Clone operation types. */
969enum Ha_clone_type : size_t {
970 /** Caller must block all write operation to the SE. */
972
973 /** For transactional SE, archive redo to support concurrent dml */
975
976 /** For transactional SE, track page changes to support concurrent dml */
978
979 /** For transactional SE, use both page tracking and redo to optimize
980 clone with concurrent dml. Currently supported by Innodb. */
982
983 /** SE supports multiple threads for clone */
985
986 /** SE supports restarting clone after network failure */
988
989 /** Maximum value of clone type */
992
993using Ha_clone_flagset = std::bitset<HA_CLONE_TYPE_MAX>;
994
997
998/** File reference for clone */
1000 /** File reference type */
1001 enum {
1002 /** File handle */
1004
1005 /** File descriptor */
1006 FILE_DESC
1007
1009
1010 /** File reference */
1011 union {
1012 /** File descriptor */
1014
1015 /** File handle for windows */
1017 };
1018};
1019
1020/* Abstract callback interface to stream data back to the caller. */
1022 protected:
1023 /** Constructor to initialize members. */
1025 : m_hton(),
1026 m_loc_idx(),
1028 m_data_desc(),
1029 m_desc_len(),
1030 m_src_name(),
1031 m_dest_name(),
1033 m_flag() {}
1034
1035 public:
1036 /** Callback providing data from current position of a
1037 file descriptor of specific length.
1038 @param[in] from_file source file to read from
1039 @param[in] len data length
1040 @return error code */
1041 virtual int file_cbk(Ha_clone_file from_file, uint len) = 0;
1042
1043 /** Callback providing data in buffer of specific length.
1044 @param[in] from_buffer source buffer to read from
1045 @param[in] len data length
1046 @return error code */
1047 virtual int buffer_cbk(uchar *from_buffer, uint len) = 0;
1048
1049 /** Callback providing a file descriptor to write data starting
1050 from current position.
1051 @param[in] to_file destination file to write data
1052 @return error code */
1053 virtual int apply_file_cbk(Ha_clone_file to_file) = 0;
1054
1055 /** Callback to get data in buffer.
1056 @param[out] to_buffer data buffer
1057 @param[out] len data length
1058 @return error code */
1059 virtual int apply_buffer_cbk(uchar *&to_buffer, uint &len) = 0;
1060
1061 /** virtual destructor. */
1062 virtual ~Ha_clone_cbk() = default;
1063
1064 /** Set current storage engine handlerton.
1065 @param[in] hton SE handlerton */
1066 void set_hton(handlerton *hton) { m_hton = hton; }
1067
1068 /** Get current storage engine handlerton.
1069 @return SE handlerton */
1070 handlerton *get_hton() { return (m_hton); }
1071
1072 /** Set caller's transfer buffer size. SE can adjust the data chunk size
1073 based on this parameter.
1074 @param[in] size buffer size in bytes */
1076
1077 /** Get caller's transfer buffer size.
1078 @return buffer size in bytes */
1080
1081 /** Set current SE index.
1082 @param[in] idx SE index in locator array */
1083 void set_loc_index(uint idx) { m_loc_idx = idx; }
1084
1085 /** Get current SE index.
1086 @return SE index in locator array */
1087 uint get_loc_index() { return (m_loc_idx); }
1088
1089 /** Set data descriptor. SE specific descriptor for the
1090 data transferred by the callbacks.
1091 @param[in] desc serialized data descriptor
1092 @param[in] len length of the descriptor byte stream */
1093 void set_data_desc(const uchar *desc, uint len) {
1094 m_data_desc = desc;
1095 m_desc_len = len;
1096 }
1097
1098 /** Get data descriptor. SE specific descriptor for the
1099 data transferred by the callbacks.
1100 @param[out] lenp length of the descriptor byte stream
1101 @return pointer to the serialized data descriptor */
1102 const uchar *get_data_desc(uint *lenp) {
1103 if (lenp != nullptr) {
1104 *lenp = m_desc_len;
1105 }
1106
1107 return (m_data_desc);
1108 }
1109
1110 /** Get SE source file name. Used for debug printing and error message.
1111 @return null terminated string for source file name */
1112 const char *get_source_name() { return (m_src_name); }
1113
1114 /** Set SE source file name.
1115 @param[in] name null terminated string for source file name */
1116 void set_source_name(const char *name) { m_src_name = name; }
1117
1118 /** Get SE destination file name. Used for debug printing and error message.
1119 @return null terminated string for destination file name */
1120 const char *get_dest_name() { return (m_dest_name); }
1121
1122 /** Set SE destination file name.
1123 @param[in] name null terminated string for destination file name */
1124 void set_dest_name(const char *name) { m_dest_name = name; }
1125
1126 /** Clear all flags set by SE */
1127 void clear_flags() { m_flag = 0; }
1128
1129 /** Mark that ACK is needed for the data transfer before returning
1130 from callback. Set by SE. */
1132
1133 /** Check if ACK is needed for the data transfer
1134 @return true if ACK is needed */
1135 bool is_ack_needed() const { return (m_flag & HA_CLONE_ACK); }
1136
1137 /** Mark that the file descriptor is opened for read/write
1138 with OS buffer cache. For O_DIRECT, the flag is not set. */
1140
1141 /** Check if the file descriptor is opened for read/write with OS
1142 buffer cache. Currently clone avoids using zero copy (sendfile on linux),
1143 if SE is using O_DIRECT. This improves data copy performance.
1144 @return true if O_DIRECT is not used */
1145 bool is_os_buffer_cache() const { return (m_flag & HA_CLONE_FILE_CACHE); }
1146
1147 /** Mark that the file can be transferred with zero copy. */
1149
1150 /** Check if zero copy optimization is suggested. */
1151 bool is_zero_copy() const { return (m_flag & HA_CLONE_ZERO_COPY); }
1152
1153 /** Mark that data needs secure transfer. */
1155
1156 /** Check if data needs secure transfer. */
1157 bool is_secure() const { return (m_flag & HA_CLONE_SECURE); }
1158
1159 /** Set state information and notify state change.
1160 @param[in] estimate estimated bytes for current state. */
1161 void mark_state_change(uint64_t estimate) {
1163 m_state_estimate = estimate;
1164 }
1165
1166 /** Check if SE notified state change. */
1167 bool is_state_change(uint64_t &estimate) {
1168 estimate = m_state_estimate;
1169 return (m_flag & HA_CLONE_STATE_CHANGE);
1170 }
1171
1172 private:
1173 /** Handlerton for the SE */
1175
1176 /** SE index in caller's locator array */
1178
1179 /** Caller's transfer buffer size. */
1181
1182 /** SE's Serialized data descriptor */
1184
1185 /** SE's Serialized descriptor length. */
1187
1188 /** Current source file name */
1189 const char *m_src_name;
1190
1191 /** Current destination file name */
1192 const char *m_dest_name;
1193
1194 /** Estimated bytes to be transferred. */
1196
1197 /** Flag storing data related options */
1199
1200 /** Acknowledgement is needed for the data transfer. */
1201 const int HA_CLONE_ACK = 0x01;
1202
1203 /** Data file is opened for read/write with OS buffer cache. */
1204 const int HA_CLONE_FILE_CACHE = 0x02;
1205
1206 /** Data file can be transferred with zero copy. */
1207 const int HA_CLONE_ZERO_COPY = 0x04;
1208
1209 /** Data needs to be transferred securely over SSL connection. */
1210 const int HA_CLONE_SECURE = 0x08;
1211
1212 /** State change notification by SE. */
1213 const int HA_CLONE_STATE_CHANGE = 0x10;
1214};
1215
1216/**
1217 Column type description for foreign key columns compatibility check.
1218
1219 Contains subset of information from dd::Column class. It is inconvenient
1220 to use dd::Column class directly for such checks because it requires valid
1221 dd::Table object and in some cases we want to produce Ha_fk_column_type
1222 right from column description in Create_field format.
1223*/
1226 /*
1227 Note that both dd::Column::char_length() and length here are really
1228 in bytes.
1229 */
1235};
1236
1237typedef ulonglong my_xid; // this line is the same as in log_event.h
1238/**
1239 Enumeration of possible states for externally coordinated transactions (XA).
1240 */
1242 NOT_FOUND = -1, // Trnasaction not found
1243 PREPARED_IN_SE = 0, // Transaction is prepared in SEs
1244 PREPARED_IN_TC = 1, // Transaction is prepared in SEs and TC
1245 COMMITTED_WITH_ONEPHASE = 2, // Transaction was one-phase committed
1246 COMMITTED = 3, // Transaction was committed
1247 ROLLEDBACK = 4 // Transaction was rolled back
1248};
1249/**
1250 Single occurrence set of XIDs of internally coordinated transactions
1251 found as been committed in the transaction coordinator state.
1252 */
1254 std::unordered_set<my_xid, std::hash<my_xid>, std::equal_to<my_xid>,
1256
1257/**
1258 Class to maintain list of externally coordinated transactions and their
1259 current state at recovery.
1260 */
1262 public:
1263 using pair = std::pair<const XID, enum_ha_recover_xa_state>;
1265 using list = std::map<XID, enum_ha_recover_xa_state, std::less<XID>,
1267 using iterator = std::map<XID, enum_ha_recover_xa_state, std::less<XID>,
1269 using instantiation_tuple = std::tuple<
1270 std::unique_ptr<MEM_ROOT>, std::unique_ptr<Xa_state_list::allocator>,
1271 std::unique_ptr<Xa_state_list::list>, std::unique_ptr<Xa_state_list>>;
1272
1273 /**
1274 Class constructor.
1275
1276 @param populated_by_tc The underlying list of XIDs and transaction
1277 states, after being populated by the transaction
1278 coodinator.
1279 */
1280 Xa_state_list(Xa_state_list::list &populated_by_tc);
1281 virtual ~Xa_state_list() = default;
1282
1283 /**
1284 Searches the underlying map to find an key that corresponds to the
1285 parameter.
1286
1287 @param to_find The XID to find within the underlying map.
1288
1289 @return Ha_recover_states::NOT_FOUND if the transaction wasn't found,
1290 the state of the transaction, otherwise.
1291 */
1292 enum_ha_recover_xa_state find(XID const &to_find);
1293 /**
1294 Adds a transaction and state to the underlying map. If the given XID
1295 already exists in the underlying map, the associated state changes according
1296 to the following rules:
1297
1298 - If the parameter state is `PREPARED_IN_SE` it means that the
1299 transaction didn't reach PREPARED_IN_TC, COMMIT or ROLLBACK for
1300 sure. In that case:
1301 . If other participants state is `COMMITTED`/`ROLLEDBACK`, it would
1302 mean that it's a state inherited from a previous execution with the
1303 same XID and we should set the state to `PREPARED_IN_SE`.
1304 . If other participants state is `PREPARED_IN_TC`/
1305 `COMMITTED_WITH_ONEPHASE` it means that the current participant
1306 didn't reach it but some other did so, keep the state as
1307 `PREPARED_IN_TC`/`COMMITTED_WITH_ONEPHASE`.
1308
1309 - If the parameter state is `PREPARED_IN_TC`, it means that other
1310 participants must have persisted either the PREPARE, the COMMIT or
1311 the ROLLBACK. In that case, keep whatever state is already there and
1312 ensure that is not `PREPARED_IN_SE`.
1313
1314 - If the parameter state is `COMMITTED_WITH_ONEPHASE`, `COMMITTED` or
1315 `ROLLEDBACK`, do nothing, only the active transaction coordinator has
1316 the ability, for now, to set the transaction state to those values.
1317
1318 @param xid The XID to be added (the key).
1319 @param state The state to be added (the value).
1320
1321 @return The current value of the transaction state if the XID has
1322 already been added, Ha_recover_states::NOT_FOUND otherwise.
1323 */
1325 /**
1326 Factory like method to instantiate all the infra-structure needed to
1327 create an `Xa_state_list`. Since such infra-structuer is dependent on
1328 `MEM_ROOT` and `Mem_root_allocator`, the method returns a tuple
1329 containing unique pointers to all 4 objects needed: MEM_ROOT;
1330 Mem_root_allocator; Xa_state_list::list; Xa_state_list.
1331
1332 @return An std::tuple containing unique pointers to all 4 objects
1333 needed: MEM_ROOT; Mem_root_allocator; Xa_state_list::list;
1334 Xa_state_list.
1335 */
1337
1338 private:
1339 /** The underlying map holding the trx and states*/
1341};
1342
1343/* handlerton methods */
1344
1345/**
1346 close_connection is only called if
1347 thd->ha_data[xxx_hton.slot] is non-zero, so even if you don't need
1348 this storage area - set it to something, so that MySQL would know
1349 this storage engine was accessed in this connection
1350*/
1351typedef int (*close_connection_t)(handlerton *hton, THD *thd);
1352
1353/** Terminate connection/statement notification. */
1354typedef void (*kill_connection_t)(handlerton *hton, THD *thd);
1355
1356/**
1357 Shut down all storage engine background tasks that might access
1358 the data dictionary, before the main shutdown.
1359*/
1360typedef void (*pre_dd_shutdown_t)(handlerton *hton);
1361
1362/**
1363 Some plugin session variables may require some special handling
1364 upon clean up. Reset appropriately these variables before
1365 ending the THD connection
1366*/
1367typedef void (*reset_plugin_vars_t)(THD *thd);
1368
1369/**
1370 sv points to a storage area, that was earlier passed
1371 to the savepoint_set call
1372*/
1373typedef int (*savepoint_rollback_t)(handlerton *hton, THD *thd, void *sv);
1374
1375/**
1376 sv points to an uninitialized storage area of requested size
1377 (see savepoint_offset description)
1378*/
1379typedef int (*savepoint_set_t)(handlerton *hton, THD *thd, void *sv);
1380
1381/**
1382 Check if storage engine allows to release metadata locks which were
1383 acquired after the savepoint if rollback to savepoint is done.
1384 @return true - If it is safe to release MDL locks.
1385 false - If it is not.
1386*/
1388 THD *thd);
1389
1390typedef int (*savepoint_release_t)(handlerton *hton, THD *thd, void *sv);
1391
1392/**
1393 'all' is true if it's a real commit, that makes persistent changes
1394 'all' is false if it's not in fact a commit but an end of the
1395 statement that is part of the transaction.
1396 NOTE 'all' is also false in auto-commit mode where 'end of statement'
1397 and 'real commit' mean the same event.
1398*/
1399typedef int (*commit_t)(handlerton *hton, THD *thd, bool all);
1400
1401typedef int (*rollback_t)(handlerton *hton, THD *thd, bool all);
1402
1403typedef int (*prepare_t)(handlerton *hton, THD *thd, bool all);
1404
1405typedef int (*recover_t)(handlerton *hton, XA_recover_txn *xid_list, uint len,
1407/**
1408 Retrieves information about externally coordinated transactions for which
1409 the two-phase prepare was finished and transactions were prepared in the
1410 server TC.
1411 */
1413 Xa_state_list &xa_list);
1414/**
1415 Instructs the storage engine to mark the externally coordinated
1416 transactions held by the THD parameters as prepared in the server TC.
1417 */
1418using set_prepared_in_tc_t = int (*)(handlerton *hton, THD *thd);
1419
1420/** X/Open XA distributed transaction status codes */
1422 /**
1423 normal execution
1424 */
1426
1427 /**
1428 asynchronous operation already outstanding
1429 */
1431
1432 /**
1433 a resource manager error occurred in the transaction branch
1434 */
1436
1437 /**
1438 the XID is not valid
1439 */
1441
1442 /**
1443 invalid arguments were given
1444 */
1446
1447 /**
1448 routine invoked in an improper context
1449 */
1451
1452 /**
1453 resource manager unavailable
1454 */
1456
1457 /**
1458 the XID already exists
1459 */
1461
1462 /**
1463 resource manager doing work outside transaction
1464 */
1465 XAER_OUTSIDE = -9
1467
1469
1471
1472/**
1473 Instructs the storage engine to mark the externally coordinated
1474 transactions identified by the XID parameters as prepared in the server
1475 TC.
1476 */
1478 XID *xid);
1479
1480/**
1481 Create handler object for the table in the storage engine.
1482
1483 @param hton Handlerton object for the storage engine.
1484 @param table TABLE_SHARE for the table, can be NULL if caller
1485 didn't perform full-blown open of table definition.
1486 @param partitioned Indicates whether table is partitioned.
1487 @param mem_root Memory root to be used for allocating handler
1488 object.
1489*/
1490typedef handler *(*create_t)(handlerton *hton, TABLE_SHARE *table,
1491 bool partitioned, MEM_ROOT *mem_root);
1492
1493typedef void (*drop_database_t)(handlerton *hton, const char *db);
1494
1495typedef bool (*log_ddl_drop_schema_t)(handlerton *hton,
1496 const char *schema_name);
1497
1499 const char *schema_name);
1500
1501typedef int (*panic_t)(handlerton *hton, enum ha_panic_function flag);
1502
1503typedef int (*start_consistent_snapshot_t)(handlerton *hton, THD *thd);
1504
1505/**
1506 Flush the log(s) of storage engine(s).
1507
1508 @param hton Handlerton of storage engine.
1509 @param binlog_group_flush true if we got invoked by binlog group
1510 commit during flush stage, false in other cases.
1511 @retval false Succeed
1512 @retval true Error
1513*/
1514typedef bool (*flush_logs_t)(handlerton *hton, bool binlog_group_flush);
1515
1516typedef bool (*show_status_t)(handlerton *hton, THD *thd, stat_print_fn *print,
1517 enum ha_stat_type stat);
1518
1519/**
1520 The flag values are defined in sql_partition.h.
1521 If this function is set, then it implies that the handler supports
1522 partitioned tables.
1523 If this function exists, then handler::get_partition_handler must also be
1524 implemented.
1525*/
1526typedef uint (*partition_flags_t)();
1527
1528/**
1529 SE specific validation of the tablespace name.
1530
1531 This function will ask the relevant SE whether the submitted tablespace
1532 name is valid.
1533
1534 @param ts_cmd Purpose of usage - is this tablespace DDL?
1535 @param tablespace_name Name of the tablespace.
1536
1537 @return Tablespace name validity.
1538 @retval Whether the tablespace name is valid.
1539*/
1541 const char *tablespace_name);
1542
1543/**
1544 Create/drop or alter tablespace in the storage engine.
1545
1546 @param hton Hadlerton of the SE.
1547 @param thd Thread context.
1548 @param ts_info Description of tablespace and specific
1549 operation on it.
1550 @param old_ts_def dd::Tablespace object describing old version
1551 of tablespace.
1552 @param [in,out] new_ts_def dd::Tablespace object describing new version
1553 of tablespace. Engines which support atomic DDL
1554 can adjust this object. The updated information
1555 will be saved to the data-dictionary.
1556
1557 @return Operation status.
1558 @retval == 0 Success.
1559 @retval != 0 Error (handler error code returned).
1560*/
1561typedef int (*alter_tablespace_t)(handlerton *hton, THD *thd,
1562 st_alter_tablespace *ts_info,
1563 const dd::Tablespace *old_ts_def,
1564 dd::Tablespace *new_ts_def);
1565
1566/**
1567 SE interface for getting tablespace extension.
1568 @return Extension of tablespace datafile name.
1569*/
1570typedef const char *(*get_tablespace_filename_ext_t)();
1571
1572/**
1573 Get the tablespace data from SE and insert it into Data dictionary
1574
1575 @param thd Thread context
1576
1577 @return Operation status.
1578 @retval == 0 Success.
1579 @retval != 0 Error (handler error code returned)
1580*/
1581typedef int (*upgrade_tablespace_t)(THD *thd);
1582
1583/**
1584 Get the tablespace data from SE and insert it into Data dictionary
1585
1586 @param[in] tablespace tablespace object
1587
1588 @return Operation status.
1589 @retval == 0 Success.
1590 @retval != 0 Error (handler error code returned)
1591*/
1592typedef bool (*upgrade_space_version_t)(dd::Tablespace *tablespace);
1593
1594/**
1595 Finish upgrade process inside storage engines.
1596 This includes resetting flags to indicate upgrade process
1597 and cleanup after upgrade.
1598
1599 @param thd Thread context
1600 @param failed_upgrade True if the upgrade failed.
1601
1602 @return Operation status.
1603 @retval == 0 Success.
1604 @retval != 0 Error (handler error code returned)
1605*/
1606typedef int (*finish_upgrade_t)(THD *thd, bool failed_upgrade);
1607
1608/**
1609 Upgrade logs after the checkpoint from where upgrade
1610 process can only roll forward.
1611
1612 @param thd Thread context
1613
1614 @return Operation status.
1615 @retval == 0 Success.
1616 @retval != 0 Error (handler error code returned)
1617*/
1618typedef int (*upgrade_logs_t)(THD *thd);
1619
1627};
1628
1629/**
1630 Get the tablespace type from the SE.
1631
1632 @param[in] space tablespace object
1633 @param[out] space_type type of space
1634
1635 @return Operation status.
1636 @retval false on success and true for failure.
1637*/
1638typedef bool (*get_tablespace_type_t)(const dd::Tablespace &space,
1639 Tablespace_type *space_type);
1640
1641/**
1642 Get the tablespace type given the name, from the SE.
1643
1644 @param[in] tablespace_name tablespace name
1645 @param[out] space_type type of space
1646
1647 @return Operation status.
1648 @retval false on success and true for failure.
1649*/
1650typedef bool (*get_tablespace_type_by_name_t)(const char *tablespace_name,
1651 Tablespace_type *space_type);
1652
1653typedef int (*fill_is_table_t)(handlerton *hton, THD *thd, Table_ref *tables,
1654 class Item *cond, enum enum_schema_tables);
1655
1656typedef int (*binlog_func_t)(handlerton *hton, THD *thd, enum_binlog_func fn,
1657 void *arg);
1658
1659typedef void (*binlog_log_query_t)(handlerton *hton, THD *thd,
1660 enum_binlog_command binlog_command,
1661 const char *query, uint query_length,
1662 const char *db, const char *table_name);
1663
1664typedef void (*acl_notify_t)(THD *thd,
1665 const class Acl_change_notification *notice);
1666
1667typedef int (*discover_t)(handlerton *hton, THD *thd, const char *db,
1668 const char *name, uchar **frmblob, size_t *frmlen);
1669
1670typedef int (*find_files_t)(handlerton *hton, THD *thd, const char *db,
1671 const char *path, const char *wild, bool dir,
1672 List<LEX_STRING> *files);
1673
1674typedef int (*table_exists_in_engine_t)(handlerton *hton, THD *thd,
1675 const char *db, const char *name);
1676
1677/**
1678 Let storage engine inspect the query Accesspath and pick whatever
1679 it like for being pushed down to the engine. (Join, conditions, ..)
1680
1681 The handler implementation should itself keep track of what it 'pushed',
1682 such that later calls to the handlers access methods should
1683 activate the pushed parts of the execution plan on the storage
1684 engines.
1685
1686 @param thd Thread context
1687 @param query The AccessPath for the entire query.
1688 @param join The JOIN to be pushed
1689
1690 @returns
1691 0 on success
1692 error otherwise
1693*/
1694using push_to_engine_t = int (*)(THD *thd, AccessPath *query, JOIN *join);
1695
1696/**
1697 Check if the given db.tablename is a system table for this SE.
1698
1699 @param db Database name to check.
1700 @param table_name table name to check.
1701 @param is_sql_layer_system_table if the supplied db.table_name is a SQL
1702 layer system table.
1703
1704 @see example_is_supported_system_table in ha_example.cc
1705
1706 is_sql_layer_system_table is supplied to make more efficient
1707 checks possible for SEs that support all SQL layer tables.
1708
1709 This interface is optional, so every SE need not implement it.
1710*/
1711typedef bool (*is_supported_system_table_t)(const char *db,
1712 const char *table_name,
1713 bool is_sql_layer_system_table);
1714
1715/**
1716 Create SDI in a tablespace. This API should be used when upgrading
1717 a tablespace with no SDI or after invoking sdi_drop().
1718 @param[in] tablespace tablespace object
1719 @retval false success
1720 @retval true failure
1721*/
1722typedef bool (*sdi_create_t)(dd::Tablespace *tablespace);
1723
1724/**
1725 Drop SDI in a tablespace. This API should be used only when
1726 SDI is corrupted.
1727 @param[in] tablespace tablespace object
1728 @retval false success
1729 @retval true failure
1730*/
1731typedef bool (*sdi_drop_t)(dd::Tablespace *tablespace);
1732
1733/**
1734 Get the SDI keys in a tablespace into vector.
1735 @param[in] tablespace tablespace object
1736 @param[in,out] vector vector of SDI Keys
1737 @retval false success
1738 @retval true failure
1739*/
1740typedef bool (*sdi_get_keys_t)(const dd::Tablespace &tablespace,
1742
1743/**
1744 Retrieve SDI for a given SDI key.
1745
1746 Since the caller of this api will not know the SDI length, SDI retrieval
1747 should be done in the following way.
1748
1749 i. Allocate initial memory of some size (Lets say 64KB)
1750 ii. Pass the allocated memory to the below api.
1751 iii. If passed buffer is sufficient, sdi_get_by_id() copies the sdi
1752 to the buffer passed and returns success, else sdi_len is modified
1753 with the actual length of the SDI (and returns false on failure).
1754 For genuine errors, sdi_len is returned as UINT64_MAX
1755 iv. If sdi_len != UINT64_MAX, retry the call after allocating the memory
1756 of sdi_len
1757 v. Free the memory after using SDI (responsibility of caller)
1758
1759 @param[in] tablespace tablespace object
1760 @param[in] sdi_key SDI key to uniquely identify SDI obj
1761 @param[in,out] sdi SDI retrieved from tablespace
1762 A non-null pointer must be passed in
1763 @param[in,out] sdi_len in: length of the memory allocated
1764 out: actual length of SDI
1765 @retval false success
1766 @retval true failure
1767*/
1768typedef bool (*sdi_get_t)(const dd::Tablespace &tablespace,
1769 const sdi_key_t *sdi_key, void *sdi, uint64 *sdi_len);
1770
1771/**
1772 Insert/Update SDI for a given SDI key.
1773 @param[in] hton handlerton object
1774 @param[in] tablespace tablespace object
1775 @param[in] table table object
1776 @param[in] sdi_key SDI key to uniquely identify SDI obj
1777 @param[in] sdi SDI to write into the tablespace
1778 @param[in] sdi_len length of SDI BLOB returned
1779 @retval false success
1780 @retval true failure, my_error() should be called
1781 by SE
1782*/
1783typedef bool (*sdi_set_t)(handlerton *hton, const dd::Tablespace &tablespace,
1784 const dd::Table *table, const sdi_key_t *sdi_key,
1785 const void *sdi, uint64 sdi_len);
1786
1787/**
1788 Delete SDI for a given SDI key.
1789 @param[in] tablespace tablespace object
1790 @param[in] table table object
1791 @param[in] sdi_key SDI key to uniquely identify SDI obj
1792 @retval false success
1793 @retval true failure, my_error() should be called
1794 by SE
1795*/
1796typedef bool (*sdi_delete_t)(const dd::Tablespace &tablespace,
1797 const dd::Table *table, const sdi_key_t *sdi_key);
1798
1799/**
1800 Check if the DDSE is started in a way that leaves thd DD being read only.
1801
1802 @retval true The data dictionary can only be read.
1803 @retval false The data dictionary can be read and written.
1804 */
1805typedef bool (*is_dict_readonly_t)();
1806
1807/**
1808 Drop all temporary tables which have been left from previous server
1809 run belonging to this SE. Used on server start-up.
1810
1811 @param[in] hton Handlerton for storage engine.
1812 @param[in] thd Thread context.
1813 @param[in,out] files List of files in directories for temporary files
1814 which match tmp_file_prefix and thus can belong to
1815 temporary tables (but not necessarily in this SE).
1816 It is recommended to remove file from the list if
1817 SE recognizes it as belonging to temporary table
1818 in this SE and deletes it.
1819*/
1820typedef bool (*rm_tmp_tables_t)(handlerton *hton, THD *thd,
1821 List<LEX_STRING> *files);
1822
1823/**
1824 Retrieve cost constants to be used for this storage engine.
1825
1826 A storage engine that wants to provide its own cost constants to
1827 be used in the optimizer cost model, should implement this function.
1828 The server will call this function to get a cost constant object
1829 that will be used for tables stored in this storage engine instead
1830 of using the default cost constants.
1831
1832 Life cycle for the cost constant object: The storage engine must
1833 allocate the cost constant object on the heap. After the function
1834 returns, the server takes over the ownership of this object.
1835 The server will eventually delete the object by calling delete.
1836
1837 @note In the initial version the storage_category parameter will
1838 not be used. The only valid value this will have is DEFAULT_STORAGE_CLASS
1839 (see declaration in opt_costconstants.h).
1840
1841 @param storage_category the storage type that the cost constants will
1842 be used for
1843
1844 @return a pointer to the cost constant object, if NULL is returned
1845 the default cost constants will be used
1846*/
1847typedef SE_cost_constants *(*get_cost_constants_t)(uint storage_category);
1848
1849/**
1850 @param[in,out] thd pointer to THD
1851 @param[in] new_trx_arg pointer to replacement transaction
1852 @param[out] ptr_trx_arg double pointer to being replaced transaction
1853
1854 Associated with THD engine's native transaction is replaced
1855 with @c new_trx_arg. The old value is returned through a buffer if non-null
1856 pointer is provided with @c ptr_trx_arg.
1857 The method is adapted by XA start and XA prepare handlers to
1858 handle XA transaction that is logged as two parts by slave applier.
1859
1860 This interface concerns engines that are aware of XA transaction.
1861*/
1862typedef void (*replace_native_transaction_in_thd_t)(THD *thd, void *new_trx_arg,
1863 void **ptr_trx_arg);
1864
1865/** Mode for initializing the data dictionary. */
1867 DICT_INIT_CREATE_FILES, ///< Create all required SE files
1868 DICT_INIT_CHECK_FILES ///< Verify existence of expected files
1870
1871/**
1872 Initialize the SE for being used to store the DD tables. Create
1873 the required files according to the dict_init_mode. Create strings
1874 representing the required DDSE tables, i.e., tables that the DDSE
1875 expects to exist in the DD, and add them to the appropriate out
1876 parameter.
1877
1878 @note There are two variants of this function type, one is to be
1879 used by the DDSE, and has a different type of output parameters
1880 because the SQL layer needs more information about the DDSE tables
1881 in order to support upgrade.
1882
1883 @param dict_init_mode How to initialize files
1884 @param version Target DD version if a new
1885 server is being installed.
1886 0 if restarting an existing
1887 server.
1888 @param [out] DDSE_tables List of SQL DDL statements
1889 for creating DD tables that
1890 are needed by the DDSE.
1891 @param [out] DDSE_tablespaces List of meta data for predefined
1892 tablespaces created by the DDSE.
1893
1894 @retval true An error occurred.
1895 @retval false Success - no errors.
1896 */
1897
1898typedef bool (*dict_init_t)(dict_init_mode_t dict_init_mode, uint version,
1899 List<const Plugin_table> *DDSE_tables,
1900 List<const Plugin_tablespace> *DDSE_tablespaces);
1901
1902typedef bool (*ddse_dict_init_t)(
1903 dict_init_mode_t dict_init_mode, uint version,
1904 List<const dd::Object_table> *DDSE_tables,
1905 List<const Plugin_tablespace> *DDSE_tablespaces);
1906
1907/**
1908 Initialize the set of hard coded DD table ids.
1909*/
1910typedef void (*dict_register_dd_table_id_t)(dd::Object_id hard_coded_tables);
1911
1912/**
1913 Invalidate an entry in the local dictionary cache.
1914
1915 Needed during bootstrap to make sure the contents in the DDSE
1916 dictionary cache is in sync with the global DD.
1917
1918 @param schema_name Schema name.
1919 @param table_name Table name.
1920 */
1921
1922typedef void (*dict_cache_reset_t)(const char *schema_name,
1923 const char *table_name);
1924
1925/**
1926 Invalidate all table and tablespace entries in the local dictionary cache.
1927
1928 Needed for recovery during server restart.
1929 */
1930
1932
1933/** Mode for data dictionary recovery. */
1935 DICT_RECOVERY_INITIALIZE_SERVER, ///< First start of a new server
1936 DICT_RECOVERY_INITIALIZE_TABLESPACES, ///< First start, create tablespaces
1937 DICT_RECOVERY_RESTART_SERVER ///< Restart of an existing server
1939
1940/**
1941 Do recovery in the DDSE as part of initializing the data dictionary.
1942 The dict_recovery_mode indicates what kind of recovery should be
1943 done.
1944
1945 @param dict_recovery_mode How to do recovery
1946 @param version Target DD version if a new
1947 server is being installed.
1948 Actual DD version if restarting
1949 an existing server.
1950
1951 @retval true An error occurred.
1952 @retval false Success - no errors.
1953 */
1954
1955typedef bool (*dict_recover_t)(dict_recovery_mode_t dict_recovery_mode,
1956 uint version);
1957
1958/**
1959 Get the server version id stored in the header of the
1960 dictionary tablespace.
1961
1962 @param [out] version Version number from the DD
1963 tablespace header.
1964
1965 @retval Operation outcome, false if no error, otherwise true.
1966*/
1967typedef bool (*dict_get_server_version_t)(uint *version);
1968
1969/**
1970 Store the current server version number into the
1971 header of the dictionary tablespace.
1972
1973 @retval Operation outcome, false if no error, otherwise true.
1974*/
1976
1977/**
1978 Notify/get permission from storage engine before acquisition or after
1979 release of exclusive metadata lock on object represented by key.
1980
1981 @param thd Thread context.
1982 @param mdl_key MDL key identifying object on which exclusive
1983 lock is to be acquired/was released.
1984 @param notification_type Indicates whether this is pre-acquire or
1985 post-release notification.
1986 @param victimized 'true' if locking failed as we were selected
1987 as a victim in order to avoid possible deadlocks.
1988
1989 @note Notification is done only for objects from TABLESPACE, SCHEMA,
1990 TABLE, FUNCTION, PROCEDURE, TRIGGER and EVENT namespaces.
1991
1992 @note Problems during notification are to be reported as warnings, MDL
1993 subsystem will report generic error if pre-acquire notification
1994 fails/SE refuses lock acquisition.
1995 @note Return value is ignored/error is not reported in case of
1996 post-release notification.
1997
1998 @note In some cases post-release notification might happen even if
1999 there were no prior pre-acquire notification. For example,
2000 when SE was loaded after exclusive lock acquisition, or when
2001 we need notify SEs which permitted lock acquisition that it
2002 didn't happen because one of SEs didn't allow it (in such case
2003 we will do post-release notification for all SEs for simplicity).
2004
2005 @return False - if notification was successful/lock can be acquired,
2006 True - if it has failed/lock should not be acquired.
2007*/
2008typedef bool (*notify_exclusive_mdl_t)(THD *thd, const MDL_key *mdl_key,
2009 ha_notification_type notification_type,
2010 bool *victimized);
2011
2012/**
2013 Notify/get permission from storage engine before or after execution of
2014 ALTER TABLE operation on the table identified by the MDL key.
2015
2016 @param thd Thread context.
2017 @param mdl_key MDL key identifying table which is going to be
2018 or was ALTERed.
2019 @param notification_type Indicates whether this is pre-ALTER TABLE or
2020 post-ALTER TABLE notification.
2021
2022 @note This hook is necessary because for ALTER TABLE upgrade to X
2023 metadata lock happens fairly late during the execution process,
2024 so it can be expensive to abort ALTER TABLE operation at this
2025 stage by returning failure from notify_exclusive_mdl() hook.
2026
2027 @note This hook follows the same error reporting convention as
2028 @see notify_exclusive_mdl().
2029
2030 @note Similarly to notify_exclusive_mdl() in some cases post-ALTER
2031 notification might happen even if there were no prior pre-ALTER
2032 notification.
2033
2034 @note Post-ALTER notification can happen before post-release notification
2035 for exclusive metadata lock acquired by this ALTER TABLE.
2036
2037 @return False - if notification was successful/ALTER TABLE can proceed.
2038 True - if it has failed/ALTER TABLE should be aborted.
2039*/
2040typedef bool (*notify_alter_table_t)(THD *thd, const MDL_key *mdl_key,
2041 ha_notification_type notification_type);
2042
2043/**
2044 Notify/get permission from storage engine before or after execution of
2045 RENAME TABLE operation on the table identified by the MDL key.
2046
2047 @param thd Thread context.
2048 @param mdl_key MDL key identifying table which is going to be
2049 or was RENAMEd.
2050 @param notification_type Indicates whether this is pre-RENAME TABLE or
2051 post-RENAME TABLE notification.
2052 @param old_db_name old db name
2053 @param old_table_name old table name
2054 @param new_db_name new db name
2055 @param new_table_name new table name
2056*/
2057typedef bool (*notify_rename_table_t)(THD *thd, const MDL_key *mdl_key,
2058 ha_notification_type notification_type,
2059 const char *old_db_name,
2060 const char *old_table_name,
2061 const char *new_db_name,
2062 const char *new_table_name);
2063
2064/**
2065 Notify/get permission from storage engine before or after execution of
2066 TRUNCATE TABLE operation on the table identified by the MDL key.
2067
2068 @param thd Thread context.
2069 @param mdl_key MDL key identifying table which is going to be
2070 or was TRUNCATEd.
2071 @param notification_type Indicates whether this is pre-TRUNCATE TABLE or
2072 post-TRUNCATE TABLE notification.
2073*/
2074typedef bool (*notify_truncate_table_t)(THD *thd, const MDL_key *mdl_key,
2075 ha_notification_type notification_type);
2076
2077/**
2078 @brief
2079 Initiate master key rotation
2080
2081 @returns false on success,
2082 true on failure
2083*/
2085
2086/**
2087 @brief
2088 Enable or Disable SE write ahead logging.
2089
2090 @param[in] thd server thread handle
2091 @param[in] enable enable/disable redo logging
2092
2093 @return true iff failed.
2094*/
2095typedef bool (*redo_log_set_state_t)(THD *thd, bool enable);
2096
2097/**
2098 @brief
2099 Retrieve ha_statistics from SE.
2100
2101 @param db_name Name of schema
2102 @param table_name Name of table
2103 @param se_private_id SE private id of the table.
2104 @param ts_se_private_data Tablespace SE private data.
2105 @param tbl_se_private_data Table SE private data.
2106 @param flags Type of statistics to retrieve.
2107 @param[out] stats Contains statistics read from SE.
2108
2109 @note Handlers that implement this callback/API should adhere
2110 to servers expectation that, the implementation would invoke
2111 my_error() before returning 'true'/failure from this function.
2112
2113 @returns false on success,
2114 true on failure
2115*/
2117 const char *db_name, const char *table_name, dd::Object_id se_private_id,
2118 const dd::Properties &ts_se_private_data,
2119 const dd::Properties &tbl_se_private_data, uint flags,
2121
2122/**
2123 Retrieve column_statistics from SE.
2124 @param thd Current THD
2125 @param db_name Name of schema
2126 @param table_name Name of table
2127 @param column_name Name of column
2128 @param rows_in_table Nrows in table
2129
2130 @returns The statistics if available, empty value otherwise.
2131*/
2132typedef std::optional<ha_column_statistics> (*get_column_statistics_t)(
2133 THD *thd, const char *db_name, const char *table_name,
2134 const char *column_name, double rows_in_table);
2135
2136/**
2137 @brief
2138 Retrieve index column cardinality from SE.
2139
2140 @param db_name Name of schema
2141 @param table_name Name of table
2142 @param index_name Name of index
2143 @param index_ordinal_position Position of index.
2144 @param column_ordinal_position Position of column in index.
2145 @param se_private_id SE private id of the table.
2146 @param[out] cardinality cardinality being returned by SE.
2147
2148 @note Handlers that implement this callback/API should adhere
2149 to servers expectation that, the implementation would invoke
2150 my_error() before returning 'true'/failure from this function.
2151
2152 @returns false on success,
2153 true on failure
2154*/
2156 const char *db_name, const char *table_name, const char *index_name,
2157 uint index_ordinal_position, uint column_ordinal_position,
2158 dd::Object_id se_private_id, ulonglong *cardinality);
2159
2160/**
2161 Retrieve ha_tablespace_statistics from SE.
2162
2163 @param tablespace_name Tablespace_name
2164 @param file_name Tablespace file name.
2165 @param ts_se_private_data Tablespace SE private data.
2166 @param[out] stats Contains tablespace
2167 statistics read from SE.
2168
2169 @note Handlers that implement this callback/API should adhere
2170 to servers expectation that, the implementation would invoke
2171 my_error() before returning 'true'/failure from this function.
2172
2173 @returns false on success, true on failure
2174*/
2176 const char *tablespace_name, const char *file_name,
2177 const dd::Properties &ts_se_private_data, ha_tablespace_statistics *stats);
2178
2179/* Database physical clone interfaces */
2180
2181/** Get capability flags for clone operation
2182@param[out] flags capability flag */
2184
2185/** Begin copy from source database
2186@param[in] hton handlerton for SE
2187@param[in] thd server thread handle
2188@param[in,out] loc locator
2189@param[in,out] loc_len locator length
2190@param[out] task_id task identifier
2191@param[in] type clone type
2192@param[in] mode mode for starting clone
2193@return error code */
2194using Clone_begin_t = int (*)(handlerton *hton, THD *thd, const uchar *&loc,
2195 uint &loc_len, uint &task_id, Ha_clone_type type,
2197
2198/** Copy data from source database in chunks via callback
2199@param[in] hton handlerton for SE
2200@param[in] thd server thread handle
2201@param[in] loc locator
2202@param[in] loc_len locator length in bytes
2203@param[in] task_id task identifier
2204@param[in] cbk callback interface for sending data
2205@return error code */
2206using Clone_copy_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
2207 uint loc_len, uint task_id, Ha_clone_cbk *cbk);
2208
2209/** Acknowledge data transfer to source database
2210@param[in] hton handlerton for SE
2211@param[in] thd server thread handle
2212@param[in] loc locator
2213@param[in] loc_len locator length in bytes
2214@param[in] task_id task identifier
2215@param[in] in_err inform any error occurred
2216@param[in] cbk callback interface
2217@return error code */
2218using Clone_ack_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
2219 uint loc_len, uint task_id, int in_err,
2220 Ha_clone_cbk *cbk);
2221
2222/** End copy from source database
2223@param[in] hton handlerton for SE
2224@param[in] thd server thread handle
2225@param[in] loc locator
2226@param[in] loc_len locator length in bytes
2227@param[in] task_id task identifier
2228@param[in] in_err error code when ending after error
2229@return error code */
2230using Clone_end_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
2231 uint loc_len, uint task_id, int in_err);
2232
2233/** Begin apply to destination database
2234@param[in] hton handlerton for SE
2235@param[in] thd server thread handle
2236@param[in,out] loc locator
2237@param[in,out] loc_len locator length
2238@param[in] task_id task identifier
2239@param[in] mode mode for starting clone
2240@param[in] data_dir target data directory
2241@return error code */
2242using Clone_apply_begin_t = int (*)(handlerton *hton, THD *thd,
2243 const uchar *&loc, uint &loc_len,
2244 uint &task_id, Ha_clone_mode mode,
2245 const char *data_dir);
2246
2247/** Apply data to destination database in chunks via callback
2248@param[in] hton handlerton for SE
2249@param[in] thd server thread handle
2250@param[in] loc locator
2251@param[in] loc_len locator length in bytes
2252@param[in] task_id task identifier
2253@param[in] in_err inform any error occurred
2254@param[in] cbk callback interface for receiving data
2255@return error code */
2256using Clone_apply_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
2257 uint loc_len, uint task_id, int in_err,
2258 Ha_clone_cbk *cbk);
2259
2260/** End apply to destination database
2261@param[in] hton handlerton for SE
2262@param[in] thd server thread handle
2263@param[in] loc locator
2264@param[in] loc_len locator length in bytes
2265@param[in] task_id task identifier
2266@param[in] in_err error code when ending after error
2267@return error code */
2268using Clone_apply_end_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
2269 uint loc_len, uint task_id, int in_err);
2270
2272 /* Get clone capabilities of an SE */
2274
2275 /* Interfaces to copy data. */
2280
2281 /* Interfaces to apply data. */
2285};
2286
2287/**
2288 Perform post-commit/rollback cleanup after DDL statement (e.g. in
2289 case of DROP TABLES really remove table files from disk).
2290
2291 @note This hook will be invoked after DDL commit or rollback only
2292 for storage engines supporting atomic DDL.
2293
2294 @note Problems during execution of this method should be reported to
2295 error log and as warnings/notes to user. Since this method is
2296 called after successful commit of the statement we can't fail
2297 statement with error.
2298*/
2299typedef void (*post_ddl_t)(THD *thd);
2300
2301/**
2302 Perform SE-specific cleanup after recovery of transactions.
2303
2304 @note Particularly SEs supporting atomic DDL can use this call
2305 to perform post-DDL actions for DDL statements which were
2306 committed or rolled back during recovery stage.
2307*/
2308typedef void (*post_recover_t)(void);
2309
2310/**
2311 Lock a handlerton (resource) log to collect log information.
2312*/
2313
2314typedef bool (*lock_hton_log_t)(handlerton *hton);
2315
2316/**
2317 Unlock a handlerton (resource) log after collecting log information.
2318*/
2319
2320typedef bool (*unlock_hton_log_t)(handlerton *hton);
2321
2322/**
2323 Collect a handlerton (resource) log information.
2324*/
2325
2326typedef bool (*collect_hton_log_info_t)(handlerton *hton, Json_dom *json);
2327
2328/**
2329 Check SE considers types of child and parent columns in foreign key
2330 to be compatible.
2331
2332 @param child_column_type Child column type description.
2333 @param parent_column_type Parent column type description.
2334 @param check_charsets Indicates whether we need to check
2335 that charsets of string columns
2336 match. Which is true in most cases.
2337
2338 @returns True if types are compatible, False if not.
2339*/
2340
2342 const Ha_fk_column_type *child_column_type,
2343 const Ha_fk_column_type *parent_column_type, bool check_charsets);
2344
2345typedef bool (*is_reserved_db_name_t)(handlerton *hton, const char *name);
2346
2347/**
2348 Prepare the secondary engine for executing a statement. This function is
2349 called right after the secondary engine TABLE objects have been opened by
2350 open_secondary_engine_tables(), before the statement is optimized and
2351 executed. Secondary engines will typically create a context object in this
2352 function, which they can use to store state that is needed during the
2353 optimization and execution phases.
2354
2355 @param thd thread context
2356 @param lex the statement to execute
2357 @return true on error, false on success
2358*/
2359using prepare_secondary_engine_t = bool (*)(THD *thd, LEX *lex);
2360
2361/**
2362 Optimize a statement for execution on a secondary storage engine. This
2363 function is called when the optimization of a statement has completed, just
2364 before the statement is executed. Secondary engines can use this function to
2365 apply engine-specific optimizations to the execution plan. They can also
2366 reject executing the query by raising an error, in which case the query will
2367 be reprepared and executed by the primary storage engine.
2368
2369 @param thd thread context
2370 @param lex the statement being optimized
2371 @return true on error, false on success
2372*/
2373using optimize_secondary_engine_t = bool (*)(THD *thd, LEX *lex);
2374
2375/**
2376 Compares the cost of two join plans in the secondary storage engine. The cost
2377 of the current candidate is compared with the cost of the best plan seen so
2378 far.
2379
2380 @param thd thread context
2381 @param join the candidate plan to evaluate
2382 @param optimizer_cost the cost estimate calculated by the optimizer
2383 @param[out] use_best_so_far true if the optimizer should stop searching for
2384 a better plan and use the best plan it has seen so far
2385 @param[out] cheaper true if the candidate is the best plan seen so far for
2386 this JOIN (must be true if it is the first plan seen),
2387 false otherwise
2388 @param[out] secondary_engine_cost the cost estimated by the secondary engine
2389
2390 @return false on success, or true if an error has been raised
2391*/
2392using compare_secondary_engine_cost_t = bool (*)(THD *thd, const JOIN &join,
2393 double optimizer_cost,
2394 bool *use_best_so_far,
2395 bool *cheaper,
2396 double *secondary_engine_cost);
2397
2398/**
2399 Evaluates/Views the cost of executing the given access path in the secondary
2400 storage engine, and potentially modifies the cost estimates that are in the
2401 access path when optimization is being done for secondary engine. For primary
2402 engine, the cost should be only viewed. This function is only called from the
2403 hypergraph join optimizer.
2404
2405 The function is called on every access path that the join optimizer might
2406 compare to an alternative access path. This includes both paths that represent
2407 complete execution plans and paths that represent partial plans. It is not
2408 guaranteed to be called on every child path. For example, if GROUP BY is done
2409 by sorting first and then aggregating the sorted results, the function will
2410 only be called on the aggregation path, and not on the sort path, because only
2411 the aggregation path will be compared to other paths.
2412
2413 The secondary engine is allowed to modify the estimates in the access path to
2414 better match the costs of the access path in the secondary engine. It can
2415 change any of the following AccessPath members:
2416
2417 - init_once_cost
2418 - init_cost
2419 - cost
2420 - cost_before_filter
2421 - num_output_rows
2422 - num_output_rows_before_filter
2423 - secondary_engine_data
2424
2425 Any other members should be left unchanged. The AccessPath must be in an
2426 internally consistent state when the function returns, and satisfy invariants
2427 expected by the hypergraph join optimizer, such as:
2428
2429 - init_cost <= cost_before_filter <= cost
2430 - num_output_rows <= num_output_rows_before_filter
2431
2432 The secondary engine can also reject an access path altogether, by returning
2433 true, in which case the join optimizer will not use that path in the final
2434 plan. Since the secondary engine can reject any partial or complete plan, it
2435 is possible that the join optimizer does not find any valid plan that is
2436 accepted. In this case, the join optimizer will raise an error.
2437
2438 If the secondary encounters an error when evaluating the cost of the path, it
2439 can signal an error by calling my_error() and return true, in which case the
2440 join optimizer will not suggest any plan for the query.
2441
2442 @param thd The thread context.
2443 @param hypergraph The hypergraph that represents the search space.
2444 @param[in,out] access_path The AccessPath to evaluate.
2445
2446 @retval false on success.
2447 @retval true if the plan is to be rejected, or if an error was raised.
2448*/
2450 THD *thd, const JoinHypergraph &hypergraph, AccessPath *access_path);
2451
2452/**
2453 Checks whether the tables used in an explain query are loaded in the secondary
2454 engine.
2455 @param thd thread context.
2456
2457 @retval true if there is a table not loaded to the secondary engine, false
2458 otherwise
2459*/
2461
2462/**
2463 Looks up and returns a specific secondary engine query offload or exec
2464 failure reason as a string given a thread context (representing the query)
2465 when the offloaded query fails in the secondary storage engine.
2466
2467 @param thd thread context.
2468
2469 @retval std::string_view as the offload failure reason.
2470 The memory pointed to is managed by the handlerton and may be freed
2471 when the statement completes.
2472*/
2474 std::string_view (*)(const THD *thd);
2475
2476/**
2477 Finds and returns a specific secondary engine query offload failure reason
2478 as a string given a thread context (representing the query) whenever
2479 get_secondary_engine_offload_or_exec_fail_reason_t returns an empty reason.
2480
2481 @param thd thread context.
2482
2483 @retval std::string_view as the offload failure reason.
2484*/
2486 std::string_view (*)(THD *thd);
2487
2488/**
2489 Sets a specific secondary engine offload failure reason for a query
2490 represented by the thread context when the offloaded query fails in
2491 the secondary storage engine.
2492
2493 @param thd thread context.
2494
2495 @param reason offload failure reason.
2496
2497 @retval bool to indicate if the setting succeeded or failed
2498*/
2500 bool (*)(const THD *thd, std::string_view reason);
2501
2503 /** Continue optimization phase with current hypergraph. */
2504 kContinue = 0,
2505 /** Trigger restart of hypergraph with provided number of subgraph pairs. */
2506 kRestart = 1,
2507};
2508
2510 /** Optimizer request from the secondary engine. */
2512 /** Subgraph pairs requested by the secondary engine. */
2514 /** Indicates if simplification is guided using secondary engine */
2516};
2517
2518/**
2519 Hook to evaluate the current hypergraph optimization state in optimization for
2520 all the engines, and returns the state that hypergraph should transition to.
2521 Usually invoked after secondary_engine_modify_view_ap_cost_t is invoked via
2522 the optimizer. The state is returned as object of type
2523 SecondaryEngineGraphSimplificationRequestParameters, and can lead to
2524 simplification of hypergraph search space, or resetting the graph and starting
2525 search afresh.
2526
2527 @param thd The thread context.
2528 @param hypergraph The hypergraph that represents the search space.
2529 @param access_path The AccessPath to evaluate.
2530 @param current_subgraph_pairs Count of subgraph pairs explored so far.
2531 @param current_subgraph_pairs_limit Limit for current hypergraph.
2532 @param is_root_access_path Indicating if access_path is root.
2533 @param trace Optimizer trace string.
2534
2535 @returns instance of SecondaryEngineGraphSimplificationRequestParameters which
2536 contains description of the state hypergraph optimizer should transition to.
2537*/
2540 THD *thd, const JoinHypergraph &hypergraph,
2541 const AccessPath *access_path, int current_subgraph_pairs,
2542 int current_subgraph_pairs_limit, bool is_root_access_path,
2543 std::string *trace);
2544
2545// Capabilities (bit flags) for secondary engines.
2546using SecondaryEngineFlags = uint64_t;
2550
2551 // If this flag is set, aggregation (GROUP BY and DISTINCT) do not require
2552 // ordered inputs and create unordered outputs. This is typically the case
2553 // if they are implemented using hash-based techniques.
2555
2556 /// This flag can be set to signal that a secondary storage engine will not
2557 /// use MySQL's executor (see JOIN::override_executor_func). In this case, it
2558 /// doesn't need MySQL's execution data structures, like internal temporary
2559 /// tables, filesort objects or iterators. If the flag is set,
2560 /// FinalizePlanForQueryBlock() will not make any changes to the plan, and
2561 /// CreateIteratorFromAccessPath() will not be called.
2563};
2564
2565/// Creates an empty bitmap of access path types. This is the base
2566/// case for the function template with the same name below.
2567inline constexpr SecondaryEngineFlags MakeSecondaryEngineFlags() { return 0; }
2568
2569/// Creates a bitmap representing a set of access path types.
2570template <typename... Args>
2572 SecondaryEngineFlag flag1, Args... rest) {
2573 return (uint64_t{1} << static_cast<int>(flag1)) |
2574 MakeSecondaryEngineFlags(rest...);
2575}
2576
2577/// Returns the handlerton of the secondary engine that is used in the session,
2578/// or nullptr if a secondary engine is not used.
2579const handlerton *SecondaryEngineHandlerton(const THD *thd);
2580
2581/// Returns the handlerton of the eligible secondary engine that is used in the
2582/// session, If found, also initialises the thd member which caches this
2583/// eligible secondary engine, or returns nullptr if a secondary engine is not
2584/// used.
2586 THD *thd, const LEX_CSTRING *secondary_engine_in_name);
2587
2588// FIXME: Temporary workaround to enable storage engine plugins to use the
2589// before_commit hook. Remove after WL#11320 has been completed.
2590using se_before_commit_t = void (*)(void *arg);
2591
2592// FIXME: Temporary workaround to enable storage engine plugins to use the
2593// after_commit hook. Remove after WL#11320 has been completed.
2594using se_after_commit_t = void (*)(void *arg);
2595
2596// FIXME: Temporary workaround to enable storage engine plugins to use the
2597// before_rollback hook. Remove after WL#11320 has been completed.
2598using se_before_rollback_t = void (*)(void *arg);
2599
2600/**
2601 Notify plugins when a SELECT query was executed. The plugins will be notified
2602 only if the query is not considered secondary engine relevant, i.e.:
2603 1. for a query with missing secondary_engine_statement_ctx, its estimated cost
2604 is greater than the currently configured 'secondary_engine_cost_threshold'
2605 2. for queries with secondary_engine_statement_ctx, wherever
2606 secondary_engine_statement_ctx::is_primary_engine_optimal() returns False
2607 indicating secondary engine relevance.
2608 */
2609using notify_after_select_t = void (*)(THD *thd, SelectExecutedIn executed_in);
2610
2611/**
2612 * Notify plugins when a table is created.
2613 */
2614using notify_create_table_t = void (*)(struct HA_CREATE_INFO *create_info,
2615 const char *db, const char *table_name);
2616
2617/**
2618 Secondary engine hook called after PRIMARY_TENTATIVELY optimization is
2619 complete, and decides if secondary engine optimization will be performed, and
2620 comparison of primary engine cost and secondary engine cost will determine
2621 which engine to use for execution.
2622 @param[in] thd current thd.
2623 @return :
2624 @retval true When secondary_engine's prepare hook is to be further called
2625 @retval false When secondary_engine's prepare hook is NOT to be further called
2626
2627 */
2629
2630/**
2631 Hook used to estimate the cardinality of table Node objects in the
2632 JoinHypergraph. For each Node, it attempts to estimate the cardinality,
2633 and if successful, stores it in the field `cardinality`.
2634
2635 @param thd The thread context.
2636 @param graph The JoinHypergraph where the estimates are to be made.
2637*/
2638using cardinality_estimation_hook_t = void (*)(THD *thd, JoinHypergraph *graph);
2639
2640/**
2641 * Notify plugins when a table is dropped.
2642 */
2643using notify_drop_table_t = void (*)(Table_ref *tab);
2644
2645/**
2646 * Store the name of default secondary engine, if any.
2647 */
2648extern std::atomic<const char *> default_secondary_engine_name;
2649/*
2650 Page Tracking : interfaces to handlerton functions which starts/stops page
2651 tracking, and purges/fetches page tracking information.
2652*/
2653
2654/**
2655 Start page tracking.
2656
2657 @param[out] start_id SE specific sequence number [LSN for InnoDB]
2658 indicating when the tracking was started
2659
2660 @return Operation status.
2661 @retval 0 Success
2662 @retval other ER_* mysql error. Get error details from THD.
2663*/
2664using page_track_start_t = int (*)(uint64_t *start_id);
2665
2666/**
2667 Stop page tracking.
2668
2669 @param[out] stop_id SE specific sequence number [LSN for InnoDB]
2670 indicating when the tracking was stopped
2671
2672 @return Operation status.
2673 @retval 0 Success
2674 @retval other ER_* mysql error. Get error details from THD.
2675*/
2676using page_track_stop_t = int (*)(uint64_t *stop_id);
2677
2678/**
2679 Purge page tracking data.
2680
2681 @param[in,out] purge_id SE specific sequence number [LSN for InnoDB]
2682 initially indicating till where the data needs to be purged and finally
2683 updated to until where it was actually purged
2684
2685 @return Operation status.
2686 @retval 0 Success
2687 @retval other ER_* mysql error. Get error details from THD.
2688*/
2689using page_track_purge_t = int (*)(uint64_t *purge_id);
2690
2691/**
2692 Fetch tracked pages.
2693
2694 @param[in] cbk_func callback function return page IDs
2695 @param[in] cbk_ctx caller's context for callback
2696 @param[in,out] start_id SE specific sequence number [LSN for InnoDB] from
2697 where the pages tracked would be returned.
2698 @note The range might get expanded and the actual start_id used for the
2699 querying will be updated.
2700 @param[in,out] stop_id SE specific sequence number [LSN for InnoDB]
2701 until where the pages tracked would be returned.
2702 @note The range might get expanded and the actual stop_id used for the
2703 querying will be updated.
2704 @param[out] buffer allocated buffer to copy page IDs
2705 @param[in] buffer_len length of buffer in bytes
2706
2707 @return Operation status.
2708 @retval 0 Success
2709 @retval other ER_* mysql error. Get error details from THD.
2710*/
2712 void *cbk_ctx, uint64_t *start_id,
2713 uint64_t *stop_id,
2714 unsigned char *buffer,
2715 size_t buffer_len);
2716
2717/**
2718 Fetch approximate number of tracked pages in the given range.
2719
2720 @param[in,out] start_id SE specific sequence number [LSN for InnoDB] from
2721 where the pages tracked would be returned.
2722 @note the range might get expanded and the actual start_id used for the
2723 querying will be updated.
2724 @param[in,out] stop_id SE specific sequence number [LSN for InnoDB]
2725 until where the pages tracked would be returned.
2726 @note the range might get expanded and the actual stop_id used for the
2727 querying will be updated.
2728 @param[out] num_pages number of pages tracked
2729
2730 @return Operation status.
2731 @retval 0 Success
2732 @retval other ER_* mysql error. Get error details from THD.
2733*/
2734using page_track_get_num_page_ids_t = int (*)(uint64_t *start_id,
2735 uint64_t *stop_id,
2736 uint64_t *num_pages);
2737
2738/** Fetch the status of the page tracking system.
2739@param[out] status vector of a pair of (ID, bool) where ID is the
2740start/stop point and bool is true if the ID is a start point else false */
2742 void (*)(std::vector<std::pair<uint64_t, bool>> &status);
2743
2744/** Page track interface */
2752};
2753
2754/**
2755 handlerton is a singleton structure - one instance per storage engine -
2756 to provide access to storage engine functionality that works on the
2757 "global" level (unlike handler class that works on a per-table basis).
2758
2759 usually handlerton instance is defined statically in ha_xxx.cc as
2760
2761 static handlerton { ... } xxx_hton;
2762
2763 savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
2764*/
2766 /**
2767 Historical marker for if the engine is available or not.
2768 */
2770
2771 /**
2772 Historical number used for frm file to determine the correct storage engine.
2773 This is going away and new engines will just use "name" for this.
2774 */
2776 /**
2777 Each storage engine has it's own memory area (actually a pointer)
2778 in the thd, for storing per-connection information.
2779 It is accessed as
2780
2781 thd->ha_data[xxx_hton.slot]
2782
2783 slot number is initialized by MySQL after xxx_init() is called.
2784 */
2785 uint slot;
2786 /**
2787 To store per-savepoint data storage engine is provided with an area
2788 of a requested size (0 is ok here).
2789 savepoint_offset must be initialized statically to the size of
2790 the needed memory to store per-savepoint information.
2791 After xxx_init it is changed to be an offset to savepoint storage
2792 area and need not be used by storage engine.
2793 see binlog_hton and binlog_savepoint_set/rollback for an example.
2794 */
2796
2797 /* handlerton methods */
2798
2845
2846 /** Global handler flags. */
2848
2849 /*
2850 Those handlerton functions below are properly initialized at handler
2851 init.
2852 */
2853
2862
2863 /*
2864 APIs for retrieving Serialized Dictionary Information by tablespace id
2865 */
2866
2873
2874 /**
2875 Null-ended array of file extensions that exist for the storage engine.
2876 Used by frm_error() and the default handler::rename_table and delete_table
2877 methods in handler.cc.
2878
2879 For engines that have two file name extensions (separate meta/index file
2880 and data file), the order of elements is relevant. First element of engine
2881 file name extensions array should be meta/index file extension. Second
2882 element - data file extension. This order is assumed by
2883 prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
2884
2885 For engines that don't have files, file_extensions is NULL.
2886
2887 Currently, the following alternatives are used:
2888 - file_extensions == NULL;
2889 - file_extensions[0] != NULL, file_extensions[1] == NULL;
2890 - file_extensions[0] != NULL, file_extensions[1] != NULL,
2891 file_extensions[2] == NULL;
2892 */
2893 const char **file_extensions;
2894
2905
2910
2913
2914 /** Clone data transfer interfaces */
2916
2917 /** Flag for Engine License. */
2919 /** Location for engines to keep personal structures. */
2920 void *data;
2921
2922 /*
2923 Log_resource functions that must be supported by storage engines
2924 with relevant log information to be collected.
2925 */
2929
2930 /** Flags describing details of foreign key support by storage engine. */
2932
2934
2935 /**
2936 Suffix for auto-generated foreign key names for tables using this storage
2937 engine. If such suffix is specified by SE then its generated foreign key
2938 names follow (table name)(SE-specific FK name suffix)(FK number) pattern.
2939 Length of such suffix should not exceed MAX_FK_NAME_SUFFIX_LENGTH bytes.
2940 If no suffix is specified then FK_NAME_DEFAULT_SUFFIX is used as
2941 default.
2942 */
2944
2945 /**
2946 Pointer to a function that prepares a secondary engine for executing a
2947 statement.
2948
2949 @see prepare_secondary_engine_t for function signature.
2950 */
2952
2953 /**
2954 Pointer to a function that optimizes the current statement for
2955 execution on the secondary storage engine represented by this
2956 handlerton.
2957
2958 @see optimize_secondary_engine_t for function signature.
2959 */
2961
2962 /**
2963 Pointer to a function that estimates the cost of executing a join in a
2964 secondary storage engine.
2965
2966 @see compare_secondary_engine_cost_t for function signature.
2967 */
2969
2970 /// Bitmap which contains the supported join types and other flags
2971 /// for a secondary storage engine when used with the hypergraph join
2972 /// optimizer. If it is empty, it means that the secondary engine
2973 /// does not support the hypergraph join optimizer.
2975
2976 /// Pointer to a function that checks if the table is loaded in the
2977 /// secondary engine in the case of an explain statement.
2978 ///
2979 /// @see external_engine_explain_check_t for function signature.
2981
2982 /// Pointer to a function that evaluates the cost of executing an access path
2983 /// in a secondary storage engine.
2984 ///
2985 /// @see secondary_engine_modify_view_ap_cost_t for function signature.
2987
2988 /// Pointer to a function that returns the query offload or exec failure
2989 /// reason as a string given a thread context (representing the query) when
2990 /// the offloaded query failed in a secondary storage engine.
2991 ///
2992 /// @see get_secondary_engine_offload_or_exec_fail_reason_t for function
2993 /// signature.
2996
2997 /// Pointer to a function that finds and returns the query offload failure
2998 /// reason as a string given a thread context (representing the query) when
2999 /// get_secondary_engine_offload_or_exec_fail_reason returns an empty reason.
3000 ///
3001 /// @see find_secondary_engine_offload_fail_reason_t for function
3002 /// signature.
3005
3006 /// Pointer to a function that sets the offload failure reason as a string
3007 /// for a thread context (representing the query) when the offloaded query
3008 /// failed in a secondary storage engine.
3009 ///
3010 /// @see set_secondary_engine_offload_fail_reason_t for function signature.
3013
3014 /// Pointer to function that checks secondary engine request for updating
3015 /// hypergraph join optimization.
3016 ///
3017 /// @see secondary_engine_check_optimizer_request_t for function signature.
3020
3021 /* Pointer to a function that is called at the end of the PRIMARY_TENTATIVELY
3022 * optimization stage, which also decides that the statement should be
3023 * attempted offloaded to a secondary storage engine. */
3025
3026 /* Pointer to a function to request table filter estimation to the
3027 * secondary_engine. */
3029
3033
3035
3038
3039 /** Page tracking interface */
3041};
3042
3043/* Possible flags of a handlerton (there can be 32 of them) */
3044#define HTON_NO_FLAGS 0
3045#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
3046#define HTON_ALTER_NOT_SUPPORTED (1 << 1) // Engine does not support alter
3047#define HTON_CAN_RECREATE (1 << 2) // Delete all is used for truncate
3048#define HTON_HIDDEN (1 << 3) // Engine does not appear in lists
3049/*
3050 Bit 4 was occupied by BDB-specific HTON_FLUSH_AFTER_RENAME flag and is no
3051 longer used.
3052*/
3053#define HTON_NOT_USER_SELECTABLE (1 << 5)
3054#define HTON_TEMPORARY_NOT_SUPPORTED \
3055 (1 << 6) // Having temporary tables not supported
3056#define HTON_SUPPORT_LOG_TABLES (1 << 7) // Engine supports log tables
3057#define HTON_NO_PARTITION (1 << 8) // You can not partition these tables
3058
3059/*
3060 This flag should be set when deciding that the engine does not allow row based
3061 binary logging (RBL) optimizations.
3062
3063 Currently, setting this flag, means that table's read/write_set will be left
3064 untouched when logging changes to tables in this engine. In practice this
3065 means that the server will not mess around with table->write_set and/or
3066 table->read_set when using RBL and deciding whether to log full or minimal
3067 rows.
3068
3069 It's valuable for instance for virtual tables, eg: Performance Schema which
3070 have no meaning for replication.
3071*/
3072#define HTON_NO_BINLOG_ROW_OPT (1 << 9)
3073
3074/**
3075 Engine supports extended keys. The flag allows to
3076 use 'extended key' feature if the engine is able to
3077 do it (has primary key values in the secondary key).
3078 Note that handler flag HA_PRIMARY_KEY_IN_READ_INDEX is
3079 actually partial case of HTON_SUPPORTS_EXTENDED_KEYS.
3080*/
3081
3082#define HTON_SUPPORTS_EXTENDED_KEYS (1 << 10)
3083
3084// Engine support foreign key constraint.
3085
3086#define HTON_SUPPORTS_FOREIGN_KEYS (1 << 11)
3087
3088/**
3089 Engine supports atomic DDL. That is rollback of transaction for DDL
3090 statement will also rollback all changes in SE, commit of transaction
3091 of DDL statement will make it durable.
3092*/
3093
3094#define HTON_SUPPORTS_ATOMIC_DDL (1 << 12)
3095
3096/* Engine supports packed keys. */
3097#define HTON_SUPPORTS_PACKED_KEYS (1 << 13)
3098
3099/** Engine is a secondary storage engine. */
3100#define HTON_IS_SECONDARY_ENGINE (1 << 14)
3101
3102/** Engine supports secondary storage engines. */
3103#define HTON_SUPPORTS_SECONDARY_ENGINE (1 << 15)
3104
3105/** Engine supports table or tablespace encryption . */
3106#define HTON_SUPPORTS_TABLE_ENCRYPTION (1 << 16)
3107
3109 1 << 17};
3110
3111/** Engine supports Generated invisible primary key. */
3112// clang-format off
3113constexpr const decltype(
3115// clang-format on
3116
3117/** Whether the secondary engine supports DDLs. No meaning if the engine is not
3118 * secondary. */
3119#define HTON_SECONDARY_ENGINE_SUPPORTS_DDL (1 << 19)
3120
3121/** Whether the engine does not support triggers. */
3122#define HTON_NO_TRIGGER_SUPPORT (1 << 20)
3123
3124/** Whether the primary engine supports external data sources. This case refers
3125 to having tables with data in object store and the engine does not store any
3126 of those data, only metadata. Table contents can be accessed only after
3127 loading the table in the secondary storage engine. The flag is used for
3128 a primary engine only.
3129 */
3130#define HTON_SUPPORTS_EXTERNAL_SOURCE (1 << 21)
3131
3132constexpr const decltype(handlerton::flags) HTON_SUPPORTS_BULK_LOAD{1 << 22};
3133
3134/** Engine supports index distance scan. */
3135inline constexpr const decltype(handlerton::flags) HTON_SUPPORTS_DISTANCE_SCAN{
3136 1 << 23};
3137
3138/* Whether the engine supports being specified as a default storage engine */
3139inline constexpr const decltype(handlerton::flags)
3141
3143 assert(hton->flags & HTON_IS_SECONDARY_ENGINE);
3144
3145 return (hton->flags & HTON_SECONDARY_ENGINE_SUPPORTS_DDL) != 0;
3146}
3147
3148inline bool ddl_is_atomic(const handlerton *hton) {
3149 return (hton->flags & HTON_SUPPORTS_ATOMIC_DDL) != 0;
3150}
3151
3152/* Bits for handlerton::foreign_keys_flags bitmap. */
3153
3154/**
3155 Engine supports both unique and non-unique parent keys for
3156 foreign keys which contain full foreign key as its prefix.
3157
3158 Storage engines which support foreign keys but do not have
3159 this flag set are assumed to support only parent keys which
3160 are primary/unique and contain exactly the same columns as
3161 the foreign key, possibly, in different order.
3162*/
3163
3165
3166/**
3167 Storage engine supports hash keys as supporting keys for foreign
3168 keys. Hash key should contain all foreign key columns and only
3169 them (although in any order).
3170
3171 Storage engines which support foreign keys but do not have this
3172 flag set are assumed to not allow hash keys as supporting keys.
3173*/
3174
3176
3177/**
3178 Storage engine supports non-hash keys which have common prefix
3179 with the foreign key as supporting keys for it. If there are
3180 several such keys, one which shares biggest prefix with FK is
3181 chosen.
3182
3183 Storage engines which support foreign keys but do not have this
3184 flag set are assumed to require that supporting key contains full
3185 foreign key as its prefix.
3186*/
3187
3189
3190/**
3191 Storage engine does not support using the same key for both parent
3192 and supporting key, but requires the two to be different.
3193*/
3194
3196 (1 << 3);
3197
3198/**
3199 Engine takes into account hidden part of key (coming from primary key)
3200 when determines if it can serve as parent key for a foreign key.
3201
3202 Implies HTON_FKS_WITH_PREFIX_PARENT_KEYS and is related to
3203 HTON_SUPPORTS_EXTENDED_KEYS.
3204*/
3205
3207
3208/**
3209 Maximum possible length of SE-specific suffixes for auto-generated
3210 foreign key names.
3211*/
3212static const size_t MAX_FK_NAME_SUFFIX_LENGTH = 16;
3213
3214/**
3215 Suffix for auto-generated foreign key names for tables in SE's which
3216 don't specify own suffix. I.e. for foreign keys on tables in such
3217 SE's generated names follow (table name)FK_NAME_DEFAULT_SUFFIX(FK number)
3218 pattern.
3219*/
3221
3228
3234
3235/**
3236 Struct to hold information about the table that should be created.
3237 */
3241 bool schema_read_only{false};
3243 const char *password{nullptr};
3244 const char *tablespace{nullptr};
3245 LEX_STRING comment{nullptr, 0};
3246
3247 /**
3248 Algorithm (and possible options) to be used for InnoDB's transparent
3249 page compression. If this attribute is set then it is hint to the
3250 storage engine to try and compress the data using the specified algorithm
3251 where possible. Note: this value is interpreted by the storage engine only.
3252 and ignored by the Server layer. */
3253
3255
3256 /**
3257 This attribute is used for InnoDB's transparent page encryption.
3258 If this attribute is set then it is hint to the storage engine to encrypt
3259 the data. Note: this value is interpreted by the storage engine only.
3260 and ignored by the Server layer. */
3261
3263
3264 /**
3265 * Secondary engine of the table.
3266 * Is nullptr if no secondary engine defined.
3267 */
3269 /** Secondary engine load status */
3270 bool secondary_load{false};
3271
3272 /** Part info in order to maintain in HA_CREATE_INFO the per-partition
3273 * secondary_load status*/
3275
3276 const char *data_file_name{nullptr};
3277 const char *index_file_name{nullptr};
3278 const char *alias{nullptr};
3284 uint64_t used_fields{0};
3285 // Can only be 1,2,4,8 or 16, but use uint32_t since that how it is
3286 // represented in InnoDB
3287 std::uint32_t key_block_size{0};
3288 uint stats_sample_pages{0}; /* number of pages to sample during
3289 stats estimation, if used, otherwise 0. */
3293 /**
3294 Row type of the table definition.
3295
3296 Defaults to ROW_TYPE_DEFAULT for all non-ALTER statements.
3297 For ALTER TABLE defaults to ROW_TYPE_NOT_USED (means "keep the current").
3298
3299 Can be changed either explicitly by the parser.
3300 If nothing specified inherits the value of the original table (if present).
3301 */
3303 uint null_bits{0}; /* NULL bits at start of record */
3304 uint options{0}; /* OR of HA_CREATE_ options */
3306 ha_storage_media storage_media{HA_SM_DEFAULT}; /* DEFAULT, DISK or MEMORY */
3307
3308 /*
3309 A flag to indicate if this table should be marked as a hidden table in
3310 the data dictionary. One use case is to mark the temporary tables
3311 created by ALTER to be marked as hidden.
3312 */
3313 bool m_hidden{false};
3314
3315 /*
3316 A flag to indicate if this table should be created but not committed at
3317 the end of statement.
3318 */
3320
3323
3325
3327
3328 /**
3329 Fill HA_CREATE_INFO to be used by ALTER as well as upgrade code.
3330 This function separates code from mysql_prepare_alter_table() to be
3331 used by upgrade code as well to reduce code duplication.
3332 For ALTER code path, this lets new create options override the old
3333 ones.
3334
3335 @param[in] share TABLE_SHARE object
3336 @param[in] used_fields If a given create option is not flagged, old
3337 value be copied from the TABLE_SHARE.
3338 */
3339
3341 uint64_t used_fields);
3342};
3343
3344/**
3345 Structure describing changes to an index to be caused by ALTER TABLE.
3346*/
3347
3348struct KEY_PAIR {
3349 /**
3350 Pointer to KEY object describing old version of index in
3351 TABLE::key_info array for TABLE instance representing old
3352 version of table.
3353 */
3355 /**
3356 Pointer to KEY object describing new version of index in
3357 Alter_inplace_info::key_info_buffer array.
3358 */
3360};
3361
3362/**
3363 In-place alter handler context.
3364
3365 This is a superclass intended to be subclassed by individual handlers
3366 in order to store handler unique context between in-place alter API calls.
3367
3368 The handler is responsible for creating the object. This can be done
3369 as early as during check_if_supported_inplace_alter().
3370
3371 The SQL layer is responsible for destroying the object.
3372
3373 @see Alter_inplace_info
3374*/
3375
3377 public:
3379
3381 [[maybe_unused]]) {}
3382 virtual ~inplace_alter_handler_ctx() = default;
3383};
3384
3385/**
3386 Class describing changes to be done by ALTER TABLE.
3387 Instance of this class is passed to storage engine in order
3388 to determine if this ALTER TABLE can be done using in-place
3389 algorithm. It is also used for executing the ALTER TABLE
3390 using in-place algorithm.
3391*/
3392
3394 public:
3395 /**
3396 Bits to show in detail what operations the storage engine is
3397 to execute.
3398
3399 All these operations are supported as in-place operations by the
3400 SQL layer. This means that operations that by their nature must
3401 be performed by copying the table to a temporary table, will not
3402 have their own flags here (e.g. ALTER TABLE FORCE, ALTER TABLE
3403 ENGINE).
3404
3405 We generally try to specify handler flags only if there are real
3406 changes. But in cases when it is cumbersome to determine if some
3407 attribute has really changed we might choose to set flag
3408 pessimistically, for example, relying on parser output only.
3409 */
3411
3412 // Add non-unique, non-primary index
3413 static const HA_ALTER_FLAGS ADD_INDEX = 1ULL << 0;
3414
3415 // Drop non-unique, non-primary index
3416 static const HA_ALTER_FLAGS DROP_INDEX = 1ULL << 1;
3417
3418 // Add unique, non-primary index
3419 static const HA_ALTER_FLAGS ADD_UNIQUE_INDEX = 1ULL << 2;
3420
3421 // Drop unique, non-primary index
3422 static const HA_ALTER_FLAGS DROP_UNIQUE_INDEX = 1ULL << 3;
3423
3424 // Add primary index
3425 static const HA_ALTER_FLAGS ADD_PK_INDEX = 1ULL << 4;
3426
3427 // Drop primary index
3428 static const HA_ALTER_FLAGS DROP_PK_INDEX = 1ULL << 5;
3429
3430 // Add column
3431
3432 // Virtual generated column
3433 static const HA_ALTER_FLAGS ADD_VIRTUAL_COLUMN = 1ULL << 6;
3434 // Stored base (non-generated) column
3435 static const HA_ALTER_FLAGS ADD_STORED_BASE_COLUMN = 1ULL << 7;
3436 // Stored generated column
3438 // Add generic column (convenience constant).
3441
3442 // Drop column
3443 static const HA_ALTER_FLAGS DROP_VIRTUAL_COLUMN = 1ULL << 9;
3444 static const HA_ALTER_FLAGS DROP_STORED_COLUMN = 1ULL << 10;
3447
3448 // Rename column
3449 static const HA_ALTER_FLAGS ALTER_COLUMN_NAME = 1ULL << 11;
3450
3451 // Change column datatype
3453 static const HA_ALTER_FLAGS ALTER_STORED_COLUMN_TYPE = 1ULL << 13;
3454
3455 /**
3456 Change column datatype in such way that new type has compatible
3457 packed representation with old type, so it is theoretically
3458 possible to perform change by only updating data dictionary
3459 without changing table rows.
3460 */
3462
3463 /// A virtual column has changed its position
3465
3466 /// A stored column has changed its position (disregarding virtual columns)
3468
3469 // Change column from NOT NULL to NULL
3470 static const HA_ALTER_FLAGS ALTER_COLUMN_NULLABLE = 1ULL << 17;
3471
3472 // Change column from NULL to NOT NULL
3474
3475 // Set or remove default column value
3476 static const HA_ALTER_FLAGS ALTER_COLUMN_DEFAULT = 1ULL << 19;
3477
3478 // Change column generation expression
3479 static const HA_ALTER_FLAGS ALTER_VIRTUAL_GCOL_EXPR = 1ULL << 20;
3480 static const HA_ALTER_FLAGS ALTER_STORED_GCOL_EXPR = 1ULL << 21;
3481
3482 // Add foreign key
3483 static const HA_ALTER_FLAGS ADD_FOREIGN_KEY = 1ULL << 22;
3484
3485 // Drop foreign key
3486 static const HA_ALTER_FLAGS DROP_FOREIGN_KEY = 1ULL << 23;
3487
3488 // table_options changed, see HA_CREATE_INFO::used_fields for details.
3489 static const HA_ALTER_FLAGS CHANGE_CREATE_OPTION = 1ULL << 24;
3490
3491 // Table is renamed
3492 static const HA_ALTER_FLAGS ALTER_RENAME = 1ULL << 25;
3493
3494 // Change the storage type of column
3496
3497 // Change the column format of column
3499
3500 // Add partition
3501 static const HA_ALTER_FLAGS ADD_PARTITION = 1ULL << 28;
3502
3503 // Drop partition
3504 static const HA_ALTER_FLAGS DROP_PARTITION = 1ULL << 29;
3505
3506 // Changing partition options
3507 static const HA_ALTER_FLAGS ALTER_PARTITION = 1ULL << 30;
3508
3509 // Coalesce partition
3510 static const HA_ALTER_FLAGS COALESCE_PARTITION = 1ULL << 31;
3511
3512 // Reorganize partition ... into
3513 static const HA_ALTER_FLAGS REORGANIZE_PARTITION = 1ULL << 32;
3514
3515 // Reorganize partition
3516 static const HA_ALTER_FLAGS ALTER_TABLE_REORG = 1ULL << 33;
3517
3518 // Remove partitioning
3520
3521 // Partition operation with ALL keyword
3522 static const HA_ALTER_FLAGS ALTER_ALL_PARTITION = 1ULL << 35;
3523
3524 /**
3525 Rename index. Note that we set this flag only if there are no other
3526 changes to the index being renamed. Also for simplicity we don't
3527 detect renaming of indexes which is done by dropping index and then
3528 re-creating index with identical definition under different name.
3529 */
3530 static const HA_ALTER_FLAGS RENAME_INDEX = 1ULL << 36;
3531
3532 /**
3533 Recreate the table for ALTER TABLE FORCE, ALTER TABLE ENGINE
3534 and OPTIMIZE TABLE operations.
3535 */
3536 static const HA_ALTER_FLAGS RECREATE_TABLE = 1ULL << 37;
3537
3538 // Add spatial index
3539 static const HA_ALTER_FLAGS ADD_SPATIAL_INDEX = 1ULL << 38;
3540
3541 // Alter index comment
3542 static const HA_ALTER_FLAGS ALTER_INDEX_COMMENT = 1ULL << 39;
3543
3544 // New/changed virtual generated column require validation
3545 static const HA_ALTER_FLAGS VALIDATE_VIRTUAL_COLUMN = 1ULL << 40;
3546
3547 /**
3548 Change index option in a way which is likely not to require index
3549 recreation. For example, change COMMENT or KEY::is_algorithm_explicit
3550 flag (without change of index algorithm itself).
3551 */
3552 static const HA_ALTER_FLAGS CHANGE_INDEX_OPTION = 1LL << 41;
3553
3554 // Rebuild partition
3555 static const HA_ALTER_FLAGS ALTER_REBUILD_PARTITION = 1ULL << 42;
3556
3557 /**
3558 Change in index length such that it does not require index rebuild.
3559 For example, change in index length due to column expansion like
3560 varchar(X) changed to varchar(X + N).
3561 */
3563
3564 /**
3565 Change to one of columns on which virtual generated column depends,
3566 so its values require re-evaluation.
3567 */
3568 static const HA_ALTER_FLAGS VIRTUAL_GCOL_REEVAL = 1ULL << 44;
3569
3570 /**
3571 Change to one of columns on which stored generated column depends,
3572 so its values require re-evaluation.
3573 */
3574 static const HA_ALTER_FLAGS STORED_GCOL_REEVAL = 1ULL << 45;
3575
3576 // Add check constraint.
3577 static const HA_ALTER_FLAGS ADD_CHECK_CONSTRAINT = 1ULL << 46;
3578
3579 // Drop check constraint.
3580 static const HA_ALTER_FLAGS DROP_CHECK_CONSTRAINT = 1ULL << 47;
3581
3582 // Suspend check constraint.
3583 static const HA_ALTER_FLAGS SUSPEND_CHECK_CONSTRAINT = 1ULL << 48;
3584
3585 // Alter column visibility.
3586 static const HA_ALTER_FLAGS ALTER_COLUMN_VISIBILITY = 1ULL << 49;
3587
3588 /**
3589 Create options (like MAX_ROWS) for the new version of table.
3590
3591 @note The referenced instance of HA_CREATE_INFO object was already
3592 used to create new .FRM file for table being altered. So it
3593 has been processed by mysql_prepare_create_table() already.
3594 For example, this means that it has HA_OPTION_PACK_RECORD
3595 flag in HA_CREATE_INFO::table_options member correctly set.
3596 */
3598
3599 /**
3600 Alter options, fields and keys for the new version of table.
3601
3602 @note The referenced instance of Alter_info object was already
3603 used to create new .FRM file for table being altered. So it
3604 has been processed by mysql_prepare_create_table() already.
3605 In particular, this means that in Create_field objects for
3606 fields which were present in some form in the old version
3607 of table, Create_field::field member points to corresponding
3608 Field instance for old version of table.
3609 */
3611
3612 /**
3613 Indicates whether operation should fail if table is non-empty.
3614 Storage engines should not suggest/allow execution of such operations
3615 using INSTANT algorithm since check whether table is empty done from
3616 SQL-layer is not "instant". Also SEs might choose different algorithm for
3617 ALTER TABLE execution knowing that it will be allowed to proceed only if
3618 table is empty.
3619
3620 Unlike for Alter_table_ctx::error_if_not_empty, we use bool for this flag
3621 and not bitmap, since SEs are really interested in the fact that ALTER
3622 will fail if table is not empty and not in exact reason behind this fact,
3623 and because we want to avoid extra dependency between Alter_table_ctx and
3624 Alter_inplace_info.
3625 */
3627
3628 /**
3629 Array of KEYs for new version of table - including KEYs to be added.
3630
3631 @note Currently this array is produced as result of
3632 mysql_prepare_create_table() call.
3633 This means that it follows different convention for
3634 KEY_PART_INFO::fieldnr values than objects in TABLE::key_info
3635 array.
3636
3637 @todo This is mainly due to the fact that we need to keep compatibility
3638 with removed handler::add_index() call. We plan to switch to
3639 TABLE::key_info numbering later.
3640
3641 KEYs are sorted - see sort_keys().
3642 */
3644
3645 /** Size of key_info_buffer array. */
3647
3648 /** Size of index_drop_buffer array. */
3650
3651 /**
3652 Array of pointers to KEYs to be dropped belonging to the TABLE instance
3653 for the old version of the table.
3654 */
3656
3657 /** Size of index_add_buffer array. */
3659
3660 /**
3661 Array of indexes into key_info_buffer for KEYs to be added,
3662 sorted in increasing order.
3663 */
3665
3666 /** Size of index_rename_buffer array. */
3668
3669 /** Size of index_rename_buffer array. */
3671
3672 /**
3673 Array of KEY_PAIR objects describing indexes being renamed.
3674 For each index renamed it contains object with KEY_PAIR::old_key
3675 pointing to KEY object belonging to the TABLE instance for old
3676 version of table representing old version of index and with
3677 KEY_PAIR::new_key pointing to KEY object for new version of
3678 index in key_info_buffer member.
3679 */
3682
3683 /** Number of virtual columns to be added. */
3685
3686 /** number of virtual columns to be dropped. */
3688
3689 /**
3690 Context information to allow handlers to keep context between in-place
3691 alter API calls.
3692
3693 @see inplace_alter_handler_ctx for information about object lifecycle.
3694 */
3696
3697 /**
3698 If the table uses several handlers, like ha_partition uses one handler
3699 per partition, this contains a Null terminated array of ctx pointers
3700 that should all be committed together.
3701 Or NULL if only handler_ctx should be committed.
3702 Set to NULL if the low level handler::commit_inplace_alter_table uses it,
3703 to signal to the main handler that everything was committed as atomically.
3704
3705 @see inplace_alter_handler_ctx for information about object lifecycle.
3706 */
3708
3709 /**
3710 Flags describing in detail which operations the storage engine is to
3711 execute.
3712 */
3714
3715 /**
3716 Partition_info taking into account the partition changes to be performed.
3717 Contains all partitions which are present in the old version of the table
3718 with partitions to be dropped or changed marked as such + all partitions
3719 to be added in the new version of table marked as such.
3720 */
3722
3723 /** true for online operation (LOCK=NONE) */
3725
3726 /**
3727 Can be set by handler along with handler_ctx. The difference is that
3728 this flag can be used to store SE-specific in-place ALTER context in cases
3729 when constructing full-blown inplace_alter_handler_ctx descendant is
3730 inconvenient.
3731 */
3733
3734 /**
3735 Can be set by handler to describe why a given operation cannot be done
3736 in-place (HA_ALTER_INPLACE_NOT_SUPPORTED) or why it cannot be done
3737 online (HA_ALTER_INPLACE_NO_LOCK or HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE)
3738 If set, it will be used with ER_ALTER_OPERATION_NOT_SUPPORTED_REASON if
3739 results from handler::check_if_supported_inplace_alter() doesn't match
3740 requirements set by user. If not set, the more generic
3741 ER_ALTER_OPERATION_NOT_SUPPORTED will be used.
3742
3743 Please set to a properly localized string, for example using
3744 my_get_err_msg(), so that the error message as a whole is localized.
3745 */
3747
3749 Alter_info *alter_info_arg, bool error_if_not_empty_arg,
3750 KEY *key_info_arg, uint key_count_arg,
3751 partition_info *modified_part_info_arg)
3752 : create_info(create_info_arg),
3753 alter_info(alter_info_arg),
3754 error_if_not_empty(error_if_not_empty_arg),
3755 key_info_buffer(key_info_arg),
3756 key_count(key_count_arg),
3759 index_add_count(0),
3768 handler_flags(0),
3769 modified_part_info(modified_part_info_arg),
3770 online(false),
3773
3775 if (handler_ctx != nullptr) ::destroy_at(handler_ctx);
3776 }
3777
3778 /**
3779 Used after check_if_supported_inplace_alter() to report
3780 error if the result does not match the LOCK/ALGORITHM
3781 requirements set by the user.
3782
3783 @param not_supported Part of statement that was not supported.
3784 @param try_instead Suggestion as to what the user should
3785 replace not_supported with.
3786 */
3787 void report_unsupported_error(const char *not_supported,
3788 const char *try_instead);
3789
3790 /** Add old and new version of key to array of indexes to be renamed. */
3791 void add_renamed_key(KEY *old_key, KEY *new_key) {
3793 key_pair->old_key = old_key;
3794 key_pair->new_key = new_key;
3795 DBUG_PRINT("info",
3796 ("index renamed: '%s' to '%s'", old_key->name, new_key->name));
3797 }
3798
3799 void add_altered_index_visibility(KEY *old_key, KEY *new_key) {
3800 KEY_PAIR *key_pair =
3802 key_pair->old_key = old_key;
3803 key_pair->new_key = new_key;
3804 DBUG_PRINT("info", ("index had visibility altered: %i to %i",
3805 old_key->is_visible, new_key->is_visible));
3806 }
3807
3808 /**
3809 Add old and new version of modified key to arrays of indexes to
3810 be dropped and added (correspondingly).
3811 */
3812 void add_modified_key(KEY *old_key, KEY *new_key) {
3814 index_add_buffer[index_add_count++] = (uint)(new_key - key_info_buffer);
3815 DBUG_PRINT("info", ("index changed: '%s'", old_key->name));
3816 }
3817
3818 /** Drop key to array of indexes to be dropped. */
3819 void add_dropped_key(KEY *old_key) {
3821 DBUG_PRINT("info", ("index dropped: '%s'", old_key->name));
3822 }
3823
3824 /** Add key to array of indexes to be added. */
3825 void add_added_key(KEY *new_key) {
3826 index_add_buffer[index_add_count++] = (uint)(new_key - key_info_buffer);
3827 DBUG_PRINT("info", ("index added: '%s'", new_key->name));
3828 }
3829};
3830
3832 uint flags{0}; /* isam layer flags (e.g. for myisamchk) */
3833 uint sql_flags{0}; /* sql layer flags - for something myisamchk cannot do */
3834 KEY_CACHE *key_cache; /* new key cache when changing key cache */
3835};
3836
3837/*
3838 This is a buffer area that the handler can use to store rows.
3839 'end_of_used_area' should be kept updated after calls to
3840 read-functions so that other parts of the code can use the
3841 remaining area (until next read calls is issued).
3842*/
3843
3845 uchar *buffer; /* Buffer one can start using */
3846 uchar *buffer_end; /* End of buffer */
3847 uchar *end_of_used_area; /* End of area that was used by handler */
3848};
3849
3850typedef void *range_seq_t;
3851
3853 /*
3854 Initialize the traversal of range sequence
3855
3856 SYNOPSIS
3857 init()
3858 init_params The seq_init_param parameter
3859 n_ranges The number of ranges obtained
3860 flags A combination of HA_MRR_SINGLE_POINT, HA_MRR_FIXED_KEY
3861
3862 RETURN
3863 An opaque value to be used as RANGE_SEQ_IF::next() parameter
3864 */
3865 range_seq_t (*init)(void *init_params, uint n_ranges, uint flags);
3866
3867 /*
3868 Get the next range in the range sequence
3869
3870 SYNOPSIS
3871 next()
3872 seq The value returned by RANGE_SEQ_IF::init()
3873 range OUT Information about the next range
3874
3875 RETURN
3876 0 - Ok, the range structure filled with info about the next range
3877 1 - No more ranges
3878 */
3880
3881 /*
3882 Check whether range_info orders to skip the next record
3883
3884 SYNOPSIS
3885 skip_record()
3886 seq The value returned by RANGE_SEQ_IF::init()
3887 range_info Information about the next range
3888 (Ignored if MRR_NO_ASSOCIATION is set)
3889 rowid Rowid of the record to be checked (ignored if set to 0)
3890
3891 RETURN
3892 1 - Record with this range_info and/or this rowid shall be filtered
3893 out from the stream of records returned by ha_multi_range_read_next()
3894 0 - The record shall be left in the stream
3895 */
3896 bool (*skip_record)(range_seq_t seq, char *range_info, uchar *rowid);
3897};
3898
3899/**
3900 Used to store optimizer cost estimates.
3901
3902 The class consists of PODs only: default operator=, copy constructor
3903 and destructor are used.
3904 */
3906 private:
3907 double io_cost; ///< cost of I/O operations
3908 double cpu_cost; ///< cost of CPU operations
3909 double import_cost; ///< cost of remote operations
3910 double mem_cost; ///< memory used (bytes)
3911
3912 public:
3914
3915 /// Returns sum of time-consuming costs, i.e., not counting memory cost
3916 double total_cost() const { return io_cost + cpu_cost + import_cost; }
3917 double get_io_cost() const { return io_cost; }
3918 double get_cpu_cost() const { return cpu_cost; }
3919 double get_import_cost() const { return import_cost; }
3920 double get_mem_cost() const { return mem_cost; }
3921
3922 /**
3923 Whether or not all costs in the object are zero
3924
3925 @return true if all costs are zero, false otherwise
3926 */
3927 bool is_zero() const {
3928 return !(io_cost || cpu_cost || import_cost || mem_cost);
3929 }
3930 /**
3931 Whether or not the total cost is the maximal double
3932
3933 @return true if total cost is the maximal double, false otherwise
3934 */
3935 bool is_max_cost() const { return io_cost == DBL_MAX; }
3936 /// Reset all costs to zero
3938 /// Set current cost to the maximal double
3940 reset();
3941 io_cost = DBL_MAX;
3942 }
3943
3944 /// Multiply io, cpu and import costs by parameter
3945 void multiply(double m) {
3946 assert(!is_max_cost());
3947
3948 io_cost *= m;
3949 cpu_cost *= m;
3950 import_cost *= m;
3951 /* Don't multiply mem_cost */
3952 }
3953
3955 assert(!is_max_cost() && !other.is_max_cost());
3956
3957 io_cost += other.io_cost;
3958 cpu_cost += other.cpu_cost;
3959 import_cost += other.import_cost;
3960 mem_cost += other.mem_cost;
3961
3962 return *this;
3963 }
3964
3966 Cost_estimate result = *this;
3967 result += other;
3968
3969 return result;
3970 }
3971
3974
3975 assert(!other.is_max_cost());
3976
3977 result.io_cost = io_cost - other.io_cost;
3978 result.cpu_cost = cpu_cost - other.cpu_cost;
3979 result.import_cost = import_cost - other.import_cost;
3980 result.mem_cost = mem_cost - other.mem_cost;
3981 return result;
3982 }
3983
3984 bool operator>(const Cost_estimate &other) const {
3985 return total_cost() > other.total_cost() ? true : false;
3986 }
3987
3988 bool operator<(const Cost_estimate &other) const {
3989 return other > *this ? true : false;
3990 }
3991
3992 /// Add to IO cost
3993 void add_io(double add_io_cost) {
3994 assert(!is_max_cost());
3995 io_cost += add_io_cost;
3996 }
3997
3998 /// Add to CPU cost
3999 void add_cpu(double add_cpu_cost) {
4000 assert(!is_max_cost());
4001 cpu_cost += add_cpu_cost;
4002 }
4003
4004 /// Add to import cost
4005 void add_import(double add_import_cost) {
4006 assert(!is_max_cost());
4007 import_cost += add_import_cost;
4008 }
4009
4010 /// Add to memory cost
4011 void add_mem(double add_mem_cost) {
4012 assert(!is_max_cost());
4013 mem_cost += add_mem_cost;
4014 }
4015};
4016
4018 Cost_estimate *cost);
4019
4020/*
4021 The below two are not used (and not handled) in this milestone of this WL
4022 entry because there seems to be no use for them at this stage of
4023 implementation.
4024*/
4025#define HA_MRR_SINGLE_POINT 1
4026#define HA_MRR_FIXED_KEY 2
4027
4028/*
4029 Indicates that RANGE_SEQ_IF::next(&range) doesn't need to fill in the
4030 'range' parameter.
4031*/
4032#define HA_MRR_NO_ASSOCIATION 4
4033
4034/*
4035 The MRR user will provide ranges in key order, and MRR implementation
4036 must return rows in key order.
4037 Passing this flag to multi_read_range_init() may cause the
4038 default MRR handler to be used even if HA_MRR_USE_DEFAULT_IMPL
4039 was not specified.
4040 (If the native MRR impl. can not provide SORTED result)
4041*/
4042#define HA_MRR_SORTED 8
4043
4044/* MRR implementation doesn't have to retrieve full records */
4045#define HA_MRR_INDEX_ONLY 16
4046
4047/*
4048 The passed memory buffer is of maximum possible size, the caller can't
4049 assume larger buffer.
4050*/
4051#define HA_MRR_LIMITS 32
4052
4053/*
4054 Flag set <=> default MRR implementation is used
4055 (The choice is made by **_info[_const]() function which may set this
4056 flag. SQL layer remembers the flag value and then passes it to
4057 multi_read_range_init().
4058*/
4059#define HA_MRR_USE_DEFAULT_IMPL 64
4060
4061/*
4062 Used only as parameter to multi_range_read_info():
4063 Flag set <=> the caller guarantees that the bounds of the scanned ranges
4064 will not have NULL values.
4065*/
4066#define HA_MRR_NO_NULL_ENDPOINTS 128
4067
4068/*
4069 Set by the MRR implementation to signal that it will natively
4070 produced sorted result if multi_range_read_init() is called with
4071 the HA_MRR_SORTED flag - Else multi_range_read_init(HA_MRR_SORTED)
4072 will revert to use the default MRR implementation.
4073*/
4074#define HA_MRR_SUPPORT_SORTED 256
4075
4077 public:
4078 ulonglong data_file_length; /* Length off data file */
4079 ulonglong max_data_file_length; /* Length off data file */
4082 ulonglong delete_length; /* Free bytes */
4084 /*
4085 The number of records in the table.
4086 0 - means the table has exactly 0 rows
4087 other - if (table_flags() & HA_STATS_RECORDS_IS_EXACT)
4088 the value is the exact number of records in the table
4089 else
4090 it is an estimate
4091 */
4093 ha_rows deleted; /* Deleted records */
4094 ulong mean_rec_length; /* physical reclength */
4095 /* TODO: create_time should be retrieved from the new DD. Remove this. */
4096 time_t create_time; /* When table was created */
4099 uint block_size; /* index block size */
4100
4101 /*
4102 number of buffer bytes that native mrr implementation needs,
4103 */
4105
4106 /**
4107 Estimate for how much of the table that is available in a memory
4108 buffer. Valid range is [0..1]. If it has the special value
4109 IN_MEMORY_ESTIMATE_UNKNOWN (defined in structs.h), it means that
4110 the storage engine has not supplied any value for it.
4111 */
4113
4115 : data_file_length(0),
4118 delete_length(0),
4120 records(0),
4121 deleted(0),
4122 mean_rec_length(0),
4123 create_time(0),
4124 check_time(0),
4125 update_time(0),
4126 block_size(0),
4128};
4129
4131 public:
4133
4135};
4136
4137/**
4138 Calculates length of key.
4139
4140 Given a key index and a map of key parts return length of buffer used by key
4141 parts.
4142
4143 @param table Table containing the key
4144 @param key Key index
4145 @param keypart_map which key parts that is used
4146
4147 @return Length of used key parts.
4148*/
4149uint calculate_key_len(TABLE *table, uint key, key_part_map keypart_map);
4150/*
4151 bitmap with first N+1 bits set
4152 (keypart_map for a key prefix of [0..N] keyparts)
4153*/
4154#define make_keypart_map(N) (((key_part_map)2 << (N)) - 1)
4155/*
4156 bitmap with first N bits set
4157 (keypart_map for a key prefix of [0..N-1] keyparts)
4158*/
4159#define make_prev_keypart_map(N) (((key_part_map)1 << (N)) - 1)
4160
4161/** Base class to be used by handlers different shares */
4163 public:
4164 Handler_share() = default;
4165 virtual ~Handler_share() = default;
4166};
4167
4168/**
4169 Wrapper for struct ft_hints.
4170*/
4171
4173 private:
4175
4176 public:
4177 explicit Ft_hints(uint ft_flags) {
4178 hints.flags = ft_flags;
4180 hints.op_value = 0.0;
4182 }
4183
4184 /**
4185 Set comparison operation type and and value for master MATCH function.
4186
4187 @param type comparison operation type
4188 @param value comparison operation value
4189 */
4190 void set_hint_op(enum ft_operation type, double value) {
4191 hints.op_type = type;
4193 }
4194
4195 /**
4196 Set Ft_hints flag.
4197
4198 @param ft_flag Ft_hints flag
4199 */
4200 void set_hint_flag(uint ft_flag) { hints.flags |= ft_flag; }
4201
4202 /**
4203 Set Ft_hints limit.
4204
4205 @param ft_limit limit
4206 */
4207 void set_hint_limit(ha_rows ft_limit) { hints.limit = ft_limit; }
4208
4209 /**
4210 Get Ft_hints limit.
4211
4212 @return Ft_hints limit
4213 */
4214 ha_rows get_limit() const { return hints.limit; }
4215
4216 /**
4217 Get Ft_hints operation value.
4218
4219 @return operation value
4220 */
4221 double get_op_value() const { return hints.op_value; }
4222
4223 /**
4224 Get Ft_hints operation type.
4225
4226 @return operation type
4227 */
4228 enum ft_operation get_op_type() const { return hints.op_type; }
4229
4230 /**
4231 Get Ft_hints flags.
4232
4233 @return Ft_hints flags
4234 */
4235 uint get_flags() const { return hints.flags; }
4236
4237 /**
4238 Get ft_hints struct.
4239
4240 @return pointer to ft_hints struct
4241 */
4242 struct ft_hints *get_hints() { return &hints; }
4243};
4244
4245/**
4246 The handler class is the interface for dynamically loadable
4247 storage engines. Do not add ifdefs and take care when adding or
4248 changing virtual functions to avoid vtable confusion
4249
4250 Functions in this class accept and return table columns data. Two data
4251 representation formats are used:
4252 1. TableRecordFormat - Used to pass [partial] table records to/from
4253 storage engine
4254
4255 2. KeyTupleFormat - used to pass index search tuples (aka "keys") to
4256 storage engine. See opt_range.cc for description of this format.
4257
4258 TableRecordFormat
4259 =================
4260 [Warning: this description is work in progress and may be incomplete]
4261 The table record is stored in a fixed-size buffer:
4262
4263 record: null_bytes, column1_data, column2_data, ...
4264
4265 The offsets of the parts of the buffer are also fixed: every column has
4266 an offset to its column{i}_data, and if it is nullable it also has its own
4267 bit in null_bytes.
4268
4269 The record buffer only includes data about columns that are marked in the
4270 relevant column set (table->read_set and/or table->write_set, depending on
4271 the situation).
4272 <not-sure>It could be that it is required that null bits of non-present
4273 columns are set to 1</not-sure>
4274
4275 VARIOUS EXCEPTIONS AND SPECIAL CASES
4276
4277 If the table has no nullable columns, then null_bytes is still
4278 present, its length is one byte <not-sure> which must be set to 0xFF
4279 at all times. </not-sure>
4280
4281 If the table has columns of type BIT, then certain bits from those columns
4282 may be stored in null_bytes as well. Grep around for Field_bit for
4283 details.
4284
4285 For blob columns (see Field_blob), the record buffer stores length of the
4286 data, following by memory pointer to the blob data. The pointer is owned
4287 by the storage engine and is valid until the next operation.
4288
4289 If a blob column has NULL value, then its length and blob data pointer
4290 must be set to 0.
4291
4292
4293 Overview of main modules of the handler API
4294 ===========================================
4295 The overview below was copied from the storage/partition/ha_partition.h when
4296 support for non-native partitioning was removed.
4297
4298 -------------------------------------------------------------------------
4299 MODULE create/delete handler object
4300 -------------------------------------------------------------------------
4301 Object create/delete method. Normally called when a table object
4302 exists.
4303
4304 -------------------------------------------------------------------------
4305 MODULE meta data changes
4306 -------------------------------------------------------------------------
4307 Meta data routines to CREATE, DROP, RENAME table are often used at
4308 ALTER TABLE (update_create_info used from ALTER TABLE and SHOW ..).
4309
4310 Methods:
4311 delete_table()
4312 rename_table()
4313 create()
4314 update_create_info()
4315
4316 -------------------------------------------------------------------------
4317 MODULE open/close object
4318 -------------------------------------------------------------------------
4319 Open and close handler object to ensure all underlying files and
4320 objects allocated and deallocated for query handling is handled
4321 properly.
4322
4323 A handler object is opened as part of its initialisation and before
4324 being used for normal queries (not before meta-data changes always.
4325 If the object was opened it will also be closed before being deleted.
4326
4327 Methods:
4328 open()
4329 close()
4330
4331 -------------------------------------------------------------------------
4332 MODULE start/end statement
4333 -------------------------------------------------------------------------
4334 This module contains methods that are used to understand start/end of
4335 statements, transaction boundaries, and aid for proper concurrency
4336 control.
4337
4338 Methods:
4339 store_lock()
4340 external_lock()
4341 start_stmt()
4342 lock_count()
4343 unlock_row()
4344 was_semi_consistent_read()
4345 try_semi_consistent_read()
4346
4347 -------------------------------------------------------------------------
4348 MODULE change record
4349 -------------------------------------------------------------------------
4350 This part of the handler interface is used to change the records
4351 after INSERT, DELETE, UPDATE, REPLACE method calls but also other
4352 special meta-data operations as ALTER TABLE, LOAD DATA, TRUNCATE.
4353
4354 These methods are used for insert (write_row), update (update_row)
4355 and delete (delete_row). All methods to change data always work on
4356 one row at a time. update_row and delete_row also contains the old
4357 row.
4358 delete_all_rows will delete all rows in the table in one call as a
4359 special optimization for DELETE from table;
4360
4361 Bulk inserts are supported if all underlying handlers support it.
4362 start_bulk_insert and end_bulk_insert is called before and after a
4363 number of calls to write_row.
4364
4365 Methods:
4366 write_row()
4367 update_row()
4368 delete_row()
4369 delete_all_rows()
4370 start_bulk_insert()
4371 end_bulk_insert()
4372
4373 -------------------------------------------------------------------------
4374 MODULE full table scan
4375 -------------------------------------------------------------------------
4376 This module is used for the most basic access method for any table
4377 handler. This is to fetch all data through a full table scan. No
4378 indexes are needed to implement this part.
4379 It contains one method to start the scan (rnd_init) that can also be
4380 called multiple times (typical in a nested loop join). Then proceeding
4381 to the next record (rnd_next) and closing the scan (rnd_end).
4382 To remember a record for later access there is a method (position)
4383 and there is a method used to retrieve the record based on the stored
4384 position.
4385 The position can be a file position, a primary key, a ROWID dependent
4386 on the handler below.
4387
4388 All functions that retrieve records and are callable through the
4389 handler interface must indicate whether a record is present after the call
4390 or not. Record found is indicated by returning 0 and setting table status
4391 to "has row". Record not found is indicated by returning a non-zero value
4392 and setting table status to "no row".
4393 @see TABLE::set_found_row() and TABLE::set_no_row().
4394 By enforcing these rules in the handler interface, storage handler functions
4395 need not set any status in struct TABLE. These notes also apply to module
4396 index scan, documented below.
4397
4398 Methods:
4399
4400 rnd_init()
4401 rnd_end()
4402 rnd_next()
4403 rnd_pos()
4404 rnd_pos_by_record()
4405 position()
4406
4407 -------------------------------------------------------------------------
4408 MODULE index scan
4409 -------------------------------------------------------------------------
4410 This part of the handler interface is used to perform access through
4411 indexes. The interface is defined as a scan interface but the handler
4412 can also use key lookup if the index is a unique index or a primary
4413 key index.
4414 Index scans are mostly useful for SELECT queries but are an important
4415 part also of UPDATE, DELETE, REPLACE and CREATE TABLE table AS SELECT
4416 and so forth.
4417 Naturally an index is needed for an index scan and indexes can either
4418 be ordered, hash based. Some ordered indexes can return data in order
4419 but not necessarily all of them.
4420 There are many flags that define the behavior of indexes in the
4421 various handlers. These methods are found in the optimizer module.
4422
4423 index_read is called to start a scan of an index. The find_flag defines
4424 the semantics of the scan. These flags are defined in
4425 include/my_base.h
4426 index_read_idx is the same but also initializes index before calling doing
4427 the same thing as index_read. Thus it is similar to index_init followed
4428 by index_read. This is also how we implement it.
4429
4430 index_read/index_read_idx does also return the first row. Thus for
4431 key lookups, the index_read will be the only call to the handler in
4432 the index scan.
4433
4434 index_init initializes an index before using it and index_end does
4435 any end processing needed.
4436
4437 Methods:
4438 index_read_map()
4439 index_init()
4440 index_end()
4441 index_read_idx_map()
4442 index_next()
4443 index_prev()
4444 index_first()
4445 index_last()
4446 index_next_same()
4447 index_read_last_map()
4448 read_range_first()
4449 read_range_next()
4450
4451 -------------------------------------------------------------------------
4452 MODULE information calls
4453 -------------------------------------------------------------------------
4454 This calls are used to inform the handler of specifics of the ongoing
4455 scans and other actions. Most of these are used for optimisation
4456 purposes.
4457
4458 Methods:
4459 info()
4460 get_dynamic_partition_info
4461 extra()
4462 extra_opt()
4463 reset()
4464
4465 -------------------------------------------------------------------------
4466 MODULE optimizer support
4467 -------------------------------------------------------------------------
4468 NOTE:
4469 One important part of the public handler interface that is not depicted in
4470 the methods is the attribute records which is defined in the base class.
4471 This is looked upon directly and is set by calling info(HA_STATUS_INFO) ?
4472
4473 Methods:
4474 min_rows_for_estimate()
4475 get_biggest_used_partition()
4476 scan_time()
4477 read_time()
4478 records_in_range()
4479 estimate_rows_upper_bound()
4480 records()
4481
4482 -------------------------------------------------------------------------
4483 MODULE print messages
4484 -------------------------------------------------------------------------
4485 This module contains various methods that returns text messages for
4486 table types, index type and error messages.
4487
4488 Methods:
4489 table_type()
4490 get_row_type()
4491 print_error()
4492 get_error_message()
4493
4494 -------------------------------------------------------------------------
4495 MODULE handler characteristics
4496 -------------------------------------------------------------------------
4497 This module contains a number of methods defining limitations and
4498 characteristics of the handler (see also documentation regarding the
4499 individual flags).
4500
4501 Methods:
4502 table_flags()
4503 index_flags()
4504 min_of_the_max_uint()
4505 max_supported_record_length()
4506 max_supported_keys()
4507 max_supported_key_parts()
4508 max_supported_key_length()
4509 max_supported_key_part_length()
4510 low_byte_first()
4511 extra_rec_buf_length()
4512 min_record_length(uint options)
4513 primary_key_is_clustered()
4514 ha_key_alg get_default_index_algorithm()
4515 is_index_algorithm_supported()
4516
4517 -------------------------------------------------------------------------
4518 MODULE compare records
4519 -------------------------------------------------------------------------
4520 cmp_ref checks if two references are the same. For most handlers this is
4521 a simple memcmp of the reference. However some handlers use primary key
4522 as reference and this can be the same even if memcmp says they are
4523 different. This is due to character sets and end spaces and so forth.
4524
4525 Methods:
4526 cmp_ref()
4527
4528 -------------------------------------------------------------------------
4529 MODULE auto increment
4530 -------------------------------------------------------------------------
4531 This module is used to handle the support of auto increments.
4532
4533 This variable in the handler is used as part of the handler interface
4534 It is maintained by the parent handler object and should not be
4535 touched by child handler objects (see handler.cc for its use).
4536
4537 Methods:
4538 get_auto_increment()
4539 release_auto_increment()
4540
4541 -------------------------------------------------------------------------
4542 MODULE initialize handler for HANDLER call
4543 -------------------------------------------------------------------------
4544 This method is a special InnoDB method called before a HANDLER query.
4545
4546 Methods:
4547 init_table_handle_for_HANDLER()
4548
4549 -------------------------------------------------------------------------
4550 MODULE fulltext index
4551 -------------------------------------------------------------------------
4552 Fulltext index support.
4553
4554 Methods:
4555 ft_init_ext_with_hints()
4556 ft_init()
4557 ft_init_ext()
4558 ft_read()
4559
4560 -------------------------------------------------------------------------
4561 MODULE in-place ALTER TABLE
4562 -------------------------------------------------------------------------
4563 Methods for in-place ALTER TABLE support (implemented by InnoDB and NDB).
4564
4565 Methods:
4566 check_if_supported_inplace_alter()
4567 prepare_inplace_alter_table()
4568 inplace_alter_table()
4569 commit_inplace_alter_table()
4570 notify_table_changed()
4571
4572 -------------------------------------------------------------------------
4573 MODULE tablespace support
4574 -------------------------------------------------------------------------
4575 Methods:
4576 discard_or_import_tablespace()
4577
4578 -------------------------------------------------------------------------
4579 MODULE administrative DDL
4580 -------------------------------------------------------------------------
4581 Methods:
4582 optimize()
4583 analyze()
4584 check()
4585 repair()
4586 check_and_repair()
4587 auto_repair()
4588 is_crashed()
4589 check_for_upgrade()
4590 checksum()
4591 assign_to_keycache()
4592
4593 -------------------------------------------------------------------------
4594 MODULE enable/disable indexes
4595 -------------------------------------------------------------------------
4596 Enable/Disable Indexes are only supported by HEAP and MyISAM.
4597
4598 Methods:
4599 disable_indexes()
4600 enable_indexes()
4601 indexes_are_disabled()
4602
4603 -------------------------------------------------------------------------
4604 MODULE append_create_info
4605 -------------------------------------------------------------------------
4606 Only used by MyISAM MERGE tables.
4607
4608 Methods:
4609 append_create_info()
4610
4611 -------------------------------------------------------------------------
4612 MODULE partitioning specific handler API
4613 -------------------------------------------------------------------------
4614 Methods:
4615 get_partition_handler()
4616*/
4617
4618class handler {
4619 friend class Partition_handler;
4620
4621 public:
4623 using Blob_context = void *;
4624
4625 protected:
4626 TABLE_SHARE *table_share; /* The table definition */
4627 TABLE *table; /* The current open table */
4628 Table_flags cached_table_flags{0}; /* Set on init() and open() */
4629
4631
4632 public:
4633 handlerton *ht; /* storage engine of this handler */
4634 /** Pointer to current row */
4636 /** Pointer to duplicate row */
4638
4640
4641 /* MultiRangeRead-related members: */
4642 range_seq_t mrr_iter; /* Iterator to traverse the range sequence */
4643 RANGE_SEQ_IF mrr_funcs; /* Range sequence traversal functions */
4644 HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
4645 uint ranges_in_seq; /* Total number of ranges in the traversed sequence */
4646 /* true <=> source MRR ranges and the output are ordered */
4648
4649 /* true <=> we're currently traversing a range in mrr_cur_range. */
4651 /* Current range (the one we're now returning rows from) */
4653
4654 /*
4655 The direction of the current range or index scan. This is used by
4656 the ICP implementation to determine if it has reached the end
4657 of the current range.
4658 */
4660
4661 private:
4662 Record_buffer *m_record_buffer = nullptr; ///< Buffer for multi-row reads.
4663 /*
4664 Storage space for the end range value. Should only be accessed using
4665 the end_range pointer. The content is invalid when end_range is NULL.
4666 */
4670
4671 /**
4672 Pointer to the handler of the table in the primary storage engine,
4673 if this handler represents a table in a secondary storage engine.
4674 */
4676
4677 protected:
4680 /*
4681 true <=> the engine guarantees that returned records are within the range
4682 being scanned.
4683 */
4685
4686 public:
4687 /**
4688 End value for a range scan. If this is NULL the range scan has no
4689 end value. Should also be NULL when there is no ongoing range scan.
4690 Used by the read_range() functions and also evaluated by pushed
4691 index conditions.
4692 */
4694 /**
4695 Flag which tells if #end_range contains a virtual generated column.
4696 The content is invalid when #end_range is @c nullptr.
4697 */
4699 uint errkey; /* Last dup key */
4702 /** Length of ref (1-8 or the clustered key length) */
4705 enum { NONE = 0, INDEX, RND, SAMPLING } inited;
4706 bool implicit_emptied; /* Can be !=0 only if HEAP */
4708
4710 uint pushed_idx_cond_keyno; /* The index which the above condition is for */
4711
4712 /**
4713 next_insert_id is the next value which should be inserted into the
4714 auto_increment column: in a inserting-multi-row statement (like INSERT
4715 SELECT), for the first row where the autoinc value is not specified by the
4716 statement, get_auto_increment() called and asked to generate a value,
4717 next_insert_id is set to the next value, then for all other rows
4718 next_insert_id is used (and increased each time) without calling
4719 get_auto_increment().
4720 */
4722 /**
4723 insert id for the current row (*autogenerated*; if not
4724 autogenerated, it's 0).
4725 At first successful insertion, this variable is stored into
4726 THD::first_successful_insert_id_in_cur_stmt.
4727 */
4729 /**
4730 Interval returned by get_auto_increment() and being consumed by the
4731 inserter.
4732 */
4734 /**
4735 Number of reserved auto-increment intervals. Serves as a heuristic
4736 when we have no estimation of how many records the statement will insert:
4737 the more intervals we have reserved, the bigger the next one. Reset in
4738 handler::ha_release_auto_increment().
4739 */
4741
4742 /**
4743 Instrumented table associated with this handler.
4744 */
4746
4747 std::mt19937 *m_random_number_engine{nullptr};
4749
4750 private:
4751 /** Internal state of the batch instrumentation. */
4753 /** Batch mode not used. */
4755 /** Batch mode used, before first table io. */
4757 /** Batch mode used, after first table io. */
4760 /**
4761 Batch mode state.
4762 @sa start_psi_batch_mode.
4763 @sa end_psi_batch_mode.
4764 */
4766 /**
4767 The number of rows in the batch.
4768 @sa start_psi_batch_mode.
4769 @sa end_psi_batch_mode.
4770 */
4772 /**
4773 The current event in a batch.
4774 @sa start_psi_batch_mode.
4775 @sa end_psi_batch_mode.
4776 */
4778 /**
4779 Storage for the event in a batch.
4780 @sa start_psi_batch_mode.
4781 @sa end_psi_batch_mode.
4782 */
4784
4785 public:
4786 void unbind_psi();
4787 void rebind_psi();
4788 /**
4789 Put the handler in 'batch' mode when collecting
4790 table io instrumented events.
4791 When operating in batch mode:
4792 - a single start event is generated in the performance schema.
4793 - all table io performed between @c start_psi_batch_mode
4794 and @c end_psi_batch_mode is not instrumented:
4795 the number of rows affected is counted instead in @c m_psi_numrows.
4796 - a single end event is generated in the performance schema
4797 when the batch mode ends with @c end_psi_batch_mode.
4798 */
4799 void start_psi_batch_mode();
4800 /** End a batch started with @c start_psi_batch_mode. */
4801 void end_psi_batch_mode();
4802 /**
4803 If a PSI batch was started, turn if off.
4804 @returns true if it was started.
4805 */
4807 const bool rc = m_psi_batch_mode;
4808 if (rc) end_psi_batch_mode();
4809 return rc;
4810 }
4811
4812 private:
4813 /**
4814 The lock type set by when calling::ha_external_lock(). This is
4815 propagated down to the storage engine. The reason for also storing
4816 it here, is that when doing MRR we need to create/clone a second handler
4817 object. This cloned handler object needs to know about the lock_type used.
4818 */
4820 /**
4821 Pointer where to store/retrieve the Handler_share pointer.
4822 For non partitioned handlers this is &TABLE_SHARE::ha_share.
4823 */
4825
4826 /**
4827 Some non-virtual ha_* functions, responsible for reading rows,
4828 like ha_rnd_pos(), must ensure that virtual generated columns are
4829 calculated before they return. For that, they should set this
4830 member to true at their start, and check it before they return: if
4831 the member is still true, it means they should calculate; if it's
4832 false, it means the calculation has been done by some called
4833 lower-level function and does not need to be re-done (which is why
4834 we need this status flag: to avoid redundant calculations, for
4835 performance).
4836
4837 Note that when updating generated fields, the NULL row status in
4838 the underlying TABLE objects matter, so be sure to reset them if needed!
4839 */
4841
4842 /* Filter row ids to weed out duplicates when multi-valued index is used */
4844
4845 public:
4846 handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
4847 : table_share(share_arg),
4848 table(nullptr),
4850 ht(ht_arg),
4851 ref(nullptr),
4857 ref_length(sizeof(my_off_t)),
4859 inited(NONE),
4860 implicit_emptied(false),
4864 next_insert_id(0),
4867 m_psi(nullptr),
4869 m_psi_numrows(0),
4871 m_lock_type(F_UNLCK),
4874 m_unique(nullptr) {
4875 DBUG_PRINT("info", ("handler created F_UNLCK %d F_RDLCK %d F_WRLCK %d",
4876 F_UNLCK, F_RDLCK, F_WRLCK));
4877 }
4878
4879 virtual ~handler(void) {
4880 assert(m_psi == nullptr);
4882 assert(m_psi_locker == nullptr);
4883 assert(m_lock_type == F_UNLCK);
4884 assert(inited == NONE);
4885 }
4886
4887 /**
4888 Return extra handler specific text for EXPLAIN.
4889 */
4890 virtual std::string explain_extra() const { return ""; }
4891
4892 /*
4893 @todo reorganize functions, make proper public/protected/private qualifiers
4894 */
4895 virtual handler *clone(const char *name, MEM_ROOT *mem_root);
4896 /** This is called after create to allow us to set up cached variables */
4898 /* ha_ methods: public wrappers for private virtual API */
4899
4900 /**
4901 Set a record buffer that the storage engine can use for multi-row reads.
4902 The buffer has to be provided prior to the first read from an index or a
4903 table.
4904
4905 @param buffer the buffer to use for multi-row reads
4906 */
4908
4909 /**
4910 Get the record buffer that was set with ha_set_record_buffer().
4911
4912 @return the buffer to use for multi-row reads, or nullptr if there is none
4913 */
4915
4916 /**
4917 Does this handler want to get a Record_buffer for multi-row reads
4918 via the ha_set_record_buffer() function? And if so, what is the
4919 maximum number of records to allocate space for in the buffer?
4920
4921 Storage engines that support using a Record_buffer should override
4922 handler::is_record_buffer_wanted().
4923
4924 @param[out] max_rows gets set to the maximum number of records to
4925 allocate space for in the buffer if the function
4926 returns true
4927
4928 @retval true if the handler would like a Record_buffer
4929 @retval false if the handler does not want a Record_buffer
4930 */
4931 bool ha_is_record_buffer_wanted(ha_rows *const max_rows) const {
4932 return is_record_buffer_wanted(max_rows);
4933 }
4934
4935 int ha_open(TABLE *table, const char *name, int mode, int test_if_locked,
4936 const dd::Table *table_def);
4937 int ha_close(void);
4938 int ha_index_init(uint idx, bool sorted);
4939 int ha_index_end();
4940 int ha_rnd_init(bool scan);
4941 int ha_rnd_end();
4942 int ha_rnd_next(uchar *buf);
4943 // See the comment on m_update_generated_read_fields.
4944 int ha_rnd_pos(uchar *buf, uchar *pos);
4945 int ha_index_read_map(uchar *buf, const uchar *key, key_part_map keypart_map,
4946 enum ha_rkey_function find_flag);
4948 key_part_map keypart_map);
4949 int ha_index_read_idx_map(uchar *buf, uint index, const uchar *key,
4950 key_part_map keypart_map,
4951 enum ha_rkey_function find_flag);
4952 int ha_index_next(uchar *buf);
4953 int ha_index_prev(uchar *buf);
4954 int ha_index_first(uchar *buf);
4955 int ha_index_last(uchar *buf);
4956 int ha_index_next_same(uchar *buf, const uchar *key, uint keylen);
4957 int ha_reset();
4958 /* this is necessary in many places, e.g. in HANDLER command */
4960 return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
4961 }
4962 /**
4963 The cached_table_flags is set at ha_open and ha_external_lock
4964 */
4966 /**
4967 These functions represent the public interface to *users* of the
4968 handler class, hence they are *not* virtual. For the inheritance
4969 interface, see the (private) functions write_row(), update_row(),
4970 and delete_row() below.
4971 */
4972 int ha_external_lock(THD *thd, int lock_type);
4973 int ha_write_row(uchar *buf);
4974 /**
4975 Update the current row.
4976
4977 @param old_data the old contents of the row
4978 @param new_data the new contents of the row
4979 @return error status (zero on success, HA_ERR_* error code on error)
4980 */
4981 int ha_update_row(const uchar *old_data, uchar *new_data);
4982 int ha_delete_row(const uchar *buf);
4984
4985 int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
4986 /** to be actually called to get 'check()' functionality*/
4987 int ha_check(THD *thd, HA_CHECK_OPT *check_opt);
4988 int ha_repair(THD *thd, HA_CHECK_OPT *check_opt);
4989 void ha_start_bulk_insert(ha_rows rows);
4990 int ha_end_bulk_insert();
4991 int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
4992 uint *dup_key_found);
4993 int ha_delete_all_rows();
4995 int ha_optimize(THD *thd, HA_CHECK_OPT *check_opt);
4996 int ha_analyze(THD *thd, HA_CHECK_OPT *check_opt);
4997 bool ha_check_and_repair(THD *thd);
4998 int ha_disable_indexes(uint mode);
4999 int ha_enable_indexes(uint mode);
5001 int ha_rename_table(const char *from, const char *to,
5002 const dd::Table *from_table_def, dd::Table *to_table_def);
5003 int ha_delete_table(const char *name, const dd::Table *table_def);
5004 void ha_drop_table(const char *name);
5005
5006 int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info,
5008
5009 int ha_load_table(const TABLE &table, bool *skip_metadata_update);
5010
5011 int ha_unload_table(const char *db_name, const char *table_name,
5012 bool error_if_not_loaded);
5013
5014 /**
5015 Initializes a parallel scan. It creates a parallel_scan_ctx that has to
5016 be used across all parallel_scan methods. Also, gets the number of
5017 threads that would be spawned for parallel scan.
5018 @param[out] scan_ctx The parallel scan context.
5019 @param[out] num_threads Number of threads used for the scan.
5020 @param[in] use_reserved_threads true if reserved threads are to be used
5021 if we exhaust the max cap of number of
5022 parallel read threads that can be
5023 spawned at a time
5024 @param[in] max_desired_threads Maximum number of desired scan threads;
5025 passing 0 has no effect, it is ignored.
5026 @return error code
5027 @retval 0 on success
5028 */
5029 virtual int parallel_scan_init(void *&scan_ctx [[maybe_unused]],
5030 size_t *num_threads [[maybe_unused]],
5031 bool use_reserved_threads [[maybe_unused]],
5032 size_t max_desired_threads [[maybe_unused]]) {
5033 return 0;
5034 }
5035
5036 /**
5037 This callback is called by each parallel load thread at the beginning of
5038 the parallel load for the adapter scan.
5039 @param cookie The cookie for this thread
5040 @param ncols Number of columns in each row
5041 @param row_len The size of a row in bytes
5042 @param col_offsets An array of size ncols, where each element represents
5043 the offset of a column in the row data. The memory of
5044 this array belongs to the caller and will be free-ed
5045 after the pload_end_cbk call.
5046 @param null_byte_offsets An array of size ncols, where each element
5047 represents the offset of a column in the row data. The
5048 memory of this array belongs to the caller and will be
5049 free-ed after the pload_end_cbk call.
5050 @param null_bitmasks An array of size ncols, where each element
5051 represents the bitmask required to get the null bit. The
5052 memory of this array belongs to the caller and will be
5053 free-ed after the pload_end_cbk call.
5054 */
5055 using Load_init_cbk = std::function<bool(
5056 void *cookie, ulong ncols, ulong row_len, const ulong *col_offsets,
5057 const ulong *null_byte_offsets, const ulong *null_bitmasks)>;
5058
5059 /**
5060 This callback is called by each parallel load thread when processing
5061 of rows is required for the adapter scan.
5062 @param[in] cookie The cookie for this thread
5063 @param[in] nrows The nrows that are available
5064 @param[in] rowdata The mysql-in-memory row data buffer. This is a
5065 memory buffer for nrows records. The length of each record is fixed and
5066 communicated via Load_init_cbk
5067 @param[in] partition_id Partition id if it's a partitioned table, else
5068 std::numeric_limits<uint64_t>::max()
5069 @returns true if there is an error, false otherwise.
5070 */
5071 using Load_cbk = std::function<bool(void *cookie, uint nrows, void *rowdata,
5072 uint64_t partition_id)>;
5073
5074 /**
5075 This callback is called by each parallel load thread when processing
5076 of rows has ended for the adapter scan.
5077 @param[in] cookie The cookie for this thread
5078 */
5079 using Load_end_cbk = std::function<void(void *cookie)>;
5080
5081 /**
5082 Run the parallel read of data.
5083 @param[in] scan_ctx Scan context of the parallel read.
5084 @param[in,out] thread_ctxs Caller thread contexts.
5085 @param[in] init_fn Callback called by each parallel load
5086 thread at the beginning of the parallel load.
5087 @param[in] load_fn Callback called by each parallel load
5088 thread when processing of rows is required.
5089 @param[in] end_fn Callback called by each parallel load
5090 thread when processing of rows has ended.
5091 @return error code
5092 @retval 0 on success
5093 */
5094 virtual int parallel_scan(void *scan_ctx [[maybe_unused]],
5095 void **thread_ctxs [[maybe_unused]],
5096 Load_init_cbk init_fn [[maybe_unused]],
5097 Load_cbk load_fn [[maybe_unused]],
5098 Load_end_cbk end_fn [[maybe_unused]]) {
5099 return 0;
5100 }
5101
5102 /**
5103 End of the parallel scan.
5104 @param[in] scan_ctx A scan context created by parallel_scan_init.
5105 */
5106 virtual void parallel_scan_end(void *scan_ctx [[maybe_unused]]) { return; }
5107
5108 /** Check if the table is ready for bulk load
5109 @param[in] thd user session
5110 @return true iff bulk load can be done on the table. */
5111 virtual bool bulk_load_check(THD *thd [[maybe_unused]]) const {
5112 return false;
5113 }
5114
5115 /** Get the total memory available for bulk load in SE.
5116 @param[in] thd user session
5117 @return available memory for bulk load */
5118 virtual size_t bulk_load_available_memory(THD *thd [[maybe_unused]]) const {
5119 return 0;
5120 }
5121
5122 /** Begin parallel bulk data load to the table.
5123 @param[in] thd user session
5124 @param[in] data_size total data size to load
5125 @param[in] memory memory to be used by SE
5126 @param[in] num_threads number of concurrent threads used for load.
5127 @return bulk load context or nullptr if unsuccessful. */
5128 virtual void *bulk_load_begin(THD *thd [[maybe_unused]],
5129 size_t keynr [[maybe_unused]],
5130 size_t data_size [[maybe_unused]],
5131 size_t memory [[maybe_unused]],
5132 size_t num_threads [[maybe_unused]]) {
5133 return nullptr;
5134 }
5135
5136 /** Execute bulk load operation. To be called by each of the concurrent
5137 threads idenified by thread index.
5138 @param[in,out] thd user session
5139 @param[in,out] load_ctx load execution context
5140 @param[in] thread_idx index of the thread executing
5141 @param[in] rows rows to be loaded to the table
5142 @return error code. */
5143 virtual int bulk_load_execute(THD *thd [[maybe_unused]],
5144 void *load_ctx [[maybe_unused]],
5145 size_t thread_idx [[maybe_unused]],
5146 const Rows_mysql &rows [[maybe_unused]],
5148 [[maybe_unused]]) {
5149 return HA_ERR_UNSUPPORTED;
5150 }
5151
5152 /** Open a blob for write operation.
5153 @param[in,out] thd user session
5154 @param[in,out] load_ctx load execution context
5155 @param[in] thread_idx index of the thread executing
5156 @param[out] blob_ctx a blob context
5157 @param[out] blobref a blob reference to be placed in the record.
5158 @return 0 on success, error code on failure */
5159 virtual int open_blob(THD *thd [[maybe_unused]],
5160 void *load_ctx [[maybe_unused]],
5161 size_t thread_idx [[maybe_unused]],
5162 Blob_context &blob_ctx [[maybe_unused]],
5163 unsigned char *blobref [[maybe_unused]]) {
5164 return HA_ERR_UNSUPPORTED;
5165 }
5166
5167 /** Write to a blob
5168 @param[in,out] thd user session
5169 @param[in,out] load_ctx load execution context
5170 @param[in] thread_idx index of the thread executing
5171 @param[in] blob_ctx a blob context
5172 @param[in] data data to be written to blob.
5173 @param[in] data_len length of data to be written in bytes.
5174 @return 0 on success, error code on failure */
5175 virtual int write_blob(THD *thd [[maybe_unused]],
5176 void *load_ctx [[maybe_unused]],
5177 size_t thread_idx [[maybe_unused]],
5178 Blob_context blob_ctx [[maybe_unused]],
5179 unsigned char *blobref [[maybe_unused]],
5180 const unsigned char *data [[maybe_unused]],
5181 size_t data_len [[maybe_unused]]) {
5182 return HA_ERR_UNSUPPORTED;
5183 }
5184
5185 /** Close the blob
5186 @param[in,out] thd user session
5187 @param[in,out] load_ctx load execution context
5188 @param[in] thread_idx index of the thread executing
5189 @param[in] blob_ctx a blob context
5190 @return 0 on success, error code on failure */
5191 virtual int close_blob(THD *thd [[maybe_unused]],
5192 void *load_ctx [[maybe_unused]],
5193 size_t thread_idx [[maybe_unused]],
5194 Blob_context blob_ctx [[maybe_unused]],
5195 unsigned char *blobref [[maybe_unused]]) {
5196 return HA_ERR_UNSUPPORTED;
5197 }
5198
5199 /** End bulk load operation. Must be called after all execution threads have
5200 completed. Must be called even if the bulk load execution failed.
5201 @param[in,out] thd user session
5202 @param[in,out] load_ctx load execution context
5203 @param[in] is_error true, if bulk load execution have failed
5204 @return error code. */
5205 virtual int bulk_load_end(THD *thd [[maybe_unused]],
5206 void *load_ctx [[maybe_unused]],
5207 bool is_error [[maybe_unused]]) {
5208 return false;
5209 }
5210
5211 /**
5212 Submit a dd::Table object representing a core DD table having
5213 hardcoded data to be filled in by the DDSE. This function can be
5214 used for retrieving the hard coded SE private data for the
5215 mysql.dd_properties table, before creating or opening it, or for
5216 retrieving the hard coded SE private data for a core table,
5217 before creating or opening them.
5218
5219 @param dd_table [in,out] A dd::Table object representing
5220 a core DD table.
5221 @param reset Reset counters.
5222
5223 @retval true An error occurred.
5224 @retval false Success - no errors.
5225 */
5226
5227 bool ha_get_se_private_data(dd::Table *dd_table, bool reset);
5228
5231 virtual void print_error(int error, myf errflag);
5232 virtual bool get_error_message(int error, String *buf);
5233 uint get_dup_key(int error);
5234 /**
5235 Retrieves the names of the table and the key for which there was a
5236 duplicate entry in the case of HA_ERR_FOREIGN_DUPLICATE_KEY.
5237
5238 If any of the table or key name is not available this method will return
5239 false and will not change any of child_table_name or child_key_name.
5240
5241 @param [out] child_table_name Table name
5242 @param [in] child_table_name_len Table name buffer size
5243 @param [out] child_key_name Key name
5244 @param [in] child_key_name_len Key name buffer size
5245
5246 @retval true table and key names were available
5247 and were written into the corresponding
5248 out parameters.
5249 @retval false table and key names were not available,
5250 the out parameters were not touched.
5251 */
5252 virtual bool get_foreign_dup_key(char *child_table_name,
5253 uint child_table_name_len,
5254 char *child_key_name,
5255 uint child_key_name_len);
5256 /**
5257 Change the internal TABLE_SHARE pointer.
5258
5259 @param table_arg TABLE object
5260 @param share New share to use
5261
5262 @note Is used in error handling in ha_delete_table.
5263 */
5264
5265 virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share) {
5266 table = table_arg;
5268 }
5269 const TABLE_SHARE *get_table_share() const { return table_share; }
5270 const TABLE *get_table() const { return table; }
5271
5272 /* Estimates calculation */
5273
5274 /**
5275 @deprecated This function is deprecated and will be removed in a future
5276 version. Use table_scan_cost() instead.
5277 */
5278
5279 virtual double scan_time() {
5280 return ulonglong2double(stats.data_file_length) / IO_SIZE + 2;
5281 }
5282
5283 /**
5284 The cost of reading a set of ranges from the table using an index
5285 to access it.
5286
5287 @deprecated This function is deprecated and will be removed in a future
5288 version. Use read_cost() instead.
5289
5290 @param index The index number.
5291 @param ranges The number of ranges to be read.
5292 @param rows Total number of rows to be read.
5293
5294 This method can be used to calculate the total cost of scanning a table
5295 using an index by calling it using read_time(index, 1, table_size).
5296 */
5297
5298 virtual double read_time(uint index [[maybe_unused]], uint ranges,
5299 ha_rows rows) {
5300 return rows2double(ranges + rows);
5301 }
5302
5303 /**
5304 @deprecated This function is deprecated and will be removed in a future
5305 version. Use index_scan_cost() instead.
5306 */
5307
5308 virtual double index_only_read_time(uint keynr, double records);
5309
5310 /**
5311 Cost estimate for doing a complete table scan.
5312
5313 @note For this version it is recommended that storage engines continue
5314 to override scan_time() instead of this function.
5315
5316 @returns the estimated cost
5317 */
5318
5320
5321 /**
5322 Cost estimate for reading a number of ranges from an index.
5323
5324 The cost estimate will only include the cost of reading data that
5325 is contained in the index. If the records need to be read, use
5326 read_cost() instead.
5327
5328 @note The ranges parameter is currently ignored and is not taken
5329 into account in the cost estimate.
5330
5331 @note For this version it is recommended that storage engines continue
5332 to override index_only_read_time() instead of this function.
5333
5334 @param index the index number
5335 @param ranges the number of ranges to be read
5336 @param rows total number of rows to be read
5337
5338 @returns the estimated cost
5339 */
5340
5341 virtual Cost_estimate index_scan_cost(uint index, double ranges, double rows);
5342
5343 /**
5344 Cost estimate for reading a set of ranges from the table using an index
5345 to access it.
5346
5347 @note For this version it is recommended that storage engines continue
5348 to override read_time() instead of this function.
5349
5350 @param index the index number
5351 @param ranges the number of ranges to be read
5352 @param rows total number of rows to be read
5353
5354 @returns the estimated cost
5355 */
5356
5357 virtual Cost_estimate read_cost(uint index, double ranges, double rows);
5358
5359 /**
5360 Cost estimate for doing a number of non-sequentially accesses
5361 against the storage engine. Such accesses can be either number
5362 of rows to read, or number of disk pages to access.
5363 Each handler implementation is free to interpret that as best
5364 suited, depending on what is the dominating cost for that
5365 storage engine.
5366
5367 This method is mainly provided as a temporary workaround for
5368 bug#33317872, where we fix problems caused by calling
5369 Cost_model::page_read_cost() directly from the optimizer.
5370 That should be avoided, as it introduced assumption about all
5371 storage engines being disk-page based, and having a 'page' cost.
5372 Furthermore, this page cost was even compared against read_cost(),
5373 which was computed with an entirely different algorithm, and thus
5374 could not be compared.
5375
5376 The default implementation still call Cost_model::page_read_cost(),
5377 thus behaving just as before. However, handler implementation may
5378 override it to call handler::read_cost() instead(), which probably
5379 will be more correct. (If a page_read_cost should be included
5380 in the cost estimate, that should preferable be done inside
5381 each read_cost() implementation)
5382
5383 Longer term we should consider to remove all page_read_cost()
5384 usage from the optimizer itself, making this method obsolete.
5385
5386 @param index the index number
5387 @param reads the number of accesses being made
5388
5389 @returns the estimated cost
5390 */
5391 virtual double page_read_cost(uint index, double reads);
5392
5393 /**
5394 Provide an upper cost-limit of doing a specified number of
5395 seek-and-read key lookups. This need to be comparable and
5396 calculated with the same 'metric' as page_read_cost.
5397
5398 @param reads the number of rows read in the 'worst' case.
5399
5400 @returns the estimated cost
5401 */
5402 virtual double worst_seek_times(double reads);
5403
5404 /**
5405 Return an estimate on the amount of memory the storage engine will
5406 use for caching data in memory. If this is unknown or the storage
5407 engine does not cache data in memory -1 is returned.
5408 */
5409 virtual longlong get_memory_buffer_size() const { return -1; }
5410
5411 /**
5412 Return an estimate of how much of the table that is currently stored
5413 in main memory.
5414
5415 This estimate should be the fraction of the table that currently
5416 is available in a main memory buffer. The estimate should be in the
5417 range from 0.0 (nothing in memory) to 1.0 (entire table in memory).
5418
5419 @return The fraction of the table in main memory buffer
5420 */
5421
5422 double table_in_memory_estimate() const;
5423
5424 /**
5425 Return an estimate of how much of the index that is currently stored
5426 in main memory.
5427
5428 This estimate should be the fraction of the index that currently
5429 is available in a main memory buffer. The estimate should be in the
5430 range from 0.0 (nothing in memory) to 1.0 (entire index in memory).
5431
5432 @param keyno the index to get an estimate for
5433
5434 @return The fraction of the index in main memory buffer
5435 */
5436
5437 double index_in_memory_estimate(uint keyno) const;
5438
5439 /**
5440 Initialize sampling.
5441
5442 @param[out] scan_ctx A scan context created by this method that has to be
5443 used in sample_next
5444 @param[in] sampling_percentage percentage of records that need to be
5445 sampled
5446 @param[in] sampling_seed random seed that the random generator will
5447 use
5448 @param[in] sampling_method sampling method to be used; currently only
5449 SYSTEM sampling is supported
5450 @param[in] tablesample true if the sampling is for tablesample
5451
5452 @return 0 for success, else one of the HA_xxx values in case of error.
5453 */
5454 int ha_sample_init(void *&scan_ctx, double sampling_percentage,
5455 int sampling_seed, enum_sampling_method sampling_method,
5456 const bool tablesample);
5457
5458 /**
5459 Get the next record for sampling.
5460
5461 @param[in] scan_ctx Scan context of the sampling
5462 @param[in] buf buffer to place the read record
5463
5464 @return 0 for success, else one of the HA_xxx values in case of error.
5465 */
5466 int ha_sample_next(void *scan_ctx, uchar *buf);
5467
5468 /**
5469 End sampling.
5470
5471 @param[in] scan_ctx Scan context of the sampling
5472
5473 @return 0 for success, else one of the HA_xxx values in case of error.
5474 */
5475 int ha_sample_end(void *scan_ctx);
5476
5477 private:
5479
5480 /**
5481 Make a guesstimate for how much of a table or index is in a memory
5482 buffer in the case where the storage engine has not provided any
5483 estimate for this.
5484
5485 @param table_index_size size of the table or index
5486
5487 @return The fraction of the table or index in main memory buffer
5488 */
5489
5490 double estimate_in_memory_buffer(ulonglong table_index_size) const;
5491
5492 public:
5494 uint keyno, RANGE_SEQ_IF *seq, void *seq_init_param, uint n_ranges,
5495 uint *bufsz, uint *flags, bool *force_default_mrr, Cost_estimate *cost);
5496 virtual ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys,
5497 uint *bufsz, uint *flags,
5498 Cost_estimate *cost);
5499 virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
5500 uint n_ranges, uint mode,
5502
5503 int ha_multi_range_read_next(char **range_info);
5504
5505 int ha_read_range_first(const key_range *start_key, const key_range *end_key,
5506 bool eq_range, bool sorted);
5507 int ha_read_range_next();
5508
5510 return (ha_table_flags() & HA_NO_TRANSACTIONS) == 0;
5511 }
5512 virtual uint extra_rec_buf_length() const { return 0; }
5513
5514 /**
5515 @brief Determine whether an error can be ignored or not.
5516
5517 @details This method is used to analyze the error to see whether the
5518 error is ignorable or not. Such errors will be reported as warnings
5519 instead of errors for IGNORE statements. This means that the statement
5520 will not abort, but instead continue to the next row.
5521
5522 HA_ERR_FOUND_DUP_UNIQUE is a special case in MyISAM that means the
5523 same thing as HA_ERR_FOUND_DUP_KEY, but can in some cases lead to
5524 a slightly different error message.
5525
5526 @param error error code received from the handler interface (HA_ERR_...)
5527
5528 @return whether the error is ignorable or not
5529 @retval true the error is ignorable
5530 @retval false the error is not ignorable
5531 */
5532
5533 virtual bool is_ignorable_error(int error);
5534
5535 /**
5536 @brief Determine whether an error is fatal or not.
5537
5538 @details This method is used to analyze the error to see whether the
5539 error is fatal or not. A fatal error is an error that will not be
5540 possible to handle with SP handlers and will not be subject to
5541 retry attempts on the slave.
5542
5543 @param error error code received from the handler interface (HA_ERR_...)
5544
5545 @return whether the error is fatal or not
5546 @retval true the error is fatal
5547 @retval false the error is not fatal
5548 */
5549
5550 virtual bool is_fatal_error(int error);
5551
5552 protected:
5553 virtual int multi_range_read_next(char **range_info);
5554
5555 /**
5556 Number of rows in table. If HA_COUNT_ROWS_INSTANT is set, count is
5557 available instantly. Else do a table scan.
5558
5559 @param num_rows [out] num_rows number of rows in table.
5560
5561 @retval 0 for OK, one of the HA_xxx values in case of error.
5562 */
5563 virtual int records(ha_rows *num_rows);
5564
5565 /**
5566 Number of rows in table counted using the secondary index chosen by
5567 optimizer. See comments in optimize_aggregated_query() .
5568
5569 @param num_rows [out] Number of rows in table.
5570 @param index Index chosen by optimizer for counting.
5571
5572 @retval 0 for OK, one of the HA_xxx values in case of error.
5573 */
5574 virtual int records_from_index(ha_rows *num_rows, uint index);
5575
5576 private:
5577 /**
5578 Function will handle the error code from call to records() and
5579 records_from_index().
5580
5581 @param error return code from records() and records_from_index().
5582 @param num_rows Check if it contains HA_POS_ERROR in case error < 0.
5583
5584 @retval 0 for OK, one of the HA_xxx values in case of error.
5585 */
5586 int handle_records_error(int error, ha_rows *num_rows);
5587
5588 public:
5589 /**
5590 Wrapper function to call records() in storage engine.
5591
5592 @param num_rows [out] Number of rows in table.
5593
5594 @retval 0 for OK, one of the HA_xxx values in case of error.
5595 */
5596 int ha_records(ha_rows *num_rows) {
5597 return handle_records_error(records(num_rows), num_rows);
5598 }
5599
5600 /**
5601 Wrapper function to call records_from_index() in storage engine.
5602
5603 @param num_rows [out] Number of rows in table.
5604 @param index Index chosen by optimizer for counting.
5605
5606 @retval 0 for OK, one of the HA_xxx values in case of error.
5607 */
5608 int ha_records(ha_rows *num_rows, uint index) {
5609 return handle_records_error(records_from_index(num_rows, index), num_rows);
5610 }
5611
5612 /**
5613 Return upper bound of current number of records in the table
5614 (max. of how many records one will retrieve when doing a full table scan)
5615 If upper bound is not known, HA_POS_ERROR should be returned as a max
5616 possible upper bound.
5617 */
5619 return stats.records + EXTRA_RECORDS;
5620 }
5621
5622 /**
5623 Get real row type for the table created based on one specified by user,
5624 CREATE TABLE options and SE capabilities.
5625 */
5627 const HA_CREATE_INFO *create_info) const {
5628 return (create_info->table_options & HA_OPTION_COMPRESS_RECORD)
5630 : ((create_info->table_options & HA_OPTION_PACK_RECORD)
5632 : ROW_TYPE_FIXED);
5633 }
5634
5635 /**
5636 Get default key algorithm for SE. It is used when user has not provided
5637 algorithm explicitly or when algorithm specified is not supported by SE.
5638 */
5641 }
5642
5643 /**
5644 Check if SE supports specific key algorithm.
5645
5646 @note This method is never used for FULLTEXT or SPATIAL keys.
5647 We rely on handler::ha_table_flags() to check if such keys
5648 are supported.
5649 */
5650 virtual bool is_index_algorithm_supported(enum ha_key_alg key_alg) const {
5651 return key_alg == HA_KEY_ALG_SE_SPECIFIC;
5652 }
5653
5654 /**
5655 Signal that the table->read_set and table->write_set table maps changed
5656 The handler is allowed to set additional bits in the above map in this
5657 call. Normally the handler should ignore all calls until we have done
5658 a ha_rnd_init() or ha_index_init(), write_row(), update_row or delete_row()
5659 as there may be several calls to this routine.
5660 */
5661 virtual void column_bitmaps_signal();
5662 uint get_index(void) const { return active_index; }
5663
5664 /**
5665 @retval false Bulk update used by handler
5666 @retval true Bulk update not used, normal operation used
5667 */
5668 virtual bool start_bulk_update() { return true; }
5669 /**
5670 @retval false Bulk delete used by handler
5671 @retval true Bulk delete not used, normal operation used
5672 */
5673 virtual bool start_bulk_delete() { return true; }
5674 /**
5675 After this call all outstanding updates must be performed. The number
5676 of duplicate key errors are reported in the duplicate key parameter.
5677 It is allowed to continue to the batched update after this call, the
5678 handler has to wait until end_bulk_update with changing state.
5679
5680 @param dup_key_found Number of duplicate keys found
5681
5682 @retval 0 Success
5683 @retval >0 Error code
5684 */
5685 virtual int exec_bulk_update(uint *dup_key_found [[maybe_unused]]) {
5686 assert(false);
5687 return HA_ERR_WRONG_COMMAND;
5688 }
5689 /**
5690 Perform any needed clean-up, no outstanding updates are there at the
5691 moment.
5692 */
5693 virtual void end_bulk_update() { return; }
5694 /**
5695 Execute all outstanding deletes and close down the bulk delete.
5696
5697 @retval 0 Success
5698 @retval >0 Error code
5699 */
5700 virtual int end_bulk_delete() {
5701 assert(false);
5702 return HA_ERR_WRONG_COMMAND;
5703 }
5704
5705 protected:
5706 /**
5707 @brief
5708 Positions an index cursor to the index specified in the handle
5709 ('active_index'). Fetches the row if available. If the key value is null,
5710 begin at the first key of the index.
5711 @returns 0 if success (found a record); non-zero if no record.
5712 */
5713 virtual int index_read_map(uchar *buf, const uchar *key,
5714 key_part_map keypart_map,
5715 enum ha_rkey_function find_flag) {
5716 const uint key_len = calculate_key_len(table, active_index, keypart_map);
5717 return index_read(buf, key, key_len, find_flag);
5718 }
5719 /**
5720 Positions an index cursor to the index specified in argument. Fetches
5721 the row if available. If the key value is null, begin at the first key of
5722 the index.
5723 @sa index_read_map()
5724 */
5725 virtual int index_read_idx_map(uchar *buf, uint index, const uchar *key,
5726 key_part_map keypart_map,
5727 enum ha_rkey_function find_flag);
5728
5729 /*
5730 These methods are used to jump to next or previous entry in the index
5731 scan. There are also methods to jump to first and last entry.
5732 */
5733 /// @see index_read_map().
5734 virtual int index_next(uchar *) { return HA_ERR_WRONG_COMMAND; }
5735
5736 /// @see index_read_map().
5737 virtual int index_prev(uchar *) { return HA_ERR_WRONG_COMMAND; }
5738
5739 /// @see index_read_map().
5740 virtual int index_first(uchar *) { return HA_ERR_WRONG_COMMAND; }
5741
5742 /// @see index_read_map().
5743 virtual int index_last(uchar *) { return HA_ERR_WRONG_COMMAND; }
5744
5745 /// @see index_read_map().
5746 virtual int index_next_same(uchar *buf, const uchar *key, uint keylen);
5747
5748 /**
5749 The following functions works like index_read, but it find the last
5750 row with the current key value or prefix.
5751 @see index_read_map().
5752 */
5753 virtual int index_read_last_map(uchar *buf, const uchar *key,
5754 key_part_map keypart_map) {
5755 const uint key_len = calculate_key_len(table, active_index, keypart_map);
5756 return index_read_last(buf, key, key_len);
5757 }
5758
5759 virtual int read_range_first(const key_range *start_key,
5760 const key_range *end_key, bool eq_range_arg,
5761 bool sorted);
5762 virtual int read_range_next();
5763
5764 public:
5765 /**
5766 Set the end position for a range scan. This is used for checking
5767 for when to end the range scan and by the ICP code to determine
5768 that the next record is within the current range.
5769
5770 @param range The end value for the range scan
5771 @param direction Direction of the range scan
5772 */
5773 void set_end_range(const key_range *range,
5774 enum_range_scan_direction direction);
5776 int compare_key_icp(const key_range *range) const;
5777 int compare_key_in_buffer(const uchar *buf) const;
5778 virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
5779 virtual FT_INFO *ft_init_ext(uint flags, uint inx, String *key);
5781 Ft_hints *hints) {
5782 return ft_init_ext(hints->get_flags(), inx, key);
5783 }
5784 int ha_ft_read(uchar *buf);
5786
5787 protected:
5788 /// @see index_read_map().
5789 virtual int rnd_next(uchar *buf) = 0;
5790 /// @see index_read_map().
5791 virtual int rnd_pos(uchar *buf, uchar *pos) = 0;
5792
5793 virtual int ft_read(uchar *) { return HA_ERR_WRONG_COMMAND; }
5794
5795 public:
5796 /**
5797 This function only works for handlers having
5798 HA_PRIMARY_KEY_REQUIRED_FOR_POSITION set.
5799 It will return the row with the PK given in the record argument.
5800 */
5802 int error;
5804
5805 error = ha_rnd_init(false);
5806 if (error != 0) return error;
5807
5810
5811 ha_rnd_end();
5812 return error;
5813 }
5814
5815 /**
5816 Find number of records in a range.
5817
5818 Given a starting key, and an ending key estimate the number of rows that
5819 will exist between the two. max_key may be empty which in case determine
5820 if start_key matches any rows. Used by optimizer to calculate cost of
5821 using a particular index.
5822
5823 @param inx Index number
5824 @param min_key Start of range
5825 @param max_key End of range
5826
5827 @return Number of rows in range.
5828 */
5829
5830 virtual ha_rows records_in_range(uint inx [[maybe_unused]],
5831 key_range *min_key [[maybe_unused]],
5832 key_range *max_key [[maybe_unused]]) {
5833 return (ha_rows)10;
5834 }
5835 /*
5836 If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, then it sets ref
5837 (reference to the row, aka position, with the primary key given in
5838 the record).
5839 Otherwise it set ref to the current row.
5840 */
5841 virtual void position(const uchar *record) = 0;
5842
5843 /**
5844 General method to gather info from handler
5845
5846 ::info() is used to return information to the optimizer.
5847 SHOW also makes use of this data Another note, if your handler
5848 doesn't proved exact record count, you will probably want to
5849 have the following in your code:
5850 if (records < 2)
5851 records = 2;
5852 The reason is that the server will optimize for cases of only a single
5853 record. If in a table scan you don't know the number of records
5854 it will probably be better to set records to two so you can return
5855 as many records as you need.
5856
5857 Along with records a few more variables you may wish to set are:
5858 records
5859 deleted
5860 data_file_length
5861 index_file_length
5862 delete_length
5863 check_time
5864 Take a look at the public variables in handler.h for more information.
5865 See also my_base.h for a full description.
5866
5867 @param flag Specifies what info is requested
5868 */
5869
5870 virtual int info(uint flag) = 0;
5872 [[maybe_unused]]) {
5873 assert(0);
5874 return 0;
5875 }
5876 /**
5877 Request storage engine to do an extra operation: enable,disable or run some
5878 functionality.
5879
5880 @param operation the operation to perform
5881
5882 @returns
5883 0 on success
5884 error otherwise
5885 */
5886 int ha_extra(enum ha_extra_function operation);
5887
5888 private:
5889 /**
5890 Storage engine specific implementation of ha_extra()
5891
5892 @param operation the operation to perform
5893
5894 @returns
5895 0 on success
5896 error otherwise
5897 */
5898 virtual int extra(enum ha_extra_function operation [[maybe_unused]]) {
5899 return 0;
5900 }
5901
5902 public:
5903 virtual int extra_opt(enum ha_extra_function operation,
5904 ulong cache_size [[maybe_unused]]) {
5905 return extra(operation);
5906 }
5907
5908 /**
5909 Get the handlerton of the storage engine if the SE is capable of
5910 pushing down some of the AccessPath functionality.
5911 (Join, Filter conditions, ... possiby more)
5912
5913 Call the handlerton::push_to_engine() method for performing the
5914 actual pushdown of (parts of) the AccessPath functionality
5915
5916 @returns handlerton* of the SE if it may be capable of
5917 off loading part of the query by calling
5918 handlerton::push_to_engine()
5919
5920 Else, 'nullptr' is returned.
5921 */
5923 return nullptr;
5924 }
5925
5926 /**
5927 Start read (before write) removal on the current table.
5928 @see HA_READ_BEFORE_WRITE_REMOVAL
5929 */
5930 virtual bool start_read_removal(void) {
5931 assert(0);
5932 return false;
5933 }
5934
5935 /**
5936 End read (before write) removal and return the number of rows
5937 really written
5938 @see HA_READ_BEFORE_WRITE_REMOVAL
5939 */
5941 assert(0);
5942 return (ha_rows)0;
5943 }
5944
5945 /**
5946 Normally, when running UPDATE or DELETE queries, we need to wait for other
5947 transactions to release their locks on a given row before we can read it and
5948 potentially update it. However, in READ UNCOMMITTED and READ COMMITTED, we
5949 can ignore these locks if we don't intend to modify the row (e.g., because
5950 it failed a WHERE). This is signaled through enabling “semi-consistent
5951 read”, by calling try_semi_consistent_read(true) (and then setting it back
5952 to false after finishing the query).
5953
5954 If semi-consistent read is enabled, and we are in READ UNCOMMITTED or READ
5955 COMMITTED, the storage engine is permitted to return rows that are locked
5956 and thus un-updatable. If the optimizer doesn't want the row, e.g., because
5957 it got filtered out, it can call unlock_row() as usual. However, if it
5958 intends to update the row, it needs to call was_semi_consistent_read()
5959 before doing so. If was_semi_consistent_read() returns false, the row was
5960 never locked to begin with and can be updated as usual. However, if it
5961 returns 1, it was read optimistically, must be discarded (ie., do not try to
5962 update the row) and must be re-read with locking enabled. The next read call
5963 after was_semi_consistent_read() will automatically re-read the same row,
5964 this time with locking enabled.
5965
5966 Thus, typical use in an UPDATE scenario would look like this:
5967
5968 file->try_semi_consistent_read(true);
5969 file->ha_rnd_init(true);
5970 while (file->ha_rnd_next(table->record[0]) == 0) {
5971 if (row is filtered...) {
5972 file->unlock_row();
5973 continue;
5974 }
5975 if (file->was_semi_consistent_read()) {
5976 // Discard the row; next ha_rnd_next() will read it again with
5977 // locking.
5978 continue;
5979 }
5980 // Process row here.
5981 }
5982 file->ha_rnd_end();
5983 file->try_semi_consistent_read(false);
5984
5985 If the transaction isolation level is REPEATABLE READ or SERIALIZABLE,
5986 enabling this flag has no effect.
5987 */
5988 virtual bool was_semi_consistent_read() { return false; }
5989 /**
5990 Tell the engine whether it should avoid unnecessary lock waits.
5991 If yes, in an UPDATE or DELETE, if the row under the cursor was locked
5992 by another transaction, the engine may try an optimistic read of
5993 the last committed row value under the cursor.
5994 */
5995 virtual void try_semi_consistent_read(bool) {}
5996
5997 /**
5998 Unlock last accessed row.
5999
6000 Record currently processed was not in the result set of the statement
6001 and is thus unlocked. Used for UPDATE and DELETE queries.
6002 */
6003
6004 virtual void unlock_row() {}
6005
6006 /**
6007 Start a statement when table is locked
6008
6009 This method is called instead of external lock when the table is locked
6010 before the statement is executed.
6011
6012 @param thd Thread object.
6013 @param lock_type Type of external lock.
6014
6015 @retval >0 Error code.
6016 @retval 0 Success.
6017 */
6018
6019 virtual int start_stmt(THD *thd [[maybe_unused]],
6020 thr_lock_type lock_type [[maybe_unused]]) {
6021 return 0;
6022 }
6023 virtual void get_auto_increment(ulonglong offset, ulonglong increment,
6024 ulonglong nb_desired_values,
6025 ulonglong *first_value,
6026 ulonglong *nb_reserved_values);
6028 DBUG_PRINT("info", ("auto_increment: next value %lu", (ulong)id));
6030 }
6032 /*
6033 Insertion of a row failed, re-use the lastly generated auto_increment
6034 id, for the next row. This is achieved by resetting next_insert_id to
6035 what it was before the failed insertion (that old value is provided by
6036 the caller). If that value was 0, it was the first row of the INSERT;
6037 then if insert_id_for_cur_row contains 0 it means no id was generated
6038 for this first row, so no id was generated since the INSERT started, so
6039 we should set next_insert_id to 0; if insert_id_for_cur_row is not 0, it
6040 is the generated id of the first and failed row, so we use it.
6041 */
6044 }
6045
6046 /**
6047 Update create info as part of ALTER TABLE.
6048
6049 Forward this handler call to the storage engine foreach
6050 partition handler. The data_file_name for each partition may
6051 need to be reset if the tablespace was moved. Use a dummy
6052 HA_CREATE_INFO structure and transfer necessary data.
6053
6054 @param create_info Create info from ALTER TABLE.
6055 */
6056
6057 virtual void update_create_info(HA_CREATE_INFO *create_info
6058 [[maybe_unused]]) {}
6061 }
6062 virtual int preload_keys(THD *, HA_CHECK_OPT *) {
6064 }
6065 /* end of the list of admin commands */
6066
6067 /**
6068 Check if indexes are disabled.
6069
6070 @retval 0 Indexes are enabled.
6071 @retval != 0 Indexes are disabled.
6072 */
6073
6074 virtual int indexes_are_disabled(void) { return 0; }
6075 virtual void append_create_info(String *packet [[maybe_unused]]) {}
6077 return;
6078 } /* prepare InnoDB for HANDLER */
6079 /** The following can be called without an open handler */
6080 virtual const char *table_type() const = 0;
6081
6082 virtual ulong index_flags(uint idx, uint part, bool all_parts) const = 0;
6083
6084 uint max_record_length() const {
6086 }
6087 uint max_keys() const {
6088 return std::min<uint>(MAX_KEY, max_supported_keys());
6089 }
6090 uint max_key_parts() const {
6091 return std::min(MAX_REF_PARTS, max_supported_key_parts());
6092 }
6093 uint max_key_length() const {
6094 return std::min(MAX_KEY_LENGTH, max_supported_key_length());
6095 }
6096 uint max_key_part_length(HA_CREATE_INFO *create_info) const {
6097 return std::min(MAX_KEY_LENGTH, max_supported_key_part_length(create_info));
6098 }
6099
6100 virtual uint max_supported_record_length() const { return HA_MAX_REC_LENGTH; }
6101 virtual uint max_supported_keys() const { return 0; }
6102 virtual uint max_supported_key_parts() const { return MAX_REF_PARTS; }
6103 virtual uint max_supported_key_length() const { return MAX_KEY_LENGTH; }
6105 [[maybe_unused]]) const {
6106 return 255;
6107 }
6108 virtual uint min_record_length(uint options [[maybe_unused]]) const {
6109 return 1;
6110 }
6111
6112 virtual bool low_byte_first() const { return true; }
6113 virtual ha_checksum checksum() const { return 0; }
6114
6115 /**
6116 Check if the table is crashed.
6117
6118 @retval true Crashed
6119 @retval false Not crashed
6120 */
6121
6122 virtual bool is_crashed() const { return false; }
6123
6124 /**
6125 Check if the table can be automatically repaired.
6126
6127 @retval true Can be auto repaired
6128 @retval false Cannot be auto repaired
6129 */
6130
6131 virtual bool auto_repair() const { return false; }
6132
6133 /**
6134 Get number of lock objects returned in store_lock.
6135
6136 Returns the number of store locks needed in call to store lock.
6137 We return number of partitions we will lock multiplied with number of
6138 locks needed by each partition. Assists the above functions in allocating
6139 sufficient space for lock structures.
6140
6141 @returns Number of locks returned in call to store_lock.
6142
6143 @note lock_count() can return > 1 if the table is MERGE or partitioned.
6144 */
6145
6146 virtual uint lock_count(void) const { return 1; }
6147
6148 /**
6149 Is not invoked for non-transactional temporary tables.
6150
6151 @note store_lock() can return more than one lock if the table is MERGE
6152 or partitioned.
6153
6154 @note that one can NOT rely on table->in_use in store_lock(). It may
6155 refer to a different thread if called from mysql_lock_abort_for_thread().
6156
6157 @note If the table is MERGE, store_lock() can return less locks
6158 than lock_count() claimed. This can happen when the MERGE children
6159 are not attached when this is called from another thread.
6160
6161 The idea with handler::store_lock() is the following:
6162
6163 The statement decided which locks we should need for the table
6164 for updates/deletes/inserts we get WRITE locks, for SELECT... we get
6165 read locks.
6166
6167 Before adding the lock into the table lock handler (see thr_lock.c)
6168 mysqld calls store lock with the requested locks. Store lock can now
6169 modify a write lock to a read lock (or some other lock), ignore the
6170 lock (if we don't want to use MySQL table locks at all) or add locks
6171 for many tables (like we do when we are using a MERGE handler).
6172
6173 In some exceptional cases MySQL may send a request for a TL_IGNORE;
6174 This means that we are requesting the same lock as last time and this
6175 should also be ignored.
6176
6177 Called from lock.cc by get_lock_data().
6178 */
6180 enum thr_lock_type lock_type) = 0;
6181
6182 /**
6183 Check if the primary key is clustered or not.
6184
6185 @retval true Primary key (if there is one) is a clustered
6186 key covering all fields
6187 @retval false otherwise
6188 */
6189
6190 virtual bool primary_key_is_clustered() const { return false; }
6191
6192 /**
6193 Compare two positions.
6194
6195 @param ref1 First position.
6196 @param ref2 Second position.
6197
6198 @retval <0 ref1 < ref2.
6199 @retval 0 Equal.
6200 @retval >0 ref1 > ref2.
6201 */
6202
6203 virtual int cmp_ref(const uchar *ref1, const uchar *ref2) const {
6204 return memcmp(ref1, ref2, ref_length);
6205 }
6206
6207 /*
6208 Condition pushdown to storage engines
6209 */
6210
6211 /**
6212 Push condition down to the table handler.
6213
6214 @param cond Condition to be pushed. The condition tree
6215 must not be modified by the caller.
6216
6217 @return
6218 The 'remainder' condition that caller must use to filter out records.
6219 NULL means the handler will not return rows that do not match the
6220 passed condition.
6221
6222 @note
6223 handler->ha_reset() call discard any pushed conditions.
6224 Calls to rnd_init/rnd_end, index_init/index_end etc do not affect the
6225 pushed conditions.
6226 */
6227 virtual const Item *cond_push(const Item *cond) {
6228 assert(pushed_cond == nullptr);
6229 return cond;
6230 }
6231
6232 /**
6233 Push down an index condition to the handler.
6234
6235 The server will use this method to push down a condition it wants
6236 the handler to evaluate when retrieving records using a specified
6237 index. The pushed index condition will only refer to fields from
6238 this handler that is contained in the index (but it may also refer
6239 to fields in other handlers). Before the handler evaluates the
6240 condition it must read the content of the index entry into the
6241 record buffer.
6242
6243 The handler is free to decide if and how much of the condition it
6244 will take responsibility for evaluating. Based on this evaluation
6245 it should return the part of the condition it will not evaluate.
6246 If it decides to evaluate the entire condition it should return
6247 NULL. If it decides not to evaluate any part of the condition it
6248 should return a pointer to the same condition as given as argument.
6249
6250 @param keyno the index number to evaluate the condition on
6251 @param idx_cond the condition to be evaluated by the handler
6252
6253 @return The part of the pushed condition that the handler decides
6254 not to evaluate
6255 */
6256
6257 virtual Item *idx_cond_push(uint keyno [[maybe_unused]], Item *idx_cond) {
6258 return idx_cond;
6259 }
6260
6261 /** Reset information about pushed index conditions */
6262 virtual void cancel_pushed_idx_cond() {
6263 pushed_idx_cond = nullptr;
6266 }
6267
6268 /**
6269 Reports number of tables included in pushed join which this
6270 handler instance is part of. ==0 -> Not pushed
6271 */
6272 virtual uint number_of_pushed_joins() const { return 0; }
6273
6274 /**
6275 If this handler instance is part of a pushed join sequence
6276 returned TABLE instance being root of the pushed query?
6277 */
6278 virtual const TABLE *member_of_pushed_join() const { return nullptr; }
6279
6280 /**
6281 If this handler instance is a child in a pushed join sequence
6282 returned TABLE instance being my parent?
6283 */
6284 virtual const TABLE *parent_of_pushed_join() const { return nullptr; }
6285
6286 /// @returns a map of the tables involved in this pushed join, or 0 if not
6287 /// part of a pushed join.
6288 virtual table_map tables_in_pushed_join() const { return 0; }
6289
6290 int ha_index_read_pushed(uchar *buf, const uchar *key,
6291 key_part_map keypart_map);
6292
6294
6295 protected:
6296 virtual int index_read_pushed(uchar *, const uchar *, key_part_map) {
6297 return HA_ERR_WRONG_COMMAND;
6298 }
6299
6301
6302 public:
6303 /**
6304 Part of old, deprecated in-place ALTER API.
6305 */
6307 [[maybe_unused]],
6308 uint table_changes [[maybe_unused]]) {
6309 return COMPATIBLE_DATA_NO;
6310 }
6311
6312 /* On-line/in-place/instant ALTER TABLE interface. */
6313
6314 /*
6315 Here is an outline of on-line/in-place ALTER TABLE execution through
6316 this interface.
6317
6318 Phase 1 : Initialization
6319 ========================
6320 During this phase we determine which algorithm should be used
6321 for execution of ALTER TABLE and what level concurrency it will
6322 require.
6323
6324 *) This phase starts by opening the table and preparing description
6325 of the new version of the table.
6326 *) Then we check if it is impossible even in theory to carry out
6327 this ALTER TABLE using the in-place/instant algorithm. For example,
6328 because we need to change storage engine or the user has explicitly
6329 requested usage of the "copy" algorithm.
6330 *) If in-place/instant ALTER TABLE is theoretically possible, we continue
6331 by compiling differences between old and new versions of the table
6332 in the form of HA_ALTER_FLAGS bitmap. We also build a few
6333 auxiliary structures describing requested changes and store
6334 all these data in the Alter_inplace_info object.
6335 *) Then the handler::check_if_supported_inplace_alter() method is called
6336 in order to find if the storage engine can carry out changes requested
6337 by this ALTER TABLE using the in-place or instant algorithm.
6338 To determine this, the engine can rely on data in HA_ALTER_FLAGS/
6339 Alter_inplace_info passed to it as well as on its own checks.
6340 If the in-place algorithm can be used for this ALTER TABLE, the level
6341 of required concurrency for its execution is also returned.
6342 If any errors occur during the handler call, ALTER TABLE is aborted
6343 and no further handler functions are called.
6344 Note that in cases when there is difference between in-place and
6345 instant algorithm and user explicitly asked for usage of in-place
6346 algorithm storage engine MUST return one of values corresponding
6347 to in-place algorithm and not HA_ALTER_INPLACE_INSTANT from this
6348 method.
6349 *) Locking requirements of the in-place algorithm are compared to any
6350 concurrency requirements specified by user. If there is a conflict
6351 between them, we either switch to the copy algorithm or emit an error.
6352
6353 Phase 2 : Execution
6354 ===================
6355
6356 In this phase the operations are executed.
6357
6358 *) As the first step, we acquire a lock corresponding to the concurrency
6359 level which was returned by handler::check_if_supported_inplace_alter()
6360 and requested by the user. This lock is held for most of the
6361 duration of in-place ALTER (if HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE
6362 or HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE were returned we acquire an
6363 exclusive lock for duration of the next step only).
6364 For HA_ALTER_INPLACE_INSTANT we keep shared upgradable metadata lock
6365 which was acquired at table open time.
6366 *) After that we call handler::ha_prepare_inplace_alter_table() to give the
6367 storage engine a chance to update its internal structures with a higher
6368 lock level than the one that will be used for the main step of algorithm.
6369 After that we downgrade the lock if it is necessary.
6370 This step should be no-op for instant algorithm.
6371 *) After that, the main step of this phase and algorithm is executed.
6372 We call the handler::ha_inplace_alter_table() method, which carries out
6373 the changes requested by ALTER TABLE but does not makes them visible to
6374 other connections yet.
6375 This step should be no-op for instant algorithm as well.
6376 *) We ensure that no other connection uses the table by upgrading our
6377 lock on it to exclusive.
6378 *) a) If the previous step succeeds,
6379 handler::ha_commit_inplace_alter_table() is called to allow the storage
6380 engine to do any final updates to its structures, to make all earlier
6381 changes durable and visible to other connections.
6382 For instant algorithm this is the step during which SE changes are done.
6383 Engines that support atomic DDL only prepare for the commit during this
6384 step but do not finalize it. Real commit happens later when the whole
6385 statement is committed. Also in some situations statement might be rolled
6386 back after call to commit_inplace_alter_table() for such storage engines.
6387 In the latter special case SE might require call to
6388 handlerton::dict_cache_reset() in order to invalidate its internal table
6389 definition cache after rollback.
6390 b) If we have failed to upgrade lock or any errors have occurred during
6391 the handler functions calls (including commit), we call
6392 handler::ha_commit_inplace_alter_table() to rollback all changes which
6393 were done during previous steps.
6394
6395 All the above calls to SE are provided with dd::Table objects describing old
6396 and new version of table being altered. Engines which support atomic DDL are
6397 allowed to adjust object corresponding to the new version. During phase 3
6398 these changes are saved to the data-dictionary.
6399
6400
6401 Phase 3 : Final
6402 ===============
6403
6404 In this phase we:
6405
6406 a) For engines which don't support atomic DDL:
6407
6408 *) Update the SQL-layer data-dictionary by replacing description of old
6409 version of the table with its new version. This change is immediately
6410 committed.
6411 *) Inform the storage engine about this change by calling the
6412 handler::ha_notify_table_changed() method.
6413 *) Process the RENAME clause by calling handler::ha_rename_table() and
6414 updating the data-dictionary accordingly. Again this change is
6415 immediately committed.
6416 *) Destroy the Alter_inplace_info and handler_ctx objects.
6417
6418 b) For engines which support atomic DDL:
6419
6420 *) Update the SQL-layer data-dictionary by replacing description of old
6421 version of the table with its new version.
6422 *) Process the RENAME clause by calling handler::ha_rename_table() and
6423 updating the data-dictionary accordingly.
6424 *) Commit the statement/transaction.
6425 *) Finalize atomic DDL operation by calling handlerton::post_ddl() hook
6426 for the storage engine.
6427 *) Additionally inform the storage engine about completion of ALTER TABLE
6428 for the table by calling the handler::ha_notify_table_changed()
6429 method.
6430 *) Destroy the Alter_inplace_info and handler_ctx objects.
6431 */
6432
6433 /**
6434 Check if a storage engine supports a particular alter table in-place
6435
6436 @param altered_table TABLE object for new version of table.
6437 @param ha_alter_info Structure describing changes to be done
6438 by ALTER TABLE and holding data used
6439 during in-place alter.
6440
6441 @retval HA_ALTER_ERROR Unexpected error.
6442 @retval HA_ALTER_INPLACE_NOT_SUPPORTED Not supported, must use copy.
6443 @retval HA_ALTER_INPLACE_EXCLUSIVE_LOCK Supported, but requires X lock.
6444 @retval HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE
6445 Supported, but requires SNW lock
6446 during main phase. Prepare phase
6447 requires X lock.
6448 @retval HA_ALTER_INPLACE_SHARED_LOCK Supported, but requires SNW lock.
6449 @retval HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE
6450 Supported, concurrent
6451 reads/writes allowed. However, prepare phase requires X lock.
6452 @retval HA_ALTER_INPLACE_NO_LOCK Supported, concurrent
6453 reads/writes allowed.
6454 @retval HA_ALTER_INPLACE_INSTANT Instant algorithm is supported.
6455 Prepare and main phases are
6456 no-op. Changes happen during
6457 commit phase and it should be
6458 "instant". We keep SU lock,
6459 allowing concurrent reads and
6460 writes during no-op phases and
6461 upgrade it to X lock before
6462 commit phase.
6463
6464 @note The default implementation uses the old in-place ALTER API
6465 to determine if the storage engine supports in-place ALTER or not.
6466
6467 @note In cases when there is difference between in-place and instant
6468 algorithm and explicit ALGORITHM=INPLACE clause was provided SE MUST
6469 return one of values corresponding to in-place algorithm and not
6470 HA_ALTER_INPLACE_INSTANT from this method.
6471
6472 @note Called without holding thr_lock.c lock.
6473 */
6475 TABLE *altered_table, Alter_inplace_info *ha_alter_info);
6476
6477 /**
6478 Public functions wrapping the actual handler call.
6479 @see prepare_inplace_alter_table()
6480 */
6481 bool ha_prepare_inplace_alter_table(TABLE *altered_table,
6482 Alter_inplace_info *ha_alter_info,
6483 const dd::Table *old_table_def,
6484 dd::Table *new_table_def);
6485
6486 /**
6487 Public function wrapping the actual handler call.
6488 @see inplace_alter_table()
6489 */
6490 bool ha_inplace_alter_table(TABLE *altered_table,
6491 Alter_inplace_info *ha_alter_info,
6492 const dd::Table *old_table_def,
6493 dd::Table *new_table_def) {
6494 return inplace_alter_table(altered_table, ha_alter_info, old_table_def,
6495 new_table_def);
6496 }
6497
6498 /**
6499 Public function wrapping the actual handler call.
6500 Allows us to enforce asserts regardless of handler implementation.
6501 @see commit_inplace_alter_table()
6502 */
6503 bool ha_commit_inplace_alter_table(TABLE *altered_table,
6504 Alter_inplace_info *ha_alter_info,
6505 bool commit,
6506 const dd::Table *old_table_def,
6507 dd::Table *new_table_def);
6508
6509 /**
6510 Public function wrapping the actual handler call.
6511
6512 @see notify_table_changed()
6513 */
6515 notify_table_changed(ha_alter_info);
6516 }
6517
6518 protected:
6519 /**
6520 Allows the storage engine to update internal structures with concurrent
6521 writes blocked. If check_if_supported_inplace_alter() returns
6522 HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE or
6523 HA_ALTER_INPLACE_SHARED_AFTER_PREPARE, this function is called with
6524 exclusive lock otherwise the same level of locking as for
6525 inplace_alter_table() will be used.
6526
6527 @note Should be no-op for instant algorithm.
6528
6529 @note Storage engines are responsible for reporting any errors by
6530 calling my_error()/print_error()
6531
6532 @note If this function reports error, commit_inplace_alter_table()
6533 will be called with commit= false.
6534
6535 @note For partitioning, failing to prepare one partition, means that
6536 commit_inplace_alter_table() will be called to roll back changes for
6537 all partitions. This means that commit_inplace_alter_table() might be
6538 called without prepare_inplace_alter_table() having been called first
6539 for a given partition.
6540
6541 @param altered_table TABLE object for new version of table.
6542 @param ha_alter_info Structure describing changes to be done
6543 by ALTER TABLE and holding data used
6544 during in-place alter.
6545 @param old_table_def dd::Table object describing old version of
6546 the table.
6547 @param new_table_def dd::Table object for the new version of the
6548 table. Can be adjusted by this call if SE
6549 supports atomic DDL. These changes to the
6550 table definition will be persisted in the
6551 data-dictionary at statement commit time.
6552
6553 @retval true Error
6554 @retval false Success
6555 */
6557 TABLE *altered_table [[maybe_unused]],
6558 Alter_inplace_info *ha_alter_info [[maybe_unused]],
6559 const dd::Table *old_table_def [[maybe_unused]],
6560 dd::Table *new_table_def [[maybe_unused]]) {
6561 return false;
6562 }
6563
6564 /**
6565 Alter the table structure in-place with operations specified using
6566 HA_ALTER_FLAGS and Alter_inplace_info. The level of concurrency allowed
6567 during this operation depends on the return value from
6568 check_if_supported_inplace_alter().
6569
6570 @note Should be no-op for instant algorithm.
6571
6572 @note Storage engines are responsible for reporting any errors by
6573 calling my_error()/print_error()
6574
6575 @note If this function reports error, commit_inplace_alter_table()
6576 will be called with commit= false.
6577
6578 @param altered_table TABLE object for new version of table.
6579 @param ha_alter_info Structure describing changes to be done
6580 by ALTER TABLE and holding data used
6581 during in-place alter.
6582 @param old_table_def dd::Table object describing old version of
6583 the table.
6584 @param new_table_def dd::Table object for the new version of the
6585 table. Can be adjusted by this call if SE
6586 supports atomic DDL. These changes to the
6587 table definition will be persisted in the
6588 data-dictionary at statement commit time.
6589
6590 @retval true Error
6591 @retval false Success
6592 */
6593 virtual bool inplace_alter_table(TABLE *altered_table [[maybe_unused]],
6594 Alter_inplace_info *ha_alter_info
6595 [[maybe_unused]],
6596 const dd::Table *old_table_def
6597 [[maybe_unused]],
6598 dd::Table *new_table_def [[maybe_unused]]) {
6599 return false;
6600 }
6601
6602 /**
6603 Commit or rollback the changes made during prepare_inplace_alter_table()
6604 and inplace_alter_table() inside the storage engine.
6605 Note that in case of rollback the allowed level of concurrency during
6606 this operation will be the same as for inplace_alter_table() and thus
6607 might be higher than during prepare_inplace_alter_table(). (For example,
6608 concurrent writes were blocked during prepare, but might not be during
6609 rollback).
6610
6611 @note This is the place where SE changes happen for instant algorithm.
6612
6613 @note For storage engines supporting atomic DDL this method should only
6614 prepare for the commit but do not finalize it. Real commit should happen
6615 later when the whole statement is committed. Also in some situations
6616 statement might be rolled back after call to commit_inplace_alter_table()
6617 for such storage engines. In the latter special case SE might require call
6618 to handlerton::dict_cache_reset() in order to invalidate its internal
6619 table definition cache after rollback.
6620
6621 @note Storage engines are responsible for reporting any errors by
6622 calling my_error()/print_error()
6623
6624 @note If this function with commit= true reports error, it will be called
6625 again with commit= false.
6626
6627 @note In case of partitioning, this function might be called for rollback
6628 without prepare_inplace_alter_table() having been called first.
6629 Also partitioned tables sets ha_alter_info->group_commit_ctx to a NULL
6630 terminated array of the partitions handlers and if all of them are
6631 committed as one, then group_commit_ctx should be set to NULL to indicate
6632 to the partitioning handler that all partitions handlers are committed.
6633 @see prepare_inplace_alter_table().
6634
6635 @param altered_table TABLE object for new version of table.
6636 @param ha_alter_info Structure describing changes to be done
6637 by ALTER TABLE and holding data used
6638 during in-place alter.
6639 @param commit True => Commit, False => Rollback.
6640 @param old_table_def dd::Table object describing old version of
6641 the table.
6642 @param new_table_def dd::Table object for the new version of the
6643 table. Can be adjusted by this call if SE
6644 supports atomic DDL. These changes to the
6645 table definition will be persisted in the
6646 data-dictionary at statement commit time.
6647
6648 @retval true Error
6649 @retval false Success
6650 */
6651 virtual bool commit_inplace_alter_table(TABLE *altered_table [[maybe_unused]],
6652 Alter_inplace_info *ha_alter_info
6653 [[maybe_unused]],
6654 bool commit [[maybe_unused]],
6655 const dd::Table *old_table_def
6656 [[maybe_unused]],
6657 dd::Table *new_table_def
6658 [[maybe_unused]]) {
6659 /* Nothing to commit/rollback, mark all handlers committed! */
6660 ha_alter_info->group_commit_ctx = nullptr;
6661 return false;
6662 }
6663
6664 /**
6665 Notify the storage engine that the table definition has been updated.
6666
6667 @param ha_alter_info Structure describing changes done by
6668 ALTER TABLE and holding data used
6669 during in-place alter.
6670
6671 @note No errors are allowed during notify_table_changed().
6672
6673 @note For storage engines supporting atomic DDL this method is invoked
6674 after the whole ALTER TABLE is completed and committed.
6675 Particularly this means that for ALTER TABLE statements with RENAME
6676 clause TABLE/handler object used for invoking this method will be
6677 associated with new table name. If storage engine needs to know
6678 the old schema and table name in this method for some reason it
6679 has to use ha_alter_info object to figure it out.
6680 */
6681 virtual void notify_table_changed(Alter_inplace_info *ha_alter_info
6682 [[maybe_unused]]) {}
6683
6684 public:
6685 /* End of On-line/in-place ALTER TABLE interface. */
6686
6687 /**
6688 use_hidden_primary_key() is called in case of an update/delete when
6689 (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
6690 but we don't have a primary key
6691 */
6692 virtual void use_hidden_primary_key();
6693
6694 protected:
6695 /* Service methods for use by storage engines. */
6697 THD *ha_thd() const;
6698
6699 /**
6700 Acquire the instrumented table information from a table share.
6701 @param share a table share
6702 @return an instrumented table share, or NULL.
6703 */
6705
6706 /**
6707 Default rename_table() and delete_table() rename/delete files with a
6708 given name and extensions from handlerton::file_extensions.
6709
6710 These methods can be overridden, but their default implementation
6711 provide useful functionality.
6712
6713 @param [in] from Path for the old table name.
6714 @param [in] to Path for the new table name.
6715 @param [in] from_table_def Old version of definition for table
6716 being renamed (i.e. prior to rename).
6717 @param [in,out] to_table_def New version of definition for table
6718 being renamed. Storage engines which
6719 support atomic DDL (i.e. having
6720 HTON_SUPPORTS_ATOMIC_DDL flag set)
6721 are allowed to adjust this object.
6722
6723 @retval >0 Error.
6724 @retval 0 Success.
6725 */
6726 virtual int rename_table(const char *from, const char *to,
6727 const dd::Table *from_table_def,
6728 dd::Table *to_table_def);
6729
6730 /**
6731 Delete a table.
6732
6733 Used to delete a table. By the time delete_table() has been called all
6734 opened references to this table will have been closed (and your globally
6735 shared references released. The variable name will just be the name of
6736 the table. You will need to remove any files you have created at this
6737 point. Called for base as well as temporary tables.
6738
6739 @param name Full path of table name.
6740 @param table_def dd::Table describing table being deleted
6741 (can be NULL for temporary tables created
6742 by optimizer).
6743
6744 @return Zero on success, nonzero otherwise.
6745 */
6746 virtual int delete_table(const char *name, const dd::Table *table_def);
6747
6748 private:
6749 /* Private helpers */
6750 void mark_trx_read_write();
6751 /*
6752 Low-level primitives for storage engines. These should be
6753 overridden by the storage engine class. To call these methods, use
6754 the corresponding 'ha_*' method above.
6755 */
6756
6757 virtual int open(const char *name, int mode, uint test_if_locked,
6758 const dd::Table *table_def) = 0;
6759 virtual int close(void) = 0;
6760 virtual int index_init(uint idx, bool sorted [[maybe_unused]]) {
6761 active_index = idx;
6762 return 0;
6763 }
6764 virtual int index_end() {
6766 return 0;
6767 }
6768 /**
6769 rnd_init() can be called two times without rnd_end() in between
6770 (it only makes sense if scan=1).
6771 then the second call should prepare for the new table scan (e.g
6772 if rnd_init allocates the cursor, second call should position it
6773 to the start of the table, no need to deallocate and allocate it again
6774 */
6775 virtual int rnd_init(bool scan) = 0;
6776 virtual int rnd_end() { return 0; }
6777 /**
6778 Write a row.
6779
6780 write_row() inserts a row. buf is a byte array of data, normally
6781 record[0].
6782
6783 You can use the field information to extract the data from the native byte
6784 array type.
6785
6786 Example of this would be:
6787 for (Field **field=table->field ; *field ; field++)
6788 {
6789 ...
6790 }
6791
6792 @param buf Buffer to write from.
6793
6794 @return Operation status.
6795 @retval 0 Success.
6796 @retval != 0 Error code.
6797 */
6798 virtual int write_row(uchar *buf [[maybe_unused]]) {
6799 return HA_ERR_WRONG_COMMAND;
6800 }
6801
6802 /**
6803 Update a single row.
6804
6805 Note: If HA_ERR_FOUND_DUPP_KEY is returned, the handler must read
6806 all columns of the row so MySQL can create an error message. If
6807 the columns required for the error message are not read, the error
6808 message will contain garbage.
6809 */
6810 virtual int update_row(const uchar *old_data [[maybe_unused]],
6811 uchar *new_data [[maybe_unused]]) {
6812 return HA_ERR_WRONG_COMMAND;
6813 }
6814
6815 virtual int delete_row(const uchar *buf [[maybe_unused]]) {
6816 return HA_ERR_WRONG_COMMAND;
6817 }
6818 /**
6819 Reset state of file to after 'open'.
6820 This function is called after every statement for all tables used
6821 by that statement.
6822 */
6823 virtual int reset() { return 0; }
6824 virtual Table_flags table_flags(void) const = 0;
6825 /**
6826 Is not invoked for non-transactional temporary tables.
6827
6828 Tells the storage engine that we intend to read or write data
6829 from the table. This call is prefixed with a call to handler::store_lock()
6830 and is invoked only for those handler instances that stored the lock.
6831
6832 Calls to @c rnd_init / @c index_init are prefixed with this call. When table
6833 IO is complete, we call @code external_lock(F_UNLCK) @endcode.
6834 A storage engine writer should expect that each call to
6835 @code ::external_lock(F_[RD|WR]LOCK @endcode is followed by a call to
6836 @code ::external_lock(F_UNLCK) @endcode. If it is not, it is a bug in MySQL.
6837
6838 The name and signature originate from the first implementation
6839 in MyISAM, which would call @c fcntl to set/clear an advisory
6840 lock on the data file in this method.
6841
6842 Originally this method was used to set locks on file level to enable
6843 several MySQL Servers to work on the same data. For transactional
6844 engines it has been "abused" to also mean start and end of statements
6845 to enable proper rollback of statements and transactions. When LOCK
6846 TABLES has been issued the start_stmt method takes over the role of
6847 indicating start of statement but in this case there is no end of
6848 statement indicator(?).
6849
6850 Called from lock.cc by lock_external() and unlock_external(). Also called
6851 from sql_table.cc by copy_data_between_tables().
6852
6853 @param thd the current thread
6854 @param lock_type F_RDLCK, F_WRLCK, F_UNLCK
6855
6856 @return non-0 in case of failure, 0 in case of success.
6857 When lock_type is F_UNLCK, the return value is ignored.
6858 */
6859 virtual int external_lock(THD *thd [[maybe_unused]],
6860 int lock_type [[maybe_unused]]) {
6861 return 0;
6862 }
6863 virtual void release_auto_increment() { return; }
6864 /** admin commands - called from mysql_admin_table */
6865 virtual int check_for_upgrade(HA_CHECK_OPT *) { return 0; }
6866 virtual int check(THD *, HA_CHECK_OPT *) { return HA_ADMIN_NOT_IMPLEMENTED; }
6867
6868 /**
6869 In this method check_opt can be modified
6870 to specify CHECK option to use to call check()
6871 upon the table.
6872 */
6873 virtual int repair(THD *, HA_CHECK_OPT *) {
6874 assert(!(ha_table_flags() & HA_CAN_REPAIR));
6876 }
6878 virtual int end_bulk_insert() { return 0; }
6879
6880 /**
6881 Does this handler want to get a Record_buffer for multi-row reads
6882 via the ha_set_record_buffer() function? And if so, what is the
6883 maximum number of records to allocate space for in the buffer?
6884
6885 Storage engines that support using a Record_buffer should override
6886 this function and return true for scans that could benefit from a
6887 buffer.
6888
6889 @param[out] max_rows gets set to the maximum number of records to
6890 allocate space for in the buffer if the function
6891 returns true
6892
6893 @retval true if the handler would like a Record_buffer
6894 @retval false if the handler does not want a Record_buffer
6895 */
6896 virtual bool is_record_buffer_wanted(ha_rows *const max_rows) const {
6897 *max_rows = 0;
6898 return false;
6899 }
6900
6901 // Set se_private_id and se_private_data during upgrade
6902 virtual bool upgrade_table(THD *thd [[maybe_unused]],
6903 const char *dbname [[maybe_unused]],
6904 const char *table_name [[maybe_unused]],
6905 dd::Table *dd_table [[maybe_unused]]) {
6906 return false;
6907 }
6908
6909 /** Initialize sampling.
6910 @param[out] scan_ctx A scan context created by this method that has to be
6911 used in sample_next
6912 @param[in] sampling_percentage percentage of records that need to be sampled
6913 @param[in] sampling_seed random seed
6914 @param[in] sampling_method sampling method to be used; currently only
6915 SYSTEM sampling is supported
6916 @param[in] tablesample true if the sampling is for tablesample
6917 @return 0 for success, else failure. */
6918 virtual int sample_init(void *&scan_ctx, double sampling_percentage,
6919 int sampling_seed,
6920 enum_sampling_method sampling_method,
6921 const bool tablesample);
6922
6923 /** Get the next record for sampling.
6924 @param[in] scan_ctx Scan context of the sampling
6925 @param[in] buf buffer to place the read record
6926 @return 0 for success, else failure. */
6927 virtual int sample_next(void *scan_ctx, uchar *buf);
6928
6929 /** End sampling.
6930 @param[in] scan_ctx Scan context of the sampling
6931 @return 0 for success, else failure. */
6932 virtual int sample_end(void *scan_ctx);
6933
6934 /**
6935 * Loads a table into its defined secondary storage engine.
6936 *
6937 * @param[in] table - Table opened in primary storage engine. Its read_set
6938 * tells which columns to load.
6939 * @param[out] skip_metadata_update - should the DD metadata be updated for
6940 * the load of this table
6941 *
6942 * @return 0 if success, error code otherwise.
6943 */
6944 virtual int load_table(const TABLE &table [[maybe_unused]],
6945 bool *skip_metadata_update [[maybe_unused]]) {
6946 /* purecov: begin inspected */
6947 assert(false);
6948 return HA_ERR_WRONG_COMMAND;
6949 /* purecov: end */
6950 }
6951
6952 /**
6953 * Unloads a table from its defined secondary storage engine.
6954 *
6955 * @param db_name Database name.
6956 * @param table_name Table name.
6957 * @param error_if_not_loaded If true, then errors will be reported by this
6958 * function. If false, no errors will be reported
6959 * (silently fail). This case of false is useful
6960 * during DROP TABLE where a failure to unload
6961 * should not prevent dropping the whole table.
6962 * @return 0 if success, error code otherwise.
6963 */
6964 virtual int unload_table(const char *db_name [[maybe_unused]],
6965 const char *table_name [[maybe_unused]],
6966 bool error_if_not_loaded [[maybe_unused]]) {
6967 /* purecov: begin inspected */
6968 assert(false);
6969 return HA_ERR_WRONG_COMMAND;
6970 /* purecov: end */
6971 }
6972
6973 protected:
6974 virtual int index_read(uchar *buf [[maybe_unused]],
6975 const uchar *key [[maybe_unused]],
6976 uint key_len [[maybe_unused]],
6977 enum ha_rkey_function find_flag [[maybe_unused]]) {
6978 return HA_ERR_WRONG_COMMAND;
6979 }
6980 virtual int index_read_last(uchar *buf [[maybe_unused]],
6981 const uchar *key [[maybe_unused]],
6982 uint key_len [[maybe_unused]]) {
6984 return HA_ERR_WRONG_COMMAND;
6985 }
6986
6987 public:
6988 /**
6989 This method is similar to update_row, however the handler doesn't need
6990 to execute the updates at this point in time. The handler can be certain
6991 that another call to bulk_update_row will occur OR a call to
6992 exec_bulk_update before the set of updates in this query is concluded.
6993
6994 Note: If HA_ERR_FOUND_DUPP_KEY is returned, the handler must read
6995 all columns of the row so MySQL can create an error message. If
6996 the columns required for the error message are not read, the error
6997 message will contain garbage.
6998
6999 @param old_data Old record
7000 @param new_data New record
7001 @param dup_key_found Number of duplicate keys found
7002
7003 */
7004 virtual int bulk_update_row(const uchar *old_data [[maybe_unused]],
7005 uchar *new_data [[maybe_unused]],
7006 uint *dup_key_found [[maybe_unused]]) {
7007 assert(false);
7008 return HA_ERR_WRONG_COMMAND;
7009 }
7010 /**
7011 Delete all rows in a table.
7012
7013 This is called both for cases of truncate and for cases where the
7014 optimizer realizes that all rows will be removed as a result of an
7015 SQL statement.
7016
7017 If the handler don't support this, then this function will
7018 return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
7019 by one.
7020 */
7021 virtual int delete_all_rows() {
7023 return HA_ERR_WRONG_COMMAND;
7024 }
7025 /**
7026 Quickly remove all rows from a table.
7027
7028 @param[in,out] table_def dd::Table object for table being truncated.
7029
7030 @remark This method is responsible for implementing MySQL's TRUNCATE
7031 TABLE statement, which is a DDL operation. As such, a engine
7032 can bypass certain integrity checks and in some cases avoid
7033 fine-grained locking (e.g. row locks) which would normally be
7034 required for a DELETE statement.
7035
7036 @remark Typically, truncate is not used if it can result in integrity
7037 violation. For example, truncate is not used when a foreign
7038 key references the table, but it might be used if foreign key
7039 checks are disabled.
7040
7041 @remark Engine is responsible for resetting the auto-increment counter.
7042
7043 @remark The table is locked in exclusive mode. All open TABLE/handler
7044 instances except the one which is used for truncate() call
7045 are closed.
7046
7047 @note It is assumed that transactional storage engines implementing
7048 this method can revert its effects if transaction is rolled
7049 back (e.g. because we failed to write statement to the binary
7050 log).
7051
7052 @note Changes to dd::Table object done by this method will be saved
7053 to data-dictionary only if storage engine supports atomic DDL
7054 (i.e. has HTON_SUPPORTS_ATOMIC_DDL flag set).
7055 */
7056 virtual int truncate(dd::Table *table_def [[maybe_unused]]) {
7057 return HA_ERR_WRONG_COMMAND;
7058 }
7059 virtual int optimize(THD *, HA_CHECK_OPT *) {
7061 }
7062 virtual int analyze(THD *, HA_CHECK_OPT *) {
7064 }
7065
7066 /**
7067 @brief Check and repair the table if necessary.
7068
7069 @param thd Thread object
7070
7071 @retval true Error/Not supported
7072 @retval false Success
7073
7074 @note Called if open_table_from_share fails and is_crashed().
7075 */
7076
7077 virtual bool check_and_repair(THD *thd [[maybe_unused]]) { return true; }
7078
7079 /**
7080 Disable indexes for a while.
7081
7082 @param mode Mode.
7083
7084 @retval 0 Success.
7085 @retval != 0 Error.
7086 */
7087
7088 virtual int disable_indexes(uint mode [[maybe_unused]]) {
7089 return HA_ERR_WRONG_COMMAND;
7090 }
7091
7092 /**
7093 Enable indexes again.
7094
7095 @param mode Mode.
7096
7097 @retval 0 Success.
7098 @retval != 0 Error.
7099 */
7100
7101 virtual int enable_indexes(uint mode [[maybe_unused]]) {
7102 return HA_ERR_WRONG_COMMAND;
7103 }
7104
7105 /**
7106 Discard or import tablespace.
7107
7108 @param [in] discard Indicates whether this is discard operation.
7109 @param [in,out] table_def dd::Table object describing the table
7110 in which tablespace needs to be discarded
7111 or imported. This object can be adjusted by
7112 storage engine if it supports atomic DDL
7113 (i.e. has HTON_SUPPORTS_ATOMIC_DDL flag set).
7114 These changes will be persisted in the
7115 data-dictionary.
7116 @retval 0 Success.
7117 @retval != 0 Error.
7118 */
7119
7120 virtual int discard_or_import_tablespace(bool discard [[maybe_unused]],
7122 [[maybe_unused]]) {
7124 return HA_ERR_WRONG_COMMAND;
7125 }
7126
7127 virtual void drop_table(const char *name);
7128
7129 /**
7130 Create table (implementation).
7131
7132 @param [in] name Table name.
7133 @param [in] form TABLE object describing the table to be
7134 created.
7135 @param [in] info HA_CREATE_INFO describing table.
7136 @param [in,out] table_def dd::Table object describing the table
7137 to be created. This object can be
7138 adjusted by storage engine if it
7139 supports atomic DDL (i.e. has
7140 HTON_SUPPORTS_ATOMIC_DDL flag set).
7141 These changes will be persisted in the
7142 data-dictionary. Can be NULL for
7143 temporary tables created by optimizer.
7144
7145 @retval 0 Success.
7146 @retval non-0 Error.
7147 */
7148 virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info,
7149 dd::Table *table_def) = 0;
7150
7151 virtual bool get_se_private_data(dd::Table *dd_table [[maybe_unused]],
7152 bool reset [[maybe_unused]]) {
7153 return false;
7154 }
7155
7156 /**
7157 Adjust definition of table to be created by adding implicit columns
7158 and indexes necessary for the storage engine.
7159
7160 @param [in] create_info HA_CREATE_INFO describing the table.
7161 @param [in] create_list List of columns in the table.
7162 @param [in] key_info Array of KEY objects describing table
7163 indexes.
7164 @param [in] key_count Number of indexes in the table.
7165 @param [in,out] table_obj dd::Table object describing the table
7166 to be created. Implicit columns and
7167 indexes are to be added to this object.
7168 Adjusted table description will be
7169 saved into the data-dictionary.
7170
7171 @retval 0 Success.
7172 @retval non-0 Error.
7173 */
7175 const HA_CREATE_INFO *create_info [[maybe_unused]],
7176 const List<Create_field> *create_list [[maybe_unused]],
7177 const KEY *key_info [[maybe_unused]], uint key_count [[maybe_unused]],
7178 dd::Table *table_obj [[maybe_unused]]) {
7179 return 0;
7180 }
7181
7182 virtual bool set_ha_share_ref(Handler_share **arg_ha_share) {
7183 ha_share = arg_ha_share;
7184 return false;
7185 }
7186
7187 void set_ha_table(TABLE *table_arg) { table = table_arg; }
7188
7189 int get_lock_type() const { return m_lock_type; }
7190
7191 /**
7192 Callback function that will be called by my_prepare_gcolumn_template
7193 once the table has been opened.
7194 */
7195 typedef void (*my_gcolumn_template_callback_t)(const TABLE *, void *);
7196 static bool my_prepare_gcolumn_template(THD *thd, const char *db_name,
7197 const char *table_name,
7199 void *ib_table);
7200 static bool my_eval_gcolumn_expr_with_open(THD *thd, const char *db_name,
7201 const char *table_name,
7202 const MY_BITMAP *const fields,
7203 uchar *record,
7204 const char **mv_data_ptr,
7205 ulong *mv_length);
7206
7207 /**
7208 Callback for computing generated column values.
7209
7210 Storage engines that need to have virtual column values for a row
7211 can use this function to get the values computed. The storage
7212 engine must have filled in the values for the base columns that
7213 the virtual columns depend on.
7214
7215 @param thd thread handle
7216 @param table table object
7217 @param fields bitmap of field index of evaluated generated
7218 column
7219 @param[in,out] record buff of base columns generated column depends.
7220 After calling this function, it will be
7221 used to return the value of the generated
7222 columns.
7223 @param[out] mv_data_ptr When given (not null) and the field
7224 needs to be calculated is a typed array field, it
7225 will contain pointer to field's calculated value.
7226 @param[out] mv_length Length of the data above
7227
7228 @retval true in case of error
7229 @retval false on success
7230 */
7231 static bool my_eval_gcolumn_expr(THD *thd, TABLE *table,
7232 const MY_BITMAP *const fields, uchar *record,
7233 const char **mv_data_ptr, ulong *mv_length);
7234
7235 /* This must be implemented if the handlerton's partition_flags() is set. */
7236 virtual Partition_handler *get_partition_handler() { return nullptr; }
7237
7238 /**
7239 Set se_private_id and se_private_data during upgrade
7240
7241 @param thd Pointer of THD
7242 @param dbname Database name
7243 @param table_name Table name
7244 @param dd_table dd::Table for the table
7245 @param table_arg TABLE object for the table.
7246
7247 @return Operation status
7248 @retval false Success
7249 @retval true Error
7250 */
7251
7252 bool ha_upgrade_table(THD *thd, const char *dbname, const char *table_name,
7253 dd::Table *dd_table, TABLE *table_arg);
7254
7255 /**
7256 Store a pointer to the handler of the primary table that
7257 corresponds to the secondary table in this handler.
7258 */
7259 void ha_set_primary_handler(handler *primary_handler);
7260
7261 /**
7262 Get a pointer to a handler for the table in the primary storage
7263 engine, if this handler is for a table in a secondary storage
7264 engine.
7265 */
7267
7268 /**
7269 Return max limits for a single set of multi-valued keys
7270
7271 @param[out] num_keys number of keys to store
7272 @param[out] keys_length total length of keys, bytes
7273 */
7274 void ha_mv_key_capacity(uint *num_keys, size_t *keys_length) const {
7275 return mv_key_capacity(num_keys, keys_length);
7276 }
7277
7278 /**
7279 Propagates the secondary storage engine offload failure reason for a query
7280 to the external engine when the offloaded query fails in the secondary
7281 storage engine.
7282 */
7283 virtual void set_external_table_offload_error(const char * /*reason*/) {}
7284
7285 /**
7286 Identifies and throws the propagated external engine query offload or exec
7287 failure reason given by the external engine handler.
7288 */
7289 virtual void external_table_offload_error() const {}
7290
7291 private:
7292 /**
7293 Engine-specific function for ha_can_store_mv_keys().
7294 Dummy function. SE's overloaded method is used instead.
7295 */
7296 /* purecov: begin inspected */
7297 virtual void mv_key_capacity(uint *num_keys, size_t *keys_length) const {
7298 *num_keys = 0;
7299 *keys_length = 0;
7300 }
7301 /* purecov: end */
7302
7303 /**
7304 Filter duplicate records when multi-valued index is used for retrieval
7305
7306 @returns
7307 true duplicate, such row id was already seen
7308 false row id is seen for the first time
7309 */
7310 bool filter_dup_records();
7311
7312 protected:
7314 void set_ha_share_ptr(Handler_share *arg_ha_share);
7315 void lock_shared_ha_data();
7316 void unlock_shared_ha_data();
7317
7318 friend class DsMrr_impl;
7319};
7320
7321/* Temporary Table handle for opening uncached table */
7323 public:
7325
7326 /** Open the table handler
7327 @param[in] thd Thread object
7328 @param[in] db_name Database name
7329 @param[in] table_name Table name
7330 @return table object or nullptr */
7331 TABLE *open(THD *thd, const char *db_name, const char *table_name);
7332
7334
7335 private:
7337};
7338
7339/**
7340 Function identifies any old data type present in table.
7341
7342 This function was handler::check_old_types().
7343 Function is not part of SE API. It is now converted to
7344 auxiliary standalone function.
7345
7346 @param[in] table TABLE object
7347
7348 @retval 0 ON SUCCESS
7349 @retval error code ON FAILURE
7350*/
7351
7353
7354/*
7355 A Disk-Sweep MRR interface implementation
7356
7357 This implementation makes range (and, in the future, 'ref') scans to read
7358 table rows in disk sweeps.
7359
7360 Currently it is used by MyISAM and InnoDB. Potentially it can be used with
7361 any table handler that has non-clustered indexes and on-disk rows.
7362*/
7363
7365 public:
7366 DsMrr_impl(handler *owner) : h(owner), table(nullptr), h2(nullptr) {}
7367
7369 /*
7370 If ha_reset() has not been called then the h2 dialog might still
7371 exist. This must be closed and deleted (this is the case for
7372 internally created temporary tables).
7373 */
7374 if (h2) reset();
7375 assert(h2 == nullptr);
7376 }
7377
7378 private:
7379 /*
7380 The "owner" handler object (the one that calls dsmrr_XXX functions.
7381 It is used to retrieve full table rows by calling rnd_pos().
7382 */
7383 handler *const h;
7384 TABLE *table; /* Always equal to h->table */
7385
7386 /* Secondary handler object. It is used for scanning the index */
7388
7389 /* Buffer to store rowids, or (rowid, range_id) pairs */
7391 uchar *rowids_buf_cur; /* Current position when reading/writing */
7392 uchar *rowids_buf_last; /* When reading: end of used buffer space */
7393 uchar *rowids_buf_end; /* End of the buffer */
7394
7395 bool dsmrr_eof; /* true <=> We have reached EOF when reading index tuples */
7396
7397 /* true <=> need range association, buffer holds {rowid, range_id} pairs */
7399
7400 bool use_default_impl; /* true <=> shortcut all calls to default MRR impl */
7401 public:
7402 /**
7403 Initialize the DsMrr_impl object.
7404
7405 This object is used for both doing default MRR scans and DS-MRR scans.
7406 This function just initializes the object. To do a DS-MRR scan,
7407 this must also be initialized by calling dsmrr_init().
7408
7409 @param table_arg pointer to the TABLE that owns the handler
7410 */
7411
7412 void init(TABLE *table_arg) {
7413 assert(table_arg != nullptr);
7414 table = table_arg;
7415 }
7416
7417 int dsmrr_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param, uint n_ranges,
7418 uint mode, HANDLER_BUFFER *buf);
7419 void dsmrr_close();
7420
7421 /**
7422 Resets the DS-MRR object to the state it had after being initialized.
7423
7424 If there is an open scan then it will be closed.
7425
7426 This function should be called by handler::ha_reset() which is called
7427 when a statement is completed in order to make the handler object ready
7428 for re-use by a different statement.
7429 */
7430
7431 void reset();
7432 int dsmrr_fill_buffer();
7433 int dsmrr_next(char **range_info);
7434
7435 ha_rows dsmrr_info(uint keyno, uint n_ranges, uint keys, uint *bufsz,
7436 uint *flags, Cost_estimate *cost);
7437
7438 ha_rows dsmrr_info_const(uint keyno, RANGE_SEQ_IF *seq, void *seq_init_param,
7439 uint n_ranges, uint *bufsz, uint *flags,
7440 Cost_estimate *cost);
7441
7442 private:
7443 bool choose_mrr_impl(uint keyno, ha_rows rows, uint *flags, uint *bufsz,
7444 Cost_estimate *cost);
7445 bool get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags,
7446 uint *buffer_size, Cost_estimate *cost);
7447};
7448
7449/* lookups */
7452/**
7453 Resolve handlerton plugin by name, without checking for "DEFAULT" or
7454 HTON_NOT_USER_SELECTABLE.
7455
7456 @param thd Thread context.
7457 @param name Plugin name.
7458
7459 @return plugin or NULL if not found.
7460*/
7463 bool is_temp_table);
7464plugin_ref ha_lock_engine(THD *thd, const handlerton *hton);
7466handler *get_new_handler(TABLE_SHARE *share, bool partitioned, MEM_ROOT *alloc,
7467 handlerton *db_type);
7468handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
7469 bool no_substitute, bool report_error);
7470
7472 THD *thd, const LEX_CSTRING &secondary_engine) noexcept;
7473
7474/**
7475 Get default handlerton, if handler supplied is null.
7476
7477 @param thd Thread context.
7478 @param hton The handlerton passed.
7479
7480 @returns pointer to handlerton.
7481*/
7483 if (!hton) {
7484 hton = ha_checktype(thd, DB_TYPE_UNKNOWN, false, false);
7485 assert(hton);
7486 }
7487 return hton;
7488}
7489
7490static inline enum legacy_db_type ha_legacy_type(const handlerton *db_type) {
7491 return (db_type == nullptr) ? DB_TYPE_UNKNOWN : db_type->db_type;
7492}
7493
7494const char *ha_resolve_storage_engine_name(const handlerton *db_type);
7495
7496static inline bool ha_check_storage_engine_flag(const handlerton *db_type,
7497 uint32 flag) {
7498 return db_type == nullptr ? false : (db_type->flags & flag);
7499}
7500
7501/**
7502 Predicate to determine if a storage engine, represented by a handlerton*, is
7503 enabled.
7504 @note "Enabled" in this context refers only the state of the handlerton
7505 object, and does not consider the disabled_storage_engines system variable.
7506 This leads to the very counter-intuitive and confusing situation that it is
7507 possible for a storage engine to be enabled, but at the same time also be
7508 disabled.
7509 */
7510inline bool ha_storage_engine_is_enabled(const handlerton *db_type) {
7511 return (db_type && db_type->create) ? (db_type->state == SHOW_OPTION_YES)
7512 : false;
7513}
7514
7515/* basic stuff */
7516int ha_init_errors(void);
7517int ha_init(void);
7518void ha_end();
7521
7524void ha_reset_plugin_vars(THD *thd);
7525void ha_close_connection(THD *thd);
7526void ha_kill_connection(THD *thd);
7527/** Invoke handlerton::pre_dd_shutdown() on every storage engine plugin. */
7528void ha_pre_dd_shutdown(void);
7529
7530/**
7531 Flush the log(s) of storage engine(s).
7532
7533 @param binlog_group_flush true if we got invoked by binlog group
7534 commit during flush stage, false in other cases.
7535 @retval false Succeed
7536 @retval true Error
7537*/
7538bool ha_flush_logs(bool binlog_group_flush = false);
7539
7540/**
7541 Call the "drop_database_t" handlerton API for storage engines that
7542 implemented it to drop the database.
7543
7544 @param schema_name name of the database to be dropped.
7545*/
7546void ha_drop_database(const char *schema_name);
7547
7548/**
7549 Call "log_ddl_drop_schema" handletron for
7550 storage engines who implement it.
7551
7552 @param schema_name name of the database to be dropped.
7553 @retval false Succeed
7554 @retval true Error
7555*/
7556bool ha_log_ddl_drop_schema(const char *schema_name);
7557
7558/**
7559 Call "log_ddl_create_schema" handletron for
7560 storage engines who implement it.
7561
7562 @param schema_name name of the database to be dropped.
7563 @retval false Succeed
7564 @retval true Error
7565*/
7566bool ha_log_ddl_create_schema(const char *schema_name);
7567
7568int ha_create_table(THD *thd, const char *path, const char *db,
7569 const char *table_name, HA_CREATE_INFO *create_info,
7570 bool update_create_info, bool is_temp_table,
7572
7573int ha_delete_table(THD *thd, handlerton *db_type, const char *path,
7574 const char *db, const char *alias,
7575 const dd::Table *table_def, bool generate_warning);
7576bool ha_check_reserved_db_name(const char *name);
7577
7578/* statistics and info */
7579bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat);
7580
7581typedef bool Log_func(THD *, TABLE *, bool, const uchar *, const uchar *);
7582
7583int binlog_log_row(TABLE *table, const uchar *before_record,
7584 const uchar *after_record, Log_func *log_func);
7585
7586/* discovery */
7587int ha_create_table_from_engine(THD *thd, const char *db, const char *name);
7588bool ha_check_if_table_exists(THD *thd, const char *db, const char *name,
7589 bool *exists);
7590int ha_find_files(THD *thd, const char *db, const char *path, const char *wild,
7591 bool dir, List<LEX_STRING> *files);
7592int ha_table_exists_in_engine(THD *thd, const char *db, const char *name);
7593bool ha_check_if_supported_system_table(handlerton *hton, const char *db,
7594 const char *table_name);
7595bool ha_rm_tmp_tables(THD *thd, List<LEX_STRING> *files);
7596bool default_rm_tmp_tables(handlerton *hton, THD *thd, List<LEX_STRING> *files);
7597
7598/* key cache */
7599int ha_init_key_cache(std::string_view name, KEY_CACHE *key_cache);
7600int ha_resize_key_cache(KEY_CACHE *key_cache);
7601int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
7602
7603/* transactions: interface to handlerton functions */
7605int ha_commit_trans(THD *thd, bool all, bool ignore_global_read_lock = false);
7606int ha_commit_attachable(THD *thd);
7607int ha_rollback_trans(THD *thd, bool all);
7608
7609/**
7610 Stage of the recovery process where information is collected from the
7611 storage engines (SE), merged with information from the transaction
7612 coordinator (TC) and transactions states are determined and enforced.
7613
7614 Implemented heuristics is as follows:
7615
7616 1. The `commit_list` parameter contains the set of internally coordinated
7617 transactions that the TC ensures were marked as committed.
7618
7619 2. The `xa_state_list` parameter contains the list of externally
7620 coordinated transactions and their states, as recorded by the TC.
7621
7622 3. For each SE:
7623 a. Collect list of transactions found in `PREPARED_IN_TC` state in the
7624 SE and merge it with the information collected from the TC, in
7625 `xa_state_list`.
7626 b. Retrieve the list of transactions found in prepared state in the
7627 SE.
7628
7629 c. For each internally coordinated transactions found in prepared
7630 state:
7631 1. If the transaction is found in `commit_list`, commit it.
7632 2. If the transaction is NOT found in `commit_list` but
7633 `tc_heuristic_recover = TC_HEURISTIC_RECOVER_COMMIT`, commit it.
7634 3. Otherwise, roll it back.
7635
7636 d. For each externally coordinated transactions found in prepared
7637 state:
7638 1. If the transaction isn't found in `xa_state_list`, roll it back.
7639 2. If the transaction is found in `xa_state_list` in `COMMITTED`
7640 state, commit it.
7641 3. If the transaction is found in `xa_state_list` in `ROLLEDBACK`
7642 state, roll it back.
7643 4. If the transaction is found in `xa_state_list` in `PREPARED`
7644 state, ensure that the transaction state in the SE is
7645 `PREPARED_IN_TC`.
7646
7647 @param commit_list Set of XIDs of internally coordinated transactions
7648 found as been committed in the transaction coordinator
7649 state.
7650 @param xa_state_list Map between XIDs and states of externally
7651 coordinated transactions as found in the internal
7652 transaction coordinator state.
7653
7654 @return 0 if recovery was successful, non-zero otherwise.
7655*/
7656int ha_recover(Xid_commit_list *commit_list = nullptr,
7657 Xa_state_list *xa_state_list = nullptr);
7658
7659/**
7660 Perform SE-specific cleanup after recovery of transactions.
7661
7662 @note SE supporting atomic DDL can use this method to perform
7663 post-DDL actions for DDL statements which were committed
7664 or rolled back during recovery stage.
7665*/
7666void ha_post_recover();
7667
7668/*
7669 transactions: interface to low-level handlerton functions. These are
7670 intended to be used by the transaction coordinators to
7671 commit/prepare/rollback transactions in the engines.
7672*/
7673int ha_commit_low(THD *thd, bool all, bool run_after_commit = true);
7674/**
7675 Prepares the underlying transaction of the THD session object parameter
7676 in the storage engines that participate in the transaction.
7677
7678 In case of failure, an error will be emitted by the function in the case
7679 of internally coordinated transactions. In the case of externally
7680 coordinated transactions (XA), the error treatment must follow the
7681 XA/Open specification and is handled by the `Sql_cmd_xa_prepare` class.
7682
7683 @param thd The THD session object holding the transaction to be prepared.
7684 @param all Whether or not the prepare regards a full transaction or the
7685 statement being executed..
7686
7687 @return 0 if the transaction was successfully prepared, non-zero
7688 otherwise.
7689 */
7690int ha_prepare_low(THD *thd, bool all);
7691int ha_rollback_low(THD *thd, bool all);
7692
7693/* transactions: these functions never call handlerton functions directly */
7694int ha_enable_transaction(THD *thd, bool on);
7695
7696/* savepoints */
7699int ha_savepoint(THD *thd, SAVEPOINT *sv);
7700int ha_release_savepoint(THD *thd, SAVEPOINT *sv);
7701
7702/* these are called by storage engines */
7703void trans_register_ha(THD *thd, bool all, handlerton *ht,
7704 const ulonglong *trxid);
7705
7706int ha_reset_logs(THD *thd);
7707
7708/**
7709 Inform storage engine(s) that a binary log file will be purged and any
7710 references to it should be removed.
7711
7712 The function is called for all purged files, regardless if it is an explicit
7713 PURGE BINARY LOGS statement, or an automatic purge performed by the server.
7714
7715 @note Since function is called with the LOCK_index mutex held the work
7716 performed in this callback should be kept at minimum. One way to defer work is
7717 to schedule work and use the `ha_binlog_index_purge_wait` callback to wait for
7718 completion.
7719
7720 @param thd Thread handle of session purging file. The nullptr value indicates
7721 that purge is done at server startup.
7722 @param file Name of file being purged.
7723 @return Always 0, return value are ignored by caller.
7724*/
7725int ha_binlog_index_purge_file(THD *thd, const char *file);
7726
7727/**
7728 Request the storage engine to complete any operations that were initiated
7729 by `ha_binlog_index_purge_file` and which need to complete
7730 before PURGE BINARY LOGS completes.
7731
7732 The function is called only from PURGE BINARY LOGS. Each PURGE BINARY LOGS
7733 statement will result in 0, 1 or more calls to `ha_binlog_index_purge_file`,
7734 followed by exactly 1 call to `ha_binlog_index_purge_wait`.
7735
7736 @note This function is called without LOCK_index mutex held and thus any
7737 waiting performed will only affect the current session.
7738
7739 @param thd Thread handle of session.
7740*/
7742
7743void ha_reset_slave(THD *thd);
7744void ha_binlog_log_query(THD *thd, handlerton *db_type,
7745 enum_binlog_command binlog_command, const char *query,
7746 size_t query_length, const char *db,
7747 const char *table_name);
7748void ha_acl_notify(THD *thd, class Acl_change_notification *);
7749void ha_binlog_wait(THD *thd);
7750
7751/* It is required by basic binlog features on both MySQL server and libmysqld */
7752int ha_binlog_end(THD *thd);
7753
7754const char *get_canonical_filename(handler *file, const char *path,
7755 char *tmp_path);
7756
7757const char *table_case_name(const HA_CREATE_INFO *info, const char *name);
7758
7759void print_keydup_error(TABLE *table, KEY *key, const char *msg, myf errflag,
7760 const char *org_table_name);
7761void print_keydup_error(TABLE *table, KEY *key, myf errflag,
7762 const char *org_table_name);
7763
7764inline void print_keydup_error(TABLE *table, KEY *key, const char *msg,
7765 myf errflag) {
7766 print_keydup_error(table, key, msg, errflag, nullptr);
7767}
7768inline void print_keydup_error(TABLE *table, KEY *key, myf errflag) {
7769 print_keydup_error(table, key, errflag, nullptr);
7770}
7771
7773
7774bool ha_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key,
7775 ha_notification_type notification_type,
7776 bool *victimized);
7777bool ha_notify_table_ddl(THD *thd, const MDL_key *mdl_key,
7778 ha_notification_type notification_type,
7779 ha_ddl_type ddl_type, const char *old_db_name,
7780 const char *old_table_name, const char *new_db_name,
7781 const char *new_table_name);
7782
7783std::pair<int, bool> commit_owned_gtids(THD *thd, bool all);
7784bool set_tx_isolation(THD *thd, enum_tx_isolation tx_isolation, bool one_shot);
7786
7787/*
7788 This class is used by INFORMATION_SCHEMA.FILES to read SE specific
7789 tablespace dynamic metadata. Some member like m_type and id, is not
7790 really dynamic, but as this information is not stored in data dictionary
7791 in a generic format and still is SE specific Some member like m_type and
7792 id, is not really dynamic, but as this information is not stored in data
7793 dictionary in a generic format and still needs SE specific decision, we
7794 are requesting the same from SE.
7795*/
7796
7798 public:
7800 : m_id(0),
7802 m_free_extents(0),
7803 m_total_extents(0),
7804 m_extent_size(0),
7805 m_initial_size(0),
7806 m_maximum_size(0),
7808 m_version(~0ULL),
7809 m_data_free(0) {}
7810
7826};
7827
7828#endif /* HANDLER_INCLUDED */
app_data_ptr new_data(u_int n, char *val, cons_type consensus)
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:247
Services for bulk data conversion and load to SE.
Definition: acl_change_notification.h:32
const std::string db
Definition: acl_change_notification.h:51
Data describing the table being created by CREATE TABLE or altered by ALTER TABLE.
Definition: sql_alter.h:205
Class describing changes to be done by ALTER TABLE.
Definition: handler.h:3393
static const HA_ALTER_FLAGS COALESCE_PARTITION
Definition: handler.h:3510
Alter_info * alter_info
Alter options, fields and keys for the new version of table.
Definition: handler.h:3610
static const HA_ALTER_FLAGS CHANGE_INDEX_OPTION
Change index option in a way which is likely not to require index recreation.
Definition: handler.h:3552
uint key_count
Size of key_info_buffer array.
Definition: handler.h:3646
static const HA_ALTER_FLAGS ALTER_VIRTUAL_COLUMN_TYPE
Definition: handler.h:3452
static const HA_ALTER_FLAGS DROP_PARTITION
Definition: handler.h:3504
static const HA_ALTER_FLAGS ADD_VIRTUAL_COLUMN
Definition: handler.h:3433
const char * unsupported_reason
Can be set by handler to describe why a given operation cannot be done in-place (HA_ALTER_INPLACE_NOT...
Definition: handler.h:3746
KEY * key_info_buffer
Array of KEYs for new version of table - including KEYs to be added.
Definition: handler.h:3643
static const HA_ALTER_FLAGS ADD_FOREIGN_KEY
Definition: handler.h:3483
static const HA_ALTER_FLAGS DROP_COLUMN
Definition: handler.h:3445
static const HA_ALTER_FLAGS ALTER_COLUMN_INDEX_LENGTH
Change in index length such that it does not require index rebuild.
Definition: handler.h:3562
static const HA_ALTER_FLAGS ADD_STORED_GENERATED_COLUMN
Definition: handler.h:3437
static const HA_ALTER_FLAGS ALTER_TABLE_REORG
Definition: handler.h:3516
static const HA_ALTER_FLAGS VALIDATE_VIRTUAL_COLUMN
Definition: handler.h:3545
static const HA_ALTER_FLAGS ADD_SPATIAL_INDEX
Definition: handler.h:3539
static const HA_ALTER_FLAGS DROP_CHECK_CONSTRAINT
Definition: handler.h:3580
static const HA_ALTER_FLAGS ALTER_STORED_GCOL_EXPR
Definition: handler.h:3480
uint virtual_column_add_count
Number of virtual columns to be added.
Definition: handler.h:3684
static const HA_ALTER_FLAGS RECREATE_TABLE
Recreate the table for ALTER TABLE FORCE, ALTER TABLE ENGINE and OPTIMIZE TABLE operations.
Definition: handler.h:3536
static const HA_ALTER_FLAGS STORED_GCOL_REEVAL
Change to one of columns on which stored generated column depends, so its values require re-evaluatio...
Definition: handler.h:3574
static const HA_ALTER_FLAGS ADD_PARTITION
Definition: handler.h:3501
static const HA_ALTER_FLAGS ADD_STORED_BASE_COLUMN
Definition: handler.h:3435
static const HA_ALTER_FLAGS ADD_PK_INDEX
Definition: handler.h:3425
uint index_drop_count
Size of index_drop_buffer array.
Definition: handler.h:3649
ulonglong HA_ALTER_FLAGS
Bits to show in detail what operations the storage engine is to execute.
Definition: handler.h:3410
static const HA_ALTER_FLAGS ALTER_COLUMN_STORAGE_TYPE
Definition: handler.h:3495
static const HA_ALTER_FLAGS ALTER_COLUMN_NAME
Definition: handler.h:3449
static const HA_ALTER_FLAGS ALTER_COLUMN_COLUMN_FORMAT
Definition: handler.h:3498
static const HA_ALTER_FLAGS ADD_COLUMN
Definition: handler.h:3439
static const HA_ALTER_FLAGS ALTER_REBUILD_PARTITION
Definition: handler.h:3555
static const HA_ALTER_FLAGS ALTER_INDEX_COMMENT
Definition: handler.h:3542
KEY_PAIR * index_rename_buffer
Array of KEY_PAIR objects describing indexes being renamed.
Definition: handler.h:3680
uint index_altered_visibility_count
Size of index_rename_buffer array.
Definition: handler.h:3670
void report_unsupported_error(const char *not_supported, const char *try_instead)
Used after check_if_supported_inplace_alter() to report error if the result does not match the LOCK/A...
Definition: handler.cc:5153
bool error_if_not_empty
Indicates whether operation should fail if table is non-empty.
Definition: handler.h:3626
static const HA_ALTER_FLAGS ADD_CHECK_CONSTRAINT
Definition: handler.h:3577
static const HA_ALTER_FLAGS ALTER_RENAME
Definition: handler.h:3492
void add_renamed_key(KEY *old_key, KEY *new_key)
Add old and new version of key to array of indexes to be renamed.
Definition: handler.h:3791
static const HA_ALTER_FLAGS SUSPEND_CHECK_CONSTRAINT
Definition: handler.h:3583
static const HA_ALTER_FLAGS ALTER_REMOVE_PARTITIONING
Definition: handler.h:3519
static const HA_ALTER_FLAGS ALTER_COLUMN_EQUAL_PACK_LENGTH
Change column datatype in such way that new type has compatible packed representation with old type,...
Definition: handler.h:3461
uint index_add_count
Size of index_add_buffer array.
Definition: handler.h:3658
static const HA_ALTER_FLAGS REORGANIZE_PARTITION
Definition: handler.h:3513
inplace_alter_handler_ctx * handler_ctx
Context information to allow handlers to keep context between in-place alter API calls.
Definition: handler.h:3695
static const HA_ALTER_FLAGS ALTER_VIRTUAL_GCOL_EXPR
Definition: handler.h:3479
static const HA_ALTER_FLAGS ADD_INDEX
Definition: handler.h:3413
static const HA_ALTER_FLAGS DROP_FOREIGN_KEY
Definition: handler.h:3486
uint index_rename_count
Size of index_rename_buffer array.
Definition: handler.h:3667
static const HA_ALTER_FLAGS ADD_UNIQUE_INDEX
Definition: handler.h:3419
HA_CREATE_INFO * create_info
Create options (like MAX_ROWS) for the new version of table.
Definition: handler.h:3597
uint handler_trivial_ctx
Can be set by handler along with handler_ctx.
Definition: handler.h:3732
KEY_PAIR * index_altered_visibility_buffer
Definition: handler.h:3681
static const HA_ALTER_FLAGS DROP_INDEX
Definition: handler.h:3416
static const HA_ALTER_FLAGS ALTER_COLUMN_NOT_NULLABLE
Definition: handler.h:3473
static const HA_ALTER_FLAGS DROP_UNIQUE_INDEX
Definition: handler.h:3422
static const HA_ALTER_FLAGS ALTER_PARTITION
Definition: handler.h:3507
static const HA_ALTER_FLAGS ALTER_COLUMN_NULLABLE
Definition: handler.h:3470
partition_info * modified_part_info
Partition_info taking into account the partition changes to be performed.
Definition: handler.h:3721
HA_ALTER_FLAGS handler_flags
Flags describing in detail which operations the storage engine is to execute.
Definition: handler.h:3713
Alter_inplace_info(HA_CREATE_INFO *create_info_arg, Alter_info *alter_info_arg, bool error_if_not_empty_arg, KEY *key_info_arg, uint key_count_arg, partition_info *modified_part_info_arg)
Definition: handler.h:3748
~Alter_inplace_info()
Definition: handler.h:3774
static const HA_ALTER_FLAGS VIRTUAL_GCOL_REEVAL
Change to one of columns on which virtual generated column depends, so its values require re-evaluati...
Definition: handler.h:3568
void add_added_key(KEY *new_key)
Add key to array of indexes to be added.
Definition: handler.h:3825
void add_altered_index_visibility(KEY *old_key, KEY *new_key)
Definition: handler.h:3799
static const HA_ALTER_FLAGS ALTER_VIRTUAL_COLUMN_ORDER
A virtual column has changed its position.
Definition: handler.h:3464
static const HA_ALTER_FLAGS RENAME_INDEX
Rename index.
Definition: handler.h:3530
uint virtual_column_drop_count
number of virtual columns to be dropped.
Definition: handler.h:3687
void add_modified_key(KEY *old_key, KEY *new_key)
Add old and new version of modified key to arrays of indexes to be dropped and added (correspondingly...
Definition: handler.h:3812
static const HA_ALTER_FLAGS DROP_PK_INDEX
Definition: handler.h:3428
static const HA_ALTER_FLAGS ALTER_STORED_COLUMN_ORDER
A stored column has changed its position (disregarding virtual columns)
Definition: handler.h:3467
bool online
true for online operation (LOCK=NONE)
Definition: handler.h:3724
KEY ** index_drop_buffer
Array of pointers to KEYs to be dropped belonging to the TABLE instance for the old version of the ta...
Definition: handler.h:3655
uint * index_add_buffer
Array of indexes into key_info_buffer for KEYs to be added, sorted in increasing order.
Definition: handler.h:3664
void add_dropped_key(KEY *old_key)
Drop key to array of indexes to be dropped.
Definition: handler.h:3819
static const HA_ALTER_FLAGS CHANGE_CREATE_OPTION
Definition: handler.h:3489
static const HA_ALTER_FLAGS DROP_VIRTUAL_COLUMN
Definition: handler.h:3443
static const HA_ALTER_FLAGS ALTER_COLUMN_VISIBILITY
Definition: handler.h:3586
static const HA_ALTER_FLAGS ALTER_STORED_COLUMN_TYPE
Definition: handler.h:3453
inplace_alter_handler_ctx ** group_commit_ctx
If the table uses several handlers, like ha_partition uses one handler per partition,...
Definition: handler.h:3707
static const HA_ALTER_FLAGS ALTER_COLUMN_DEFAULT
Definition: handler.h:3476
static const HA_ALTER_FLAGS DROP_STORED_COLUMN
Definition: handler.h:3444
static const HA_ALTER_FLAGS ALTER_ALL_PARTITION
Definition: handler.h:3522
Used to store optimizer cost estimates.
Definition: handler.h:3905
Cost_estimate & operator+=(const Cost_estimate &other)
Definition: handler.h:3954
Cost_estimate operator-(const Cost_estimate &other)
Definition: handler.h:3972
void add_import(double add_import_cost)
Add to import cost.
Definition: handler.h:4005
void reset()
Reset all costs to zero.
Definition: handler.h:3937
void set_max_cost()
Set current cost to the maximal double.
Definition: handler.h:3939
Cost_estimate()
Definition: handler.h:3913
void add_cpu(double add_cpu_cost)
Add to CPU cost.
Definition: handler.h:3999
double mem_cost
memory used (bytes)
Definition: handler.h:3910
double io_cost
cost of I/O operations
Definition: handler.h:3907
bool is_max_cost() const
Whether or not the total cost is the maximal double.
Definition: handler.h:3935
void add_mem(double add_mem_cost)
Add to memory cost.
Definition: handler.h:4011
bool operator<(const Cost_estimate &other) const
Definition: handler.h:3988
double get_cpu_cost() const
Definition: handler.h:3918
double get_mem_cost() const
Definition: handler.h:3920
double total_cost() const
Returns sum of time-consuming costs, i.e., not counting memory cost.
Definition: handler.h:3916
double get_io_cost() const
Definition: handler.h:3917
void add_io(double add_io_cost)
Add to IO cost.
Definition: handler.h:3993
double import_cost
cost of remote operations
Definition: handler.h:3909
double cpu_cost
cost of CPU operations
Definition: handler.h:3908
double get_import_cost() const
Definition: handler.h:3919
void multiply(double m)
Multiply io, cpu and import costs by parameter.
Definition: handler.h:3945
bool is_zero() const
Whether or not all costs in the object are zero.
Definition: handler.h:3927
bool operator>(const Cost_estimate &other) const
Definition: handler.h:3984
Cost_estimate operator+(const Cost_estimate &other)
Definition: handler.h:3965
Create_field is a description a field/column that may or may not exists in a table.
Definition: create_field.h:51
Definition: discrete_interval.h:41
Definition: handler.h:7364
DsMrr_impl(handler *owner)
Definition: handler.h:7366
bool get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags, uint *buffer_size, Cost_estimate *cost)
Get cost of DS-MRR scan.
Definition: handler.cc:7230
void reset()
Resets the DS-MRR object to the state it had after being initialized.
Definition: handler.cc:6900
ha_rows dsmrr_info(uint keyno, uint n_ranges, uint keys, uint *bufsz, uint *flags, Cost_estimate *cost)
Definition: handler.cc:7042
ha_rows dsmrr_info_const(uint keyno, RANGE_SEQ_IF *seq, void *seq_init_param, uint n_ranges, uint *bufsz, uint *flags, Cost_estimate *cost)
Definition: handler.cc:7071
void dsmrr_close()
Definition: handler.cc:6889
uchar * rowids_buf_end
Definition: handler.h:7393
uchar * rowids_buf_cur
Definition: handler.h:7391
int dsmrr_fill_buffer()
DS-MRR: Fill the buffer with rowids and sort it by rowid.
Definition: handler.cc:6929
uchar * rowids_buf
Definition: handler.h:7390
handler * h2
Definition: handler.h:7387
handler *const h
Definition: handler.h:7383
~DsMrr_impl()
Definition: handler.h:7368
bool use_default_impl
Definition: handler.h:7400
void init(TABLE *table_arg)
Initialize the DsMrr_impl object.
Definition: handler.h:7412
int dsmrr_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param, uint n_ranges, uint mode, HANDLER_BUFFER *buf)
DS-MRR: Initialize and start MRR scan.
Definition: handler.cc:6712
bool choose_mrr_impl(uint keyno, ha_rows rows, uint *flags, uint *bufsz, Cost_estimate *cost)
DS-MRR Internals: Choose between Default MRR implementation and DS-MRR.
Definition: handler.cc:7133
bool dsmrr_eof
Definition: handler.h:7395
bool is_mrr_assoc
Definition: handler.h:7398
uchar * rowids_buf_last
Definition: handler.h:7392
TABLE * table
Definition: handler.h:7384
int dsmrr_next(char **range_info)
Definition: handler.cc:6996
Definition: field.h:573
Wrapper for struct ft_hints.
Definition: handler.h:4172
uint get_flags() const
Get Ft_hints flags.
Definition: handler.h:4235
void set_hint_flag(uint ft_flag)
Set Ft_hints flag.
Definition: handler.h:4200
double get_op_value() const
Get Ft_hints operation value.
Definition: handler.h:4221
struct ft_hints * get_hints()
Get ft_hints struct.
Definition: handler.h:4242
Ft_hints(uint ft_flags)
Definition: handler.h:4177
ha_rows get_limit() const
Get Ft_hints limit.
Definition: handler.h:4214
enum ft_operation get_op_type() const
Get Ft_hints operation type.
Definition: handler.h:4228
void set_hint_limit(ha_rows ft_limit)
Set Ft_hints limit.
Definition: handler.h:4207
void set_hint_op(enum ft_operation type, double value)
Set comparison operation type and and value for master MATCH function.
Definition: handler.h:4190
struct ft_hints hints
Definition: handler.h:4174
Definition: handler.h:1021
const char * get_source_name()
Get SE source file name.
Definition: handler.h:1112
void set_dest_name(const char *name)
Set SE destination file name.
Definition: handler.h:1124
virtual int file_cbk(Ha_clone_file from_file, uint len)=0
Callback providing data from current position of a file descriptor of specific length.
uint m_desc_len
SE's Serialized descriptor length.
Definition: handler.h:1186
void set_hton(handlerton *hton)
Set current storage engine handlerton.
Definition: handler.h:1066
handlerton * get_hton()
Get current storage engine handlerton.
Definition: handler.h:1070
virtual int buffer_cbk(uchar *from_buffer, uint len)=0
Callback providing data in buffer of specific length.
Ha_clone_cbk()
Constructor to initialize members.
Definition: handler.h:1024
const int HA_CLONE_FILE_CACHE
Data file is opened for read/write with OS buffer cache.
Definition: handler.h:1204
void mark_state_change(uint64_t estimate)
Set state information and notify state change.
Definition: handler.h:1161
bool is_os_buffer_cache() const
Check if the file descriptor is opened for read/write with OS buffer cache.
Definition: handler.h:1145
void set_os_buffer_cache()
Mark that the file descriptor is opened for read/write with OS buffer cache.
Definition: handler.h:1139
const int HA_CLONE_STATE_CHANGE
State change notification by SE.
Definition: handler.h:1213
const char * m_dest_name
Current destination file name.
Definition: handler.h:1192
int m_flag
Flag storing data related options.
Definition: handler.h:1198
void set_source_name(const char *name)
Set SE source file name.
Definition: handler.h:1116
bool is_zero_copy() const
Check if zero copy optimization is suggested.
Definition: handler.h:1151
const char * m_src_name
Current source file name.
Definition: handler.h:1189
bool is_state_change(uint64_t &estimate)
Check if SE notified state change.
Definition: handler.h:1167
uint m_loc_idx
SE index in caller's locator array.
Definition: handler.h:1177
const uchar * get_data_desc(uint *lenp)
Get data descriptor.
Definition: handler.h:1102
uint64_t m_state_estimate
Estimated bytes to be transferred.
Definition: handler.h:1195
const uchar * m_data_desc
SE's Serialized data descriptor.
Definition: handler.h:1183
const char * get_dest_name()
Get SE destination file name.
Definition: handler.h:1120
bool is_secure() const
Check if data needs secure transfer.
Definition: handler.h:1157
void set_zero_copy()
Mark that the file can be transferred with zero copy.
Definition: handler.h:1148
virtual ~Ha_clone_cbk()=default
virtual destructor.
const int HA_CLONE_SECURE
Data needs to be transferred securely over SSL connection.
Definition: handler.h:1210
virtual int apply_buffer_cbk(uchar *&to_buffer, uint &len)=0
Callback to get data in buffer.
uint m_client_buff_size
Caller's transfer buffer size.
Definition: handler.h:1180
virtual int apply_file_cbk(Ha_clone_file to_file)=0
Callback providing a file descriptor to write data starting from current position.
void set_ack()
Mark that ACK is needed for the data transfer before returning from callback.
Definition: handler.h:1131
bool is_ack_needed() const
Check if ACK is needed for the data transfer.
Definition: handler.h:1135
void set_client_buffer_size(uint size)
Set caller's transfer buffer size.
Definition: handler.h:1075
void set_secure()
Mark that data needs secure transfer.
Definition: handler.h:1154
const int HA_CLONE_ACK
Acknowledgement is needed for the data transfer.
Definition: handler.h:1201
void set_loc_index(uint idx)
Set current SE index.
Definition: handler.h:1083
void clear_flags()
Clear all flags set by SE.
Definition: handler.h:1127
handlerton * m_hton
Handlerton for the SE.
Definition: handler.h:1174
uint get_client_buffer_size()
Get caller's transfer buffer size.
Definition: handler.h:1079
uint get_loc_index()
Get current SE index.
Definition: handler.h:1087
const int HA_CLONE_ZERO_COPY
Data file can be transferred with zero copy.
Definition: handler.h:1207
void set_data_desc(const uchar *desc, uint len)
Set data descriptor.
Definition: handler.h:1093
Base class to be used by handlers different shares.
Definition: handler.h:4162
Handler_share()=default
virtual ~Handler_share()=default
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:930
Definition: sql_optimizer.h:133
JSON DOM abstract base class.
Definition: json_dom.h:172
Definition: key.h:57
Definition: key.h:113
const char * name
Name of key.
Definition: key.h:153
bool is_visible
True if this index is visible to the query optimizer.
Definition: key.h:201
Definition: sql_list.h:494
Mem_root_allocator is a C++ STL memory allocator based on MEM_ROOT.
Definition: mem_root_allocator.h:68
Class for partitioning specific operations.
Definition: partition_handler.h:194
Class to hold information regarding a table to be created on behalf of a plugin.
Definition: plugin_table.h:40
Class to hold information regarding a predefined tablespace created by a storage engine.
Definition: plugin_table.h:129
This class represents a buffer that can be used for multi-row reads.
Definition: record_buffer.h:47
Implements the row and column memory management for parse and load operations.
Definition: bulk_data_service.h:292
Cost constants for a storage engine.
Definition: opt_costconstants.h:208
Simple intrusive linked list.
Definition: sql_list.h:48
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Definition: table.h:2904
Data structure that contains the information about shared tablespaces.
Definition: fsp0space.h:47
Definition: handler.h:7322
Temp_table_handle()
Definition: handler.h:7324
~Temp_table_handle()
Definition: handler.cc:8729
TABLE * open(THD *thd, const char *db_name, const char *table_name)
Open the table handler.
Definition: handler.cc:8699
TABLE * table
Definition: handler.h:7336
Unique_on_insert – similar to above, but rejects duplicates on insert, not just on read of the final ...
Definition: uniques.h:123
Class to maintain list of externally coordinated transactions and their current state at recovery.
Definition: handler.h:1261
enum_ha_recover_xa_state add(XID const &xid, enum_ha_recover_xa_state state)
Adds a transaction and state to the underlying map.
Definition: handler.cc:9104
std::map< XID, enum_ha_recover_xa_state, std::less< XID >, Xa_state_list::allocator >::iterator iterator
Definition: handler.h:1268
enum_ha_recover_xa_state find(XID const &to_find)
Searches the underlying map to find an key that corresponds to the parameter.
Definition: handler.cc:9098
static Xa_state_list::instantiation_tuple new_instance()
Factory like method to instantiate all the infra-structure needed to create an Xa_state_list.
Definition: handler.cc:9136
Xa_state_list(Xa_state_list::list &populated_by_tc)
Class constructor.
Definition: handler.cc:9095
std::pair< const XID, enum_ha_recover_xa_state > pair
Definition: handler.h:1263
Xa_state_list::list & m_underlying
The underlying map holding the trx and states.
Definition: handler.h:1340
std::map< XID, enum_ha_recover_xa_state, std::less< XID >, Xa_state_list::allocator > list
Definition: handler.h:1266
std::tuple< std::unique_ptr< MEM_ROOT >, std::unique_ptr< Xa_state_list::allocator >, std::unique_ptr< Xa_state_list::list >, std::unique_ptr< Xa_state_list > > instantiation_tuple
Definition: handler.h:1271
virtual ~Xa_state_list()=default
The Properties class defines an interface for storing key=value pairs, where both key and value may b...
Definition: properties.h:74
Definition: table.h:47
Definition: tablespace.h:56
Definition: handler.h:4130
ha_rows num_distinct_values
Definition: handler.h:4132
ha_column_statistics()
Definition: handler.h:4134
Definition: handler.h:4076
ulonglong index_file_length
Definition: handler.h:4080
uint block_size
Definition: handler.h:4099
ulonglong data_file_length
Definition: handler.h:4078
ulong update_time
Definition: handler.h:4098
ha_rows records
Definition: handler.h:4092
ulonglong max_data_file_length
Definition: handler.h:4079
ulong check_time
Definition: handler.h:4097
time_t create_time
Definition: handler.h:4096
ulonglong max_index_file_length
Definition: handler.h:4081
ulong mean_rec_length
Definition: handler.h:4094
ulonglong auto_increment_value
Definition: handler.h:4083
ha_statistics()
Definition: handler.h:4114
double table_in_mem_estimate
Estimate for how much of the table that is available in a memory buffer.
Definition: handler.h:4112
ulonglong delete_length
Definition: handler.h:4082
uint mrr_length_per_rec
Definition: handler.h:4104
ha_rows deleted
Definition: handler.h:4093
Definition: handler.h:7797
ulonglong m_id
Definition: handler.h:7811
ulonglong m_initial_size
Definition: handler.h:7818
dd::String_type m_row_format
Definition: handler.h:7822
ulonglong m_data_free
Definition: handler.h:7823
ulonglong m_version
Definition: handler.h:7821
dd::String_type m_status
Definition: handler.h:7824
ulonglong m_maximum_size
Definition: handler.h:7819
ulonglong m_logfile_group_number
Definition: handler.h:7814
ulonglong m_free_extents
Definition: handler.h:7815
ha_tablespace_statistics()
Definition: handler.h:7799
ulonglong m_autoextend_size
Definition: handler.h:7820
ulonglong m_total_extents
Definition: handler.h:7816
ulonglong m_extent_size
Definition: handler.h:7817
dd::String_type m_logfile_group_name
Definition: handler.h:7813
dd::String_type m_type
Definition: handler.h:7812
dd::String_type m_extra
Definition: handler.h:7825
The handler class is the interface for dynamically loadable storage engines.
Definition: handler.h:4618
virtual int sample_end(void *scan_ctx)
End sampling.
Definition: handler.cc:3227
KEY_PART_INFO * range_key_part
Definition: handler.h:4678
virtual int ft_read(uchar *)
Definition: handler.h:5793
virtual bool get_foreign_dup_key(char *child_table_name, uint child_table_name_len, char *child_key_name, uint child_key_name_len)
Retrieves the names of the table and the key for which there was a duplicate entry in the case of HA_...
Definition: handler.cc:4750
virtual int repair(THD *, HA_CHECK_OPT *)
In this method check_opt can be modified to specify CHECK option to use to call check() upon the tabl...
Definition: handler.h:6873
ulonglong insert_id_for_cur_row
insert id for the current row (autogenerated; if not autogenerated, it's 0).
Definition: handler.h:4728
virtual bool is_index_algorithm_supported(enum ha_key_alg key_alg) const
Check if SE supports specific key algorithm.
Definition: handler.h:5650
virtual void set_external_table_offload_error(const char *)
Propagates the secondary storage engine offload failure reason for a query to the external engine whe...
Definition: handler.h:7283
virtual double read_time(uint index, uint ranges, ha_rows rows)
The cost of reading a set of ranges from the table using an index to access it.
Definition: handler.h:5298
handler * m_primary_handler
Pointer to the handler of the table in the primary storage engine, if this handler represents a table...
Definition: handler.h:4675
void * Blob_context
Definition: handler.h:4623
virtual ~handler(void)
Definition: handler.h:4879
virtual int open_blob(THD *thd, void *load_ctx, size_t thread_idx, Blob_context &blob_ctx, unsigned char *blobref)
Open a blob for write operation.
Definition: handler.h:5159
int ha_index_init(uint idx, bool sorted)
Initialize use of index.
Definition: handler.cc:3004
virtual int index_prev(uchar *)
Definition: handler.h:5737
virtual FT_INFO * ft_init_ext(uint flags, uint inx, String *key)
Definition: handler.cc:3140
virtual void external_table_offload_error() const
Identifies and throws the propagated external engine query offload or exec failure reason given by th...
Definition: handler.h:7289
virtual uint max_supported_key_length() const
Definition: handler.h:6103
const Item * pushed_cond
Definition: handler.h:4707
void set_ha_table(TABLE *table_arg)
Definition: handler.h:7187
Unique_on_insert * m_unique
Definition: handler.h:4843
virtual int reset()
Reset state of file to after 'open'.
Definition: handler.h:6823
virtual int records_from_index(ha_rows *num_rows, uint index)
Number of rows in table counted using the secondary index chosen by optimizer.
Definition: handler.cc:3274
virtual int open(const char *name, int mode, uint test_if_locked, const dd::Table *table_def)=0
virtual int index_first(uchar *)
Definition: handler.h:5740
Handler_share * get_ha_share_ptr()
Get an initialized ha_share.
Definition: handler.cc:8293
bool m_update_generated_read_fields
Some non-virtual ha_* functions, responsible for reading rows, like ha_rnd_pos(), must ensure that vi...
Definition: handler.h:4840
batch_mode_t
Internal state of the batch instrumentation.
Definition: handler.h:4752
@ PSI_BATCH_MODE_STARTING
Batch mode used, before first table io.
Definition: handler.h:4756
@ PSI_BATCH_MODE_STARTED
Batch mode used, after first table io.
Definition: handler.h:4758
@ PSI_BATCH_MODE_NONE
Batch mode not used.
Definition: handler.h:4754
Discrete_interval auto_inc_interval_for_cur_row
Interval returned by get_auto_increment() and being consumed by the inserter.
Definition: handler.h:4733
void restore_auto_increment(ulonglong prev_insert_id)
Definition: handler.h:6031
bool ha_check_and_repair(THD *thd)
Check and repair table: public interface.
Definition: handler.cc:5017
virtual enum ha_key_alg get_default_index_algorithm() const
Get default key algorithm for SE.
Definition: handler.h:5639
double table_in_memory_estimate() const
Return an estimate of how much of the table that is currently stored in main memory.
Definition: handler.cc:6095
virtual const char * table_type() const =0
The following can be called without an open handler.
virtual Cost_estimate read_cost(uint index, double ranges, double rows)
Cost estimate for reading a set of ranges from the table using an index to access it.
Definition: handler.cc:6233
bool in_range_check_pushed_down
Definition: handler.h:4684
uint ranges_in_seq
Definition: handler.h:4645
uint max_key_parts() const
Definition: handler.h:6090
virtual bool primary_key_is_clustered() const
Check if the primary key is clustered or not.
Definition: handler.h:6190
bool m_virt_gcol_in_end_range
Flag which tells if end_range contains a virtual generated column.
Definition: handler.h:4698
int ha_index_next_pushed(uchar *buf)
Definition: handler.cc:3710
ha_statistics stats
Definition: handler.h:4639
void rebind_psi()
Definition: handler.cc:2839
int ha_update_row(const uchar *old_data, uchar *new_data)
Update the current row.
Definition: handler.cc:8214
int ha_delete_all_rows()
Delete all rows: public interface.
Definition: handler.cc:4965
virtual int index_init(uint idx, bool sorted)
Definition: handler.h:6760
virtual int enable_indexes(uint mode)
Enable indexes again.
Definition: handler.h:7101
int check_collation_compatibility()
Check for incompatible collation changes.
Definition: handler.cc:4637
virtual uint lock_count(void) const
Get number of lock objects returned in store_lock.
Definition: handler.h:6146
std::function< void(void *cookie)> Load_end_cbk
This callback is called by each parallel load thread when processing of rows has ended for the adapte...
Definition: handler.h:5079
virtual int bulk_load_end(THD *thd, void *load_ctx, bool is_error)
End bulk load operation.
Definition: handler.h:5205
virtual const TABLE * parent_of_pushed_join() const
If this handler instance is a child in a pushed join sequence returned TABLE instance being my parent...
Definition: handler.h:6284
virtual uint max_supported_key_parts() const
Definition: handler.h:6102
enum_range_scan_direction range_scan_direction
Definition: handler.h:4668
bool eq_range
Definition: handler.h:4679
virtual int disable_indexes(uint mode)
Disable indexes for a while.
Definition: handler.h:7088
virtual uint extra_rec_buf_length() const
Definition: handler.h:5512
key_range * end_range
End value for a range scan.
Definition: handler.h:4693
virtual void init_table_handle_for_HANDLER()
Definition: handler.h:6076
uint active_index
Definition: handler.h:4701
RANGE_SEQ_IF mrr_funcs
Definition: handler.h:4643
int ha_index_last(uchar *buf)
Reads the last row via index.
Definition: handler.cc:3586
virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share)
Change the internal TABLE_SHARE pointer.
Definition: handler.h:5265
virtual int extra(enum ha_extra_function operation)
Storage engine specific implementation of ha_extra()
Definition: handler.h:5898
virtual void end_bulk_update()
Perform any needed clean-up, no outstanding updates are there at the moment.
Definition: handler.h:5693
int ha_multi_range_read_next(char **range_info)
Definition: handler.cc:6581
int ha_end_bulk_insert()
End bulk insert.
Definition: handler.cc:4938
uint errkey
Definition: handler.h:4699
virtual ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key)
Find number of records in a range.
Definition: handler.h:5830
virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, uint n_ranges, uint mode, HANDLER_BUFFER *buf)
Initialize the MRR scan.
Definition: handler.cc:6569
virtual int multi_range_read_next(char **range_info)
Get next record in MRR scan.
Definition: handler.cc:6611
virtual int update_row(const uchar *old_data, uchar *new_data)
Update a single row.
Definition: handler.h:6810
virtual int index_read_pushed(uchar *, const uchar *, key_part_map)
Definition: handler.h:6296
virtual bool check_if_incompatible_data(HA_CREATE_INFO *create_info, uint table_changes)
Part of old, deprecated in-place ALTER API.
Definition: handler.h:6306
int ha_enable_indexes(uint mode)
Enable indexes: public interface.
Definition: handler.cc:5043
virtual bool is_fatal_error(int error)
Determine whether an error is fatal or not.
Definition: handler.cc:4282
virtual int sample_next(void *scan_ctx, uchar *buf)
Get the next record for sampling.
Definition: handler.cc:3229
double index_in_memory_estimate(uint keyno) const
Return an estimate of how much of the index that is currently stored in main memory.
Definition: handler.cc:6114
bool filter_dup_records()
Filter duplicate records when multi-valued index is used for retrieval.
Definition: handler.cc:8666
int m_lock_type
The lock type set by when calling::ha_external_lock().
Definition: handler.h:4819
handlerton * ht
Definition: handler.h:4633
virtual bool is_ignorable_error(int error)
Determine whether an error can be ignored or not.
Definition: handler.cc:4257
TABLE_SHARE * table_share
Definition: handler.h:4626
int ha_read_range_next()
Definition: handler.cc:7545
int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info, dd::Table *table_def)
Create a table in the engine: public interface.
Definition: handler.cc:5210
virtual int info(uint flag)=0
General method to gather info from handler.
virtual bool start_read_removal(void)
Start read (before write) removal on the current table.
Definition: handler.h:5930
int ha_sample_end(void *scan_ctx)
End sampling.
Definition: handler.cc:3190
void ha_start_bulk_insert(ha_rows rows)
Start bulk insert.
Definition: handler.cc:4923
int ha_delete_row(const uchar *buf)
Definition: handler.cc:8242
int ha_index_next_same(uchar *buf, const uchar *key, uint keylen)
Reads the next same row via index.
Definition: handler.cc:3622
int ha_index_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map)
Definition: handler.cc:3398
virtual void cancel_pushed_idx_cond()
Reset information about pushed index conditions.
Definition: handler.h:6262
int ha_sample_init(void *&scan_ctx, double sampling_percentage, int sampling_seed, enum_sampling_method sampling_method, const bool tablesample)
Initialize sampling.
Definition: handler.cc:3163
virtual size_t bulk_load_available_memory(THD *thd) const
Get the total memory available for bulk load in SE.
Definition: handler.h:5118
virtual void append_create_info(String *packet)
Definition: handler.h:6075
virtual uint max_supported_key_part_length(HA_CREATE_INFO *create_info) const
Definition: handler.h:6104
bool ha_upgrade_table(THD *thd, const char *dbname, const char *table_name, dd::Table *dd_table, TABLE *table_arg)
Set se_private_id and se_private_data during upgrade.
Definition: handler.cc:8578
virtual int check(THD *, HA_CHECK_OPT *)
Definition: handler.h:6866
virtual const Item * cond_push(const Item *cond)
Push condition down to the table handler.
Definition: handler.h:6227
virtual longlong get_memory_buffer_size() const
Return an estimate on the amount of memory the storage engine will use for caching data in memory.
Definition: handler.h:5409
virtual int rnd_next(uchar *buf)=0
virtual void unlock_row()
Unlock last accessed row.
Definition: handler.h:6004
virtual int preload_keys(THD *, HA_CHECK_OPT *)
Definition: handler.h:6062
uint max_keys() const
Definition: handler.h:6087
void ha_statistic_increment(ulonglong System_status_var::*offset) const
Definition: handler.cc:2815
int ha_bulk_update_row(const uchar *old_data, uchar *new_data, uint *dup_key_found)
Bulk update row: public interface.
Definition: handler.cc:4951
virtual double index_only_read_time(uint keynr, double records)
Calculate cost of 'index only' scan for given index and number of records.
Definition: handler.cc:6084
double m_sampling_percentage
Definition: handler.h:4748
virtual FT_INFO * ft_init_ext_with_hints(uint inx, String *key, Ft_hints *hints)
Definition: handler.h:5780
void set_end_range(const key_range *range, enum_range_scan_direction direction)
Set the end position for a range scan.
Definition: handler.cc:7611
int ha_index_next(uchar *buf)
Reads the next row via index.
Definition: handler.cc:3467
virtual int index_read(uchar *buf, const uchar *key, uint key_len, enum ha_rkey_function find_flag)
Definition: handler.h:6974
int ha_discard_or_import_tablespace(bool discard, dd::Table *table_def)
Discard or import tablespace: public interface.
Definition: handler.cc:5056
uint pushed_idx_cond_keyno
Definition: handler.h:4710
virtual void column_bitmaps_signal()
Signal that the table->read_set and table->write_set table maps changed The handler is allowed to set...
Definition: handler.cc:4084
virtual int close_blob(THD *thd, void *load_ctx, size_t thread_idx, Blob_context blob_ctx, unsigned char *blobref)
Close the blob.
Definition: handler.h:5191
virtual Partition_handler * get_partition_handler()
Definition: handler.h:7236
virtual ha_rows end_read_removal(void)
End read (before write) removal and return the number of rows really written.
Definition: handler.h:5940
HANDLER_BUFFER * multi_range_buffer
Definition: handler.h:4644
const TABLE * get_table() const
Definition: handler.h:5270
uchar * ref
Pointer to current row.
Definition: handler.h:4635
int ha_reset()
Check handler usage and reset state of file to after 'open'.
Definition: handler.cc:8158
virtual int index_next_same(uchar *buf, const uchar *key, uint keylen)
Definition: handler.cc:5277
virtual bool was_semi_consistent_read()
Definition: handler.h:5988
int ha_records(ha_rows *num_rows, uint index)
Wrapper function to call records_from_index() in storage engine.
Definition: handler.h:5608
virtual Cost_estimate index_scan_cost(uint index, double ranges, double rows)
Cost estimate for reading a number of ranges from an index.
Definition: handler.cc:6213
int ha_check(THD *thd, HA_CHECK_OPT *check_opt)
to be actually called to get 'check()' functionality
Definition: handler.cc:4824
virtual int load_table(const TABLE &table, bool *skip_metadata_update)
Loads a table into its defined secondary storage engine.
Definition: handler.h:6944
virtual int index_next(uchar *)
Definition: handler.h:5734
int ha_read_range_first(const key_range *start_key, const key_range *end_key, bool eq_range, bool sorted)
Definition: handler.cc:7526
virtual void update_create_info(HA_CREATE_INFO *create_info)
Update create info as part of ALTER TABLE.
Definition: handler.h:6057
virtual int rnd_end()
Definition: handler.h:6776
uint key_used_on_scan
Definition: handler.h:4700
virtual ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys, uint *bufsz, uint *flags, Cost_estimate *cost)
Get cost and other information about MRR scan over some sequence of ranges.
Definition: handler.cc:6510
virtual Cost_estimate table_scan_cost()
Cost estimate for doing a complete table scan.
Definition: handler.cc:6199
virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0
virtual int external_lock(THD *thd, int lock_type)
Is not invoked for non-transactional temporary tables.
Definition: handler.h:6859
virtual int parallel_scan_init(void *&scan_ctx, size_t *num_threads, bool use_reserved_threads, size_t max_desired_threads)
Initializes a parallel scan.
Definition: handler.h:5029
int ha_extra(enum ha_extra_function operation)
Request storage engine to do an extra operation: enable,disable or run some functionality.
Definition: handler.cc:8672
ulonglong next_insert_id
next_insert_id is the next value which should be inserted into the auto_increment column: in a insert...
Definition: handler.h:4721
virtual bool low_byte_first() const
Definition: handler.h:6112
void ha_set_primary_handler(handler *primary_handler)
Store a pointer to the handler of the primary table that corresponds to the secondary table in this h...
Definition: handler.cc:8985
uint ref_length
Length of ref (1-8 or the clustered key length)
Definition: handler.h:4703
virtual double scan_time()
Definition: handler.h:5279
int ha_analyze(THD *thd, HA_CHECK_OPT *check_opt)
Analyze table: public interface.
Definition: handler.cc:5004
virtual uint max_supported_record_length() const
Definition: handler.h:6100
virtual enum_alter_inplace_result check_if_supported_inplace_alter(TABLE *altered_table, Alter_inplace_info *ha_alter_info)
Check if a storage engine supports a particular alter table in-place.
Definition: handler.cc:5100
ulonglong Table_flags
Definition: handler.h:4622
virtual void parallel_scan_end(void *scan_ctx)
End of the parallel scan.
Definition: handler.h:5106
bool ha_commit_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, bool commit, const dd::Table *old_table_def, dd::Table *new_table_def)
Public function wrapping the actual handler call.
Definition: handler.cc:5075
PSI_table_share * ha_table_share_psi(const TABLE_SHARE *share) const
Acquire the instrumented table information from a table share.
Definition: handler.cc:2873
int get_lock_type() const
Definition: handler.h:7189
std::function< bool(void *cookie, ulong ncols, ulong row_len, const ulong *col_offsets, const ulong *null_byte_offsets, const ulong *null_bitmasks)> Load_init_cbk
This callback is called by each parallel load thread at the beginning of the parallel load for the ad...
Definition: handler.h:5057
Table_flags ha_table_flags() const
The cached_table_flags is set at ha_open and ha_external_lock.
Definition: handler.h:4965
int ha_load_table(const TABLE &table, bool *skip_metadata_update)
Loads a table into its defined secondary storage engine: public interface.
Definition: handler.cc:5228
virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
Definition: handler.h:5903
void ha_drop_table(const char *name)
Drop table in the engine: public interface.
Definition: handler.cc:5197
bool ha_prepare_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def)
Public functions wrapping the actual handler call.
Definition: handler.cc:5064
void start_psi_batch_mode()
Put the handler in 'batch' mode when collecting table io instrumented events.
Definition: handler.cc:2852
enum handler::@61 inited
int ha_index_or_rnd_end()
Definition: handler.h:4959
virtual bool is_crashed() const
Check if the table is crashed.
Definition: handler.h:6122
int ha_truncate(dd::Table *table_def)
Truncate table: public interface.
Definition: handler.cc:4978
virtual int close(void)=0
int ha_index_read_map(uchar *buf, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag)
Read [part of] row via [part of] index.
Definition: handler.cc:3368
int ha_sample_next(void *scan_ctx, uchar *buf)
Get the next record for sampling.
Definition: handler.cc:3201
void unbind_psi()
Definition: handler.cc:2827
virtual int assign_to_keycache(THD *, HA_CHECK_OPT *)
Definition: handler.h:6059
virtual bool start_bulk_update()
Definition: handler.h:5668
uchar * dup_ref
Pointer to duplicate row.
Definition: handler.h:4637
bool end_psi_batch_mode_if_started()
If a PSI batch was started, turn if off.
Definition: handler.h:4806
virtual ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq, void *seq_init_param, uint n_ranges, uint *bufsz, uint *flags, bool *force_default_mrr, Cost_estimate *cost)
Get cost and other information about MRR scan over a known list of ranges.
Definition: handler.cc:6334
int ha_check_for_upgrade(HA_CHECK_OPT *check_opt)
Definition: handler.cc:4669
handler * ha_get_primary_handler() const
Get a pointer to a handler for the table in the primary storage engine, if this handler is for a tabl...
Definition: handler.h:7266
bool ha_get_se_private_data(dd::Table *dd_table, bool reset)
Submit a dd::Table object representing a core DD table having hardcoded data to be filled in by the D...
Definition: handler.cc:5247
virtual uint32 calculate_key_hash_value(Field **field_array)
Definition: handler.h:5871
uint max_record_length() const
Definition: handler.h:6084
@ SAMPLING
Definition: handler.h:4705
@ NONE
Definition: handler.h:4705
@ INDEX
Definition: handler.h:4705
@ RND
Definition: handler.h:4705
void unlock_shared_ha_data()
Release lock for protecting ha_share.
Definition: handler.cc:8339
void mark_trx_read_write()
A helper function to mark a transaction read-write, if it is started.
Definition: handler.cc:4846
virtual uint number_of_pushed_joins() const
Reports number of tables included in pushed join which this handler instance is part of.
Definition: handler.h:6272
virtual int sample_init(void *&scan_ctx, double sampling_percentage, int sampling_seed, enum_sampling_method sampling_method, const bool tablesample)
Initialize sampling.
Definition: handler.cc:3222
PSI_table * m_psi
Instrumented table associated with this handler.
Definition: handler.h:4745
virtual int discard_or_import_tablespace(bool discard, dd::Table *table_def)
Discard or import tablespace.
Definition: handler.h:7120
virtual int exec_bulk_update(uint *dup_key_found)
After this call all outstanding updates must be performed.
Definition: handler.h:5685
int update_auto_increment()
Definition: handler.cc:3881
virtual int indexes_are_disabled(void)
Check if indexes are disabled.
Definition: handler.h:6074
Record_buffer * ha_get_record_buffer() const
Get the record buffer that was set with ha_set_record_buffer().
Definition: handler.h:4914
virtual Table_flags table_flags(void) const =0
THD * ha_thd() const
Definition: handler.cc:2820
batch_mode_t m_psi_batch_mode
Batch mode state.
Definition: handler.h:4765
virtual int index_read_last(uchar *buf, const uchar *key, uint key_len)
Definition: handler.h:6980
virtual int start_stmt(THD *thd, thr_lock_type lock_type)
Start a statement when table is locked.
Definition: handler.h:6019
virtual const TABLE * member_of_pushed_join() const
If this handler instance is part of a pushed join sequence returned TABLE instance being root of the ...
Definition: handler.h:6278
virtual int index_next_pushed(uchar *)
Definition: handler.h:6300
FT_INFO * ft_handler
Definition: handler.h:4704
int ha_index_read_pushed(uchar *buf, const uchar *key, key_part_map keypart_map)
Definition: handler.cc:3694
virtual const handlerton * hton_supporting_engine_pushdown()
Get the handlerton of the storage engine if the SE is capable of pushing down some of the AccessPath ...
Definition: handler.h:5922
virtual bool is_record_buffer_wanted(ha_rows *const max_rows) const
Does this handler want to get a Record_buffer for multi-row reads via the ha_set_record_buffer() func...
Definition: handler.h:6896
Handler_share ** ha_share
Pointer where to store/retrieve the Handler_share pointer.
Definition: handler.h:4824
virtual handler * clone(const char *name, MEM_ROOT *mem_root)
Definition: handler.cc:2783
int ha_optimize(THD *thd, HA_CHECK_OPT *check_opt)
Optimize table: public interface.
Definition: handler.cc:4991
Table_flags cached_table_flags
Definition: handler.h:4628
virtual int analyze(THD *, HA_CHECK_OPT *)
Definition: handler.h:7062
int ha_external_lock(THD *thd, int lock_type)
These functions represent the public interface to users of the handler class, hence they are not virt...
Definition: handler.cc:8115
virtual void notify_table_changed(Alter_inplace_info *ha_alter_info)
Notify the storage engine that the table definition has been updated.
Definition: handler.h:6681
handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
Definition: handler.h:4846
virtual uint max_supported_keys() const
Definition: handler.h:6101
virtual int records(ha_rows *num_rows)
Number of rows in table.
Definition: handler.cc:3240
virtual int rnd_init(bool scan)=0
rnd_init() can be called two times without rnd_end() in between (it only makes sense if scan=1).
uint max_key_length() const
Definition: handler.h:6093
range_seq_t mrr_iter
Definition: handler.h:4642
int handle_records_error(int error, ha_rows *num_rows)
Function will handle the error code from call to records() and records_from_index().
Definition: handler.cc:3314
virtual int rename_table(const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def)
Default rename_table() and delete_table() rename/delete files with a given name and extensions from h...
Definition: handler.cc:4783
int ha_records(ha_rows *num_rows)
Wrapper function to call records() in storage engine.
Definition: handler.h:5596
void lock_shared_ha_data()
Take a lock for protecting shared handler data.
Definition: handler.cc:8329
PSI_table_locker * m_psi_locker
The current event in a batch.
Definition: handler.h:4777
int ha_open(TABLE *table, const char *name, int mode, int test_if_locked, const dd::Table *table_def)
Definition: handler.cc:2903
virtual void start_bulk_insert(ha_rows)
Definition: handler.h:6877
static bool my_prepare_gcolumn_template(THD *thd, const char *db_name, const char *table_name, my_gcolumn_template_callback_t myc, void *ib_table)
Callback to allow InnoDB to prepare a template for generated column processing.
Definition: handler.cc:8600
virtual bool inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def)
Alter the table structure in-place with operations specified using HA_ALTER_FLAGS and Alter_inplace_i...
Definition: handler.h:6593
virtual bool bulk_load_check(THD *thd) const
Check if the table is ready for bulk load.
Definition: handler.h:5111
uint get_index(void) const
Definition: handler.h:5662
virtual int read_range_first(const key_range *start_key, const key_range *end_key, bool eq_range_arg, bool sorted)
Read first row between two ranges.
Definition: handler.cc:7496
virtual void * bulk_load_begin(THD *thd, size_t keynr, size_t data_size, size_t memory, size_t num_threads)
Begin parallel bulk data load to the table.
Definition: handler.h:5128
int ha_delete_table(const char *name, const dd::Table *table_def)
Delete table: public interface.
Definition: handler.cc:5184
virtual void get_auto_increment(ulonglong offset, ulonglong increment, ulonglong nb_desired_values, ulonglong *first_value, ulonglong *nb_reserved_values)
Reserves an interval of auto_increment values from the handler.
Definition: handler.cc:4106
virtual bool prepare_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def)
Allows the storage engine to update internal structures with concurrent writes blocked.
Definition: handler.h:6556
std::mt19937 * m_random_number_engine
Definition: handler.h:4747
virtual uint min_record_length(uint options) const
Definition: handler.h:6108
void init()
This is called after create to allow us to set up cached variables.
Definition: handler.h:4897
void set_ha_share_ptr(Handler_share *arg_ha_share)
Set ha_share to be used by all instances of the same table/partition.
Definition: handler.cc:8314
virtual std::string explain_extra() const
Return extra handler specific text for EXPLAIN.
Definition: handler.h:4890
virtual int write_row(uchar *buf)
Write a row.
Definition: handler.h:6798
virtual void try_semi_consistent_read(bool)
Tell the engine whether it should avoid unnecessary lock waits.
Definition: handler.h:5995
enum_range_scan_direction
Definition: handler.h:4659
@ RANGE_SCAN_ASC
Definition: handler.h:4659
@ RANGE_SCAN_DESC
Definition: handler.h:4659
void end_psi_batch_mode()
End a batch started with start_psi_batch_mode.
Definition: handler.cc:2861
void set_next_insert_id(ulonglong id)
Definition: handler.h:6027
virtual int ft_init()
Definition: handler.h:5778
int compare_key_icp(const key_range *range) const
Definition: handler.cc:7695
TABLE * table
Definition: handler.h:4627
void ha_notify_table_changed(Alter_inplace_info *ha_alter_info)
Public function wrapping the actual handler call.
Definition: handler.h:6514
int ha_index_prev(uchar *buf)
Reads the previous row via index.
Definition: handler.cc:3512
int ha_rnd_pos(uchar *buf, uchar *pos)
Read row via random scan from position.
Definition: handler.cc:3120
int ha_index_first(uchar *buf)
Reads the first row via index.
Definition: handler.cc:3548
bool ha_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def)
Public function wrapping the actual handler call.
Definition: handler.h:6490
Record_buffer * m_record_buffer
Buffer for multi-row reads.
Definition: handler.h:4662
void ha_release_auto_increment()
Definition: handler.cc:4170
virtual int truncate(dd::Table *table_def)
Quickly remove all rows from a table.
Definition: handler.h:7056
virtual int index_end()
Definition: handler.h:6764
virtual table_map tables_in_pushed_join() const
Definition: handler.h:6288
virtual int delete_all_rows()
Delete all rows in a table.
Definition: handler.h:7021
virtual int rnd_pos_by_record(uchar *record)
This function only works for handlers having HA_PRIMARY_KEY_REQUIRED_FOR_POSITION set.
Definition: handler.h:5801
virtual void drop_table(const char *name)
Definition: handler.cc:4804
virtual int unload_table(const char *db_name, const char *table_name, bool error_if_not_loaded)
Unloads a table from its defined secondary storage engine.
Definition: handler.h:6964
void ha_mv_key_capacity(uint *num_keys, size_t *keys_length) const
Return max limits for a single set of multi-valued keys.
Definition: handler.h:7274
virtual int optimize(THD *, HA_CHECK_OPT *)
Definition: handler.h:7059
int ha_index_read_idx_map(uchar *buf, uint index, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag)
Initializes an index and read it.
Definition: handler.cc:3428
virtual int bulk_update_row(const uchar *old_data, uchar *new_data, uint *dup_key_found)
This method is similar to update_row, however the handler doesn't need to execute the updates at this...
Definition: handler.h:7004
virtual bool check_and_repair(THD *thd)
Check and repair the table if necessary.
Definition: handler.h:7077
virtual bool auto_repair() const
Check if the table can be automatically repaired.
Definition: handler.h:6131
virtual int end_bulk_insert()
Definition: handler.h:6878
virtual int index_read_idx_map(uchar *buf, uint index, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag)
Positions an index cursor to the index specified in argument.
Definition: handler.cc:7756
virtual bool start_bulk_delete()
Definition: handler.h:5673
uint auto_inc_intervals_count
Number of reserved auto-increment intervals.
Definition: handler.h:4740
void ha_set_record_buffer(Record_buffer *buffer)
Set a record buffer that the storage engine can use for multi-row reads.
Definition: handler.h:4907
virtual ha_checksum checksum() const
Definition: handler.h:6113
virtual void mv_key_capacity(uint *num_keys, size_t *keys_length) const
Engine-specific function for ha_can_store_mv_keys().
Definition: handler.h:7297
static bool my_eval_gcolumn_expr_with_open(THD *thd, const char *db_name, const char *table_name, const MY_BITMAP *const fields, uchar *record, const char **mv_data_ptr, ulong *mv_length)
Callback for generated columns processing.
Definition: handler.cc:8638
virtual bool get_se_private_data(dd::Table *dd_table, bool reset)
Definition: handler.h:7151
int ha_repair(THD *thd, HA_CHECK_OPT *check_opt)
Repair table: public interface.
Definition: handler.cc:4900
int ha_rnd_next(uchar *buf)
Read next row via random scan.
Definition: handler.cc:3089
virtual void position(const uchar *record)=0
void adjust_next_insert_id_after_explicit_value(ulonglong nr)
Definition: handler.cc:3756
void(* my_gcolumn_template_callback_t)(const TABLE *, void *)
Callback function that will be called by my_prepare_gcolumn_template once the table has been opened.
Definition: handler.h:7195
int ha_rnd_end()
End use of random access.
Definition: handler.cc:3067
uint get_dup_key(int error)
Definition: handler.cc:4740
virtual bool upgrade_table(THD *thd, const char *dbname, const char *table_name, dd::Table *dd_table)
Definition: handler.h:6902
int ha_write_row(uchar *buf)
Definition: handler.cc:8186
virtual int delete_table(const char *name, const dd::Table *table_def)
Delete a table.
Definition: handler.cc:4755
virtual int get_extra_columns_and_keys(const HA_CREATE_INFO *create_info, const List< Create_field > *create_list, const KEY *key_info, uint key_count, dd::Table *table_obj)
Adjust definition of table to be created by adding implicit columns and indexes necessary for the sto...
Definition: handler.h:7174
virtual void use_hidden_primary_key()
use_hidden_primary_key() is called in case of an update/delete when (table_flags() and HA_PRIMARY_KEY...
Definition: handler.cc:8277
int ha_ft_read(uchar *buf)
Definition: handler.cc:3147
key_range save_end_range
Definition: handler.h:4667
PSI_table_locker_state m_psi_locker_state
Storage for the event in a batch.
Definition: handler.h:4783
ha_rows estimation_rows_to_insert
Definition: handler.h:4630
virtual int rnd_pos(uchar *buf, uchar *pos)=0
virtual int bulk_load_execute(THD *thd, void *load_ctx, size_t thread_idx, const Rows_mysql &rows, Bulk_load::Stat_callbacks &wait_cbk)
Execute bulk load operation.
Definition: handler.h:5143
bool mrr_is_output_sorted
Definition: handler.h:4647
virtual int index_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map)
The following functions works like index_read, but it find the last row with the current key value or...
Definition: handler.h:5753
int ha_close(void)
Close handler.
Definition: handler.cc:2973
uint max_key_part_length(HA_CREATE_INFO *create_info) const
Definition: handler.h:6096
virtual bool set_ha_share_ref(Handler_share **arg_ha_share)
Definition: handler.h:7182
virtual void release_auto_increment()
Definition: handler.h:6863
const TABLE_SHARE * get_table_share() const
Definition: handler.h:5269
virtual int read_range_next()
Read next row between two endpoints.
Definition: handler.cc:7573
int ha_read_first_row(uchar *buf, uint primary_key)
Read first row (only) from a table.
Definition: handler.cc:3664
virtual ha_rows estimate_rows_upper_bound()
Return upper bound of current number of records in the table (max.
Definition: handler.h:5618
bool has_transactions()
Definition: handler.h:5509
virtual int delete_row(const uchar *buf)
Definition: handler.h:6815
Item * pushed_idx_cond
Definition: handler.h:4709
int compare_key_in_buffer(const uchar *buf) const
Check if the key in the given buffer (which is not necessarily TABLE::record[0]) is within range.
Definition: handler.cc:7731
virtual int parallel_scan(void *scan_ctx, void **thread_ctxs, Load_init_cbk init_fn, Load_cbk load_fn, Load_end_cbk end_fn)
Run the parallel read of data.
Definition: handler.h:5094
virtual int check_for_upgrade(HA_CHECK_OPT *)
admin commands - called from mysql_admin_table
Definition: handler.h:6865
int ha_disable_indexes(uint mode)
Disable indexes: public interface.
Definition: handler.cc:5030
double estimate_in_memory_buffer(ulonglong table_index_size) const
Make a guesstimate for how much of a table or index is in a memory buffer in the case where the stora...
Definition: handler.cc:6142
virtual int index_last(uchar *)
Definition: handler.h:5743
virtual double page_read_cost(uint index, double reads)
Cost estimate for doing a number of non-sequentially accesses against the storage engine.
Definition: handler.cc:6252
virtual Item * idx_cond_push(uint keyno, Item *idx_cond)
Push down an index condition to the handler.
Definition: handler.h:6257
int key_compare_result_on_equal
Definition: handler.h:4669
int compare_key(key_range *range)
Compare if found key (in row) is over max-value.
Definition: handler.cc:7654
KEY_MULTI_RANGE mrr_cur_range
Definition: handler.h:4652
bool mrr_have_range
Definition: handler.h:4650
virtual int cmp_ref(const uchar *ref1, const uchar *ref2) const
Compare two positions.
Definition: handler.h:6203
bool ha_is_record_buffer_wanted(ha_rows *const max_rows) const
Does this handler want to get a Record_buffer for multi-row reads via the ha_set_record_buffer() func...
Definition: handler.h:4931
ulonglong m_psi_numrows
The number of rows in the batch.
Definition: handler.h:4771
virtual bool commit_inplace_alter_table(TABLE *altered_table, Alter_inplace_info *ha_alter_info, bool commit, const dd::Table *old_table_def, dd::Table *new_table_def)
Commit or rollback the changes made during prepare_inplace_alter_table() and inplace_alter_table() in...
Definition: handler.h:6651
virtual int end_bulk_delete()
Execute all outstanding deletes and close down the bulk delete.
Definition: handler.h:5700
virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info, dd::Table *table_def)=0
Create table (implementation).
virtual double worst_seek_times(double reads)
Provide an upper cost-limit of doing a specified number of seek-and-read key lookups.
Definition: handler.cc:6266
int ha_rename_table(const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def)
Rename table: public interface.
Definition: handler.cc:5169
virtual enum row_type get_real_row_type(const HA_CREATE_INFO *create_info) const
Get real row type for the table created based on one specified by user, CREATE TABLE options and SE c...
Definition: handler.h:5626
virtual int index_read_map(uchar *buf, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag)
Positions an index cursor to the index specified in the handle ('active_index').
Definition: handler.h:5713
std::function< bool(void *cookie, uint nrows, void *rowdata, uint64_t partition_id)> Load_cbk
This callback is called by each parallel load thread when processing of rows is required for the adap...
Definition: handler.h:5072
int ha_index_end()
End use of index.
Definition: handler.cc:3024
virtual THR_LOCK_DATA ** store_lock(THD *thd, THR_LOCK_DATA **to, enum thr_lock_type lock_type)=0
Is not invoked for non-transactional temporary tables.
int ha_unload_table(const char *db_name, const char *table_name, bool error_if_not_loaded)
Unloads a table from its defined secondary storage engine: public interface.
Definition: handler.cc:5237
int ha_rnd_init(bool scan)
Initialize table for random read or scan.
Definition: handler.cc:3048
virtual bool get_error_message(int error, String *buf)
Return an error message specific to this handler.
Definition: handler.cc:4623
bool implicit_emptied
Definition: handler.h:4706
virtual void print_error(int error, myf errflag)
Print error that we got from handler function.
Definition: handler.cc:4317
static bool my_eval_gcolumn_expr(THD *thd, TABLE *table, const MY_BITMAP *const fields, uchar *record, const char **mv_data_ptr, ulong *mv_length)
Callback for computing generated column values.
Definition: handler.cc:8656
virtual int write_blob(THD *thd, void *load_ctx, size_t thread_idx, Blob_context blob_ctx, unsigned char *blobref, const unsigned char *data, size_t data_len)
Write to a blob.
Definition: handler.h:5175
In-place alter handler context.
Definition: handler.h:3376
virtual void set_shared_data(const inplace_alter_handler_ctx *ctx)
Definition: handler.h:3380
virtual ~inplace_alter_handler_ctx()=default
inplace_alter_handler_ctx()=default
Definition: partition_info.h:209
Legacy struct for passing tablespace information to SEs.
Definition: handler.h:871
ts_command_type ts_cmd_type
Definition: handler.h:875
bool wait_until_completed
Definition: handler.h:888
ulonglong undo_buffer_size
Definition: handler.h:881
ulonglong extent_size
Definition: handler.h:880
st_alter_tablespace(const char *tablespace, const char *logfile_group, ts_command_type cmd, enum ts_alter_tablespace_type alter_tablespace_cmd, const char *datafile, const char *undofile, const Tablespace_options &opts)
Proper constructor even for all-public class simplifies initialization and allows members to be const...
Definition: sql_tablespace.cc:93
const char * logfile_group_name
Definition: handler.h:874
ulonglong file_block_size
Definition: handler.h:886
const char * encryption
Definition: handler.h:890
const char * undo_file_name
Definition: handler.h:879
const char * tablespace_name
Definition: handler.h:873
const char * ts_comment
Definition: handler.h:889
std::optional< ulonglong > autoextend_size
Definition: handler.h:884
ulonglong redo_buffer_size
Definition: handler.h:882
ulonglong max_size
Definition: handler.h:885
ulonglong initial_size
Definition: handler.h:883
const char * data_file_name
Definition: handler.h:878
uint nodegroup_id
Definition: handler.h:887
bool is_tablespace_command()
Definition: handler.h:892
A table definition from the master.
Definition: rpl_utility.h:249
static MEM_ROOT mem_root
Definition: client_plugin.cc:114
static bool report_error(THD *thd, int error_code, Sql_condition::enum_severity_level level, Args... args)
Definition: error_handler.cc:290
Some definitions for full-text indices.
ft_operation
Operation types, used in FT_HINTS.
Definition: ft_global.h:99
@ FT_OP_UNDEFINED
Definition: ft_global.h:100
struct PSI_table_locker PSI_table_locker
Definition: psi_table_bits.h:43
struct PSI_table_share PSI_table_share
Definition: psi_table_bits.h:100
struct PSI_table PSI_table
Definition: psi_table_bits.h:107
static int flags[50]
Definition: hp_test1.cc:40
static int flag
Definition: hp_test1.cc:40
static uint keys
Definition: hp_test2.cc:49
#define IN_MEMORY_ESTIMATE_UNKNOWN
If the "in memory estimate" for a table (in ha_statistics.table_in_mem_estimate) or index (in KEY::m_...
Definition: key.h:111
constexpr const LEX_CSTRING NULL_CSTR
Definition: lex_string.h:47
A better implementation of the UNIX ctype(3) library.
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
void destroy_at(T *ptr)
Definition: my_alloc.h:462
This file includes constants used by all storage engines.
#define HA_OPTION_PACK_RECORD
Indicates that storage engine needs to use packed row format.
Definition: my_base.h:603
#define rows2double(A)
Definition: my_base.h:1140
ha_panic_function
Definition: my_base.h:432
ha_key_alg
Definition: my_base.h:98
@ HA_KEY_ALG_SE_SPECIFIC
Used for cases when key algorithm which is supported by SE can't be described by one of other classes...
Definition: my_base.h:107
#define HA_ERR_UNSUPPORTED
unsupported extension used
Definition: my_base.h:855
ha_rkey_function
Definition: my_base.h:78
ulong key_part_map
Definition: my_base.h:1008
my_off_t ha_rows
Definition: my_base.h:1141
ha_extra_function
Definition: my_base.h:185
#define HA_POS_ERROR
Definition: my_base.h:1143
#define HA_ERR_WRONG_COMMAND
Command not supported.
Definition: my_base.h:841
#define HA_OPTION_COMPRESS_RECORD
Flag indicating that table is compressed.
Definition: my_base.h:629
ha_storage_media
Definition: my_base.h:116
@ HA_SM_DEFAULT
Definition: my_base.h:117
Abstraction functions over zlib/intrinsics.
std::uint32_t ha_checksum
Definition: my_checksum.h:106
Header for compiler-dependent features.
#define DBUG_PRINT(keyword, arglist)
Definition: my_dbug.h:181
Utility functions for converting between ulonglong and double.
#define ulonglong2double(A)
Definition: my_double2ulonglong.h:46
Some integer typedefs for easier portability.
int myf
Definition: my_inttypes.h:94
unsigned long long int ulonglong
Definition: my_inttypes.h:56
ulonglong my_off_t
Definition: my_inttypes.h:72
unsigned char uchar
Definition: my_inttypes.h:52
long long int longlong
Definition: my_inttypes.h:55
uint64_t uint64
Definition: my_inttypes.h:69
uint32_t uint32
Definition: my_inttypes.h:67
Common #defines and includes for file and socket I/O.
constexpr const size_t IO_SIZE
Definition: my_io.h:163
Common header for many mysys elements.
uint64_t table_map
Definition: my_table_map.h:30
void set_my_errno(int my_errno)
Set the MySQL thread-local storage variant of errno.
Definition: my_thr_init.cc:368
static char * query
Definition: myisam_ftdump.cc:47
static HashTable ht
Definition: mysql.cc:162
static bool interrupted
Definition: mysqladmin.cc:73
void error(const char *format,...)
static char * path
Definition: mysqldump.cc:150
struct stats stats
Definition: mysqlslap.cc:240
static Secondary_engine * secondary_engine
Definition: mysqltest.cc:260
static int record
Definition: mysqltest.cc:195
bool is_temp_table(const HA_CREATE_INFO &ci)
Definition: sql_table.cc:231
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: buf0block_hint.cc:30
constexpr value_type primary_key
Definition: classic_protocol_constants.h:269
static PFS_engine_table_share_proxy share
Definition: connection_control_pfs_table.cc:92
std::string dir
Double write files location.
Definition: buf0dblwr.cc:77
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:43
unsigned long long Object_id
Definition: object_id.h:31
enum_column_types
Definition: column.h:53
Char_string_template< String_type_allocator > String_type
Definition: string_type.h:51
Definition: os0file.h:89
bool index(const std::string &value, const String &search_for, uint32_t *idx)
Definition: contains.h:75
Definition: hypergraph.cc:30
void print(trx_t *trx, dict_index_t *index, std::ostream &out, ref_t ref, bool fatal)
Print information about the given LOB.
Definition: lob0impl.cc:1333
std::string file_name(Log_file_id file_id)
Provides name of the log file with the given file id, e.g.
Definition: log0pre_8_0_30.cc:94
Definition: aligned_atomic.h:44
entry::Table Table
Definition: select.h:51
ValueType value(const std::optional< ValueType > &v)
Definition: gtid.h:83
std::string join(const detail::range auto &rng, std::string_view delim)
join elements of a range into a string separated by a delimiter.
Definition: string.h:74
size_t size(const char *const c)
Definition: base64.h:46
mutable_buffer buffer(void *p, size_t n) noexcept
Definition: buffer.h:418
size_t buffer_size(const ConstBufferSequence &buffers) noexcept
Definition: buffer.h:313
Definition: options.cc:57
const char * table_name
Definition: rules_table_service.cc:56
const char * db_name
Definition: rules_table_service.cc:55
mode
Definition: file_handle.h:61
std::vector< T, ut::allocator< T > > vector
Specialization of vector which uses allocator.
Definition: ut0new.h:2876
static int exists(node_address *name, node_list const *nodes, u_int with_uid)
Definition: node_list.cc:106
int(* Page_Track_Callback)(MYSQL_THD thd, const unsigned char *buffer, size_t buf_len, int num_pages, void *user_ctx)
Page tracking callback function.
Definition: page_track_service.h:66
struct result result
Definition: result.h:34
Performance schema instrumentation interface.
required string key
Definition: replication_asynchronous_connection_failover.proto:60
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:61
required uint64 version
Definition: replication_group_member_actions.proto:41
required string type
Definition: replication_group_member_actions.proto:34
ulonglong prev_insert_id(ulonglong nr, struct System_variables *variables)
Computes the largest number X:
Definition: handler.cc:3781
void trans_register_ha(THD *thd, bool all, handlerton *ht, const ulonglong *trxid)
Register a storage engine for a transaction.
Definition: handler.cc:1366
bool(* sdi_get_t)(const dd::Tablespace &tablespace, const sdi_key_t *sdi_key, void *sdi, uint64 *sdi_len)
Retrieve SDI for a given SDI key.
Definition: handler.h:1768
int ha_finalize_handlerton(st_plugin_int *plugin)
Definition: handler.cc:732
bool(* ddse_dict_init_t)(dict_init_mode_t dict_init_mode, uint version, List< const dd::Object_table > *DDSE_tables, List< const Plugin_tablespace > *DDSE_tablespaces)
Definition: handler.h:1902
handlerton * ha_checktype(THD *thd, enum legacy_db_type database_type, bool no_substitute, bool report_error)
Use other database handler if databasehandler is not compiled in.
Definition: handler.cc:574
bool(* qc_engine_callback)(THD *thd, const char *table_key, uint key_length, ulonglong *engine_data)
Definition: handler.h:143
int(* savepoint_set_t)(handlerton *hton, THD *thd, void *sv)
sv points to an uninitialized storage area of requested size (see savepoint_offset description)
Definition: handler.h:1379
bool(* show_status_t)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat)
Definition: handler.h:1516
bool(*)(const THD *thd, std::string_view reason) set_secondary_engine_offload_fail_reason_t
Sets a specific secondary engine offload failure reason for a query represented by the thread context...
Definition: handler.h:2500
#define UNDEF_NODEGROUP
Definition: handler.h:838
static const uint32 HTON_FKS_WITH_ANY_PREFIX_SUPPORTING_KEYS
Storage engine supports non-hash keys which have common prefix with the foreign key as supporting key...
Definition: handler.h:3188
int(*)(uint64_t *purge_id) page_track_purge_t
Purge page tracking data.
Definition: handler.h:2689
bool(* sdi_set_t)(handlerton *hton, const dd::Tablespace &tablespace, const dd::Table *table, const sdi_key_t *sdi_key, const void *sdi, uint64 sdi_len)
Insert/Update SDI for a given SDI key.
Definition: handler.h:1783
int ha_rollback_low(THD *thd, bool all)
Definition: handler.cc:2057
bool ha_notify_exclusive_mdl(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type, bool *victimized)
Notify/get permission from all interested storage engines before acquisition or after release of excl...
Definition: handler.cc:8805
size_t num_hton2plugins()
Returns the size of the array holding pointers to plugins.
Definition: handler.cc:243
int ha_find_files(THD *thd, const char *db, const char *path, const char *wild, bool dir, List< LEX_STRING > *files)
Definition: handler.cc:5881
bool(* dict_recover_t)(dict_recovery_mode_t dict_recovery_mode, uint version)
Do recovery in the DDSE as part of initializing the data dictionary.
Definition: handler.h:1955
int(*)(handlerton *hton, THD *thd, const uchar *&loc, uint &loc_len, uint &task_id, Ha_clone_mode mode, const char *data_dir) Clone_apply_begin_t
Begin apply to destination database.
Definition: handler.h:2245
void(* reset_plugin_vars_t)(THD *thd)
Some plugin session variables may require some special handling upon clean up.
Definition: handler.h:1367
constexpr const uint32 SDI_TYPE_TABLE
Id for identifying Table SDIs.
Definition: handler.h:124
void ha_kill_connection(THD *thd)
Definition: handler.cc:1027
enum_ha_recover_xa_state
Enumeration of possible states for externally coordinated transactions (XA).
Definition: handler.h:1241
#define COMPATIBLE_DATA_NO
Definition: handler.h:832
constexpr const decltype(handlerton::flags) HTON_NO_DEFAULT_ENGINE_SUPPORT
Definition: handler.h:3140
std::unordered_set< my_xid, std::hash< my_xid >, std::equal_to< my_xid >, Mem_root_allocator< my_xid > > Xid_commit_list
Single occurrence set of XIDs of internally coordinated transactions found as been committed in the t...
Definition: handler.h:1255
bool(* lock_hton_log_t)(handlerton *hton)
Lock a handlerton (resource) log to collect log information.
Definition: handler.h:2314
Ha_clone_mode
Clone start operation mode.
Definition: handler.h:951
@ HA_CLONE_MODE_ADD_TASK
Add a new task to a running clone operation.
Definition: handler.h:959
@ HA_CLONE_MODE_START
Start a new clone operation.
Definition: handler.h:953
@ HA_CLONE_MODE_MAX
Max value for clone mode.
Definition: handler.h:965
@ HA_CLONE_MODE_VERSION
Get version for transfer data format.
Definition: handler.h:962
@ HA_CLONE_MODE_RESTART
Re-start a clone operation after failure.
Definition: handler.h:956
int(*)(uint64_t *start_id) page_track_start_t
Start page tracking.
Definition: handler.h:2664
static const size_t MAX_FK_NAME_SUFFIX_LENGTH
Maximum possible length of SE-specific suffixes for auto-generated foreign key names.
Definition: handler.h:3212
ha_stat_type
Definition: handler.h:941
@ HA_ENGINE_LOGS
Definition: handler.h:941
@ HA_ENGINE_MUTEX
Definition: handler.h:941
@ HA_ENGINE_STATUS
Definition: handler.h:941
st_plugin_int * remove_hton2plugin(uint slot)
Definition: handler.cc:251
SecondaryEngineGraphSimplificationRequestParameters(*)(THD *thd, const JoinHypergraph &hypergraph, const AccessPath *access_path, int current_subgraph_pairs, int current_subgraph_pairs_limit, bool is_root_access_path, std::string *trace) secondary_engine_check_optimizer_request_t
Hook to evaluate the current hypergraph optimization state in optimization for all the engines,...
Definition: handler.h:2543
static const uint MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT
Options for the START TRANSACTION statement.
Definition: handler.h:642
void(* drop_database_t)(handlerton *hton, const char *db)
Definition: handler.h:1493
int ha_create_table(THD *thd, const char *path, const char *db, const char *table_name, HA_CREATE_INFO *create_info, bool update_create_info, bool is_temp_table, dd::Table *table_def)
Initiates table-file and calls appropriate database-creator.
Definition: handler.cc:5348
std::pair< int, bool > commit_owned_gtids(THD *thd, bool all)
The function computes condition to call gtid persistor wrapper, and executes it.
Definition: handler.cc:1612
int ha_resize_key_cache(KEY_CACHE *key_cache)
Resize key cache.
Definition: handler.cc:5769
std::bitset< HA_CLONE_TYPE_MAX > Ha_clone_flagset
Definition: handler.h:993
bool ha_log_ddl_create_schema(const char *schema_name)
Call "log_ddl_create_schema" handletron for storage engines who implement it.
Definition: handler.cc:977
bool(*)(THD *thd, LEX *lex) optimize_secondary_engine_t
Optimize a statement for execution on a secondary storage engine.
Definition: handler.h:2373
bool(* notify_alter_table_t)(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type)
Notify/get permission from storage engine before or after execution of ALTER TABLE operation on the t...
Definition: handler.h:2040
bool(* savepoint_rollback_can_release_mdl_t)(handlerton *hton, THD *thd)
Check if storage engine allows to release metadata locks which were acquired after the savepoint if r...
Definition: handler.h:1387
void(* dict_register_dd_table_id_t)(dd::Object_id hard_coded_tables)
Initialize the set of hard coded DD table ids.
Definition: handler.h:1910
ts_command_type
Definition: handler.h:841
@ CREATE_LOGFILE_GROUP
Definition: handler.h:845
@ DROP_UNDO_TABLESPACE
Definition: handler.h:853
@ TS_CMD_NOT_DEFINED
Definition: handler.h:842
@ ALTER_TABLESPACE
Definition: handler.h:844
@ DROP_LOGFILE_GROUP
Definition: handler.h:848
@ ALTER_ACCESS_MODE_TABLESPACE
Definition: handler.h:850
@ ALTER_UNDO_TABLESPACE
Definition: handler.h:852
@ CHANGE_FILE_TABLESPACE
Definition: handler.h:849
@ DROP_TABLESPACE
Definition: handler.h:847
@ CREATE_UNDO_TABLESPACE
Definition: handler.h:851
@ CREATE_TABLESPACE
Definition: handler.h:843
@ ALTER_LOGFILE_GROUP
Definition: handler.h:846
bool(* is_dict_readonly_t)()
Check if the DDSE is started in a way that leaves thd DD being read only.
Definition: handler.h:1805
int(* recover_t)(handlerton *hton, XA_recover_txn *xid_list, uint len, MEM_ROOT *mem_root)
Definition: handler.h:1405
bool(* get_table_statistics_t)(const char *db_name, const char *table_name, dd::Object_id se_private_id, const dd::Properties &ts_se_private_data, const dd::Properties &tbl_se_private_data, uint flags, ha_statistics *stats)
Retrieve ha_statistics from SE.
Definition: handler.h:2116
#define HA_MAX_REC_LENGTH
Definition: handler.h:627
#define HTON_SUPPORTS_ATOMIC_DDL
Engine supports atomic DDL.
Definition: handler.h:3094
void(*)(void *arg) se_before_rollback_t
Definition: handler.h:2598
bool(* log_ddl_drop_schema_t)(handlerton *hton, const char *schema_name)
Definition: handler.h:1495
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache)
Move all tables from one key cache to another one.
Definition: handler.cc:5790
int(* savepoint_release_t)(handlerton *hton, THD *thd, void *sv)
Definition: handler.h:1390
bool(*)(THD *thd) external_engine_explain_check_t
Checks whether the tables used in an explain query are loaded in the secondary engine.
Definition: handler.h:2460
plugin_ref ha_lock_engine(THD *thd, const handlerton *hton)
Definition: handler.cc:525
int(*)(handlerton *hton, THD *thd, const uchar *loc, uint loc_len, uint task_id, int in_err) Clone_apply_end_t
End apply to destination database.
Definition: handler.h:2269
int(* find_files_t)(handlerton *hton, THD *thd, const char *db, const char *path, const char *wild, bool dir, List< LEX_STRING > *files)
Definition: handler.h:1670
bool(* redo_log_set_state_t)(THD *thd, bool enable)
Enable or Disable SE write ahead logging.
Definition: handler.h:2095
void ha_post_recover()
Perform SE-specific cleanup after recovery of transactions.
Definition: handler.cc:8980
void(* acl_notify_t)(THD *thd, const class Acl_change_notification *notice)
Definition: handler.h:1664
constexpr const decltype(handlerton::flags) HTON_SUPPORTS_BULK_LOAD
Definition: handler.h:3132
int(*)(handlerton *hton, THD *thd, const uchar *loc, uint loc_len, uint task_id, int in_err, Ha_clone_cbk *cbk) Clone_apply_t
Apply data to destination database in chunks via callback.
Definition: handler.h:2258
TYPELIB tx_isolation_typelib
Definition: handler.cc:302
handlerton * ha_default_temp_handlerton(THD *thd)
Return the default storage engine handlerton used for explicitly created temp tables for a thread.
Definition: handler.cc:379
bool(* collect_hton_log_info_t)(handlerton *hton, Json_dom *json)
Collect a handlerton (resource) log information.
Definition: handler.h:2326
int(*)(handlerton *hton, THD *thd) set_prepared_in_tc_t
Instructs the storage engine to mark the externally coordinated transactions held by the THD paramete...
Definition: handler.h:1418
void ha_reset_slave(THD *thd)
Definition: handler.cc:5988
void ha_end()
Definition: handler.cc:923
static enum legacy_db_type ha_legacy_type(const handlerton *db_type)
Definition: handler.h:7490
int(*)(handlerton *hton, THD *thd, const uchar *loc, uint loc_len, uint task_id, int in_err) Clone_end_t
End copy from source database.
Definition: handler.h:2231
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
Definition: handler.cc:2458
static const uint MYSQL_START_TRANS_OPT_READ_WRITE
Definition: handler.h:646
bool ha_log_ddl_drop_schema(const char *schema_name)
Call "log_ddl_drop_schema" handletron for storage engines who implement it.
Definition: handler.cc:956
int(*)(uint64_t *stop_id) page_track_stop_t
Stop page tracking.
Definition: handler.h:2676
bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
Definition: handler.cc:7859
bool(* unlock_hton_log_t)(handlerton *hton)
Unlock a handlerton (resource) log after collecting log information.
Definition: handler.h:2320
constexpr const uint64_t HA_CREATE_USED_ENGINE_ATTRIBUTE
Definition: handler.h:799
int(*)(Page_Track_Callback cbk_func, void *cbk_ctx, uint64_t *start_id, uint64_t *stop_id, unsigned char *buffer, size_t buffer_len) page_track_get_page_ids_t
Fetch tracked pages.
Definition: handler.h:2715
plugin_ref ha_resolve_by_name_raw(THD *thd, const LEX_CSTRING &name)
Resolve handlerton plugin by name, without checking for "DEFAULT" or HTON_NOT_USER_SELECTABLE.
Definition: handler.cc:396
constexpr const decltype(handlerton::flags) HTON_SUPPORTS_DISTANCE_SCAN
Engine supports index distance scan.
Definition: handler.h:3135
void ha_binlog_index_purge_wait(THD *thd)
Request the storage engine to complete any operations that were initiated by ha_binlog_index_purge_fi...
Definition: handler.cc:6004
#define HA_ADMIN_NOT_IMPLEMENTED
Definition: handler.h:180
bool(* is_supported_system_table_t)(const char *db, const char *table_name, bool is_sql_layer_system_table)
Check if the given db.tablename is a system table for this SE.
Definition: handler.h:1711
bool ha_rm_tmp_tables(THD *thd, List< LEX_STRING > *files)
Ask all SEs to drop all temporary tables which have been left from previous server run.
Definition: handler.cc:5693
bool(*)(THD *thd, LEX *lex) prepare_secondary_engine_t
Prepare the secondary engine for executing a statement.
Definition: handler.h:2359
#define HA_CAN_REPAIR
Definition: handler.h:379
bool ha_check_if_supported_system_table(handlerton *hton, const char *db, const char *table_name)
Check if a given table is a system table.
Definition: handler.cc:5573
int ha_commit_attachable(THD *thd)
Commit the attachable transaction in storage engines.
Definition: handler.cc:2221
bool ha_secondary_engine_supports_ddl(THD *thd, const LEX_CSTRING &secondary_engine) noexcept
Definition: handler.cc:446
xa_status_code(*)(handlerton *hton, XID *xid) set_prepared_in_tc_by_xid_t
Instructs the storage engine to mark the externally coordinated transactions identified by the XID pa...
Definition: handler.h:1478
int(* close_connection_t)(handlerton *hton, THD *thd)
close_connection is only called if thd->ha_data[xxx_hton.slot] is non-zero, so even if you don't need...
Definition: handler.h:1351
const char * tx_isolation_names[]
Definition: handler.cc:300
int check_table_for_old_types(const TABLE *table)
Function identifies any old data type present in table.
Definition: handler.cc:4699
TYPELIB * ha_known_exts()
Definition: handler.cc:7814
bool(* sdi_create_t)(dd::Tablespace *tablespace)
Create SDI in a tablespace.
Definition: handler.h:1722
bool(* dict_init_t)(dict_init_mode_t dict_init_mode, uint version, List< const Plugin_table > *DDSE_tables, List< const Plugin_tablespace > *DDSE_tablespaces)
Initialize the SE for being used to store the DD tables.
Definition: handler.h:1898
int(* panic_t)(handlerton *hton, enum ha_panic_function flag)
Definition: handler.h:1501
constexpr const uint64_t HA_CREATE_USED_SECONDARY_ENGINE_ATTRIBUTE
Definition: handler.h:800
static bool ha_check_storage_engine_flag(const handlerton *db_type, uint32 flag)
Definition: handler.h:7496
int ha_prepare_low(THD *thd, bool all)
Prepares the underlying transaction of the THD session object parameter in the storage engines that p...
Definition: handler.cc:2371
ha_ddl_type
Definition: handler.h:943
@ HA_TRUNCATE_DDL
Definition: handler.h:946
@ HA_INVALID_DDL
Definition: handler.h:944
@ HA_ALTER_DDL
Definition: handler.h:945
@ HA_RENAME_DDL
Definition: handler.h:947
int ha_init_key_cache(std::string_view name, KEY_CACHE *key_cache)
Init a key cache if it has not been initied before.
Definition: handler.cc:5750
uint64_t SecondaryEngineFlags
Definition: handler.h:2546
int(* finish_upgrade_t)(THD *thd, bool failed_upgrade)
Finish upgrade process inside storage engines.
Definition: handler.h:1606
void(*)(std::vector< std::pair< uint64_t, bool > > &status) page_track_get_status_t
Fetch the status of the page tracking system.
Definition: handler.h:2742
bool(* rm_tmp_tables_t)(handlerton *hton, THD *thd, List< LEX_STRING > *files)
Drop all temporary tables which have been left from previous server run belonging to this SE.
Definition: handler.h:1820
static const uint32 HTON_FKS_WITH_SUPPORTING_HASH_KEYS
Storage engine supports hash keys as supporting keys for foreign keys.
Definition: handler.h:3175
static const uint MYSQL_START_TRANS_OPT_HIGH_PRIORITY
Definition: handler.h:648
int ha_binlog_index_purge_file(THD *thd, const char *file)
Inform storage engine(s) that a binary log file will be purged and any references to it should be rem...
Definition: handler.cc:5998
#define HTON_SECONDARY_ENGINE_SUPPORTS_DDL
Whether the secondary engine supports DDLs.
Definition: handler.h:3119
bool(* get_index_column_cardinality_t)(const char *db_name, const char *table_name, const char *index_name, uint index_ordinal_position, uint column_ordinal_position, dd::Object_id se_private_id, ulonglong *cardinality)
Retrieve index column cardinality from SE.
Definition: handler.h:2155
bool default_rm_tmp_tables(handlerton *hton, THD *thd, List< LEX_STRING > *files)
Default implementation for handlerton::rm_tmp_tables() method which simply removes all files from "fi...
Definition: handler.cc:5705
enum_alter_inplace_result
Return values for check_if_supported_inplace_alter().
Definition: handler.h:202
@ HA_ALTER_INPLACE_NOT_SUPPORTED
Definition: handler.h:204
@ HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE
Definition: handler.h:208
@ HA_ALTER_INPLACE_INSTANT
Definition: handler.h:210
@ HA_ALTER_INPLACE_SHARED_LOCK
Definition: handler.h:207
@ HA_ALTER_INPLACE_NO_LOCK
Definition: handler.h:209
@ HA_ALTER_INPLACE_EXCLUSIVE_LOCK
Definition: handler.h:205
@ HA_ALTER_ERROR
Definition: handler.h:203
@ HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE
Definition: handler.h:206
constexpr const decltype(handlerton::flags) HTON_SUPPORTS_ENGINE_ATTRIBUTE
Definition: handler.h:3108
bool Log_func(THD *, TABLE *, bool, const uchar *, const uchar *)
Definition: handler.h:7581
void(*)(struct HA_CREATE_INFO *create_info, const char *db, const char *table_name) notify_create_table_t
Notify plugins when a table is created.
Definition: handler.h:2615
static const uint MYSQL_START_TRANS_OPT_READ_ONLY
Definition: handler.h:644
void(* kill_connection_t)(handlerton *hton, THD *thd)
Terminate connection/statement notification.
Definition: handler.h:1354
uint calculate_key_len(TABLE *table, uint key, key_part_map keypart_map)
Calculates length of key.
Definition: handler.cc:7768
int(* prepare_t)(handlerton *hton, THD *thd, bool all)
Definition: handler.h:1403
bool(* sdi_drop_t)(dd::Tablespace *tablespace)
Drop SDI in a tablespace.
Definition: handler.h:1731
void print_keydup_error(TABLE *table, KEY *key, const char *msg, myf errflag, const char *org_table_name)
Construct and emit duplicate key error message using information from table's record buffer.
Definition: handler.cc:4205
int ha_init(void)
Definition: handler.cc:908
int(* alter_tablespace_t)(handlerton *hton, THD *thd, st_alter_tablespace *ts_info, const dd::Tablespace *old_ts_def, dd::Tablespace *new_ts_def)
Create/drop or alter tablespace in the storage engine.
Definition: handler.h:1561
int ha_enable_transaction(THD *thd, bool on)
Tell the storage engine that it is allowed to "disable transaction" in the handler.
Definition: handler.cc:5259
bool secondary_engine_supports_ddl(const handlerton *hton)
Definition: handler.h:3142
Ha_clone_type
Clone operation types.
Definition: handler.h:969
@ HA_CLONE_BLOCKING
Caller must block all write operation to the SE.
Definition: handler.h:971
@ HA_CLONE_RESTART
SE supports restarting clone after network failure.
Definition: handler.h:987
@ HA_CLONE_HYBRID
For transactional SE, use both page tracking and redo to optimize clone with concurrent dml.
Definition: handler.h:981
@ HA_CLONE_MULTI_TASK
SE supports multiple threads for clone.
Definition: handler.h:984
@ HA_CLONE_TYPE_MAX
Maximum value of clone type.
Definition: handler.h:990
@ HA_CLONE_PAGE
For transactional SE, track page changes to support concurrent dml.
Definition: handler.h:977
@ HA_CLONE_REDO
For transactional SE, archive redo to support concurrent dml.
Definition: handler.h:974
enum_schema_tables
Definition: handler.h:924
@ SCH_OPTIMIZER_TRACE
Definition: handler.h:929
@ SCH_ENGINES
Definition: handler.h:927
@ SCH_TABLE_PRIVILEGES
Definition: handler.h:934
@ SCH_COLUMN_PRIVILEGES
Definition: handler.h:926
@ SCH_SCHEMA_PRIVILEGES
Definition: handler.h:933
@ SCH_PLUGINS
Definition: handler.h:930
@ SCH_PROFILES
Definition: handler.h:932
@ SCH_LAST
Definition: handler.h:938
@ SCH_TMP_TABLE_KEYS
Definition: handler.h:937
@ SCH_USER_PRIVILEGES
Definition: handler.h:935
@ SCH_PROCESSLIST
Definition: handler.h:931
@ SCH_OPEN_TABLES
Definition: handler.h:928
@ SCH_TMP_TABLE_COLUMNS
Definition: handler.h:936
@ SCH_FIRST
Definition: handler.h:925
constexpr const uint64_t HA_CREATE_USED_AUTOEXTEND_SIZE
These flags convey that the options AUTOEXTEND_SIZE has been specified in the CREATE TABLE statement.
Definition: handler.h:813
bool(* get_tablespace_type_by_name_t)(const char *tablespace_name, Tablespace_type *space_type)
Get the tablespace type given the name, from the SE.
Definition: handler.h:1650
bool ha_check_if_table_exists(THD *thd, const char *db, const char *name, bool *exists)
Try to find a table in a storage engine.
Definition: handler.cc:5510
void(*)(void *arg) se_after_commit_t
Definition: handler.h:2594
std::vector< sdi_key_t > sdi_container
Definition: handler.h:138
st_plugin_int * hton2plugin(uint slot)
Maps from slot to plugin. May return NULL if plugin has been unloaded.
Definition: handler.cc:241
st_plugin_int * insert_hton2plugin(uint slot, st_plugin_int *plugin)
For unit testing.
Definition: handler.cc:245
SecondaryEngineFlag
Definition: handler.h:2547
@ USE_EXTERNAL_EXECUTOR
This flag can be set to signal that a secondary storage engine will not use MySQL's executor (see JOI...
void ha_pre_dd_shutdown(void)
Invoke handlerton::pre_dd_shutdown() on every storage engine plugin.
Definition: handler.cc:1055
void get_sweep_read_cost(TABLE *table, ha_rows nrows, bool interrupted, Cost_estimate *cost)
Get cost of reading nrows table records in a "disk sweep".
Definition: handler.cc:7406
constexpr const decltype(handlerton::flags) HTON_SUPPORTS_GENERATED_INVISIBLE_PK
Engine supports Generated invisible primary key.
Definition: handler.h:3114
bool(* get_tablespace_type_t)(const dd::Tablespace &space, Tablespace_type *space_type)
Get the tablespace type from the SE.
Definition: handler.h:1638
bool(* rotate_encryption_master_key_t)(void)
Initiate master key rotation.
Definition: handler.h:2084
void(* post_recover_t)(void)
Perform SE-specific cleanup after recovery of transactions.
Definition: handler.h:2308
bool(* notify_rename_table_t)(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type, const char *old_db_name, const char *old_table_name, const char *new_db_name, const char *new_table_name)
Notify/get permission from storage engine before or after execution of RENAME TABLE operation on the ...
Definition: handler.h:2057
int ha_commit_trans(THD *thd, bool all, bool ignore_global_read_lock=false)
Definition: handler.cc:1684
#define HTON_IS_SECONDARY_ENGINE
Engine is a secondary storage engine.
Definition: handler.h:3100
int(* start_consistent_snapshot_t)(handlerton *hton, THD *thd)
Definition: handler.h:1503
enum_stats_auto_recalc
Definition: handler.h:3229
@ HA_STATS_AUTO_RECALC_DEFAULT
Definition: handler.h:3230
@ HA_STATS_AUTO_RECALC_OFF
Definition: handler.h:3232
@ HA_STATS_AUTO_RECALC_ON
Definition: handler.h:3231
const char *(* get_tablespace_filename_ext_t)()
SE interface for getting tablespace extension.
Definition: handler.h:1570
ts_alter_tablespace_type
Definition: handler.h:856
@ TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED
Definition: handler.h:857
@ ALTER_UNDO_TABLESPACE_SET_ACTIVE
Definition: handler.h:862
@ ALTER_UNDO_TABLESPACE_SET_INACTIVE
Definition: handler.h:863
@ ALTER_TABLESPACE_OPTIONS
Definition: handler.h:861
@ ALTER_TABLESPACE_DROP_FILE
Definition: handler.h:859
@ ALTER_TABLESPACE_RENAME
Definition: handler.h:860
@ ALTER_TABLESPACE_ADD_FILE
Definition: handler.h:858
void(* binlog_log_query_t)(handlerton *hton, THD *thd, enum_binlog_command binlog_command, const char *query, uint query_length, const char *db, const char *table_name)
Definition: handler.h:1659
xa_status_code(* commit_by_xid_t)(handlerton *hton, XID *xid)
Definition: handler.h:1468
bool is_index_access_error(int error)
Check whether an error is index access error or not after an index read.
Definition: handler.cc:9091
plugin_ref ha_resolve_by_name(THD *thd, const LEX_CSTRING *name, bool is_temp_table)
Return the storage engine handlerton for the supplied name.
Definition: handler.cc:411
void(* replace_native_transaction_in_thd_t)(THD *thd, void *new_trx_arg, void **ptr_trx_arg)
Definition: handler.h:1862
constexpr const uint64_t HA_CREATE_USED_READ_ONLY
ALTER SCHEMA|DATABASE has an explicit READ_ONLY clause.
Definition: handler.h:807
bool(* sdi_delete_t)(const dd::Tablespace &tablespace, const dd::Table *table, const sdi_key_t *sdi_key)
Delete SDI for a given SDI key.
Definition: handler.h:1796
std::string_view(*)(THD *thd) find_secondary_engine_offload_fail_reason_t
Finds and returns a specific secondary engine query offload failure reason as a string given a thread...
Definition: handler.h:2486
bool(* get_tablespace_statistics_t)(const char *tablespace_name, const char *file_name, const dd::Properties &ts_se_private_data, ha_tablespace_statistics *stats)
Retrieve ha_tablespace_statistics from SE.
Definition: handler.h:2175
SecondaryEngineGraphSimplificationRequest
Definition: handler.h:2502
@ kRestart
Trigger restart of hypergraph with provided number of subgraph pairs.
@ kContinue
Continue optimization phase with current hypergraph.
int(* discover_t)(handlerton *hton, THD *thd, const char *db, const char *name, uchar **frmblob, size_t *frmlen)
Definition: handler.h:1667
ulong total_ha_2pc
Definition: handler.cc:271
int(* table_exists_in_engine_t)(handlerton *hton, THD *thd, const char *db, const char *name)
Definition: handler.h:1674
enum_binlog_command
Definition: handler.h:707
@ LOGCOM_DROP_TABLE
Definition: handler.h:711
@ LOGCOM_CREATE_DB
Definition: handler.h:712
@ LOGCOM_DROP_DB
Definition: handler.h:714
@ LOGCOM_RENAME_TABLE
Definition: handler.h:710
@ LOGCOM_ALTER_TABLE
Definition: handler.h:709
@ LOGCOM_ALTER_DB
Definition: handler.h:713
@ LOGCOM_CREATE_TABLE
Definition: handler.h:708
static const uint32 HTON_FKS_NEED_DIFFERENT_PARENT_AND_SUPPORTING_KEYS
Storage engine does not support using the same key for both parent and supporting key,...
Definition: handler.h:3195
bool set_tx_isolation(THD *thd, enum_tx_isolation tx_isolation, bool one_shot)
Set the transaction isolation level for the next transaction and update session tracker information a...
Definition: handler.cc:8935
bool ha_is_storage_engine_disabled(handlerton *se_engine)
Definition: handler.cc:520
const char * ha_row_type[]
Definition: handler.cc:289
bool ha_notify_table_ddl(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type, ha_ddl_type ddl_type, const char *old_db_name, const char *old_table_name, const char *new_db_name, const char *new_table_name)
Notify/get permission from all interested storage engines before or after executed DDL (ALTER TABLE,...
Definition: handler.cc:8903
handlerton * ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)
Definition: handler.cc:556
std::string_view(*)(const THD *thd) get_secondary_engine_offload_or_exec_fail_reason_t
Looks up and returns a specific secondary engine query offload or exec failure reason as a string giv...
Definition: handler.h:2474
std::optional< ha_column_statistics >(* get_column_statistics_t)(THD *thd, const char *db_name, const char *table_name, const char *column_name, double rows_in_table)
Retrieve column_statistics from SE.
Definition: handler.h:2132
handler * get_new_handler(TABLE_SHARE *share, bool partitioned, MEM_ROOT *alloc, handlerton *db_type)
Create handler object for the table in the storage engine.
Definition: handler.cc:612
std::atomic< const char * > default_secondary_engine_name
Store the name of default secondary engine, if any.
Definition: handler.cc:8998
#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION
Definition: handler.h:299
enum_tx_isolation
Definition: handler.h:3222
@ ISO_READ_UNCOMMITTED
Definition: handler.h:3223
@ ISO_REPEATABLE_READ
Definition: handler.h:3225
@ ISO_READ_COMMITTED
Definition: handler.h:3224
@ ISO_SERIALIZABLE
Definition: handler.h:3226
bool(* notify_truncate_table_t)(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type)
Notify/get permission from storage engine before or after execution of TRUNCATE TABLE operation on th...
Definition: handler.h:2074
void(* pre_dd_shutdown_t)(handlerton *hton)
Shut down all storage engine background tasks that might access the data dictionary,...
Definition: handler.h:1360
const char * ha_resolve_storage_engine_name(const handlerton *db_type)
Definition: handler.cc:258
bool(* flush_logs_t)(handlerton *hton, bool binlog_group_flush)
Flush the log(s) of storage engine(s).
Definition: handler.h:1514
bool ha_check_reserved_db_name(const char *name)
Check if the database name is reserved word used by SE.
Definition: handler.cc:9074
const char * table_case_name(const HA_CREATE_INFO *info, const char *name)
Definition: handler.cc:4188
const char * get_canonical_filename(handler *file, const char *path, char *tmp_path)
make canonical filename
Definition: handler.cc:2553
bool(* dict_set_server_version_t)()
Store the current server version number into the header of the dictionary tablespace.
Definition: handler.h:1975
bool(* log_ddl_create_schema_t)(handlerton *hton, const char *schema_name)
Definition: handler.h:1498
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
Definition: handler.cc:2307
int(*)(THD *thd, AccessPath *query, JOIN *join) push_to_engine_t
Let storage engine inspect the query Accesspath and pick whatever it like for being pushed down to th...
Definition: handler.h:1694
int ha_panic(enum ha_panic_function flag)
int(* commit_t)(handlerton *hton, THD *thd, bool all)
'all' is true if it's a real commit, that makes persistent changes 'all' is false if it's not in fact...
Definition: handler.h:1399
int ha_recover(Xid_commit_list *commit_list=nullptr, Xa_state_list *xa_state_list=nullptr)
Stage of the recovery process where information is collected from the storage engines (SE),...
Definition: xa.cc:270
int ha_delete_table(THD *thd, handlerton *db_type, const char *path, const char *db, const char *alias, const dd::Table *table_def, bool generate_warning)
Delete table from the storage engine.
Definition: handler.cc:2600
static const uint32 HTON_FKS_WITH_EXTENDED_PARENT_KEYS
Engine takes into account hidden part of key (coming from primary key) when determines if it can serv...
Definition: handler.h:3206
row_type
Definition: handler.h:686
@ ROW_TYPE_COMPRESSED
Definition: handler.h:691
@ ROW_TYPE_REDUNDANT
Definition: handler.h:692
@ ROW_TYPE_NOT_USED
Definition: handler.h:687
@ ROW_TYPE_FIXED
Definition: handler.h:689
@ ROW_TYPE_PAGED
Unused.
Definition: handler.h:695
@ ROW_TYPE_DEFAULT
Definition: handler.h:688
@ ROW_TYPE_COMPACT
Definition: handler.h:693
@ ROW_TYPE_DYNAMIC
Definition: handler.h:690
bool() stat_print_fn(THD *thd, const char *type, size_t type_len, const char *file, size_t file_len, const char *status, size_t status_len)
Definition: handler.h:146
void ha_drop_database(const char *schema_name)
Call the "drop_database_t" handlerton API for storage engines that implemented it to drop the databas...
Definition: handler.cc:937
const handlerton * SecondaryEngineHandlerton(const THD *thd)
Returns the handlerton of the secondary engine that is used in the session, or nullptr if a secondary...
Definition: handler.cc:8991
static const LEX_CSTRING FK_NAME_DEFAULT_SUFFIX
Suffix for auto-generated foreign key names for tables in SE's which don't specify own suffix.
Definition: handler.h:3220
handlerton * ha_default_handlerton(THD *thd)
Return the default storage engine handlerton used for non-temp tables for thread.
Definition: handler.cc:355
int ha_savepoint(THD *thd, SAVEPOINT *sv)
Definition: handler.cc:2415
void(*)(THD *thd, SelectExecutedIn executed_in) notify_after_select_t
Notify plugins when a SELECT query was executed.
Definition: handler.h:2609
void ha_close_connection(THD *thd)
Definition: handler.cc:1012
int(*)(handlerton *hton, THD *thd, const uchar *&loc, uint &loc_len, uint &task_id, Ha_clone_type type, Ha_clone_mode mode) Clone_begin_t
Begin copy from source database.
Definition: handler.h:2196
int(* upgrade_logs_t)(THD *thd)
Upgrade logs after the checkpoint from where upgrade process can only roll forward.
Definition: handler.h:1618
bool(* is_reserved_db_name_t)(handlerton *hton, const char *name)
Definition: handler.h:2345
int(* savepoint_rollback_t)(handlerton *hton, THD *thd, void *sv)
sv points to a storage area, that was earlier passed to the savepoint_set call
Definition: handler.h:1373
void(*)(Ha_clone_flagset &flags) Clone_capability_t
Get capability flags for clone operation.
Definition: handler.h:2183
int ha_binlog_end(THD *thd)
Definition: handler.cc:6050
bool(*)(THD *thd) secondary_engine_pre_prepare_hook_t
Secondary engine hook called after PRIMARY_TENTATIVELY optimization is complete, and decides if secon...
Definition: handler.h:2628
void(*)(Table_ref *tab) notify_drop_table_t
Notify plugins when a table is dropped.
Definition: handler.h:2643
const char * binlog_format_names[]
Definition: mysqld.cc:1338
constexpr const uint64_t HA_CREATE_USED_START_TRANSACTION
This option is used to convey that the create table should not commit the operation and keep the tran...
Definition: handler.h:797
int(*)(uint64_t *start_id, uint64_t *stop_id, uint64_t *num_pages) page_track_get_num_page_ids_t
Fetch approximate number of tracked pages in the given range.
Definition: handler.h:2736
int(*)(handlerton *hton, THD *thd, const uchar *loc, uint loc_len, uint task_id, Ha_clone_cbk *cbk) Clone_copy_t
Copy data from source database in chunks via callback.
Definition: handler.h:2207
xa_status_code
X/Open XA distributed transaction status codes.
Definition: handler.h:1421
@ XAER_ASYNC
asynchronous operation already outstanding
Definition: handler.h:1430
@ XAER_PROTO
routine invoked in an improper context
Definition: handler.h:1450
@ XAER_INVAL
invalid arguments were given
Definition: handler.h:1445
@ XAER_NOTA
the XID is not valid
Definition: handler.h:1440
@ XAER_OUTSIDE
resource manager doing work outside transaction
Definition: handler.h:1465
@ XAER_RMFAIL
resource manager unavailable
Definition: handler.h:1455
@ XA_OK
normal execution
Definition: handler.h:1425
@ XAER_DUPID
the XID already exists
Definition: handler.h:1460
@ XAER_RMERR
a resource manager error occurred in the transaction branch
Definition: handler.h:1435
void ha_binlog_wait(THD *thd)
Definition: handler.cc:5993
bool(* dict_get_server_version_t)(uint *version)
Get the server version id stored in the header of the dictionary tablespace.
Definition: handler.h:1967
void ha_reset_plugin_vars(THD *thd)
Definition: handler.cc:1003
int ha_start_consistent_snapshot(THD *thd)
Definition: handler.cc:2499
constexpr const uint32 SDI_TYPE_TABLESPACE
Id for identifying Tablespace SDIs.
Definition: handler.h:127
int(*)(handlerton *hton, THD *thd, const uchar *loc, uint loc_len, uint task_id, int in_err, Ha_clone_cbk *cbk) Clone_ack_t
Acknowledge data transfer to source database.
Definition: handler.h:2220
bool(*)(THD *thd, const JoinHypergraph &hypergraph, AccessPath *access_path) secondary_engine_modify_view_ap_cost_t
Evaluates/Views the cost of executing the given access path in the secondary storage engine,...
Definition: handler.h:2450
bool(* is_valid_tablespace_name_t)(ts_command_type ts_cmd, const char *tablespace_name)
SE specific validation of the tablespace name.
Definition: handler.h:1540
int ha_table_exists_in_engine(THD *thd, const char *db, const char *name)
Definition: handler.cc:5924
int(* upgrade_tablespace_t)(THD *thd)
Get the tablespace data from SE and insert it into Data dictionary.
Definition: handler.h:1581
bool(* notify_exclusive_mdl_t)(THD *thd, const MDL_key *mdl_key, ha_notification_type notification_type, bool *victimized)
Notify/get permission from storage engine before acquisition or after release of exclusive metadata l...
Definition: handler.h:2008
int ha_commit_low(THD *thd, bool all, bool run_after_commit=true)
Commit the sessions outstanding transaction.
Definition: handler.cc:1957
uint(* partition_flags_t)()
The flag values are defined in sql_partition.h.
Definition: handler.h:1526
bool ha_flush_logs(bool binlog_group_flush=false)
Flush the log(s) of storage engine(s).
Definition: handler.cc:2523
dict_recovery_mode_t
Mode for data dictionary recovery.
Definition: handler.h:1934
@ DICT_RECOVERY_RESTART_SERVER
Restart of an existing server.
Definition: handler.h:1937
@ DICT_RECOVERY_INITIALIZE_TABLESPACES
First start, create tablespaces.
Definition: handler.h:1936
@ DICT_RECOVERY_INITIALIZE_SERVER
First start of a new server.
Definition: handler.h:1935
bool(* sdi_get_keys_t)(const dd::Tablespace &tablespace, sdi_vector_t &vector)
Get the SDI keys in a tablespace into vector.
Definition: handler.h:1740
ulong savepoint_alloc_size
Definition: handler.cc:273
int(* fill_is_table_t)(handlerton *hton, THD *thd, Table_ref *tables, class Item *cond, enum enum_schema_tables)
Definition: handler.h:1653
int(* binlog_func_t)(handlerton *hton, THD *thd, enum_binlog_func fn, void *arg)
Definition: handler.h:1656
int ha_create_table_from_engine(THD *thd, const char *db, const char *name)
Try to discover table from engine.
Definition: handler.cc:5430
enum_binlog_func
Definition: handler.h:698
@ BFN_BINLOG_WAIT
Definition: handler.h:701
@ BFN_BINLOG_PURGE_WAIT
Definition: handler.h:704
@ BFN_BINLOG_END
Definition: handler.h:702
@ BFN_RESET_SLAVE
Definition: handler.h:700
@ BFN_BINLOG_PURGE_FILE
Definition: handler.h:703
@ BFN_RESET_LOGS
Definition: handler.h:699
void set_externally_disabled_storage_engine_names(const char *)
Read a comma-separated list of storage engine names.
Definition: handler.cc:469
void(*)(void *arg) se_before_commit_t
Definition: handler.h:2590
int(* rollback_t)(handlerton *hton, THD *thd, bool all)
Definition: handler.h:1401
void(* dict_cache_reset_t)(const char *schema_name, const char *table_name)
Invalidate an entry in the local dictionary cache.
Definition: handler.h:1922
bool ha_rollback_to_savepoint_can_release_mdl(THD *thd)
Check if all storage engines used in transaction agree that after rollback to savepoint it is safe to...
Definition: handler.cc:2284
int binlog_log_row(TABLE *table, const uchar *before_record, const uchar *after_record, Log_func *log_func)
Definition: handler.cc:8044
void * range_seq_t
Definition: handler.h:3850
int ha_init_errors(void)
Register handler error messages for use with my_error().
Definition: handler.cc:647
bool(*)(THD *thd, const JOIN &join, double optimizer_cost, bool *use_best_so_far, bool *cheaper, double *secondary_engine_cost) compare_secondary_engine_cost_t
Compares the cost of two join plans in the secondary storage engine.
Definition: handler.h:2396
handlerton * get_default_handlerton(THD *thd, handlerton *hton)
Get default handlerton, if handler supplied is null.
Definition: handler.h:7482
int ha_rollback_trans(THD *thd, bool all)
Definition: handler.cc:2120
constexpr const ha_rows EXTRA_RECORDS
Definition: handler.h:121
void(*)(THD *thd, JoinHypergraph *graph) cardinality_estimation_hook_t
Hook used to estimate the cardinality of table Node objects in the JoinHypergraph.
Definition: handler.h:2638
enum_sampling_method
Definition: handler.h:717
int ha_reset_logs(THD *thd)
Definition: handler.cc:5982
bool ha_storage_engine_is_enabled(const handlerton *db_type)
Predicate to determine if a storage engine, represented by a handlerton*, is enabled.
Definition: handler.h:7510
dict_init_mode_t
Mode for initializing the data dictionary.
Definition: handler.h:1866
@ DICT_INIT_CREATE_FILES
Create all required SE files.
Definition: handler.h:1867
@ DICT_INIT_CHECK_FILES
Verify existence of expected files.
Definition: handler.h:1868
bool(* check_fk_column_compat_t)(const Ha_fk_column_type *child_column_type, const Ha_fk_column_type *parent_column_type, bool check_charsets)
Check SE considers types of child and parent columns in foreign key to be compatible.
Definition: handler.h:2341
constexpr SecondaryEngineFlags MakeSecondaryEngineFlags()
Creates an empty bitmap of access path types.
Definition: handler.h:2567
bool ha_is_externally_disabled(const handlerton &)
Returns true if the storage engine of the handlerton argument has been listed in the disabled_storage...
Definition: handler.cc:513
int(*)(handlerton *hton, Xa_state_list &xa_list) recover_prepared_in_tc_t
Retrieves information about externally coordinated transactions for which the two-phase prepare was f...
Definition: handler.h:1413
static const uint32 HTON_FKS_WITH_PREFIX_PARENT_KEYS
Engine supports both unique and non-unique parent keys for foreign keys which contain full foreign ke...
Definition: handler.h:3164
void(* dict_cache_reset_tables_and_tablespaces_t)()
Invalidate all table and tablespace entries in the local dictionary cache.
Definition: handler.h:1931
#define HA_NO_TRANSACTIONS
Definition: handler.h:220
void(* post_ddl_t)(THD *thd)
Perform post-commit/rollback cleanup after DDL statement (e.g.
Definition: handler.h:2299
bool ddl_is_atomic(const handlerton *hton)
Definition: handler.h:3148
const handlerton * EligibleSecondaryEngineHandlerton(THD *thd, const LEX_CSTRING *secondary_engine_in_name)
Returns the handlerton of the eligible secondary engine that is used in the session,...
Definition: handler.cc:9009
ulonglong my_xid
Definition: handler.h:1237
legacy_db_type
Definition: handler.h:650
@ DB_TYPE_MARIA
Definition: handler.h:678
@ DB_TYPE_FEDERATED_DB
Definition: handler.h:669
@ DB_TYPE_GEMINI
Definition: handler.h:664
@ DB_TYPE_FIRST_DYNAMIC
Definition: handler.h:682
@ DB_TYPE_MISAM
Definition: handler.h:654
@ DB_TYPE_HEAP
Definition: handler.h:657
@ DB_TYPE_TABLE_FUNCTION
Definition: handler.h:675
@ DB_TYPE_DIAB_ISAM
Definition: handler.h:652
@ DB_TYPE_TEMPTABLE
Definition: handler.h:681
@ DB_TYPE_HASH
Definition: handler.h:653
@ DB_TYPE_PARTITION_DB
Definition: handler.h:671
@ DB_TYPE_BINLOG
Definition: handler.h:672
@ DB_TYPE_SOLID
Definition: handler.h:673
@ DB_TYPE_UNKNOWN
Definition: handler.h:651
@ DB_TYPE_ISAM
Definition: handler.h:658
@ DB_TYPE_MRG_MYISAM
Definition: handler.h:661
@ DB_TYPE_PERFORMANCE_SCHEMA
Performance schema engine.
Definition: handler.h:680
@ DB_TYPE_EXAMPLE_DB
Definition: handler.h:666
@ DB_TYPE_CSV_DB
Definition: handler.h:668
@ DB_TYPE_NDBCLUSTER
Definition: handler.h:665
@ DB_TYPE_INNODB
Definition: handler.h:663
@ DB_TYPE_FALCON
Definition: handler.h:677
@ DB_TYPE_DEFAULT
Definition: handler.h:683
@ DB_TYPE_BLACKHOLE_DB
Definition: handler.h:670
@ DB_TYPE_MYISAM
Definition: handler.h:660
@ DB_TYPE_RMS_ISAM
Definition: handler.h:656
@ DB_TYPE_BERKELEY_DB
Definition: handler.h:662
@ DB_TYPE_MRG_ISAM
Definition: handler.h:659
@ DB_TYPE_PBXT
Definition: handler.h:674
@ DB_TYPE_PISAM
Definition: handler.h:655
@ DB_TYPE_ARCHIVE_DB
Definition: handler.h:667
@ DB_TYPE_MEMCACHE
Definition: handler.h:676
int ha_initialize_handlerton(st_plugin_int *plugin)
Definition: handler.cc:782
ha_notification_type
Definition: handler.h:942
@ HA_NOTIFY_POST_EVENT
Definition: handler.h:942
@ HA_NOTIFY_PRE_EVENT
Definition: handler.h:942
bool(* upgrade_space_version_t)(dd::Tablespace *tablespace)
Get the tablespace data from SE and insert it into Data dictionary.
Definition: handler.h:1592
Tablespace_type
Definition: handler.h:1620
xa_status_code(* rollback_by_xid_t)(handlerton *hton, XID *xid)
Definition: handler.h:1470
SelectExecutedIn
Used to identify which engine executed a SELECT query.
Definition: handler.h:216
void ha_binlog_log_query(THD *thd, handlerton *db_type, enum_binlog_command binlog_command, const char *query, size_t query_length, const char *db, const char *table_name)
Definition: handler.cc:6033
handler *(* create_t)(handlerton *hton, TABLE_SHARE *table, bool partitioned, MEM_ROOT *mem_root)
Create handler object for the table in the storage engine.
Definition: handler.h:1490
void ha_acl_notify(THD *thd, class Acl_change_notification *)
Definition: handler.cc:6064
SE_cost_constants *(* get_cost_constants_t)(uint storage_category)
Retrieve cost constants to be used for this storage engine.
Definition: handler.h:1847
static bool commit(THD *thd)
Commit the current statement and transaction.
Definition: sql_cmd_srs.cc:152
File containing constants that can be used throughout the server.
SHOW_COMP_OPTION
Definition: sql_const.h:230
@ SHOW_OPTION_YES
Definition: sql_const.h:230
constexpr const unsigned int MAX_KEY
Definition: sql_const.h:45
constexpr const unsigned int MAX_REF_PARTS
Definition: sql_const.h:46
constexpr const unsigned int MAX_KEY_LENGTH
Definition: sql_const.h:47
case opt name
Definition: sslopt-case.h:29
#define STRING_WITH_LEN(X)
Definition: string_with_len.h:29
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:238
Callbacks for collecting time statistics.
Definition: bulk_data_service.h:840
Definition: m_ctype.h:421
Definition: handler.h:2271
Clone_apply_t clone_apply
Definition: handler.h:2283
Clone_end_t clone_end
Definition: handler.h:2279
Clone_capability_t clone_capability
Definition: handler.h:2273
Clone_apply_begin_t clone_apply_begin
Definition: handler.h:2282
Clone_begin_t clone_begin
Definition: handler.h:2276
Clone_copy_t clone_copy
Definition: handler.h:2277
Clone_apply_end_t clone_apply_end
Definition: handler.h:2284
Clone_ack_t clone_ack
Definition: handler.h:2278
Definition: ft_global.h:72
Definition: handler.h:3844
uchar * buffer_end
Definition: handler.h:3846
uchar * buffer
Definition: handler.h:3845
uchar * end_of_used_area
Definition: handler.h:3847
Definition: handler.h:3831
KEY_CACHE * key_cache
Definition: handler.h:3834
uint sql_flags
Definition: handler.h:3833
uint flags
Definition: handler.h:3832
Struct to hold information about the table that should be created.
Definition: handler.h:3238
ulonglong auto_increment_value
Definition: handler.h:3281
bool m_hidden
Definition: handler.h:3313
bool m_transactional_ddl
Definition: handler.h:3319
bool m_implicit_tablespace_autoextend_size_change
Definition: handler.h:3326
handlerton * db_type
Definition: handler.h:3292
LEX_STRING compress
Algorithm (and possible options) to be used for InnoDB's transparent page compression.
Definition: handler.h:3254
LEX_STRING encrypt_type
This attribute is used for InnoDB's transparent page encryption.
Definition: handler.h:3262
LEX_CSTRING engine_attribute
Definition: handler.h:3321
ulong avg_row_length
Definition: handler.h:3283
const CHARSET_INFO * table_charset
Definition: handler.h:3239
const char * data_file_name
Definition: handler.h:3276
ulonglong m_implicit_tablespace_autoextend_size
Definition: handler.h:3324
bool secondary_load
Secondary engine load status.
Definition: handler.h:3270
ulong table_options
Definition: handler.h:3282
const CHARSET_INFO * default_table_charset
Definition: handler.h:3240
uint stats_sample_pages
Definition: handler.h:3288
const char * alias
Definition: handler.h:3278
uint null_bits
Definition: handler.h:3303
uint merge_insert_method
Definition: handler.h:3305
LEX_STRING connect_string
Definition: handler.h:3242
partition_info * part_info
Part info in order to maintain in HA_CREATE_INFO the per-partition secondary_load status.
Definition: handler.h:3274
const char * tablespace
Definition: handler.h:3244
ulonglong max_rows
Definition: handler.h:3279
void init_create_options_from_share(const TABLE_SHARE *share, uint64_t used_fields)
Fill HA_CREATE_INFO to be used by ALTER as well as upgrade code.
Definition: handler.cc:2668
const char * password
Definition: handler.h:3243
ha_storage_media storage_media
Definition: handler.h:3306
LEX_STRING comment
Definition: handler.h:3245
const char * index_file_name
Definition: handler.h:3277
SQL_I_List< Table_ref > merge_list
Definition: handler.h:3291
std::uint32_t key_block_size
Definition: handler.h:3287
LEX_CSTRING secondary_engine_attribute
Definition: handler.h:3322
LEX_CSTRING secondary_engine
Secondary engine of the table.
Definition: handler.h:3268
ulonglong min_rows
Definition: handler.h:3280
uint64_t used_fields
Definition: handler.h:3284
bool schema_read_only
Definition: handler.h:3241
enum_stats_auto_recalc stats_auto_recalc
Definition: handler.h:3290
File reference for clone.
Definition: handler.h:999
enum Ha_clone_file::@58 type
File reference type.
@ FILE_DESC
File descriptor.
Definition: handler.h:1006
@ FILE_HANDLE
File handle.
Definition: handler.h:1003
void * file_handle
File handle for windows.
Definition: handler.h:1016
int file_desc
File descriptor.
Definition: handler.h:1013
Column type description for foreign key columns compatibility check.
Definition: handler.h:1224
size_t elements_count
Definition: handler.h:1232
bool is_unsigned
Definition: handler.h:1234
size_t char_length
Definition: handler.h:1230
const CHARSET_INFO * field_charset
Definition: handler.h:1231
uint numeric_scale
Definition: handler.h:1233
dd::enum_column_types type
Definition: handler.h:1225
A struct containing a join hypergraph of a single query block, encapsulating the constraints given by...
Definition: make_join_hypergraph.h:89
Definition: keycache.h:73
Definition: my_base.h:1132
Structure describing changes to an index to be caused by ALTER TABLE.
Definition: handler.h:3348
KEY * new_key
Pointer to KEY object describing new version of index in Alter_inplace_info::key_info_buffer array.
Definition: handler.h:3359
KEY * old_key
Pointer to KEY object describing old version of index in TABLE::key_info array for TABLE instance rep...
Definition: handler.h:3354
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3987
Metadata lock object key.
Definition: mdl.h:366
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:83
Definition: mysql_lex_string.h:40
Definition: mysql_lex_string.h:35
Definition: my_bitmap.h:43
State data storage for start_table_io_wait_v1_t, start_table_lock_wait_v1_t.
Definition: psi_table_bits.h:69
Page track interface.
Definition: handler.h:2745
page_track_get_num_page_ids_t get_num_page_ids
Definition: handler.h:2750
page_track_purge_t purge
Definition: handler.h:2748
page_track_start_t start
Definition: handler.h:2746
page_track_stop_t stop
Definition: handler.h:2747
page_track_get_status_t get_status
Definition: handler.h:2751
page_track_get_page_ids_t get_page_ids
Definition: handler.h:2749
Definition: handler.h:3852
range_seq_t(* init)(void *init_params, uint n_ranges, uint flags)
Definition: handler.h:3865
uint(* next)(range_seq_t seq, KEY_MULTI_RANGE *range)
Definition: handler.h:3879
bool(* skip_record)(range_seq_t seq, char *range_info, uchar *rowid)
Definition: handler.h:3896
Definition: transaction_info.h:46
bool is_enabled
Indicates if simplification is guided using secondary engine.
Definition: handler.h:2515
int subgraph_pair_limit
Subgraph pairs requested by the secondary engine.
Definition: handler.h:2513
SecondaryEngineGraphSimplificationRequest secondary_engine_optimizer_request
Optimizer request from the secondary engine.
Definition: handler.h:2511
Per thread status variables.
Definition: system_variables.h:529
This structure is shared between different table objects.
Definition: table.h:708
Definition: table.h:1425
Definition: thr_lock.h:124
Definition: typelib.h:35
Structure used by parser to store options for tablespace statements and pass them on to Execution cla...
Definition: sql_tablespace.h:43
Info about FULLTEXT index hints, passed to the storage engine.
Definition: ft_global.h:117
double op_value
Operation value.
Definition: ft_global.h:123
ha_rows limit
LIMIT value, HA_POS_ERROR if not set.
Definition: ft_global.h:125
enum ft_operation op_type
Operation type.
Definition: ft_global.h:121
uint flags
FULLTEXT flags, see FT_NL, etc.
Definition: ft_global.h:119
handlerton is a singleton structure - one instance per storage engine - to provide access to storage ...
Definition: handler.h:2765
sdi_get_keys_t sdi_get_keys
Definition: handler.h:2869
sdi_drop_t sdi_drop
Definition: handler.h:2868
unlock_hton_log_t unlock_hton_log
Definition: handler.h:2927
notify_alter_table_t notify_alter_table
Definition: handler.h:2900
dict_cache_reset_t dict_cache_reset
Definition: handler.h:2838
void * data
Location for engines to keep personal structures.
Definition: handler.h:2920
set_prepared_in_tc_by_xid_t set_prepared_in_tc_by_xid
Definition: handler.h:2815
se_before_rollback_t se_before_rollback
Definition: handler.h:3032
sdi_set_t sdi_set
Definition: handler.h:2871
lock_hton_log_t lock_hton_log
Definition: handler.h:2926
is_dict_readonly_t is_dict_readonly
Definition: handler.h:2895
alter_tablespace_t alter_tablespace
Definition: handler.h:2826
finish_upgrade_t finish_upgrade
Definition: handler.h:2833
create_t create
Definition: handler.h:2816
collect_hton_log_info_t collect_hton_log_info
Definition: handler.h:2928
secondary_engine_pre_prepare_hook_t secondary_engine_pre_prepare_hook
Definition: handler.h:3024
dict_register_dd_table_id_t dict_register_dd_table_id
Definition: handler.h:2837
redo_log_set_state_t redo_log_set_state
Definition: handler.h:2904
find_files_t find_files
Definition: handler.h:2858
external_engine_explain_check_t external_engine_explain_check
Pointer to a function that checks if the table is loaded in the secondary engine in the case of an ex...
Definition: handler.h:2980
ddse_dict_init_t ddse_dict_init
Definition: handler.h:2836
replace_native_transaction_in_thd_t replace_native_transaction_in_thd
Definition: handler.h:2898
LEX_CSTRING fk_name_suffix
Suffix for auto-generated foreign key names for tables using this storage engine.
Definition: handler.h:2943
pre_dd_shutdown_t pre_dd_shutdown
Definition: handler.h:2801
check_fk_column_compat_t check_fk_column_compat
Definition: handler.h:2933
cardinality_estimation_hook_t cardinality_estimation_hook
Definition: handler.h:3028
SecondaryEngineFlags secondary_engine_flags
Bitmap which contains the supported join types and other flags for a secondary storage engine when us...
Definition: handler.h:2974
uint32 license
Flag for Engine License.
Definition: handler.h:2918
is_supported_system_table_t is_supported_system_table
Definition: handler.h:2861
commit_t commit
Definition: handler.h:2807
get_tablespace_statistics_t get_tablespace_statistics
Definition: handler.h:2909
se_after_commit_t se_after_commit
Definition: handler.h:3031
savepoint_set_t savepoint_set
Definition: handler.h:2803
uint savepoint_offset
To store per-savepoint data storage engine is provided with an area of a requested size (0 is ok here...
Definition: handler.h:2795
drop_database_t drop_database
Definition: handler.h:2817
savepoint_release_t savepoint_release
Definition: handler.h:2806
enum legacy_db_type db_type
Historical number used for frm file to determine the correct storage engine.
Definition: handler.h:2775
is_valid_tablespace_name_t is_valid_tablespace_name
Definition: handler.h:2825
se_before_commit_t se_before_commit
Definition: handler.h:3030
flush_logs_t flush_logs
Definition: handler.h:2822
log_ddl_create_schema_t log_ddl_create_schema
Definition: handler.h:2819
uint slot
Each storage engine has it's own memory area (actually a pointer) in the thd, for storing per-connect...
Definition: handler.h:2785
find_secondary_engine_offload_fail_reason_t find_secondary_engine_offload_fail_reason
Pointer to a function that finds and returns the query offload failure reason as a string given a thr...
Definition: handler.h:3004
dict_get_server_version_t dict_get_server_version
Definition: handler.h:2842
get_tablespace_type_t get_tablespace_type
Definition: handler.h:2830
close_connection_t close_connection
Definition: handler.h:2799
rotate_encryption_master_key_t rotate_encryption_master_key
Definition: handler.h:2903
secondary_engine_check_optimizer_request_t secondary_engine_check_optimizer_request
Pointer to function that checks secondary engine request for updating hypergraph join optimization.
Definition: handler.h:3019
notify_truncate_table_t notify_truncate_table
Definition: handler.h:2902
start_consistent_snapshot_t start_consistent_snapshot
Definition: handler.h:2821
savepoint_rollback_t savepoint_rollback
Definition: handler.h:2804
fill_is_table_t fill_is_table
Definition: handler.h:2834
binlog_func_t binlog_func
Definition: handler.h:2854
optimize_secondary_engine_t optimize_secondary_engine
Pointer to a function that optimizes the current statement for execution on the secondary storage eng...
Definition: handler.h:2960
log_ddl_drop_schema_t log_ddl_drop_schema
Definition: handler.h:2818
notify_exclusive_mdl_t notify_exclusive_mdl
Definition: handler.h:2899
get_cost_constants_t get_cost_constants
Definition: handler.h:2897
set_secondary_engine_offload_fail_reason_t set_secondary_engine_offload_fail_reason
Pointer to a function that sets the offload failure reason as a string for a thread context (represen...
Definition: handler.h:3012
notify_create_table_t notify_create_table
Definition: handler.h:3036
rollback_by_xid_t rollback_by_xid
Definition: handler.h:2813
sdi_delete_t sdi_delete
Definition: handler.h:2872
get_index_column_cardinality_t get_index_column_cardinality
Definition: handler.h:2908
rollback_t rollback
Definition: handler.h:2808
dict_recover_t dict_recover
Definition: handler.h:2841
rm_tmp_tables_t rm_tmp_tables
Definition: handler.h:2896
prepare_secondary_engine_t prepare_secondary_engine
Pointer to a function that prepares a secondary engine for executing a statement.
Definition: handler.h:2951
get_table_statistics_t get_table_statistics
Definition: handler.h:2906
Page_track_t page_track
Page tracking interface.
Definition: handler.h:3040
sdi_create_t sdi_create
Definition: handler.h:2867
notify_drop_table_t notify_drop_table
Definition: handler.h:3037
dict_init_t dict_init
Definition: handler.h:2835
uint32 foreign_keys_flags
Flags describing details of foreign key support by storage engine.
Definition: handler.h:2931
binlog_log_query_t binlog_log_query
Definition: handler.h:2855
get_tablespace_filename_ext_t get_tablespace_filename_ext
Definition: handler.h:2827
upgrade_logs_t upgrade_logs
Definition: handler.h:2832
get_secondary_engine_offload_or_exec_fail_reason_t get_secondary_engine_offload_or_exec_fail_reason
Pointer to a function that returns the query offload or exec failure reason as a string given a threa...
Definition: handler.h:2995
partition_flags_t partition_flags
Definition: handler.h:2824
const char ** file_extensions
Null-ended array of file extensions that exist for the storage engine.
Definition: handler.h:2893
dict_cache_reset_tables_and_tablespaces_t dict_cache_reset_tables_and_tablespaces
Definition: handler.h:2840
push_to_engine_t push_to_engine
Definition: handler.h:2860
Clone_interface_t clone_interface
Clone data transfer interfaces.
Definition: handler.h:2915
recover_prepared_in_tc_t recover_prepared_in_tc
Definition: handler.h:2811
discover_t discover
Definition: handler.h:2857
table_exists_in_engine_t table_exists_in_engine
Definition: handler.h:2859
upgrade_tablespace_t upgrade_tablespace
Definition: handler.h:2828
sdi_get_t sdi_get
Definition: handler.h:2870
reset_plugin_vars_t reset_plugin_vars
Definition: handler.h:2802
get_tablespace_type_by_name_t get_tablespace_type_by_name
Definition: handler.h:2831
dict_set_server_version_t dict_set_server_version
Definition: handler.h:2843
recover_t recover
Definition: handler.h:2810
SHOW_COMP_OPTION state
Historical marker for if the engine is available or not.
Definition: handler.h:2769
post_recover_t post_recover
Definition: handler.h:2912
uint32 flags
Global handler flags.
Definition: handler.h:2847
upgrade_space_version_t upgrade_space_version
Definition: handler.h:2829
kill_connection_t kill_connection
Definition: handler.h:2800
get_column_statistics_t get_column_statistics
Definition: handler.h:2907
prepare_t prepare
Definition: handler.h:2809
panic_t panic
Definition: handler.h:2820
post_ddl_t post_ddl
Definition: handler.h:2911
compare_secondary_engine_cost_t compare_secondary_engine_cost
Pointer to a function that estimates the cost of executing a join in a secondary storage engine.
Definition: handler.h:2968
notify_after_select_t notify_after_select
Definition: handler.h:3034
commit_by_xid_t commit_by_xid
Definition: handler.h:2812
set_prepared_in_tc_t set_prepared_in_tc
Definition: handler.h:2814
acl_notify_t acl_notify
Definition: handler.h:2856
show_status_t show_status
Definition: handler.h:2823
secondary_engine_modify_view_ap_cost_t secondary_engine_modify_view_ap_cost
Pointer to a function that evaluates the cost of executing an access path in a secondary storage engi...
Definition: handler.h:2986
is_reserved_db_name_t is_reserved_db_name
Definition: handler.h:2844
savepoint_rollback_can_release_mdl_t savepoint_rollback_can_release_mdl
Definition: handler.h:2805
notify_rename_table_t notify_rename_table
Definition: handler.h:2901
Definition: my_base.h:1125
Definition: gen_lex_token.cc:149
Definition: result.h:30
Key to identify a dictionary object.
Definition: handler.h:130
uint32 type
Type of Object, For ex: column, index, etc.
Definition: handler.h:132
uint64 id
Object id which should be unique in tablespsace.
Definition: handler.h:135
Definition: handler.h:139
sdi_container m_vec
Definition: handler.h:140
Definition: handler.h:823
const char * db
Definition: handler.h:824
const char * tablename
Definition: handler.h:825
Definition: sql_plugin_ref.h:45
Plain structure to store information about XA transaction id and a list of table names involved into ...
Definition: xa.h:290
Definition: mysqlslap.cc:242
struct xid_t is binary compatible with the XID structure as in the X/Open CAE Specification,...
Definition: xa.h:83
thr_lock_type
Definition: thr_lock.h:51
Include file for Sun RPC to compile out of the box.
unsigned long id[MAX_DEAD]
Definition: xcom_base.cc:510
static uint64_t cache_size
Definition: xcom_cache.cc:363
static int all(site_def const *s, node_no node)
Definition: xcom_transport.cc:890