← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_create.cc

  • Committer: Jay Pipes
  • Date: 2009-09-15 21:01:42 UTC
  • mto: (1126.2.5 merge)
  • mto: This revision was merged to the branch mainline in revision 1128.
  • Revision ID: jpipes@serialcoder-20090915210142-x8mwiqn1q0vzjspp
Moves Alter_info out into its own header and source file, cleans up some related include mess in sql_lex.h, and renames Alter_info to AlterInfo.

Show diffs side-by-side

added added

removed removed

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