← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_write.cc

Made a bunch of smaler plugins dynamic.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_write.cc
17
17
 
18
18
#include "myisam_priv.h"
19
19
 
20
 
#include "drizzled/internal/m_string.h"
 
20
#include <mystrings/m_string.h>
21
21
#include <drizzled/util/test.h>
22
22
 
23
 
using namespace drizzled;
24
23
 
25
24
#define MAX_POINTER_LENGTH 8
26
25
 
28
27
 
29
28
static int w_search(MI_INFO *info,MI_KEYDEF *keyinfo,
30
29
                    uint32_t comp_flag, unsigned char *key,
31
 
                    uint32_t key_length, internal::my_off_t pos, unsigned char *father_buff,
32
 
                    unsigned char *father_keypos, internal::my_off_t father_page,
 
30
                    uint32_t key_length, my_off_t pos, unsigned char *father_buff,
 
31
                    unsigned char *father_keypos, my_off_t father_page,
33
32
                    bool insert_last);
34
33
static int _mi_balance_page(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
35
34
                            unsigned char *curr_buff,unsigned char *father_buff,
36
 
                            unsigned char *father_keypos,internal::my_off_t father_page);
 
35
                            unsigned char *father_keypos,my_off_t father_page);
37
36
static unsigned char *_mi_find_last_pos(MI_KEYDEF *keyinfo, unsigned char *page,
38
37
                                unsigned char *key, uint32_t *return_key_length,
39
38
                                unsigned char **after_key);
49
48
  MYISAM_SHARE *share=info->s;
50
49
  uint32_t i;
51
50
  int save_errno;
52
 
  internal::my_off_t filepos;
 
51
  my_off_t filepos;
53
52
  unsigned char *buff;
54
53
  bool lock_tree= share->concurrent_insert;
55
54
 
56
55
  if (share->options & HA_OPTION_READ_ONLY_DATA)
57
56
  {
58
 
    return(errno=EACCES);
 
57
    return(my_errno=EACCES);
59
58
  }
60
59
  if (_mi_readinfo(info,F_WRLCK,1))
61
 
    return(errno);
 
60
    return(my_errno);
62
61
  filepos= ((share->state.dellink != HA_OFFSET_ERROR &&
63
62
             !info->append_insert_at_end) ?
64
63
            share->state.dellink :
68
67
      share->base.records == (ha_rows) 1 &&
69
68
      info->state->records == (ha_rows) 1)
70
69
  {                                             /* System file */
71
 
    errno=HA_ERR_RECORD_FILE_FULL;
 
70
    my_errno=HA_ERR_RECORD_FILE_FULL;
72
71
    goto err2;
73
72
  }
74
73
  if (info->state->key_file_length >= share->base.margin_key_file_length)
75
74
  {
76
 
    errno=HA_ERR_INDEX_FILE_FULL;
 
75
    my_errno=HA_ERR_INDEX_FILE_FULL;
77
76
    goto err2;
78
77
  }
79
78
  if (_mi_mark_file_changed(info))
151
150
  return(0);
152
151
 
153
152
err:
154
 
  save_errno=errno;
155
 
  if (errno == HA_ERR_FOUND_DUPP_KEY || errno == HA_ERR_RECORD_FILE_FULL ||
156
 
      errno == HA_ERR_NULL_IN_SPATIAL || errno == HA_ERR_OUT_OF_MEM)
 
153
  save_errno=my_errno;
 
154
  if (my_errno == HA_ERR_FOUND_DUPP_KEY || my_errno == HA_ERR_RECORD_FILE_FULL ||
 
155
      my_errno == HA_ERR_NULL_IN_SPATIAL || my_errno == HA_ERR_OUT_OF_MEM)
157
156
  {
158
157
    if (info->bulk_insert)
159
158
    {
191
190
    mi_mark_crashed(info);
192
191
  }
193
192
  info->update= (HA_STATE_CHANGED | HA_STATE_WRITTEN | HA_STATE_ROW_CHANGED);
194
 
  errno=save_errno;
 
193
  my_errno=save_errno;
195
194
err2:
196
 
  save_errno=errno;
 
195
  save_errno=my_errno;
197
196
  _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
198
 
  return(errno=save_errno);
 
197
  return(my_errno=save_errno);
199
198
} /* mi_write */
200
199
 
201
200
 
224
223
  uint32_t error;
225
224
  uint32_t comp_flag;
226
225
  MI_KEYDEF *keyinfo=info->s->keyinfo+keynr;
227
 
  internal::my_off_t  *root=&info->s->state.key_root[keynr];
 
226
  my_off_t  *root=&info->s->state.key_root[keynr];
228
227
 
229
228
  if (keyinfo->flag & HA_SORT_ALLOWS_SAME)
230
229
    comp_flag=SEARCH_BIGGER;                    /* Put after same key */
243
242
} /* _mi_ck_write_btree */
244
243
 
245
244
int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
246
 
    unsigned char *key, uint32_t key_length, internal::my_off_t *root, uint32_t comp_flag)
 
245
    unsigned char *key, uint32_t key_length, my_off_t *root, uint32_t comp_flag)
247
246
{
248
247
  int error;
249
248
  /* key_length parameter is used only if comp_flag is SEARCH_FIND */
250
249
  if (*root == HA_OFFSET_ERROR ||
251
250
      (error=w_search(info, keyinfo, comp_flag, key, key_length,
252
251
                      *root, (unsigned char *) 0, (unsigned char*) 0,
253
 
                      (internal::my_off_t) 0, 1)) > 0)
 
252
                      (my_off_t) 0, 1)) > 0)
254
253
    error=_mi_enlarge_root(info,keyinfo,key,root);
255
254
  return(error);
256
255
} /* _mi_ck_real_write_btree */
259
258
        /* Make a new root with key as only pointer */
260
259
 
261
260
int _mi_enlarge_root(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *key,
262
 
                     internal::my_off_t *root)
 
261
                     my_off_t *root)
263
262
{
264
263
  uint32_t t_length,nod_flag;
265
264
  MI_KEY_PARAM s_temp;
287
286
        */
288
287
 
289
288
static int w_search(register MI_INFO *info, register MI_KEYDEF *keyinfo,
290
 
                    uint32_t comp_flag, unsigned char *key, uint32_t key_length, internal::my_off_t page,
 
289
                    uint32_t comp_flag, unsigned char *key, uint32_t key_length, my_off_t page,
291
290
                    unsigned char *father_buff, unsigned char *father_keypos,
292
 
                    internal::my_off_t father_page, bool insert_last)
 
291
                    my_off_t father_page, bool insert_last)
293
292
{
294
293
  int error,flag;
295
294
  uint32_t nod_flag, search_key_length;
296
295
  unsigned char *temp_buff,*keypos;
297
296
  unsigned char keybuff[MI_MAX_KEY_BUFF];
298
297
  bool was_last_key;
299
 
  internal::my_off_t next_page, dupp_key_pos;
 
298
  my_off_t next_page, dupp_key_pos;
300
299
 
301
300
  search_key_length= (comp_flag & SEARCH_FIND) ? key_length : USE_WHOLE_KEY;
302
301
  if (!(temp_buff= (unsigned char*) malloc(keyinfo->block_length+
321
320
    {
322
321
      info->dupp_key_pos= dupp_key_pos;
323
322
      free(temp_buff);
324
 
      errno=HA_ERR_FOUND_DUPP_KEY;
 
323
      my_errno=HA_ERR_FOUND_DUPP_KEY;
325
324
      return(-1);
326
325
    }
327
326
  }
374
373
 
375
374
int _mi_insert(register MI_INFO *info, register MI_KEYDEF *keyinfo,
376
375
               unsigned char *key, unsigned char *anc_buff, unsigned char *key_pos, unsigned char *key_buff,
377
 
               unsigned char *father_buff, unsigned char *father_key_pos, internal::my_off_t father_page,
 
376
               unsigned char *father_buff, unsigned char *father_key_pos, my_off_t father_page,
378
377
               bool insert_last)
379
378
{
380
379
  uint32_t a_length,nod_flag;
396
395
    if (t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
397
396
    {
398
397
      mi_print_error(info->s, HA_ERR_CRASHED);
399
 
      errno=HA_ERR_CRASHED;
 
398
      my_errno=HA_ERR_CRASHED;
400
399
      return(-1);
401
400
    }
402
 
    internal::bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,(uint) (endpos-key_pos));
 
401
    bmove_upp((unsigned char*) endpos+t_length,(unsigned char*) endpos,(uint) (endpos-key_pos));
403
402
  }
404
403
  else
405
404
  {
406
405
    if (-t_length >= keyinfo->maxlength*2+MAX_POINTER_LENGTH)
407
406
    {
408
407
      mi_print_error(info->s, HA_ERR_CRASHED);
409
 
      errno=HA_ERR_CRASHED;
 
408
      my_errno=HA_ERR_CRASHED;
410
409
      return(-1);
411
410
    }
412
411
    memmove(key_pos, key_pos - t_length, endpos - key_pos + t_length);
437
436
{
438
437
  uint32_t length,a_length,key_ref_length,t_length,nod_flag,key_length;
439
438
  unsigned char *key_pos,*pos, *after_key= NULL;
440
 
  internal::my_off_t new_pos;
 
439
  my_off_t new_pos;
441
440
  MI_KEY_PARAM s_temp;
442
441
 
443
442
  if (info->s->keyinfo+info->lastinx == keyinfo)
576
575
    if (!(length=(*keyinfo->get_key)(keyinfo,0,&page,key_buff)))
577
576
    {
578
577
      mi_print_error(keyinfo->share, HA_ERR_CRASHED);
579
 
      errno=HA_ERR_CRASHED;
 
578
      my_errno=HA_ERR_CRASHED;
580
579
      return(0);
581
580
    }
582
581
  }
591
590
 
592
591
static int _mi_balance_page(register MI_INFO *info, MI_KEYDEF *keyinfo,
593
592
                            unsigned char *key, unsigned char *curr_buff, unsigned char *father_buff,
594
 
                            unsigned char *father_key_pos, internal::my_off_t father_page)
 
593
                            unsigned char *father_key_pos, my_off_t father_page)
595
594
{
596
595
  bool right;
597
596
  uint32_t k_length,father_length,father_keylength,nod_flag,curr_keylength,
598
597
       right_length,left_length,new_right_length,new_left_length,extra_length,
599
598
       length,keys;
600
599
  unsigned char *pos,*buff,*extra_buff;
601
 
  internal::my_off_t next_page,new_pos;
 
600
  my_off_t next_page,new_pos;
602
601
  unsigned char tmp_part_key[MI_MAX_KEY_BUFF];
603
602
 
604
603
  k_length=keyinfo->keylength;
656
655
    else
657
656
    {                                           /* Move keys -> buff */
658
657
 
659
 
      internal::bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) buff+right_length,
 
658
      bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) buff+right_length,
660
659
                right_length-2);
661
660
      length=new_right_length-right_length-k_length;
662
661
      memcpy(buff+2+length,father_key_pos, k_length);
689
688
  /* Save new parting key */
690
689
  memcpy(tmp_part_key, pos-k_length,k_length);
691
690
  /* Make place for new keys */
692
 
  internal::bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) pos-k_length,
 
691
  bmove_upp((unsigned char*) buff+new_right_length,(unsigned char*) pos-k_length,
693
692
            right_length-extra_length-k_length-2);
694
693
  /* Copy keys from left page */
695
694
  pos= curr_buff+new_left_length;