BUG#34667384 Report flags incorrect for opened event

When opening a NdbDictionary::Event from NDB the report option flags are
not sent to the NdbApi, this causes the Event::getReport()
function to always indicate that only updated columns would be reported
for NdbDictionary::Event's. This problem makes it impossible to use the
NdbApi for checking how an Event is configured in NDB. Furthermore the
Event::getReport() function is documented as returning only one value
while it actually returns a value consisting of several 'EventReport'
flags. Due to this the `ndbinfo.reporting` column is using an ENUM value
which also always shows the same value due to first problem.

Fix by extending the CreateEvntConf signal with an additional data field
to send the report flags and translate them from
CreateEventReq::EventFlags to 'EventReport' flags as used in the NdbApi.
Also change the `ndbinfo.reporting` column to use a SET to describe the
different report flags for each event in NDB, this means that were the
`reporting` column preivosly only returned one value it will now show
more than one. The complete functionality is tested by showing how
events for the well known tables of ndb_ddl
suite are configured.
Add signal data printers for CreateEvntReq, CreateEvntConf and
CreateEvntRef.
Also improve functionality for EventDurability:
 * Change Event::getDurability() to always return correctly that Event
is created as permanent (ED_PERMANENT) which is the only supported
value.
 * Add function comment describing that Event::setDurability() has no
effect, event will alwyas be created as permanent.

Change-Id: I91a47331ffcb74c39b979e8c44c7e1f167ac1c35

Author: blaudden

mysql-test/suite/ndb_ddl/check_event_for_table.inc

@@ -38,6 +38,15 @@ let $found_event = `SELECT count(*) FROM ndbinfo.events
 if ($found_event)
 {
   echo Found event for '$check_event_dbname.$check_event_tabname';
+
+  #
+  # Check how report options for the event is configured. Use the 'reporting'
+  # column of ndbinfo.events which is a SET that correspond to the flags
+  # describing what should be reported
+  let $reporting = `SELECT reporting FROM ndbinfo.events
+                      WHERE name = '$expected_event_name'`;
+  echo Report flags: '$reporting';
+
 }
 if (!$found_event)
 {

mysql-test/suite/ndb_ddl/table_event.result

@@ -1,13 +1,24 @@
 Found event for 'mysql.ndb_apply_status'
+Report flags: 'updated,DDL'
 Found event for 'mysql.ndb_schema'
+Report flags: 'all,subscribe,DDL'
 Found event for 'mysql.ndb_schema_result'
+Report flags: 'all,DDL'
 Found event for 'ndb_ddl_test.t1'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t2'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t3'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t4'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t5'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t6'
+Report flags: 'all,DDL'
 Found event for 'ndb_ddl_test.t7'
+Report flags: 'updated,DDL'
 Found event for 'ndb_ddl_test.t8'
+Report flags: 'all,DDL'
 NOTE! t9 have hidden pk and blobs -> no event
 No event found for 'ndb_ddl_test.t9'

storage/ndb/include/kernel/signaldata/CreateEvnt.hpp

@@ -339,7 +339,8 @@ class CreateEvntConf {
 
 public:
   //  static constexpr Uint32 InternalLength = 3;
-  static constexpr Uint32 SignalLength = 8+MAXNROFATTRIBUTESINWORDS_OLD;
+  static constexpr Uint32 SignalLength_v8_0_31 = 8+MAXNROFATTRIBUTESINWORDS_OLD;
+  static constexpr Uint32 SignalLength = 13;
 
   union {
     Uint32 m_userRef;             // user block reference
@@ -356,6 +357,7 @@ class CreateEvntConf {
   Uint32 m_eventType;
   Uint32 m_eventId;
   Uint32 m_eventKey;
+  Uint32 m_reportFlags;          // using CreateEvntReq::EventFlags
 
   Uint32 getUserRef() const {
     return m_userRef;
@@ -411,6 +413,18 @@ class CreateEvntConf {
   void setEventKey(Uint32 val) {
     m_eventKey = val;
   }
+  void setReportFlags(Uint32 val) {
+    m_reportFlags = val;
+  }
+  Uint32 getReportAll() const {
+    return m_reportFlags & CreateEvntReq::EF_REPORT_ALL;
+  }
+  Uint32 getReportSubscribe() const {
+    return m_reportFlags & CreateEvntReq::EF_REPORT_SUBSCRIBE;
+  }
+  Uint32 getReportDDL() const {
+    return (m_reportFlags & CreateEvntReq::EF_NO_REPORT_DDL) == 0;
+  }
 };
 
 /**

storage/ndb/include/kernel/signaldata/SignalData.hpp

@@ -365,6 +365,9 @@ GSN_PRINT_SIGNATURE(printISOLATE_ORD);
 
 GSN_PRINT_SIGNATURE(printPROCESSINFO_REP);
 GSN_PRINT_SIGNATURE(printTRP_KEEP_ALIVE);
+GSN_PRINT_SIGNATURE(printCREATE_EVNT_CONF);
+GSN_PRINT_SIGNATURE(printCREATE_EVNT_REQ);
+GSN_PRINT_SIGNATURE(printCREATE_EVNT_REF);
 
   /**
      Signal scope monitoring

storage/ndb/include/ndbapi/NdbDictionary.hpp

@@ -1594,15 +1594,6 @@ class NdbDictionary {
       ED_UNDEFINED
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
       = 0
-#endif
-#if 0 // not supported
-      ,ED_SESSION = 1,
-      // Only this API can use it
-      // and it's deleted after api has disconnected or ndb has restarted
-
-      ED_TEMPORARY = 2
-      // All API's can use it,
-      // But's its removed when ndb is restarted
 #endif
       ,ED_PERMANENT    ///< All API's can use it.
                        ///< It's still defined after a cluster system restart
@@ -1681,20 +1672,33 @@ class NdbDictionary {
     bool getTableEvent(const TableEvent te) const;
     /**
      * Set durability of the event
+     *
+     * @note This function has no effect
      */
     void setDurability(EventDurability);
     /**
      * Get durability of the event
+     *
+     * @note This function always returns that event is permanent
      */
     EventDurability getDurability() const;
     /**
-     * Set report option of the event
+     * Set report options for the event
+     *
+     * @note The function accepts a value consisting of 'EventReport' flags
+     * describing what the event should report
+     *
      */
     void setReport(EventReport);
+    void setReportOptions(Uint32 report_options);
     /**
-     * Get report option of the event
+     * Get report options for the event
+     *
+     * @note The function returns a value consisting of 'EventReport' flags
+     * describing what the event is configured to report
      */
     EventReport getReport() const;
+    Uint32 getReportOptions() const;
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
     void addColumn(const Column &c);
 #endif

storage/ndb/plugin/ha_ndbcluster_binlog.cc

@@ -5100,31 +5100,27 @@ int Ndb_binlog_client::create_event(Ndb *ndb,
   my_event.addTableEvent(NDBEVENT::TE_ALL);
   if (ndb_table_has_hidden_pk(ndbtab)) {
     /* Hidden primary key, subscribe for all attributes */
-    my_event.setReport(
-        (NDBEVENT::EventReport)(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL));
+    my_event.setReportOptions(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL);
     DBUG_PRINT("info", ("subscription all"));
   } else {
     if (Ndb_schema_dist_client::is_schema_dist_table(share->db,
                                                      share->table_name)) {
       /**
        * ER_SUBSCRIBE is only needed on schema distribution table
        */
-      my_event.setReport((NDBEVENT::EventReport)(
-          NDBEVENT::ER_ALL | NDBEVENT::ER_SUBSCRIBE | NDBEVENT::ER_DDL));
+      my_event.setReportOptions(NDBEVENT::ER_ALL | NDBEVENT::ER_SUBSCRIBE |
+                                NDBEVENT::ER_DDL);
       DBUG_PRINT("info", ("subscription all and subscribe"));
     } else if (Ndb_schema_dist_client::is_schema_dist_result_table(
                    share->db, share->table_name)) {
-      my_event.setReport(
-          (NDBEVENT::EventReport)(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL));
+      my_event.setReportOptions(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL);
       DBUG_PRINT("info", ("subscription all"));
     } else {
       if (share->get_binlog_full()) {
-        my_event.setReport(
-            (NDBEVENT::EventReport)(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL));
+        my_event.setReportOptions(NDBEVENT::ER_ALL | NDBEVENT::ER_DDL);
         DBUG_PRINT("info", ("subscription all"));
       } else {
-        my_event.setReport(
-            (NDBEVENT::EventReport)(NDBEVENT::ER_UPDATED | NDBEVENT::ER_DDL));
+        my_event.setReportOptions(NDBEVENT::ER_UPDATED | NDBEVENT::ER_DDL);
         DBUG_PRINT("info", ("subscription only updated"));
       }
     }

storage/ndb/plugin/ha_ndbinfo_sql.cc

@@ -729,7 +729,7 @@ static struct lookup {
      "event_id INT UNSIGNED NOT NULL PRIMARY KEY, "
      "name varchar(192) NOT NULL, "
      "table_id INT UNSIGNED NOT NULL, "
-     "reporting  enum('updated', 'all', 'subscribe', 'DDL') NOT NULL, "
+     "reporting  SET('updated', 'all', 'subscribe', 'DDL') NOT NULL, "
      "columns varchar(512) NOT NULL, "
      "table_event SET('INSERT','DELETE','UPDATE','SCAN','DROP','ALTER',"
      "'CREATE','GCP_COMPLETE','CLUSTER_FAILURE','STOP',"

storage/ndb/src/common/debugger/signaldata/CMakeLists.txt

@@ -36,6 +36,7 @@ ADD_CONVENIENCE_LIBRARY(ndbsignaldata
   CntrStart.cpp
   ContinueB.cpp
   CopyGCI.cpp
+  CreateEvnt.cpp
   CreateFK.cpp
   CreateFragmentation.cpp
   CreateIndx.cpp

storage/ndb/src/common/debugger/signaldata/CreateEvnt.cpp

@@ -25,23 +25,103 @@
 
 #include <signaldata/CreateEvnt.hpp>
 
-bool printCREATE_EVNT_REQ(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo)
-{
-  //  const CreateEvntReq * const sig = (const CreateEvntReq *) theData;
+static void print_request_info(FILE *output,
+                               CreateEvntReq::RequestType req_type,
+                               Uint32 req_flags) {
+  fprintf(output, " requestType: ");
+  switch(req_type) {
+    case CreateEvntReq::RT_UNDEFINED:
+      fprintf(output, "'Undefined'");
+      break;
+    case CreateEvntReq::RT_USER_CREATE:
+      fprintf(output, "'Create'");
+      break;
+    case CreateEvntReq::RT_USER_GET:
+      fprintf(output, "'Get'");
+      break;
+    default:
+      fprintf(output, "0x%08x", req_type);
+      break;
+  }
+  if (req_flags) {
+    fprintf(output, " flags: 0x%08x [", req_flags);
+    if (req_flags & CreateEvntReq::RT_DICT_AFTER_GET)
+      fprintf(output, "DICT_AFTER_GET ");
+    fprintf(output, "]");
+  }
+  fprintf(output, "\n");
+}
+
+bool printCREATE_EVNT_REQ(FILE *output, const Uint32 *theData, Uint32 len,
+                          Uint16) {
+  if (len < CreateEvntReq::SignalLengthGet)
+  {
+    assert(false);
+    return false;
+  }
+
+  const CreateEvntReq * const sig = (const CreateEvntReq *) theData;
+  fprintf(output, " senderRef: 0x%x", sig->senderRef);
+  fprintf(output, " senderData: %u", sig->senderData);
+  fprintf(output, "\n");
+  print_request_info(output, sig->getRequestType(), sig->getRequestFlag());
+
+  if (len <= CreateEvntReq::SignalLengthGet)
+    return true;
+
+  fprintf(output, " tableId: %u tableVersion: %u\n",
+          sig->m_tableId, sig->m_tableVersion);
+  // attrListBitmask;
+  fprintf(output, " m_eventType: 0x%08x [eventType: %u, reportFlags: 0x%08x]\n",
+          sig->m_eventType, sig->getEventType(), sig->getReportFlags());
+  fprintf(output, " eventId: %u eventKey: %u\n", sig->m_eventId,
+          sig->m_eventKey);
 
   return false;
 }
 
-bool printCREATE_EVNT_CONF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo)
-{
-  //  const CreateEvntConf * const sig = (const CreateEvntConf *) theData;
+bool printCREATE_EVNT_CONF(FILE *output, const Uint32 *theData, Uint32 len,
+                           Uint16) {
+  if (len < CreateEvntConf::SignalLength_v8_0_31)
+  {
+    assert(false);
+    return false;
+  }
+
+  const CreateEvntConf * const sig = (const CreateEvntConf *) theData;
+  fprintf(output, " senderRef: 0x%x", sig->senderRef);
+  fprintf(output, " senderData: %u", sig->senderData);
+  fprintf(output, "\n");
+  print_request_info(output, sig->getRequestType(), 0);
+  fprintf(output, " tableId: %u tableVersion: %u\n", sig->m_tableId, sig->m_tableVersion);
+  // attrListBitmask;
+  fprintf(output, " m_eventType: 0x%08x [eventType: %u]\n", sig->m_eventType, sig->getEventType());
+  fprintf(output, " eventId: %u eventKey: %u\n", sig->m_eventId, sig->m_eventKey);
+  if (len > CreateEvntConf::SignalLength_v8_0_31) {
+    fprintf(output, " reportFlags: 0x%08x\n", sig->m_reportFlags);
+  }
 
   return false;
 }
 
-bool printCREATE_EVNT_REF(FILE * output, const Uint32 * theData, Uint32 len, Uint16 receiverBlockNo)
-{
-  //  const CreateEvntRef * const sig = (const CreateEvntRef *) theData;
+bool printCREATE_EVNT_REF(FILE *output, const Uint32 *theData, Uint32 len,
+                          Uint16) {
+  if (len < CreateEvntRef::SignalLength)
+  {
+    assert(false);
+    return false;
+  }
+
+  const CreateEvntRef * const sig = (const CreateEvntRef *) theData;
+  fprintf(output, " senderRef: 0x%x", sig->senderRef);
+  fprintf(output, " senderData: %u", sig->senderData);
+  fprintf(output, "\n");
+  print_request_info(output, sig->getRequestType(), 0);
+  fprintf(output, " errorCode: %u\n", sig->errorCode);
+  fprintf(output, " errorLine: %u\n", sig->m_errorLine);
+  fprintf(output, " errorRef: 0x%08x\n", sig->m_errorNode);
+  if (len >= CreateEvntRef::SignalLength2)
+    fprintf(output, " masterNodeId: %u\n", sig->m_masterNodeId);
 
   return false;
 }

storage/ndb/src/common/debugger/signaldata/SignalDataPrint.cpp

@@ -312,6 +312,9 @@ SignalDataPrintFunctions[] = {
   ,{ GSN_PROCESSINFO_REP, printPROCESSINFO_REP }
 
   ,{ GSN_TRP_KEEP_ALIVE, printTRP_KEEP_ALIVE }
+  ,{ GSN_CREATE_EVNT_REQ, printCREATE_EVNT_REQ}
+  ,{ GSN_CREATE_EVNT_CONF, printCREATE_EVNT_CONF}
+  ,{ GSN_CREATE_EVNT_REF, printCREATE_EVNT_REF}
   ,{ 0, nullptr }
 };