Bug#21140111: Explain ... match against: Assertion failed: ret ...

The problem here is missing error check in Item_func_match::init_search()
after the handler call ft_init_ext_with_hints(), and missing error
propagation in the call stack.

The fix also includes a new inlined query block property function
has_ft_funcs() that is used to avoid an unnecessary and costly
function call to optimize full-text searches.

Author: roylyseng

mysql-test/r/fulltext.result

@@ -730,3 +730,10 @@ EXECUTE stmt;
 DEALLOCATE PREPARE stmt;
 DROP TABLE t1;
 End of 5.1 tests
+# Bug#21140111: Explain ... match against: Assertion failed: ret ...
+CREATE TABLE z(a INTEGER) engine=innodb;
+CREATE TABLE q(b TEXT CHARSET latin1, fulltext(b)) engine=innodb;
+explain format=json SELECT 1 FROM q
+WHERE (SELECT MATCH(b) AGAINST ('*') FROM z);
+ERROR 42000: syntax error, unexpected $end, expecting FTS_TERM or FTS_NUMB or '*'
+DROP TABLE z, q;

mysql-test/t/fulltext.test

@@ -642,3 +642,17 @@ DEALLOCATE PREPARE stmt;
 DROP TABLE t1;
 
 --echo End of 5.1 tests
+
+--echo # Bug#21140111: Explain ... match against: Assertion failed: ret ...
+
+CREATE TABLE z(a INTEGER) engine=innodb;
+CREATE TABLE q(b TEXT CHARSET latin1, fulltext(b)) engine=innodb;
+
+let $query=
+SELECT 1 FROM q
+WHERE (SELECT MATCH(b) AGAINST ('*') FROM z);
+
+--error ER_PARSE_ERROR
+eval explain format=json $query;
+
+DROP TABLE z, q;

sql/item_func.cc

@@ -7303,7 +7303,15 @@ bool Item_func_match::itemize(Parse_context *pc, Item **res)
 }
 
 
-void Item_func_match::init_search()
+/**
+  Initialize searching within full-text index.
+
+  @param thd    Thread handler
+
+  @returns false if success, true if error
+*/
+
+bool Item_func_match::init_search(THD *thd)
 {
   DBUG_ENTER("Item_func_match::init_search");
 
@@ -7312,7 +7320,7 @@ void Item_func_match::init_search()
     with fix_field
   */
   if (!fixed)
-    DBUG_VOID_RETURN;
+    DBUG_RETURN(false);
 
   TABLE *const table= table_ref->table;
   /* Check if init_search() has been called before */
@@ -7326,16 +7334,19 @@ void Item_func_match::init_search()
     */
     if (join_key)
       table->file->ft_handler= ft_handler;
-    DBUG_VOID_RETURN;
+    DBUG_RETURN(false);
   }
 
   if (key == NO_SUCH_KEY)
   {
     List<Item> fields;
-    fields.push_back(new Item_string(" ",1, cmp_collation.collation));
+    if (fields.push_back(new Item_string(" ",1, cmp_collation.collation)))
+      DBUG_RETURN(true);
     for (uint i= 0; i < arg_count; i++)
       fields.push_back(args[i]);
     concat_ws=new Item_func_concat_ws(fields);
+    if (concat_ws == NULL)
+      DBUG_RETURN(true);
     /*
       Above function used only to get value and do not need fix_fields for it:
       Item_string - basic constant
@@ -7347,9 +7358,11 @@ void Item_func_match::init_search()
 
   if (master)
   {
-    master->init_search();
+    if (master->init_search(thd))
+      DBUG_RETURN(true);
+
     ft_handler=master->ft_handler;
-    DBUG_VOID_RETURN;
+    DBUG_RETURN(false);
   }
 
   String *ft_tmp= 0;
@@ -7372,16 +7385,18 @@ void Item_func_match::init_search()
   if (!table->is_created())
   {
      my_error(ER_NO_FT_MATERIALIZED_SUBQUERY, MYF(0));
-     DBUG_VOID_RETURN;
+     DBUG_RETURN(true);
   }
 
   DBUG_ASSERT(master == NULL);
   ft_handler= table->file->ft_init_ext_with_hints(key, ft_tmp, get_hints());
+  if (thd->is_error())
+    DBUG_RETURN(true);
 
   if (join_key)
     table->file->ft_handler=ft_handler;
 
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(false);
 }
 
 

sql/item_func.h

@@ -2376,7 +2376,7 @@ class Item_func_match :public Item_real_func
   virtual void print(String *str, enum_query_type query_type);
 
   bool fix_index();
-  void init_search();
+  bool init_search(THD *thd);
   bool check_gcol_func_processor(uchar *int_arg) 
   {
     /* TODO: consider adding in support for the MATCH-based generated columns */

sql/opt_sum.cc

@@ -374,8 +374,7 @@ int opt_sum_query(THD *thd,
         {
           Item_func_match* fts_item= static_cast<Item_func_match*>(conds); 
           fts_item->set_hints(NULL, FT_NO_RANKING, HA_POS_ERROR, false);
-          fts_item->init_search();
-          if (thd->is_error())
+          if (fts_item->init_search(thd))
             break;
           count= fts_item->get_count();
         }

sql/sql_base.cc

@@ -9694,19 +9694,21 @@ int setup_ftfuncs(SELECT_LEX *select_lex)
 }
 
 
-int init_ftfuncs(THD *thd, SELECT_LEX *select_lex)
+bool init_ftfuncs(THD *thd, SELECT_LEX *select_lex)
 {
-  if (select_lex->ftfunc_list->elements)
-  {
-    List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
-    Item_func_match *ifm;
-    DBUG_PRINT("info",("Performing FULLTEXT search"));
-    THD_STAGE_INFO(thd, stage_fulltext_initialization);
+  DBUG_ASSERT(select_lex->has_ft_funcs());
+
+  List_iterator<Item_func_match> li(*(select_lex->ftfunc_list));
+  DBUG_PRINT("info",("Performing FULLTEXT search"));
+  THD_STAGE_INFO(thd, stage_fulltext_initialization);
 
-    while ((ifm=li++))
-      ifm->init_search();
+  Item_func_match *ifm;
+  while ((ifm= li++))
+  {
+    if (ifm->init_search(thd))
+      return true;
   }
-  return 0;
+  return false;
 }
 
 

sql/sql_base.h

@@ -279,7 +279,7 @@ void update_non_unique_table_error(TABLE_LIST *update,
                                    const char *operation,
                                    TABLE_LIST *duplicate);
 int setup_ftfuncs(SELECT_LEX* select);
-int init_ftfuncs(THD *thd, SELECT_LEX* select);
+bool init_ftfuncs(THD *thd, SELECT_LEX* select);
 int run_before_dml_hook(THD *thd);
 bool lock_table_names(THD *thd, TABLE_LIST *table_list,
                       TABLE_LIST *table_list_end, ulong lock_wait_timeout,

sql/sql_delete.cc

@@ -404,7 +404,9 @@ bool Sql_cmd_delete::mysql_delete(THD *thd, ha_rows limit)
       goto exit_without_my_ok;
     }
 
-    init_ftfuncs(thd, select_lex);
+    if (select_lex->has_ft_funcs() && init_ftfuncs(thd, select_lex))
+      goto exit_without_my_ok;
+
     THD_STAGE_INFO(thd, stage_updating);
 
     if (table->triggers &&
@@ -834,7 +836,9 @@ bool Query_result_delete::initialize_tables(JOIN *join)
 {
   DBUG_ENTER("Query_result_delete::initialize_tables");
   ASSERT_BEST_REF_IN_JOIN_ORDER(join);
-  DBUG_ASSERT(join == unit->first_select()->join);
+
+  SELECT_LEX *const select= unit->first_select();
+  DBUG_ASSERT(join == select->join);
 
   if ((thd->variables.option_bits & OPTION_SAFE_UPDATES) &&
       error_if_full_join(join))
@@ -924,8 +928,11 @@ bool Query_result_delete::initialize_tables(JOIN *join)
       DBUG_RETURN(true);                     /* purecov: inspected */
     *(table_ptr++)= table;
   }
-  DBUG_ASSERT(unit->first_select() == thd->lex->current_select());
-  init_ftfuncs(thd, unit->first_select());
+  DBUG_ASSERT(select == thd->lex->current_select());
+
+  if (select->has_ft_funcs() && init_ftfuncs(thd, select))
+    DBUG_RETURN(true);
+
   DBUG_RETURN(thd->is_fatal_error != 0);
 }
 

sql/sql_lex.h

@@ -1161,6 +1161,10 @@ class st_select_lex: public Sql_alloc
   bool has_limit() const
   { return select_limit != NULL; }
 
+  /// @return true if query block references full-text functions
+  bool has_ft_funcs() const
+  { return ftfunc_list->elements > 0; }
+
   void invalidate();
 
   bool set_braces(bool value);

sql/sql_optimizer.cc

@@ -481,7 +481,8 @@ JOIN::optimize()
     no_jbuf_after= 0;
 
   /* Perform FULLTEXT search before all regular searches */
-  optimize_fts_query();
+  if (select_lex->has_ft_funcs() && optimize_fts_query())
+    DBUG_RETURN(1);
 
   /*
     By setting child_subquery_can_materialize so late we gain the following:
@@ -10282,12 +10283,11 @@ void JOIN::optimize_keyuse()
   and checks if FT index can be used as covered.
 */
 
-void JOIN::optimize_fts_query()
+bool JOIN::optimize_fts_query()
 {
   ASSERT_BEST_REF_IN_JOIN_ORDER(this);
 
-  if (!select_lex->ftfunc_list->elements)
-    return;
+  DBUG_ASSERT(select_lex->has_ft_funcs());
 
   for (uint i= const_tables; i < tables; i++)
   {
@@ -10333,7 +10333,7 @@ void JOIN::optimize_fts_query()
                          !order ? m_select_limit : HA_POS_ERROR, false);
   }
 
-  init_ftfuncs(thd, select_lex);
+  return init_ftfuncs(thd, select_lex);
 }
 
 

sql/sql_optimizer.h

@@ -710,7 +710,7 @@ class JOIN :public Sql_alloc
     Function sets FT hints, initializes FT handlers and
     checks if FT index can be used as covered.
   */
-  void optimize_fts_query();
+  bool optimize_fts_query();
 
   bool prune_table_partitions();
 

sql/sql_select.cc

@@ -864,7 +864,15 @@ void JOIN::reset()
       func->clear();
   }
 
-  init_ftfuncs(thd, select_lex);
+  if (select_lex->has_ft_funcs())
+  {
+#ifdef DBUG_OFF
+    (void)init_ftfuncs(thd, select_lex);
+#else
+    // Should not return an error on second execution
+    DBUG_ASSERT(!init_ftfuncs(thd, select_lex));
+#endif
+  }
 
   DBUG_VOID_RETURN;
 }

sql/sql_update.cc

@@ -525,7 +525,8 @@ bool mysql_update(THD *thd,
       goto exit_without_my_ok;
     }
   }
-  init_ftfuncs(thd, select_lex);
+  if (select_lex->has_ft_funcs() && init_ftfuncs(thd, select_lex))
+    goto exit_without_my_ok;
 
   table->update_const_key_parts(conds);
   order= simple_remove_const(order, conds);