← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/ibuf0ibuf.h

Merged Nathan from lp:~nlws/drizzle/fix-string-c-ptr-overrun

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/ibuf0ibuf.h
1
 
/******************************************************
2
 
Insert buffer
3
 
 
4
 
(c) 1997 Innobase Oy
5
 
 
6
 
Created 7/19/1997 Heikki Tuuri
7
 
*******************************************************/
8
 
 
9
 
#ifndef ibuf0ibuf_h
10
 
#define ibuf0ibuf_h
11
 
 
12
 
#include "univ.i"
13
 
 
14
 
#include "dict0mem.h"
15
 
#include "dict0dict.h"
16
 
#include "mtr0mtr.h"
17
 
#include "que0types.h"
18
 
#include "ibuf0types.h"
19
 
#include "fsp0fsp.h"
20
 
 
21
 
extern ibuf_t*  ibuf;
22
 
 
23
 
/**********************************************************************
24
 
Creates the insert buffer data struct for a single tablespace. Reads the
25
 
root page of the insert buffer tree in the tablespace. This function can
26
 
be called only after the dictionary system has been initialized, as this
27
 
creates also the insert buffer table and index for this tablespace. */
28
 
UNIV_INTERN
29
 
ibuf_data_t*
30
 
ibuf_data_init_for_space(
31
 
/*=====================*/
32
 
                        /* out, own: ibuf data struct, linked to the list
33
 
                        in ibuf control structure. */
34
 
        ulint   space); /* in: space id */
35
 
/**********************************************************************
36
 
Creates the insert buffer data structure at a database startup and
37
 
initializes the data structures for the insert buffer of each tablespace. */
38
 
UNIV_INTERN
39
 
void
40
 
ibuf_init_at_db_start(void);
41
 
/*=======================*/
42
 
/*************************************************************************
43
 
Reads the biggest tablespace id from the high end of the insert buffer
44
 
tree and updates the counter in fil_system. */
45
 
UNIV_INTERN
46
 
void
47
 
ibuf_update_max_tablespace_id(void);
48
 
/*===============================*/
49
 
/*************************************************************************
50
 
Initializes an ibuf bitmap page. */
51
 
UNIV_INTERN
52
 
void
53
 
ibuf_bitmap_page_init(
54
 
/*==================*/
55
 
        buf_block_t*    block,  /* in: bitmap page */
56
 
        mtr_t*          mtr);   /* in: mtr */
57
 
/****************************************************************************
58
 
Resets the free bits of the page in the ibuf bitmap. This is done in a
59
 
separate mini-transaction, hence this operation does not restrict further
60
 
work to only ibuf bitmap operations, which would result if the latch to the
61
 
bitmap page were kept. */
62
 
UNIV_INTERN
63
 
void
64
 
ibuf_reset_free_bits(
65
 
/*=================*/
66
 
        buf_block_t*    block); /* in: index page; free bits are set to 0
67
 
                                if the index is a non-clustered
68
 
                                non-unique, and page level is 0 */
69
 
/****************************************************************************
70
 
Updates the free bits of an uncompressed page in the ibuf bitmap if
71
 
there is not enough free on the page any more. This is done in a
72
 
separate mini-transaction, hence this operation does not restrict
73
 
further work to only ibuf bitmap operations, which would result if the
74
 
latch to the bitmap page were kept. */
75
 
UNIV_INLINE
76
 
void
77
 
ibuf_update_free_bits_if_full(
78
 
/*==========================*/
79
 
        buf_block_t*    block,  /* in: index page to which we have added new
80
 
                                records; the free bits are updated if the
81
 
                                index is non-clustered and non-unique and
82
 
                                the page level is 0, and the page becomes
83
 
                                fuller */
84
 
        ulint           max_ins_size,/* in: value of maximum insert size with
85
 
                                reorganize before the latest operation
86
 
                                performed to the page */
87
 
        ulint           increase);/* in: upper limit for the additional space
88
 
                                used in the latest operation, if known, or
89
 
                                ULINT_UNDEFINED */
90
 
/**************************************************************************
91
 
Updates the free bits for an uncompressed page to reflect the present state.
92
 
Does this in the mtr given, which means that the latching order rules virtually
93
 
prevent any further operations for this OS thread until mtr is committed. */
94
 
UNIV_INTERN
95
 
void
96
 
ibuf_update_free_bits_low(
97
 
/*======================*/
98
 
        const buf_block_t*      block,          /* in: index page */
99
 
        ulint                   max_ins_size,   /* in: value of
100
 
                                                maximum insert size
101
 
                                                with reorganize before
102
 
                                                the latest operation
103
 
                                                performed to the page */
104
 
        mtr_t*                  mtr);           /* in/out: mtr */
105
 
/**************************************************************************
106
 
Updates the free bits for a compressed page to reflect the present state.
107
 
Does this in the mtr given, which means that the latching order rules virtually
108
 
prevent any further operations for this OS thread until mtr is committed. */
109
 
UNIV_INTERN
110
 
void
111
 
ibuf_update_free_bits_zip(
112
 
/*======================*/
113
 
        buf_block_t*    block,  /* in/out: index page */
114
 
        mtr_t*          mtr);   /* in/out: mtr */
115
 
/**************************************************************************
116
 
Updates the free bits for the two pages to reflect the present state. Does
117
 
this in the mtr given, which means that the latching order rules virtually
118
 
prevent any further operations until mtr is committed. */
119
 
UNIV_INTERN
120
 
void
121
 
ibuf_update_free_bits_for_two_pages_low(
122
 
/*====================================*/
123
 
        ulint           zip_size,/* in: compressed page size in bytes;
124
 
                                0 for uncompressed pages */
125
 
        buf_block_t*    block1, /* in: index page */
126
 
        buf_block_t*    block2, /* in: index page */
127
 
        mtr_t*          mtr);   /* in: mtr */
128
 
/**************************************************************************
129
 
A basic partial test if an insert to the insert buffer could be possible and
130
 
recommended. */
131
 
UNIV_INLINE
132
 
ibool
133
 
ibuf_should_try(
134
 
/*============*/
135
 
        dict_index_t*   index,                  /* in: index where to insert */
136
 
        ulint           ignore_sec_unique);     /* in: if != 0, we should
137
 
                                                ignore UNIQUE constraint on
138
 
                                                a secondary index when we
139
 
                                                decide */
140
 
/**********************************************************************
141
 
Returns TRUE if the current OS thread is performing an insert buffer
142
 
routine. */
143
 
UNIV_INTERN
144
 
ibool
145
 
ibuf_inside(void);
146
 
/*=============*/
147
 
                /* out: TRUE if inside an insert buffer routine: for instance,
148
 
                a read-ahead of non-ibuf pages is then forbidden */
149
 
/***************************************************************************
150
 
Checks if a page address is an ibuf bitmap page (level 3 page) address. */
151
 
UNIV_INLINE
152
 
ibool
153
 
ibuf_bitmap_page(
154
 
/*=============*/
155
 
                        /* out: TRUE if a bitmap page */
156
 
        ulint   zip_size,/* in: compressed page size in bytes;
157
 
                        0 for uncompressed pages */
158
 
        ulint   page_no);/* in: page number */
159
 
/***************************************************************************
160
 
Checks if a page is a level 2 or 3 page in the ibuf hierarchy of pages. */
161
 
UNIV_INTERN
162
 
ibool
163
 
ibuf_page(
164
 
/*======*/
165
 
                        /* out: TRUE if level 2 or level 3 page */
166
 
        ulint   space,  /* in: space id */
167
 
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
168
 
        ulint   page_no);/* in: page number */
169
 
/***************************************************************************
170
 
Checks if a page is a level 2 or 3 page in the ibuf hierarchy of pages. */
171
 
UNIV_INTERN
172
 
ibool
173
 
ibuf_page_low(
174
 
/*==========*/
175
 
                        /* out: TRUE if level 2 or level 3 page */
176
 
        ulint   space,  /* in: space id */
177
 
        ulint   zip_size,/* in: compressed page size in bytes, or 0 */
178
 
        ulint   page_no,/* in: page number */
179
 
        mtr_t*  mtr);   /* in: mtr which will contain an x-latch to the
180
 
                        bitmap page if the page is not one of the fixed
181
 
                        address ibuf pages */
182
 
/***************************************************************************
183
 
Frees excess pages from the ibuf free list. This function is called when an OS
184
 
thread calls fsp services to allocate a new file segment, or a new page to a
185
 
file segment, and the thread did not own the fsp latch before this call. */
186
 
UNIV_INTERN
187
 
void
188
 
ibuf_free_excess_pages(
189
 
/*===================*/
190
 
        ulint   space);         /* in: space id */
191
 
/*************************************************************************
192
 
Makes an index insert to the insert buffer, instead of directly to the disk
193
 
page, if this is possible. Does not do insert if the index is clustered
194
 
or unique. */
195
 
UNIV_INTERN
196
 
ibool
197
 
ibuf_insert(
198
 
/*========*/
199
 
                                /* out: TRUE if success */
200
 
        const dtuple_t* entry,  /* in: index entry to insert */
201
 
        dict_index_t*   index,  /* in: index where to insert */
202
 
        ulint           space,  /* in: space id where to insert */
203
 
        ulint           zip_size,/* in: compressed page size in bytes, or 0 */
204
 
        ulint           page_no,/* in: page number where to insert */
205
 
        que_thr_t*      thr);   /* in: query thread */
206
 
/*************************************************************************
207
 
When an index page is read from a disk to the buffer pool, this function
208
 
inserts to the page the possible index entries buffered in the insert buffer.
209
 
The entries are deleted from the insert buffer. If the page is not read, but
210
 
created in the buffer pool, this function deletes its buffered entries from
211
 
the insert buffer; there can exist entries for such a page if the page
212
 
belonged to an index which subsequently was dropped. */
213
 
UNIV_INTERN
214
 
void
215
 
ibuf_merge_or_delete_for_page(
216
 
/*==========================*/
217
 
        buf_block_t*    block,  /* in: if page has been read from
218
 
                                disk, pointer to the page x-latched,
219
 
                                else NULL */
220
 
        ulint           space,  /* in: space id of the index page */
221
 
        ulint           page_no,/* in: page number of the index page */
222
 
        ulint           zip_size,/* in: compressed page size in bytes,
223
 
                                or 0 */
224
 
        ibool           update_ibuf_bitmap);/* in: normally this is set
225
 
                                to TRUE, but if we have deleted or are
226
 
                                deleting the tablespace, then we
227
 
                                naturally do not want to update a
228
 
                                non-existent bitmap page */
229
 
/*************************************************************************
230
 
Deletes all entries in the insert buffer for a given space id. This is used
231
 
in DISCARD TABLESPACE and IMPORT TABLESPACE.
232
 
NOTE: this does not update the page free bitmaps in the space. The space will
233
 
become CORRUPT when you call this function! */
234
 
UNIV_INTERN
235
 
void
236
 
ibuf_delete_for_discarded_space(
237
 
/*============================*/
238
 
        ulint   space); /* in: space id */
239
 
/*************************************************************************
240
 
Contracts insert buffer trees by reading pages to the buffer pool. */
241
 
UNIV_INTERN
242
 
ulint
243
 
ibuf_contract(
244
 
/*==========*/
245
 
                        /* out: a lower limit for the combined size in bytes
246
 
                        of entries which will be merged from ibuf trees to the
247
 
                        pages read, 0 if ibuf is empty */
248
 
        ibool   sync);  /* in: TRUE if the caller wants to wait for the
249
 
                        issued read with the highest tablespace address
250
 
                        to complete */
251
 
/*************************************************************************
252
 
Contracts insert buffer trees by reading pages to the buffer pool. */
253
 
UNIV_INTERN
254
 
ulint
255
 
ibuf_contract_for_n_pages(
256
 
/*======================*/
257
 
                        /* out: a lower limit for the combined size in bytes
258
 
                        of entries which will be merged from ibuf trees to the
259
 
                        pages read, 0 if ibuf is empty */
260
 
        ibool   sync,   /* in: TRUE if the caller wants to wait for the
261
 
                        issued read with the highest tablespace address
262
 
                        to complete */
263
 
        ulint   n_pages);/* in: try to read at least this many pages to
264
 
                        the buffer pool and merge the ibuf contents to
265
 
                        them */
266
 
/*************************************************************************
267
 
Parses a redo log record of an ibuf bitmap page init. */
268
 
UNIV_INTERN
269
 
byte*
270
 
ibuf_parse_bitmap_init(
271
 
/*===================*/
272
 
                                /* out: end of log record or NULL */
273
 
        byte*           ptr,    /* in: buffer */
274
 
        byte*           end_ptr,/* in: buffer end */
275
 
        buf_block_t*    block,  /* in: block or NULL */
276
 
        mtr_t*          mtr);   /* in: mtr or NULL */
277
 
#ifdef UNIV_IBUF_COUNT_DEBUG
278
 
/**********************************************************************
279
 
Gets the ibuf count for a given page. */
280
 
UNIV_INTERN
281
 
ulint
282
 
ibuf_count_get(
283
 
/*===========*/
284
 
                        /* out: number of entries in the insert buffer
285
 
                        currently buffered for this page */
286
 
        ulint   space,  /* in: space id */
287
 
        ulint   page_no);/* in: page number */
288
 
#endif
289
 
/**********************************************************************
290
 
Looks if the insert buffer is empty. */
291
 
UNIV_INTERN
292
 
ibool
293
 
ibuf_is_empty(void);
294
 
/*===============*/
295
 
                        /* out: TRUE if empty */
296
 
/**********************************************************************
297
 
Prints info of ibuf. */
298
 
UNIV_INTERN
299
 
void
300
 
ibuf_print(
301
 
/*=======*/
302
 
        FILE*   file);  /* in: file where to print */
303
 
 
304
 
#define IBUF_HEADER_PAGE_NO     FSP_IBUF_HEADER_PAGE_NO
305
 
#define IBUF_TREE_ROOT_PAGE_NO  FSP_IBUF_TREE_ROOT_PAGE_NO
306
 
 
307
 
/* The ibuf header page currently contains only the file segment header
308
 
for the file segment from which the pages for the ibuf tree are allocated */
309
 
#define IBUF_HEADER             PAGE_DATA
310
 
#define IBUF_TREE_SEG_HEADER    0       /* fseg header for ibuf tree */
311
 
 
312
 
#ifndef UNIV_NONINL
313
 
#include "ibuf0ibuf.ic"
314
 
#endif
315
 
 
316
 
#endif