← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_delete.c

  • Committer: Jay Pipes
  • Date: 2009-01-30 04:38:21 UTC
  • mto: This revision was merged to the branch mainline in revision 830.
  • Revision ID: jpipes@serialcoder-20090130043821-4d7jg2ftabefamxb
Fixes for the QUARTER() function to use new Temporal system and throw
errors on bad datetime values.

Added test case for QUARTER() function and modified func_time.test existing
test to correctly throw errors and report NULL, not 0 on NULL input.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_delete.c
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* Remove a row from a MyISAM table */
17
17
 
18
 
#include "myisam_priv.h"
19
 
#include "drizzled/internal/m_string.h"
 
18
#include "myisamdef.h"
 
19
#include <mystrings/m_string.h>
20
20
#include <drizzled/util/test.h>
21
21
 
22
 
using namespace drizzled;
23
 
 
24
22
static int d_search(MI_INFO *info,MI_KEYDEF *keyinfo,uint32_t comp_flag,
25
 
                    unsigned char *key,uint32_t key_length,internal::my_off_t page,unsigned char *anc_buff);
 
23
                    unsigned char *key,uint32_t key_length,my_off_t page,unsigned char *anc_buff);
26
24
static int del(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,unsigned char *anc_buff,
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);
 
25
               my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos,
 
26
               my_off_t next_block,unsigned char *ret_key);
29
27
static int underflow(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *anc_buff,
30
 
                     internal::my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos);
 
28
                     my_off_t leaf_page,unsigned char *leaf_buff,unsigned char *keypos);
31
29
static uint32_t remove_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char *keypos,
32
30
                       unsigned char *lastkey,unsigned char *page_end,
33
 
                       internal::my_off_t *next_block);
 
31
                       my_off_t *next_block);
34
32
static int _mi_ck_real_delete(register MI_INFO *info,MI_KEYDEF *keyinfo,
35
 
                              unsigned char *key, uint32_t key_length, internal::my_off_t *root);
 
33
                              unsigned char *key, uint32_t key_length, my_off_t *root);
36
34
 
37
35
 
38
36
int mi_delete(MI_INFO *info,const unsigned char *record)
47
45
        /* Test if record is in datafile */
48
46
  if (!(info->update & HA_STATE_AKTIV))
49
47
  {
50
 
    return(errno=HA_ERR_KEY_NOT_FOUND); /* No database read */
 
48
    return(my_errno=HA_ERR_KEY_NOT_FOUND);      /* No database read */
51
49
  }
52
50
  if (share->options & HA_OPTION_READ_ONLY_DATA)
53
51
  {
54
 
    return(errno=EACCES);
 
52
    return(my_errno=EACCES);
55
53
  }
56
54
  if (_mi_readinfo(info,F_WRLCK,1))
57
 
    return(errno);
 
55
    return(my_errno);
58
56
  if (info->s->calc_checksum)
59
57
    info->checksum=(*info->s->calc_checksum)(info,record);
60
58
  if ((*share->compare_record)(info,record))
90
88
 
91
89
  mi_sizestore(lastpos,info->lastpos);
92
90
  _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
 
91
  if (info->invalidator != 0)
 
92
  {
 
93
    (*info->invalidator)(info->filename);
 
94
    info->invalidator=0;
 
95
  }
93
96
  return(0);
94
97
 
95
98
err:
96
 
  save_errno=errno;
 
99
  save_errno=my_errno;
97
100
  mi_sizestore(lastpos,info->lastpos);
98
101
  if (save_errno != HA_ERR_RECORD_CHANGED)
99
102
  {
102
105
  }
103
106
  _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
104
107
  info->update|=HA_STATE_WRITTEN;       /* Buffer changed */
105
 
  errno=save_errno;
 
108
  my_errno=save_errno;
106
109
  if (save_errno == HA_ERR_KEY_NOT_FOUND)
107
110
  {
108
111
    mi_print_error(info->s, HA_ERR_CRASHED);
109
 
    errno=HA_ERR_CRASHED;
 
112
    my_errno=HA_ERR_CRASHED;
110
113
  }
111
114
 
112
 
  return(errno);
 
115
  return(my_errno);
113
116
} /* mi_delete */
114
117
 
115
118
 
124
127
 
125
128
 
126
129
static int _mi_ck_real_delete(register MI_INFO *info, MI_KEYDEF *keyinfo,
127
 
                              unsigned char *key, uint32_t key_length, internal::my_off_t *root)
 
130
                              unsigned char *key, uint32_t key_length, my_off_t *root)
128
131
{
129
132
  int error;
130
133
  uint32_t nod_flag;
131
 
  internal::my_off_t old_root;
 
134
  my_off_t old_root;
132
135
  unsigned char *root_buff;
133
136
 
134
137
  if ((old_root=*root) == HA_OFFSET_ERROR)
135
138
  {
136
139
    mi_print_error(info->s, HA_ERR_CRASHED);
137
 
    return(errno=HA_ERR_CRASHED);
 
140
    return(my_errno=HA_ERR_CRASHED);
138
141
  }
139
142
  if (!(root_buff= (unsigned char*) malloc(keyinfo->block_length+
140
143
                                      MI_MAX_KEY_BUFF*2)))
141
144
  {
142
 
    return(errno=ENOMEM);
 
145
    return(my_errno=ENOMEM);
143
146
  }
144
147
  if (!_mi_fetch_keypage(info,keyinfo,old_root,DFLT_INIT_HITS,root_buff,0))
145
148
  {
185
188
 
186
189
static int d_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
187
190
                    uint32_t comp_flag, unsigned char *key, uint32_t key_length,
188
 
                    internal::my_off_t page, unsigned char *anc_buff)
 
191
                    my_off_t page, unsigned char *anc_buff)
189
192
{
190
193
  int flag,ret_value,save_flag;
191
194
  uint32_t length,nod_flag,search_key_length;
192
195
  bool last_key;
193
196
  unsigned char *leaf_buff,*keypos;
194
 
  internal::my_off_t leaf_page= 0, next_block;
 
197
  my_off_t leaf_page= 0, next_block;
195
198
  unsigned char lastkey[MI_MAX_KEY_BUFF];
196
199
 
197
200
  search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
210
213
    if (!(leaf_buff= (unsigned char*) malloc(keyinfo->block_length+
211
214
                                        MI_MAX_KEY_BUFF*2)))
212
215
    {
213
 
      errno=ENOMEM;
 
216
      my_errno=ENOMEM;
214
217
      return(-1);
215
218
    }
216
219
    if (!_mi_fetch_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff,0))
222
225
    if (!nod_flag)
223
226
    {
224
227
      mi_print_error(info->s, HA_ERR_CRASHED);
225
 
      errno=HA_ERR_CRASHED;             /* This should newer happend */
 
228
      my_errno=HA_ERR_CRASHED;          /* This should newer happend */
226
229
      goto err;
227
230
    }
228
231
    save_flag=0;
266
269
        goto err;
267
270
      }
268
271
      ret_value=_mi_insert(info,keyinfo,key,anc_buff,keypos,lastkey,
269
 
                           (unsigned char*) 0,(unsigned char*) 0,(internal::my_off_t) 0,(bool) 0);
 
272
                           (unsigned char*) 0,(unsigned char*) 0,(my_off_t) 0,(bool) 0);
270
273
    }
271
274
  }
272
275
  if (ret_value == 0 && mi_getint(anc_buff) > keyinfo->block_length)
288
291
        /* Remove a key that has a page-reference */
289
292
 
290
293
static int del(register MI_INFO *info, register MI_KEYDEF *keyinfo, unsigned char *key,
291
 
               unsigned char *anc_buff, internal::my_off_t leaf_page, unsigned char *leaf_buff,
 
294
               unsigned char *anc_buff, my_off_t leaf_page, unsigned char *leaf_buff,
292
295
               unsigned char *keypos,           /* Pos to where deleted key was */
293
 
               internal::my_off_t next_block,
 
296
               my_off_t next_block,
294
297
               unsigned char *ret_key)          /* key before keypos in anc_buff */
295
298
{
296
299
  int ret_value,length;
297
300
  uint32_t a_length,nod_flag,tmp;
298
 
  internal::my_off_t next_page;
 
301
  my_off_t next_page;
299
302
  unsigned char keybuff[MI_MAX_KEY_BUFF],*endpos,*next_buff,*key_start, *prev_key;
300
303
  MYISAM_SHARE *share=info->s;
301
304
  MI_KEY_PARAM s_temp;
334
337
                                &tmp))
335
338
            goto err;
336
339
          ret_value=_mi_insert(info,keyinfo,key,leaf_buff,endpos,keybuff,
337
 
                               (unsigned char*) 0,(unsigned char*) 0,(internal::my_off_t) 0,0);
 
340
                               (unsigned char*) 0,(unsigned char*) 0,(my_off_t) 0,0);
338
341
        }
339
342
      }
340
343
      if (_mi_write_keypage(info,keyinfo,leaf_page,DFLT_INIT_HITS,leaf_buff))
364
367
                              prev_key, prev_key,
365
368
                              keybuff,&s_temp);
366
369
  if (length > 0)
367
 
    internal::bmove_upp((unsigned char*) endpos+length,(unsigned char*) endpos,(uint) (endpos-keypos));
 
370
    bmove_upp((unsigned char*) endpos+length,(unsigned char*) endpos,(uint) (endpos-keypos));
368
371
  else
369
372
    memmove(keypos,keypos-length, (int) (endpos-keypos)+length);
370
373
  (*keyinfo->store_key)(keyinfo,keypos,&s_temp);
386
389
 
387
390
static int underflow(register MI_INFO *info, register MI_KEYDEF *keyinfo,
388
391
                     unsigned char *anc_buff,
389
 
                     internal::my_off_t leaf_page,/* Ancestor page and underflow page */
 
392
                     my_off_t leaf_page,/* Ancestor page and underflow page */
390
393
                     unsigned char *leaf_buff,
391
394
                     unsigned char *keypos)     /* Position to pos after key */
392
395
{
393
396
  int t_length;
394
397
  uint32_t length,anc_length,buff_length,leaf_length,p_length,s_length,nod_flag,
395
398
       key_reflength,key_length;
396
 
  internal::my_off_t next_page;
 
399
  my_off_t next_page;
397
400
  unsigned char anc_key[MI_MAX_KEY_BUFF],leaf_key[MI_MAX_KEY_BUFF],
398
401
        *buff,*endpos,*next_keypos,*anc_pos,*half_pos,*temp_pos,*prev_key,
399
402
        *after_key;
448
451
    length=buff_length-p_length;
449
452
    endpos=buff+length+leaf_length+t_length;
450
453
    /* buff will always be larger than before !*/
451
 
    internal::bmove_upp((unsigned char*) endpos, (unsigned char*) buff+buff_length,length);
 
454
    bmove_upp((unsigned char*) endpos, (unsigned char*) buff+buff_length,length);
452
455
    memcpy(buff, leaf_buff, leaf_length);
453
456
    (*keyinfo->store_key)(keyinfo,buff+leaf_length,&s_temp);
454
457
    buff_length=(uint) (endpos-buff);
457
460
    /* remove key from anc_buff */
458
461
 
459
462
    if (!(s_length=remove_key(keyinfo,key_reflength,keypos,anc_key,
460
 
                              anc_buff+anc_length,(internal::my_off_t *) 0)))
 
463
                              anc_buff+anc_length,(my_off_t *) 0)))
461
464
      goto err;
462
465
 
463
466
    anc_length-=s_length;
493
496
                                    prev_key, prev_key,
494
497
                                    leaf_key, &s_temp);
495
498
      if (t_length >= 0)
496
 
        internal::bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,
 
499
        bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,
497
500
                  (uint) (endpos-keypos));
498
501
      else
499
502
        memmove(keypos,keypos-t_length,(uint) (endpos-keypos)+t_length);
560
563
 
561
564
  /* remove key from anc_buff */
562
565
  if (!(s_length= remove_key(keyinfo,key_reflength,keypos,anc_key,
563
 
                             anc_buff+anc_length,(internal::my_off_t *) 0)))
 
566
                             anc_buff+anc_length,(my_off_t *) 0)))
564
567
    goto err;
565
568
 
566
569
  anc_length-=s_length;
592
595
                                  anc_pos, anc_pos,
593
596
                                  leaf_key,&s_temp);
594
597
    if (t_length > 0)
595
 
      internal::bmove_upp((unsigned char*) temp_pos+t_length,(unsigned char*) temp_pos,
 
598
      bmove_upp((unsigned char*) temp_pos+t_length,(unsigned char*) temp_pos,
596
599
                (uint) (temp_pos-keypos));
597
600
    else
598
601
      memmove(keypos,keypos-t_length,(uint) (temp_pos-keypos)+t_length);
634
637
                       unsigned char *keypos,   /* Where key starts */
635
638
                       unsigned char *lastkey,  /* key to be removed */
636
639
                       unsigned char *page_end, /* End of page */
637
 
                       internal::my_off_t *next_block)  /* ptr to next block */
 
640
                       my_off_t *next_block)    /* ptr to next block */
638
641
{
639
642
  int s_length;
640
643
  unsigned char *start;
668
671
        if (next_length > prev_length)
669
672
        {
670
673
          /* We have to copy data from the current key to the next key */
671
 
          internal::bmove_upp(keypos, (lastkey+next_length),
 
674
          bmove_upp(keypos, (lastkey+next_length),
672
675
                    (next_length-prev_length));
673
676
          keypos-=(next_length-prev_length)+prev_pack_length;
674
677
          store_key_length(keypos,prev_length);
715
718
          if (next_length >= prev_length)
716
719
          {             /* Key after is based on deleted key */
717
720
            uint32_t pack_length,tmp;
718
 
            internal::bmove_upp(keypos, (lastkey+next_length),
719
 
                                tmp=(next_length-prev_length));
 
721
            bmove_upp(keypos, (lastkey+next_length),
 
722
                      tmp=(next_length-prev_length));
720
723
            rest_length+=tmp;
721
724
            pack_length= prev_length ? get_pack_length(rest_length): 0;
722
725
            keypos-=tmp+pack_length+prev_pack_length;