transaction_services.h

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 *  Copyright (C) 2010 Jay Pipes <jaypipes@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#pragma once

#include <drizzled/atomics.h>
#include <drizzled/message/transaction.pb.h>
#include <drizzled/identifier.h>
#include <drizzled/message/schema.h>
#include <drizzled/message/table.h>
#include <drizzled/session.h>

#include <drizzled/visibility.h>

namespace drizzled {

class DRIZZLED_API TransactionServices
{
public:
  static const size_t DEFAULT_RECORD_SIZE= 100;
  
  static bool shouldConstructMessages();

  static void finalizeStatementMessage(message::Statement&, Session&);

  static bool insertRecord(Session&, Table &in_table);

  static void updateRecord(Session&, 
                    Table&, 
                    const unsigned char *old_record, 
                    const unsigned char *new_record);

  static void deleteRecord(Session&, Table&, bool use_update_record= false);

  static void createSchema(Session&, const message::Schema &schema);

  static void dropSchema(Session&,
                  const identifier::Schema& identifier,
                  message::schema::const_reference schema);

  static void alterSchema(Session&,
                   const message::Schema &old_schema,
                   const message::Schema &new_schema);

  static void createTable(Session&, const message::Table&);

  static void dropTable(Session&,
                 const identifier::Table& identifier,
                 message::table::const_reference table,
                 bool if_exists);

  static void truncateTable(Session&, Table&);

  static void rawStatement(Session&, const std::string &query, const std::string &schema);

  static void rawStatement(Session& session, const std::string& query)
  {
    rawStatement(session, query, "");
  }

  /* transactions: interface to plugin::StorageEngine functions */
  static int rollbackTransaction(Session&, bool all);

  static int commitTransaction(Session&, bool all);

  static int autocommitOrRollback(Session&, int error);

  /* savepoints */
  static int rollbackToSavepoint(Session&, NamedSavepoint &sv);
  static int setSavepoint(Session&, NamedSavepoint &sv);
  static int releaseSavepoint(Session&, NamedSavepoint &sv);

  static void registerResourceForStatement(Session&, plugin::MonitoredInTransaction*, plugin::TransactionalStorageEngine*);

  static void registerResourceForStatement(Session&,
                                    plugin::MonitoredInTransaction *monitored,
                                    plugin::TransactionalStorageEngine *engine,
                                    plugin::XaResourceManager *resource_manager);

  static void registerResourceForTransaction(Session&, plugin::MonitoredInTransaction*, plugin::TransactionalStorageEngine*);

  static void registerResourceForTransaction(Session&, plugin::MonitoredInTransaction*, plugin::TransactionalStorageEngine*, plugin::XaResourceManager*);

  static void allocateNewTransactionId();
 
  /**************
   * Events API
   **************/

  static bool sendStartupEvent(Session&);

  static bool sendShutdownEvent(Session&);

private:

  static message::Transaction *getActiveTransactionMessage(Session&, bool should_inc_trx_id= true);

  static void initTransactionMessage(message::Transaction&, Session&, bool should_inc_trx_id);
  
  static void initStatementMessage(message::Statement&, message::Statement::Type type, const Session&);

  static void finalizeTransactionMessage(message::Transaction&, const Session&);

  static void cleanupTransactionMessage(message::Transaction *transaction, Session&);
  
  static message::Statement &getInsertStatement(Session&, Table&, uint32_t *next_segment_id);
  
  static void setInsertHeader(message::Statement&,
                       const Session&,
                       Table&);
  static message::Statement &getUpdateStatement(Session&,
                                         Table&,
                                         const unsigned char *old_record, 
                                         const unsigned char *new_record,
                                         uint32_t *next_segment_id);
  static void setUpdateHeader(message::Statement&,
                       const Session&,
                       Table&,
                       const unsigned char *old_record, 
                       const unsigned char *new_record);

  static message::Statement &getDeleteStatement(Session&, Table&, uint32_t *next_segment_id);
  
  static void setDeleteHeader(message::Statement&, const Session&, Table&);

  static int commitTransactionMessage(Session&);

  static void rollbackTransactionMessage(Session&);

  static void rollbackStatementMessage(Session&);

  static bool isFieldUpdated(Field *current_field,
                      Table&,
                      const unsigned char *old_record,
                      const unsigned char *new_record);

  static int sendEvent(Session&, const message::Event &event);

  static message::Transaction *segmentTransactionMessage(Session&, message::Transaction*);

  static int commitPhaseOne(Session&, bool all);

  static uint64_t getCurrentTransactionId(Session&);
};

} /* namespace drizzled */