MySQL 8.0.31
Source Code Documentation
fts0priv.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 2011, 2022, 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/fts0priv.h
28 Full text search internal header file
29
30 Created 2011/09/02 Sunny Bains
31 ***********************************************************************/
32
33#ifndef INNOBASE_FTS0PRIV_H
34#define INNOBASE_FTS0PRIV_H
35
36#include "dict0dict.h"
37#include "fts0types.h"
38#include "pars0pars.h"
39#include "que0que.h"
40#include "que0types.h"
41#include "univ.i"
42
43/* The various states of the FTS sub system pertaining to a table with
44FTS indexes defined on it. */
46 /* !<This must be 0 since we insert
47 a hard coded '0' at create time
48 to the config table */
49
50 FTS_TABLE_STATE_RUNNING = 0, /*!< Auxiliary tables created OK */
51
52 FTS_TABLE_STATE_OPTIMIZING, /*!< This is a substate of RUNNING */
53
54 FTS_TABLE_STATE_DELETED /*!< All aux tables to be dropped when
55 it's safe to do so */
56};
57
59
60/** The default time to wait for the background thread. */
61constexpr std::chrono::milliseconds FTS_MAX_BACKGROUND_THREAD_WAIT{10};
62
63/** Maximum number of iterations to wait before we complain */
64#define FTS_BACKGROUND_THREAD_WAIT_COUNT 1000
65
66/** The maximum length of the config table's value column in bytes */
67#define FTS_MAX_CONFIG_NAME_LEN 64
68
69/** The maximum length of the config table's value column in bytes */
70#define FTS_MAX_CONFIG_VALUE_LEN 1024
71
72/** Approx. upper limit of ilist length in bytes. */
73#define FTS_ILIST_MAX_SIZE (64 * 1024)
74
75/** FTS config table name parameters */
76
77/** The number of seconds after which an OPTIMIZE run will stop */
78#define FTS_OPTIMIZE_LIMIT_IN_SECS "optimize_checkpoint_limit"
79
80/** The next doc id */
81#define FTS_SYNCED_DOC_ID "synced_doc_id"
82
83/** The last word that was OPTIMIZED */
84#define FTS_LAST_OPTIMIZED_WORD "last_optimized_word"
85
86/** Total number of documents that have been deleted. The next_doc_id
87minus this count gives us the total number of documents. */
88#define FTS_TOTAL_DELETED_COUNT "deleted_doc_count"
89
90/** Total number of words parsed from all documents */
91#define FTS_TOTAL_WORD_COUNT "total_word_count"
92
93/** Start of optimize of an FTS index */
94#define FTS_OPTIMIZE_START_TIME "optimize_start_time"
95
96/** End of optimize for an FTS index */
97#define FTS_OPTIMIZE_END_TIME "optimize_end_time"
98
99/** User specified stopword table name */
100#define FTS_STOPWORD_TABLE_NAME "stopword_table_name"
101
102/** Whether to use (turn on/off) stopword */
103#define FTS_USE_STOPWORD "use_stopword"
104
105/** State of the FTS system for this table. It can be one of
106 RUNNING, OPTIMIZING, DELETED. */
107#define FTS_TABLE_STATE "table_state"
108
109/** The minimum length of an FTS auxiliary table names's id component
110e.g., For an auxiliary table name
111
112 "FTS_@<TABLE_ID@>_SUFFIX"
113
114This constant is for the minimum length required to store the @<TABLE_ID@>
115component.
116*/
117#define FTS_AUX_MIN_TABLE_ID_LENGTH 48
118
119/** Maximum length of an integer stored in the config table value column. */
120#define FTS_MAX_INT_LEN 32
121
122/** Parse an SQL string. %s is replaced with the table's id.
123 @return query graph */
124[[nodiscard]] que_t *fts_parse_sql(
125 fts_table_t *fts_table, /*!< in: FTS aux table */
126 pars_info_t *info, /*!< in: info struct, or NULL */
127 const char *sql); /*!< in: SQL string to evaluate */
128
129/** Evaluate a parsed SQL statement
130 @return DB_SUCCESS or error code */
131[[nodiscard]] dberr_t fts_eval_sql(trx_t *trx, /*!< in: transaction */
132 que_t *graph); /*!< in: Parsed statement */
133
134/** Construct the name of an ancillary FTS table for the given table.
135 Caller must allocate enough memory(usually size of MAX_FULL_NAME_LEN)
136 for param 'table_name'. */
138 const fts_table_t *fts_table, /*!< in: FTS aux table info */
139 char *table_name); /*!< in/out: aux table name */
140
141/** Construct the name of an ancillary FTS table for the given table in
1425.7 compatible format. Caller must allocate enough memory(usually size
143of MAX_FULL_NAME_LEN) for param 'table_name'
144@param[in] fts_table Auxiliary table object
145@param[in,out] table_name aux table name */
146void fts_get_table_name_5_7(const fts_table_t *fts_table, char *table_name);
147
148/** Construct the column specification part of the SQL string for selecting the
149 indexed FTS columns for the given table. Adds the necessary bound
150 ids to the given 'info' and returns the SQL string. Examples:
151
152 One indexed column named "text":
153
154 "$sel0",
155 info/ids: sel0 -> "text"
156
157 Two indexed columns named "subject" and "content":
158
159 "$sel0, $sel1",
160 info/ids: sel0 -> "subject", sel1 -> "content",
161 @return heap-allocated WHERE string */
162[[nodiscard]] const char *fts_get_select_columns_str(
163 dict_index_t *index, /*!< in: FTS index */
164 pars_info_t *info, /*!< in/out: parser info */
165 mem_heap_t *heap); /*!< in: memory heap */
166
167/** define for fts_doc_fetch_by_doc_id() "option" value, defines whether
168we want to get Doc whose ID is equal to or greater or smaller than supplied
169ID */
170#define FTS_FETCH_DOC_BY_ID_EQUAL 1
171#define FTS_FETCH_DOC_BY_ID_LARGE 2
172
173/** Fetch document (= a single row's indexed text) with the given
174 document id.
175 @return: DB_SUCCESS if fetch is successful, else error */
177 fts_get_doc_t *get_doc, /*!< in: state */
178 doc_id_t doc_id, /*!< in: id of document to fetch */
179 dict_index_t *index_to_use, /*!< in: caller supplied FTS index,
180 or NULL */
181 ulint option, /*!< in: search option, if it is
182 greater than doc_id or equal */
183 fts_sql_callback callback, /*!< in: callback to read
184 records */
185 void *arg); /*!< in: callback arg */
186
187/** Callback function for fetch that stores the text of an FTS document,
188 converting each column to UTF-16.
189 @return always false */
190bool fts_query_expansion_fetch_doc(void *row, /*!< in: sel_node_t* */
191 void *user_arg); /*!< in: fts_doc_t* */
192
193/********************************************************************
194Write out a single word's data as new entry/entries in the INDEX table.
195@return DB_SUCCESS if all OK. */
196[[nodiscard]] dberr_t fts_write_node(
197 trx_t *trx, /*!< in: transaction */
198 que_t **graph, /*!< in: query graph */
199 fts_table_t *fts_table, /*!< in: the FTS aux index */
200 fts_string_t *word, /*!< in: word in UTF-8 */
201 fts_node_t *node); /*!< in: node columns */
202
203/** Check fts token
2041. for ngram token, check whether the token contains any words in stopwords
2052. for non-ngram token, check if it's stopword or less than fts_min_token_size
206or greater than fts_max_token_size.
207@param[in] token token string
208@param[in] stopwords stopwords rb tree
209@param[in] is_ngram is ngram parser
210@param[in] cs token charset
211@retval true if it is not stopword and length in range
212@retval false if it is stopword or length not in range */
213bool fts_check_token(const fts_string_t *token, const ib_rbt_t *stopwords,
214 bool is_ngram, const CHARSET_INFO *cs);
215
216/** Initialize a document. */
217void fts_doc_init(fts_doc_t *doc); /*!< in: doc to initialize */
218
219/** Do a binary search for a doc id in the array
220 @return +ve index if found -ve index where it should be
221 inserted if not found */
222[[nodiscard]] int fts_bsearch(fts_update_t *array, /*!< in: array to sort */
223 int lower, /*!< in: lower bound of array*/
224 int upper, /*!< in: upper bound of array*/
225 doc_id_t doc_id); /*!< in: doc id to lookup */
226/** Free document. */
227void fts_doc_free(fts_doc_t *doc); /*!< in: document */
228
229/** Free fts_optimizer_word_t instanace.*/
230void fts_word_free(fts_word_t *word); /*!< in: instance to free.*/
231
232/** Read the rows from the FTS inde
233 @return DB_SUCCESS or error code */
235 trx_t *trx, /*!< in: transaction */
236 que_t **graph, /*!< in: prepared statement */
237 fts_table_t *fts_table, /*!< in: FTS aux table */
238 const fts_string_t *word, /*!< in: the word to fetch */
239 fts_fetch_t *fetch); /*!< in: fetch callback.*/
240
241/** Compare two fts_trx_table_t instances, we actually compare the
242table id's here.
243@param[in] v1 id1
244@param[in] v2 id2
245@return < 0 if n1 < n2, 0 if n1 == n2, > 0 if n1 > n2 */
246static inline int fts_trx_table_cmp(const void *v1, const void *v2);
247
248/** Compare a table id with a trx_table_t table id.
249@param[in] p1 id1
250@param[in] p2 id2
251@return < 0 if n1 < n2, 0 if n1 == n2, > 0 if n1 > n2 */
252static inline int fts_trx_table_id_cmp(const void *p1, const void *p2);
253
254/** Commit a transaction.
255 @return DB_SUCCESS if all OK */
256dberr_t fts_sql_commit(trx_t *trx); /*!< in: transaction */
257
258/** Rollback a transaction.
259 @return DB_SUCCESS if all OK */
260dberr_t fts_sql_rollback(trx_t *trx); /*!< in: transaction */
261
262/** Get value from config table. The caller must ensure that enough
263 space is allocated for value to hold the column contents
264 @return DB_SUCCESS or error code */
266 trx_t *trx, /* transaction */
267 fts_table_t *fts_table, /*!< in: the indexed FTS table */
268 const char *name, /*!< in: get config value for
269 this parameter name */
270 fts_string_t *value); /*!< out: value read from
271 config table */
272/** Get value specific to an FTS index from the config table. The caller
273 must ensure that enough space is allocated for value to hold the
274 column contents.
275 @return DB_SUCCESS or error code */
277 trx_t *trx, /*!< transaction */
278 dict_index_t *index, /*!< in: index */
279 const char *param, /*!< in: get config value
280 for this parameter name */
281 fts_string_t *value); /*!< out: value read
282 from config table */
283
284/** Set the value in the config table for name.
285 @return DB_SUCCESS or error code */
287 trx_t *trx, /*!< transaction */
288 fts_table_t *fts_table, /*!< in: the indexed FTS table */
289 const char *name, /*!< in: get config value for
290 this parameter name */
291 const fts_string_t *value); /*!< in: value to update */
292
293/** Set an ulint value in the config table.
294 @return DB_SUCCESS if all OK else error code */
295[[nodiscard]] dberr_t fts_config_set_ulint(
296 trx_t *trx, /*!< in: transaction */
297 fts_table_t *fts_table, /*!< in: the indexed FTS table */
298 const char *name, /*!< in: param name */
299 ulint int_value); /*!< in: value */
300
301/** Set the value specific to an FTS index in the config table.
302 @return DB_SUCCESS or error code */
304 trx_t *trx, /*!< transaction */
305 dict_index_t *index, /*!< in: index */
306 const char *param, /*!< in: get config value
307 for this parameter name */
308 fts_string_t *value); /*!< out: value read
309 from config table */
310
311#ifdef FTS_OPTIMIZE_DEBUG
312/** Get an ulint value from the config table.
313 @return DB_SUCCESS or error code */
314[[nodiscard]] dberr_t fts_config_get_index_ulint(
315 trx_t *trx, /*!< in: transaction */
316 dict_index_t *index, /*!< in: FTS index */
317 const char *name, /*!< in: param name */
318 ulint *int_value); /*!< out: value */
319
320/** Set an ulint value int the config table.
321 @return DB_SUCCESS or error code */
322[[nodiscard]] dberr_t fts_config_set_index_ulint(
323 trx_t *trx, /*!< in: transaction */
324 dict_index_t *index, /*!< in: FTS index */
325 const char *name, /*!< in: param name */
326 ulint int_value); /*!< in: value */
327#endif /* FTS_OPTIMIZE_DEBUG */
328
329/** Get an ulint value from the config table.
330 @return DB_SUCCESS or error code */
332 trx_t *trx, /*!< in: transaction */
333 fts_table_t *fts_table, /*!< in: the indexed FTS table */
334 const char *name, /*!< in: param name */
335 ulint *int_value); /*!< out: value */
336
337/** Search cache for word.
338 @return the word node vector if found else NULL */
339[[nodiscard]] const ib_vector_t *fts_cache_find_word(
340 const fts_index_cache_t *index_cache, /*!< in: cache to search */
341 const fts_string_t *text); /*!< in: word to search for */
342
343/** Append deleted doc ids to vector and sort the vector. */
345 const fts_cache_t *cache, /*!< in: cache to use */
346 ib_vector_t *vector); /*!< in: append to this vector */
347/** Wait for the background thread to start. We poll to detect change
348of state, which is acceptable, since the wait should happen only
349once during startup.
350@param[in] table table to which the thread is attached
351@param[in] max_wait Time to wait. If set to 0 then it disables timeout checking
352@return true if the thread started else false (i.e timed out) */
354 dict_table_t *table, std::chrono::microseconds max_wait);
355/** Search the index specific cache for a particular FTS index.
356 @return the index specific cache else NULL */
358 const fts_cache_t *cache, /*!< in: cache to search */
359 const dict_index_t *index); /*!< in: index to search for */
360
361/** Write the table id to the given buffer (including final NUL). Buffer must
362be at least FTS_AUX_MIN_TABLE_ID_LENGTH bytes long.
363@param[in] id a table/index id
364@param[in] str buffer to write the id to
365@return number of bytes written */
366static inline int fts_write_object_id(ib_id_t id, char *str);
367
368/** Read the table id from the string generated by fts_write_object_id().
369@param[out] id Table ID.
370@param[in] str Buffer to read from.
371@return true if parse successful */
372[[nodiscard]] static inline bool fts_read_object_id(ib_id_t *id,
373 const char *str);
374
375/** Get the table id.
376 @return number of bytes written */
377[[nodiscard]] int fts_get_table_id(
378 const fts_table_t *fts_table, /*!< in: FTS Auxiliary table */
379 char *table_id); /*!< out: table id, must be at least
380 FTS_AUX_MIN_TABLE_ID_LENGTH bytes
381 long */
382
383/** Add the table to add to the OPTIMIZER's list. */
384void fts_optimize_add_table(dict_table_t *table); /*!< in: table to add */
385
386/** Construct the prefix name of an FTS table.
387 @return own: table name, must be freed with ut::free() */
388[[nodiscard]] char *fts_get_table_name_prefix(
389 const fts_table_t *fts_table); /*!< in: Auxiliary table type */
390
391/** Add node positions. */
393 fts_cache_t *cache, /*!< in: cache */
394 fts_node_t *node, /*!< in: word node */
395 doc_id_t doc_id, /*!< in: doc id */
396 ib_vector_t *positions); /*!< in: fts_token_t::positions */
397
398/** Create the config table name for retrieving index specific value.
399 @return index config parameter name */
400[[nodiscard]] char *fts_config_create_index_param_name(
401 const char *param, /*!< in: base name of param */
402 const dict_index_t *index); /*!< in: index for config */
403
404#include "fts0priv.ic"
405
406#endif /* INNOBASE_FTS0PRIV_H */
dberr_t
Definition: db0err.h:38
Data dictionary system.
uint64_t doc_id_t
Document id type.
Definition: fts0fts.h:76
const char * fts_get_select_columns_str(dict_index_t *index, pars_info_t *info, mem_heap_t *heap)
Construct the column specification part of the SQL string for selecting the indexed FTS columns for t...
Definition: fts0sql.cc:276
static int fts_trx_table_cmp(const void *v1, const void *v2)
Compare two fts_trx_table_t instances, we actually compare the table id's here.
dberr_t fts_config_get_index_value(trx_t *trx, dict_index_t *index, const char *param, fts_string_t *value)
Get value specific to an FTS index from the config table.
Definition: fts0config.cc:151
enum fts_table_state_enum fts_table_state_t
Definition: fts0priv.h:58
void fts_doc_free(fts_doc_t *doc)
Free document.
Definition: fts0fts.cc:3256
dberr_t fts_sql_rollback(trx_t *trx)
Rollback a transaction.
Definition: fts0sql.cc:316
fts_index_cache_t * fts_find_index_cache(const fts_cache_t *cache, const dict_index_t *index)
Search the index specific cache for a particular FTS index.
Definition: fts0fts.cc:5215
dberr_t fts_doc_fetch_by_doc_id(fts_get_doc_t *get_doc, doc_id_t doc_id, dict_index_t *index_to_use, ulint option, fts_sql_callback callback, void *arg)
Fetch document (= a single row's indexed text) with the given document id.
Definition: fts0fts.cc:3810
constexpr std::chrono::milliseconds FTS_MAX_BACKGROUND_THREAD_WAIT
The default time to wait for the background thread.
Definition: fts0priv.h:61
que_t * fts_parse_sql(fts_table_t *fts_table, pars_info_t *info, const char *sql)
Parse an SQL string.
Definition: fts0sql.cc:192
fts_table_state_enum
Definition: fts0priv.h:45
@ FTS_TABLE_STATE_OPTIMIZING
This is a substate of RUNNING.
Definition: fts0priv.h:52
@ FTS_TABLE_STATE_DELETED
All aux tables to be dropped when it's safe to do so.
Definition: fts0priv.h:54
@ FTS_TABLE_STATE_RUNNING
Auxiliary tables created OK.
Definition: fts0priv.h:50
dberr_t fts_config_set_ulint(trx_t *trx, fts_table_t *fts_table, const char *name, ulint int_value)
Set an ulint value in the config table.
Definition: fts0config.cc:366
dberr_t fts_config_get_value(trx_t *trx, fts_table_t *fts_table, const char *name, fts_string_t *value)
Get value from config table.
Definition: fts0config.cc:70
static int fts_trx_table_id_cmp(const void *p1, const void *p2)
Compare a table id with a trx_table_t table id.
int fts_bsearch(fts_update_t *array, int lower, int upper, doc_id_t doc_id)
Do a binary search for a doc id in the array.
Definition: fts0opt.cc:964
dberr_t fts_index_fetch_nodes(trx_t *trx, que_t **graph, fts_table_t *fts_table, const fts_string_t *word, fts_fetch_t *fetch)
Read the rows from the FTS inde.
Definition: fts0opt.cc:461
void fts_optimize_add_table(dict_table_t *table)
Add the table to add to the OPTIMIZER's list.
Definition: fts0opt.cc:2422
dberr_t fts_write_node(trx_t *trx, que_t **graph, fts_table_t *fts_table, fts_string_t *word, fts_node_t *node)
in: node columns
Definition: fts0fts.cc:3930
dberr_t fts_sql_commit(trx_t *trx)
Commit a transaction.
Definition: fts0sql.cc:302
dberr_t fts_config_set_index_value(trx_t *trx, dict_index_t *index, const char *param, fts_string_t *value)
Set the value specific to an FTS index in the config table.
Definition: fts0config.cc:243
static int fts_write_object_id(ib_id_t id, char *str)
Write the table id to the given buffer (including final NUL).
dberr_t fts_config_set_value(trx_t *trx, fts_table_t *fts_table, const char *name, const fts_string_t *value)
Set the value in the config table for name.
Definition: fts0config.cc:177
bool fts_query_expansion_fetch_doc(void *row, void *user_arg)
Callback function for fetch that stores the text of an FTS document, converting each column to UTF-16...
Definition: fts0fts.cc:3272
char * fts_get_table_name_prefix(const fts_table_t *fts_table)
Construct the prefix name of an FTS table.
Definition: fts0sql.cc:134
void fts_cache_node_add_positions(fts_cache_t *cache, fts_node_t *node, doc_id_t doc_id, ib_vector_t *positions)
Add node positions.
Definition: fts0fts.cc:1052
bool fts_wait_for_background_thread_to_start(dict_table_t *table, std::chrono::microseconds max_wait)
Wait for the background thread to start.
Definition: fts0fts.cc:5276
void fts_doc_init(fts_doc_t *doc)
Initialize a document.
Definition: fts0fts.cc:3246
void fts_get_table_name(const fts_table_t *fts_table, char *table_name)
Construct the name of an ancillary FTS table for the given table.
Definition: fts0sql.cc:173
bool fts_check_token(const fts_string_t *token, const ib_rbt_t *stopwords, bool is_ngram, const CHARSET_INFO *cs)
Check fts token.
Definition: fts0fts.cc:4477
int fts_get_table_id(const fts_table_t *fts_table, char *table_id)
Get the table id.
Definition: fts0sql.cc:59
void fts_word_free(fts_word_t *word)
Free fts_optimizer_word_t instanace.
Definition: fts0opt.cc:1408
static bool fts_read_object_id(ib_id_t *id, const char *str)
Read the table id from the string generated by fts_write_object_id().
void fts_get_table_name_5_7(const fts_table_t *fts_table, char *table_name)
Construct the name of an ancillary FTS table for the given table in 5.7 compatible format.
Definition: fts0sql.cc:186
char * fts_config_create_index_param_name(const char *param, const dict_index_t *index)
Create the config table name for retrieving index specific value.
Definition: fts0config.cc:126
dberr_t fts_config_get_ulint(trx_t *trx, fts_table_t *fts_table, const char *name, ulint *int_value)
Get an ulint value from the config table.
Definition: fts0config.cc:335
const ib_vector_t * fts_cache_find_word(const fts_index_cache_t *index_cache, const fts_string_t *text)
Search cache for word.
Definition: fts0fts.cc:5227
void fts_cache_append_deleted_doc_ids(const fts_cache_t *cache, ib_vector_t *vector)
Append deleted doc ids to vector and sort the vector.
Definition: fts0fts.cc:5253
dberr_t fts_eval_sql(trx_t *trx, que_t *graph)
Evaluate a parsed SQL statement.
Definition: fts0sql.cc:248
Full text search internal header file.
Full text search types file.
pars_user_func_cb_t fts_sql_callback
Callbacks used within FTS.
Definition: fts0types.h:46
Log info(cout, "NOTE")
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1063
Definition: commit_order_queue.h:33
static std::string lower(std::string str)
Definition: config_parser.cc:67
static mysql_service_status_t fetch(const char *service_name, reference_caching_channel *out_channel) noexcept
Definition: component.cc:76
const char * table_name
Definition: rules_table_service.cc:55
std::vector< T, ut::allocator< T > > vector
Specialization of vector which uses allocator.
Definition: ut0new.h:2855
SQL parser.
Query graph.
Query graph global types.
case opt name
Definition: sslopt-case.h:32
Definition: m_ctype.h:382
Data structure for an index.
Definition: dict0mem.h:1021
Data structure for a database table.
Definition: dict0mem.h:1884
The cache for the FTS system.
Definition: fts0types.h:143
This type represents a single document.
Definition: fts0types.h:267
Callback for reading and filtering nodes that are read from FTS index.
Definition: fts0types.h:250
It's main purpose is to store the SQL prepared statements that are required to retrieve a document fr...
Definition: fts0types.h:60
Since we can have multiple FTS indexes on a table, we keep a per index cache of words etc.
Definition: fts0types.h:70
Columns of the FTS auxiliary INDEX table.
Definition: fts0types.h:210
An UTF-16 ro UTF-8 string.
Definition: fts0fts.h:291
This is used to generate the FTS auxiliary table name, we need the table id and the index id to gener...
Definition: fts0fts.h:323
For supporting the tracking of updates on multiple FTS indexes we need to track which FTS indexes nee...
Definition: fts0types.h:92
Word text plus it's array of nodes as on disk in FTS index.
Definition: fts0types.h:242
Red black tree instance.
Definition: ut0rbt.h:71
Definition: ut0vec.h:212
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:299
Extra information supplied for pars_sql().
Definition: pars0pars.h:451
Definition: que0que.h:300
Definition: trx0trx.h:680
Version control for database, common definitions, and include files.
uint64_t ib_id_t
The generic InnoDB system object identifier data type.
Definition: univ.i:444
unsigned long int ulint
Definition: univ.i:407