Changed comments before functions to Doxygen style.

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/** @file handler.cc

/* Handler-calling-functions */

    @brief

  Handler-calling-functions

*/

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation				// gcc: Class implementation

uint known_extensions_id= 0;

/*

/** @brief

  Return the default storage engine handlerton for thread

  SYNOPSIS

  RETURN

    pointer to handlerton

*/

handlerton *ha_default_handlerton(THD *thd)

{

  return (thd->variables.table_type != NULL) ?

}

/*

/** @brief

  Return the storage engine handlerton for the supplied name

  SYNOPSIS

  RETURN

    pointer to handlerton

*/

handlerton *ha_resolve_by_name(THD *thd, const LEX_STRING *name)

{

  const LEX_STRING *table_alias;

}

/* Use other database handler if databasehandler is not compiled in */

/** @brief

  Use other database handler if databasehandler is not compiled in

*/

handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,

                          bool no_substitute, bool report_error)

{

#endif

/*

/** @brief

  Register handler error messages for use with my_error().

  SYNOPSIS

    0           OK

    != 0        Error

*/

static int ha_init_errors(void)

{

#define SETMSG(nr, msg) errmsgs[(nr) - HA_ERR_FIRST]= (msg)

}

/*

/** @brief

  Unregister handler error messages.

  SYNOPSIS

    0           OK

    != 0        Error

*/

static int ha_finish_errors(void)

{

  const char    **errmsgs;

}

/* don't bother to rollback here, it's done already */

/** @brief

  don't bother to rollback here, it's done already

*/

void ha_close_connection(THD* thd)

{

  plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);

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

 ======================= TRANSACTIONS ===================================*/

/*

/** @brief

  Register a storage engine for a transaction

  DESCRIPTION

  DBUG_VOID_RETURN;

}

/*

/** @brief

  RETURN

      0  - ok

      1  - error, transaction was rolled back

  DBUG_RETURN(error);

}

/*

/** @brief

  RETURN

      0  - ok

      1  - transaction was rolled back

  DBUG_RETURN(error);

}

/*

/** @brief

  NOTE - this function does not care about global read lock.

  A caller should.

*/

  DBUG_RETURN(error);

}

/*

/** @brief

  This is used to commit or rollback a single statement depending on the value

  of error. Note that if the autocommit is on, then the following call inside

  InnoDB will commit or rollback the whole transaction (= the statement). The

  the user has used LOCK TABLES then that mechanism does not know to do the

  commit.

*/

int ha_autocommit_or_rollback(THD *thd, int error)

{

  DBUG_ENTER("ha_autocommit_or_rollback");

}

#endif

/*

/** @brief

  recover() step of xa

  NOTE

     in this case commit_list==0, tc_heuristic_recover == 0

     there should be no prepared transactions in this case.

*/

struct xarecover_st

{

  int len, found_foreign_xids, found_my_xids;

  DBUG_RETURN(0);

}

/*

/** @brief

  return the list of XID's to a client, the same way SHOW commands do

  NOTE

  DBUG_RETURN(0);

}

/*

/** @brief

  This function should be called when MySQL sends rows of a SELECT result set

  or the EOF mark to the client. It releases a possible adaptive hash index

  S-latch held by thd in InnoDB and also releases a possible InnoDB query

  thd:           the thread handle of the current connection

  return value:  always 0

*/

static my_bool release_temporary_latches(THD *thd, st_plugin_int *plugin,

                                 void *unused)

{

  DBUG_RETURN(error);

}

/*

/** @brief

  note, that according to the sql standard (ISO/IEC 9075-2:2003)

  section "4.33.4 SQL-statements and transaction states",

  SAVEPOINT is *not* transaction-initiating SQL-statement

*/

int ha_savepoint(THD *thd, SAVEPOINT *sv)

{

  int error=0;

  return FALSE;

}

/*

/** @brief

  This should return ENOENT if the file doesn't exists.

  The .frm file will be deleted only if we return 0 or ENOENT

*/

int ha_delete_table(THD *thd, handlerton *table_type, const char *path,

                    const char *db, const char *alias, bool generate_warning)

{

  return TRUE;

}

/*

/** @brief

  Open database-handler.

  IMPLEMENTATION

    Try O_RDONLY if cannot open as O_RDWR

    Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set

*/

int handler::ha_open(TABLE *table_arg, const char *name, int mode,

                     int test_if_locked)

{

}

/*

/** @brief

  Read first row (only) from a table

  This is never called for InnoDB tables, as these table types

  has the HA_STATS_RECORDS_IS_EXACT set.

*/

int handler::read_first_row(byte * buf, uint primary_key)

{

  register int error;

  DBUG_RETURN(error);

}

/*

/** @brief

  Generate the next auto-increment number based on increment and offset:

  computes the lowest number

  - strictly greater than "nr"

  If increment=10 and offset=5 and previous number is 1, we get:

  1,5,15,25,35,...

*/

inline ulonglong

compute_next_insert_id(ulonglong nr,struct system_variables *variables)

{

}

/*

/** @brief

  Computes the largest number X:

  - smaller than or equal to "nr"

  - of the form: auto_increment_offset + N * auto_increment_increment

  RETURN

    The number X if it exists, "nr" otherwise.

*/

inline ulonglong

prev_insert_id(ulonglong nr, struct system_variables *variables)

{

}

/*

/** @brief

  MySQL signal that it changed the column bitmap

  USAGE

    rnd_init() call is made as after this, MySQL will not use the bitmap

    for any program logic checking.

*/

void handler::column_bitmaps_signal()

{

  DBUG_ENTER("column_bitmaps_signal");

}

/*

/** @brief

  Reserves an interval of auto_increment values from the handler.

  SYNOPSIS

  If the function sets *nb_reserved_values to ULONGLONG_MAX it means it has

  reserved to "positive infinite".

*/

void handler::get_auto_increment(ulonglong offset, ulonglong increment,

                                 ulonglong nb_desired_values,

                                 ulonglong *first_value,

}

/*

/** @brief

  Print error that we got from handler function

  NOTE

     table->s->path

     table->alias

*/

void handler::print_error(int error, myf errflag)

{

  DBUG_ENTER("handler::print_error");

}

/*

/** @brief

   Return an error message specific to this handler

   SYNOPSIS

   Returns true if this is a temporary error

*/

bool handler::get_error_message(int error, String* buf)

{

  return FALSE;

/* Return key if error because of duplicated keys */

/** @brief

  Return key if error because of duplicated keys */

uint handler::get_dup_key(int error)

{

  DBUG_ENTER("handler::get_dup_key");

}

/*

/** @brief

  Delete all files with extension from bas_ext()

  SYNOPSIS

	didn't get any other errors than ENOENT

    #   Error

*/

int handler::delete_table(const char *name)

{

  int error= 0;

}

/*

/** @brief

   Performs checks upon the table.

   SYNOPSIS

   HA_ADMIN_NEEDS_ALTER        Table has structures requiring ALTER TABLE

   HA_ADMIN_NOT_IMPLEMENTED

*/

int handler::ha_check(THD *thd, HA_CHECK_OPT *check_opt)

{

  int error;

}

/*

/** @brief

  Tell the storage engine that it is allowed to "disable transaction" in the

  handler. It is a hint that ACID is not required - it is used in NDB for

  ALTER TABLE, for example, when data are copied to temporary table.

  starts to commit every now and then automatically.

  This hint can be safely ignored.

*/

int ha_enable_transaction(THD *thd, bool on)

{

  int error=0;

** Some general functions that isn't in the handler class

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

/*

/** @brief

  Initiates table-file and calls appropriate database-creator

  NOTES

   0  ok

   1  error

*/

int ha_create_table(THD *thd, const char *path,

                    const char *db, const char *table_name,

                    HA_CREATE_INFO *create_info,

  DBUG_RETURN(error != 0);

}

/*

/** @brief

  Try to discover table from engine

  NOTES

   > 0  Error, table existed but could not be created

*/

int ha_create_table_from_engine(THD* thd, const char *db, const char *name)

{

  int error;

  call to ha_init_key_cache() (probably out of memory)

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

/* Init a key cache if it has not been initied before */

/** @brief

  Init a key cache if it has not been initied before

*/

int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)

{

  DBUG_ENTER("ha_init_key_cache");

}

/* Resize key cache */

/** @brief

  Resize key cache

*/

int ha_resize_key_cache(KEY_CACHE *key_cache)

{

  DBUG_ENTER("ha_resize_key_cache");

}

/* Change parameters for key cache (like size) */

/** @brief

  Change parameters for key cache (like size)

*/

int ha_change_key_cache_param(KEY_CACHE *key_cache)

{

  if (key_cache->key_cache_inited)

  return 0;

}

/* Free memory allocated by a key cache */

/** @brief

  Free memory allocated by a key cache

*/

int ha_end_key_cache(KEY_CACHE *key_cache)

{

  end_key_cache(key_cache, 1);		// Can never fail

  return 0;

}

/* Move all tables from one key cache to another one */

/** @brief

  Move all tables from one key cache to another one

*/

int ha_change_key_cache(KEY_CACHE *old_key_cache,

			KEY_CACHE *new_key_cache)

{

}

/*

/** @brief

  Try to discover one table from handler(s)

  RETURN

    0  : OK. In this case *frmblob and *frmlen are set

    >0 : error.  frmblob and frmlen may not be set

*/

struct st_discover_args

{

  const char *db;

}

/*

/** @brief

  Call this function in order to give the handler the possibility 

  to ask engine if there are any new tables that should be written to disk 

  or any dropped tables that need to be removed from disk

}

/*

/** @brief

  Ask handler if the table exists in engine

  RETURN

    #                   Error code

*/

struct st_table_exists_in_engine_args

{

  const char *db;

  void *arg;

};

/*

/** @brief

  Listing handlertons first to avoid recursive calls and deadlock

*/

static my_bool binlog_func_list(THD *thd, st_plugin_int *plugin, void *arg)

}

#endif

/*

/** @brief

  Read the first row of a multi-range set.

  SYNOPSIS

    HA_ERR_END_OF_FILE	No rows in range

    #			Error code

*/

int handler::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,

                                    KEY_MULTI_RANGE *ranges, uint range_count,

                                    bool sorted, HANDLER_BUFFER *buffer)

}

/*

/** @brief

  Read the next row of a multi-range set.

  SYNOPSIS

    HA_ERR_END_OF_FILE	No (more) rows in range

    #			Error code

*/

int handler::read_multi_range_next(KEY_MULTI_RANGE **found_range_p)

{

  int result;

}

/*

/** @brief

  Read first row between two ranges.

  Store ranges for future calls to read_range_next

    HA_ERR_END_OF_FILE	No rows in range

    #			Error code

*/

int handler::read_range_first(const key_range *start_key,

			      const key_range *end_key,

			      bool eq_range_arg, bool sorted)

}

/*

/** @brief

  Read next row between two ranges.

  SYNOPSIS

    HA_ERR_END_OF_FILE	No rows in range

    #			Error code

*/

int handler::read_range_next()

{

  int result;

}

/*

/** @brief

  Compare if found key (in row) is over max-value

  SYNOPSIS

   -1			Key is less than range

    1			Key is larger than range

*/

int handler::compare_key(key_range *range)

{

  int cmp;

}

/*

/** @brief

  Returns a list of all known extensions.

  SYNOPSIS

  RETURN VALUE

    pointer		pointer to TYPELIB structure

*/

static my_bool exts_handlerton(THD *unused, st_plugin_int *plugin,

                               void *arg)

{

  }

}

/*

/** @brief

   Write table maps for all (manually or automatically) locked tables

   to the binary log.

}

/*

/** @brief

  Check handler usage and reset state of file to after 'open'

*/

int handler::ha_reset()

{

  DBUG_ENTER("ha_reset");

/*

/** @brief

  use_hidden_primary_key() is called in case of an update/delete when

  (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined

  but we don't have a primary key

*/

void handler::use_hidden_primary_key()

{

  /* fallback to use all columns in the table to identify row */

}

/*

/** @brief

  Dummy function which accept information about log files which is not need

  by handlers

*/

void signal_log_not_needed(struct handlerton, char *log_file)

{

  DBUG_ENTER("signal_log_not_needed");

#define fl_dir FN_ROOTDIR

/*

/** @brief

  Dummy function to return log status should be replaced by function which

  really detect the log status and check that the file is a log of this

  handler.

*/

enum log_status fl_get_log_status(char *log)

{

  MY_STAT stat_buff;

}

/*

/** @brief

  returns buffer, to be assigned in handler_iterator struct

*/

enum handler_create_iterator_result