row0sel.h
上传用户:tsgydb
上传日期:2007-04-14
资源大小:10674k
文件大小:12k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Select
  3. (c) 1997 Innobase Oy
  4. Created 12/19/1997 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef row0sel_h
  7. #define row0sel_h
  8. #include "univ.i"
  9. #include "data0data.h"
  10. #include "que0types.h"
  11. #include "dict0types.h"
  12. #include "trx0types.h"
  13. #include "row0types.h"
  14. #include "que0types.h"
  15. #include "pars0sym.h"
  16. #include "btr0pcur.h"
  17. #include "read0read.h"
  18. #include "row0mysql.h"
  19. /*************************************************************************
  20. Creates a select node struct. */
  21. sel_node_t*
  22. sel_node_create(
  23. /*============*/
  24. /* out, own: select node struct */
  25. mem_heap_t* heap); /* in: memory heap where created */
  26. /*************************************************************************
  27. Frees the memory private to a select node when a query graph is freed,
  28. does not free the heap where the node was originally created. */
  29. void
  30. sel_node_free_private(
  31. /*==================*/
  32. sel_node_t* node); /* in: select node struct */
  33. /*************************************************************************
  34. Frees a prefetch buffer for a column, including the dynamically allocated
  35. memory for data stored there. */
  36. void
  37. sel_col_prefetch_buf_free(
  38. /*======================*/
  39. sel_buf_t* prefetch_buf); /* in, own: prefetch buffer */
  40. /*************************************************************************
  41. Gets the plan node for the nth table in a join. */
  42. UNIV_INLINE
  43. plan_t*
  44. sel_node_get_nth_plan(
  45. /*==================*/
  46. sel_node_t* node,
  47. ulint i);
  48. /**************************************************************************
  49. Performs a select step. This is a high-level function used in SQL execution
  50. graphs. */
  51. que_thr_t*
  52. row_sel_step(
  53. /*=========*/
  54. /* out: query thread to run next or NULL */
  55. que_thr_t* thr); /* in: query thread */
  56. /**************************************************************************
  57. Performs an execution step of an open or close cursor statement node. */
  58. UNIV_INLINE
  59. que_thr_t*
  60. open_step(
  61. /*======*/
  62. /* out: query thread to run next or NULL */
  63. que_thr_t* thr); /* in: query thread */
  64. /**************************************************************************
  65. Performs a fetch for a cursor. */
  66. que_thr_t*
  67. fetch_step(
  68. /*=======*/
  69. /* out: query thread to run next or NULL */
  70. que_thr_t* thr); /* in: query thread */
  71. /***************************************************************
  72. Prints a row in a select result. */
  73. que_thr_t*
  74. row_printf_step(
  75. /*============*/
  76. /* out: query thread to run next or NULL */
  77. que_thr_t* thr); /* in: query thread */
  78. /********************************************************************
  79. Converts a key value stored in MySQL format to an Innobase dtuple.
  80. The last field of the key value may be just a prefix of a fixed length
  81. field: hence the parameter key_len. */
  82. void
  83. row_sel_convert_mysql_key_to_innobase(
  84. /*==================================*/
  85. dtuple_t* tuple, /* in: tuple where to build;
  86. NOTE: we assume that the type info
  87. in the tuple is already according
  88. to index! */
  89. byte* buf, /* in: buffer to use in field
  90. conversions */
  91. dict_index_t* index, /* in: index of the key value */
  92. byte* key_ptr, /* in: MySQL key value */
  93. ulint key_len); /* in: MySQL key value length */
  94. /************************************************************************
  95. Searches for rows in the database. This is used in the interface to
  96. MySQL. This function opens a cursor, and also implements fetch next
  97. and fetch prev. NOTE that if we do a search with a full key value
  98. from a unique index (ROW_SEL_EXACT), then we will not store the cursor
  99. position and fetch next or fetch prev must not be tried to the cursor! */
  100. ulint
  101. row_search_for_mysql(
  102. /*=================*/
  103. /* out: DB_SUCCESS,
  104. DB_RECORD_NOT_FOUND, 
  105. DB_END_OF_INDEX, or DB_DEADLOCK */
  106. byte* buf, /* in/out: buffer for the fetched
  107. row in the MySQL format */
  108. ulint mode, /* in: search mode PAGE_CUR_L, ... */
  109. row_prebuilt_t* prebuilt, /* in: prebuilt struct for the
  110. table handle; this contains the info
  111. of search_tuple, index; if search
  112. tuple contains 0 fields then we
  113. position the cursor at the start or
  114. the end of the index, depending on
  115. 'mode' */
  116. ulint match_mode, /* in: 0 or ROW_SEL_EXACT or
  117. ROW_SEL_EXACT_PREFIX */ 
  118. ulint direction); /* in: 0 or ROW_SEL_NEXT or
  119. ROW_SEL_PREV; NOTE: if this is != 0,
  120. then prebuilt must have a pcur
  121. with stored position! In opening of a
  122. cursor 'direction' should be 0. */
  123. /* A structure for caching column values for prefetched rows */
  124. struct sel_buf_struct{
  125. byte* data; /* data, or NULL; if not NULL, this field
  126. has allocated memory which must be explicitly
  127. freed; can be != NULL even when len is
  128. UNIV_SQL_NULL */
  129. ulint len; /* data length or UNIV_SQL_NULL */
  130. ulint val_buf_size;
  131. /* size of memory buffer allocated for data:
  132. this can be more than len; this is defined
  133. when data != NULL */
  134. };
  135. struct plan_struct{
  136. dict_table_t* table; /* table struct in the dictionary
  137. cache */
  138. dict_index_t* index; /* table index used in the search */
  139. btr_pcur_t pcur; /* persistent cursor used to search
  140. the index */
  141. ibool asc; /* TRUE if cursor traveling upwards */
  142. ibool pcur_is_open; /* TRUE if pcur has been positioned
  143. and we can try to fetch new rows */
  144. ibool cursor_at_end; /* TRUE if the cursor is open but
  145. we know that there are no more
  146. qualifying rows left to retrieve from
  147. the index tree; NOTE though, that
  148. there may still be unprocessed rows in
  149. the prefetch stack; always FALSE when
  150. pcur_is_open is FALSE */
  151. ibool stored_cursor_rec_processed;
  152. /* TRUE if the pcur position has been
  153. stored and the record it is positioned
  154. on has already been processed */
  155. que_node_t** tuple_exps; /* array of expressions which are used
  156. to calculate the field values in the
  157. search tuple: there is one expression
  158. for each field in the search tuple */
  159. dtuple_t* tuple; /* search tuple */
  160. ulint mode; /* search mode: PAGE_CUR_G, ... */
  161. ulint n_exact_match; /* number of first fields in the search
  162. tuple which must be exactly matched */
  163. ibool unique_search; /* TRUE if we are searching an
  164. index record with a unique key */
  165. ulint n_rows_fetched; /* number of rows fetched using pcur
  166. after it was opened */
  167. ulint n_rows_prefetched;/* number of prefetched rows cached
  168. for fetch: fetching several rows in
  169. the same mtr saves CPU time */
  170. ulint first_prefetched;/* index of the first cached row in
  171. select buffer arrays for each column */
  172. ibool no_prefetch; /* no prefetch for this table */
  173. ibool mixed_index; /* TRUE if index is a clustered index
  174. in a mixed cluster */
  175. sym_node_list_t columns; /* symbol table nodes for the columns
  176. to retrieve from the table */
  177. UT_LIST_BASE_NODE_T(func_node_t)
  178. end_conds; /* conditions which determine the
  179. fetch limit of the index segment we
  180. have to look at: when one of these
  181. fails, the result set has been
  182. exhausted for the cursor in this
  183. index; these conditions are normalized
  184. so that in a comparison the column
  185. for this table is the first argument */
  186. UT_LIST_BASE_NODE_T(func_node_t)
  187. other_conds; /* the rest of search conditions we can
  188. test at this table in a join */
  189. ibool must_get_clust; /* TRUE if index is a non-clustered
  190. index and we must also fetch the
  191. clustered index record; this is the
  192. case if the non-clustered record does
  193. not contain all the needed columns, or
  194. if this is a single-table explicit
  195. cursor, or a searched update or
  196. delete */
  197. ulint* clust_map; /* map telling how clust_ref is built
  198. from the fields of a non-clustered
  199. record */
  200. dtuple_t* clust_ref; /* the reference to the clustered
  201. index entry is built here if index is
  202. a non-clustered index */
  203. btr_pcur_t clust_pcur; /* if index is non-clustered, we use
  204. this pcur to search the clustered
  205. index */
  206. mem_heap_t* old_vers_heap; /* memory heap used in building an old
  207. version of a row, or NULL */
  208. };
  209. struct sel_node_struct{
  210. que_common_t common; /* node type: QUE_NODE_SELECT */
  211. ulint state; /* node state */
  212. que_node_t* select_list; /* select list */
  213. sym_node_t* into_list; /* variables list or NULL */
  214. sym_node_t* table_list; /* table list */
  215. ibool asc; /* TRUE if the rows should be fetched
  216. in an ascending order */
  217. ibool set_x_locks; /* TRUE if the cursor is for update or
  218. delete, which means that a row x-lock
  219. should be placed on the cursor row */
  220. ibool select_will_do_update;
  221. /* TRUE if the select is for a searched
  222. update which can be performed in-place:
  223. in this case the select will take care
  224. of the update */
  225. ulint latch_mode; /* BTR_SEARCH_LEAF, or BTR_MODIFY_LEAF
  226. if select_will_do_update is TRUE */
  227. ulint row_lock_mode; /* LOCK_X or LOCK_S */
  228. ulint n_tables; /* number of tables */
  229. ulint fetch_table; /* number of the next table to access
  230. in the join */
  231. plan_t* plans; /* array of n_tables many plan nodes
  232. containing the search plan and the
  233. search data structures */
  234. que_node_t* search_cond; /* search condition */
  235. read_view_t* read_view; /* if the query is a non-locking
  236. consistent read, its read view is
  237. placed here, otherwise NULL */
  238. ibool consistent_read;/* TRUE if the select is a consistent,
  239. non-locking read */
  240. order_node_t* order_by; /* order by column definition, or
  241. NULL */
  242. ibool is_aggregate; /* TRUE if the select list consists of
  243. aggregate functions */
  244. ibool aggregate_already_fetched;
  245. /* TRUE if the aggregate row has
  246. already been fetched for the current
  247. cursor */
  248. ibool can_get_updated;/* this is TRUE if the select is in a
  249. single-table explicit cursor which can
  250. get updated within the stored procedure,
  251. or in a searched update or delete;
  252. NOTE that to determine of an explicit
  253. cursor if it can get updated, the
  254. parser checks from a stored procedure
  255. if it contains positioned update or
  256. delete statements */
  257. sym_node_t* explicit_cursor;/* not NULL if an explicit cursor */
  258. UT_LIST_BASE_NODE_T(sym_node_t)
  259. copy_variables; /* variables whose values we have to
  260. copy when an explicit cursor is opened,
  261. so that they do not change between
  262. fetches */
  263. };
  264. /* Select node states */
  265. #define SEL_NODE_CLOSED 0 /* it is a declared cursor which is not
  266. currently open */
  267. #define SEL_NODE_OPEN 1 /* intention locks not yet set on
  268. tables */
  269. #define SEL_NODE_FETCH 2 /* intention locks have been set */
  270. #define SEL_NODE_NO_MORE_ROWS 3 /* cursor has reached the result set
  271. end */
  272. /* Fetch statement node */
  273. struct fetch_node_struct{
  274. que_common_t common; /* type: QUE_NODE_FETCH */
  275. sel_node_t* cursor_def; /* cursor definition */
  276. sym_node_t* into_list; /* variables to set */
  277. };
  278. /* Open or close cursor statement node */
  279. struct open_node_struct{
  280. que_common_t common; /* type: QUE_NODE_OPEN */
  281. ulint op_type; /* ROW_SEL_OPEN_CURSOR or
  282. ROW_SEL_CLOSE_CURSOR */
  283. sel_node_t* cursor_def; /* cursor definition */
  284. };
  285. /* Row printf statement node */
  286. struct row_printf_node_struct{
  287. que_common_t common; /* type: QUE_NODE_ROW_PRINTF */
  288. sel_node_t* sel_node; /* select */
  289. };
  290. #define ROW_SEL_OPEN_CURSOR 0
  291. #define ROW_SEL_CLOSE_CURSOR 1
  292. /* Flags for the MySQL interface */
  293. #define ROW_SEL_NEXT 1
  294. #define ROW_SEL_PREV 2
  295. #define ROW_SEL_EXACT 1 /* search using a complete key value */
  296. #define ROW_SEL_EXACT_PREFIX  2 /* search using a key prefix which
  297. must match to rows: the prefix may
  298. contain an incomplete field (the
  299. last field in prefix may be just
  300. a prefix of a fixed length column) */
  301. #ifndef UNIV_NONINL
  302. #include "row0sel.ic"
  303. #endif
  304. #endif