← Back to branch summary

~mdcallag/+junk/5.1-map

« back to all changes in this revision

Viewing changes to storage/ndb/src/ndbapi/NdbDictionary.cpp

  • Committer: msvensson at pilot
  • Date: 2007-04-24 09:11:45 UTC
  • mfrom: (2469.1.106)
  • Revision ID: sp1r-msvensson@pilot.blaudden-20070424091145-10463
Merge pilot.blaudden:/home/msvensson/mysql/my51-m-mysql_upgrade
into  pilot.blaudden:/home/msvensson/mysql/mysql-5.1-maint

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/ndbapi/NdbDictionary.cpp
78
78
  return *this;
79
79
}
80
80
 
81
 
void 
 
81
int
82
82
NdbDictionary::Column::setName(const char * name){
83
 
  m_impl.m_name.assign(name);
 
83
  return !m_impl.m_name.assign(name);
84
84
}
85
85
 
86
86
const char* 
234
234
  m_impl.m_autoIncrementInitialValue = val;
235
235
}
236
236
 
237
 
void
 
237
int
238
238
NdbDictionary::Column::setDefaultValue(const char* defaultValue)
239
239
{
240
 
  m_impl.m_defaultValue.assign(defaultValue);
 
240
  return !m_impl.m_defaultValue.assign(defaultValue);
241
241
}
242
242
 
243
243
const char*
327
327
  return *this;
328
328
}
329
329
 
330
 
void 
 
330
int
331
331
NdbDictionary::Table::setName(const char * name){
332
 
  m_impl.setName(name);
 
332
  return m_impl.setName(name);
333
333
}
334
334
 
335
335
const char * 
347
347
  return m_impl.m_id;
348
348
}
349
349
 
350
 
void 
 
350
int
351
351
NdbDictionary::Table::addColumn(const Column & c){
352
352
  NdbColumnImpl* col = new NdbColumnImpl;
 
353
  if (col ==  NULL)
 
354
  {
 
355
    errno = ENOMEM;
 
356
    return -1;
 
357
  }
353
358
  (* col) = NdbColumnImpl::getImpl(c);
354
 
  m_impl.m_columns.push_back(col);
355
 
  m_impl.buildColumnHash();
 
359
  if (m_impl.m_columns.push_back(col))
 
360
  {
 
361
    return -1;
 
362
  }
 
363
  if (m_impl.buildColumnHash())
 
364
  {
 
365
    return -1;
 
366
  }
 
367
  return 0;
356
368
}
357
369
 
358
370
const NdbDictionary::Column*
495
507
  return m_impl.getFrmLength();
496
508
}
497
509
 
 
510
enum NdbDictionary::Table::SingleUserMode
 
511
NdbDictionary::Table::getSingleUserMode() const
 
512
{
 
513
  return (enum SingleUserMode)m_impl.m_single_user_mode;
 
514
}
 
515
 
498
516
void
 
517
NdbDictionary::Table::setSingleUserMode(enum NdbDictionary::Table::SingleUserMode mode)
 
518
{
 
519
  m_impl.m_single_user_mode = (Uint8)mode;
 
520
}
 
521
 
 
522
int
499
523
NdbDictionary::Table::setTablespaceNames(const void *data, Uint32 len)
500
524
{
501
 
  m_impl.setTablespaceNames(data, len);
 
525
  return m_impl.setTablespaceNames(data, len);
502
526
}
503
527
 
504
528
const void*
537
561
  return m_impl.getFragmentCount();
538
562
}
539
563
 
540
 
void
 
564
int
541
565
NdbDictionary::Table::setFrm(const void* data, Uint32 len){
542
 
  m_impl.setFrm(data, len);
 
566
  return m_impl.setFrm(data, len);
543
567
}
544
568
 
545
569
const void* 
552
576
  return m_impl.getFragmentDataLen();
553
577
}
554
578
 
555
 
void
 
579
int
556
580
NdbDictionary::Table::setFragmentData(const void* data, Uint32 len)
557
581
{
558
 
  m_impl.setFragmentData(data, len);
 
582
  return m_impl.setFragmentData(data, len);
559
583
}
560
584
 
561
585
const void* 
568
592
  return m_impl.getTablespaceDataLen();
569
593
}
570
594
 
571
 
void
 
595
int
572
596
NdbDictionary::Table::setTablespaceData(const void* data, Uint32 len)
573
597
{
574
 
  m_impl.setTablespaceData(data, len);
 
598
  return m_impl.setTablespaceData(data, len);
575
599
}
576
600
 
577
601
const void* 
584
608
  return m_impl.getRangeListDataLen();
585
609
}
586
610
 
587
 
void
 
611
int
588
612
NdbDictionary::Table::setRangeListData(const void* data, Uint32 len)
589
613
{
590
 
  m_impl.setRangeListData(data, len);
 
614
  return m_impl.setRangeListData(data, len);
591
615
}
592
616
 
593
617
NdbDictionary::Object::Status
669
693
  return m_impl.m_tablespace_name.c_str();
670
694
}
671
695
 
672
 
void 
 
696
int
673
697
NdbDictionary::Table::setTablespaceName(const char * name){
674
698
  m_impl.m_tablespace_id = ~0;
675
699
  m_impl.m_tablespace_version = ~0;
676
 
  m_impl.m_tablespace_name.assign(name);
 
700
  return !m_impl.m_tablespace_name.assign(name);
677
701
}
678
702
 
679
 
void 
 
703
int
680
704
NdbDictionary::Table::setTablespace(const NdbDictionary::Tablespace & ts){
681
705
  m_impl.m_tablespace_id = NdbTablespaceImpl::getImpl(ts).m_id;
682
706
  m_impl.m_tablespace_version = ts.getObjectVersion();
683
 
  m_impl.m_tablespace_name.assign(ts.getName());
 
707
  return !m_impl.m_tablespace_name.assign(ts.getName());
684
708
}
685
709
 
686
710
void
719
743
/*****************************************************************
720
744
 * Index facade
721
745
 */
 
746
 
722
747
NdbDictionary::Index::Index(const char * name)
723
748
  : m_impl(* new NdbIndexImpl(* this))
724
749
{
737
762
  }
738
763
}
739
764
 
740
 
void 
 
765
int
741
766
NdbDictionary::Index::setName(const char * name){
742
 
  m_impl.setName(name);
 
767
  return m_impl.setName(name);
743
768
}
744
769
 
745
770
const char * 
747
772
  return m_impl.getName();
748
773
}
749
774
 
750
 
void 
 
775
int
751
776
NdbDictionary::Index::setTable(const char * table){
752
 
  m_impl.setTable(table);
 
777
  return m_impl.setTable(table);
753
778
}
754
779
 
755
780
const char * 
784
809
    return NULL;
785
810
}
786
811
 
787
 
void
 
812
int
788
813
NdbDictionary::Index::addColumn(const Column & c){
789
814
  NdbColumnImpl* col = new NdbColumnImpl;
 
815
  if (col == NULL)
 
816
  {
 
817
    errno = ENOMEM;
 
818
    return -1;
 
819
  }
790
820
  (* col) = NdbColumnImpl::getImpl(c);
791
 
  m_impl.m_columns.push_back(col);
 
821
  if (m_impl.m_columns.push_back(col))
 
822
  {
 
823
    return -1;
 
824
  }
 
825
  return 0;
792
826
}
793
827
 
794
 
void
 
828
int
795
829
NdbDictionary::Index::addColumnName(const char * name){
796
830
  const Column c(name);
797
 
  addColumn(c);
 
831
  return addColumn(c);
798
832
}
799
833
 
800
 
void
 
834
int
801
835
NdbDictionary::Index::addIndexColumn(const char * name){
802
836
  const Column c(name);
803
 
  addColumn(c);
 
837
  return addColumn(c);
804
838
}
805
839
 
806
 
void
 
840
int
807
841
NdbDictionary::Index::addColumnNames(unsigned noOfNames, const char ** names){
808
842
  for(unsigned i = 0; i < noOfNames; i++) {
809
843
    const Column c(names[i]);
810
 
    addColumn(c);
 
844
    if (addColumn(c))
 
845
    {
 
846
      return -1;
 
847
    }
811
848
  }
 
849
  return 0;
812
850
}
813
851
 
814
 
void
 
852
int
815
853
NdbDictionary::Index::addIndexColumns(int noOfNames, const char ** names){
816
854
  for(int i = 0; i < noOfNames; i++) {
817
855
    const Column c(names[i]);
818
 
    addColumn(c);
 
856
    if (addColumn(c))
 
857
    {
 
858
      return -1;
 
859
    }
819
860
  }
 
861
  return 0;
820
862
}
821
863
 
822
864
void
894
936
  }
895
937
}
896
938
 
897
 
void 
 
939
int
898
940
NdbDictionary::Event::setName(const char * name)
899
941
{
900
 
  m_impl.setName(name);
 
942
  return m_impl.setName(name);
901
943
}
902
944
 
903
945
const char *
918
960
  return m_impl.getTable();
919
961
}
920
962
 
921
 
void 
 
963
int
922
964
NdbDictionary::Event::setTable(const char * table)
923
965
{
924
 
  m_impl.setTable(table);
 
966
  return m_impl.setTable(table);
925
967
}
926
968
 
927
969
const char*
1253
1295
  return m_impl.m_free;
1254
1296
}
1255
1297
 
1256
 
void 
 
1298
int
1257
1299
NdbDictionary::Datafile::setTablespace(const char * tablespace){
1258
1300
  m_impl.m_filegroup_id = ~0;
1259
1301
  m_impl.m_filegroup_version = ~0;
1260
 
  m_impl.m_filegroup_name.assign(tablespace);
 
1302
  return !m_impl.m_filegroup_name.assign(tablespace);
1261
1303
}
1262
1304
 
1263
 
void 
 
1305
int
1264
1306
NdbDictionary::Datafile::setTablespace(const NdbDictionary::Tablespace & ts){
1265
1307
  m_impl.m_filegroup_id = NdbTablespaceImpl::getImpl(ts).m_id;
1266
1308
  m_impl.m_filegroup_version = ts.getObjectVersion();
1267
 
  m_impl.m_filegroup_name.assign(ts.getName());
 
1309
  return !m_impl.m_filegroup_name.assign(ts.getName());
1268
1310
}
1269
1311
 
1270
1312
const char *