← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/hp_write.c

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/hp_write.c
15
15
 
16
16
/* Write a record to heap-databas */
17
17
 
18
 
#include "heap_priv.h"
 
18
#include "heapdef.h"
19
19
#ifdef __WIN__
20
20
#include <fcntl.h>
21
21
#endif
25
25
#define HIGHFIND 4
26
26
#define HIGHUSED 8
27
27
 
28
 
using namespace drizzled;
29
 
 
 
28
static uchar *next_free_record_pos(HP_SHARE *info);
30
29
static HASH_INFO *hp_find_free_hash(HP_SHARE *info, HP_BLOCK *block,
31
 
                                     uint32_t records);
 
30
                                     ulong records);
32
31
 
33
 
int heap_write(HP_INFO *info, const unsigned char *record)
 
32
int heap_write(HP_INFO *info, const uchar *record)
34
33
{
35
34
  HP_KEYDEF *keydef, *end;
36
 
  unsigned char *pos;
 
35
  uchar *pos;
37
36
  HP_SHARE *share=info->s;
38
 
  uint32_t rec_length, chunk_count;
39
 
 
40
 
  if ((share->records >= share->max_records && share->max_records) ||
41
 
    (share->recordspace.total_data_length + share->index_length >= share->max_table_size))
 
37
  DBUG_ENTER("heap_write");
 
38
#ifndef DBUG_OFF
 
39
  if (info->mode & O_RDONLY)
42
40
  {
43
 
    return(errno=HA_ERR_RECORD_FILE_FULL);
 
41
    DBUG_RETURN(my_errno=EACCES);
44
42
  }
45
 
 
46
 
  rec_length = hp_get_encoded_data_length(share, record, &chunk_count);
47
 
 
48
 
  if (!(pos=hp_allocate_chunkset(&share->recordspace, chunk_count)))
49
 
    return(errno);
 
43
#endif
 
44
  if (!(pos=next_free_record_pos(share)))
 
45
    DBUG_RETURN(my_errno);
50
46
  share->changed=1;
51
47
 
52
48
  for (keydef = share->keydef, end = keydef + share->keys; keydef < end;
56
52
      goto err;
57
53
  }
58
54
 
59
 
  hp_copy_record_data_to_chunkset(share, record, pos);
60
 
 
 
55
  memcpy(pos,record,(size_t) share->reclength);
 
56
  pos[share->reclength]=1;              /* Mark record as not deleted */
61
57
  if (++share->records == share->blength)
62
58
    share->blength+= share->blength;
63
 
 
64
59
  info->current_ptr=pos;
65
60
  info->current_hash_ptr=0;
66
61
  info->update|=HA_STATE_AKTIV;
 
62
#if !defined(DBUG_OFF) && defined(EXTRA_HEAP_DEBUG)
 
63
  DBUG_EXECUTE("check_heap",heap_check_heap(info, 0););
 
64
#endif
67
65
  if (share->auto_key)
68
66
    heap_update_auto_increment(info, record);
69
 
  return(0);
 
67
  DBUG_RETURN(0);
70
68
 
71
69
err:
 
70
  if (my_errno == HA_ERR_FOUND_DUPP_KEY)
 
71
    DBUG_PRINT("info",("Duplicate key: %d", (int) (keydef - share->keydef)));
72
72
  info->errkey= keydef - share->keydef;
73
73
  /*
74
74
    We don't need to delete non-inserted key from rb-tree.  Also, if
76
76
    either.  Otherwise for HASH index on HA_ERR_FOUND_DUPP_KEY the key
77
77
    was inserted and we have to delete it.
78
78
  */
79
 
  if (keydef->algorithm == HA_KEY_ALG_BTREE || errno == ENOMEM)
 
79
  if (keydef->algorithm == HA_KEY_ALG_BTREE || my_errno == ENOMEM)
80
80
  {
81
81
    keydef--;
82
82
  }
85
85
    if ((*keydef->delete_key)(info, keydef, record, pos, 0))
86
86
      break;
87
87
    keydef--;
88
 
  }
89
 
 
90
 
  hp_free_chunks(&share->recordspace, pos);
91
 
 
92
 
  return(errno);
 
88
  } 
 
89
 
 
90
  share->deleted++;
 
91
  *((uchar**) pos)=share->del_link;
 
92
  share->del_link=pos;
 
93
  pos[share->reclength]=0;                      /* Record deleted */
 
94
 
 
95
  DBUG_RETURN(my_errno);
93
96
} /* heap_write */
94
97
 
95
 
/*
96
 
  Write a key to rb_tree-index
 
98
/* 
 
99
  Write a key to rb_tree-index 
97
100
*/
98
101
 
99
 
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const unsigned char *record,
100
 
                    unsigned char *recpos)
 
102
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const uchar *record, 
 
103
                    uchar *recpos)
101
104
{
102
105
  heap_rb_param custom_arg;
103
 
  uint32_t old_allocated;
 
106
  uint old_allocated;
104
107
 
105
108
  custom_arg.keyseg= keyinfo->seg;
106
109
  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
118
121
  if (!tree_insert(&keyinfo->rb_tree, (void*)info->recbuf,
119
122
                   custom_arg.key_length, &custom_arg))
120
123
  {
121
 
    errno= HA_ERR_FOUND_DUPP_KEY;
 
124
    my_errno= HA_ERR_FOUND_DUPP_KEY;
122
125
    return 1;
123
126
  }
124
127
  info->s->index_length+= (keyinfo->rb_tree.allocated-old_allocated);
125
128
  return 0;
126
129
}
127
130
 
 
131
        /* Find where to place new record */
 
132
 
 
133
static uchar *next_free_record_pos(HP_SHARE *info)
 
134
{
 
135
  int block_pos;
 
136
  uchar *pos;
 
137
  size_t length;
 
138
  DBUG_ENTER("next_free_record_pos");
 
139
 
 
140
  if (info->del_link)
 
141
  {
 
142
    pos=info->del_link;
 
143
    info->del_link= *((uchar**) pos);
 
144
    info->deleted--;
 
145
    DBUG_PRINT("exit",("Used old position: 0x%lx",(long) pos));
 
146
    DBUG_RETURN(pos);
 
147
  }
 
148
  if (!(block_pos=(info->records % info->block.records_in_block)))
 
149
  {
 
150
    if ((info->records > info->max_records && info->max_records) ||
 
151
        (info->data_length + info->index_length >= info->max_table_size))
 
152
    {
 
153
      my_errno=HA_ERR_RECORD_FILE_FULL;
 
154
      DBUG_RETURN(NULL);
 
155
    }
 
156
    if (hp_get_new_block(&info->block,&length))
 
157
      DBUG_RETURN(NULL);
 
158
    info->data_length+=length;
 
159
  }
 
160
  DBUG_PRINT("exit",("Used new position: 0x%lx",
 
161
                     (long) ((uchar*) info->block.level_info[0].last_blocks+
 
162
                             block_pos * info->block.recbuffer)));
 
163
  DBUG_RETURN((uchar*) info->block.level_info[0].last_blocks+
 
164
              block_pos*info->block.recbuffer);
 
165
}
 
166
 
 
167
 
128
168
/*
129
169
  Write a hash-key to the hash-index
130
170
  SYNOPSIS
131
171
    info     Heap table info
132
172
    keyinfo  Key info
133
173
    record   Table record to added
134
 
    recpos   Memory buffer where the table record will be stored if added
 
174
    recpos   Memory buffer where the table record will be stored if added 
135
175
             successfully
136
176
  NOTE
137
 
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO
 
177
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO 
138
178
    structs. Array size == number of entries in hash index.
139
179
    hp_mask(hp_rec_hashnr()) maps hash entries values to hash array positions.
140
180
    If there are several hash entries with the same hash array position P,
141
 
    they are connected in a linked list via HASH_INFO::next_key. The first
142
 
    list element is located at position P, next elements are located at
 
181
    they are connected in a linked list via HASH_INFO::next_key. The first 
 
182
    list element is located at position P, next elements are located at 
143
183
    positions for which there is no record that should be located at that
144
184
    position. The order of elements in the list is arbitrary.
145
185
 
146
186
  RETURN
147
187
    0  - OK
148
188
    -1 - Out of memory
149
 
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was
 
189
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was 
150
190
    still added and the caller must call hp_delete_key for it.
151
191
*/
152
192
 
153
193
int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
154
 
                 const unsigned char *record, unsigned char *recpos)
 
194
                 const uchar *record, uchar *recpos)
155
195
{
156
196
  HP_SHARE *share = info->s;
157
197
  int flag;
158
 
  uint32_t halfbuff,hashnr,first_index;
159
 
  unsigned char *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
160
 
  HASH_INFO *empty, *gpos= NULL, *gpos2= NULL, *pos;
 
198
  ulong halfbuff,hashnr,first_index;
 
199
  uchar *ptr_to_rec,*ptr_to_rec2;
 
200
  HASH_INFO *empty,*gpos,*gpos2,*pos;
 
201
  DBUG_ENTER("hp_write_key");
161
202
 
162
203
  flag=0;
163
204
  if (!(empty= hp_find_free_hash(share,&keyinfo->block,share->records)))
164
 
    return(-1);                         /* No more memory */
 
205
    DBUG_RETURN(-1);                            /* No more memory */
165
206
  halfbuff= (long) share->blength >> 1;
166
207
  pos= hp_find_hash(&keyinfo->block,(first_index=share->records-halfbuff));
167
 
 
 
208
  
168
209
  /*
169
210
    We're about to add one more hash array position, with hash_mask=#records.
170
 
    The number of hash positions will change and some entries might need to
171
 
    be relocated to the newly added position. Those entries are currently
172
 
    members of the list that starts at #first_index position (this is
 
211
    The number of hash positions will change and some entries might need to 
 
212
    be relocated to the newly added position. Those entries are currently 
 
213
    members of the list that starts at #first_index position (this is 
173
214
    guaranteed by properties of hp_mask(hp_rec_hashnr(X)) mapping function)
174
215
    At #first_index position currently there may be either:
175
216
    a) An entry with hashnr != first_index. We don't need to move it.
176
217
    or
177
218
    b) A list of items with hash_mask=first_index. The list contains entries
178
219
       of 2 types:
179
 
       1) entries that should be relocated to the list that starts at new
 
220
       1) entries that should be relocated to the list that starts at new 
180
221
          position we're adding ('uppper' list)
181
 
       2) entries that should be left in the list starting at #first_index
 
222
       2) entries that should be left in the list starting at #first_index 
182
223
          position ('lower' list)
183
224
  */
184
225
  if (pos != empty)                             /* If some records */
188
229
      hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);
189
230
      if (flag == 0)
190
231
      {
191
 
        /*
192
 
          First loop, bail out if we're dealing with case a) from above
 
232
        /* 
 
233
          First loop, bail out if we're dealing with case a) from above 
193
234
          comment
194
235
        */
195
236
        if (hp_mask(hashnr, share->blength, share->records) != first_index)
207
248
        ptr_to_rec2 - same for upper list.
208
249
      */
209
250
      if (!(hashnr & halfbuff))
210
 
      {
 
251
      {                                         
211
252
        /* Key should be put into 'lower' list */
212
253
        if (!(flag & LOWFIND))
213
254
        {
223
264
          else
224
265
          {
225
266
            /*
226
 
              We can only get here at first iteration: key is at 'lower'
 
267
              We can only get here at first iteration: key is at 'lower' 
227
268
              position pos and should be left here.
228
269
            */
229
270
            flag=LOWFIND | LOWUSED;
271
312
      }
272
313
    }
273
314
    while ((pos=pos->next_key));
274
 
 
 
315
    
275
316
    if ((flag & (LOWFIND | HIGHFIND)) == (LOWFIND | HIGHFIND))
276
317
    {
277
318
      /*
332
373
      {
333
374
        if (! hp_rec_key_cmp(keyinfo, record, pos->ptr_to_rec, 1))
334
375
        {
335
 
          return(errno=HA_ERR_FOUND_DUPP_KEY);
 
376
          DBUG_RETURN(my_errno=HA_ERR_FOUND_DUPP_KEY);
336
377
        }
337
378
      } while ((pos=pos->next_key));
338
379
    }
339
380
  }
340
 
  return(0);
 
381
  DBUG_RETURN(0);
341
382
}
342
383
 
343
384
        /* Returns ptr to block, and allocates block if neaded */
344
385
 
345
386
static HASH_INFO *hp_find_free_hash(HP_SHARE *info,
346
 
                                     HP_BLOCK *block, uint32_t records)
 
387
                                     HP_BLOCK *block, ulong records)
347
388
{
348
 
  uint32_t block_pos;
 
389
  uint block_pos;
349
390
  size_t length;
350
391
 
351
392
  if (records < block->last_allocated)
357
398
    info->index_length+=length;
358
399
  }
359
400
  block->last_allocated=records+1;
360
 
  return((HASH_INFO*) ((unsigned char*) block->level_info[0].last_blocks+
 
401
  return((HASH_INFO*) ((uchar*) block->level_info[0].last_blocks+
361
402
                       block_pos*block->recbuffer));
362
403
}