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