Coverage Report

Created: 2026-11-11 06:16

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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
}