MDEV-8931: (server part of) session state tracking

Transaction tracker

1 files changed, 142 insertions, 15 deletions

diff --git a/sql/session_tracker.h b/sql/session_tracker.h
index 7025c34967d..431726f03ed 100644
--- a/sql/session_tracker.h
+++ b/sql/session_tracker.h
@@ -20,6 +20,7 @@
 #include "m_string.h"
 #include "thr_lock.h"
 
+#ifndef EMBEDDED_LIBRARY
 /* forward declarations */
 class THD;
 class set_var;
@@ -32,12 +33,10 @@ enum enum_session_tracker
   CURRENT_SCHEMA_TRACKER,                        /* Current schema */
   SESSION_STATE_CHANGE_TRACKER,
   SESSION_GTIDS_TRACKER,                         /* Tracks GTIDs */
-  TRANSACTION_INFO_TRACKER                       /* Transaction state */
+  TRANSACTION_INFO_TRACKER,                      /* Transaction state */
+  SESSION_TRACKER_END                            /* must be the last */
 };
 
-#define SESSION_TRACKER_END TRANSACTION_INFO_TRACKER
-
-
 /**
   State_tracker
 
@@ -54,8 +53,7 @@ enum enum_session_tracker
   the respective system variable either through SET command or via command
   line option. As required in system variable handling, this interface also
   includes two functions to help in the verification of the supplied value
-  (ON_CHECK) and the updation (ON_UPDATE) of the tracker system variable,
-  namely - check() and update().
+  (ON_UPDATE) of the tracker system variable, namely - update().
 */
 
 class State_tracker
@@ -91,22 +89,19 @@ public:
   /** Called in the constructor of THD*/
   virtual bool enable(THD *thd)= 0;
 
-  /** To be invoked when the tracker's system variable is checked (ON_CHECK). */
-  virtual bool check(THD *thd, set_var *var)= 0;
-
   /** To be invoked when the tracker's system variable is updated (ON_UPDATE).*/
-  virtual bool update(THD *thd)= 0;
+  virtual bool update(THD *thd, set_var *var)= 0;
 
   /** Store changed data into the given buffer. */
   virtual bool store(THD *thd, String *buf)= 0;
 
   /** Mark the entity as changed. */
-  virtual void mark_as_changed(THD *thd, LEX_CSTRING *name)= 0;
+  virtual void mark_as_changed(THD *thd, LEX_CSTRING *name);
 };
 
 bool sysvartrack_validate_value(THD *thd, const char *str, size_t len);
 bool sysvartrack_reprint_value(THD *thd, char *str, size_t len);
-bool sysvartrack_update(THD *thd);
+bool sysvartrack_update(THD *thd, set_var *var);
 size_t sysvartrack_value_len(THD *thd);
 bool sysvartrack_value_construct(THD *thd, char *val, size_t len);
 
@@ -122,7 +117,7 @@ bool sysvartrack_value_construct(THD *thd, char *val, size_t len);
 class Session_tracker
 {
 private:
-  State_tracker *m_trackers[SESSION_TRACKER_END + 1];
+  State_tracker *m_trackers[SESSION_TRACKER_END];
 
   /* The following two functions are private to disable copying. */
   Session_tracker(Session_tracker const &other)
@@ -146,7 +141,7 @@ public:
   /* trick to make happy memory accounting system */
   void deinit()
   {
-    for (int i= 0; i <= SESSION_TRACKER_END; i ++)
+    for (int i= 0; i < SESSION_TRACKER_END; i++)
     {
       if (m_trackers[i])
         delete m_trackers[i];
@@ -155,7 +150,7 @@ public:
   }
 
   void enable(THD *thd);
-  bool server_boot_verify(const CHARSET_INFO *char_set);
+  static bool server_boot_verify(CHARSET_INFO *char_set);
 
   /** Returns the pointer to the tracker object for the specified tracker. */
   inline State_tracker *get_tracker(enum_session_tracker tracker) const
@@ -174,4 +169,136 @@ public:
   void store(THD *thd, String *main_buf);
 };
 
+
+/*
+  Transaction_state_tracker
+*/
+
+/**
+  Transaction state (no transaction, transaction active, work attached, etc.)
+*/
+enum enum_tx_state {
+  TX_EMPTY        =   0,  ///< "none of the below"
+  TX_EXPLICIT     =   1,  ///< an explicit transaction is active
+  TX_IMPLICIT     =   2,  ///< an implicit transaction is active
+  TX_READ_TRX     =   4,  ///<     transactional reads  were done
+  TX_READ_UNSAFE  =   8,  ///< non-transaction   reads  were done
+  TX_WRITE_TRX    =  16,  ///<     transactional writes were done
+  TX_WRITE_UNSAFE =  32,  ///< non-transactional writes were done
+  TX_STMT_UNSAFE  =  64,  ///< "unsafe" (non-deterministic like UUID()) stmts
+  TX_RESULT_SET   = 128,  ///< result set was sent
+  TX_WITH_SNAPSHOT= 256,  ///< WITH CONSISTENT SNAPSHOT was used
+  TX_LOCKED_TABLES= 512   ///< LOCK TABLES is active
+};
+
+
+/**
+  Transaction access mode
+*/
+enum enum_tx_read_flags {
+  TX_READ_INHERIT =   0,  ///< not explicitly set, inherit session.tx_read_only
+  TX_READ_ONLY    =   1,  ///< START TRANSACTION READ ONLY,  or tx_read_only=1
+  TX_READ_WRITE   =   2,  ///< START TRANSACTION READ WRITE, or tx_read_only=0
+};
+
+
+/**
+  Transaction isolation level
+*/
+enum enum_tx_isol_level {
+  TX_ISOL_INHERIT     = 0, ///< not explicitly set, inherit session.tx_isolation
+  TX_ISOL_UNCOMMITTED = 1,
+  TX_ISOL_COMMITTED   = 2,
+  TX_ISOL_REPEATABLE  = 3,
+  TX_ISOL_SERIALIZABLE= 4
+};
+
+
+/**
+  Transaction tracking level
+*/
+enum enum_session_track_transaction_info {
+  TX_TRACK_NONE      = 0,  ///< do not send tracker items on transaction info
+  TX_TRACK_STATE     = 1,  ///< track transaction status
+  TX_TRACK_CHISTICS  = 2   ///< track status and characteristics
+};
+
+
+/**
+  This is a tracker class that enables & manages the tracking of
+  current transaction info for a particular connection.
+*/
+
+class Transaction_state_tracker : public State_tracker
+{
+private:
+  /** Helper function: turn table info into table access flag */
+  enum_tx_state calc_trx_state(THD *thd, thr_lock_type l, bool has_trx);
+public:
+  /** Constructor */
+  Transaction_state_tracker();
+  bool enable(THD *thd)
+  { return update(thd, NULL); }
+  bool update(THD *thd, set_var *var);
+  bool store(THD *thd, String *buf);
+
+  /** Change transaction characteristics */
+  void set_read_flags(THD *thd, enum enum_tx_read_flags flags);
+  void set_isol_level(THD *thd, enum enum_tx_isol_level level);
+
+  /** Change transaction state */
+  void clear_trx_state(THD *thd, uint clear);
+  void add_trx_state(THD *thd, uint add);
+  void inline add_trx_state(THD *thd, thr_lock_type l, bool has_trx)
+  {
+    add_trx_state(thd, calc_trx_state(thd, l, has_trx));
+  }
+  void add_trx_state_from_thd(THD *thd);
+  void end_trx(THD *thd);
+
+
+private:
+  enum enum_tx_changed {
+    TX_CHG_NONE     = 0,  ///< no changes from previous stmt
+    TX_CHG_STATE    = 1,  ///< state has changed from previous stmt
+    TX_CHG_CHISTICS = 2   ///< characteristics have changed from previous stmt
+  };
+
+  /** any trackable changes caused by this statement? */
+  uint                     tx_changed;
+
+  /** transaction state */
+  uint                     tx_curr_state,  tx_reported_state;
+
+  /** r/w or r/o set? session default? */
+  enum enum_tx_read_flags  tx_read_flags;
+
+  /**  isolation level */
+  enum enum_tx_isol_level  tx_isol_level;
+
+  void reset();
+
+  inline void update_change_flags(THD *thd)
+  {
+    tx_changed &= ~TX_CHG_STATE;
+    tx_changed |= (tx_curr_state != tx_reported_state) ? TX_CHG_STATE : 0;
+    if (tx_changed != TX_CHG_NONE)
+      mark_as_changed(thd, NULL);
+  }
+};
+
+#define TRANSACT_TRACKER(X) \
+ do { if (thd->variables.session_track_transaction_info > TX_TRACK_NONE) \
+   {((Transaction_state_tracker *) \
+         thd->session_tracker.get_tracker(TRANSACTION_INFO_TRACKER)) \
+          ->X; } } while(0)
+#define SESSION_TRACKER_CHANGED(A,B,C) \
+  thd->session_tracker.mark_as_changed(A,B,C)
+#else
+
+#define TRANSACT_TRACKER(X) do{}while(0)
+#define SESSION_TRACKER_CHANGED(A,B,C) do{}while(0)
+
+#endif //EMBEDDED_LIBRARY
+
 #endif /* SESSION_TRACKER_INCLUDED */