← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_delete.cc

Merged build.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_delete.cc
19
19
#include "drizzled/internal/m_string.h"
20
20
#include <drizzled/util/test.h>
21
21
 
 
22
using namespace drizzled;
 
23
 
22
24
static int d_search(MI_INFO *info,MI_KEYDEF *keyinfo,uint32_t comp_flag,
23
 
                    unsigned char *key,uint32_t key_length,my_off_t page,unsigned char *anc_buff);
 
25
                    unsigned char *key,uint32_t key_length,internal::my_off_t page,unsigned char *anc_buff);
24
26
static int del(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,unsigned char *anc_buff,
25
 
               my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos,
26
 
               my_off_t next_block,unsigned char *ret_key);
 
27
               internal::my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos,
 
28
               internal::my_off_t next_block,unsigned char *ret_key);
27
29
static int underflow(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *anc_buff,
28
 
                     my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos);
 
30
                     internal::my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos);
29
31
static uint32_t remove_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *keypos,
30
32
                       unsigned char *lastkey,unsigned char *page_end,
31
 
                       my_off_t *next_block);
 
33
                       internal::my_off_t *next_block);
32
34
static int _mi_ck_real_delete(register MI_INFO *info,MI_KEYDEF *keyinfo,
33
 
                              unsigned char *key, uint32_t key_length, my_off_t *root);
 
35
                              unsigned char *key, uint32_t key_length, internal::my_off_t *root);
34
36
 
35
37
 
36
38
int mi_delete(MI_INFO *info,const unsigned char *record)
122
124
 
123
125
 
124
126
static int _mi_ck_real_delete(register MI_INFO *info, MI_KEYDEF *keyinfo,
125
 
                              unsigned char *key, uint32_t key_length, my_off_t *root)
 
127
                              unsigned char *key, uint32_t key_length, internal::my_off_t *root)
126
128
{
127
129
  int error;
128
130
  uint32_t nod_flag;
129
 
  my_off_t old_root;
 
131
  internal::my_off_t old_root;
130
132
  unsigned char *root_buff;
131
133
 
132
134
  if ((old_root=*root) == HA_OFFSET_ERROR)
183
185
 
184
186
static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
185
187
                    uint32_t comp_flag, unsigned char *key, uint32_t key_length,
186
 
                    my_off_t page, unsigned char *anc_buff)
 
188
                    internal::my_off_t page, unsigned char *anc_buff)
187
189
{
188
190
  int flag,ret_value,save_flag;
189
191
  uint32_t length,nod_flag,search_key_length;
190
192
  bool last_key;
191
193
  unsigned char *leaf_buff,*keypos;
192
 
  my_off_t leaf_page= 0, next_block;
 
194
  internal::my_off_t leaf_page= 0, next_block;
193
195
  unsigned char lastkey[MI_MAX_KEY_BUFF];
194
196
 
195
197
  search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
264
266
        goto err;
265
267
      }
266
268
      ret_value=_mi_insert(info,keyinfo,key,anc_buff,keypos,lastkey,
267
 
                           (unsigned char*) 0,(unsigned char*) 0,(my_off_t) 0,(bool) 0);
 
269
                           (unsigned char*) 0,(unsigned char*) 0,(internal::my_off_t) 0,(bool) 0);
268
270
    }
269
271
  }
270
272
  if (ret_value == 0 && mi_getint(anc_buff) > keyinfo->block_length)
286
288
        /* Remove a key that has a page-reference */
287
289
 
288
290
static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *key,
289
 
               unsigned char *anc_buff, my_off_t leaf_page, unsigned char *leaf_buff,
 
291
               unsigned char *anc_buff, internal::my_off_t leaf_page, unsigned char *leaf_buff,
290
292
               unsigned char *keypos,           /* Pos to where deleted key was */
291
 
               my_off_t next_block,
 
293
               internal::my_off_t next_block,
292
294
               unsigned char *ret_key)          /* key before keypos in anc_buff */
293
295
{
294
296
  int ret_value,length;
295
297
  uint32_t a_length,nod_flag,tmp;
296
 
  my_off_t next_page;
 
298
  internal::my_off_t next_page;
297
299
  unsigned char keybuff[MI_MAX_KEY_BUFF],*endpos,*next_buff,*key_start, *prev_key;
298
300
  MYISAM_SHARE *share=info->s;
299
301
  MI_KEY_PARAM s_temp;
332
334
                                &tmp))
333
335
            goto err;
334
336
          ret_value=_mi_insert(info,keyinfo,key,leaf_buff,endpos,keybuff,
335
 
                               (unsigned char*) 0,(unsigned char*) 0,(my_off_t) 0,0);
 
337
                               (unsigned char*) 0,(unsigned char*) 0,(internal::my_off_t) 0,0);
336
338
        }
337
339
      }
338
340
      if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
362
364
                              prev_key, prev_key,
363
365
                              keybuff,&s_temp);
364
366
  if (length > 0)
365
 
    bmove_upp((unsigned char*) endpos+length,(unsigned char*) endpos,(uint) (endpos-keypos));
 
367
    internal::bmove_upp((unsigned char*) endpos+length,(unsigned char*) endpos,(uint) (endpos-keypos));
366
368
  else
367
369
    memmove(keypos,keypos-length, (int) (endpos-keypos)+length);
368
370
  (*keyinfo->store_key)(keyinfo,keypos,&s_temp);
384
386
 
385
387
static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
386
388
                     unsigned char *anc_buff,
387
 
                     my_off_t leaf_page,/* Ancestor page and underflow page */
 
389
                     internal::my_off_t leaf_page,/* Ancestor page and underflow page */
388
390
                     unsigned char *leaf_buff,
389
391
                     unsigned char *keypos)     /* Position to pos after key */
390
392
{
391
393
  int t_length;
392
394
  uint32_t length,anc_length,buff_length,leaf_length,p_length,s_length,nod_flag,
393
395
       key_reflength,key_length;
394
 
  my_off_t next_page;
 
396
  internal::my_off_t next_page;
395
397
  unsigned char anc_key[MI_MAX_KEY_BUFF],leaf_key[MI_MAX_KEY_BUFF],
396
398
        *buff,*endpos,*next_keypos,*anc_pos,*half_pos,*temp_pos,*prev_key,
397
399
        *after_key;
446
448
    length=buff_length-p_length;
447
449
    endpos=buff+length+leaf_length+t_length;
448
450
    /* buff will always be larger than before !*/
449
 
    bmove_upp((unsigned char*) endpos, (unsigned char*) buff+buff_length,length);
 
451
    internal::bmove_upp((unsigned char*) endpos, (unsigned char*) buff+buff_length,length);
450
452
    memcpy(buff, leaf_buff, leaf_length);
451
453
    (*keyinfo->store_key)(keyinfo,buff+leaf_length,&s_temp);
452
454
    buff_length=(uint) (endpos-buff);
455
457
    /* remove key from anc_buff */
456
458
 
457
459
    if (!(s_length=remove_key(keyinfo,key_reflength,keypos,anc_key,
458
 
                              anc_buff+anc_length,(my_off_t *) 0)))
 
460
                              anc_buff+anc_length,(internal::my_off_t *) 0)))
459
461
      goto err;
460
462
 
461
463
    anc_length-=s_length;
491
493
                                    prev_key, prev_key,
492
494
                                    leaf_key, &s_temp);
493
495
      if (t_length >= 0)
494
 
        bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,
 
496
        internal::bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,
495
497
                  (uint) (endpos-keypos));
496
498
      else
497
499
        memmove(keypos,keypos-t_length,(uint) (endpos-keypos)+t_length);
558
560
 
559
561
  /* remove key from anc_buff */
560
562
  if (!(s_length= remove_key(keyinfo,key_reflength,keypos,anc_key,
561
 
                             anc_buff+anc_length,(my_off_t *) 0)))
 
563
                             anc_buff+anc_length,(internal::my_off_t *) 0)))
562
564
    goto err;
563
565
 
564
566
  anc_length-=s_length;
590
592
                                  anc_pos, anc_pos,
591
593
                                  leaf_key,&s_temp);
592
594
    if (t_length > 0)
593
 
      bmove_upp((unsigned char*) temp_pos+t_length,(unsigned char*) temp_pos,
 
595
      internal::bmove_upp((unsigned char*) temp_pos+t_length,(unsigned char*) temp_pos,
594
596
                (uint) (temp_pos-keypos));
595
597
    else
596
598
      memmove(keypos,keypos-t_length,(uint) (temp_pos-keypos)+t_length);
632
634
                       unsigned char *keypos,   /* Where key starts */
633
635
                       unsigned char *lastkey,  /* key to be removed */
634
636
                       unsigned char *page_end, /* End of page */
635
 
                       my_off_t *next_block)    /* ptr to next block */
 
637
                       internal::my_off_t *next_block)  /* ptr to next block */
636
638
{
637
639
  int s_length;
638
640
  unsigned char *start;
666
668
        if (next_length > prev_length)
667
669
        {
668
670
          /* We have to copy data from the current key to the next key */
669
 
          bmove_upp(keypos, (lastkey+next_length),
 
671
          internal::bmove_upp(keypos, (lastkey+next_length),
670
672
                    (next_length-prev_length));
671
673
          keypos-=(next_length-prev_length)+prev_pack_length;
672
674
          store_key_length(keypos,prev_length);
713
715
          if (next_length >= prev_length)
714
716
          {             /* Key after is based on deleted key */
715
717
            uint32_t pack_length,tmp;
716
 
            bmove_upp(keypos, (lastkey+next_length),
717
 
                      tmp=(next_length-prev_length));
 
718
            internal::bmove_upp(keypos, (lastkey+next_length),
 
719
                                tmp=(next_length-prev_length));
718
720
            rest_length+=tmp;
719
721
            pack_length= prev_length ? get_pack_length(rest_length): 0;
720
722
            keypos-=tmp+pack_length+prev_pack_length;