~posulliv/drizzle/optimizer-style-cleanup

#include "drizzled/plugin/xa_storage_engine.h"

#include "data_dictionary.h"

#include <iostream>

#include <sstream>

#include "plugin/innobase/handler/status_function.h"

 

static plugin::XaStorageEngine* innodb_engine_ptr= NULL;

static plugin::TableFunction* status_table_function_ptr= NULL;

static plugin::TableFunction* cmp_tool= NULL;

static plugin::TableFunction* cmp_reset_tool= NULL;

static plugin::TableFunction* cmp_mem_tool= NULL;

static plugin::TableFunction* cmp_mem_reset_tool= NULL;

static plugin::TableFunction* innodb_trx_tool= NULL;

static plugin::TableFunction* innodb_locks_tool= NULL;

static plugin::TableFunction* innodb_lock_waits_tool= NULL;

class InnobaseEngine : public plugin::XaStorageEngine

    plugin::XaStorageEngine(name_arg,

private:

  virtual int doStartTransaction(Session *session, start_transaction_option_t options);

  virtual void doStartStatement(Session *session);

  virtual void doEndStatement(Session *session);

public:

  virtual int doSetSavepoint(Session* session,

  virtual int doRollbackToSavepoint(Session* session,

                                     drizzled::NamedSavepoint &savepoint);

  virtual int doReleaseSavepoint(Session* session,

                                     drizzled::NamedSavepoint &savepoint);

  virtual int doXaCommit(Session* session, bool all)

  {

    return doCommit(session, all); /* XA commit just does a SQL COMMIT */

  }

  virtual int doXaRollback(Session *session, bool all)

  {

    return doRollback(session, all); /* XA rollback just does a SQL ROLLBACK */

  }

  virtual int doCommit(Session* session, bool all);

  virtual int doRollback(Session* session, bool all);

  doXaPrepare(

  doXaRecover(

        size_t len);            /* in: number of slots in xid_list */

  doXaCommitXid(

  doXaRollbackXid(

  bool

  doDropSchema(

        const std::string       &schema_name);  /* in: database path; inside InnoDB the name

  doReleaseTemporaryLatches(

  UNIV_INTERN int doDropTable(Session& session, const string &table_path);

static drizzle_show_var innodb_status_variables[]= {

InnodbStatusTool::Generator::Generator(drizzled::Field **fields) :

  plugin::TableFunction::Generator(fields)

{ 

  srv_export_innodb_status();

  status_var_ptr= innodb_status_variables;

}

 

bool InnodbStatusTool::Generator::populate()

{

  if (status_var_ptr->name)

  {

    std::ostringstream oss;

    string return_value;

    const char *value= status_var_ptr->value;

 

    /* VARIABLE_NAME */

    push(status_var_ptr->name);

 

    switch (status_var_ptr->type)

    {

    case SHOW_LONG:

      oss << *(int64_t*) value;

      return_value= oss.str();

      break;

    case SHOW_LONGLONG:

      oss << *(int64_t*) value;

      return_value= oss.str();

      break;

    case SHOW_BOOL:

      return_value= *(bool*) value ? "ON" : "OFF";

      break;

    default:

      assert(0);

    }

 

    /* VARIABLE_VALUE */

    if (return_value.length())

      push(return_value);

    else 

      push(" ");

 

    status_var_ptr++;

 

    return true;

  }

  return false;

}

 

InnobaseEngine::doReleaseTemporaryLatches(

          "\n%s", session->getQueryString().c_str()

        trx->mysql_query_str = session->query.c_str();

        status_table_function_ptr= new InnodbStatusTool;

        registry.add(status_table_function_ptr);

 

        cmp_tool= new(std::nothrow)CmpTool(false);

        registry.add(cmp_tool);

 

        cmp_reset_tool= new(std::nothrow)CmpTool(true);

        registry.add(cmp_reset_tool);

 

        cmp_mem_tool= new(std::nothrow)CmpmemTool(false);

        registry.add(cmp_mem_tool);

 

        cmp_mem_reset_tool= new(std::nothrow)CmpmemTool(true);

        registry.add(cmp_mem_reset_tool);

 

        innodb_trx_tool= new(std::nothrow)InnodbTrxTool("INNODB_TRX");

        registry.add(innodb_trx_tool);

 

        innodb_locks_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCKS");

        registry.add(innodb_locks_tool);

 

        innodb_lock_waits_tool= new(std::nothrow)InnodbTrxTool("INNODB_LOCK_WAITS");

        registry.add(innodb_lock_waits_tool);

 

        registry.remove(status_table_function_ptr);

        delete status_table_function_ptr;

 

        registry.remove(cmp_tool);

        delete cmp_tool;

 

        registry.remove(cmp_reset_tool);

        delete cmp_reset_tool;

 

        registry.remove(cmp_mem_tool);

        delete cmp_mem_tool;

 

        registry.remove(cmp_mem_reset_tool);

        delete cmp_mem_reset_tool;

 

        registry.remove(innodb_trx_tool);

        delete innodb_trx_tool;

 

        registry.remove(innodb_locks_tool);

        delete innodb_locks_tool;

 

        registry.remove(innodb_lock_waits_tool);

        delete innodb_lock_waits_tool;

 

InnobaseEngine::doStartTransaction(

        Session*        session,        /*!< in: MySQL thread handle of the user for whom

                                                 the transaction should be committed */

  start_transaction_option_t options)

        trx_t *trx = check_trx_exists(session);

  if (options == START_TRANS_OPT_WITH_CONS_SNAPSHOT)

          trx_assign_read_view(trx);

 

        return 0;

InnobaseEngine::doCommit(

                if (trx->conc_state == TRX_PREPARED) {

InnobaseEngine::doRollback(

InnobaseEngine::doRollbackToSavepoint(

InnobaseEngine::doReleaseSavepoint(

InnobaseEngine::doSetSavepoint(

        assert(trx->conc_state != TRX_NOT_STARTED);

  assert(session->killed != Session::NOT_KILLED ||

         trx->conc_state == TRX_NOT_STARTED);

 

  /* Warn if rolling back some things... */

        if (session->killed != Session::NOT_KILLED &&

      trx->conc_state != TRX_NOT_STARTED &&

      trx->undo_no.low > 0 &&

      global_system_variables.log_warnings)

  {

      errmsg_printf(ERRMSG_LVL_WARN, 

      "Drizzle is closing a connection during a KILL operation\n"

      "that has an active InnoDB transaction.  %lu row modifications will "

      "roll back.\n",

      (ulong) trx->undo_no.low);

  }

                getTransactionalEngine()->releaseTemporaryLatches(session);

                getTransactionalEngine()->releaseTemporaryLatches(session);

        ha_statistic_increment(&system_status_var::ha_write_count);

                        getTransactionalEngine()->commit(user_session, 1);

                        getTransactionalEngine()->commit(user_session, 1);

        ha_statistic_increment(&system_status_var::ha_update_count);

        ha_statistic_increment(&system_status_var::ha_delete_count);

  1) Drizzle calls StorageEngine::doStartStatement(), indicating to

     InnoDB that a new SQL statement has begun.

 

  2a) For each InnoDB-managed table in the SELECT, Drizzle calls ::external_lock

     to set an 'intention' table level lock on the table of the Cursor instance.

     There we set prebuilt->sql_stat_start = TRUE. The flag sql_stat_start should 

     be set true if we are taking this table handle instance to use in a new SQL

     statement issued by the user.

 

  2b) If prebuilt->sql_stat_start == TRUE we 'pre-compile' the MySQL search

5) When the SELECT ends, the Drizzle kernel calls doEndStatement()

 

 (a) we execute a COMMIT there if the autocommit is on. The Drizzle interpreter 

     does NOT execute autocommit for pure read transactions, though it should.

     That is why we must execute the COMMIT in ::doEndStatement().

     have for this SQL statement.

 

  @todo

 

  Remove need for InnoDB to call autocommit for read-only trx

 

  @todo Check the below is still valid (I don't think it is...)

        ha_statistic_increment(&system_status_var::ha_read_key_count);

        ha_statistic_increment(&system_status_var::ha_read_key_count);

        ha_statistic_increment(&system_status_var::ha_read_next_count);

        ha_statistic_increment(&system_status_var::ha_read_next_count);

        ha_statistic_increment(&system_status_var::ha_read_prev_count);

        ha_statistic_increment(&system_status_var::ha_read_first_count);

        ha_statistic_increment(&system_status_var::ha_read_last_count);

        ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);

        ha_statistic_increment(&system_status_var::ha_read_rnd_count);

        if (trx->mysql_query_str) {

                        trx->mysql_query_str, norm_name,

        const string &table_path)       /* in: table name */

bool

InnobaseEngine::doDropSchema(

                             const std::string &schema_name)

                /*!< in: database path; inside InnoDB the name

        string schema_path(schema_name);

        schema_path.append("/");

        error = row_drop_database_for_mysql(schema_path.c_str(), trx);

 

        return false; // We are just a listener since we lack control over DDL, so we give no positive acknowledgement. 

starts to process an SQL statement.  We can use this function to store the pointer to

the Session in the handle.

  trx_t *trx= prebuilt->trx;

        trx->mysql_n_tables_locked= 0;