MySQL 8.3.0
Source Code Documentation
fts0fts.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 2006, 2023, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/fts0fts.h
28 Full text search header file
29
30 Created 2011/09/02 Sunny Bains
31 ***********************************************************************/
32
33#ifndef fts0fts_h
34#define fts0fts_h
35
36#include "ha_prototypes.h"
37
38#include "data0type.h"
39#include "data0types.h"
40#include "dict0types.h"
41#include "ft_global.h"
42#include "hash0hash.h"
43#include "mem0mem.h"
45#include "que0types.h"
46#include "rem0types.h"
47#include "row0types.h"
48#include "trx0types.h"
49#include "ut0rbt.h"
50#include "ut0vec.h"
51#include "ut0wqueue.h"
52
53struct CHARSET_INFO;
54
55/** "NULL" value of a document id. */
56#define FTS_NULL_DOC_ID 0
57
58/** FTS hidden column that is used to map to and from the row */
59#define FTS_DOC_ID_COL_NAME "FTS_DOC_ID"
60
61/** The name of the index created by FTS */
62#define FTS_DOC_ID_INDEX_NAME "FTS_DOC_ID_INDEX"
63
64#define FTS_DOC_ID_INDEX_NAME_LEN 16
65
66/** Doc ID is a 8 byte value */
67#define FTS_DOC_ID_LEN 8
68
69/** The number of fields to sort when we build FT index with
70FIC. Three fields are sort: (word, doc_id, position) */
71#define FTS_NUM_FIELDS_SORT 3
72
73/** Maximum number of rows in a table, smaller than which, we will
74optimize using a 4 byte Doc ID for FIC merge sort to reduce sort size */
75#define MAX_DOC_ID_OPT_VAL 1073741824
76
77/** Document id type. */
78typedef uint64_t doc_id_t;
79
80/** doc_id_t printf format */
81#define FTS_DOC_ID_FORMAT IB_ID_FMT
82
83/** Convert document id to the InnoDB (BIG ENDIAN) storage format. */
84#define fts_write_doc_id(d, s) mach_write_to_8(d, s)
85
86/** Read a document id to internal format. */
87#define fts_read_doc_id(s) mach_read_from_8(s)
88
89/** Bind the doc id to a variable */
90#define fts_bind_doc_id(i, n, v) pars_info_bind_int8_literal(i, n, v)
91
92/** Defines for FTS query mode, they have the same values as
93those defined in mysql file ft_global.h */
94#define FTS_NL 0
95#define FTS_BOOL 1
96#define FTS_SORTED 2
97#define FTS_EXPAND 4
98#define FTS_NO_RANKING 8
99#define FTS_PROXIMITY 16
100#define FTS_PHRASE 32
101#define FTS_OPT_RANKING 64
102
103#define FTS_INDEX_TABLE_IND_NAME "FTS_INDEX_TABLE_IND"
104#define FTS_COMMON_TABLE_IND_NAME "FTS_COMMON_TABLE_IND"
105
106/** The number of FTS index partitions for a fulltext index. */
107constexpr size_t FTS_NUM_AUX_INDEX = 6;
108
109/** The number of FTS AUX common table for a fulltext index. */
110constexpr size_t FTS_NUM_AUX_COMMON = 5;
111
112/** Threshold where our optimize thread automatically kicks in */
113#define FTS_OPTIMIZE_THRESHOLD 10000000
114
115/** Threshold to avoid exhausting of doc ids. Consecutive doc id difference
116should not exceed FTS_DOC_ID_MAX_STEP */
117#define FTS_DOC_ID_MAX_STEP 65535
118
119/** Maximum possible Fulltext word length */
120#define FTS_MAX_WORD_LEN HA_FT_MAXBYTELEN
121
122/** Maximum possible Fulltext word length (in characters) */
123#define FTS_MAX_WORD_LEN_IN_CHAR HA_FT_MAXCHARLEN
124
125/** Number of columns in FTS AUX Tables */
126#define FTS_DELETED_TABLE_NUM_COLS 1
127#define FTS_CONFIG_TABLE_NUM_COLS 2
128#define FTS_AUX_INDEX_TABLE_NUM_COLS 5
129
130/** DELETED_TABLE(doc_id BIGINT UNSIGNED) */
131#define FTS_DELETED_TABLE_COL_LEN 8
132/** CONFIG_TABLE(key CHAR(50), value CHAR(200)) */
133#define FTS_CONFIG_TABLE_KEY_COL_LEN 50
134#define FTS_CONFIG_TABLE_VALUE_COL_LEN 200
135
136#define FTS_INDEX_WORD_LEN FTS_MAX_WORD_LEN
137#define FTS_INDEX_FIRST_DOC_ID_LEN 8
138#define FTS_INDEX_LAST_DOC_ID_LEN 8
139#define FTS_INDEX_DOC_COUNT_LEN 4
140/* BLOB COLUMN, 0 means VARIABLE SIZE */
141#define FTS_INDEX_ILIST_LEN 0
142/* Maximum nested expression in fulltext binary search string */
143#define FTS_MAX_NESTED_EXP 31
144
145extern const char *FTS_PREFIX;
146extern const char *FTS_SUFFIX_BEING_DELETED;
147extern const char *FTS_SUFFIX_BEING_DELETED_CACHE;
148extern const char *FTS_SUFFIX_CONFIG;
149extern const char *FTS_SUFFIX_DELETED;
150extern const char *FTS_SUFFIX_DELETED_CACHE;
151
152extern const char *FTS_PREFIX_5_7;
153extern const char *FTS_SUFFIX_CONFIG_5_7;
154
155/** Variable specifying the number of word to optimize for each optimize table
156call */
157extern ulong fts_num_word_optimize;
158
159/** Variable specifying whether we do additional FTS diagnostic printout
160in the log */
161extern bool fts_enable_diag_print;
162
163/** FTS rank type, which will be between 0 .. 1 inclusive */
164typedef float fts_rank_t;
165
166/** Structure to manage FTS AUX table name and MDL during its drop */
168 /** AUX table name */
169 std::vector<char *> aux_name;
170};
171
172/** Type of a row during a transaction. FTS_NOTHING means the row can be
173forgotten from the FTS system's POV, FTS_INVALID is an internal value used
174to mark invalid states.
175
176NOTE: Do not change the order or value of these, fts_trx_row_get_new_state
177depends on them being exactly as they are. */
185
186/** The FTS table types. */
188 FTS_INDEX_TABLE, /*!< FTS auxiliary table that is
189 specific to a particular FTS index
190 on a table */
191
192 FTS_COMMON_TABLE, /*!< FTS auxiliary table that is common
193 for all FTS index on a table */
194
195 FTS_OBSOLETED_TABLE /*!< FTS obsoleted tables like DOC_ID,
196 ADDED, STOPWORDS */
198
199struct fts_doc_t;
200struct fts_cache_t;
201struct fts_token_t;
202struct fts_doc_ids_t;
203struct fts_index_cache_t;
204
205/** Initialize the "fts_table" for internal query into FTS auxiliary
206tables */
207#define FTS_INIT_FTS_TABLE(fts_table, m_suffix, m_type, m_table) \
208 do { \
209 (fts_table)->suffix = m_suffix; \
210 (fts_table)->type = m_type; \
211 (fts_table)->table_id = m_table->id; \
212 (fts_table)->parent = m_table->name.m_name; \
213 (fts_table)->table = m_table; \
214 } while (0);
215
216#define FTS_INIT_INDEX_TABLE(fts_table, m_suffix, m_type, m_index) \
217 do { \
218 (fts_table)->suffix = m_suffix; \
219 (fts_table)->type = m_type; \
220 (fts_table)->table_id = m_index->table->id; \
221 (fts_table)->parent = m_index->table->name.m_name; \
222 (fts_table)->table = m_index->table; \
223 (fts_table)->index_id = m_index->id; \
224 } while (0);
225
226/** Information about changes in a single transaction affecting
227the FTS system. */
228struct fts_trx_t {
229 trx_t *trx; /*!< InnoDB transaction */
230
231 ib_vector_t *savepoints; /*!< Active savepoints, must have at
232 least one element, the implied
233 savepoint */
234 ib_vector_t *last_stmt; /*!< last_stmt */
235
236 mem_heap_t *heap; /*!< heap */
237};
238
239/** Information required for transaction savepoint handling. */
241 char *name; /*!< First entry is always NULL, the
242 default instance. Otherwise the name
243 of the savepoint */
244
245 ib_rbt_t *tables; /*!< Modified FTS tables */
246};
247
248/** Information about changed rows in a transaction for a single table. */
250 dict_table_t *table; /*!< table */
251
252 fts_trx_t *fts_trx; /*!< link to parent */
253
254 ib_rbt_t *rows; /*!< rows changed; indexed by doc-id,
255 cells are fts_trx_row_t* */
256
257 fts_doc_ids_t *added_doc_ids; /*!< list of added doc ids (NULL until
258 the first addition) */
259
260 /*!< for adding doc ids */
262};
263
264/** Information about one changed row in a transaction. */
266 doc_id_t doc_id; /*!< Id of the ins/upd/del document */
267
268 fts_row_state state; /*!< state of the row */
269
270 ib_vector_t *fts_indexes; /*!< The indexes that are affected */
271};
272
273/** List of document ids that were added during a transaction. This
274list is passed on to a background 'Add' thread and OPTIMIZE, so it
275needs its own memory heap. */
277 ib_vector_t *doc_ids; /*!< document ids (each element is
278 of type doc_id_t). */
279
280 ib_alloc_t *self_heap; /*!< Allocator used to create an
281 instance of this type and the
282 doc_ids vector */
283};
284
285// FIXME: Get rid of this if possible.
286/** Since MySQL's character set support for Unicode is woefully inadequate
287(it supports basic operations like isalpha etc. only for 8-bit characters),
288we have to implement our own. We use UTF-16 without surrogate processing
289as our in-memory format. This typedef is a single such character. */
290typedef unsigned short ib_uc_t;
291
292/** An UTF-16 ro UTF-8 string. */
294 byte *f_str; /*!< string, not necessary terminated in
295 any way */
296 ulint f_len; /*!< Length of the string in bytes */
297 ulint f_n_char; /*!< Number of characters */
298};
299
300/** Query ranked doc ids. */
302 doc_id_t doc_id; /*!< Document id */
303
304 fts_rank_t rank; /*!< Rank is between 0 .. 1 */
305
306 byte *words; /*!< this contains the words
307 that were queried
308 and found in this document */
309 ulint words_len; /*!< words len */
310};
311
312/** Query result. */
314 ib_rbt_node_t *current; /*!< Current element */
315
316 ib_rbt_t *rankings_by_id; /*!< RB tree of type fts_ranking_t
317 indexed by doc id */
318 ib_rbt_t *rankings_by_rank; /*!< RB tree of type fts_ranking_t
319 indexed by rank */
320};
321
322/** This is used to generate the FTS auxiliary table name, we need the
323table id and the index id to generate the column specific FTS auxiliary
324table name. */
326 const char *parent; /*!< Parent table name, this is
327 required only for the database
328 name */
329
330 fts_table_type_t type; /*!< The auxiliary table type */
331
332 table_id_t table_id; /*!< The table id */
333
334 space_index_t index_id; /*!< The index id */
335
336 const char *suffix; /*!< The suffix of the fts auxiliary
337 table name, can be NULL, not used
338 everywhere (yet) */
339 const dict_table_t *table; /*!< Parent table */
340 CHARSET_INFO *charset; /*!< charset info if it is for FTS
341 index auxiliary table */
342};
343
345 BG_THREAD_STOP = 1, /*!< true if the FTS background thread
346 has finished reading the ADDED table,
347 meaning more items can be added to
348 the table. */
349
350 BG_THREAD_READY = 2, /*!< true if the FTS background thread
351 is ready */
352
353 ADD_THREAD_STARTED = 4, /*!< true if the FTS add thread
354 has started */
355
356 ADDED_TABLE_SYNCED = 8, /*!< true if the ADDED table record is
357 sync-ed after crash recovery */
358};
359
361
362/** The state of the FTS sub system. */
363class fts_t {
364 public:
365 /** fts_t constructor.
366 @param[in] table table with FTS indexes
367 @param[in,out] heap memory heap where 'this' is stored */
369
370 /** fts_t destructor. */
371 ~fts_t();
372
373 /** Mutex protecting bg_threads* and fts_add_wq. */
375
376 /** Number of background threads accessing this table. */
378
379 /** Status bit regarding fts running state. true if background
380 threads running should stop themselves. */
382
383 /** Work queue for scheduling jobs for the FTS 'Add' thread, or NULL
384 if the thread has not yet been created. Each work item is a
385 fts_trx_doc_ids_t*. */
387
388 /** FTS memory buffer for this table, or NULL if the table has no FTS
389 index. */
391
392 /** FTS doc id hidden column number in the CLUSTERED index. */
394
395 /** Vector of FTS indexes, this is mainly for caching purposes. */
397
398 /** Heap for fts_t allocation. */
400};
401
402struct fts_stopword_t;
403
404/** status bits for fts_stopword_t status field. */
405#define STOPWORD_NOT_INIT 0x1
406#define STOPWORD_OFF 0x2
407#define STOPWORD_FROM_DEFAULT 0x4
408#define STOPWORD_USER_TABLE 0x8
409
410extern const char *fts_default_stopword[];
411
412/** Variable specifying the maximum FTS cache size for each table */
413extern ulong fts_max_cache_size;
414
415/** Variable specifying the total memory allocated for FTS cache */
416extern ulong fts_max_total_cache_size;
417
418/** Variable specifying the FTS result cache limit for each query */
419extern ulong fts_result_cache_limit;
420
421/** Variable specifying the maximum FTS max token size */
422extern ulong fts_max_token_size;
423
424/** Variable specifying the minimum FTS max token size */
425extern ulong fts_min_token_size;
426
427/** Whether the total memory used for FTS cache is exhausted, and we will
428need a sync to free some memory */
429extern bool fts_need_sync;
430
431/** Variable specifying the table that has Fulltext index to display its
432content through information schema table */
433extern char *fts_internal_tbl_name;
434
435#define fts_que_graph_free(graph) \
436 do { \
437 que_graph_free(graph); \
438 } while (0)
439
440/** Create a FTS cache. */
442 dict_table_t *table); /*!< table owns the FTS cache */
443
444/** Create a FTS index cache.
445 @return Index Cache */
447 dict_table_t *table, /*!< in: table with FTS index */
448 dict_index_t *index); /*!< in: FTS index */
449
450/** Remove a FTS index cache
451@param[in] table table with FTS index
452@param[in] index FTS index */
454
455/** Get the next available document id. This function creates a new
456 transaction to generate the document id.
457 @return DB_SUCCESS if OK */
458dberr_t fts_get_next_doc_id(const dict_table_t *table, /*!< in: table */
459 doc_id_t *doc_id); /*!< out: new document id */
460/** Update the next and last Doc ID in the CONFIG table to be the input
461 "doc_id" value (+ 1). We would do so after each FTS index build or
462 table truncate */
464 trx_t *trx, /*!< in/out: transaction */
465 const dict_table_t *table, /*!< in: table */
466 const char *table_name, /*!< in: table name, or NULL */
467 doc_id_t doc_id); /*!< in: DOC ID to set */
468
469/** Create a new document id.
470@param[in] table Row is of this table.
471@param[in,out] row Add doc id value to this row. This is the current row
472that is being inserted.
473@param[in] heap Memory heap on which the doc_id object will be created.
474@return DB_SUCCESS if all went well else error */
476
477/** Create a new fts_doc_ids_t.
478 @return new fts_doc_ids_t. */
480
481/** Free a fts_doc_ids_t. */
482void fts_doc_ids_free(fts_doc_ids_t *doc_ids); /*!< in: doc_ids to free */
483
484/** Notify the FTS system about an operation on an FTS-indexed table.
485@param[in] trx Innodb transaction
486@param[in] table Table
487@param[in] doc_id Doc id
488@param[in] state State of the row
489@param[in] fts_indexes Fts indexes affected (null=all) */
491 fts_row_state state, ib_vector_t *fts_indexes);
492
493/** Free an FTS trx. */
494void fts_trx_free(fts_trx_t *fts_trx); /*!< in, own: FTS trx */
495
496/** Check if common tables already exist
497@param[in] table table with fts index
498@return true on success, false on failure */
500
501/** Creates the common auxiliary tables needed for supporting an FTS index
502on the given table. row_mysql_lock_data_dictionary must have been called
503before this.
504The following tables are created.
505CREATE TABLE $FTS_PREFIX_DELETED
506 (doc_id BIGINT UNSIGNED, UNIQUE CLUSTERED INDEX on doc_id)
507CREATE TABLE $FTS_PREFIX_DELETED_CACHE
508 (doc_id BIGINT UNSIGNED, UNIQUE CLUSTERED INDEX on doc_id)
509CREATE TABLE $FTS_PREFIX_BEING_DELETED
510 (doc_id BIGINT UNSIGNED, UNIQUE CLUSTERED INDEX on doc_id)
511CREATE TABLE $FTS_PREFIX_BEING_DELETED_CACHE
512 (doc_id BIGINT UNSIGNED, UNIQUE CLUSTERED INDEX on doc_id)
513CREATE TABLE $FTS_PREFIX_CONFIG
514 (key CHAR(50), value CHAR(200), UNIQUE CLUSTERED INDEX on key)
515@param[in,out] trx transaction
516@param[in] table table with FTS index
517@param[in] name table name normalized
518@param[in] skip_doc_id_index Skip index on doc id
519@return DB_SUCCESS if succeed */
520[[nodiscard]] dberr_t fts_create_common_tables(trx_t *trx,
521 const dict_table_t *table,
522 const char *name,
523 bool skip_doc_id_index);
524
525/** Creates the column specific ancillary tables needed for supporting an
526FTS index on the given table. row_mysql_lock_data_dictionary must have
527been called before this.
528
529All FTS AUX Index tables have the following schema.
530CREATE TABLE $FTS_PREFIX_INDEX_[1-6](
531 word VARCHAR(FTS_MAX_WORD_LEN),
532 first_doc_id INT NOT NULL,
533 last_doc_id UNSIGNED NOT NULL,
534 doc_count UNSIGNED INT NOT NULL,
535 ilist VARBINARY NOT NULL,
536 UNIQUE CLUSTERED INDEX ON (word, first_doc_id))
537@param[in,out] trx transaction
538@param[in] index index instance
539@return DB_SUCCESS or error code */
540[[nodiscard]] dberr_t fts_create_index_tables(trx_t *trx, dict_index_t *index);
541
542/** Create auxiliary index tables for an FTS index.
543@param[in,out] trx transaction
544@param[in] index the index instance
545@param[in] table_name table name
546@param[in] table_id the table id
547@return DB_SUCCESS or error code */
548[[nodiscard]] dberr_t fts_create_index_tables_low(trx_t *trx,
549 dict_index_t *index,
550 const char *table_name,
551 table_id_t table_id);
552
553/** Add the FTS document id hidden column.
554@param[in,out] table Table with FTS index
555@param[in] heap Temporary memory heap, or NULL */
557
558/** Drops the ancillary tables needed for supporting an FTS index on a
559given table. row_mysql_lock_data_dictionary must have been called before
560this.
561@param[in,out] trx transaction
562@param[in] table table has the fts index
563@param[in,out] aux_vec fts aux table name vector
564@return DB_SUCCESS or error code */
566 aux_name_vec_t *aux_vec);
567
568/** Lock all FTS AUX tables (for dropping table)
569@param[in] thd thread locking the AUX table
570@param[in] table table has the fts index
571@return DB_SUCCESS or error code */
573
574/** Drop FTS AUX table DD table objects in vector
575@param[in] aux_vec aux table name vector
576@param[in] file_per_table whether file per table
577@return true on success, false on failure. */
578bool fts_drop_dd_tables(const aux_name_vec_t *aux_vec, bool file_per_table);
579
580/** Free FTS AUX table names in vector
581@param[in] aux_vec aux table name vector
582*/
584
585/** The given transaction is about to be committed; do whatever is necessary
586 from the FTS system's POV.
587 @return DB_SUCCESS or error code */
588[[nodiscard]] dberr_t fts_commit(trx_t *trx); /*!< in: transaction */
589
590/** FTS Query entry point.
591@param[in] trx transaction
592@param[in] index fts index to search
593@param[in] flags FTS search mode
594@param[in] query_str FTS query
595@param[in] query_len FTS query string len in bytes
596@param[in,out] result result doc ids
597@param[in] limit limit value
598@return DB_SUCCESS if successful otherwise error code */
599[[nodiscard]] dberr_t fts_query(trx_t *trx, dict_index_t *index, uint flags,
600 const byte *query_str, ulint query_len,
601 fts_result_t **result, ulonglong limit);
602
603/** Retrieve the FTS Relevance Ranking result for doc with doc_id
604 @return the relevance ranking value. */
606 fts_result_t *result, /*!< in: FTS result structure */
607 doc_id_t doc_id); /*!< in: the interested document
608 doc_id */
609
610/** FTS Query sort result, returned by fts_query() on fts_ranking_t::rank. */
612 instance to sort.*/
613
614/** FTS Query free result, returned by fts_query(). */
615void fts_query_free_result(fts_result_t *result); /*!< in: result instance
616 to free.*/
617
618/** Extract the doc id from the FTS hidden column. */
620 dtuple_t *row); /*!< in: row whose FTS doc id
621 we want to extract.*/
622
623/** Extract the doc id from the record that belongs to index.
624@param[in] table table
625@param[in] rec record contains FTS_DOC_ID
626@param[in] index index of rec
627@param[in] heap heap memory
628@return doc id that was extracted from rec */
630 const dict_index_t *index, mem_heap_t *heap);
631
632/** Add new fts doc id to the update vector.
633@param[in] table the table that contains the FTS index.
634@param[in,out] ufield the fts doc id field in the update vector.
635 No new memory is allocated for this in this
636 function.
637@param[in,out] next_doc_id the fts doc id that has been added to the
638 update vector. If 0, a new fts doc id is
639 automatically generated. The memory provided
640 for this argument will be used by the update
641 vector. Ensure that the life time of this
642 memory matches that of the update vector.
643@return the fts doc id used in the update vector */
645 doc_id_t *next_doc_id);
646
647/** FTS initialize. */
648void fts_startup(void);
649
650#if 0 // TODO: Enable this in WL#6608
651/******************************************************************//**
652Signal FTS threads to initiate shutdown. */
653void
654fts_start_shutdown(
655 dict_table_t* table, /*!< in: table with FTS
656 indexes */
657 fts_t* fts); /*!< in: fts instance to
658 shutdown */
659
660/******************************************************************//**
661Wait for FTS threads to shutdown. */
662void
663fts_shutdown(
664 dict_table_t* table, /*!< in: table with FTS
665 indexes */
666 fts_t* fts); /*!< in: fts instance to
667 shutdown */
668#endif
669
670/** Create an instance of fts_t.
671 @return instance of fts_t */
672fts_t *fts_create(dict_table_t *table); /*!< out: table with FTS
673 indexes */
674
675/** Free the FTS resources. */
676void fts_free(dict_table_t *table); /*!< in/out: table with
677 FTS indexes */
678
679/** Run OPTIMIZE on the given table.
680 @return DB_SUCCESS if all OK */
681dberr_t fts_optimize_table(dict_table_t *table); /*!< in: table to optimiza */
682
683/** Startup the optimize thread and create the work queue. */
684void fts_optimize_init(void);
685
686/** Since we do a horizontal split on the index table, we need to drop
687all the split tables.
688@param[in] trx transaction
689@param[in] index fts index
690@param[out] aux_vec dropped table names vector
691@return DB_SUCCESS or error code */
693 aux_name_vec_t *aux_vec);
694
695/** Empty all common talbes.
696@param[in,out] trx transaction
697@param[in] table dict table
698@return DB_SUCCESS or error code. */
700
701/** Remove the table from the OPTIMIZER's list. We do wait for
702 acknowledgement from the consumer of the message. */
703void fts_optimize_remove_table(dict_table_t *table); /*!< in: table to remove */
704
705/** Shutdown fts optimize thread. */
707
708/** Send sync fts cache for the table.
709@param[in] table table to sync */
711
712/** Take a FTS savepoint.
713@param[in] fts_trx Fts transaction
714@param[in] name Savepoint name */
715void fts_savepoint_take(fts_trx_t *fts_trx, const char *name);
716
717/** Refresh last statement savepoint. */
718void fts_savepoint_laststmt_refresh(trx_t *trx); /*!< in: transaction */
719
720/** Release the savepoint data identified by name. */
721void fts_savepoint_release(trx_t *trx, /*!< in: transaction */
722 const char *name); /*!< in: savepoint name */
723
724/** Clear cache.
725@param[in,out] cache fts cache */
726void fts_cache_clear(fts_cache_t *cache);
727
728/** Initialize things in cache. */
729void fts_cache_init(fts_cache_t *cache); /*!< in: cache */
730
731/** Rollback to and including savepoint identified by name. */
732void fts_savepoint_rollback(trx_t *trx, /*!< in: transaction */
733 const char *name); /*!< in: savepoint name */
734
735/** Rollback to and including savepoint identified by name. */
736void fts_savepoint_rollback_last_stmt(trx_t *trx); /*!< in: transaction */
737
738/* Get parent table name if it's a fts aux table
739@param[in] aux_table_name aux table name
740@param[in] aux_table_len aux table length
741@return parent table name, or NULL */
742char *fts_get_parent_table_name(const char *aux_table_name,
743 ulint aux_table_len);
744
745/** Run SYNC on the table, i.e., write out data from the cache to the
746FTS auxiliary INDEX table and clear the cache at the end.
747@param[in,out] table fts table
748@param[in] unlock_cache whether unlock cache when write node
749@param[in] wait whether wait for existing sync to finish
750@param[in] has_dict whether has dict operation lock
751@return DB_SUCCESS on success, error code on failure. */
752dberr_t fts_sync_table(dict_table_t *table, bool unlock_cache, bool wait,
753 bool has_dict);
754
755/** Create an FTS index cache. */
756CHARSET_INFO *fts_index_get_charset(dict_index_t *index); /*!< in: FTS index */
757
758/** Get the initial Doc ID by consulting the CONFIG table
759 @return initial Doc ID */
760doc_id_t fts_init_doc_id(const dict_table_t *table); /*!< in: table */
761
762/** Compare two character string according to their charset.
763@param[in] cs Character set
764@param[in] p1 Key
765@param[in] p2 Node */
766extern int innobase_fts_text_cmp(const void *cs, const void *p1,
767 const void *p2);
768
769/** Makes all characters in a string lower case.
770@param[in] cs Character set
771@param[in] src String to put in lower case
772@param[in] src_len Input string length
773@param[in] dst Buffer for result string
774@param[in] dst_len Buffer size */
775extern size_t innobase_fts_casedn_str(CHARSET_INFO *cs, char *src,
776 size_t src_len, char *dst,
777 size_t dst_len);
778
779/** Compare two character string according to their charset.
780@param[in] cs Character set
781@param[in] p1 Key
782@param[in] p2 Node */
783extern int innobase_fts_text_cmp_prefix(const void *cs, const void *p1,
784 const void *p2);
785
786/** Get the next token from the given string and store it in *token. */
788 CHARSET_INFO *charset, /*!< in: Character set */
789 const byte *start, /*!< in: start of text */
790 const byte *end, /*!< in: one character past
791 end of text */
792 fts_string_t *token); /*!< out: token's text */
793
794/** Drop dd table & tablespace for fts aux table
795@param[in] name table name
796@param[in] file_per_table flag whether use file per table
797@return true on success, false on failure. */
798bool innobase_fts_drop_dd_table(const char *name, bool file_per_table);
799
800/** Get token char size by charset
801 @return the number of token char size */
802ulint fts_get_token_size(const CHARSET_INFO *cs, /*!< in: Character set */
803 const char *token, /*!< in: token */
804 ulint len); /*!< in: token length */
805
806/** FULLTEXT tokenizer internal in MYSQL_FTPARSER_SIMPLE_MODE
807 @return 0 if tokenize successfully */
809 MYSQL_FTPARSER_PARAM *param, /*!< in: parser parameter */
810 char *doc, /*!< in: document to tokenize */
811 int len); /*!< in: document length */
812
813/** Fetch COUNT(*) from specified table.
814 @return the number of rows in the table */
815ulint fts_get_rows_count(fts_table_t *fts_table); /*!< in: fts table to read */
816
817/** Get maximum Doc ID in a table if index "FTS_DOC_ID_INDEX" exists
818 @return max Doc ID or 0 if index "FTS_DOC_ID_INDEX" does not exist */
819doc_id_t fts_get_max_doc_id(dict_table_t *table); /*!< in: user table */
820
821/** Check whether user supplied stopword table exists and is of
822 the right format.
823 @return the stopword column charset if qualifies */
825 const char *stopword_table_name); /*!< in: Stopword table
826 name */
827/** This function loads specified stopword into FTS cache
828 @return true if success */
830 const dict_table_t *table, /*!< in: Table with FTS */
831 trx_t *trx, /*!< in: Transaction */
832 const char *global_stopword_table, /*!< in: Global stopword table
833 name */
834 const char *session_stopword_table, /*!< in: Session stopword table
835 name */
836 bool stopword_is_on, /*!< in: Whether stopword
837 option is turned on/off */
838 bool reload); /*!< in: Whether it is during
839 reload of FTS table */
840
841/** Read the rows from the FTS index
842 @return DB_SUCCESS if OK */
843dberr_t fts_table_fetch_doc_ids(trx_t *trx, /*!< in: transaction */
844 fts_table_t *fts_table, /*!< in: aux table */
845 fts_doc_ids_t *doc_ids); /*!< in: For collecting
846 doc ids */
847/** This function brings FTS index in sync when FTS index is first
848 used. There are documents that have not yet sync-ed to auxiliary
849 tables from last server abnormally shutdown, we will need to bring
850 such document into FTS cache before any further operations
851 @return true if all OK */
852bool fts_init_index(dict_table_t *table, /*!< in: Table with FTS */
853 bool has_cache_lock); /*!< in: Whether we already
854 have cache lock */
855/** Add a newly create index in FTS cache */
856void fts_add_index(dict_index_t *index, /*!< FTS index to be added */
857 dict_table_t *table); /*!< table */
858
859/** Drop auxiliary tables related to an FTS index
860@param[in] table Table where indexes are dropped
861@param[in] index Index to be dropped
862@param[in] trx Transaction for the drop
863@param[in,out] aux_vec Aux table name vector
864@return DB_SUCCESS or error number */
866 aux_name_vec_t *aux_vec);
867
868/** Rename auxiliary tables for all fts index for a table
869 @return DB_SUCCESS or error code */
870dberr_t fts_rename_aux_tables(dict_table_t *table, /*!< in: user Table */
871 const char *new_name, /*!< in: new table name */
872 trx_t *trx, /*!< in: transaction */
873 bool replay); /*!< Whether in replay
874 stage */
875
876/** Check indexes in the fts->indexes is also present in index cache and
877 table->indexes list
878 @return true if all indexes match */
880 dict_table_t *table); /*!< in: Table where indexes are dropped */
881
882/** Fetch the document from tuple, tokenize the text data and
883insert the text data into fts auxiliary table and
884its cache. Moreover this tuple fields doesn't contain any information
885about externally stored field. This tuple contains data directly
886converted from mysql.
887@param[in] ftt FTS transaction table
888@param[in] doc_id doc id
889@param[in] tuple tuple from where data can be retrieved
890 and tuple should be arranged in table
891 schema order. */
893 const dtuple_t *tuple);
894
895/** Create an FTS trx.
896@param[in,out] trx InnoDB Transaction
897@return FTS transaction. */
899
900/** For storing table info when checking for orphaned tables. */
902 /** Table id */
904
905 /** Parent table id */
907
908 /** Table FT index id */
910
911 /** Name of the table */
912 char *name;
913
914 /** FTS table type */
916};
917
918/** Check if a table is an FTS auxiliary table name.
919@param[out] table FTS table info
920@param[in] name Table name
921@param[in] len Length of table name
922@return true if the name matches an auxiliary table name pattern */
923bool fts_is_aux_table_name(fts_aux_table_t *table, const char *name, ulint len);
924
925/** Freeze all auiliary tables to be not evictable if exist, with dict_mutex
926held
927@param[in] table InnoDB table object */
929
930/** Allow all the auxiliary tables of specified base table to be evictable
931if they exist, if not exist just ignore
932@param[in] table InnoDB table object
933@param[in] dict_locked True if we have dict_sys mutex */
934void fts_detach_aux_tables(const dict_table_t *table, bool dict_locked);
935
936/** Update DD system table for auxiliary common tables for an FTS index.
937@param[in] table dict table instance
938@return true on success, false on failure */
940
941/** Check if a table has FTS index needs to have its auxiliary index
942tables' metadata updated in DD
943@param[in,out] table table to check
944@return DB_SUCCESS or error code */
946
947/** Upgrade FTS AUX Tables. The FTS common and aux tables are
948renamed because they have table_id in their name. We move table_ids
949by DICT_MAX_DD_TABLES offset. Aux tables are registered into DD
950after rename.
951@param[in] table InnoDB table object
952@return DB_SUCCESS or error code */
954
955/** Rename FTS AUX tablespace name from 8.0 format to 5.7 format.
956This will be done on upgrade failure
957@param[in] table parent table
958@param[in] rollback rollback the rename from 8.0 to 5.7
959 if true, rename to 5.7 format
960 if false, mark the table as evictable
961@return DB_SUCCESS on success, DB_ERROR on error */
963
964#endif
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:35
The state of the FTS sub system.
Definition: fts0fts.h:363
fts_cache_t * cache
FTS memory buffer for this table, or NULL if the table has no FTS index.
Definition: fts0fts.h:390
ulint bg_threads
Number of background threads accessing this table.
Definition: fts0fts.h:377
mem_heap_t * fts_heap
Heap for fts_t allocation.
Definition: fts0fts.h:399
~fts_t()
fts_t destructor.
Definition: fts0fts.cc:5413
ib_mutex_t bg_threads_mutex
Mutex protecting bg_threads* and fts_add_wq.
Definition: fts0fts.h:374
ulint doc_col
FTS doc id hidden column number in the CLUSTERED index.
Definition: fts0fts.h:393
ib_wqueue_t * add_wq
Work queue for scheduling jobs for the FTS 'Add' thread, or NULL if the thread has not yet been creat...
Definition: fts0fts.h:386
ulint fts_status
Status bit regarding fts running state.
Definition: fts0fts.h:381
fts_t(dict_table_t *table, mem_heap_t *heap)
fts_t constructor.
Definition: fts0fts.cc:5394
ib_vector_t * indexes
Vector of FTS indexes, this is mainly for caching purposes.
Definition: fts0fts.h:396
Data types.
Some type definitions.
dberr_t
Definition: db0err.h:38
Data dictionary global types.
ib_id_t space_index_t
Index identifier (unique within a tablespace).
Definition: dict0types.h:219
ib_id_t table_id_t
Table or partition identifier (unique within an InnoDB instance).
Definition: dict0types.h:217
Some definitions for full-text indices.
size_t innobase_fts_casedn_str(CHARSET_INFO *cs, char *src, size_t src_len, char *dst, size_t dst_len)
Makes all characters in a string lower case.
Definition: ha_innodb.cc:8147
const char * FTS_SUFFIX_CONFIG_5_7
Definition: fts0fts.cc:149
fts_trx_t * fts_trx_create(trx_t *trx)
Create an FTS trx.
Definition: fts0fts.cc:2478
dberr_t fts_create_index_tables(trx_t *trx, dict_index_t *index)
Creates the column specific ancillary tables needed for supporting an FTS index on the given table.
Definition: fts0fts.cc:2332
int fts_tokenize_document_internal(MYSQL_FTPARSER_PARAM *param, char *doc, int len)
FULLTEXT tokenizer internal in MYSQL_FTPARSER_SIMPLE_MODE.
Definition: fts0fts.cc:4688
dberr_t fts_create_doc_id(dict_table_t *table, dtuple_t *row, mem_heap_t *heap)
Create a new document id.
Definition: fts0fts.cc:3132
uint64_t doc_id_t
Document id type.
Definition: fts0fts.h:78
float fts_retrieve_ranking(fts_result_t *result, doc_id_t doc_id)
Retrieve the FTS Relevance Ranking result for doc with doc_id.
Definition: fts0que.cc:3317
void fts_query_sort_result_on_rank(fts_result_t *result)
FTS Query sort result, returned by fts_query() on fts_ranking_t::rank.
Definition: fts0que.cc:3850
void fts_startup(void)
FTS initialize.
void fts_optimize_request_sync_table(dict_table_t *table)
Send sync fts cache for the table.
Definition: fts0opt.cc:2515
dberr_t fts_upgrade_aux_tables(dict_table_t *table)
Upgrade FTS AUX Tables.
Definition: fts0fts.cc:6345
void fts_optimize_shutdown()
Shutdown fts optimize thread.
Definition: fts0opt.cc:2968
dberr_t fts_create_index_dd_tables(dict_table_t *table)
Check if a table has FTS index needs to have its auxiliary index tables' metadata updated in DD.
Definition: fts0fts.cc:2247
fts_doc_ids_t * fts_doc_ids_create(void)
Create a new fts_doc_ids_t.
Definition: fts0fts.cc:2978
void fts_add_doc_id_column(dict_table_t *table, mem_heap_t *heap)
Add the FTS document id hidden column.
Definition: fts0fts.cc:5330
const char * FTS_SUFFIX_BEING_DELETED_CACHE
Definition: fts0fts.cc:139
doc_id_t fts_update_doc_id(dict_table_t *table, upd_field_t *ufield, doc_id_t *next_doc_id)
Add new fts doc id to the update vector.
Definition: fts0fts.cc:5352
ulong fts_result_cache_limit
Variable specifying the FTS result cache limit for each query.
Definition: fts0fts.cc:86
void fts_add_doc_from_tuple(fts_trx_table_t *ftt, doc_id_t doc_id, const dtuple_t *tuple)
Fetch the document from tuple, tokenize the text data and insert the text data into fts auxiliary tab...
Definition: fts0fts.cc:3494
const char * fts_default_stopword[]
InnoDB default stopword list: There are different versions of stopwords, the stop words listed below ...
Definition: fts0fts.cc:120
dberr_t fts_get_next_doc_id(const dict_table_t *table, doc_id_t *doc_id)
Get the next available document id.
Definition: fts0fts.cc:2765
fts_index_cache_t * fts_cache_index_cache_create(dict_table_t *table, dict_index_t *index)
Create a FTS index cache.
Definition: fts0fts.cc:819
dberr_t fts_query(trx_t *trx, dict_index_t *index, uint flags, const byte *query_str, ulint query_len, fts_result_t **result, ulonglong limit)
FTS Query entry point.
Definition: fts0que.cc:3619
void fts_savepoint_rollback(trx_t *trx, const char *name)
Rollback to and including savepoint identified by name.
Definition: fts0fts.cc:5696
bool fts_drop_dd_tables(const aux_name_vec_t *aux_vec, bool file_per_table)
Drop FTS AUX table DD table objects in vector.
Definition: fts0fts.cc:1237
bool fts_check_common_tables_exist(const dict_table_t *table)
Check if common tables already exist.
Definition: fts0fts.cc:1866
doc_id_t fts_get_max_doc_id(dict_table_t *table)
Get maximum Doc ID in a table if index "FTS_DOC_ID_INDEX" exists.
Definition: fts0fts.cc:3748
void fts_add_index(dict_index_t *index, dict_table_t *table)
Add a newly create index in FTS cache.
Definition: fts0fts.cc:580
char * fts_internal_tbl_name
Variable specifying the table that has Fulltext index to display its content through information sche...
Definition: fts0fts.cc:112
const char * FTS_SUFFIX_CONFIG
Definition: fts0fts.cc:140
void fts_savepoint_take(fts_trx_t *fts_trx, const char *name)
Take a FTS savepoint.
Definition: fts0fts.cc:5512
enum fts_status fts_status_t
Definition: fts0fts.h:360
void fts_cache_index_cache_remove(dict_table_t *table, dict_index_t *index)
Remove a FTS index cache.
Definition: fts0fts.cc:863
void fts_optimize_init(void)
Startup the optimize thread and create the work queue.
Definition: fts0opt.cc:2951
void fts_trx_free(fts_trx_t *fts_trx)
Free an FTS trx.
Definition: fts0fts.cc:5117
void fts_update_next_doc_id(trx_t *trx, const dict_table_t *table, const char *table_name, doc_id_t doc_id)
Update the next and last Doc ID in the CONFIG table to be the input "doc_id" value (+ 1).
Definition: fts0fts.cc:2748
dberr_t fts_optimize_table(dict_table_t *table)
Run OPTIMIZE on the given table.
Definition: fts0opt.cc:2335
ulong fts_max_cache_size
Variable specifying the maximum FTS cache size for each table.
Definition: fts0fts.cc:75
void fts_free_aux_names(aux_name_vec_t *aux_vec)
Free FTS AUX table names in vector.
Definition: fts0fts.cc:1259
void fts_savepoint_release(trx_t *trx, const char *name)
Release the savepoint data identified by name.
Definition: fts0fts.cc:5558
doc_id_t fts_init_doc_id(const dict_table_t *table)
Get the initial Doc ID by consulting the CONFIG table.
Definition: fts0fts.cc:4890
dberr_t fts_sync_table(dict_table_t *table, bool unlock_cache, bool wait, bool has_dict)
Run SYNC on the table, i.e., write out data from the cache to the FTS auxiliary INDEX table and clear...
Definition: fts0fts.cc:4455
fts_t * fts_create(dict_table_t *table)
Create an instance of fts_t.
Definition: fts0fts.cc:5430
ulong fts_max_token_size
Variable specifying the maximum FTS max token size.
Definition: fts0fts.cc:89
void fts_doc_ids_free(fts_doc_ids_t *doc_ids)
Free a fts_doc_ids_t.
Definition: fts0fts.cc:2994
fts_table_type_t
The FTS table types.
Definition: fts0fts.h:187
@ FTS_INDEX_TABLE
FTS auxiliary table that is specific to a particular FTS index on a table.
Definition: fts0fts.h:188
@ FTS_OBSOLETED_TABLE
FTS obsoleted tables like DOC_ID, ADDED, STOPWORDS.
Definition: fts0fts.h:195
@ FTS_COMMON_TABLE
FTS auxiliary table that is common for all FTS index on a table.
Definition: fts0fts.h:192
bool innobase_fts_drop_dd_table(const char *name, bool file_per_table)
Drop dd table & tablespace for fts aux table.
bool fts_load_stopword(const dict_table_t *table, trx_t *trx, const char *global_stopword_table, const char *session_stopword_table, bool stopword_is_on, bool reload)
This function loads specified stopword into FTS cache.
Definition: fts0fts.cc:5945
int innobase_fts_text_cmp_prefix(const void *cs, const void *p1, const void *p2)
Compare two character string according to their charset.
Definition: ha_innodb.cc:8126
void fts_cache_init(fts_cache_t *cache)
Initialize things in cache.
Definition: fts0fts.cc:498
dberr_t fts_create_index_tables_low(trx_t *trx, dict_index_t *index, const char *table_name, table_id_t table_id)
Create auxiliary index tables for an FTS index.
Definition: fts0fts.cc:2269
int innobase_fts_text_cmp(const void *cs, const void *p1, const void *p2)
Compare two character string according to their charset.
Definition: ha_innodb.cc:8053
doc_id_t fts_get_doc_id_from_row(dict_table_t *table, dtuple_t *row)
Extract the doc id from the FTS hidden column.
Definition: fts0fts.cc:5156
bool fts_check_cached_index(dict_table_t *table)
Check indexes in the fts->indexes is also present in index cache and table->indexes list.
Definition: fts0fts.cc:673
dberr_t fts_drop_tables(trx_t *trx, dict_table_t *table, aux_name_vec_t *aux_vec)
Drops the ancillary tables needed for supporting an FTS index on a given table.
Definition: fts0fts.cc:1644
doc_id_t fts_get_doc_id_from_rec(dict_table_t *table, const rec_t *rec, const dict_index_t *index, mem_heap_t *heap)
Extract the doc id from the record that belongs to index.
Definition: fts0fts.cc:5181
bool fts_init_index(dict_table_t *table, bool has_cache_lock)
This function brings FTS index in sync when FTS index is first used.
Definition: fts0fts.cc:6195
dberr_t fts_drop_index(dict_table_t *table, dict_index_t *index, trx_t *trx, aux_name_vec_t *aux_vec)
Drop auxiliary tables related to an FTS index.
Definition: fts0fts.cc:708
bool fts_create_common_dd_tables(const dict_table_t *table)
Update DD system table for auxiliary common tables for an FTS index.
Definition: fts0fts.cc:2173
ulint fts_get_rows_count(fts_table_t *fts_table)
Fetch COUNT(*) from specified table.
Definition: fts0fts.cc:4956
bool fts_need_sync
Whether the total memory used for FTS cache is exhausted, and we will need a sync to free some memory...
Definition: fts0fts.cc:79
const char * FTS_SUFFIX_BEING_DELETED
Definition: fts0fts.cc:138
bool fts_enable_diag_print
Variable specifying whether we do additional FTS diagnostic printout in the log.
Definition: fts0opt.cc:260
dberr_t fts_drop_index_tables(trx_t *trx, dict_index_t *index, aux_name_vec_t *aux_vec)
Since we do a horizontal split on the index table, we need to drop all the split tables.
Definition: fts0fts.cc:1483
dberr_t fts_rename_aux_tables(dict_table_t *table, const char *new_name, trx_t *trx, bool replay)
Rename auxiliary tables for all fts index for a table.
Definition: fts0fts.cc:1386
constexpr size_t FTS_NUM_AUX_INDEX
The number of FTS index partitions for a fulltext index.
Definition: fts0fts.h:107
void fts_detach_aux_tables(const dict_table_t *table, bool dict_locked)
Allow all the auxiliary tables of specified base table to be evictable if they exist,...
Definition: fts0fts.cc:2108
const char * FTS_PREFIX
FTS auxiliary table prefix that are common to all FT indexes.
Definition: fts0fts.cc:128
void fts_optimize_remove_table(dict_table_t *table)
Remove the table from the OPTIMIZER's list.
Definition: fts0opt.cc:2485
dberr_t fts_create_common_tables(trx_t *trx, const dict_table_t *table, const char *name, bool skip_doc_id_index)
Creates the common auxiliary tables needed for supporting an FTS index on the given table.
Definition: fts0fts.cc:1914
ulong fts_min_token_size
Variable specifying the minimum FTS max token size.
Definition: fts0fts.cc:92
CHARSET_INFO * fts_index_get_charset(dict_index_t *index)
Create an FTS index cache.
Definition: fts0fts.cc:784
fts_cache_t * fts_cache_create(dict_table_t *table)
Create a FTS cache.
Definition: fts0fts.cc:527
fts_status
Definition: fts0fts.h:344
@ BG_THREAD_STOP
true if the FTS background thread has finished reading the ADDED table, meaning more items can be add...
Definition: fts0fts.h:345
@ BG_THREAD_READY
true if the FTS background thread is ready
Definition: fts0fts.h:350
@ ADDED_TABLE_SYNCED
true if the ADDED table record is sync-ed after crash recovery
Definition: fts0fts.h:356
@ ADD_THREAD_STARTED
true if the FTS add thread has started
Definition: fts0fts.h:353
CHARSET_INFO * fts_valid_stopword_table(const char *stopword_table_name)
Check whether user supplied stopword table exists and is of the right format.
Definition: fts0fts.cc:5884
dberr_t fts_upgrade_rename(const dict_table_t *table, bool rollback)
Rename FTS AUX tablespace name from 8.0 format to 5.7 format.
Definition: fts0fts.cc:6449
dberr_t fts_lock_all_aux_tables(THD *thd, dict_table_t *table)
Lock all FTS AUX tables (for dropping table)
Definition: fts0fts.cc:1743
const char * FTS_PREFIX_5_7
FTS auxiliary table prefix that are common to all FT indexes.
Definition: fts0fts.cc:131
dberr_t fts_commit(trx_t *trx)
The given transaction is about to be committed; do whatever is necessary from the FTS system's POV.
Definition: fts0fts.cc:3224
void fts_cache_clear(fts_cache_t *cache)
Clear cache.
Definition: fts0fts.cc:914
void fts_freeze_aux_tables(const dict_table_t *table)
Freeze all auiliary tables to be not evictable if exist, with dict_mutex held.
Definition: fts0fts.cc:2054
dberr_t fts_empty_common_tables(trx_t *trx, dict_table_t *table)
Empty all common talbes.
Definition: fts0fts.cc:1580
char * fts_get_parent_table_name(const char *aux_table_name, ulint aux_table_len)
ulong fts_max_total_cache_size
Variable specifying the total memory allocated for FTS cache.
Definition: fts0fts.cc:82
void fts_savepoint_rollback_last_stmt(trx_t *trx)
Rollback to and including savepoint identified by name.
Definition: fts0fts.cc:5656
void fts_savepoint_laststmt_refresh(trx_t *trx)
Refresh last statement savepoint.
Definition: fts0fts.cc:5595
void fts_free(dict_table_t *table)
Free the FTS resources.
Definition: fts0fts.cc:5445
ulong fts_num_word_optimize
Variable specifying the number of word to optimize for each optimize table call.
Definition: fts0opt.cc:257
ulint innobase_mysql_fts_get_token(CHARSET_INFO *charset, const byte *start, const byte *end, fts_string_t *token)
Get the next token from the given string and store it in *token.
Definition: ha_innodb.cc:8168
float fts_rank_t
FTS rank type, which will be between 0 .
Definition: fts0fts.h:164
const char * FTS_SUFFIX_DELETED
Definition: fts0fts.cc:141
dberr_t fts_table_fetch_doc_ids(trx_t *trx, fts_table_t *fts_table, fts_doc_ids_t *doc_ids)
Read the rows from the FTS index.
Definition: fts0opt.cc:931
void fts_query_free_result(fts_result_t *result)
FTS Query free result, returned by fts_query().
Definition: fts0que.cc:3831
ulint fts_get_token_size(const CHARSET_INFO *cs, const char *token, ulint len)
Get token char size by charset.
Definition: fts0fts.cc:4659
constexpr size_t FTS_NUM_AUX_COMMON
The number of FTS AUX common table for a fulltext index.
Definition: fts0fts.h:110
fts_row_state
Type of a row during a transaction.
Definition: fts0fts.h:178
@ FTS_DELETE
Definition: fts0fts.h:181
@ FTS_INVALID
Definition: fts0fts.h:183
@ FTS_MODIFY
Definition: fts0fts.h:180
@ FTS_NOTHING
Definition: fts0fts.h:182
@ FTS_INSERT
Definition: fts0fts.h:179
unsigned short ib_uc_t
Since MySQL's character set support for Unicode is woefully inadequate (it supports basic operations ...
Definition: fts0fts.h:290
const char * FTS_SUFFIX_DELETED_CACHE
Definition: fts0fts.cc:142
void fts_trx_add_op(trx_t *trx, dict_table_t *table, doc_id_t doc_id, fts_row_state state, ib_vector_t *fts_indexes)
Notify the FTS system about an operation on an FTS-indexed table.
Definition: fts0fts.cc:2638
bool fts_is_aux_table_name(fts_aux_table_t *table, const char *name, ulint len)
Check if a table is an FTS auxiliary table name.
Definition: fts0fts.cc:5754
Prototypes for global functions in ha_innodb.cc that are called by InnoDB C code.
The simple hash table utility.
static int flags[50]
Definition: hp_test1.cc:39
static void start(mysql_harness::PluginFuncEnv *env)
Definition: http_auth_backend_plugin.cc:176
The memory management.
unsigned long long int ulonglong
Definition: my_inttypes.h:55
static PFS_engine_table_share_proxy table
Definition: pfs.cc:60
const std::string charset("charset")
Definition: commit_order_queue.h:33
static int wait(mysql_cond_t *that, mysql_mutex_t *mutex_arg, const char *, unsigned int)
Definition: mysql_cond_v1_native.cc:62
const char * table_name
Definition: rules_table_service.cc:55
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:191
Query graph global types.
Record manager global types.
byte rec_t
Definition: rem0types.h:40
static bool reload(MYSQL_THD thd)
Reloads the rules into the in-memory table.
Definition: rewriter_plugin.cc:332
Row operation global types.
static bool rollback(THD *thd)
Abort the current statement and transaction.
Definition: sql_cmd_srs.cc:139
case opt name
Definition: sslopt-case.h:32
Definition: m_ctype.h:422
Definition: plugin_ftparser.h:194
Structure to manage FTS AUX table name and MDL during its drop.
Definition: fts0fts.h:167
std::vector< char * > aux_name
AUX table name.
Definition: fts0fts.h:169
Data structure for an index.
Definition: dict0mem.h:1045
Data structure for a database table.
Definition: dict0mem.h:1908
Structure for an SQL data tuple of fields (logical record)
Definition: data0data.h:681
For storing table info when checking for orphaned tables.
Definition: fts0fts.h:901
fts_table_type_t type
FTS table type.
Definition: fts0fts.h:915
table_id_t index_id
Table FT index id.
Definition: fts0fts.h:909
char * name
Name of the table.
Definition: fts0fts.h:912
table_id_t id
Table id.
Definition: fts0fts.h:903
table_id_t parent_id
Parent table id.
Definition: fts0fts.h:906
The cache for the FTS system.
Definition: fts0types.h:145
List of document ids that were added during a transaction.
Definition: fts0fts.h:276
ib_vector_t * doc_ids
document ids (each element is of type doc_id_t).
Definition: fts0fts.h:277
ib_alloc_t * self_heap
Allocator used to create an instance of this type and the doc_ids vector.
Definition: fts0fts.h:280
This type represents a single document field.
Definition: fts0types.h:273
Since we can have multiple FTS indexes on a table, we keep a per index cache of words etc.
Definition: fts0types.h:72
Query ranked doc ids.
Definition: fts0fts.h:301
ulint words_len
words len
Definition: fts0fts.h:309
fts_rank_t rank
Rank is between 0 .
Definition: fts0fts.h:304
byte * words
this contains the words that were queried and found in this document
Definition: fts0fts.h:306
doc_id_t doc_id
Document id.
Definition: fts0fts.h:302
Query result.
Definition: fts0fts.h:313
ib_rbt_t * rankings_by_id
RB tree of type fts_ranking_t indexed by doc id.
Definition: fts0fts.h:316
ib_rbt_t * rankings_by_rank
RB tree of type fts_ranking_t indexed by rank.
Definition: fts0fts.h:318
ib_rbt_node_t * current
Current element.
Definition: fts0fts.h:314
Information required for transaction savepoint handling.
Definition: fts0fts.h:240
ib_rbt_t * tables
Modified FTS tables.
Definition: fts0fts.h:245
char * name
First entry is always NULL, the default instance.
Definition: fts0fts.h:241
Stop word control infotmation.
Definition: fts0types.h:106
ib_alloc_t * heap
The memory allocator to use.
Definition: fts0types.h:108
An UTF-16 ro UTF-8 string.
Definition: fts0fts.h:293
ulint f_n_char
Number of characters.
Definition: fts0fts.h:297
ulint f_len
Length of the string in bytes.
Definition: fts0fts.h:296
byte * f_str
string, not necessary terminated in any way
Definition: fts0fts.h:294
This is used to generate the FTS auxiliary table name, we need the table id and the index id to gener...
Definition: fts0fts.h:325
space_index_t index_id
The index id.
Definition: fts0fts.h:334
CHARSET_INFO * charset
charset info if it is for FTS index auxiliary table
Definition: fts0fts.h:340
fts_table_type_t type
The auxiliary table type.
Definition: fts0fts.h:330
const dict_table_t * table
Parent table.
Definition: fts0fts.h:339
table_id_t table_id
The table id.
Definition: fts0fts.h:332
const char * suffix
The suffix of the fts auxiliary table name, can be NULL, not used everywhere (yet)
Definition: fts0fts.h:336
const char * parent
Parent table name, this is required only for the database name.
Definition: fts0fts.h:326
A token and its positions within a document.
Definition: fts0types.h:299
Information about one changed row in a transaction.
Definition: fts0fts.h:265
doc_id_t doc_id
Id of the ins/upd/del document.
Definition: fts0fts.h:266
fts_row_state state
state of the row
Definition: fts0fts.h:268
ib_vector_t * fts_indexes
The indexes that are affected.
Definition: fts0fts.h:270
Information about changes in a single transaction affecting the FTS system.
Definition: fts0fts.h:228
ib_vector_t * last_stmt
last_stmt
Definition: fts0fts.h:234
mem_heap_t * heap
heap
Definition: fts0fts.h:236
trx_t * trx
InnoDB transaction.
Definition: fts0fts.h:229
ib_vector_t * savepoints
Active savepoints, must have at least one element, the implied savepoint.
Definition: fts0fts.h:231
Information about changed rows in a transaction for a single table.
Definition: fts0fts.h:249
ib_rbt_t * rows
rows changed; indexed by doc-id, cells are fts_trx_row_t*
Definition: fts0fts.h:254
fts_trx_t * fts_trx
link to parent
Definition: fts0fts.h:252
dict_table_t * table
table
Definition: fts0fts.h:250
que_t * docs_added_graph
Definition: fts0fts.h:261
fts_doc_ids_t * added_doc_ids
list of added doc ids (NULL until the first addition)
Definition: fts0fts.h:257
Definition: ut0vec.h:203
Red black tree node.
Definition: ut0rbt.h:60
Red black tree instance.
Definition: ut0rbt.h:71
Definition: ut0vec.h:212
Definition: ut0wqueue.cc:42
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:301
Definition: que0que.h:300
Definition: result.h:29
Definition: trx0trx.h:683
Definition: row0upd.h:466
Transaction system global type definitions.
unsigned long int ulint
Definition: univ.i:405
Various utilities.
A vector of pointers to data items.
A work queue.