← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/mach0data.h

Merged in latest plugin-slot-reorg.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/mach0data.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
15
 
St, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/******************************************************************//**
20
 
@file include/mach0data.h
21
 
Utilities for converting data from the database file
22
 
to the machine format.
23
 
 
24
 
Created 11/28/1995 Heikki Tuuri
25
 
***********************************************************************/
26
 
 
27
 
#ifndef mach0data_h
28
 
#define mach0data_h
29
 
 
30
 
#include "univ.i"
31
 
#include "ut0byte.h"
32
 
 
33
 
/* The data and all fields are always stored in a database file
34
 
in the same format: ascii, big-endian, ... .
35
 
All data in the files MUST be accessed using the functions in this
36
 
module. */
37
 
 
38
 
/*******************************************************//**
39
 
The following function is used to store data in one byte. */
40
 
UNIV_INLINE
41
 
void
42
 
mach_write_to_1(
43
 
/*============*/
44
 
        byte*   b,      /*!< in: pointer to byte where to store */
45
 
        ulint   n);      /*!< in: ulint integer to be stored, >= 0, < 256 */
46
 
/********************************************************//**
47
 
The following function is used to fetch data from one byte.
48
 
@return ulint integer, >= 0, < 256 */
49
 
UNIV_INLINE
50
 
ulint
51
 
mach_read_from_1(
52
 
/*=============*/
53
 
        const byte*     b)      /*!< in: pointer to byte */
54
 
        __attribute__((nonnull, pure));
55
 
/*******************************************************//**
56
 
The following function is used to store data in two consecutive
57
 
bytes. We store the most significant byte to the lower address. */
58
 
UNIV_INLINE
59
 
void
60
 
mach_write_to_2(
61
 
/*============*/
62
 
        byte*   b,      /*!< in: pointer to two bytes where to store */
63
 
        ulint   n);      /*!< in: ulint integer to be stored, >= 0, < 64k */
64
 
/********************************************************//**
65
 
The following function is used to fetch data from two consecutive
66
 
bytes. The most significant byte is at the lowest address.
67
 
@return ulint integer, >= 0, < 64k */
68
 
UNIV_INLINE
69
 
ulint
70
 
mach_read_from_2(
71
 
/*=============*/
72
 
        const byte*     b)      /*!< in: pointer to two bytes */
73
 
        __attribute__((nonnull, pure));
74
 
 
75
 
/********************************************************//**
76
 
The following function is used to convert a 16-bit data item
77
 
to the canonical format, for fast bytewise equality test
78
 
against memory.
79
 
@return 16-bit integer in canonical format */
80
 
UNIV_INLINE
81
 
uint16
82
 
mach_encode_2(
83
 
/*==========*/
84
 
        ulint   n)      /*!< in: integer in machine-dependent format */
85
 
        __attribute__((const));
86
 
/********************************************************//**
87
 
The following function is used to convert a 16-bit data item
88
 
from the canonical format, for fast bytewise equality test
89
 
against memory.
90
 
@return integer in machine-dependent format */
91
 
UNIV_INLINE
92
 
ulint
93
 
mach_decode_2(
94
 
/*==========*/
95
 
        uint16  n)      /*!< in: 16-bit integer in canonical format */
96
 
        __attribute__((const));
97
 
/*******************************************************//**
98
 
The following function is used to store data in 3 consecutive
99
 
bytes. We store the most significant byte to the lowest address. */
100
 
UNIV_INLINE
101
 
void
102
 
mach_write_to_3(
103
 
/*============*/
104
 
        byte*   b,      /*!< in: pointer to 3 bytes where to store */
105
 
        ulint   n);      /*!< in: ulint integer to be stored */
106
 
/********************************************************//**
107
 
The following function is used to fetch data from 3 consecutive
108
 
bytes. The most significant byte is at the lowest address.
109
 
@return ulint integer */
110
 
UNIV_INLINE
111
 
ulint
112
 
mach_read_from_3(
113
 
/*=============*/
114
 
        const byte*     b)      /*!< in: pointer to 3 bytes */
115
 
        __attribute__((nonnull, pure));
116
 
/*******************************************************//**
117
 
The following function is used to store data in four consecutive
118
 
bytes. We store the most significant byte to the lowest address. */
119
 
UNIV_INLINE
120
 
void
121
 
mach_write_to_4(
122
 
/*============*/
123
 
        byte*   b,      /*!< in: pointer to four bytes where to store */
124
 
        ulint   n);      /*!< in: ulint integer to be stored */
125
 
/********************************************************//**
126
 
The following function is used to fetch data from 4 consecutive
127
 
bytes. The most significant byte is at the lowest address.
128
 
@return ulint integer */
129
 
UNIV_INLINE
130
 
ulint
131
 
mach_read_from_4(
132
 
/*=============*/
133
 
        const byte*     b)      /*!< in: pointer to four bytes */
134
 
        __attribute__((nonnull, pure));
135
 
/*********************************************************//**
136
 
Writes a ulint in a compressed form (1..5 bytes).
137
 
@return stored size in bytes */
138
 
UNIV_INLINE
139
 
ulint
140
 
mach_write_compressed(
141
 
/*==================*/
142
 
        byte*   b,      /*!< in: pointer to memory where to store */
143
 
        ulint   n);     /*!< in: ulint integer to be stored */
144
 
/*********************************************************//**
145
 
Returns the size of an ulint when written in the compressed form.
146
 
@return compressed size in bytes */
147
 
UNIV_INLINE
148
 
ulint
149
 
mach_get_compressed_size(
150
 
/*=====================*/
151
 
        ulint   n)      /*!< in: ulint integer to be stored */
152
 
        __attribute__((const));
153
 
/*********************************************************//**
154
 
Reads a ulint in a compressed form.
155
 
@return read integer */
156
 
UNIV_INLINE
157
 
ulint
158
 
mach_read_compressed(
159
 
/*=================*/
160
 
        const byte*     b)      /*!< in: pointer to memory from where to read */
161
 
        __attribute__((nonnull, pure));
162
 
/*******************************************************//**
163
 
The following function is used to store data in 6 consecutive
164
 
bytes. We store the most significant byte to the lowest address. */
165
 
UNIV_INLINE
166
 
void
167
 
mach_write_to_6(
168
 
/*============*/
169
 
        byte*           b,      /*!< in: pointer to 6 bytes where to store */
170
 
        ib_uint64_t     id);    /*!< in: 48-bit integer */
171
 
/********************************************************//**
172
 
The following function is used to fetch data from 6 consecutive
173
 
bytes. The most significant byte is at the lowest address.
174
 
@return 48-bit integer */
175
 
UNIV_INLINE
176
 
ib_uint64_t
177
 
mach_read_from_6(
178
 
/*=============*/
179
 
        const byte*     b)      /*!< in: pointer to 6 bytes */
180
 
        __attribute__((nonnull, pure));
181
 
/*******************************************************//**
182
 
The following function is used to store data in 7 consecutive
183
 
bytes. We store the most significant byte to the lowest address. */
184
 
UNIV_INLINE
185
 
void
186
 
mach_write_to_7(
187
 
/*============*/
188
 
        byte*           b,      /*!< in: pointer to 7 bytes where to store */
189
 
        ib_uint64_t     n);     /*!< in: 56-bit integer */
190
 
/********************************************************//**
191
 
The following function is used to fetch data from 7 consecutive
192
 
bytes. The most significant byte is at the lowest address.
193
 
@return 56-bit integer */
194
 
UNIV_INLINE
195
 
ib_uint64_t
196
 
mach_read_from_7(
197
 
/*=============*/
198
 
        const byte*     b)      /*!< in: pointer to 7 bytes */
199
 
        __attribute__((nonnull, pure));
200
 
/*******************************************************//**
201
 
The following function is used to store data in 8 consecutive
202
 
bytes. We store the most significant byte to the lowest address. */
203
 
UNIV_INLINE
204
 
void
205
 
mach_write_to_8(
206
 
/*============*/
207
 
        byte*           b,      /*!< in: pointer to 8 bytes where to store */
208
 
        ib_uint64_t     n);     /*!< in: 64-bit integer to be stored */
209
 
/********************************************************//**
210
 
The following function is used to fetch data from 8 consecutive
211
 
bytes. The most significant byte is at the lowest address.
212
 
@return 64-bit integer */
213
 
UNIV_INLINE
214
 
ib_uint64_t
215
 
mach_read_from_8(
216
 
/*=============*/
217
 
        const byte*     b)      /*!< in: pointer to 8 bytes */
218
 
        __attribute__((nonnull, pure));
219
 
/*********************************************************//**
220
 
Writes a 64-bit integer in a compressed form (5..9 bytes).
221
 
@return size in bytes */
222
 
UNIV_INLINE
223
 
ulint
224
 
mach_ull_write_compressed(
225
 
/*======================*/
226
 
        byte*           b,      /*!< in: pointer to memory where to store */
227
 
        ib_uint64_t     n);     /*!< in: 64-bit integer to be stored */
228
 
/*********************************************************//**
229
 
Returns the size of a 64-bit integer when written in the compressed form.
230
 
@return compressed size in bytes */
231
 
UNIV_INLINE
232
 
ulint
233
 
mach_ull_get_compressed_size(
234
 
/*=========================*/
235
 
        ib_uint64_t     n);     /*!< in: 64-bit integer to be stored */
236
 
/*********************************************************//**
237
 
Reads a 64-bit integer in a compressed form.
238
 
@return the value read */
239
 
UNIV_INLINE
240
 
ib_uint64_t
241
 
mach_ull_read_compressed(
242
 
/*=====================*/
243
 
        const byte*     b)      /*!< in: pointer to memory from where to read */
244
 
        __attribute__((nonnull, pure));
245
 
/*********************************************************//**
246
 
Writes a 64-bit integer in a compressed form (1..11 bytes).
247
 
@return size in bytes */
248
 
UNIV_INLINE
249
 
ulint
250
 
mach_ull_write_much_compressed(
251
 
/*===========================*/
252
 
        byte*           b,      /*!< in: pointer to memory where to store */
253
 
        ib_uint64_t     n);     /*!< in: 64-bit integer to be stored */
254
 
/*********************************************************//**
255
 
Returns the size of a 64-bit integer when written in the compressed form.
256
 
@return compressed size in bytes */
257
 
UNIV_INLINE
258
 
ulint
259
 
mach_ull_get_much_compressed_size(
260
 
/*==============================*/
261
 
        ib_uint64_t     n)      /*!< in: 64-bit integer to be stored */
262
 
        __attribute__((const));
263
 
/*********************************************************//**
264
 
Reads a 64-bit integer in a compressed form.
265
 
@return the value read */
266
 
UNIV_INLINE
267
 
ib_uint64_t
268
 
mach_ull_read_much_compressed(
269
 
/*==========================*/
270
 
        const byte*     b)      /*!< in: pointer to memory from where to read */
271
 
        __attribute__((nonnull, pure));
272
 
/*********************************************************//**
273
 
Reads a ulint in a compressed form if the log record fully contains it.
274
 
@return pointer to end of the stored field, NULL if not complete */
275
 
UNIV_INTERN
276
 
byte*
277
 
mach_parse_compressed(
278
 
/*==================*/
279
 
        byte*   ptr,    /*!< in: pointer to buffer from where to read */
280
 
        byte*   end_ptr,/*!< in: pointer to end of the buffer */
281
 
        ulint*  val);   /*!< out: read value */
282
 
/*********************************************************//**
283
 
Reads a 64-bit integer in a compressed form
284
 
if the log record fully contains it.
285
 
@return pointer to end of the stored field, NULL if not complete */
286
 
UNIV_INLINE
287
 
byte*
288
 
mach_ull_parse_compressed(
289
 
/*======================*/
290
 
        byte*           ptr,    /*!< in: pointer to buffer from where to read */
291
 
        byte*           end_ptr,/*!< in: pointer to end of the buffer */
292
 
        ib_uint64_t*    val);   /*!< out: read value */
293
 
#ifndef UNIV_HOTBACKUP
294
 
/*********************************************************//**
295
 
Reads a double. It is stored in a little-endian format.
296
 
@return double read */
297
 
UNIV_INLINE
298
 
double
299
 
mach_double_read(
300
 
/*=============*/
301
 
        const byte*     b)      /*!< in: pointer to memory from where to read */
302
 
        __attribute__((nonnull, pure));
303
 
/*********************************************************//**
304
 
Writes a double. It is stored in a little-endian format. */
305
 
UNIV_INLINE
306
 
void
307
 
mach_double_write(
308
 
/*==============*/
309
 
        byte*   b,      /*!< in: pointer to memory where to write */
310
 
        double  d);     /*!< in: double */
311
 
/*********************************************************//**
312
 
Reads a float. It is stored in a little-endian format.
313
 
@return float read */
314
 
UNIV_INLINE
315
 
float
316
 
mach_float_read(
317
 
/*============*/
318
 
        const byte*     b)      /*!< in: pointer to memory from where to read */
319
 
        __attribute__((nonnull, pure));
320
 
/*********************************************************//**
321
 
Writes a float. It is stored in a little-endian format. */
322
 
UNIV_INLINE
323
 
void
324
 
mach_float_write(
325
 
/*=============*/
326
 
        byte*   b,      /*!< in: pointer to memory where to write */
327
 
        float   d);     /*!< in: float */
328
 
/*********************************************************//**
329
 
Reads a ulint stored in the little-endian format.
330
 
@return unsigned long int */
331
 
UNIV_INLINE
332
 
ulint
333
 
mach_read_from_n_little_endian(
334
 
/*===========================*/
335
 
        const byte*     buf,            /*!< in: from where to read */
336
 
        ulint           buf_size)       /*!< in: from how many bytes to read */
337
 
        __attribute__((nonnull, pure));
338
 
/*********************************************************//**
339
 
Writes a ulint in the little-endian format. */
340
 
UNIV_INLINE
341
 
void
342
 
mach_write_to_n_little_endian(
343
 
/*==========================*/
344
 
        byte*   dest,           /*!< in: where to write */
345
 
        ulint   dest_size,      /*!< in: into how many bytes to write */
346
 
        ulint   n);             /*!< in: unsigned long int to write */
347
 
/*********************************************************//**
348
 
Reads a ulint stored in the little-endian format.
349
 
@return unsigned long int */
350
 
UNIV_INLINE
351
 
ulint
352
 
mach_read_from_2_little_endian(
353
 
/*===========================*/
354
 
        const byte*     buf)            /*!< in: from where to read */
355
 
        __attribute__((nonnull, pure));
356
 
/*********************************************************//**
357
 
Writes a ulint in the little-endian format. */
358
 
UNIV_INLINE
359
 
void
360
 
mach_write_to_2_little_endian(
361
 
/*==========================*/
362
 
        byte*   dest,           /*!< in: where to write */
363
 
        ulint   n);             /*!< in: unsigned long int to write */
364
 
 
365
 
/*********************************************************//**
366
 
Convert integral type from storage byte order (big endian) to
367
 
host byte order.
368
 
@return integer value */
369
 
UNIV_INLINE
370
 
ullint
371
 
mach_read_int_type(
372
 
/*===============*/
373
 
        const byte*     src,            /*!< in: where to read from */
374
 
        ulint           len,            /*!< in: length of src */
375
 
        ibool           unsigned_type); /*!< in: signed or unsigned flag */
376
 
#endif /* !UNIV_HOTBACKUP */
377
 
 
378
 
#ifndef UNIV_NONINL
379
 
#include "mach0data.ic"
380
 
#endif
381
 
 
382
 
#endif