Consistently use doxygen comments in class handler.
This commit is contained in:
unknown
parent
7213ca204d
commit
a7405ca4f2
206
sql/handler.h
206
sql/handler.h
@ -959,11 +959,11 @@ uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map);
|
||||
*/
|
||||
#define make_prev_keypart_map(N) (((key_part_map)1 << (N)) - 1)
|
||||
|
||||
/*
|
||||
/**
|
||||
The handler class is the interface for dynamically loadable
|
||||
storage engines. Do not add ifdefs and take care when adding or
|
||||
changing virtual functions to avoid vtable confusion
|
||||
*/
|
||||
*/
|
||||
|
||||
class handler :public Sql_alloc
|
||||
{
|
||||
@ -981,7 +981,7 @@ public:
|
||||
|
||||
virtual int index_init(uint idx, bool sorted) { active_index=idx; return 0; }
|
||||
virtual int index_end() { active_index=MAX_KEY; return 0; }
|
||||
/*
|
||||
/**
|
||||
rnd_init() can be called two times without rnd_end() in between
|
||||
(it only makes sense if scan=1).
|
||||
then the second call should prepare for the new table scan (e.g
|
||||
@ -1006,13 +1006,13 @@ public:
|
||||
|
||||
ha_statistics stats;
|
||||
|
||||
/* The following are for read_multi_range */
|
||||
/** The following are for read_multi_range */
|
||||
bool multi_range_sorted;
|
||||
KEY_MULTI_RANGE *multi_range_curr;
|
||||
KEY_MULTI_RANGE *multi_range_end;
|
||||
HANDLER_BUFFER *multi_range_buffer;
|
||||
|
||||
/* The following are for read_range() */
|
||||
/** The following are for read_range() */
|
||||
key_range save_end_range, *end_range;
|
||||
KEY_PART_INFO *range_key_part;
|
||||
int key_compare_result_on_equal;
|
||||
@ -1021,14 +1021,14 @@ public:
|
||||
uint errkey; /* Last dup key */
|
||||
uint key_used_on_scan;
|
||||
uint active_index;
|
||||
/* Length of ref (1-8 or the clustered key length) */
|
||||
/** Length of ref (1-8 or the clustered key length) */
|
||||
uint ref_length;
|
||||
FT_INFO *ft_handler;
|
||||
enum {NONE=0, INDEX, RND} inited;
|
||||
bool locked;
|
||||
bool implicit_emptied; /* Can be !=0 only if HEAP */
|
||||
const COND *pushed_cond;
|
||||
/*
|
||||
/**
|
||||
next_insert_id is the next value which should be inserted into the
|
||||
auto_increment column: in a inserting-multi-row statement (like INSERT
|
||||
SELECT), for the first row where the autoinc value is not specified by the
|
||||
@ -1038,14 +1038,14 @@ public:
|
||||
get_auto_increment().
|
||||
*/
|
||||
ulonglong next_insert_id;
|
||||
/*
|
||||
/**
|
||||
insert id for the current row (*autogenerated*; if not
|
||||
autogenerated, it's 0).
|
||||
At first successful insertion, this variable is stored into
|
||||
THD::first_successful_insert_id_in_cur_stmt.
|
||||
*/
|
||||
ulonglong insert_id_for_cur_row;
|
||||
/*
|
||||
/**
|
||||
Interval returned by get_auto_increment() and being consumed by the
|
||||
inserter.
|
||||
*/
|
||||
@ -1066,7 +1066,7 @@ public:
|
||||
/* TODO: DBUG_ASSERT(inited == NONE); */
|
||||
}
|
||||
virtual handler *clone(MEM_ROOT *mem_root);
|
||||
/* This is called after create to allow us to set up cached variables */
|
||||
/** This is called after create to allow us to set up cached variables */
|
||||
void init()
|
||||
{
|
||||
cached_table_flags= table_flags();
|
||||
@ -1092,7 +1092,7 @@ public:
|
||||
{ return (ha_table_flags() & HA_NO_TRANSACTIONS) == 0; }
|
||||
virtual uint extra_rec_buf_length() const { return 0; }
|
||||
|
||||
/*
|
||||
/**
|
||||
This method is used to analyse the error to see whether the error
|
||||
is ignorable or not, certain handlers can have more error that are
|
||||
ignorable than others. E.g. the partition handler can get inserts
|
||||
@ -1112,12 +1112,12 @@ public:
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
Number of rows in table. It will only be called if
|
||||
(table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
|
||||
*/
|
||||
virtual ha_rows records() { return stats.records; }
|
||||
/*
|
||||
/**
|
||||
Return upper bound of current number of records in the table
|
||||
(max. of how many records one will retrieve when doing a full table scan)
|
||||
If upper bound is not known, HA_POS_ERROR should be returned as a max
|
||||
@ -1126,7 +1126,7 @@ public:
|
||||
virtual ha_rows estimate_rows_upper_bound()
|
||||
{ return stats.records+EXTRA_RECORDS; }
|
||||
|
||||
/*
|
||||
/**
|
||||
Get the row type from the storage engine. If this method returns
|
||||
ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.
|
||||
*/
|
||||
@ -1174,7 +1174,7 @@ public:
|
||||
}
|
||||
Table_flags ha_table_flags() const { return cached_table_flags; }
|
||||
|
||||
/*
|
||||
/**
|
||||
Signal that the table->read_set and table->write_set table maps changed
|
||||
The handler is allowed to set additional bits in the above map in this
|
||||
call. Normally the handler should ignore all calls until we have done
|
||||
@ -1186,7 +1186,7 @@ public:
|
||||
virtual int open(const char *name, int mode, uint test_if_locked)=0;
|
||||
virtual int close(void)=0;
|
||||
|
||||
/*
|
||||
/**
|
||||
These functions represent the public interface to *users* of the
|
||||
handler class, hence they are *not* virtual. For the inheritance
|
||||
interface, see the (private) functions write_row(), update_row(),
|
||||
@ -1197,36 +1197,28 @@ public:
|
||||
int ha_update_row(const uchar * old_data, uchar * new_data);
|
||||
int ha_delete_row(const uchar * buf);
|
||||
|
||||
/*
|
||||
SYNOPSIS
|
||||
start_bulk_update()
|
||||
RETURN
|
||||
0 Bulk update used by handler
|
||||
1 Bulk update not used, normal operation used
|
||||
/**
|
||||
@retval 0 Bulk update used by handler
|
||||
@retval 1 Bulk update not used, normal operation used
|
||||
*/
|
||||
virtual bool start_bulk_update() { return 1; }
|
||||
/*
|
||||
SYNOPSIS
|
||||
start_bulk_delete()
|
||||
RETURN
|
||||
0 Bulk delete used by handler
|
||||
1 Bulk delete not used, normal operation used
|
||||
/**
|
||||
@retval 0 Bulk delete used by handler
|
||||
@retval 1 Bulk delete not used, normal operation used
|
||||
*/
|
||||
virtual bool start_bulk_delete() { return 1; }
|
||||
/*
|
||||
SYNOPSIS
|
||||
/**
|
||||
This method is similar to update_row, however the handler doesn't need
|
||||
to execute the updates at this point in time. The handler can be certain
|
||||
that another call to bulk_update_row will occur OR a call to
|
||||
exec_bulk_update before the set of updates in this query is concluded.
|
||||
|
||||
bulk_update_row()
|
||||
old_data Old record
|
||||
new_data New record
|
||||
dup_key_found Number of duplicate keys found
|
||||
RETURN
|
||||
0 Bulk delete used by handler
|
||||
1 Bulk delete not used, normal operation used
|
||||
@param old_data Old record
|
||||
@param new_data New record
|
||||
@param dup_key_found Number of duplicate keys found
|
||||
|
||||
@retval 0 Bulk delete used by handler
|
||||
@retval 1 Bulk delete not used, normal operation used
|
||||
*/
|
||||
virtual int bulk_update_row(const uchar *old_data, uchar *new_data,
|
||||
uint *dup_key_found)
|
||||
@ -1234,53 +1226,43 @@ public:
|
||||
DBUG_ASSERT(FALSE);
|
||||
return HA_ERR_WRONG_COMMAND;
|
||||
}
|
||||
/*
|
||||
SYNOPSIS
|
||||
/**
|
||||
After this call all outstanding updates must be performed. The number
|
||||
of duplicate key errors are reported in the duplicate key parameter.
|
||||
It is allowed to continue to the batched update after this call, the
|
||||
handler has to wait until end_bulk_update with changing state.
|
||||
|
||||
exec_bulk_update()
|
||||
dup_key_found Number of duplicate keys found
|
||||
RETURN
|
||||
0 Success
|
||||
>0 Error code
|
||||
@param dup_key_found Number of duplicate keys found
|
||||
|
||||
@retval 0 Success
|
||||
@retval >0 Error code
|
||||
*/
|
||||
virtual int exec_bulk_update(uint *dup_key_found)
|
||||
{
|
||||
DBUG_ASSERT(FALSE);
|
||||
return HA_ERR_WRONG_COMMAND;
|
||||
}
|
||||
/*
|
||||
SYNOPSIS
|
||||
/**
|
||||
Perform any needed clean-up, no outstanding updates are there at the
|
||||
moment.
|
||||
|
||||
end_bulk_update()
|
||||
RETURN
|
||||
Nothing
|
||||
*/
|
||||
virtual void end_bulk_update() { return; }
|
||||
/*
|
||||
SYNOPSIS
|
||||
/**
|
||||
Execute all outstanding deletes and close down the bulk delete.
|
||||
|
||||
end_bulk_delete()
|
||||
RETURN
|
||||
0 Success
|
||||
>0 Error code
|
||||
@retval 0 Success
|
||||
@retval >0 Error code
|
||||
*/
|
||||
virtual int end_bulk_delete()
|
||||
{
|
||||
DBUG_ASSERT(FALSE);
|
||||
return HA_ERR_WRONG_COMMAND;
|
||||
}
|
||||
private:
|
||||
private:
|
||||
virtual int index_read(uchar * buf, const uchar * key, uint key_len,
|
||||
enum ha_rkey_function find_flag)
|
||||
{ return HA_ERR_WRONG_COMMAND; }
|
||||
public:
|
||||
public:
|
||||
/**
|
||||
@brief
|
||||
Positions an index cursor to the index specified in the handle. Fetches the
|
||||
@ -1315,7 +1297,7 @@ public:
|
||||
private:
|
||||
virtual int index_read_last(uchar * buf, const uchar * key, uint key_len)
|
||||
{ return (my_errno=HA_ERR_WRONG_COMMAND); }
|
||||
public:
|
||||
public:
|
||||
/**
|
||||
@brief
|
||||
The following functions works like index_read, but it find the last
|
||||
@ -1343,11 +1325,11 @@ public:
|
||||
virtual int ft_read(uchar *buf) { return HA_ERR_WRONG_COMMAND; }
|
||||
virtual int rnd_next(uchar *buf)=0;
|
||||
virtual int rnd_pos(uchar * buf, uchar *pos)=0;
|
||||
/*
|
||||
one has to use this method when to find
|
||||
/**
|
||||
One has to use this method when to find
|
||||
random position by record as the plain
|
||||
position() call doesn't work for some
|
||||
handlers for random position
|
||||
handlers for random position.
|
||||
*/
|
||||
virtual int rnd_pos_by_record(uchar *record)
|
||||
{
|
||||
@ -1355,9 +1337,9 @@ public:
|
||||
return rnd_pos(record, ref);
|
||||
}
|
||||
virtual int read_first_row(uchar *buf, uint primary_key);
|
||||
/*
|
||||
/**
|
||||
The following function is only needed for tables that may be temporary
|
||||
tables during joins
|
||||
tables during joins.
|
||||
*/
|
||||
virtual int restart_rnd_next(uchar *buf, uchar *pos)
|
||||
{ return HA_ERR_WRONG_COMMAND; }
|
||||
@ -1374,13 +1356,13 @@ public:
|
||||
virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
|
||||
{ return extra(operation); }
|
||||
|
||||
/*
|
||||
Reset state of file to after 'open'
|
||||
/**
|
||||
Reset state of file to after 'open'.
|
||||
This function is called after every statement for all tables used
|
||||
by that statement.
|
||||
*/
|
||||
virtual int reset() { return 0; }
|
||||
/*
|
||||
/**
|
||||
In an UPDATE or DELETE, if the row under the cursor was locked by another
|
||||
transaction, and the engine used an optimistic read of the last
|
||||
committed row value under the cursor, then the engine returns 1 from this
|
||||
@ -1393,7 +1375,7 @@ public:
|
||||
engine that the next read will be a locking re-read of the row.
|
||||
*/
|
||||
virtual bool was_semi_consistent_read() { return 0; }
|
||||
/*
|
||||
/**
|
||||
Tell the engine whether it should avoid unnecessary lock waits.
|
||||
If yes, in an UPDATE or DELETE, if the row under the cursor was locked
|
||||
by another transaction, the engine may try an optimistic read of
|
||||
@ -1402,7 +1384,7 @@ public:
|
||||
virtual void try_semi_consistent_read(bool) {}
|
||||
virtual void unlock_row() {}
|
||||
virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
|
||||
/*
|
||||
/**
|
||||
This is called to delete all rows in a table
|
||||
If the handler don't support this, then this function will
|
||||
return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
|
||||
@ -1438,7 +1420,7 @@ public:
|
||||
next_insert_id= (prev_insert_id > 0) ? prev_insert_id :
|
||||
insert_id_for_cur_row;
|
||||
}
|
||||
/*
|
||||
/**
|
||||
Reset the auto-increment counter to the given value, i.e. the next row
|
||||
inserted will get the given value. This is called e.g. after TRUNCATE
|
||||
is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
|
||||
@ -1451,27 +1433,27 @@ public:
|
||||
protected:
|
||||
/* to be implemented in handlers */
|
||||
|
||||
/* admin commands - called from mysql_admin_table */
|
||||
/** admin commands - called from mysql_admin_table */
|
||||
virtual int check(THD* thd, HA_CHECK_OPT* check_opt)
|
||||
{ return HA_ADMIN_NOT_IMPLEMENTED; }
|
||||
|
||||
/*
|
||||
in these two methods check_opt can be modified
|
||||
/**
|
||||
In these two methods check_opt can be modified
|
||||
to specify CHECK option to use to call check()
|
||||
upon the table
|
||||
upon the table.
|
||||
*/
|
||||
virtual int check_for_upgrade(HA_CHECK_OPT *check_opt)
|
||||
{ return 0; }
|
||||
public:
|
||||
int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
|
||||
int check_old_types();
|
||||
/* to be actually called to get 'check()' functionality*/
|
||||
/** to be actually called to get 'check()' functionality*/
|
||||
int ha_check(THD *thd, HA_CHECK_OPT *check_opt);
|
||||
|
||||
|
||||
virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
|
||||
{ return HA_ADMIN_NOT_IMPLEMENTED; }
|
||||
/*
|
||||
restore assumes .frm file must exist, and that generate_table() has been
|
||||
/**
|
||||
Restore assumes .frm file must exist, and that generate_table() has been
|
||||
called; It will just copy the data file and run repair.
|
||||
*/
|
||||
virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
|
||||
@ -1512,17 +1494,15 @@ public:
|
||||
virtual char *update_table_comment(const char * comment)
|
||||
{ return (char*) comment;}
|
||||
virtual void append_create_info(String *packet) {}
|
||||
/*
|
||||
SYNOPSIS
|
||||
is_fk_defined_on_table_or_index()
|
||||
index Index to check if foreign key uses it
|
||||
RETURN VALUE
|
||||
TRUE Foreign key defined on table or index
|
||||
FALSE No foreign key defined
|
||||
DESCRIPTION
|
||||
If index == MAX_KEY then a check for table is made and if index <
|
||||
MAX_KEY then a check is made if the table has foreign keys and if
|
||||
a foreign key uses this index (and thus the index cannot be dropped).
|
||||
/**
|
||||
If index == MAX_KEY then a check for table is made and if index <
|
||||
MAX_KEY then a check is made if the table has foreign keys and if
|
||||
a foreign key uses this index (and thus the index cannot be dropped).
|
||||
|
||||
@param index Index to check if foreign key uses it
|
||||
|
||||
@retval TRUE Foreign key defined on table or index
|
||||
@retval FALSE No foreign key defined
|
||||
*/
|
||||
virtual bool is_fk_defined_on_table_or_index(uint index)
|
||||
{ return FALSE; }
|
||||
@ -1530,18 +1510,18 @@ public:
|
||||
{ return(NULL);} /* gets foreign key create string from InnoDB */
|
||||
virtual char* get_tablespace_name(THD *thd, char *name, uint name_len)
|
||||
{ return(NULL);} /* gets tablespace name from handler */
|
||||
/* used in ALTER TABLE; 1 if changing storage engine is allowed */
|
||||
/** used in ALTER TABLE; 1 if changing storage engine is allowed */
|
||||
virtual bool can_switch_engines() { return 1; }
|
||||
/* used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
|
||||
/** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
|
||||
virtual int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list)
|
||||
{ return 0; }
|
||||
virtual uint referenced_by_foreign_key() { return 0;}
|
||||
virtual void init_table_handle_for_HANDLER()
|
||||
{ return; } /* prepare InnoDB for HANDLER */
|
||||
virtual void free_foreign_key_create_info(char* str) {}
|
||||
/* The following can be called without an open handler */
|
||||
/** The following can be called without an open handler */
|
||||
virtual const char *table_type() const =0;
|
||||
/*
|
||||
/**
|
||||
If frm_error() is called then we will use this to find out what file
|
||||
extentions exist for the storage engine. This is also used by the default
|
||||
rename_table and delete_table method in handler.cc.
|
||||
@ -1598,14 +1578,14 @@ public:
|
||||
virtual bool is_crashed() const { return 0; }
|
||||
virtual bool auto_repair() const { return 0; }
|
||||
|
||||
/*
|
||||
/**
|
||||
default rename_table() and delete_table() rename/delete files with a
|
||||
given name and extensions from bas_ext()
|
||||
*/
|
||||
virtual int rename_table(const char *from, const char *to);
|
||||
virtual int delete_table(const char *name);
|
||||
virtual void drop_table(const char *name);
|
||||
|
||||
|
||||
virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
|
||||
|
||||
#define CHF_CREATE_FLAG 0
|
||||
@ -1658,7 +1638,7 @@ public:
|
||||
THR_LOCK_DATA **to,
|
||||
enum thr_lock_type lock_type)=0;
|
||||
|
||||
/* Type of table for caching query */
|
||||
/** Type of table for caching query */
|
||||
virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
|
||||
|
||||
|
||||
@ -1704,56 +1684,54 @@ public:
|
||||
|
||||
|
||||
/*
|
||||
RETURN
|
||||
true Primary key (if there is one) is clustered key covering all fields
|
||||
false otherwise
|
||||
@retval TRUE Primary key (if there is one) is clustered
|
||||
key covering all fields
|
||||
@retval FALSE otherwise
|
||||
*/
|
||||
virtual bool primary_key_is_clustered() { return FALSE; }
|
||||
virtual int cmp_ref(const uchar *ref1, const uchar *ref2)
|
||||
{
|
||||
return memcmp(ref1, ref2, ref_length);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
Condition pushdown to storage engines
|
||||
*/
|
||||
|
||||
/*
|
||||
/**
|
||||
Push condition down to the table handler.
|
||||
SYNOPSIS
|
||||
cond_push()
|
||||
cond Condition to be pushed. The condition tree must not be
|
||||
modified by the by the caller.
|
||||
|
||||
RETURN
|
||||
@param cond Condition to be pushed. The condition tree must not be
|
||||
modified by the by the caller.
|
||||
|
||||
@return
|
||||
The 'remainder' condition that caller must use to filter out records.
|
||||
NULL means the handler will not return rows that do not match the
|
||||
passed condition.
|
||||
|
||||
NOTES
|
||||
@note
|
||||
The pushed conditions form a stack (from which one can remove the
|
||||
last pushed condition using cond_pop).
|
||||
The table handler filters out rows using (pushed_cond1 AND pushed_cond2
|
||||
AND ... AND pushed_condN)
|
||||
or less restrictive condition, depending on handler's capabilities.
|
||||
|
||||
|
||||
handler->ha_reset() call empties the condition stack.
|
||||
Calls to rnd_init/rnd_end, index_init/index_end etc do not affect the
|
||||
condition stack.
|
||||
*/
|
||||
virtual const COND *cond_push(const COND *cond) { return cond; };
|
||||
/*
|
||||
/**
|
||||
Pop the top condition from the condition stack of the handler instance.
|
||||
SYNOPSIS
|
||||
cond_pop()
|
||||
Pops the top if condition stack, if stack is not empty
|
||||
|
||||
Pops the top if condition stack, if stack is not empty.
|
||||
*/
|
||||
virtual void cond_pop() { return; };
|
||||
virtual bool check_if_incompatible_data(HA_CREATE_INFO *create_info,
|
||||
uint table_changes)
|
||||
{ return COMPATIBLE_DATA_NO; }
|
||||
|
||||
/* These are only called from sql_select for internal temporary tables */
|
||||
/** These are only called from sql_select for internal temporary tables */
|
||||
virtual int write_row(uchar *buf __attribute__((unused)))
|
||||
{
|
||||
return HA_ERR_WRONG_COMMAND;
|
||||
@ -1769,7 +1747,7 @@ public:
|
||||
{
|
||||
return HA_ERR_WRONG_COMMAND;
|
||||
}
|
||||
/*
|
||||
/**
|
||||
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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user