← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/heap/hp_write.cc

  • Committer: Brian Aker
  • Date: 2010-02-10 18:04:24 UTC
  • mfrom: (1286.1.5 build)
  • Revision ID: brian@gaz-20100210180424-03ypoyifmlc2lgcp
Merge of Brian/Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/heap/hp_write.cc
15
15
 
16
16
/* Write a record to heap-databas */
17
17
 
18
 
#include "heapdef.h"
 
18
#include "heap_priv.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
30
static HASH_INFO *hp_find_free_hash(HP_SHARE *info, HP_BLOCK *block,
29
31
                                     uint32_t records);
30
32
 
31
 
int heap_write(HP_INFO *info, const uchar *record)
 
33
int heap_write(HP_INFO *info, const unsigned char *record)
32
34
{
33
35
  HP_KEYDEF *keydef, *end;
34
 
  uchar *pos;
 
36
  unsigned char *pos;
35
37
  HP_SHARE *share=info->s;
36
 
  uint rec_length, chunk_count;
 
38
  uint32_t rec_length, chunk_count;
37
39
 
38
40
  if ((share->records >= share->max_records && share->max_records) ||
39
41
    (share->recordspace.total_data_length + share->index_length >= share->max_table_size))
40
42
  {
41
 
    return(my_errno=HA_ERR_RECORD_FILE_FULL);
 
43
    return(errno=HA_ERR_RECORD_FILE_FULL);
42
44
  }
43
45
 
44
46
  rec_length = hp_get_encoded_data_length(share, record, &chunk_count);
45
47
 
46
48
  if (!(pos=hp_allocate_chunkset(&share->recordspace, chunk_count)))
47
 
    return(my_errno);
 
49
    return(errno);
48
50
  share->changed=1;
49
51
 
50
52
  for (keydef = share->keydef, end = keydef + share->keys; keydef < end;
74
76
    either.  Otherwise for HASH index on HA_ERR_FOUND_DUPP_KEY the key
75
77
    was inserted and we have to delete it.
76
78
  */
77
 
  if (keydef->algorithm == HA_KEY_ALG_BTREE || my_errno == ENOMEM)
 
79
  if (keydef->algorithm == HA_KEY_ALG_BTREE || errno == ENOMEM)
78
80
  {
79
81
    keydef--;
80
82
  }
83
85
    if ((*keydef->delete_key)(info, keydef, record, pos, 0))
84
86
      break;
85
87
    keydef--;
86
 
  } 
 
88
  }
87
89
 
88
90
  hp_free_chunks(&share->recordspace, pos);
89
91
 
90
 
  return(my_errno);
 
92
  return(errno);
91
93
} /* heap_write */
92
94
 
93
 
/* 
94
 
  Write a key to rb_tree-index 
 
95
/*
 
96
  Write a key to rb_tree-index
95
97
*/
96
98
 
97
 
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const uchar *record, 
98
 
                    uchar *recpos)
 
99
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const unsigned char *record,
 
100
                    unsigned char *recpos)
99
101
{
100
102
  heap_rb_param custom_arg;
101
 
  uint old_allocated;
 
103
  uint32_t old_allocated;
102
104
 
103
105
  custom_arg.keyseg= keyinfo->seg;
104
106
  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
116
118
  if (!tree_insert(&keyinfo->rb_tree, (void*)info->recbuf,
117
119
                   custom_arg.key_length, &custom_arg))
118
120
  {
119
 
    my_errno= HA_ERR_FOUND_DUPP_KEY;
 
121
    errno= HA_ERR_FOUND_DUPP_KEY;
120
122
    return 1;
121
123
  }
122
124
  info->s->index_length+= (keyinfo->rb_tree.allocated-old_allocated);
129
131
    info     Heap table info
130
132
    keyinfo  Key info
131
133
    record   Table record to added
132
 
    recpos   Memory buffer where the table record will be stored if added 
 
134
    recpos   Memory buffer where the table record will be stored if added
133
135
             successfully
134
136
  NOTE
135
 
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO 
 
137
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO
136
138
    structs. Array size == number of entries in hash index.
137
139
    hp_mask(hp_rec_hashnr()) maps hash entries values to hash array positions.
138
140
    If there are several hash entries with the same hash array position P,
139
 
    they are connected in a linked list via HASH_INFO::next_key. The first 
140
 
    list element is located at position P, next elements are located at 
 
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
141
143
    positions for which there is no record that should be located at that
142
144
    position. The order of elements in the list is arbitrary.
143
145
 
144
146
  RETURN
145
147
    0  - OK
146
148
    -1 - Out of memory
147
 
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was 
 
149
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was
148
150
    still added and the caller must call hp_delete_key for it.
149
151
*/
150
152
 
151
153
int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
152
 
                 const uchar *record, uchar *recpos)
 
154
                 const unsigned char *record, unsigned char *recpos)
153
155
{
154
156
  HP_SHARE *share = info->s;
155
157
  int flag;
156
158
  uint32_t halfbuff,hashnr,first_index;
157
 
  uchar *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
 
159
  unsigned char *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
158
160
  HASH_INFO *empty, *gpos= NULL, *gpos2= NULL, *pos;
159
161
 
160
162
  flag=0;
162
164
    return(-1);                         /* No more memory */
163
165
  halfbuff= (long) share->blength >> 1;
164
166
  pos= hp_find_hash(&keyinfo->block,(first_index=share->records-halfbuff));
165
 
  
 
167
 
166
168
  /*
167
169
    We're about to add one more hash array position, with hash_mask=#records.
168
 
    The number of hash positions will change and some entries might need to 
169
 
    be relocated to the newly added position. Those entries are currently 
170
 
    members of the list that starts at #first_index position (this is 
 
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
171
173
    guaranteed by properties of hp_mask(hp_rec_hashnr(X)) mapping function)
172
174
    At #first_index position currently there may be either:
173
175
    a) An entry with hashnr != first_index. We don't need to move it.
174
176
    or
175
177
    b) A list of items with hash_mask=first_index. The list contains entries
176
178
       of 2 types:
177
 
       1) entries that should be relocated to the list that starts at new 
 
179
       1) entries that should be relocated to the list that starts at new
178
180
          position we're adding ('uppper' list)
179
 
       2) entries that should be left in the list starting at #first_index 
 
181
       2) entries that should be left in the list starting at #first_index
180
182
          position ('lower' list)
181
183
  */
182
184
  if (pos != empty)                             /* If some records */
186
188
      hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);
187
189
      if (flag == 0)
188
190
      {
189
 
        /* 
190
 
          First loop, bail out if we're dealing with case a) from above 
 
191
        /*
 
192
          First loop, bail out if we're dealing with case a) from above
191
193
          comment
192
194
        */
193
195
        if (hp_mask(hashnr, share->blength, share->records) != first_index)
205
207
        ptr_to_rec2 - same for upper list.
206
208
      */
207
209
      if (!(hashnr & halfbuff))
208
 
      {                                         
 
210
      {
209
211
        /* Key should be put into 'lower' list */
210
212
        if (!(flag & LOWFIND))
211
213
        {
221
223
          else
222
224
          {
223
225
            /*
224
 
              We can only get here at first iteration: key is at 'lower' 
 
226
              We can only get here at first iteration: key is at 'lower'
225
227
              position pos and should be left here.
226
228
            */
227
229
            flag=LOWFIND | LOWUSED;
269
271
      }
270
272
    }
271
273
    while ((pos=pos->next_key));
272
 
    
 
274
 
273
275
    if ((flag & (LOWFIND | HIGHFIND)) == (LOWFIND | HIGHFIND))
274
276
    {
275
277
      /*
330
332
      {
331
333
        if (! hp_rec_key_cmp(keyinfo, record, pos->ptr_to_rec, 1))
332
334
        {
333
 
          return(my_errno=HA_ERR_FOUND_DUPP_KEY);
 
335
          return(errno=HA_ERR_FOUND_DUPP_KEY);
334
336
        }
335
337
      } while ((pos=pos->next_key));
336
338
    }
343
345
static HASH_INFO *hp_find_free_hash(HP_SHARE *info,
344
346
                                     HP_BLOCK *block, uint32_t records)
345
347
{
346
 
  uint block_pos;
 
348
  uint32_t block_pos;
347
349
  size_t length;
348
350
 
349
351
  if (records < block->last_allocated)
355
357
    info->index_length+=length;
356
358
  }
357
359
  block->last_allocated=records+1;
358
 
  return((HASH_INFO*) ((uchar*) block->level_info[0].last_blocks+
 
360
  return((HASH_INFO*) ((unsigned char*) block->level_info[0].last_blocks+
359
361
                       block_pos*block->recbuffer));
360
362
}