diff options
Diffstat (limited to 'storage/innobase/include/row0sel.h')
| -rw-r--r-- | storage/innobase/include/row0sel.h | 392 |
1 files changed, 0 insertions, 392 deletions
diff --git a/storage/innobase/include/row0sel.h b/storage/innobase/include/row0sel.h deleted file mode 100644 index a0a4ccb973b..00000000000 --- a/storage/innobase/include/row0sel.h +++ /dev/null @@ -1,392 +0,0 @@ -/****************************************************** -Select - -(c) 1997 Innobase Oy - -Created 12/19/1997 Heikki Tuuri -*******************************************************/ - -#ifndef row0sel_h -#define row0sel_h - -#include "univ.i" -#include "data0data.h" -#include "que0types.h" -#include "dict0types.h" -#include "trx0types.h" -#include "row0types.h" -#include "que0types.h" -#include "pars0sym.h" -#include "btr0pcur.h" -#include "read0read.h" -#include "row0mysql.h" - -/************************************************************************* -Creates a select node struct. */ - -sel_node_t* -sel_node_create( -/*============*/ - /* out, own: select node struct */ - mem_heap_t* heap); /* in: memory heap where created */ -/************************************************************************* -Frees the memory private to a select node when a query graph is freed, -does not free the heap where the node was originally created. */ - -void -sel_node_free_private( -/*==================*/ - sel_node_t* node); /* in: select node struct */ -/************************************************************************* -Frees a prefetch buffer for a column, including the dynamically allocated -memory for data stored there. */ - -void -sel_col_prefetch_buf_free( -/*======================*/ - sel_buf_t* prefetch_buf); /* in, own: prefetch buffer */ -/************************************************************************* -Gets the plan node for the nth table in a join. */ -UNIV_INLINE -plan_t* -sel_node_get_nth_plan( -/*==================*/ - sel_node_t* node, - ulint i); -/************************************************************************** -Performs a select step. This is a high-level function used in SQL execution -graphs. */ - -que_thr_t* -row_sel_step( -/*=========*/ - /* out: query thread to run next or NULL */ - que_thr_t* thr); /* in: query thread */ -/************************************************************************** -Performs an execution step of an open or close cursor statement node. */ -UNIV_INLINE -que_thr_t* -open_step( -/*======*/ - /* out: query thread to run next or NULL */ - que_thr_t* thr); /* in: query thread */ -/************************************************************************** -Performs a fetch for a cursor. */ - -que_thr_t* -fetch_step( -/*=======*/ - /* out: query thread to run next or NULL */ - que_thr_t* thr); /* in: query thread */ -/******************************************************************** -Sample callback function for fetch that prints each row.*/ - -void* -row_fetch_print( -/*============*/ - /* out: always returns non-NULL */ - void* row, /* in: sel_node_t* */ - void* user_arg); /* in: not used */ -/******************************************************************** -Callback function for fetch that stores an unsigned 4 byte integer to the -location pointed. The column's type must be DATA_INT, DATA_UNSIGNED, length -= 4. */ - -void* -row_fetch_store_uint4( -/*==================*/ - /* out: always returns NULL */ - void* row, /* in: sel_node_t* */ - void* user_arg); /* in: data pointer */ -/*************************************************************** -Prints a row in a select result. */ - -que_thr_t* -row_printf_step( -/*============*/ - /* out: query thread to run next or NULL */ - que_thr_t* thr); /* in: query thread */ -/******************************************************************** -Converts a key value stored in MySQL format to an Innobase dtuple. The last -field of the key value may be just a prefix of a fixed length field: hence -the parameter key_len. But currently we do not allow search keys where the -last field is only a prefix of the full key field len and print a warning if -such appears. */ - -void -row_sel_convert_mysql_key_to_innobase( -/*==================================*/ - dtuple_t* tuple, /* in: tuple where to build; - NOTE: we assume that the type info - in the tuple is already according - to index! */ - byte* buf, /* in: buffer to use in field - conversions */ - ulint buf_len, /* in: buffer length */ - dict_index_t* index, /* in: index of the key value */ - byte* key_ptr, /* in: MySQL key value */ - ulint key_len, /* in: MySQL key value length */ - trx_t* trx); /* in: transaction */ -/************************************************************************ -Searches for rows in the database. This is used in the interface to -MySQL. This function opens a cursor, and also implements fetch next -and fetch prev. NOTE that if we do a search with a full key value -from a unique index (ROW_SEL_EXACT), then we will not store the cursor -position and fetch next or fetch prev must not be tried to the cursor! */ - -ulint -row_search_for_mysql( -/*=================*/ - /* out: DB_SUCCESS, - DB_RECORD_NOT_FOUND, - DB_END_OF_INDEX, DB_DEADLOCK, - DB_LOCK_TABLE_FULL, - or DB_TOO_BIG_RECORD */ - byte* buf, /* in/out: buffer for the fetched - row in the MySQL format */ - ulint mode, /* in: search mode PAGE_CUR_L, ... */ - row_prebuilt_t* prebuilt, /* in: prebuilt struct for the - table handle; this contains the info - of search_tuple, index; if search - tuple contains 0 fields then we - position the cursor at the start or - the end of the index, depending on - 'mode' */ - ulint match_mode, /* in: 0 or ROW_SEL_EXACT or - ROW_SEL_EXACT_PREFIX */ - ulint direction); /* in: 0 or ROW_SEL_NEXT or - ROW_SEL_PREV; NOTE: if this is != 0, - then prebuilt must have a pcur - with stored position! In opening of a - cursor 'direction' should be 0. */ -/*********************************************************************** -Checks if MySQL at the moment is allowed for this table to retrieve a -consistent read result, or store it to the query cache. */ - -ibool -row_search_check_if_query_cache_permitted( -/*======================================*/ - /* out: TRUE if storing or retrieving - from the query cache is permitted */ - trx_t* trx, /* in: transaction object */ - const char* norm_name); /* in: concatenation of database name, - '/' char, table name */ -/*********************************************************************** -Read the max AUTOINC value from an index. */ - -ulint -row_search_max_autoinc( -/*===================*/ - /* out: DB_SUCCESS if all OK else - error code */ - dict_index_t* index, /* in: index to search */ - const char* col_name, /* in: autoinc column name */ - ib_ulonglong* value); /* out: AUTOINC value read */ - -/* A structure for caching column values for prefetched rows */ -struct sel_buf_struct{ - byte* data; /* data, or NULL; if not NULL, this field - has allocated memory which must be explicitly - freed; can be != NULL even when len is - UNIV_SQL_NULL */ - ulint len; /* data length or UNIV_SQL_NULL */ - ulint val_buf_size; - /* size of memory buffer allocated for data: - this can be more than len; this is defined - when data != NULL */ -}; - -struct plan_struct{ - dict_table_t* table; /* table struct in the dictionary - cache */ - dict_index_t* index; /* table index used in the search */ - btr_pcur_t pcur; /* persistent cursor used to search - the index */ - ibool asc; /* TRUE if cursor traveling upwards */ - ibool pcur_is_open; /* TRUE if pcur has been positioned - and we can try to fetch new rows */ - ibool cursor_at_end; /* TRUE if the cursor is open but - we know that there are no more - qualifying rows left to retrieve from - the index tree; NOTE though, that - there may still be unprocessed rows in - the prefetch stack; always FALSE when - pcur_is_open is FALSE */ - ibool stored_cursor_rec_processed; - /* TRUE if the pcur position has been - stored and the record it is positioned - on has already been processed */ - que_node_t** tuple_exps; /* array of expressions which are used - to calculate the field values in the - search tuple: there is one expression - for each field in the search tuple */ - dtuple_t* tuple; /* search tuple */ - ulint mode; /* search mode: PAGE_CUR_G, ... */ - ulint n_exact_match; /* number of first fields in the search - tuple which must be exactly matched */ - ibool unique_search; /* TRUE if we are searching an - index record with a unique key */ - ulint n_rows_fetched; /* number of rows fetched using pcur - after it was opened */ - ulint n_rows_prefetched;/* number of prefetched rows cached - for fetch: fetching several rows in - the same mtr saves CPU time */ - ulint first_prefetched;/* index of the first cached row in - select buffer arrays for each column */ - ibool no_prefetch; /* no prefetch for this table */ - sym_node_list_t columns; /* symbol table nodes for the columns - to retrieve from the table */ - UT_LIST_BASE_NODE_T(func_node_t) - end_conds; /* conditions which determine the - fetch limit of the index segment we - have to look at: when one of these - fails, the result set has been - exhausted for the cursor in this - index; these conditions are normalized - so that in a comparison the column - for this table is the first argument */ - UT_LIST_BASE_NODE_T(func_node_t) - other_conds; /* the rest of search conditions we can - test at this table in a join */ - ibool must_get_clust; /* TRUE if index is a non-clustered - index and we must also fetch the - clustered index record; this is the - case if the non-clustered record does - not contain all the needed columns, or - if this is a single-table explicit - cursor, or a searched update or - delete */ - ulint* clust_map; /* map telling how clust_ref is built - from the fields of a non-clustered - record */ - dtuple_t* clust_ref; /* the reference to the clustered - index entry is built here if index is - a non-clustered index */ - btr_pcur_t clust_pcur; /* if index is non-clustered, we use - this pcur to search the clustered - index */ - mem_heap_t* old_vers_heap; /* memory heap used in building an old - version of a row, or NULL */ -}; - -struct sel_node_struct{ - que_common_t common; /* node type: QUE_NODE_SELECT */ - ulint state; /* node state */ - que_node_t* select_list; /* select list */ - sym_node_t* into_list; /* variables list or NULL */ - sym_node_t* table_list; /* table list */ - ibool asc; /* TRUE if the rows should be fetched - in an ascending order */ - ibool set_x_locks; /* TRUE if the cursor is for update or - delete, which means that a row x-lock - should be placed on the cursor row */ - ibool select_will_do_update; - /* TRUE if the select is for a searched - update which can be performed in-place: - in this case the select will take care - of the update */ - ulint latch_mode; /* BTR_SEARCH_LEAF, or BTR_MODIFY_LEAF - if select_will_do_update is TRUE */ - ulint row_lock_mode; /* LOCK_X or LOCK_S */ - ulint n_tables; /* number of tables */ - ulint fetch_table; /* number of the next table to access - in the join */ - plan_t* plans; /* array of n_tables many plan nodes - containing the search plan and the - search data structures */ - que_node_t* search_cond; /* search condition */ - read_view_t* read_view; /* if the query is a non-locking - consistent read, its read view is - placed here, otherwise NULL */ - ibool consistent_read;/* TRUE if the select is a consistent, - non-locking read */ - order_node_t* order_by; /* order by column definition, or - NULL */ - ibool is_aggregate; /* TRUE if the select list consists of - aggregate functions */ - ibool aggregate_already_fetched; - /* TRUE if the aggregate row has - already been fetched for the current - cursor */ - ibool can_get_updated;/* this is TRUE if the select - is in a single-table explicit - cursor which can get updated - within the stored procedure, - or in a searched update or - delete; NOTE that to determine - of an explicit cursor if it - can get updated, the parser - checks from a stored procedure - if it contains positioned - update or delete statements */ - sym_node_t* explicit_cursor;/* not NULL if an explicit cursor */ - UT_LIST_BASE_NODE_T(sym_node_t) - copy_variables; /* variables whose values we have to - copy when an explicit cursor is opened, - so that they do not change between - fetches */ -}; - -/* Select node states */ -#define SEL_NODE_CLOSED 0 /* it is a declared cursor which is not - currently open */ -#define SEL_NODE_OPEN 1 /* intention locks not yet set on - tables */ -#define SEL_NODE_FETCH 2 /* intention locks have been set */ -#define SEL_NODE_NO_MORE_ROWS 3 /* cursor has reached the result set - end */ - -/* Fetch statement node */ -struct fetch_node_struct{ - que_common_t common; /* type: QUE_NODE_FETCH */ - sel_node_t* cursor_def; /* cursor definition */ - sym_node_t* into_list; /* variables to set */ - - pars_user_func_t* - func; /* User callback function or NULL. - The first argument to the function - is a sel_node_t*, containing the - results of the SELECT operation for - one row. If the function returns - NULL, it is not interested in - further rows and the cursor is - modified so (cursor % NOTFOUND) is - true. If it returns not-NULL, - continue normally. See - row_fetch_print() for an example - (and a useful debugging tool). */ -}; - -/* Open or close cursor statement node */ -struct open_node_struct{ - que_common_t common; /* type: QUE_NODE_OPEN */ - ulint op_type; /* ROW_SEL_OPEN_CURSOR or - ROW_SEL_CLOSE_CURSOR */ - sel_node_t* cursor_def; /* cursor definition */ -}; - -/* Row printf statement node */ -struct row_printf_node_struct{ - que_common_t common; /* type: QUE_NODE_ROW_PRINTF */ - sel_node_t* sel_node; /* select */ -}; - -#define ROW_SEL_OPEN_CURSOR 0 -#define ROW_SEL_CLOSE_CURSOR 1 - -/* Flags for the MySQL interface */ -#define ROW_SEL_NEXT 1 -#define ROW_SEL_PREV 2 - -#define ROW_SEL_EXACT 1 /* search using a complete key value */ -#define ROW_SEL_EXACT_PREFIX 2 /* search using a key prefix which - must match to rows: the prefix may - contain an incomplete field (the - last field in prefix may be just - a prefix of a fixed length column) */ - -#ifndef UNIV_NONINL -#include "row0sel.ic" -#endif - -#endif |