MDEV-28730 Remove internal parser usage from InnoDB fulltext

- Introduce a class FTSQueryRunner to handle queries for fulltext
internal tables. Basically it creates a query, prepares the
fulltext internal table for read or write process. Build a tuple
based on the given table and assign the FTS_CONFIG, FTS_COMMON_TABLES
and FTS_AUX_TABLE fields based on the given value. This class
also handles INSERT, DELETE, REPLACE, UPDATE and
execute the function for each record (record_executor).

FTSQueryRunner::create_query_thread(): Create a query thread to execute
the statement on internal FULLTEXT tables

FTSQueryRunner::build_tuple(): Build a tuple for the operation

FTSQueryRunner::build_clust_ref(): Build a clustered index reference
for clustered index lookup for the secondary index record

FTSQueryRunner::assign_config_fields(): Assign the tuple for the
FTS CONFIG internal table

FTSQueryRunner::assign_common_table_fields(): Assign the tuple for
FTS_DELETED, FTS_DELETED_CACHE, FTS_BEGIN_DELETED,
FTS_BEGIN_DELETED_CACHE common tables

FTSQueryRunner::assign_aux_table_fields(): Assign the tuple for
FTS_PREFIX_INDEX tables.

FTSQueryRunner::handle_error(): Handling error for DB_LOCK_WAIT,
retry the operation

FTSQueryRunner::open_table(): Open the table based on the fulltext
auxiliary table name and FTS common table name

FTSQueryRunner::prepare_for_write(): Lock the table for write
process by taking Intention Exclusive lock

FTSQueryRunner::prepare_for_read(): Lock the table for read
process by taking Intention Shared lock

FTSQueryRunner::write_record(): Insert the tuple into the given table

FTSQueryRunner::lock_or_sees_rec(): Lock the record in case of
DELETE, SELECT_UPDATE operation. Fetch the correct version of record in
case of READ operation. It also does clustered index lookup in case
of search is on secondary index

fts_cmp_rec_dtuple_prefix(): Compare the record with given tuple field
for tuple field length

FTSQueryRunner::record_executor(): Read the record of the given index and
do call the callback function for each record

FTSQueryRunner::build_update_config(): Build the update vector for
FULLTEXT CONFIG table

FTSQueryRunner::update_record(): Update the record with update vector
exist in FTSQueryRunner

Removed the fts_parse_sql(), fts_eval_sql(), fts_get_select_columns_str()
and fts_get_docs_clear().

Moved fts_get_table_id() & fts_get_table_name() from fts0sql.cc to
fts0fts.cc and deleted the file fts0sql.cc

Removed ins_graph, sel_graph from fts_index_cache_t

Changed the callback function default read function parameter for
each clustered index record to

bool fts_sql_callback(dict_index_t*, const rec_t *, const rec_offs*,
                      void *);

Following parameters are changed to default read function parameter:

fts_read_stopword()
fts_fetch_store_doc_id()
fts_query_expansion_fetch_doc()
fts_read_count()
fts_get_rows_count()
fts_init_doc_id()
fts_init_recover_doc()
read_fts_config()
fts_optimize_read_node()
fts_optimize_index_fetch_node()
fts_index_fetch_nodes()
fts_fetch_index_words()
fts_index_fetch_words()
fts_fetch_doc_ids()
fts_table_fetch_doc_ids()
fts_read_ulint()
fts_copy_doc_ids()
fts_optimize_create_deleted_doc_id_snapshot()
fts_query_index_fetch_nodes()
fts_query_fetch_document()
fts_query_index_fetch_nodes()

row_upd_clust_rec_low(): Function does updates a clustered
index record of a row when ordering fields don't change.
Function doesn't have dependency on row_prebuilt_t. This can be
used by fulltext internal table update operation

Row_sel_get_clust_rec_for_mysql::operator(): Removed the
parameter row_prebuilt_t and caller does pass the prebuilt
related variables

Removed the parser usage and execute the query directly on
fulltext internal tables in the following function:

fts_read_stopword()
fts_fetch_store_doc_id()
fts_query_expansion_fetch_doc()
fts_read_count()
fts_get_rows_count()
fts_init_doc_id()
fts_init_recover_doc()
read_fts_config()
fts_optimize_read_node()
fts_optimize_index_fetch_node()
fts_index_fetch_nodes()
fts_fetch_index_words()
fts_index_fetch_words()
fts_fetch_doc_ids()
fts_table_fetch_doc_ids()
fts_read_ulint()
fts_copy_doc_ids()
fts_optimize_create_deleted_doc_id_snapshot()
fts_query_index_fetch_nodes()
fts_query_fetch_document()
fts_query_index_fetch_nodes()
i_s_fts_deleted_generic_fill()
i_s_fts_index_table_fill_selected()

Author: Thirunarayanan

mysql-test/suite/innodb_fts/r/sync.result

@@ -82,9 +82,9 @@ SET GLOBAL innodb_ft_aux_table=default;
 SELECT * FROM t1 WHERE MATCH(title) AGAINST('mysql database');
 FTS_DOC_ID	title
 3	mysql database
-4	mysql database
-1	mysql
 2	database
+1	mysql
+4	mysql database
 connection default;
 disconnect con1;
 DROP TABLE t1;

storage/innobase/CMakeLists.txt

@@ -175,7 +175,6 @@ SET(INNOBASE_SOURCES
 	fts/fts0opt.cc
 	fts/fts0pars.cc
 	fts/fts0que.cc
-	fts/fts0sql.cc
 	fts/fts0tlex.cc
 	gis/gis0geo.cc
 	gis/gis0rtree.cc

storage/innobase/fts/fts0config.cc

@@ -29,98 +29,47 @@ Created 2007/5/9 Sunny Bains
 
 #include "fts0priv.h"
 
-/******************************************************************//**
-Callback function for fetching the config value.
-@return always returns TRUE */
-static
-ibool
-fts_config_fetch_value(
-/*===================*/
-	void*		row,			/*!< in: sel_node_t* */
-	void*		user_arg)		/*!< in: pointer to
-						 ib_vector_t */
-{
-	sel_node_t*	node = static_cast<sel_node_t*>(row);
-	fts_string_t*	value = static_cast<fts_string_t*>(user_arg);
-
-	dfield_t*	dfield = que_node_get_val(node->select_list);
-	dtype_t*	type = dfield_get_type(dfield);
-	ulint		len = dfield_get_len(dfield);
-	void*		data = dfield_get_data(dfield);
-
-	ut_a(dtype_get_mtype(type) == DATA_VARCHAR);
-
-	if (len != UNIV_SQL_NULL) {
-		ulint	max_len = ut_min(value->f_len - 1, len);
-
-		memcpy(value->f_str, data, max_len);
-		value->f_len = max_len;
-		value->f_str[value->f_len] = '\0';
-	}
-
-	return(TRUE);
-}
-
-/******************************************************************//**
-Get value from the config table. The caller must ensure that enough
+/** Get value from the config table. The caller must ensure that enough
 space is allocated for value to hold the column contents.
+@param trx        transaction
+@param fts_table  indexed FTS table
+@param name       get config value for this parameter name
+@param value      Value read from config table
 @return DB_SUCCESS or error code */
-dberr_t
-fts_config_get_value(
-/*=================*/
-	trx_t*		trx,			/*!< transaction */
-	fts_table_t*	fts_table,		/*!< in: the indexed
-						FTS table */
-	const char*	name,			/*!< in: get config value for
-						this parameter name */
-	fts_string_t*	value)			/*!< out: value read from
-						config table */
+dberr_t fts_config_get_value(trx_t *trx, fts_table_t *fts_table,
+                             const char *name, fts_string_t *value)
 {
-	pars_info_t*	info;
-	que_t*		graph;
-	dberr_t		error;
-	ulint		name_len = strlen(name);
-	char		table_name[MAX_FULL_NAME_LEN];
-
-	info = pars_info_create();
-
-	*value->f_str = '\0';
-	ut_a(value->f_len > 0);
-
-	pars_info_bind_function(info, "my_func", fts_config_fetch_value,
-				value);
-
-	/* The len field of value must be set to the max bytes that
-	it can hold. On a successful read, the len field will be set
-	to the actual number of bytes copied to value. */
-	pars_info_bind_varchar_literal(info, "name", (byte*) name, name_len);
-
-	fts_table->suffix = "CONFIG";
-	fts_get_table_name(fts_table, table_name);
-	pars_info_bind_id(info, "table_name", table_name);
-
-	graph = fts_parse_sql(
-		fts_table,
-		info,
-		"DECLARE FUNCTION my_func;\n"
-		"DECLARE CURSOR c IS SELECT value FROM $table_name"
-		" WHERE key = :name;\n"
-		"BEGIN\n"
-		""
-		"OPEN c;\n"
-		"WHILE 1 = 1 LOOP\n"
-		"  FETCH c INTO my_func();\n"
-		"  IF c % NOTFOUND THEN\n"
-		"    EXIT;\n"
-		"  END IF;\n"
-		"END LOOP;\n"
-		"CLOSE c;");
-
-	trx->op_info = "getting FTS config value";
-
-	error = fts_eval_sql(trx, graph);
-	que_graph_free(graph);
-	return(error);
+  FTSQueryRunner sqlRunner(trx);
+  fts_table->suffix = "CONFIG";
+  dberr_t err= DB_SUCCESS;
+  dict_table_t *table= sqlRunner.open_table(fts_table, &err);
+  if (table)
+  {
+    ut_ad(UT_LIST_GET_LEN(table->indexes) == 1);
+    err= sqlRunner.prepare_for_read(table);
+    if (err == DB_SUCCESS)
+    {
+      dict_index_t *clust_index= dict_table_get_first_index(table);
+      sqlRunner.build_tuple(clust_index, 1, 1);
+      sqlRunner.assign_config_fields(name);
+
+      *value->f_str = '\0';
+      ut_a(value->f_len > 0);
+
+      /* Following record executor does the following command
+      SELECT value FROM $FTS_PREFIX_CONFIG WHERE key = :name;"
+      and stores the value field in fts_string_t value */
+      err= sqlRunner.record_executor(clust_index, FTSQueryRunner::READ,
+                                     FTSQueryRunner::MATCH_UNIQUE,
+                                     PAGE_CUR_GE, &read_fts_config, value);
+      /* In case of empty table, error can be DB_END_OF_INDEX
+      and key doesn't exist, error can be DB_RECORD_NOT_FOUND */
+      if (err == DB_END_OF_INDEX || err == DB_RECORD_NOT_FOUND)
+        err= DB_SUCCESS;
+    }
+    table->release();
+  }
+  return err;
 }
 
 /*********************************************************************//**
@@ -181,81 +130,60 @@ fts_config_get_index_value(
 	return(error);
 }
 
-/******************************************************************//**
-Set the value in the config table for name.
-@return DB_SUCCESS or error code */
-dberr_t
-fts_config_set_value(
-/*=================*/
-	trx_t*		trx,			/*!< transaction */
-	fts_table_t*	fts_table,		/*!< in: the indexed
-						FTS table */
-	const char*	name,			/*!< in: get config value for
-						this parameter name */
-	const fts_string_t*
-			value)			/*!< in: value to update */
+dberr_t fts_config_set_value(trx_t *trx, fts_table_t *fts_table,
+                             const char *name, const fts_string_t *value)
 {
-	pars_info_t*	info;
-	que_t*		graph;
-	dberr_t		error;
-	undo_no_t	undo_no;
-	undo_no_t	n_rows_updated;
-	ulint		name_len = strlen(name);
-	char		table_name[MAX_FULL_NAME_LEN];
-
-	info = pars_info_create();
-
-	pars_info_bind_varchar_literal(info, "name", (byte*) name, name_len);
-	pars_info_bind_varchar_literal(info, "value",
-				       value->f_str, value->f_len);
-
-	const bool dict_locked = fts_table->table->fts->dict_locked;
-
-	fts_table->suffix = "CONFIG";
-	fts_get_table_name(fts_table, table_name, dict_locked);
-	pars_info_bind_id(info, "table_name", table_name);
-
-	graph = fts_parse_sql(
-		fts_table, info,
-		"BEGIN UPDATE $table_name SET value = :value"
-		" WHERE key = :name;");
-
-	trx->op_info = "setting FTS config value";
-
-	undo_no = trx->undo_no;
-
-	error = fts_eval_sql(trx, graph);
-
-	que_graph_free(graph);
-
-	n_rows_updated = trx->undo_no - undo_no;
-
-	/* Check if we need to do an insert. */
-	if (error == DB_SUCCESS && n_rows_updated == 0) {
-		info = pars_info_create();
-
-		pars_info_bind_varchar_literal(
-			info, "name", (byte*) name, name_len);
-
-		pars_info_bind_varchar_literal(
-			info, "value", value->f_str, value->f_len);
-
-		fts_get_table_name(fts_table, table_name, dict_locked);
-		pars_info_bind_id(info, "table_name", table_name);
-
-		graph = fts_parse_sql(
-			fts_table, info,
-			"BEGIN\n"
-			"INSERT INTO $table_name VALUES(:name, :value);");
-
-		trx->op_info = "inserting FTS config value";
-
-		error = fts_eval_sql(trx, graph);
-
-		que_graph_free(graph);
-	}
-
-	return(error);
+  dberr_t err= DB_SUCCESS;
+  const bool dict_locked = fts_table->table->fts->dict_locked;
+  fts_table->suffix = "CONFIG";
+
+  FTSQueryRunner sqlRunner(trx);
+  dict_table_t *fts_config= sqlRunner.open_table(fts_table, &err, dict_locked);
+  if (fts_config)
+  {
+    err= sqlRunner.prepare_for_write(fts_config);
+    if (err == DB_SUCCESS)
+    {
+      dict_index_t *clust_index= dict_table_get_first_index(fts_config);
+      sqlRunner.build_tuple(clust_index, 1, 1);
+      /* We set the length of value to the max bytes it can hold. This
+      information is used by the callback that reads the value.*/
+      fts_string_t old_value;
+      old_value.f_len= FTS_MAX_CONFIG_VALUE_LEN;
+      old_value.f_str=
+        static_cast<byte*>(ut_malloc_nokey(old_value.f_len + 1));
+
+      /* REPLACE INTO $FTS_PREFIX_CONFIG VALUES (KEY, VALUE) */
+      sqlRunner.assign_config_fields(name);
+      err= sqlRunner.record_executor(clust_index, FTSQueryRunner::SELECT_UPDATE,
+                                     FTSQueryRunner::MATCH_UNIQUE,
+                                     PAGE_CUR_GE, &read_fts_config, &old_value);
+      if (err == DB_SUCCESS)
+      {
+        /* Record already exist. So Update the value field with new value */
+        if (old_value.f_len != value->f_len ||
+            memcmp(old_value.f_str, value->f_str, value->f_len) != 0)
+        {
+          /* Build update vector with new value for FTS_CONFIG table */
+          sqlRunner.build_update_config(fts_config, 3, value);
+          err= sqlRunner.update_record(
+            fts_config, static_cast<uint16_t>(old_value.f_len),
+            static_cast<uint16_t>(value->f_len));
+        }
+      }
+      else if (err == DB_END_OF_INDEX || err == DB_RECORD_NOT_FOUND)
+      {
+        /* Record doesn't exist. So do insert the key, value in config table */
+        sqlRunner.build_tuple(clust_index);
+        sqlRunner.assign_config_fields(name, value->f_str, value->f_len);
+        err= sqlRunner.write_record(fts_config);
+      }
+      ut_free(old_value.f_str);
+    }
+    fts_config->release();
+  }
+
+  return err;
 }
 
 /******************************************************************//**