/src/mdbtools/src/libmdb/write.c
Line | Count | Source |
1 | | /* MDB Tools - A library for reading MS Access database file |
2 | | * Copyright (C) 2000 Brian Bruns |
3 | | * |
4 | | * This library is free software; you can redistribute it and/or |
5 | | * modify it under the terms of the GNU Library General Public |
6 | | * License as published by the Free Software Foundation; either |
7 | | * version 2 of the License, or (at your option) any later version. |
8 | | * |
9 | | * This library is distributed in the hope that it will be useful, |
10 | | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | | * Library General Public License for more details. |
13 | | * |
14 | | * You should have received a copy of the GNU Library General Public |
15 | | * License along with this library; if not, write to the Free Software |
16 | | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
17 | | */ |
18 | | |
19 | | #include <time.h> |
20 | | #include <inttypes.h> |
21 | | #include "mdbprivate.h" |
22 | | |
23 | | //static int mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg); |
24 | | static int mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg, MdbField *idx_fields, guint32 pgnum, guint16 rownum); |
25 | | |
26 | | void |
27 | | mdb_put_int16(void *buf, guint32 offset, guint32 value) |
28 | 14.8k | { |
29 | 14.8k | unsigned char *u8_buf = (unsigned char *)buf + offset; |
30 | 14.8k | u8_buf[0] = (value & 0xFF); |
31 | 14.8k | u8_buf[1] = (value >> 8) & 0xFF; |
32 | 14.8k | } |
33 | | void |
34 | | _mdb_put_int16(void *buf, guint32 offset, guint32 value) |
35 | | #ifdef HAVE_ATTRIBUTE_ALIAS |
36 | | __attribute__((alias("mdb_put_int16"))); |
37 | | #else |
38 | | { mdb_put_int16(buf, offset, value); } |
39 | | #endif |
40 | | |
41 | | void |
42 | | mdb_put_int32(void *buf, guint32 offset, guint32 value) |
43 | 1.82k | { |
44 | 1.82k | unsigned char *u8_buf = (unsigned char *)buf + offset; |
45 | 1.82k | u8_buf[0] = (value & 0xFF); |
46 | 1.82k | u8_buf[1] = (value >> 8) & 0xFF; |
47 | 1.82k | u8_buf[2] = (value >> 16) & 0xFF; |
48 | 1.82k | u8_buf[3] = (value >> 24) & 0xFF; |
49 | 1.82k | } |
50 | | void |
51 | | _mdb_put_int32(void *buf, guint32 offset, guint32 value) |
52 | | #ifdef HAVE_ATTRIBUTE_ALIAS |
53 | | __attribute__((alias("mdb_put_int32"))); |
54 | | #else |
55 | | { mdb_put_int32(buf, offset, value); } |
56 | | #endif |
57 | | |
58 | | void |
59 | | mdb_put_int32_msb(void *buf, guint32 offset, guint32 value) |
60 | 0 | { |
61 | 0 | unsigned char *u8_buf = (unsigned char *)buf + offset; |
62 | 0 | u8_buf[3] = (value & 0xFF); |
63 | 0 | u8_buf[2] = (value >> 8) & 0xFF; |
64 | 0 | u8_buf[1] = (value >> 16) & 0xFF; |
65 | 0 | u8_buf[0] = (value >> 24) & 0xFF; |
66 | 0 | } |
67 | | void |
68 | | _mdb_put_int32_mdb(void *buf, guint32 offset, guint32 value) |
69 | | #ifdef HAVE_ATTRIBUTE_ALIAS |
70 | | __attribute__((alias("mdb_put_int32_msb"))); |
71 | | #else |
72 | | { mdb_put_int32_msb(buf, offset, value); } |
73 | | #endif |
74 | | |
75 | | ssize_t |
76 | | mdb_write_pg(MdbHandle *mdb, unsigned long pg) |
77 | 52 | { |
78 | 52 | ssize_t len; |
79 | 52 | off_t offset = pg * mdb->fmt->pg_size; |
80 | 52 | unsigned char *buf = mdb->pg_buf; |
81 | | |
82 | 52 | fseeko(mdb->f->stream, 0, SEEK_END); |
83 | | /* is page beyond current size + 1 ? */ |
84 | 52 | if (ftello(mdb->f->stream) < offset + mdb->fmt->pg_size) { |
85 | 2 | fprintf(stderr,"offset %" PRIu64 " is beyond EOF\n",(uint64_t)offset); |
86 | 2 | return 0; |
87 | 2 | } |
88 | 50 | fseeko(mdb->f->stream, offset, SEEK_SET); |
89 | | |
90 | 50 | if (pg != 0 && mdb->f->db_key != 0) |
91 | 0 | { |
92 | 0 | buf = g_memdup2(mdb->pg_buf, mdb->fmt->pg_size); |
93 | 0 | unsigned int tmp_key = mdb->f->db_key ^ pg; |
94 | 0 | mdbi_rc4((unsigned char*)&tmp_key, 4, buf, mdb->fmt->pg_size); |
95 | 0 | } |
96 | | |
97 | 50 | len = fwrite(buf, 1, mdb->fmt->pg_size, mdb->f->stream); |
98 | | |
99 | 50 | if (buf != mdb->pg_buf) { |
100 | 0 | g_free(buf); |
101 | 0 | } |
102 | | |
103 | 50 | if (ferror(mdb->f->stream)) { |
104 | 0 | perror("write"); |
105 | 0 | return 0; |
106 | 50 | } else if (len<mdb->fmt->pg_size) { |
107 | | /* fprintf(stderr,"EOF reached %d bytes returned.\n",len, mdb->pg_size); */ |
108 | 0 | return 0; |
109 | 0 | } |
110 | 50 | mdb->cur_pos = 0; |
111 | 50 | return len; |
112 | 50 | } |
113 | | |
114 | | static int |
115 | | mdb_is_col_indexed(MdbTableDef *table, int colnum) |
116 | 0 | { |
117 | 0 | unsigned int i, j; |
118 | 0 | MdbIndex *idx; |
119 | |
|
120 | 0 | for (i=0;i<table->num_idxs;i++) { |
121 | 0 | idx = g_ptr_array_index (table->indices, i); |
122 | 0 | for (j=0;j<idx->num_keys;j++) { |
123 | 0 | if (idx->key_col_num[j]==colnum) return 1; |
124 | 0 | } |
125 | 0 | } |
126 | 0 | return 0; |
127 | 0 | } |
128 | | |
129 | | static int |
130 | | mdb_crack_row4(MdbHandle *mdb, unsigned int row_start, unsigned int row_end, |
131 | | unsigned int bitmask_sz, unsigned int row_var_cols, unsigned int *var_col_offsets) |
132 | 127k | { |
133 | 127k | unsigned int i; |
134 | | |
135 | 127k | if (bitmask_sz + 3 + row_var_cols*2 + 2 > row_end) |
136 | 46.0k | return 0; |
137 | | |
138 | 2.46M | for (i=0; i<row_var_cols+1; i++) { |
139 | 2.37M | var_col_offsets[i] = mdb_get_int16(mdb->pg_buf, |
140 | 2.37M | row_end - bitmask_sz - 3 - (i*2)); |
141 | 2.37M | } |
142 | | |
143 | 81.2k | return 1; |
144 | 127k | } |
145 | | static int |
146 | | mdb_crack_row3(MdbHandle *mdb, unsigned int row_start, unsigned int row_end, |
147 | | unsigned int bitmask_sz, unsigned int row_var_cols, unsigned int *var_col_offsets) |
148 | 302k | { |
149 | 302k | unsigned int i; |
150 | 302k | unsigned int num_jumps = 0, jumps_used = 0; |
151 | 302k | unsigned int col_ptr, row_len; |
152 | | |
153 | 302k | row_len = row_end - row_start + 1; |
154 | 302k | num_jumps = (row_len - 1) / 256; |
155 | 302k | col_ptr = row_end - bitmask_sz - num_jumps - 1; |
156 | | /* If last jump is a dummy value, ignore it */ |
157 | 302k | if ((col_ptr-row_start-row_var_cols)/256 < num_jumps) |
158 | 49.5k | num_jumps--; |
159 | | |
160 | 302k | if (bitmask_sz + num_jumps + 1 > row_end) |
161 | 0 | return 0; |
162 | | |
163 | 302k | if (col_ptr >= (size_t)mdb->fmt->pg_size || col_ptr < row_var_cols) |
164 | 22.1k | return 0; |
165 | | |
166 | 280k | jumps_used = 0; |
167 | 16.1M | for (i=0; i<row_var_cols+1; i++) { |
168 | 16.0M | while ((jumps_used < num_jumps) |
169 | 6.67M | && (i == mdb->pg_buf[row_end-bitmask_sz-jumps_used-1])) { |
170 | 132k | jumps_used++; |
171 | 132k | } |
172 | 15.8M | var_col_offsets[i] = mdb->pg_buf[col_ptr-i]+(jumps_used*256); |
173 | 15.8M | } |
174 | | |
175 | 280k | return 1; |
176 | 302k | } |
177 | | /** |
178 | | * @brief Cracks a row buffer apart into its component fields. |
179 | | * @param table: Table that the row belongs to |
180 | | * @param row_start: offset to start of row on current page |
181 | | * @param row_size: offset to end of row on current page |
182 | | * @param fields: pointer to MdbField array to be populated by mdb_crack_row |
183 | | * |
184 | | * |
185 | | * A row buffer is that portion of a data page which contains the values for |
186 | | * that row. Its beginning and end can be found in the row offset table. |
187 | | * |
188 | | * The resulting MdbField array contains pointers into the row for each field |
189 | | * present. Be aware that by modifying field[]->value, you would be modifying |
190 | | * the row buffer itself, not a copy. |
191 | | * |
192 | | * This routine is mostly used internally by mdb_fetch_row() but may have some |
193 | | * applicability for advanced application programs. |
194 | | * |
195 | | * @return: number of fields present, or -1 if the buffer is invalid. |
196 | | */ |
197 | | int |
198 | | mdb_crack_row(MdbTableDef *table, int row_start, size_t row_size, MdbField *fields) |
199 | 1.66M | { |
200 | 1.66M | MdbColumn *col; |
201 | 1.66M | MdbCatalogEntry *entry = table->entry; |
202 | 1.66M | MdbHandle *mdb = entry->mdb; |
203 | 1.66M | void *pg_buf = mdb->pg_buf; |
204 | 1.66M | unsigned int row_var_cols=0, row_cols; |
205 | 1.66M | unsigned char *nullmask; |
206 | 1.66M | unsigned int bitmask_sz; |
207 | 1.66M | unsigned int *var_col_offsets = NULL; |
208 | 1.66M | unsigned int fixed_cols_found, row_fixed_cols; |
209 | 1.66M | unsigned int col_count_size; |
210 | 1.66M | unsigned int i; |
211 | 1.66M | unsigned int row_end = row_start + row_size - 1; |
212 | | |
213 | 1.66M | if (mdb_get_option(MDB_DEBUG_ROW)) { |
214 | 0 | mdb_buffer_dump(pg_buf, row_start, row_size); |
215 | 0 | } |
216 | | |
217 | 1.66M | if (IS_JET3(mdb)) { |
218 | 385k | row_cols = mdb_get_byte(pg_buf, row_start); |
219 | 385k | col_count_size = 1; |
220 | 1.28M | } else { |
221 | 1.28M | row_cols = mdb_get_int16(pg_buf, row_start); |
222 | 1.28M | col_count_size = 2; |
223 | 1.28M | } |
224 | | |
225 | 1.66M | bitmask_sz = (row_cols + 7) / 8; |
226 | 1.66M | if (bitmask_sz + !IS_JET3(mdb) >= row_end) { |
227 | 658k | fprintf(stderr, "warning: Invalid page buffer detected in mdb_crack_row.\n"); |
228 | 658k | return -1; |
229 | 658k | } |
230 | | |
231 | 1.01M | nullmask = (unsigned char*)pg_buf + row_end - bitmask_sz + 1; |
232 | | |
233 | | /* read table of variable column locations */ |
234 | 1.01M | if (table->num_var_cols > 0) { |
235 | 429k | row_var_cols = IS_JET3(mdb) ? |
236 | 302k | mdb_get_byte(pg_buf, row_end - bitmask_sz) : |
237 | 429k | mdb_get_int16(pg_buf, row_end - bitmask_sz - 1); |
238 | 429k | var_col_offsets = g_malloc((row_var_cols+1)*sizeof(int)); |
239 | 429k | int success = 0; |
240 | 429k | if (IS_JET3(mdb)) { |
241 | 302k | success = mdb_crack_row3(mdb, row_start, row_end, bitmask_sz, |
242 | 302k | row_var_cols, var_col_offsets); |
243 | 302k | } else { |
244 | 127k | success = mdb_crack_row4(mdb, row_start, row_end, bitmask_sz, |
245 | 127k | row_var_cols, var_col_offsets); |
246 | 127k | } |
247 | 429k | if (!success) { |
248 | 68.1k | fprintf(stderr, "warning: Invalid page buffer detected in mdb_crack_row.\n"); |
249 | 68.1k | g_free(var_col_offsets); |
250 | 68.1k | return -1; |
251 | 68.1k | } |
252 | 429k | } |
253 | | |
254 | 942k | fixed_cols_found = 0; |
255 | 942k | row_fixed_cols = row_cols - row_var_cols; |
256 | | |
257 | 942k | if (mdb_get_option(MDB_DEBUG_ROW)) { |
258 | 0 | fprintf(stdout,"bitmask_sz %d\n", bitmask_sz); |
259 | 0 | fprintf(stdout,"row_var_cols %d\n", row_var_cols); |
260 | 0 | fprintf(stdout,"row_fixed_cols %d\n", row_fixed_cols); |
261 | 0 | } |
262 | | |
263 | 14.3M | for (i=0;i<table->num_cols;i++) { |
264 | 13.5M | unsigned int byte_num, bit_num; |
265 | 13.5M | unsigned int col_start; |
266 | 13.5M | col = g_ptr_array_index(table->columns,i); |
267 | 13.5M | fields[i].colnum = i; |
268 | 13.5M | fields[i].is_fixed = col->is_fixed; |
269 | 13.5M | byte_num = col->col_num / 8; |
270 | 13.5M | bit_num = col->col_num % 8; |
271 | | /* logic on nulls is reverse, 1 is not null, 0 is null */ |
272 | 13.5M | fields[i].is_null = nullmask[byte_num] & (1 << bit_num) ? 0 : 1; |
273 | | |
274 | 13.5M | if ((fields[i].is_fixed) |
275 | 4.37M | && (fixed_cols_found < row_fixed_cols)) { |
276 | 3.80M | col_start = col->fixed_offset + col_count_size; |
277 | 3.80M | fields[i].start = row_start + col_start; |
278 | 3.80M | fields[i].value = (char*)pg_buf + row_start + col_start; |
279 | 3.80M | fields[i].siz = col->col_size; |
280 | 3.80M | fixed_cols_found++; |
281 | | /* Use col->var_col_num because a deleted column is still |
282 | | * present in the variable column offsets table for the row */ |
283 | 9.74M | } else if ((!fields[i].is_fixed) |
284 | 9.17M | && (col->var_col_num < row_var_cols)) { |
285 | 515k | col_start = var_col_offsets[col->var_col_num]; |
286 | 515k | fields[i].start = row_start + col_start; |
287 | 515k | fields[i].value = (char*)pg_buf + row_start + col_start; |
288 | 515k | fields[i].siz = var_col_offsets[(col->var_col_num)+1] - |
289 | 515k | col_start; |
290 | 9.23M | } else { |
291 | 9.23M | fields[i].start = 0; |
292 | 9.23M | fields[i].value = NULL; |
293 | 9.23M | fields[i].siz = 0; |
294 | 9.23M | fields[i].is_null = 1; |
295 | 9.23M | } |
296 | 13.5M | if (fields[i].siz < 0 || |
297 | 13.4M | (size_t)(fields[i].start + fields[i].siz) > row_start + row_size) { |
298 | 163k | fprintf(stderr, "warning: Invalid data location detected in mdb_crack_row. Table:%s Column:%i\n",table->name, i); |
299 | 163k | g_free(var_col_offsets); |
300 | 163k | return -1; |
301 | 163k | } |
302 | 13.5M | } |
303 | | |
304 | 778k | g_free(var_col_offsets); |
305 | 778k | return row_cols; |
306 | 942k | } |
307 | | |
308 | | static int |
309 | | mdb_pack_null_mask(unsigned char *buffer, int num_fields, MdbField *fields) |
310 | 3.92k | { |
311 | 3.92k | int pos = 0, bit = 0, byte = 0; |
312 | 3.92k | int i; |
313 | | |
314 | | /* 'Not null' bitmap */ |
315 | 9.01k | for (i=0; i<num_fields; i++) { |
316 | | /* column is null if bit is clear (0) */ |
317 | 5.08k | if (!fields[i].is_null) { |
318 | 5.08k | byte |= 1 << bit; |
319 | | //printf("%d %d %d %d\n", i, bit, 1 << bit, byte); |
320 | 5.08k | } |
321 | 5.08k | bit++; |
322 | 5.08k | if (bit==8) { |
323 | 0 | buffer[pos++] = byte; |
324 | 0 | bit = byte = 0; |
325 | 0 | } |
326 | 5.08k | } |
327 | | /* if we've written any bits to the current byte, flush it */ |
328 | 3.92k | if (bit) |
329 | 3.92k | buffer[pos++] = byte; |
330 | | |
331 | 3.92k | return pos; |
332 | 3.92k | } |
333 | | /* fields must be ordered with fixed columns first, then vars, subsorted by |
334 | | * column number */ |
335 | | static int |
336 | | mdb_pack_row4(MdbTableDef *table, unsigned char *row_buffer, unsigned int num_fields, MdbField *fields) |
337 | 2.53k | { |
338 | 2.53k | unsigned int pos = 0; |
339 | 2.53k | unsigned int var_cols = 0; |
340 | 2.53k | unsigned int i; |
341 | | |
342 | 2.53k | row_buffer[pos++] = num_fields & 0xff; |
343 | 2.53k | row_buffer[pos++] = (num_fields >> 8) & 0xff; |
344 | | |
345 | | /* Fixed length columns */ |
346 | 6.21k | for (i=0;i<num_fields;i++) { |
347 | 3.68k | if (fields[i].is_fixed) { |
348 | 3.40k | fields[i].offset = pos; |
349 | 3.40k | if (!fields[i].is_null) { |
350 | 3.40k | memcpy(&row_buffer[pos], fields[i].value, fields[i].siz); |
351 | 3.40k | } |
352 | 3.40k | pos += fields[i].siz; |
353 | 3.40k | } |
354 | 3.68k | } |
355 | | /* For tables without variable-length columns */ |
356 | 2.53k | if (table->num_var_cols == 0) { |
357 | 4 | pos += mdb_pack_null_mask(&row_buffer[pos], num_fields, fields); |
358 | 4 | return pos; |
359 | 4 | } |
360 | | /* Variable length columns */ |
361 | 6.20k | for (i=0;i<num_fields;i++) { |
362 | 3.67k | if (!fields[i].is_fixed) { |
363 | 282 | var_cols++; |
364 | 282 | fields[i].offset = pos; |
365 | 282 | if (! fields[i].is_null) { |
366 | 282 | memcpy(&row_buffer[pos], fields[i].value, fields[i].siz); |
367 | 282 | pos += fields[i].siz; |
368 | 282 | } |
369 | 282 | } |
370 | 3.67k | } |
371 | | /* EOD */ |
372 | 2.52k | row_buffer[pos] = pos & 0xff; |
373 | 2.52k | row_buffer[pos+1] = (pos >> 8) & 0xff; |
374 | 2.52k | pos += 2; |
375 | | |
376 | | /* Offsets of the variable-length columns */ |
377 | 6.20k | for (i=num_fields; i>0; i--) { |
378 | 3.67k | if (!fields[i-1].is_fixed) { |
379 | 282 | row_buffer[pos++] = fields[i-1].offset & 0xff; |
380 | 282 | row_buffer[pos++] = (fields[i-1].offset >> 8) & 0xff; |
381 | 282 | } |
382 | 3.67k | } |
383 | | /* Number of variable-length columns */ |
384 | 2.52k | row_buffer[pos++] = var_cols & 0xff; |
385 | 2.52k | row_buffer[pos++] = (var_cols >> 8) & 0xff; |
386 | | |
387 | 2.52k | pos += mdb_pack_null_mask(&row_buffer[pos], num_fields, fields); |
388 | 2.52k | return pos; |
389 | 2.53k | } |
390 | | |
391 | | static int |
392 | | mdb_pack_row3(MdbTableDef *table, unsigned char *row_buffer, unsigned int num_fields, MdbField *fields) |
393 | 1.39k | { |
394 | 1.39k | unsigned int pos = 0; |
395 | 1.39k | unsigned int var_cols = 0; |
396 | 1.39k | unsigned int i, j; |
397 | 1.39k | unsigned char *offset_high; |
398 | | |
399 | 1.39k | row_buffer[pos++] = num_fields; |
400 | | |
401 | | /* Fixed length columns */ |
402 | 2.79k | for (i=0;i<num_fields;i++) { |
403 | 1.39k | if (fields[i].is_fixed) { |
404 | 1.39k | fields[i].offset = pos; |
405 | 1.39k | if (!fields[i].is_null) { |
406 | 1.39k | memcpy(&row_buffer[pos], fields[i].value, fields[i].siz); |
407 | 1.39k | } |
408 | 1.39k | pos += fields[i].siz; |
409 | 1.39k | } |
410 | 1.39k | } |
411 | | /* For tables without variable-length columns */ |
412 | 1.39k | if (table->num_var_cols == 0) { |
413 | 0 | pos += mdb_pack_null_mask(&row_buffer[pos], num_fields, fields); |
414 | 0 | return pos; |
415 | 0 | } |
416 | | /* Variable length columns */ |
417 | 2.79k | for (i=0;i<num_fields;i++) { |
418 | 1.39k | if (!fields[i].is_fixed) { |
419 | 0 | var_cols++; |
420 | 0 | fields[i].offset = pos; |
421 | 0 | if (! fields[i].is_null) { |
422 | 0 | memcpy(&row_buffer[pos], fields[i].value, fields[i].siz); |
423 | 0 | pos += fields[i].siz; |
424 | 0 | } |
425 | 0 | } |
426 | 1.39k | } |
427 | | |
428 | 1.39k | offset_high = g_malloc(var_cols+1); |
429 | 1.39k | offset_high[0] = (pos >> 8) & 0xff; |
430 | 1.39k | j = 1; |
431 | | |
432 | | /* EOD */ |
433 | 1.39k | row_buffer[pos] = pos & 0xff; |
434 | 1.39k | pos++; |
435 | | |
436 | | /* Variable length column offsets */ |
437 | 2.79k | for (i=num_fields; i>0; i--) { |
438 | 1.39k | if (!fields[i-1].is_fixed) { |
439 | 0 | row_buffer[pos++] = fields[i-1].offset & 0xff; |
440 | 0 | offset_high[j++] = (fields[i-1].offset >> 8) & 0xff; |
441 | 0 | } |
442 | 1.39k | } |
443 | | |
444 | | /* Dummy jump table entry */ |
445 | 1.39k | if (offset_high[0] < (pos+(num_fields+7)/8-1)/255) { |
446 | 0 | row_buffer[pos++] = 0xff; |
447 | 0 | } |
448 | | /* Jump table */ |
449 | 1.39k | for (i=0; i<var_cols; i++) { |
450 | 0 | if (offset_high[i] > offset_high[i+1]) { |
451 | 0 | row_buffer[pos++] = var_cols-i; |
452 | 0 | } |
453 | 0 | } |
454 | 1.39k | g_free(offset_high); |
455 | | |
456 | 1.39k | row_buffer[pos++] = var_cols; |
457 | | |
458 | 1.39k | pos += mdb_pack_null_mask(&row_buffer[pos], num_fields, fields); |
459 | 1.39k | return pos; |
460 | 1.39k | } |
461 | | int |
462 | | mdb_pack_row(MdbTableDef *table, unsigned char *row_buffer, int unsigned num_fields, MdbField *fields) |
463 | 3.92k | { |
464 | 3.92k | if (table->is_temp_table) { |
465 | 3.54k | unsigned int i; |
466 | 7.08k | for (i=0; i<num_fields; i++) { |
467 | 3.54k | MdbColumn *c = g_ptr_array_index(table->columns, i); |
468 | 3.54k | fields[i].is_null = (fields[i].value) ? 0 : 1; |
469 | 3.54k | fields[i].colnum = i; |
470 | 3.54k | fields[i].is_fixed = c->is_fixed; |
471 | 3.54k | if ((c->col_type != MDB_TEXT) |
472 | 3.54k | && (c->col_type != MDB_MEMO)) { |
473 | 3.54k | fields[i].siz = c->col_size; |
474 | 3.54k | } |
475 | 3.54k | } |
476 | 3.54k | } |
477 | 3.92k | if (IS_JET3(table->entry->mdb)) { |
478 | 1.39k | return mdb_pack_row3(table, row_buffer, num_fields, fields); |
479 | 2.53k | } else { |
480 | 2.53k | return mdb_pack_row4(table, row_buffer, num_fields, fields); |
481 | 2.53k | } |
482 | 3.92k | } |
483 | | int |
484 | | mdb_pg_get_freespace(MdbHandle *mdb) |
485 | 13.8k | { |
486 | 13.8k | int rows, free_start, free_end; |
487 | 13.8k | int row_count_offset = mdb->fmt->row_count_offset; |
488 | | |
489 | 13.8k | rows = mdb_get_int16(mdb->pg_buf, row_count_offset); |
490 | 13.8k | free_start = row_count_offset + 2 + (rows * 2); |
491 | 13.8k | free_end = mdb_get_int16(mdb->pg_buf, row_count_offset + (rows * 2)); |
492 | 13.8k | mdb_debug(MDB_DEBUG_WRITE,"free space left on page = %d", free_end - free_start); |
493 | 13.8k | return (free_end - free_start); |
494 | 13.8k | } |
495 | | void * |
496 | | mdb_new_leaf_pg(MdbCatalogEntry *entry) |
497 | 0 | { |
498 | 0 | MdbHandle *mdb = entry->mdb; |
499 | 0 | void *new_pg = g_malloc0(mdb->fmt->pg_size); |
500 | | |
501 | 0 | mdb_put_int16(new_pg, 0, 0x0104); |
502 | 0 | mdb_put_int32(new_pg, 4, entry->table_pg); |
503 | | |
504 | 0 | return new_pg; |
505 | 0 | } |
506 | | void * |
507 | | mdb_new_data_pg(MdbCatalogEntry *entry) |
508 | 1.82k | { |
509 | 1.82k | MdbFormatConstants *fmt = entry->mdb->fmt; |
510 | 1.82k | void *new_pg = g_malloc0(fmt->pg_size); |
511 | | |
512 | 1.82k | mdb_put_int16(new_pg, 0, 0x0101); |
513 | 1.82k | mdb_put_int16(new_pg, 2, fmt->pg_size - fmt->row_count_offset - 2); |
514 | 1.82k | mdb_put_int32(new_pg, 4, entry->table_pg); |
515 | | |
516 | 1.82k | return new_pg; |
517 | 1.82k | } |
518 | | |
519 | | /* could be static */ |
520 | | int |
521 | | mdb_update_indexes(MdbTableDef *table, int num_fields, MdbField *fields, guint32 pgnum, guint16 rownum) |
522 | 50 | { |
523 | 50 | unsigned int i; |
524 | 50 | MdbIndex *idx; |
525 | | |
526 | 50 | for (i=0;i<table->num_idxs;i++) { |
527 | 0 | idx = g_ptr_array_index (table->indices, i); |
528 | 0 | mdb_debug(MDB_DEBUG_WRITE,"Updating %s (%d).", idx->name, idx->index_type); |
529 | 0 | if (idx->index_type==1) { |
530 | 0 | mdb_update_index(table, idx, num_fields, fields, pgnum, rownum); |
531 | 0 | } |
532 | 0 | } |
533 | 50 | return 1; |
534 | 50 | } |
535 | | |
536 | | int |
537 | | mdb_init_index_chain(MdbTableDef *table, MdbIndex *idx) |
538 | 0 | { |
539 | 0 | MdbCatalogEntry *entry = table->entry; |
540 | 0 | MdbHandle *mdb = entry->mdb; |
541 | |
|
542 | 0 | table->scan_idx = idx; |
543 | 0 | table->chain = g_malloc0(sizeof(MdbIndexChain)); |
544 | 0 | table->mdbidx = mdb_clone_handle(mdb); |
545 | 0 | mdb_read_pg(table->mdbidx, table->scan_idx->first_pg); |
546 | |
|
547 | 0 | return 1; |
548 | 0 | } |
549 | | |
550 | | /* could be static */ |
551 | | int |
552 | | mdb_update_index(MdbTableDef *table, MdbIndex *idx, unsigned int num_fields, MdbField *fields, guint32 pgnum, guint16 rownum) |
553 | 0 | { |
554 | 0 | MdbCatalogEntry *entry = table->entry; |
555 | 0 | MdbHandle *mdb = entry->mdb; |
556 | | /*int idx_xref[16];*/ |
557 | 0 | unsigned int i, j; |
558 | 0 | MdbIndexChain *chain; |
559 | 0 | MdbField idx_fields[10]; |
560 | |
|
561 | 0 | for (i = 0; i < idx->num_keys; i++) { |
562 | 0 | for (j = 0; j < num_fields; j++) { |
563 | | // key_col_num is 1 based, can't remember why though |
564 | 0 | if (fields[j].colnum == idx->key_col_num[i]-1) { |
565 | | /* idx_xref[i] = j; */ |
566 | 0 | idx_fields[i] = fields[j]; |
567 | 0 | } |
568 | 0 | } |
569 | 0 | } |
570 | | /* |
571 | | for (i = 0; i < idx->num_keys; i++) { |
572 | | fprintf(stdout, "key col %d (%d) is mapped to field %d (%d %d)\n", |
573 | | i, idx->key_col_num[i], idx_xref[i], fields[idx_xref[i]].colnum, |
574 | | fields[idx_xref[i]].siz); |
575 | | } |
576 | | for (i = 0; i < num_fields; i++) { |
577 | | fprintf(stdout, "%d (%d %d)\n", |
578 | | i, fields[i].colnum, |
579 | | fields[i].siz); |
580 | | } |
581 | | */ |
582 | |
|
583 | 0 | chain = g_malloc0(sizeof(MdbIndexChain)); |
584 | |
|
585 | 0 | mdb_index_find_row(mdb, idx, chain, pgnum, rownum); |
586 | | //printf("chain depth = %d\n", chain->cur_depth); |
587 | | //printf("pg = %" G_GUINT32_FORMAT "\n", |
588 | | //chain->pages[chain->cur_depth-1].pg); |
589 | | //mdb_copy_index_pg(table, idx, &chain->pages[chain->cur_depth-1]); |
590 | 0 | mdb_add_row_to_leaf_pg(table, idx, &chain->pages[chain->cur_depth-1], idx_fields, pgnum, rownum); |
591 | | |
592 | 0 | return 1; |
593 | 0 | } |
594 | | |
595 | | int |
596 | | mdb_insert_row(MdbTableDef *table, int num_fields, MdbField *fields) |
597 | 388 | { |
598 | 388 | int new_row_size; |
599 | 388 | unsigned char row_buffer[4096]; |
600 | 388 | MdbCatalogEntry *entry = table->entry; |
601 | 388 | MdbHandle *mdb = entry->mdb; |
602 | 388 | MdbFormatConstants *fmt = mdb->fmt; |
603 | 388 | gint32 pgnum; |
604 | 388 | guint16 rownum; |
605 | | |
606 | 388 | if (!mdb->f->writable) { |
607 | 0 | fprintf(stderr, "File is not open for writing\n"); |
608 | 0 | return 0; |
609 | 0 | } |
610 | 388 | new_row_size = mdb_pack_row(table, row_buffer, num_fields, fields); |
611 | 388 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
612 | 0 | mdb_buffer_dump(row_buffer, 0, new_row_size); |
613 | 0 | } |
614 | 388 | pgnum = mdb_map_find_next_freepage(table, new_row_size); |
615 | 388 | if (!pgnum || pgnum == -1) { |
616 | 336 | fprintf(stderr, "Unable to allocate new page.\n"); |
617 | 336 | return 0; |
618 | 336 | } |
619 | | |
620 | 52 | rownum = mdb_add_row_to_pg(table, row_buffer, new_row_size); |
621 | | |
622 | 52 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
623 | 0 | mdb_buffer_dump(mdb->pg_buf, 0, 40); |
624 | 0 | mdb_buffer_dump(mdb->pg_buf, fmt->pg_size - 160, 160); |
625 | 0 | } |
626 | 52 | mdb_debug(MDB_DEBUG_WRITE, "writing page %d", pgnum); |
627 | 52 | if (!mdb_write_pg(mdb, pgnum)) { |
628 | 2 | fprintf(stderr, "write failed!\n"); |
629 | 2 | return 0; |
630 | 2 | } |
631 | | |
632 | 50 | mdb_update_indexes(table, num_fields, fields, pgnum, rownum); |
633 | | |
634 | 50 | return 1; |
635 | 52 | } |
636 | | /* |
637 | | * Assumes caller has verfied space is available on page and adds the new |
638 | | * row to the current pg_buf. |
639 | | */ |
640 | | guint16 |
641 | | mdb_add_row_to_pg(MdbTableDef *table, unsigned char *row_buffer, int new_row_size) |
642 | 3.59k | { |
643 | 3.59k | void *new_pg; |
644 | 3.59k | int num_rows, i, pos, row_start; |
645 | 3.59k | size_t row_size; |
646 | 3.59k | MdbCatalogEntry *entry = table->entry; |
647 | 3.59k | MdbHandle *mdb = entry->mdb; |
648 | 3.59k | MdbFormatConstants *fmt = mdb->fmt; |
649 | | |
650 | 3.59k | if (table->is_temp_table) { |
651 | 3.54k | GPtrArray *pages = table->temp_table_pages; |
652 | 3.54k | if (pages->len == 0) { |
653 | 1.77k | new_pg = mdb_new_data_pg(entry); |
654 | 1.77k | g_ptr_array_add(pages, new_pg); |
655 | 1.77k | } else { |
656 | 1.77k | new_pg = g_ptr_array_index(pages, pages->len - 1); |
657 | 1.77k | if (mdb_get_int16(new_pg, 2) < new_row_size + 2) { |
658 | 0 | new_pg = mdb_new_data_pg(entry); |
659 | 0 | g_ptr_array_add(pages, new_pg); |
660 | 0 | } |
661 | 1.77k | } |
662 | | |
663 | 3.54k | num_rows = mdb_get_int16(new_pg, fmt->row_count_offset); |
664 | 3.54k | pos = (num_rows == 0) ? fmt->pg_size : |
665 | 3.54k | mdb_get_int16(new_pg, fmt->row_count_offset + (num_rows*2)); |
666 | 3.54k | } else { /* is not a temp table */ |
667 | 52 | new_pg = mdb_new_data_pg(entry); |
668 | | |
669 | 52 | num_rows = mdb_get_int16(mdb->pg_buf, fmt->row_count_offset); |
670 | 52 | pos = fmt->pg_size; |
671 | | |
672 | | /* copy existing rows */ |
673 | 440 | for (i=0;i<num_rows;i++) { |
674 | 388 | mdb_find_row(mdb, i, &row_start, &row_size); |
675 | 388 | pos -= row_size; |
676 | 388 | memcpy((char*)new_pg + pos, mdb->pg_buf + row_start, row_size); |
677 | 388 | mdb_put_int16(new_pg, (fmt->row_count_offset + 2) + (i*2), pos); |
678 | 388 | } |
679 | 52 | } |
680 | | |
681 | | /* add our new row */ |
682 | 3.59k | pos -= new_row_size; |
683 | 3.59k | memcpy((char*)new_pg + pos, row_buffer, new_row_size); |
684 | | /* add row to the row offset table */ |
685 | 3.59k | mdb_put_int16(new_pg, (fmt->row_count_offset + 2) + (num_rows*2), pos); |
686 | | |
687 | | /* update number rows on this page */ |
688 | 3.59k | num_rows++; |
689 | 3.59k | mdb_put_int16(new_pg, fmt->row_count_offset, num_rows); |
690 | | |
691 | | /* update the freespace */ |
692 | 3.59k | mdb_put_int16(new_pg,2,pos - fmt->row_count_offset - 2 - (num_rows*2)); |
693 | | |
694 | | /* copy new page over old */ |
695 | 3.59k | if (!table->is_temp_table) { |
696 | 52 | memcpy(mdb->pg_buf, new_pg, fmt->pg_size); |
697 | 52 | g_free(new_pg); |
698 | 52 | } |
699 | | |
700 | 3.59k | return num_rows; |
701 | 3.59k | } |
702 | | int |
703 | | mdb_update_row(MdbTableDef *table) |
704 | 0 | { |
705 | 0 | int row_start, row_end; |
706 | 0 | unsigned int i; |
707 | 0 | MdbColumn *col; |
708 | 0 | MdbCatalogEntry *entry = table->entry; |
709 | 0 | MdbHandle *mdb = entry->mdb; |
710 | 0 | MdbField fields[256]; |
711 | 0 | unsigned char row_buffer[4096]; |
712 | 0 | size_t old_row_size, new_row_size; |
713 | 0 | int num_fields; |
714 | |
|
715 | 0 | if (!mdb->f->writable) { |
716 | 0 | fprintf(stderr, "File is not open for writing\n"); |
717 | 0 | return 0; |
718 | 0 | } |
719 | 0 | if (table->cur_phys_pg && mdb->cur_pg != table->cur_phys_pg) { |
720 | | /* the row was reached through an overflow pointer, so the page |
721 | | * buffer does not hold the table's data page */ |
722 | 0 | fprintf(stderr, "Updating a row stored on an overflow page is not supported\n"); |
723 | 0 | return 0; |
724 | 0 | } |
725 | 0 | mdb_find_row(mdb, table->cur_row-1, &row_start, &old_row_size); |
726 | 0 | row_end = row_start + old_row_size - 1; |
727 | |
|
728 | 0 | row_start &= 0x0FFF; /* remove flags */ |
729 | |
|
730 | 0 | mdb_debug(MDB_DEBUG_WRITE,"page %lu row %d start %d end %d", (unsigned long) table->cur_phys_pg, table->cur_row-1, row_start, row_end); |
731 | 0 | if (mdb_get_option(MDB_DEBUG_LIKE)) |
732 | 0 | mdb_buffer_dump(mdb->pg_buf, row_start, old_row_size); |
733 | |
|
734 | 0 | for (i=0;i<table->num_cols;i++) { |
735 | 0 | col = g_ptr_array_index(table->columns,i); |
736 | 0 | if (col->bind_ptr && mdb_is_col_indexed(table,i)) { |
737 | 0 | fprintf(stderr, "Attempting to update column that is part of an index\n"); |
738 | 0 | return 0; |
739 | 0 | } |
740 | 0 | } |
741 | 0 | num_fields = mdb_crack_row(table, row_start, old_row_size, fields); |
742 | 0 | if (num_fields == -1) { |
743 | 0 | fprintf(stderr, "Invalid row buffer, update will not occur\n"); |
744 | 0 | return 0; |
745 | 0 | } |
746 | | |
747 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
748 | | /* |
749 | | for (i=0;i<num_fields;i++) { |
750 | | printf("col %d %d start %d siz %d fixed 5d\n", i, fields[i].colnum, fields[i].start, fields[i].siz, fields[i].is_fixed); |
751 | | } */ |
752 | 0 | } |
753 | 0 | for (i=0;i<table->num_cols;i++) { |
754 | 0 | col = g_ptr_array_index(table->columns,i); |
755 | 0 | if (col->bind_ptr) { |
756 | 0 | fields[i].value = col->bind_ptr; |
757 | 0 | fields[i].siz = *(col->len_ptr); |
758 | 0 | } |
759 | 0 | } |
760 | |
|
761 | 0 | new_row_size = mdb_pack_row(table, row_buffer, num_fields, fields); |
762 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) |
763 | 0 | mdb_buffer_dump(row_buffer, 0, new_row_size); |
764 | 0 | if (new_row_size > (old_row_size + mdb_pg_get_freespace(mdb))) { |
765 | 0 | fprintf(stderr, "No space left on this page, update will not occur\n"); |
766 | 0 | return 0; |
767 | 0 | } |
768 | | /* do it! */ |
769 | 0 | mdb_replace_row(table, table->cur_row-1, row_buffer, new_row_size); |
770 | 0 | return 0; /* FIXME */ |
771 | 0 | } |
772 | | |
773 | | /** |
774 | | * \warning the return code is opposite to convention used elsewhere: |
775 | | * @return: |
776 | | * - 0 on success |
777 | | * - 1 on failure |
778 | | * \note This might change on next ABI break. |
779 | | */ |
780 | | int |
781 | | mdb_replace_row(MdbTableDef *table, int row, void *new_row, int new_row_size) |
782 | 0 | { |
783 | 0 | MdbCatalogEntry *entry = table->entry; |
784 | 0 | MdbHandle *mdb = entry->mdb; |
785 | 0 | int pg_size = mdb->fmt->pg_size; |
786 | 0 | int rco = mdb->fmt->row_count_offset; |
787 | 0 | void *new_pg; |
788 | 0 | guint16 num_rows; |
789 | 0 | int row_start; |
790 | 0 | size_t row_size; |
791 | 0 | int i, pos; |
792 | |
|
793 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
794 | 0 | mdb_buffer_dump(mdb->pg_buf, 0, 40); |
795 | 0 | mdb_buffer_dump(mdb->pg_buf, pg_size - 160, 160); |
796 | 0 | } |
797 | 0 | mdb_debug(MDB_DEBUG_WRITE,"updating row %d on page %lu", row, (unsigned long) table->cur_phys_pg); |
798 | 0 | new_pg = mdb_new_data_pg(entry); |
799 | |
|
800 | 0 | num_rows = mdb_get_int16(mdb->pg_buf, rco); |
801 | 0 | mdb_put_int16(new_pg, rco, num_rows); |
802 | |
|
803 | 0 | pos = pg_size; |
804 | | |
805 | | /* rows before */ |
806 | 0 | for (i=0;i<row;i++) { |
807 | 0 | mdb_find_row(mdb, i, &row_start, &row_size); |
808 | 0 | pos -= row_size; |
809 | 0 | memcpy((char*)new_pg + pos, mdb->pg_buf + row_start, row_size); |
810 | 0 | mdb_put_int16(new_pg, rco + 2 + i*2, pos); |
811 | 0 | } |
812 | | |
813 | | /* our row */ |
814 | 0 | pos -= new_row_size; |
815 | 0 | memcpy((char*)new_pg + pos, new_row, new_row_size); |
816 | 0 | mdb_put_int16(new_pg, rco + 2 + row*2, pos); |
817 | | |
818 | | /* rows after */ |
819 | 0 | for (i=row+1;i<num_rows;i++) { |
820 | 0 | mdb_find_row(mdb, i, &row_start, &row_size); |
821 | 0 | pos -= row_size; |
822 | 0 | memcpy((char*)new_pg + pos, mdb->pg_buf + row_start, row_size); |
823 | 0 | mdb_put_int16(new_pg, rco + 2 + i*2, pos); |
824 | 0 | } |
825 | | |
826 | | /* almost done, copy page over current */ |
827 | 0 | memcpy(mdb->pg_buf, new_pg, pg_size); |
828 | |
|
829 | 0 | g_free(new_pg); |
830 | |
|
831 | 0 | mdb_put_int16(mdb->pg_buf, 2, mdb_pg_get_freespace(mdb)); |
832 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
833 | 0 | mdb_buffer_dump(mdb->pg_buf, 0, 40); |
834 | 0 | mdb_buffer_dump(mdb->pg_buf, pg_size - 160, 160); |
835 | 0 | } |
836 | | /* drum roll, please */ |
837 | 0 | if (!mdb_write_pg(mdb, table->cur_phys_pg)) { |
838 | 0 | fprintf(stderr, "write failed!\n"); |
839 | 0 | return 1; |
840 | 0 | } |
841 | 0 | return 0; |
842 | 0 | } |
843 | | static int |
844 | | mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg, MdbField *idx_fields, guint32 pgnum, guint16 rownum) |
845 | | /*, guint32 pgnum, guint16 rownum) |
846 | | static int |
847 | | mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg) |
848 | | */ |
849 | 0 | { |
850 | 0 | MdbCatalogEntry *entry = table->entry; |
851 | 0 | MdbHandle *mdb = entry->mdb; |
852 | 0 | MdbColumn *col; |
853 | 0 | guint32 pg_row; |
854 | 0 | guint16 row = 0; |
855 | 0 | void *new_pg; |
856 | 0 | unsigned char key_hash[256]; |
857 | 0 | int keycol; |
858 | |
|
859 | 0 | new_pg = mdb_new_leaf_pg(entry); |
860 | | |
861 | | /* reinitial ipg pointers to start of page */ |
862 | 0 | mdb_index_page_reset(mdb, ipg); |
863 | 0 | mdb_read_pg(mdb, ipg->pg); |
864 | | |
865 | | /* do we support this index type yet? */ |
866 | 0 | if (idx->num_keys > 1) { |
867 | 0 | fprintf(stderr,"multikey indexes not yet supported, aborting\n"); |
868 | 0 | return 0; |
869 | 0 | } |
870 | 0 | keycol = idx->key_col_num[0]; |
871 | 0 | col = g_ptr_array_index (table->columns, keycol - 1); |
872 | 0 | if (!col->is_fixed) { |
873 | 0 | fprintf(stderr,"variable length key columns not yet supported, aborting\n"); |
874 | 0 | return 0; |
875 | 0 | } |
876 | | |
877 | 0 | while (mdb_index_find_next_on_page(mdb, ipg)) { |
878 | | |
879 | | /* check for compressed indexes. */ |
880 | 0 | if (ipg->len < col->col_size + 1) { |
881 | 0 | fprintf(stderr,"compressed indexes not yet supported, aborting\n"); |
882 | 0 | return 0; |
883 | 0 | } |
884 | | |
885 | 0 | pg_row = mdb_get_int32_msb(mdb->pg_buf, ipg->offset + ipg->len - 4); |
886 | | /* guint32 pg = pg_row >> 8; */ |
887 | 0 | row = pg_row & 0xff; |
888 | | /* unsigned char iflag = mdb->pg_buf[ipg->offset]; */ |
889 | | |
890 | | /* turn the key hash back into a value */ |
891 | 0 | mdb_index_swap_n(&mdb->pg_buf[ipg->offset + 1], col->col_size, key_hash); |
892 | 0 | key_hash[col->col_size - 1] &= 0x7f; |
893 | |
|
894 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
895 | 0 | mdb_buffer_dump(mdb->pg_buf, ipg->offset, ipg->len); |
896 | 0 | mdb_buffer_dump(mdb->pg_buf, ipg->offset + 1, col->col_size); |
897 | 0 | mdb_buffer_dump(key_hash, 0, col->col_size); |
898 | 0 | } |
899 | |
|
900 | 0 | memcpy((char*)new_pg + ipg->offset, mdb->pg_buf + ipg->offset, ipg->len); |
901 | 0 | ipg->offset += ipg->len; |
902 | 0 | ipg->len = 0; |
903 | |
|
904 | 0 | row++; |
905 | 0 | } |
906 | | |
907 | 0 | if (!row) { |
908 | 0 | fprintf(stderr,"missing indexes not yet supported, aborting\n"); |
909 | 0 | return 0; |
910 | 0 | } |
911 | | //mdb_put_int16(new_pg, mdb->fmt->row_count_offset, row); |
912 | | /* free space left */ |
913 | 0 | mdb_put_int16(new_pg, 2, mdb->fmt->pg_size - ipg->offset); |
914 | | //printf("offset = %d\n", ipg->offset); |
915 | |
|
916 | 0 | mdb_index_swap_n(idx_fields[0].value, col->col_size, key_hash); |
917 | 0 | key_hash[0] |= 0x080; |
918 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
919 | 0 | printf("key_hash\n"); |
920 | 0 | mdb_buffer_dump(idx_fields[0].value, 0, col->col_size); |
921 | 0 | mdb_buffer_dump(key_hash, 0, col->col_size); |
922 | 0 | printf("--------\n"); |
923 | 0 | } |
924 | 0 | ((char *)new_pg)[ipg->offset] = 0x7f; |
925 | 0 | memcpy((char*)new_pg + ipg->offset + 1, key_hash, col->col_size); |
926 | 0 | pg_row = (pgnum << 8) | ((rownum-1) & 0xff); |
927 | 0 | mdb_put_int32_msb(new_pg, ipg->offset + 5, pg_row); |
928 | 0 | ipg->idx_starts[row++] = ipg->offset + ipg->len; |
929 | | //ipg->idx_starts[row] = ipg->offset + ipg->len; |
930 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
931 | 0 | mdb_buffer_dump(mdb->pg_buf, 0, mdb->fmt->pg_size); |
932 | 0 | } |
933 | 0 | memcpy(mdb->pg_buf, new_pg, mdb->fmt->pg_size); |
934 | 0 | mdb_index_pack_bitmap(mdb, ipg); |
935 | 0 | if (mdb_get_option(MDB_DEBUG_WRITE)) { |
936 | 0 | mdb_buffer_dump(mdb->pg_buf, 0, mdb->fmt->pg_size); |
937 | 0 | } |
938 | 0 | g_free(new_pg); |
939 | |
|
940 | 0 | return ipg->len; |
941 | 0 | } |