← 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 Aker
  • Date: 2008-07-28 18:01:38 UTC
  • Revision ID: brian@tangent.org-20080728180138-q2pxlq0qiapvqsdn
Remove YEAR field type

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
static uchar *next_free_record_pos(HP_SHARE *info);
28
29
static HASH_INFO *hp_find_free_hash(HP_SHARE *info, HP_BLOCK *block,
29
 
                                     uint32_t records);
 
30
                                     ulong records);
30
31
 
31
 
int heap_write(HP_INFO *info, const unsigned char *record)
 
32
int heap_write(HP_INFO *info, const uchar *record)
32
33
{
33
34
  HP_KEYDEF *keydef, *end;
34
 
  unsigned char *pos;
 
35
  uchar *pos;
35
36
  HP_SHARE *share=info->s;
36
 
  uint32_t rec_length, chunk_count;
37
 
 
38
 
  if ((share->records >= share->max_records && share->max_records) ||
39
 
    (share->recordspace.total_data_length + share->index_length >= share->max_table_size))
40
 
  {
41
 
    return(errno=HA_ERR_RECORD_FILE_FULL);
42
 
  }
43
 
 
44
 
  rec_length = hp_get_encoded_data_length(share, record, &chunk_count);
45
 
 
46
 
  if (!(pos=hp_allocate_chunkset(&share->recordspace, chunk_count)))
47
 
    return(errno);
 
37
  if (!(pos=next_free_record_pos(share)))
 
38
    return(my_errno);
48
39
  share->changed=1;
49
40
 
50
41
  for (keydef = share->keydef, end = keydef + share->keys; keydef < end;
54
45
      goto err;
55
46
  }
56
47
 
57
 
  hp_copy_record_data_to_chunkset(share, record, pos);
58
 
 
 
48
  memcpy(pos,record,(size_t) share->reclength);
 
49
  pos[share->reclength]=1;              /* Mark record as not deleted */
59
50
  if (++share->records == share->blength)
60
51
    share->blength+= share->blength;
61
 
 
62
52
  info->current_ptr=pos;
63
53
  info->current_hash_ptr=0;
64
54
  info->update|=HA_STATE_AKTIV;
74
64
    either.  Otherwise for HASH index on HA_ERR_FOUND_DUPP_KEY the key
75
65
    was inserted and we have to delete it.
76
66
  */
77
 
  if (keydef->algorithm == HA_KEY_ALG_BTREE || errno == ENOMEM)
 
67
  if (keydef->algorithm == HA_KEY_ALG_BTREE || my_errno == ENOMEM)
78
68
  {
79
69
    keydef--;
80
70
  }
83
73
    if ((*keydef->delete_key)(info, keydef, record, pos, 0))
84
74
      break;
85
75
    keydef--;
86
 
  }
87
 
 
88
 
  hp_free_chunks(&share->recordspace, pos);
89
 
 
90
 
  return(errno);
 
76
  } 
 
77
 
 
78
  share->deleted++;
 
79
  *((uchar**) pos)=share->del_link;
 
80
  share->del_link=pos;
 
81
  pos[share->reclength]=0;                      /* Record deleted */
 
82
 
 
83
  return(my_errno);
91
84
} /* heap_write */
92
85
 
93
 
/*
94
 
  Write a key to rb_tree-index
 
86
/* 
 
87
  Write a key to rb_tree-index 
95
88
*/
96
89
 
97
 
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const unsigned char *record,
98
 
                    unsigned char *recpos)
 
90
int hp_rb_write_key(HP_INFO *info, HP_KEYDEF *keyinfo, const uchar *record, 
 
91
                    uchar *recpos)
99
92
{
100
93
  heap_rb_param custom_arg;
101
 
  uint32_t old_allocated;
 
94
  uint old_allocated;
102
95
 
103
96
  custom_arg.keyseg= keyinfo->seg;
104
97
  custom_arg.key_length= hp_rb_make_key(keyinfo, info->recbuf, record, recpos);
116
109
  if (!tree_insert(&keyinfo->rb_tree, (void*)info->recbuf,
117
110
                   custom_arg.key_length, &custom_arg))
118
111
  {
119
 
    errno= HA_ERR_FOUND_DUPP_KEY;
 
112
    my_errno= HA_ERR_FOUND_DUPP_KEY;
120
113
    return 1;
121
114
  }
122
115
  info->s->index_length+= (keyinfo->rb_tree.allocated-old_allocated);
123
116
  return 0;
124
117
}
125
118
 
 
119
        /* Find where to place new record */
 
120
 
 
121
static uchar *next_free_record_pos(HP_SHARE *info)
 
122
{
 
123
  int block_pos;
 
124
  uchar *pos;
 
125
  size_t length;
 
126
 
 
127
  if (info->del_link)
 
128
  {
 
129
    pos=info->del_link;
 
130
    info->del_link= *((uchar**) pos);
 
131
    info->deleted--;
 
132
    return(pos);
 
133
  }
 
134
  if (!(block_pos=(info->records % info->block.records_in_block)))
 
135
  {
 
136
    if ((info->records > info->max_records && info->max_records) ||
 
137
        (info->data_length + info->index_length >= info->max_table_size))
 
138
    {
 
139
      my_errno=HA_ERR_RECORD_FILE_FULL;
 
140
      return(NULL);
 
141
    }
 
142
    if (hp_get_new_block(&info->block,&length))
 
143
      return(NULL);
 
144
    info->data_length+=length;
 
145
  }
 
146
  return((uchar*) info->block.level_info[0].last_blocks+
 
147
              block_pos*info->block.recbuffer);
 
148
}
 
149
 
 
150
 
126
151
/*
127
152
  Write a hash-key to the hash-index
128
153
  SYNOPSIS
129
154
    info     Heap table info
130
155
    keyinfo  Key info
131
156
    record   Table record to added
132
 
    recpos   Memory buffer where the table record will be stored if added
 
157
    recpos   Memory buffer where the table record will be stored if added 
133
158
             successfully
134
159
  NOTE
135
 
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO
 
160
    Hash index uses HP_BLOCK structure as a 'growable array' of HASH_INFO 
136
161
    structs. Array size == number of entries in hash index.
137
162
    hp_mask(hp_rec_hashnr()) maps hash entries values to hash array positions.
138
163
    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
 
164
    they are connected in a linked list via HASH_INFO::next_key. The first 
 
165
    list element is located at position P, next elements are located at 
141
166
    positions for which there is no record that should be located at that
142
167
    position. The order of elements in the list is arbitrary.
143
168
 
144
169
  RETURN
145
170
    0  - OK
146
171
    -1 - Out of memory
147
 
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was
 
172
    HA_ERR_FOUND_DUPP_KEY - Duplicate record on unique key. The record was 
148
173
    still added and the caller must call hp_delete_key for it.
149
174
*/
150
175
 
151
176
int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
152
 
                 const unsigned char *record, unsigned char *recpos)
 
177
                 const uchar *record, uchar *recpos)
153
178
{
154
179
  HP_SHARE *share = info->s;
155
180
  int flag;
156
 
  uint32_t halfbuff,hashnr,first_index;
157
 
  unsigned char *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
 
181
  ulong halfbuff,hashnr,first_index;
 
182
  uchar *ptr_to_rec= NULL,*ptr_to_rec2= NULL;
158
183
  HASH_INFO *empty, *gpos= NULL, *gpos2= NULL, *pos;
159
184
 
160
185
  flag=0;
162
187
    return(-1);                         /* No more memory */
163
188
  halfbuff= (long) share->blength >> 1;
164
189
  pos= hp_find_hash(&keyinfo->block,(first_index=share->records-halfbuff));
165
 
 
 
190
  
166
191
  /*
167
192
    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
 
193
    The number of hash positions will change and some entries might need to 
 
194
    be relocated to the newly added position. Those entries are currently 
 
195
    members of the list that starts at #first_index position (this is 
171
196
    guaranteed by properties of hp_mask(hp_rec_hashnr(X)) mapping function)
172
197
    At #first_index position currently there may be either:
173
198
    a) An entry with hashnr != first_index. We don't need to move it.
174
199
    or
175
200
    b) A list of items with hash_mask=first_index. The list contains entries
176
201
       of 2 types:
177
 
       1) entries that should be relocated to the list that starts at new
 
202
       1) entries that should be relocated to the list that starts at new 
178
203
          position we're adding ('uppper' list)
179
 
       2) entries that should be left in the list starting at #first_index
 
204
       2) entries that should be left in the list starting at #first_index 
180
205
          position ('lower' list)
181
206
  */
182
207
  if (pos != empty)                             /* If some records */
186
211
      hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);
187
212
      if (flag == 0)
188
213
      {
189
 
        /*
190
 
          First loop, bail out if we're dealing with case a) from above
 
214
        /* 
 
215
          First loop, bail out if we're dealing with case a) from above 
191
216
          comment
192
217
        */
193
218
        if (hp_mask(hashnr, share->blength, share->records) != first_index)
205
230
        ptr_to_rec2 - same for upper list.
206
231
      */
207
232
      if (!(hashnr & halfbuff))
208
 
      {
 
233
      {                                         
209
234
        /* Key should be put into 'lower' list */
210
235
        if (!(flag & LOWFIND))
211
236
        {
221
246
          else
222
247
          {
223
248
            /*
224
 
              We can only get here at first iteration: key is at 'lower'
 
249
              We can only get here at first iteration: key is at 'lower' 
225
250
              position pos and should be left here.
226
251
            */
227
252
            flag=LOWFIND | LOWUSED;
269
294
      }
270
295
    }
271
296
    while ((pos=pos->next_key));
272
 
 
 
297
    
273
298
    if ((flag & (LOWFIND | HIGHFIND)) == (LOWFIND | HIGHFIND))
274
299
    {
275
300
      /*
330
355
      {
331
356
        if (! hp_rec_key_cmp(keyinfo, record, pos->ptr_to_rec, 1))
332
357
        {
333
 
          return(errno=HA_ERR_FOUND_DUPP_KEY);
 
358
          return(my_errno=HA_ERR_FOUND_DUPP_KEY);
334
359
        }
335
360
      } while ((pos=pos->next_key));
336
361
    }
341
366
        /* Returns ptr to block, and allocates block if neaded */
342
367
 
343
368
static HASH_INFO *hp_find_free_hash(HP_SHARE *info,
344
 
                                     HP_BLOCK *block, uint32_t records)
 
369
                                     HP_BLOCK *block, ulong records)
345
370
{
346
 
  uint32_t block_pos;
 
371
  uint block_pos;
347
372
  size_t length;
348
373
 
349
374
  if (records < block->last_allocated)
355
380
    info->index_length+=length;
356
381
  }
357
382
  block->last_allocated=records+1;
358
 
  return((HASH_INFO*) ((unsigned char*) block->level_info[0].last_blocks+
 
383
  return((HASH_INFO*) ((uchar*) block->level_info[0].last_blocks+
359
384
                       block_pos*block->recbuffer));
360
385
}