← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_write.c

  • Committer: Brian Aker
  • Date: 2008-09-04 19:31:00 UTC
  • Revision ID: brian@tangent.org-20080904193100-l849hgghfy4urj43
Changing default character set from this point on.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_write.c
16
16
/* Write a row to a MyISAM table */
17
17
 
18
18
#include "myisamdef.h"
19
 
#include <drizzled/util/test.h>
20
 
 
21
19
 
22
20
#define MAX_POINTER_LENGTH 8
23
21
 
24
22
        /* Functions declared in this file */
25
23
 
26
24
static int w_search(MI_INFO *info,MI_KEYDEF *keyinfo,
27
 
                    uint32_t comp_flag, unsigned char *key,
28
 
                    uint32_t key_length, my_off_t pos, unsigned char *father_buff,
29
 
                    unsigned char *father_keypos, my_off_t father_page,
 
25
                    uint comp_flag, uchar *key,
 
26
                    uint key_length, my_off_t pos, uchar *father_buff,
 
27
                    uchar *father_keypos, my_off_t father_page,
30
28
                    bool insert_last);
31
 
static int _mi_balance_page(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
32
 
                            unsigned char *curr_buff,unsigned char *father_buff,
33
 
                            unsigned char *father_keypos,my_off_t father_page);
34
 
static unsigned char *_mi_find_last_pos(MI_KEYDEF *keyinfo, unsigned char *page,
35
 
                                unsigned char *key, uint32_t *return_key_length,
36
 
                                unsigned char **after_key);
37
 
int _mi_ck_write_tree(register MI_INFO *info, uint32_t keynr,unsigned char *key,
38
 
                      uint32_t key_length);
39
 
int _mi_ck_write_btree(register MI_INFO *info, uint32_t keynr,unsigned char *key,
40
 
                       uint32_t key_length);
 
29
static int _mi_balance_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
 
30
                            uchar *curr_buff,uchar *father_buff,
 
31
                            uchar *father_keypos,my_off_t father_page);
 
32
static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
 
33
                                uchar *key, uint *return_key_length,
 
34
                                uchar **after_key);
 
35
int _mi_ck_write_tree(register MI_INFO *info, uint keynr,uchar *key,
 
36
                      uint key_length);
 
37
int _mi_ck_write_btree(register MI_INFO *info, uint keynr,uchar *key,
 
38
                       uint key_length);
41
39
 
42
40
        /* Write new record to database */
43
41
 
44
 
int mi_write(MI_INFO *info, unsigned char *record)
 
42
int mi_write(MI_INFO *info, uchar *record)
45
43
{
46
44
  MYISAM_SHARE *share=info->s;
47
 
  uint32_t i;
 
45
  uint i;
48
46
  int save_errno;
49
47
  my_off_t filepos;
50
 
  unsigned char *buff;
 
48
  uchar *buff;
51
49
  bool lock_tree= share->concurrent_insert;
52
50
 
53
51
  if (share->options & HA_OPTION_READ_ONLY_DATA)
132
130
                 HA_STATE_ROW_CHANGED);
133
131
  info->state->records++;
134
132
  info->lastpos=filepos;
135
 
  _mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE);
 
133
  VOID(_mi_writeinfo(info, WRITEINFO_UPDATE_KEYFILE));
136
134
  if (info->invalidator != 0)
137
135
  {
138
136
    (*info->invalidator)(info->filename);
159
157
  {
160
158
    if (info->bulk_insert)
161
159
    {
162
 
      uint32_t j;
 
160
      uint j;
163
161
      for (j=0 ; j < share->base.keys ; j++)
164
162
        mi_flush_bulk_insert(info, j);
165
163
    }
174
172
        if (local_lock_tree)
175
173
          rw_wrlock(&share->key_root_lock[i]);
176
174
        {
177
 
          uint32_t key_length=_mi_make_key(info,i,buff,record,filepos);
 
175
          uint key_length=_mi_make_key(info,i,buff,record,filepos);
178
176
          if (_mi_ck_delete(info,i,buff,key_length))
179
177
          {
180
178
            if (local_lock_tree)
196
194
  my_errno=save_errno;
197
195
err2:
198
196
  save_errno=my_errno;
199
 
  _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
 
197
  VOID(_mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE));
200
198
  return(my_errno=save_errno);
201
199
} /* mi_write */
202
200
 
203
201
 
204
202
        /* Write one key to btree */
205
203
 
206
 
int _mi_ck_write(MI_INFO *info, uint32_t keynr, unsigned char *key, uint32_t key_length)
 
204
int _mi_ck_write(MI_INFO *info, uint keynr, uchar *key, uint key_length)
207
205
{
208
206
  if (info->bulk_insert && is_tree_inited(&info->bulk_insert[keynr]))
209
207
  {
220
218
 *                Normal insert code                                  *
221
219
 **********************************************************************/
222
220
 
223
 
int _mi_ck_write_btree(register MI_INFO *info, uint32_t keynr, unsigned char *key,
224
 
                       uint32_t key_length)
 
221
int _mi_ck_write_btree(register MI_INFO *info, uint keynr, uchar *key,
 
222
                       uint key_length)
225
223
{
226
 
  uint32_t error;
227
 
  uint32_t comp_flag;
 
224
  uint error;
 
225
  uint comp_flag;
228
226
  MI_KEYDEF *keyinfo=info->s->keyinfo+keynr;
229
227
  my_off_t  *root=&info->s->state.key_root[keynr];
230
228
 
245
243
} /* _mi_ck_write_btree */
246
244
 
247
245
int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
248
 
    unsigned char *key, uint32_t key_length, my_off_t *root, uint32_t comp_flag)
 
246
    uchar *key, uint key_length, my_off_t *root, uint comp_flag)
249
247
{
250
248
  int error;
251
249
  /* key_length parameter is used only if comp_flag is SEARCH_FIND */
252
250
  if (*root == HA_OFFSET_ERROR ||
253
251
      (error=w_search(info, keyinfo, comp_flag, key, key_length,
254
 
                      *root, (unsigned char *) 0, (unsigned char*) 0,
 
252
                      *root, (uchar *) 0, (uchar*) 0,
255
253
                      (my_off_t) 0, 1)) > 0)
256
254
    error=_mi_enlarge_root(info,keyinfo,key,root);
257
255
  return(error);
260
258
 
261
259
        /* Make a new root with key as only pointer */
262
260
 
263
 
int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *key,
 
261
int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
264
262
                     my_off_t *root)
265
263
{
266
 
  uint32_t t_length,nod_flag;
 
264
  uint t_length,nod_flag;
267
265
  MI_KEY_PARAM s_temp;
268
266
  MYISAM_SHARE *share=info->s;
269
267
 
270
268
  nod_flag= (*root != HA_OFFSET_ERROR) ?  share->base.key_reflength : 0;
271
269
  _mi_kpointer(info,info->buff+2,*root); /* if nod */
272
 
  t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(unsigned char*) 0,
273
 
                                (unsigned char*) 0, (unsigned char*) 0, key,&s_temp);
 
270
  t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar*) 0,
 
271
                                (uchar*) 0, (uchar*) 0, key,&s_temp);
274
272
  mi_putint(info->buff,t_length+2+nod_flag,nod_flag);
275
273
  (*keyinfo->store_key)(keyinfo,info->buff+2+nod_flag,&s_temp);
276
274
  info->buff_used=info->page_changed=1;         /* info->buff is used */
289
287
        */
290
288
 
291
289
static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
292
 
                    uint32_t comp_flag, unsigned char *key, uint32_t key_length, my_off_t page,
293
 
                    unsigned char *father_buff, unsigned char *father_keypos,
 
290
                    uint comp_flag, uchar *key, uint key_length, my_off_t page,
 
291
                    uchar *father_buff, uchar *father_keypos,
294
292
                    my_off_t father_page, bool insert_last)
295
293
{
296
294
  int error,flag;
297
 
  uint32_t nod_flag, search_key_length;
298
 
  unsigned char *temp_buff,*keypos;
299
 
  unsigned char keybuff[MI_MAX_KEY_BUFF];
 
295
  uint nod_flag, search_key_length;
 
296
  uchar *temp_buff,*keypos;
 
297
  uchar keybuff[MI_MAX_KEY_BUFF];
300
298
  bool was_last_key;
301
299
  my_off_t next_page, dupp_key_pos;
302
300
 
303
301
  search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
304
 
  if (!(temp_buff= (unsigned char*) my_alloca((uint) keyinfo->block_length+
 
302
  if (!(temp_buff= (uchar*) my_alloca((uint) keyinfo->block_length+
305
303
                                      MI_MAX_KEY_BUFF*2)))
306
304
    return(-1);
307
305
  if (!_mi_fetch_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff,0))
312
310
  nod_flag=mi_test_if_nod(temp_buff);
313
311
  if (flag == 0)
314
312
  {
315
 
    uint32_t tmp_key_length;
 
313
    uint tmp_key_length;
316
314
        /* get position to record with duplicated key */
317
315
    tmp_key_length=(*keyinfo->get_key)(keyinfo,nod_flag,&keypos,keybuff);
318
316
    if (tmp_key_length)
322
320
 
323
321
    {
324
322
      info->dupp_key_pos= dupp_key_pos;
325
 
      my_afree((unsigned char*) temp_buff);
 
323
      my_afree((uchar*) temp_buff);
326
324
      my_errno=HA_ERR_FOUND_DUPP_KEY;
327
325
      return(-1);
328
326
    }
341
339
    if (_mi_write_keypage(info,keyinfo,page,DFLT_INIT_HITS,temp_buff))
342
340
      goto err;
343
341
  }
344
 
  my_afree((unsigned char*) temp_buff);
 
342
  my_afree((uchar*) temp_buff);
345
343
  return(error);
346
344
err:
347
 
  my_afree((unsigned char*) temp_buff);
 
345
  my_afree((uchar*) temp_buff);
348
346
  return (-1);
349
347
} /* w_search */
350
348
 
375
373
*/
376
374
 
377
375
int _mi_insert(register MI_INFO *info, register MI_KEYDEF *keyinfo,
378
 
               unsigned char *key, unsigned char *anc_buff, unsigned char *key_pos, unsigned char *key_buff,
379
 
               unsigned char *father_buff, unsigned char *father_key_pos, my_off_t father_page,
 
376
               uchar *key, uchar *anc_buff, uchar *key_pos, uchar *key_buff,
 
377
               uchar *father_buff, uchar *father_key_pos, my_off_t father_page,
380
378
               bool insert_last)
381
379
{
382
 
  uint32_t a_length,nod_flag;
 
380
  uint a_length,nod_flag;
383
381
  int t_length;
384
 
  unsigned char *endpos, *prev_key;
 
382
  uchar *endpos, *prev_key;
385
383
  MI_KEY_PARAM s_temp;
386
384
 
387
385
  nod_flag=mi_test_if_nod(anc_buff);
388
386
  a_length=mi_getint(anc_buff);
389
387
  endpos= anc_buff+ a_length;
390
 
  prev_key=(key_pos == anc_buff+2+nod_flag ? (unsigned char*) 0 : key_buff);
 
388
  prev_key=(key_pos == anc_buff+2+nod_flag ? (uchar*) 0 : key_buff);
391
389
  t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,
392
 
                                (key_pos == endpos ? (unsigned char*) 0 : key_pos),
 
390
                                (key_pos == endpos ? (uchar*) 0 : key_pos),
393
391
                                prev_key, prev_key,
394
392
                                key,&s_temp);
395
393
 
401
399
      my_errno=HA_ERR_CRASHED;
402
400
      return(-1);
403
401
    }
404
 
    bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,(uint) (endpos-key_pos));
 
402
    bmove_upp((uchar*) endpos+t_length,(uchar*) endpos,(uint) (endpos-key_pos));
405
403
  }
406
404
  else
407
405
  {
434
432
        /* split a full page in two and assign emerging item to key */
435
433
 
436
434
int _mi_split_page(register MI_INFO *info, register MI_KEYDEF *keyinfo,
437
 
                   unsigned char *key, unsigned char *buff, unsigned char *key_buff,
 
435
                   uchar *key, uchar *buff, uchar *key_buff,
438
436
                   bool insert_last_key)
439
437
{
440
 
  uint32_t length,a_length,key_ref_length,t_length,nod_flag,key_length;
441
 
  unsigned char *key_pos,*pos, *after_key= NULL;
 
438
  uint length,a_length,key_ref_length,t_length,nod_flag,key_length;
 
439
  uchar *key_pos,*pos, *after_key= NULL;
442
440
  my_off_t new_pos;
443
441
  MI_KEY_PARAM s_temp;
444
442
 
475
473
  if (!(*keyinfo->get_key)(keyinfo,nod_flag,&key_pos,key_buff))
476
474
    return(-1);
477
475
 
478
 
  t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(unsigned char *) 0,
479
 
                                (unsigned char*) 0, (unsigned char*) 0,
 
476
  t_length=(*keyinfo->pack_key)(keyinfo,nod_flag,(uchar *) 0,
 
477
                                (uchar*) 0, (uchar*) 0,
480
478
                                key_buff, &s_temp);
481
479
  length=(uint) ((buff+a_length)-key_pos);
482
480
  memcpy(info->buff+key_ref_length+t_length, key_pos, length);
497
495
          after_key will contain the position to where the next key starts
498
496
        */
499
497
 
500
 
unsigned char *_mi_find_half_pos(uint32_t nod_flag, MI_KEYDEF *keyinfo, unsigned char *page,
501
 
                         unsigned char *key, uint32_t *return_key_length,
502
 
                         unsigned char **after_key)
 
498
uchar *_mi_find_half_pos(uint nod_flag, MI_KEYDEF *keyinfo, uchar *page,
 
499
                         uchar *key, uint *return_key_length,
 
500
                         uchar **after_key)
503
501
{
504
 
  uint32_t keys,length,key_ref_length;
505
 
  unsigned char *end,*lastpos;
 
502
  uint keys,length,key_ref_length;
 
503
  uchar *end,*lastpos;
506
504
 
507
505
  key_ref_length=2+nod_flag;
508
506
  length=mi_getint(page)-key_ref_length;
540
538
          key will contain the last key
541
539
        */
542
540
 
543
 
static unsigned char *_mi_find_last_pos(MI_KEYDEF *keyinfo, unsigned char *page,
544
 
                                unsigned char *key, uint32_t *return_key_length,
545
 
                                unsigned char **after_key)
 
541
static uchar *_mi_find_last_pos(MI_KEYDEF *keyinfo, uchar *page,
 
542
                                uchar *key, uint *return_key_length,
 
543
                                uchar **after_key)
546
544
{
547
 
  uint32_t keys;
548
 
  uint32_t length;
549
 
  uint32_t last_length= 0;
550
 
  uint32_t key_ref_length;
551
 
  unsigned char *end, *lastpos, *prevpos= NULL;
552
 
  unsigned char key_buff[MI_MAX_KEY_BUFF];
 
545
  uint keys;
 
546
  uint length;
 
547
  uint last_length= 0;
 
548
  uint key_ref_length;
 
549
  uchar *end, *lastpos, *prevpos= NULL;
 
550
  uchar key_buff[MI_MAX_KEY_BUFF];
553
551
 
554
552
  key_ref_length=2;
555
553
  length=mi_getint(page)-key_ref_length;
592
590
        /* returns 0 if balance was done */
593
591
 
594
592
static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
595
 
                            unsigned char *key, unsigned char *curr_buff, unsigned char *father_buff,
596
 
                            unsigned char *father_key_pos, my_off_t father_page)
 
593
                            uchar *key, uchar *curr_buff, uchar *father_buff,
 
594
                            uchar *father_key_pos, my_off_t father_page)
597
595
{
598
596
  bool right;
599
 
  uint32_t k_length,father_length,father_keylength,nod_flag,curr_keylength,
 
597
  uint k_length,father_length,father_keylength,nod_flag,curr_keylength,
600
598
       right_length,left_length,new_right_length,new_left_length,extra_length,
601
599
       length,keys;
602
 
  unsigned char *pos,*buff,*extra_buff;
 
600
  uchar *pos,*buff,*extra_buff;
603
601
  my_off_t next_page,new_pos;
604
 
  unsigned char tmp_part_key[MI_MAX_KEY_BUFF];
 
602
  uchar tmp_part_key[MI_MAX_KEY_BUFF];
605
603
 
606
604
  k_length=keyinfo->keylength;
607
605
  father_length=mi_getint(father_buff);
658
656
    else
659
657
    {                                           /* Move keys -> buff */
660
658
 
661
 
      bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) buff+right_length,
 
659
      bmove_upp((uchar*) buff+new_right_length,(uchar*) buff+right_length,
662
660
                right_length-2);
663
661
      length=new_right_length-right_length-k_length;
664
662
      memcpy(buff+2+length,father_key_pos, k_length);
691
689
  /* Save new parting key */
692
690
  memcpy(tmp_part_key, pos-k_length,k_length);
693
691
  /* Make place for new keys */
694
 
  bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) pos-k_length,
 
692
  bmove_upp((uchar*) buff+new_right_length,(uchar*) pos-k_length,
695
693
            right_length-extra_length-k_length-2);
696
694
  /* Copy keys from left page */
697
695
  pos= curr_buff+new_left_length;
725
723
 
726
724
typedef struct {
727
725
  MI_INFO *info;
728
 
  uint32_t keynr;
 
726
  uint keynr;
729
727
} bulk_insert_param;
730
728
 
731
 
int _mi_ck_write_tree(register MI_INFO *info, uint32_t keynr, unsigned char *key,
732
 
                      uint32_t key_length)
 
729
int _mi_ck_write_tree(register MI_INFO *info, uint keynr, uchar *key,
 
730
                      uint key_length)
733
731
{
734
732
  int error;
735
733
 
743
741
 
744
742
/* typeof(_mi_keys_compare)=qsort_cmp2 */
745
743
 
746
 
static int keys_compare(bulk_insert_param *param, unsigned char *key1, unsigned char *key2)
 
744
static int keys_compare(bulk_insert_param *param, uchar *key1, uchar *key2)
747
745
{
748
 
  uint32_t not_used[2];
 
746
  uint not_used[2];
749
747
  return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg,
750
748
                    key1, key2, USE_WHOLE_KEY, SEARCH_SAME,
751
749
                    not_used);
752
750
}
753
751
 
754
752
 
755
 
static int keys_free(unsigned char *key, TREE_FREE mode, bulk_insert_param *param)
 
753
static int keys_free(uchar *key, TREE_FREE mode, bulk_insert_param *param)
756
754
{
757
755
  /*
758
756
    Probably I can use info->lastkey here, but I'm not sure,
759
757
    and to be safe I'd better use local lastkey.
760
758
  */
761
 
  unsigned char lastkey[MI_MAX_KEY_BUFF];
762
 
  uint32_t keylen;
 
759
  uchar lastkey[MI_MAX_KEY_BUFF];
 
760
  uint keylen;
763
761
  MI_KEYDEF *keyinfo;
764
762
 
765
763
  switch (mode) {
790
788
  MYISAM_SHARE *share=info->s;
791
789
  MI_KEYDEF *key=share->keyinfo;
792
790
  bulk_insert_param *params;
793
 
  uint32_t i, num_keys, total_keylength;
 
791
  uint i, num_keys, total_keylength;
794
792
  uint64_t key_map;
795
793
 
796
794
  assert(!info->bulk_insert &&
845
843
  return(0);
846
844
}
847
845
 
848
 
void mi_flush_bulk_insert(MI_INFO *info, uint32_t inx)
 
846
void mi_flush_bulk_insert(MI_INFO *info, uint inx)
849
847
{
850
848
  if (info->bulk_insert)
851
849
  {
858
856
{
859
857
  if (info->bulk_insert)
860
858
  {
861
 
    uint32_t i;
 
859
    uint i;
862
860
    for (i=0 ; i < info->s->base.keys ; i++)
863
861
    {
864
862
      if (is_tree_inited(& info->bulk_insert[i]))
866
864
        delete_tree(& info->bulk_insert[i]);
867
865
      }
868
866
    }
869
 
    free((void *)info->bulk_insert);
 
867
    my_free((void *)info->bulk_insert, MYF(0));
870
868
    info->bulk_insert=0;
871
869
  }
872
870
}