Bug#35913841: Queries from stored procedures not offloading to secondary engine when we have OUT arguments

Before this patch, RAPID could not handle queries of the type
SELECT ... INTO <list of variables>. The reason for this was that these
kind of queries were set up with a special Query_result interceptor
(Query_dumpvar), whereas regular SELECT queries were set up with
Query_result_send, which was substituted on the RAPID side with a
special protocol adapter. However, RAPID has also implemented another
protocol adapter (an Item wrapper), which is used for INSERT INTO
and CREATE TABLE ... SELECT statements.

It was noted that this adapter could also be used for SELECT INTO,
where the Item wrapper is used as an intermediary for Query_dumpvar.

Two new property functions on class Query_result are implemented:
use_protocol_adapter() returns true for Query_result_send and
use_protocol_wrapper() returns true for Query_dumpvar.
An alternative implementation may check these functions for when to use
adapters resp. wrappers instead of the original Query result classes.
The function is_interceptor() is no longer used and is hence removed.

We identify this new requirement in IsSupportedProtocol(), where
we explicitly allow Query_dumpvar and Query_result_send query results,
and in CreateQEP() where we create the Item wrapper for Query_dumpvar.

Notice that this implements SELECT ... INTO both as regular statements,
as prepared statements and as procedure statements.

Notice also that the syntax variants SELECT ... INTO OUTFILE and
SELECT ... INTO DUMPFILE are still not supported.

Most of the changes are in the test suite where we have eliminated the
earlier ER_SECONDARY_ENGINE_PLUGIN error code.

A couple of test lines were removed from the tests rapid.sp and
rapid.cp_sp because they gave different results in dict and varlen
modes.

Change-Id: Icd56cb6fbc32e121a59599a7e5b7d651747804f5

Author: roylyseng

sql/opt_explain.h

@@ -146,6 +146,7 @@ class Query_result_explain : public Query_result_send {
       : Query_result_send(), interceptor(interceptor_arg) {
     unit = unit_arg;
   }
+  bool use_protocol_adapter() const override { return false; }
 
  protected:
   bool prepare(THD *thd, const mem_root_deque<Item *> &list,

sql/query_result.h

@@ -150,13 +150,16 @@ class Query_result {
   */
   virtual void cleanup() { /* do nothing */
   }
-
   /**
-    Checks if this Query_result intercepts and transforms the result set.
-
-    @return true if it is an interceptor, false otherwise
+    @returns true if an alternative implementation may replace this with
+    a protocol adapter.
+  */
+  virtual bool use_protocol_adapter() const { return false; }
+  /**
+    @returns true if an alternative implementation may replace this with
+    a protocol wrapper.
   */
-  virtual bool is_interceptor() const { return false; }
+  virtual bool use_protocol_wrapper() const { return false; }
 
   /// Only overridden (and non-empty) for Query_result_union, q.v.
   virtual void set_limit(ha_rows) {}
@@ -182,7 +185,6 @@ class Query_result_interceptor : public Query_result {
                                 uint) override {
     return false;
   }
-  bool is_interceptor() const final { return true; }
 };
 
 class Query_result_send : public Query_result {
@@ -202,6 +204,11 @@ class Query_result_send : public Query_result {
   bool check_supports_cursor() const override { return false; }
   void abort_result_set(THD *thd) override;
   void cleanup() override { is_result_set_started = false; }
+  /**
+    An alternative implementation may provide an optimized protocol adapter
+    for this object.
+  */
+  bool use_protocol_adapter() const override { return true; }
 };
 
 class sql_exchange;
@@ -290,6 +297,11 @@ class Query_dumpvar final : public Query_result_interceptor {
   bool send_eof(THD *thd) override;
   bool check_supports_cursor() const override;
   void cleanup() override { row_count = 0; }
+  /**
+    An alternative implementation may provide an optimized protocol wrapper
+    for this object.
+  */
+  bool use_protocol_wrapper() const override { return true; }
 };
 
 /**

sql/sql_prepare.cc

@@ -220,6 +220,7 @@ class Query_fetch_protocol_binary final : public Query_result_send {
                                 uint flags) override;
   bool send_data(THD *thd, const mem_root_deque<Item *> &items) override;
   bool send_eof(THD *thd) override;
+  bool use_protocol_adapter() const override { return false; }
 };
 
 }  // namespace