~drizzle-trunk/drizzle/development

/*****************************************************************************

Copyright (c) 2000, 2009, MySQL AB & Innobase Oy. All Rights Reserved.

Copyright (c) 2008, 2009 Google Inc.

Portions of this file contain modifications contributed and copyrighted by

Google, Inc. Those modifications are gratefully acknowledged and are described

briefly in the InnoDB documentation. The contributions by Google are

incorporated with their permission, and subject to the conditions contained in

the file COPYING.Google.

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

*****************************************************************************/

/***********************************************************************

Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.

Copyright (c) 2009, Percona Inc.

Portions of this file contain modifications contributed and copyrighted

by Percona Inc.. Those modifications are

gratefully acknowledged and are described briefly in the InnoDB

documentation. The contributions by Percona Inc. are incorporated with

their permission, and subject to the conditions contained in the file

COPYING.Percona.

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

***********************************************************************/

/* TODO list for the InnoDB Cursor in 5.0:

  - Remove the flag trx->active_trans and look at trx->conc_state

  - fix savepoint functions to use savepoint storage area

  - Find out what kind of problems the OS X case-insensitivity causes to

    table and database names; should we 'normalize' the names like we do

    in Windows?

*/

#include "drizzled/server_includes.h"

#include "drizzled/error.h"

#include "drizzled/errmsg_print.h"

#include "mystrings/m_ctype.h"

#include "mysys/my_sys.h"

#include "mysys/hash.h"

#include "mysys/mysys_err.h"

#include "drizzled/plugin.h"

#include "drizzled/show.h"

#include "drizzled/data_home.h"

#include "drizzled/error.h"

#include "drizzled/field.h"

#include "drizzled/session.h"

#include "drizzled/current_session.h"

#include "drizzled/table.h"

#include "drizzled/field/blob.h"

#include "drizzled/field/varstring.h"

#include "drizzled/field/timestamp.h"

#include "drizzled/plugin/storage_engine.h"

#include "drizzled/plugin/info_schema_table.h"

#include "drizzled/memory/multi_malloc.h"

/** @file ha_innodb.cc */

/* Include necessary InnoDB headers */

extern "C" {

#include "univ.i"

#include "btr0sea.h"

#include "os0file.h"

#include "os0thread.h"

#include "srv0start.h"

#include "srv0srv.h"

#include "trx0roll.h"

#include "trx0trx.h"

#include "trx0sys.h"

#include "mtr0mtr.h"

#include "row0ins.h"

#include "row0mysql.h"

#include "row0sel.h"

#include "row0upd.h"

#include "log0log.h"

#include "lock0lock.h"

#include "dict0crea.h"

#include "btr0cur.h"

#include "btr0btr.h"

#include "fsp0fsp.h"

#include "sync0sync.h"

#include "fil0fil.h"

#include "trx0xa.h"

#include "row0merge.h"

#include "thr0loc.h"

#include "dict0boot.h"

#include "ha_prototypes.h"

#include "ut0mem.h"

#include "ibuf0ibuf.h"

}

#include "ha_innodb.h"

#include "i_s.h"

#include "handler0vars.h"

#include <string>

using namespace std;

#ifndef DRIZZLE_SERVER

/* This is needed because of Bug #3596.  Let us hope that pthread_mutex_t

is defined the same in both builds: the MySQL server and the InnoDB plugin. */

extern pthread_mutex_t LOCK_thread_count;

#endif /* DRIZZLE_SERVER */

/** to protect innobase_open_files */

static pthread_mutex_t innobase_share_mutex;

/** to force correct commit order in binlog */

static pthread_mutex_t prepare_commit_mutex;

static ulong commit_threads = 0;

static pthread_mutex_t commit_threads_m;

static pthread_cond_t commit_cond;

static pthread_mutex_t commit_cond_m;

static bool innodb_inited = 0;

#define INSIDE_HA_INNOBASE_CC

/* In the Windows plugin, the return value of current_session is

undefined.  Map it to NULL. */

#if defined MYSQL_DYNAMIC_PLUGIN && defined __WIN__

# undef current_session

# define current_session NULL

# define EQ_CURRENT_SESSION(session) TRUE

#else /* MYSQL_DYNAMIC_PLUGIN && __WIN__ */

# define EQ_CURRENT_SESSION(session) ((session) == current_session)

#endif /* MYSQL_DYNAMIC_PLUGIN && __WIN__ */

static drizzled::plugin::StorageEngine* innodb_engine_ptr= NULL;

static const long AUTOINC_OLD_STYLE_LOCKING = 0;

static const long AUTOINC_NEW_STYLE_LOCKING = 1;

static const long AUTOINC_NO_LOCKING = 2;

static long innobase_mirrored_log_groups, innobase_log_files_in_group,

	innobase_log_buffer_size,

	innobase_additional_mem_pool_size, innobase_file_io_threads,

	innobase_force_recovery, innobase_open_files,

	innobase_autoinc_lock_mode;

static ulong innobase_commit_concurrency = 0;

static ulong innobase_read_io_threads;

static ulong innobase_write_io_threads;

/**

 * @TODO: Turn this into size_t as soon as we have a Variable<size_t>

 */

static int64_t innobase_buffer_pool_size, innobase_log_file_size;

/* The default values for the following char* start-up parameters

are determined in innobase_init below: */

static char*	innobase_data_home_dir			= NULL;

static char*	innobase_data_file_path			= NULL;

static char*	innobase_log_group_home_dir		= NULL;

static char*	innobase_file_format_name		= NULL;

static char*	innobase_change_buffering		= NULL;

/* Note: This variable can be set to on/off and any of the supported

file formats in the configuration file, but can only be set to any

of the supported file formats during runtime. */

static char*	innobase_file_format_check		= NULL;

/* The following has a misleading name: starting from 4.0.5, this also

affects Windows: */

static char*	innobase_unix_file_flush_method		= NULL;

/* Below we have boolean-valued start-up parameters, and their default

values */

static ulong	innobase_fast_shutdown			= 1;

#ifdef UNIV_LOG_ARCHIVE

static my_bool	innobase_log_archive			= FALSE;

static char*	innobase_log_arch_dir			= NULL;

#endif /* UNIV_LOG_ARCHIVE */

static my_bool	innobase_use_doublewrite		= TRUE;

static my_bool	innobase_use_checksums			= TRUE;

static my_bool	innobase_locks_unsafe_for_binlog	= TRUE;

static my_bool	innobase_rollback_on_timeout		= FALSE;

static my_bool	innobase_create_status_file		= FALSE;

static my_bool	innobase_stats_on_metadata		= TRUE;

static char*	internal_innobase_data_file_path	= NULL;

static char*	innodb_version_str = (char*) INNODB_VERSION_STR;

/* The following counter is used to convey information to InnoDB

about server activity: in selects it is not sensible to call

srv_active_wake_master_thread after each fetch or search, we only do

it every INNOBASE_WAKE_INTERVAL'th step. */

#define INNOBASE_WAKE_INTERVAL	32

static ulong	innobase_active_counter	= 0;

static hash_table_t*	innobase_open_tables;

#ifdef __NETWARE__	/* some special cleanup for NetWare */

bool nw_panic = FALSE;

#endif

/** Allowed values of innodb_change_buffering */

static const char* innobase_change_buffering_values[IBUF_USE_COUNT] = {

	"none",		/* IBUF_USE_NONE */

	"inserts"	/* IBUF_USE_INSERT */

};

/********************************************************************

Gives the file extension of an InnoDB single-table tablespace. */

static const char* ha_innobase_exts[] = {

  ".ibd",

  NULL

};

static INNOBASE_SHARE *get_share(const char *table_name);

static void free_share(INNOBASE_SHARE *share);

class InnobaseEngine : public drizzled::plugin::StorageEngine

{

public:

  InnobaseEngine(string name_arg)

   : drizzled::plugin::StorageEngine(name_arg,

                                     HTON_HAS_DOES_TRANSACTIONS, sizeof(trx_named_savept_t))

  {

    table_definition_ext= drizzled::plugin::DEFAULT_DEFINITION_FILE_EXT;

    addAlias("INNOBASE");

  }

  uint64_t table_flags() const

  {

    return (HA_NULL_IN_KEY |

            HA_CAN_INDEX_BLOBS |

            HA_PRIMARY_KEY_REQUIRED_FOR_POSITION |

            HA_PRIMARY_KEY_IN_READ_INDEX |

            HA_PARTIAL_COLUMN_READ |

            HA_TABLE_SCAN_ON_INDEX | 

            HA_MRR_CANT_SORT);

  }

  virtual

  int

  close_connection(

/*======================*/

			/* out: 0 or error number */

	Session*	session);	/* in: handle to the MySQL thread of the user

			whose resources should be free'd */

  virtual int savepoint_set_hook(Session* session,

                                 void *savepoint);

  virtual int savepoint_rollback_hook(Session* session, 

                                      void *savepoint);

  virtual int savepoint_release_hook(Session* session, 

                                     void *savepoint);

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

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

  /***********************************************************************

  This function is used to prepare X/Open XA distributed transaction   */

  virtual

  int

  prepare(

  /*================*/

  			/* out: 0 or error number */

  	Session*	session,	/* in: handle to the MySQL thread of the user

  			whose XA transaction should be prepared */

  	bool	all);	/* in: TRUE - commit transaction

  			FALSE - the current SQL statement ended */

  /***********************************************************************

  This function is used to recover X/Open XA distributed transactions   */

  virtual

  int

  recover(

  /*================*/

  				/* out: number of prepared transactions

  				stored in xid_list */

  	XID*	xid_list,	/* in/out: prepared transactions */

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

  /***********************************************************************

  This function is used to commit one X/Open XA distributed transaction

  which is in the prepared state */

  virtual

  int

  commit_by_xid(

  /*===================*/

  			/* out: 0 or error number */

  	XID*	xid);	/* in: X/Open XA transaction identification */

  /***********************************************************************

  This function is used to rollback one X/Open XA distributed transaction

  which is in the prepared state */

  virtual

  int

  rollback_by_xid(

  /*=====================*/

  			/* out: 0 or error number */

  	XID	*xid);	/* in: X/Open XA transaction identification */

  virtual Cursor *create(TableShare &table,

                          MEM_ROOT *mem_root)

  {

    return new (mem_root) ha_innobase(*this, table);

  }

  /*********************************************************************

  Removes all tables in the named database inside InnoDB. */

  virtual

  void

  drop_database(

  /*===================*/

  			/* out: error number */

  	char*	path);	/* in: database path; inside InnoDB the name

  			of the last directory in the path is used as

  			the database name: for example, in 'mysql/data/test'

  			the database name is 'test' */

  /*********************************************************************

  Creates an InnoDB transaction struct for the session if it does not yet have one.

  Starts a new InnoDB transaction if a transaction is not yet started. And

  assigns a new snapshot for a consistent read if the transaction does not yet

  have one. */

  virtual

  int

  start_consistent_snapshot(

  /*====================================*/

  			/* out: 0 */

  	Session*	session);	/* in: MySQL thread handle of the user for whom

  			the transaction should be committed */

  /********************************************************************

  Flushes InnoDB logs to disk and makes a checkpoint. Really, a commit flushes

  the logs, and the name of this function should be innobase_checkpoint. */

  virtual

  bool

  flush_logs();

  /*================*/

  				/* out: TRUE if error */

  /****************************************************************************

  Implements the SHOW INNODB STATUS command. Sends the output of the InnoDB

  Monitor to the client. */

  virtual

  bool

  show_status(

  /*===============*/

  	Session*	session,	/* in: the MySQL query thread of the caller */

  	stat_print_fn *stat_print,

	enum ha_stat_type stat_type);

  virtual

  int

  release_temporary_latches(

  /*===============================*/

				/* out: 0 */

	Session*		session);	/* in: MySQL thread */

  const char** bas_ext() const {

	return(ha_innobase_exts);

  }

  UNIV_INTERN int doCreateTable(Session *session, 

                                const char *table_name,

                                Table& form,

                                drizzled::message::Table&);

  UNIV_INTERN int doRenameTable(Session* session,

                                const char* from, 

                                const char* to);

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

  UNIV_INTERN virtual bool get_error_message(int error, String *buf);

};

/** @brief Initialize the default value of innodb_commit_concurrency.

Once InnoDB is running, the innodb_commit_concurrency must not change

from zero to nonzero. (Bug #42101)

The initial default value is 0, and without this extra initialization,

SET GLOBAL innodb_commit_concurrency=DEFAULT would set the parameter

to 0, even if it was initially set to nonzero at the command line

or configuration file. */

static

void

innobase_commit_concurrency_init_default(void);

/*==========================================*/

/************************************************************//**

Validate the file format name and return its corresponding id.

@return	valid file format id */

static

uint

innobase_file_format_name_lookup(

/*=============================*/

	const char*	format_name);		/*!< in: pointer to file format

						name */

/************************************************************//**

Validate the file format check config parameters, as a side effect it

sets the srv_check_file_format_at_startup variable.

@return	true if one of  "on" or "off" */

static

bool

innobase_file_format_check_on_off(

/*==============================*/

	const char*	format_check);		/*!< in: parameter value */

/************************************************************//**

Validate the file format check config parameters, as a side effect it

sets the srv_check_file_format_at_startup variable.

@return	true if valid config value */

static

bool

innobase_file_format_check_validate(

/*================================*/

	const char*	format_check);		/*!< in: parameter value */

static const char innobase_engine_name[]= "InnoDB";

/*************************************************************//**

Check for a valid value of innobase_commit_concurrency.

@return	0 for valid innodb_commit_concurrency */

static

int

innobase_commit_concurrency_validate(

/*=================================*/

	Session*			,	/*!< in: thread handle */

	struct st_mysql_sys_var*	,	/*!< in: pointer to system

						variable */

	void*				save,	/*!< out: immediate result

						for update function */

	struct st_mysql_value*		value)	/*!< in: incoming string */

{

	int64_t 	intbuf;

	ulong		commit_concurrency;

	if (value->val_int(value, &intbuf)) {

		/* The value is NULL. That is invalid. */

		return(1);

	}

	*reinterpret_cast<ulong*>(save) = commit_concurrency

		= static_cast<ulong>(intbuf);

	/* Allow the value to be updated, as long as it remains zero

	or nonzero. */

	return(!(!commit_concurrency == !innobase_commit_concurrency));

}

static DRIZZLE_SessionVAR_BOOL(support_xa, PLUGIN_VAR_OPCMDARG,

  "Enable InnoDB support for the XA two-phase commit",

  /* check_func */ NULL, /* update_func */ NULL,

  /* default */ TRUE);

static DRIZZLE_SessionVAR_BOOL(table_locks, PLUGIN_VAR_OPCMDARG,

  "Enable InnoDB locking in LOCK TABLES",

  /* check_func */ NULL, /* update_func */ NULL,

  /* default */ TRUE);

static DRIZZLE_SessionVAR_BOOL(strict_mode, PLUGIN_VAR_OPCMDARG,

  "Use strict mode when evaluating create options.",

  NULL, NULL, FALSE);

static DRIZZLE_SessionVAR_ULONG(lock_wait_timeout, PLUGIN_VAR_RQCMDARG,

  "Timeout in seconds an InnoDB transaction may wait for a lock before being rolled back. Values above 100000000 disable the timeout.",

  NULL, NULL, 50, 1, 1024 * 1024 * 1024, 0);

/***********************************************************************

Closes an InnoDB database. */

static

int

innobase_deinit(drizzled::plugin::Registry &registry);

/*****************************************************************//**

Commits a transaction in an InnoDB database. */

static

void

innobase_commit_low(

/*================*/

	trx_t*	trx);	/*!< in: transaction handle */

static SHOW_VAR innodb_status_variables[]= {

  {"buffer_pool_pages_data",

  (char*) &export_vars.innodb_buffer_pool_pages_data,	  SHOW_LONG},

  {"buffer_pool_pages_dirty",

  (char*) &export_vars.innodb_buffer_pool_pages_dirty,	  SHOW_LONG},

  {"buffer_pool_pages_flushed",

  (char*) &export_vars.innodb_buffer_pool_pages_flushed,  SHOW_LONG},

  {"buffer_pool_pages_free",

  (char*) &export_vars.innodb_buffer_pool_pages_free,	  SHOW_LONG},

#ifdef UNIV_DEBUG

  {"buffer_pool_pages_latched",

  (char*) &export_vars.innodb_buffer_pool_pages_latched,  SHOW_LONG},

#endif /* UNIV_DEBUG */

  {"buffer_pool_pages_misc",

  (char*) &export_vars.innodb_buffer_pool_pages_misc,	  SHOW_LONG},

  {"buffer_pool_pages_total",

  (char*) &export_vars.innodb_buffer_pool_pages_total,	  SHOW_LONG},

  {"buffer_pool_read_ahead_rnd",

  (char*) &export_vars.innodb_buffer_pool_read_ahead_rnd, SHOW_LONG},

  {"buffer_pool_read_ahead_seq",

  (char*) &export_vars.innodb_buffer_pool_read_ahead_seq, SHOW_LONG},

  {"buffer_pool_read_requests",

  (char*) &export_vars.innodb_buffer_pool_read_requests,  SHOW_LONG},

  {"buffer_pool_reads",

  (char*) &export_vars.innodb_buffer_pool_reads,	  SHOW_LONG},

  {"buffer_pool_wait_free",

  (char*) &export_vars.innodb_buffer_pool_wait_free,	  SHOW_LONG},

  {"buffer_pool_write_requests",

  (char*) &export_vars.innodb_buffer_pool_write_requests, SHOW_LONG},

  {"data_fsyncs",

  (char*) &export_vars.innodb_data_fsyncs,		  SHOW_LONG},

  {"data_pending_fsyncs",

  (char*) &export_vars.innodb_data_pending_fsyncs,	  SHOW_LONG},

  {"data_pending_reads",

  (char*) &export_vars.innodb_data_pending_reads,	  SHOW_LONG},

  {"data_pending_writes",

  (char*) &export_vars.innodb_data_pending_writes,	  SHOW_LONG},

  {"data_read",

  (char*) &export_vars.innodb_data_read,		  SHOW_LONG},

  {"data_reads",

  (char*) &export_vars.innodb_data_reads,		  SHOW_LONG},

  {"data_writes",

  (char*) &export_vars.innodb_data_writes,		  SHOW_LONG},

  {"data_written",

  (char*) &export_vars.innodb_data_written,		  SHOW_LONG},

  {"dblwr_pages_written",

  (char*) &export_vars.innodb_dblwr_pages_written,	  SHOW_LONG},

  {"dblwr_writes",

  (char*) &export_vars.innodb_dblwr_writes,		  SHOW_LONG},

  {"have_atomic_builtins",

  (char*) &export_vars.innodb_have_atomic_builtins,	  SHOW_BOOL},

  {"log_waits",

  (char*) &export_vars.innodb_log_waits,		  SHOW_LONG},

  {"log_write_requests",

  (char*) &export_vars.innodb_log_write_requests,	  SHOW_LONG},

  {"log_writes",

  (char*) &export_vars.innodb_log_writes,		  SHOW_LONG},

  {"os_log_fsyncs",

  (char*) &export_vars.innodb_os_log_fsyncs,		  SHOW_LONG},

  {"os_log_pending_fsyncs",

  (char*) &export_vars.innodb_os_log_pending_fsyncs,	  SHOW_LONG},

  {"os_log_pending_writes",

  (char*) &export_vars.innodb_os_log_pending_writes,	  SHOW_LONG},

  {"os_log_written",

  (char*) &export_vars.innodb_os_log_written,		  SHOW_LONG},

  {"page_size",

  (char*) &export_vars.innodb_page_size,		  SHOW_LONG},

  {"pages_created",

  (char*) &export_vars.innodb_pages_created,		  SHOW_LONG},

  {"pages_read",

  (char*) &export_vars.innodb_pages_read,		  SHOW_LONG},

  {"pages_written",

  (char*) &export_vars.innodb_pages_written,		  SHOW_LONG},

  {"row_lock_current_waits",

  (char*) &export_vars.innodb_row_lock_current_waits,	  SHOW_LONG},

  {"row_lock_time",

  (char*) &export_vars.innodb_row_lock_time,		  SHOW_LONGLONG},

  {"row_lock_time_avg",

  (char*) &export_vars.innodb_row_lock_time_avg,	  SHOW_LONG},

  {"row_lock_time_max",

  (char*) &export_vars.innodb_row_lock_time_max,	  SHOW_LONG},

  {"row_lock_waits",

  (char*) &export_vars.innodb_row_lock_waits,		  SHOW_LONG},

  {"rows_deleted",

  (char*) &export_vars.innodb_rows_deleted,		  SHOW_LONG},

  {"rows_inserted",

  (char*) &export_vars.innodb_rows_inserted,		  SHOW_LONG},

  {"rows_read",

  (char*) &export_vars.innodb_rows_read,		  SHOW_LONG},

  {"rows_updated",

  (char*) &export_vars.innodb_rows_updated,		  SHOW_LONG},

  {NULL, NULL, SHOW_LONG}

};

/* General functions */

/******************************************************************//**

Returns true if the thread is the replication thread on the slave

server. Used in srv_conc_enter_innodb() to determine if the thread

should be allowed to enter InnoDB - the replication thread is treated

differently than other threads. Also used in

srv_conc_force_exit_innodb().

DRIZZLE: Note, we didn't change this name to avoid more ifdef forking 

         in non-Cursor code.

@return	true if session is the replication thread */

extern "C" UNIV_INTERN

ibool

thd_is_replication_slave_thread(

/*============================*/

	void*	)	/*!< in: thread handle (Session*) */

{

	return false;

}

/******************************************************************//**

Save some CPU by testing the value of srv_thread_concurrency in inline

functions. */

static inline

void

innodb_srv_conc_enter_innodb(

/*=========================*/

	trx_t*	trx)	/*!< in: transaction handle */

{

	if (UNIV_LIKELY(!srv_thread_concurrency)) {

		return;

	}

	srv_conc_enter_innodb(trx);

}

/******************************************************************//**

Save some CPU by testing the value of srv_thread_concurrency in inline

functions. */

static inline

void

innodb_srv_conc_exit_innodb(

/*========================*/

	trx_t*	trx)	/*!< in: transaction handle */

{

	if (UNIV_LIKELY(!trx->declared_to_be_inside_innodb)) {

		return;

	}

	srv_conc_exit_innodb(trx);

}

/******************************************************************//**

Releases possible search latch and InnoDB thread FIFO ticket. These should

be released at each SQL statement end, and also when mysqld passes the

control to the client. It does no harm to release these also in the middle

of an SQL statement. */

static inline

void

innobase_release_stat_resources(

/*============================*/

	trx_t*	trx)	/*!< in: transaction object */

{

	if (trx->has_search_latch) {

		trx_search_latch_release_if_reserved(trx);

	}

	if (trx->declared_to_be_inside_innodb) {

		/* Release our possible ticket in the FIFO */

		srv_conc_force_exit_innodb(trx);

	}

}

/******************************************************************//**

Returns true if the transaction this thread is processing has edited

non-transactional tables. Used by the deadlock detector when deciding

which transaction to rollback in case of a deadlock - we try to avoid

rolling back transactions that have edited non-transactional tables.

DRIZZLE: Note, we didn't change this name to avoid more ifdef forking 

         in non-Cursor code.

@return	true if non-transactional tables have been edited */

extern "C" UNIV_INTERN

ibool

thd_has_edited_nontrans_tables(

/*===========================*/

	void*		session)	/*!< in: thread handle (Session*) */

{

	return((ibool) session_non_transactional_update((Session*) session));

}

/******************************************************************//**

Returns true if the thread is executing a SELECT statement.

@return	true if session is executing SELECT */

extern "C" UNIV_INTERN

ibool

thd_is_select(

/*==========*/

	const void*	session)	/*!< in: thread handle (Session*) */

{

	return(session_sql_command((const Session*) session) == SQLCOM_SELECT);

}

/******************************************************************//**

Returns true if the thread supports XA,

global value of innodb_supports_xa if session is NULL.

@return	true if session has XA support */

extern "C" UNIV_INTERN

ibool

thd_supports_xa(

/*============*/

	void*	session)	/*!< in: thread handle (Session*), or NULL to query

				the global innodb_supports_xa */

{

	return(SessionVAR((Session*) session, support_xa));

}

/******************************************************************//**

Returns the lock wait timeout for the current connection.

@return	the lock wait timeout, in seconds */

extern "C" UNIV_INTERN

ulong

thd_lock_wait_timeout(

/*==================*/

	void*	session)	/*!< in: thread handle (Session*), or NULL to query

			the global innodb_lock_wait_timeout */

{

	/* According to <drizzle/plugin.h>, passing session == NULL

	returns the global value of the session variable. */

	return(SessionVAR((Session*) session, lock_wait_timeout));

}

/********************************************************************//**

Obtain the InnoDB transaction of a MySQL thread.

@return	reference to transaction pointer */

static inline

trx_t*&

session_to_trx(

/*=======*/

	Session*	session)	/*!< in: Drizzle Session */

{

	return(*(trx_t**) session_ha_data(session, innodb_engine_ptr));

}

/********************************************************************//**

Call this function when mysqld passes control to the client. That is to

avoid deadlocks on the adaptive hash S-latch possibly held by session. For more

documentation, see Cursor.cc.

@return	0 */

int

InnobaseEngine::release_temporary_latches(

/*===============================*/

	Session*		session)	/*!< in: MySQL thread */

{

	trx_t*	trx;

	assert(this == innodb_engine_ptr);

	if (!innodb_inited) {

		return(0);

	}

	trx = session_to_trx(session);

	if (trx) {

		innobase_release_stat_resources(trx);

	}

	return(0);

}

/********************************************************************//**

Increments innobase_active_counter and every INNOBASE_WAKE_INTERVALth

time calls srv_active_wake_master_thread. This function should be used

when a single database operation may introduce a small need for

server utility activity, like checkpointing. */