← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_create.cc

Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_create.cc
15
15
 
16
16
/* Create a MyISAM table */
17
17
 
18
 
#include "myisamdef.h"
19
 
#include <mysys/my_tree.h>
20
 
#include <mysys/my_bit.h>
21
 
 
22
 
#include <drizzled/util/test.h>
23
 
 
 
18
#include "myisam_priv.h"
 
19
#include "drizzled/internal/my_bit.h"
 
20
#include "drizzled/internal/my_sys.h"
 
21
 
 
22
#include "drizzled/util/test.h"
 
23
#include "drizzled/global_charset_info.h"
 
24
#include "drizzled/error.h"
 
25
 
 
26
#include <cassert>
24
27
#include <algorithm>
25
28
 
26
29
using namespace std;
 
30
using namespace drizzled;
27
31
 
28
32
/*
29
33
  Old options is used when recreating database, from myisamchk
35
39
              MI_CREATE_INFO *ci,uint32_t flags)
36
40
{
37
41
  register uint32_t i, j;
38
 
  File dfile= 0, file= 0;
 
42
  int dfile= 0, file= 0;
39
43
  int errpos,save_errno, create_mode= O_RDWR | O_TRUNC;
40
44
  myf create_flag;
41
45
  uint32_t fields,length,max_key_length,packed,pointer,real_length_diff,
54
58
  HA_KEYSEG *keyseg,tmp_keyseg;
55
59
  MI_COLUMNDEF *rec;
56
60
  ulong *rec_per_key_part;
57
 
  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
 
61
  internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
58
62
  MI_CREATE_INFO tmp_create_info;
59
63
 
60
64
  if (!ci)
65
69
 
66
70
  if (keys + uniques > MI_MAX_KEY || columns == 0)
67
71
  {
68
 
    return(my_errno=HA_WRONG_CREATE_OPTION);
 
72
    return(errno=HA_WRONG_CREATE_OPTION);
69
73
  }
70
74
  errpos= 0;
71
75
  options= 0;
88
92
 
89
93
  if (!(rec_per_key_part=
90
94
        (ulong*) malloc((keys + uniques)*MI_MAX_KEY_SEG*sizeof(long))))
91
 
    return(my_errno);
 
95
    return(errno);
92
96
  memset(rec_per_key_part, 0, (keys + uniques)*MI_MAX_KEY_SEG*sizeof(long));
93
97
 
94
98
        /* Start by checking fields and field-types used */
232
236
      /* Test if prefix compression */
233
237
      if (keydef->flag & HA_PACK_KEY)
234
238
      {
235
 
        /* Can't use space_compression on number keys */
236
 
        if ((keydef->seg[0].flag & HA_SPACE_PACK) &&
237
 
            keydef->seg[0].type == (int) HA_KEYTYPE_NUM)
238
 
          keydef->seg[0].flag&= ~HA_SPACE_PACK;
239
 
 
240
239
        /* Only use HA_PACK_KEY when first segment is a variable length key */
241
240
        if (!(keydef->seg[0].flag & (HA_SPACE_PACK | HA_BLOB_PART |
242
241
                                     HA_VAR_LENGTH_PART)))
261
260
      {
262
261
        /* numbers are stored with high by first to make compression easier */
263
262
        switch (keyseg->type) {
264
 
        case HA_KEYTYPE_SHORT_INT:
265
263
        case HA_KEYTYPE_LONG_INT:
266
 
        case HA_KEYTYPE_FLOAT:
267
264
        case HA_KEYTYPE_DOUBLE:
268
 
        case HA_KEYTYPE_USHORT_INT:
269
265
        case HA_KEYTYPE_ULONG_INT:
270
266
        case HA_KEYTYPE_LONGLONG:
271
267
        case HA_KEYTYPE_ULONGLONG:
272
 
        case HA_KEYTYPE_INT24:
273
268
        case HA_KEYTYPE_UINT24:
274
 
        case HA_KEYTYPE_INT8:
275
269
          keyseg->flag|= HA_SWAP_KEY;
276
270
          break;
277
271
        case HA_KEYTYPE_VARTEXT1:
331
325
    key_segs+=keydef->keysegs;
332
326
    if (keydef->keysegs > MI_MAX_KEY_SEG)
333
327
    {
334
 
      my_errno=HA_WRONG_CREATE_OPTION;
 
328
      errno=HA_WRONG_CREATE_OPTION;
335
329
      goto err;
336
330
    }
337
331
    /*
356
350
    if (keydef->block_length > MI_MAX_KEY_BLOCK_LENGTH ||
357
351
        length >= MI_MAX_KEY_BUFF)
358
352
    {
359
 
      my_errno=HA_WRONG_CREATE_OPTION;
 
353
      errno=HA_WRONG_CREATE_OPTION;
360
354
      goto err;
361
355
    }
362
356
    set_if_bigger(max_key_block_length,(uint32_t)keydef->block_length);
401
395
  {
402
396
    my_printf_error(0, "MyISAM table '%s' has too many columns and/or "
403
397
                    "indexes and/or unique constraints.",
404
 
                    MYF(0), name + dirname_length(name));
405
 
    my_errno= HA_WRONG_CREATE_OPTION;
 
398
                    MYF(0), name + internal::dirname_length(name));
 
399
    errno= HA_WRONG_CREATE_OPTION;
406
400
    goto err;
407
401
  }
408
402
 
464
458
 
465
459
  /* max_data_file_length and max_key_file_length are recalculated on open */
466
460
  if (options & HA_OPTION_TMP_TABLE)
467
 
    share.base.max_data_file_length=(my_off_t) ci->data_file_length;
 
461
    share.base.max_data_file_length=(internal::my_off_t) ci->data_file_length;
468
462
 
469
463
  share.base.min_block_length=
470
464
    (share.base.pack_reclength+3 < MI_EXTEND_BLOCK_LENGTH &&
478
472
 
479
473
  /*
480
474
    NOTE: For test_if_reopen() we need a real path name. Hence we need
481
 
    MY_RETURN_REAL_PATH for every fn_format(filename, ...).
 
475
    MY_RETURN_REAL_PATH for every internal::fn_format(filename, ...).
482
476
  */
483
477
  if (ci->index_file_name)
484
478
  {
490
484
      /* chop off the table name, tempory tables use generated name */
491
485
      if ((path= strrchr((char *)ci->index_file_name, FN_LIBCHAR)))
492
486
        *path= '\0';
493
 
      fn_format(filename, name, ci->index_file_name, MI_NAME_IEXT,
 
487
      internal::fn_format(filename, name, ci->index_file_name, MI_NAME_IEXT,
494
488
                MY_REPLACE_DIR | MY_UNPACK_FILENAME |
495
489
                MY_RETURN_REAL_PATH | MY_APPEND_EXT);
496
490
    }
497
491
    else
498
492
    {
499
 
      fn_format(filename, ci->index_file_name, "", MI_NAME_IEXT,
 
493
      internal::fn_format(filename, ci->index_file_name, "", MI_NAME_IEXT,
500
494
                MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
501
495
                (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
502
496
    }
503
 
    fn_format(linkname, name, "", MI_NAME_IEXT,
 
497
    internal::fn_format(linkname, name, "", MI_NAME_IEXT,
504
498
              MY_UNPACK_FILENAME|MY_APPEND_EXT);
505
499
    linkname_ptr=linkname;
506
500
    /*
513
507
  {
514
508
    char *iext= strrchr((char *)name, '.');
515
509
    int have_iext= iext && !strcmp(iext, MI_NAME_IEXT);
516
 
    fn_format(filename, name, "", MI_NAME_IEXT,
 
510
    internal::fn_format(filename, name, "", MI_NAME_IEXT,
517
511
              MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
518
512
              (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
519
513
    linkname_ptr=0;
535
529
  {
536
530
    my_printf_error(0, "MyISAM table '%s' is in use "
537
531
                    "(most likely by a MERGE table). Try FLUSH TABLES.",
538
 
                    MYF(0), name + dirname_length(name));
539
 
    my_errno= HA_ERR_TABLE_EXIST;
 
532
                    MYF(0), name + internal::dirname_length(name));
 
533
    errno= HA_ERR_TABLE_EXIST;
540
534
    goto err;
541
535
  }
542
536
 
543
 
  if ((file= my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
544
 
                                    MYF(MY_WME | create_flag))) < 0)
 
537
  if ((file= internal::my_create_with_symlink(linkname_ptr,
 
538
                                              filename,
 
539
                                              0,
 
540
                                              create_mode,
 
541
                                              MYF(MY_WME | create_flag))) < 0)
545
542
    goto err;
546
543
  errpos=1;
547
544
 
559
556
          /* chop off the table name, tempory tables use generated name */
560
557
          if ((path= strrchr((char *)ci->data_file_name, FN_LIBCHAR)))
561
558
            *path= '\0';
562
 
          fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
 
559
          internal::fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
563
560
                    MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_APPEND_EXT);
564
561
        }
565
562
        else
566
563
        {
567
 
          fn_format(filename, ci->data_file_name, "", MI_NAME_DEXT,
 
564
          internal::fn_format(filename, ci->data_file_name, "", MI_NAME_DEXT,
568
565
                    MY_UNPACK_FILENAME |
569
566
                    (have_dext ? MY_REPLACE_EXT : MY_APPEND_EXT));
570
567
        }
571
568
 
572
 
        fn_format(linkname, name, "",MI_NAME_DEXT,
 
569
        internal::fn_format(linkname, name, "",MI_NAME_DEXT,
573
570
                  MY_UNPACK_FILENAME | MY_APPEND_EXT);
574
571
        linkname_ptr=linkname;
575
572
        create_flag=0;
576
573
      }
577
574
      else
578
575
      {
579
 
        fn_format(filename,name,"", MI_NAME_DEXT,
 
576
        internal::fn_format(filename,name,"", MI_NAME_DEXT,
580
577
                  MY_UNPACK_FILENAME | MY_APPEND_EXT);
581
578
        linkname_ptr=0;
582
579
        create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
583
580
      }
584
 
      if ((dfile=
585
 
           my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
586
 
                                  MYF(MY_WME | create_flag))) < 0)
 
581
      if ((dfile= internal::my_create_with_symlink(linkname_ptr,
 
582
                                                   filename, 0, create_mode,
 
583
                                                   MYF(MY_WME | create_flag))) < 0)
587
584
        goto err;
588
585
    }
589
586
    errpos=3;
670
667
      goto err;
671
668
#endif
672
669
    errpos=2;
673
 
    if (my_close(dfile,MYF(0)))
 
670
    if (internal::my_close(dfile,MYF(0)))
674
671
      goto err;
675
672
  }
676
673
  errpos=0;
677
674
  pthread_mutex_unlock(&THR_LOCK_myisam);
678
 
  if (my_close(file,MYF(0)))
 
675
  if (internal::my_close(file,MYF(0)))
679
676
    goto err;
680
677
  free((char*) rec_per_key_part);
681
678
  return(0);
682
679
 
683
680
err:
684
681
  pthread_mutex_unlock(&THR_LOCK_myisam);
685
 
  save_errno=my_errno;
 
682
  save_errno=errno;
686
683
  switch (errpos) {
687
684
  case 3:
688
 
    my_close(dfile,MYF(0));
 
685
    internal::my_close(dfile,MYF(0));
689
686
    /* fall through */
690
687
  case 2:
691
688
  if (! (flags & HA_DONT_TOUCH_DATA))
692
 
    my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_DEXT,
 
689
    internal::my_delete_with_symlink(internal::fn_format(filename,name,"",MI_NAME_DEXT,
693
690
                                     MY_UNPACK_FILENAME | MY_APPEND_EXT),
694
691
                           MYF(0));
695
692
    /* fall through */
696
693
  case 1:
697
 
    my_close(file,MYF(0));
 
694
    internal::my_close(file,MYF(0));
698
695
    if (! (flags & HA_DONT_TOUCH_DATA))
699
 
      my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_IEXT,
 
696
      internal::my_delete_with_symlink(internal::fn_format(filename,name,"",MI_NAME_IEXT,
700
697
                                       MY_UNPACK_FILENAME | MY_APPEND_EXT),
701
698
                             MYF(0));
702
699
  }
703
700
  free((char*) rec_per_key_part);
704
 
  return(my_errno=save_errno);          /* return the fatal errno */
 
701
  return(errno=save_errno);             /* return the fatal errno */
705
702
}
706
703
 
707
704