← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_create.cc

Reworked getTableNames() interface. Way simpler, less mallocs....

Added a straight vector<> for use with storage engines.

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"
21
 
 
22
 
#include "drizzled/util/test.h"
23
 
#include "drizzled/global_charset_info.h"
24
 
#include "drizzled/error.h"
25
 
 
26
 
#include <cassert>
 
18
#include "myisamdef.h"
 
19
#include <mysys/my_tree.h>
 
20
#include <mysys/my_bit.h>
 
21
 
 
22
#include <drizzled/util/test.h>
 
23
 
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 */
265
261
        case HA_KEYTYPE_ULONG_INT:
266
262
        case HA_KEYTYPE_LONGLONG:
267
263
        case HA_KEYTYPE_ULONGLONG:
 
264
        case HA_KEYTYPE_UINT24:
268
265
          keyseg->flag|= HA_SWAP_KEY;
269
266
          break;
270
267
        case HA_KEYTYPE_VARTEXT1:
324
321
    key_segs+=keydef->keysegs;
325
322
    if (keydef->keysegs > MI_MAX_KEY_SEG)
326
323
    {
327
 
      errno=HA_WRONG_CREATE_OPTION;
 
324
      my_errno=HA_WRONG_CREATE_OPTION;
328
325
      goto err;
329
326
    }
330
327
    /*
349
346
    if (keydef->block_length > MI_MAX_KEY_BLOCK_LENGTH ||
350
347
        length >= MI_MAX_KEY_BUFF)
351
348
    {
352
 
      errno=HA_WRONG_CREATE_OPTION;
 
349
      my_errno=HA_WRONG_CREATE_OPTION;
353
350
      goto err;
354
351
    }
355
352
    set_if_bigger(max_key_block_length,(uint32_t)keydef->block_length);
392
389
  /* There are only 16 bits for the total header length. */
393
390
  if (info_length > 65535)
394
391
  {
395
 
    my_printf_error(EE_OK, "MyISAM table '%s' has too many columns and/or "
 
392
    my_printf_error(0, "MyISAM table '%s' has too many columns and/or "
396
393
                    "indexes and/or unique constraints.",
397
 
                    MYF(0), name + internal::dirname_length(name));
398
 
    errno= HA_WRONG_CREATE_OPTION;
 
394
                    MYF(0), name + dirname_length(name));
 
395
    my_errno= HA_WRONG_CREATE_OPTION;
399
396
    goto err;
400
397
  }
401
398
 
457
454
 
458
455
  /* max_data_file_length and max_key_file_length are recalculated on open */
459
456
  if (options & HA_OPTION_TMP_TABLE)
460
 
    share.base.max_data_file_length=(internal::my_off_t) ci->data_file_length;
 
457
    share.base.max_data_file_length=(my_off_t) ci->data_file_length;
461
458
 
462
459
  share.base.min_block_length=
463
460
    (share.base.pack_reclength+3 < MI_EXTEND_BLOCK_LENGTH &&
467
464
  if (! (flags & HA_DONT_TOUCH_DATA))
468
465
    share.state.create_time= (long) time((time_t*) 0);
469
466
 
470
 
  THR_LOCK_myisam.lock();
 
467
  pthread_mutex_lock(&THR_LOCK_myisam);
471
468
 
472
469
  /*
473
470
    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, ...).
 
471
    MY_RETURN_REAL_PATH for every fn_format(filename, ...).
475
472
  */
476
473
  if (ci->index_file_name)
477
474
  {
483
480
      /* chop off the table name, tempory tables use generated name */
484
481
      if ((path= strrchr((char *)ci->index_file_name, FN_LIBCHAR)))
485
482
        *path= '\0';
486
 
      internal::fn_format(filename, name, ci->index_file_name, MI_NAME_IEXT,
 
483
      fn_format(filename, name, ci->index_file_name, MI_NAME_IEXT,
487
484
                MY_REPLACE_DIR | MY_UNPACK_FILENAME |
488
485
                MY_RETURN_REAL_PATH | MY_APPEND_EXT);
489
486
    }
490
487
    else
491
488
    {
492
 
      internal::fn_format(filename, ci->index_file_name, "", MI_NAME_IEXT,
 
489
      fn_format(filename, ci->index_file_name, "", MI_NAME_IEXT,
493
490
                MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
494
491
                (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
495
492
    }
496
 
    internal::fn_format(linkname, name, "", MI_NAME_IEXT,
 
493
    fn_format(linkname, name, "", MI_NAME_IEXT,
497
494
              MY_UNPACK_FILENAME|MY_APPEND_EXT);
498
495
    linkname_ptr=linkname;
499
496
    /*
506
503
  {
507
504
    char *iext= strrchr((char *)name, '.');
508
505
    int have_iext= iext && !strcmp(iext, MI_NAME_IEXT);
509
 
    internal::fn_format(filename, name, "", MI_NAME_IEXT,
 
506
    fn_format(filename, name, "", MI_NAME_IEXT,
510
507
              MY_UNPACK_FILENAME | MY_RETURN_REAL_PATH |
511
508
              (have_iext ? MY_REPLACE_EXT : MY_APPEND_EXT));
512
509
    linkname_ptr=0;
526
523
  */
527
524
  if (test_if_reopen(filename))
528
525
  {
529
 
    my_printf_error(EE_OK, "MyISAM table '%s' is in use "
 
526
    my_printf_error(0, "MyISAM table '%s' is in use "
530
527
                    "(most likely by a MERGE table). Try FLUSH TABLES.",
531
 
                    MYF(0), name + internal::dirname_length(name));
532
 
    errno= HA_ERR_TABLE_EXIST;
 
528
                    MYF(0), name + dirname_length(name));
 
529
    my_errno= HA_ERR_TABLE_EXIST;
533
530
    goto err;
534
531
  }
535
532
 
536
 
  if ((file= internal::my_create_with_symlink(linkname_ptr,
537
 
                                              filename,
538
 
                                              0,
539
 
                                              create_mode,
540
 
                                              MYF(MY_WME | create_flag))) < 0)
 
533
  if ((file= my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
 
534
                                    MYF(MY_WME | create_flag))) < 0)
541
535
    goto err;
542
536
  errpos=1;
543
537
 
555
549
          /* chop off the table name, tempory tables use generated name */
556
550
          if ((path= strrchr((char *)ci->data_file_name, FN_LIBCHAR)))
557
551
            *path= '\0';
558
 
          internal::fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
 
552
          fn_format(filename, name, ci->data_file_name, MI_NAME_DEXT,
559
553
                    MY_REPLACE_DIR | MY_UNPACK_FILENAME | MY_APPEND_EXT);
560
554
        }
561
555
        else
562
556
        {
563
 
          internal::fn_format(filename, ci->data_file_name, "", MI_NAME_DEXT,
 
557
          fn_format(filename, ci->data_file_name, "", MI_NAME_DEXT,
564
558
                    MY_UNPACK_FILENAME |
565
559
                    (have_dext ? MY_REPLACE_EXT : MY_APPEND_EXT));
566
560
        }
567
561
 
568
 
        internal::fn_format(linkname, name, "",MI_NAME_DEXT,
 
562
        fn_format(linkname, name, "",MI_NAME_DEXT,
569
563
                  MY_UNPACK_FILENAME | MY_APPEND_EXT);
570
564
        linkname_ptr=linkname;
571
565
        create_flag=0;
572
566
      }
573
567
      else
574
568
      {
575
 
        internal::fn_format(filename,name,"", MI_NAME_DEXT,
 
569
        fn_format(filename,name,"", MI_NAME_DEXT,
576
570
                  MY_UNPACK_FILENAME | MY_APPEND_EXT);
577
571
        linkname_ptr=0;
578
572
        create_flag=(flags & HA_CREATE_KEEP_FILES) ? 0 : MY_DELETE_OLD;
579
573
      }
580
 
      if ((dfile= internal::my_create_with_symlink(linkname_ptr,
581
 
                                                   filename, 0, create_mode,
582
 
                                                   MYF(MY_WME | create_flag))) < 0)
 
574
      if ((dfile=
 
575
           my_create_with_symlink(linkname_ptr, filename, 0, create_mode,
 
576
                                  MYF(MY_WME | create_flag))) < 0)
583
577
        goto err;
584
578
    }
585
579
    errpos=3;
666
660
      goto err;
667
661
#endif
668
662
    errpos=2;
669
 
    if (internal::my_close(dfile,MYF(0)))
 
663
    if (my_close(dfile,MYF(0)))
670
664
      goto err;
671
665
  }
672
666
  errpos=0;
673
 
  THR_LOCK_myisam.unlock();
674
 
  if (internal::my_close(file,MYF(0)))
 
667
  pthread_mutex_unlock(&THR_LOCK_myisam);
 
668
  if (my_close(file,MYF(0)))
675
669
    goto err;
676
670
  free((char*) rec_per_key_part);
677
671
  return(0);
678
672
 
679
673
err:
680
 
  THR_LOCK_myisam.unlock();
681
 
  save_errno=errno;
 
674
  pthread_mutex_unlock(&THR_LOCK_myisam);
 
675
  save_errno=my_errno;
682
676
  switch (errpos) {
683
677
  case 3:
684
 
    internal::my_close(dfile,MYF(0));
 
678
    my_close(dfile,MYF(0));
685
679
    /* fall through */
686
680
  case 2:
687
681
  if (! (flags & HA_DONT_TOUCH_DATA))
688
 
    internal::my_delete_with_symlink(internal::fn_format(filename,name,"",MI_NAME_DEXT,
 
682
    my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_DEXT,
689
683
                                     MY_UNPACK_FILENAME | MY_APPEND_EXT),
690
684
                           MYF(0));
691
685
    /* fall through */
692
686
  case 1:
693
 
    internal::my_close(file,MYF(0));
 
687
    my_close(file,MYF(0));
694
688
    if (! (flags & HA_DONT_TOUCH_DATA))
695
 
      internal::my_delete_with_symlink(internal::fn_format(filename,name,"",MI_NAME_IEXT,
 
689
      my_delete_with_symlink(fn_format(filename,name,"",MI_NAME_IEXT,
696
690
                                       MY_UNPACK_FILENAME | MY_APPEND_EXT),
697
691
                             MYF(0));
698
692
  }
699
693
  free((char*) rec_per_key_part);
700
 
  return(errno=save_errno);             /* return the fatal errno */
 
694
  return(my_errno=save_errno);          /* return the fatal errno */
701
695
}
702
696
 
703
697