~drizzle-trunk/drizzle/development

/* Copyright (C) 2000-2003 MySQL AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/**
  @file

  @brief
  logging of commands

  @todo
    Abort logging when we get an error in reading or writing log files
*/

#include <drizzled/server_includes.h>
#include <libdrizzleclient/libdrizzle.h>
#include <drizzled/replicator.h>
#include <mysys/hash.h>

#include <mysys/my_dir.h>
#include <stdarg.h>

#include <drizzled/plugin.h>
#include <drizzled/error.h>
#include <drizzled/errmsg_print.h>
#include <drizzled/gettext.h>
#include <drizzled/data_home.h>
#include <drizzled/session.h>
#include <drizzled/handler.h>

/* max size of the log message */
#define MY_OFF_T_UNDEF (~(my_off_t)0UL)

static int binlog_init(void *p);
static int binlog_close_connection(handlerton *hton, Session *session);
static int binlog_savepoint_set(handlerton *hton, Session *session, void *sv);
static int binlog_savepoint_rollback(handlerton *hton, Session *session, void *sv);
static int binlog_commit(handlerton *hton, Session *session, bool all);
static int binlog_rollback(handlerton *hton, Session *session, bool all);
static int binlog_prepare(handlerton *hton, Session *session, bool all);


handlerton *binlog_hton;


 /*
  Save position of binary log transaction cache.

  SYNPOSIS
    binlog_trans_log_savepos()

    session      The thread to take the binlog data from
    pos      Pointer to variable where the position will be stored

  DESCRIPTION

    Save the current position in the binary log transaction cache into
    the variable pointed to by 'pos'
 */

static void
binlog_trans_log_savepos(Session *, my_off_t *pos)
{
  assert(pos != NULL);

  return;
}


/*
  this function is mostly a placeholder.
  conceptually, binlog initialization (now mostly done in DRIZZLE_BIN_LOG::open)
  should be moved here.
*/

int binlog_init(void *p)
{
  binlog_hton= (handlerton *)p;
  binlog_hton->state= SHOW_OPTION_YES;
  binlog_hton->savepoint_offset= sizeof(my_off_t);
  binlog_hton->close_connection= binlog_close_connection;
  binlog_hton->savepoint_set= binlog_savepoint_set;
  binlog_hton->savepoint_rollback= binlog_savepoint_rollback;
  binlog_hton->commit= binlog_commit;
  binlog_hton->rollback= binlog_rollback;
  binlog_hton->prepare= binlog_prepare;
  binlog_hton->flags= HTON_NOT_USER_SELECTABLE | HTON_HIDDEN;

  return 0;
}

static int binlog_close_connection(handlerton *, Session *)
{

  return 0;
}

static int binlog_prepare(handlerton *, Session *session, bool)
{
  /*
    do nothing.
    just pretend we can do 2pc, so that MySQL won't
    switch to 1pc.
    real work will be done in DRIZZLE_BIN_LOG::log_xid()
  */

  (void)replicator_prepare(session);

  return 0;
}

/**
  This function is called once after each statement.

  It has the responsibility to flush the transaction cache to the
  binlog file on commits.

  @param hton  The binlog handlerton.
  @param session   The client thread that executes the transaction.
  @param all   This is @c true if this is a real transaction commit, and
               @false otherwise.

  @see handlerton::commit
*/
static int binlog_commit(handlerton *, Session *session, bool all)
{
  /*
    Decision table for committing a transaction. The top part, the
    *conditions* represent different cases that can occur, and hte
    bottom part, the *actions*, represent what should be done in that
    particular case.

    Real transaction        'all' was true

    Statement in cache      There were at least one statement in the
                            transaction cache

    In transaction          We are inside a transaction

    Stmt modified non-trans The statement being committed modified a
                            non-transactional table

    All modified non-trans  Some statement before this one in the
                            transaction modified a non-transactional
                            table


    =============================  = = = = = = = = = = = = = = = =
    Real transaction               N N N N N N N N N N N N N N N N
    Statement in cache             N N N N N N N N Y Y Y Y Y Y Y Y
    In transaction                 N N N N Y Y Y Y N N N N Y Y Y Y
    Stmt modified non-trans        N N Y Y N N Y Y N N Y Y N N Y Y
    All modified non-trans         N Y N Y N Y N Y N Y N Y N Y N Y

    Action: (C)ommit/(A)ccumulate  C C - C A C - C - - - - A A - A
    =============================  = = = = = = = = = = = = = = = =


    =============================  = = = = = = = = = = = = = = = =
    Real transaction               Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y
    Statement in cache             N N N N N N N N Y Y Y Y Y Y Y Y
    In transaction                 N N N N Y Y Y Y N N N N Y Y Y Y
    Stmt modified non-trans        N N Y Y N N Y Y N N Y Y N N Y Y
    All modified non-trans         N Y N Y N Y N Y N Y N Y N Y N Y

    (C)ommit/(A)ccumulate/(-)      - - - - C C - C - - - - C C - C
    =============================  = = = = = = = = = = = = = = = =

    In other words, we commit the transaction if and only if both of
    the following are true:
     - We are not in a transaction and committing a statement

     - We are in a transaction and one (or more) of the following are
       true:

       - A full transaction is committed

         OR

       - A non-transactional statement is committed and there is
         no statement cached

    Otherwise, we accumulate the statement
  */

  if (all || (!session_test_options(session, OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))) 
  {
    return replicator_end_transaction(session, all, true);
  }

  return(0);
}

/**
  This function is called when a transaction involving a transactional
  table is rolled back.

  It has the responsibility to flush the transaction cache to the
  binlog file. However, if the transaction does not involve
  non-transactional tables, nothing needs to be logged.

  @param hton  The binlog handlerton.
  @param session   The client thread that executes the transaction.
  @param all   This is @c true if this is a real transaction rollback, and
               @false otherwise.

  @see handlerton::rollback
*/
static int binlog_rollback(handlerton *, Session *session, bool all)
{
  int error=0;

  /* TODO: Fix return type */
  (void)replicator_end_transaction(session, all, false);

  return(error);
}

/**
  @note
  How do we handle this (unlikely but legal) case:
  @verbatim
    [transaction] + [update to non-trans table] + [rollback to savepoint] ?
  @endverbatim
  The problem occurs when a savepoint is before the update to the
  non-transactional table. Then when there's a rollback to the savepoint, if we
  simply truncate the binlog cache, we lose the part of the binlog cache where
  the update is. If we want to not lose it, we need to write the SAVEPOINT
  command and the ROLLBACK TO SAVEPOINT command to the binlog cache. The latter
  is easy: it's just write at the end of the binlog cache, but the former
  should be *inserted* to the place where the user called SAVEPOINT. The
  solution is that when the user calls SAVEPOINT, we write it to the binlog
  cache (so no need to later insert it). As transactions are never intermixed
  in the binary log (i.e. they are serialized), we won't have conflicts with
  savepoint names when using mysqlbinlog or in the slave SQL thread.
  Then when ROLLBACK TO SAVEPOINT is called, if we updated some
  non-transactional table, we don't truncate the binlog cache but instead write
  ROLLBACK TO SAVEPOINT to it; otherwise we truncate the binlog cache (which
  will chop the SAVEPOINT command from the binlog cache, which is good as in
  that case there is no need to have it in the binlog).
*/

static int binlog_savepoint_set(handlerton *, Session *session, void *sv)
{
  bool error;
  binlog_trans_log_savepos(session, (my_off_t*) sv);
  /* Write it to the binary log */

  error= replicator_statement(session, session->query, session->query_length);

  return(error);
}

static int binlog_savepoint_rollback(handlerton *, Session *session, void *)
{
  bool error;

  error= replicator_statement(session, session->query, session->query_length);

  return error;
}

drizzle_declare_plugin(binlog)
{
  DRIZZLE_STORAGE_ENGINE_PLUGIN,
  "binlog",
  "1.0",
  "MySQL AB",
  "This is a pseudo storage engine to represent the binlog in a transaction",
  PLUGIN_LICENSE_GPL,
  binlog_init, /* Plugin Init */
  NULL, /* Plugin Deinit */
  NULL,                       /* status variables                */
  NULL,                       /* system variables                */
  NULL                        /* config options                  */
}
drizzle_declare_plugin_end;