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