lib/Chado/AutoDBI.pm

   1 ########DBI########
   2 package Chado::DBI;
   3
   4 # Created by SQL::Translator::Producer::TTSchema
   5 # Template used: dbi.tt2
   6
   7 use strict;
   8 use Data::Dumper;
   9 no warnings 'redefine';
  10 use base qw(Class::DBI::Pg);
  11
  12 # This is how you normally connect with Class DBI's connection pooling but
  13 # its very fragile for me on FC2.  I'm replacing it with the db_Main method below
  14 #Chado::DBI->set_db('Main', 'dbi:Pg:dbname=fake_chado_db_name;host=fake_chado_db_host;port=fake_chado_db_port', 'fake_chado_db_username', 'fake_chado_db_password');
  15
  16 my $db_options = { __PACKAGE__->_default_attributes };
  17 __PACKAGE__->_remember_handle('Main'); # so dbi_commit works
  18 $db_options->{AutoCommit} = 0;
  19
  20 sub db_Main {
  21   my $dbh;
  22   $dbh = DBI->connect_cached( 'dbi:Pg:dbname=fake_chado_db_name;host=fake_chado_db_host;port=fake_chado_db_port', 'fake_chado_db_username', 'fake_chado_db_password', $db_options );
  23   # clear the connection cache if can't ping
  24   if ($dbh->ping() < 1) {
  25     my $CachedKids_hashref = $dbh->{Driver}->{CachedKids};
  26     %$CachedKids_hashref = () if $CachedKids_hashref;
  27     $dbh = DBI->connect_cached( 'dbi:Pg:dbname=fake_chado_db_name;host=fake_chado_db_host;port=fake_chado_db_port', 'fake_chado_db_username', 'fake_chado_db_password', $db_options );
  28     warn("Database handle reset!: ".$dbh." ping: ".$dbh->ping());
  29   }
  30   return($dbh);
  31 }
  32
  33 sub search_ilike { shift->_do_search(ILIKE => @_ ) }
  34 sub search_lower {
  35    my $c = shift;
  36    my %q = @_;
  37    my %t;
  38    foreach my $k (keys %q){
  39      $t{"lower($k)"} = lc($q{$k});
  40    }
  41    $c->_do_search(LIKE => %t);
  42 }
  43
  44
  45 # debug method
  46 sub dump {
  47   my $self = shift;
  48   my %arg  = %{shift @_};
  49   $arg{'indent'} ||= 1;
  50   $arg{'depth'} ||= 3;
  51   $Data::Dumper::Maxdepth = $arg{'depth'} if defined $arg{'depth'};
  52   $Data::Dumper::Indent = $arg{'indent'} if defined $arg{'indent'};
  53   return(Dumper($arg{'object'}));
  54 }
  55
  56 #
  57 #
  58 # NOT PART OF THE API, but useful function which returns a single row
  59 #  and throws an error if more than one is returned
  60 #
  61 # Added as a utility function for modware
  62 #
  63 sub get_single_row {
  64    my ($proto, @args) = @_;
  65    my $class = ref $proto || $proto;
  66
  67    my @rows  = $class->search( @args );
  68
  69    my $count = @rows;
  70    die "only one row expected, @rows returned" if @rows > 1;
  71
  72    return $rows[0];
  73 }
  74
  75
  76 1;
  77
  78
  79 ########Chado::Expression_Pub########
  80
  81 package Chado::Expression_Pub;
  82 use base 'Chado::DBI';
  83 use Class::DBI::Pager;
  84 no warnings qw(redefine);
  85
  86 Chado::Expression_Pub->set_up_table('expression_pub');
  87
  88 #
  89 # Primary key accessors
  90 #
  91
  92 sub id { shift->expression_pub_id }
  93 sub expression_pub { shift->expression_pub_id }
  94
  95
  96
  97
  98 #
  99 # Has A
 100 #
 101
 102 Chado::Expression_Pub->has_a(expression_id => 'Chado::Expression');
 103
 104 sub Chado::Expression_Pub::expression { return shift->expression_id }
 105
 106
 107 Chado::Expression_Pub->has_a(pub_id => 'Chado::Pub');
 108
 109 sub Chado::Expression_Pub::pub { return shift->pub_id }
 110
 111
 112 #
 113 # Has Many
 114 #
 115
 116
 117
 118 # one to many to one
 119
 120 # one to many to many
 121
 122 #many to many to one
 123
 124 #many to many to many
 125
 126
 127
 128 1;
 129
 130 ########Chado::Assay########
 131
 132 package Chado::Assay;
 133 use base 'Chado::DBI';
 134 use Class::DBI::Pager;
 135 no warnings qw(redefine);
 136
 137 Chado::Assay->set_up_table('assay');
 138
 139 #
 140 # Primary key accessors
 141 #
 142
 143 sub id { shift->assay_id }
 144 sub assay { shift->assay_id }
 145
 146
 147
 148
 149 #
 150 # Has A
 151 #
 152
 153 Chado::Assay->has_a(arraydesign_id => 'Chado::Arraydesign');
 154
 155 sub Chado::Assay::arraydesign { return shift->arraydesign_id }
 156
 157
 158 Chado::Assay->has_a(protocol_id => 'Chado::Protocol');
 159
 160 sub Chado::Assay::protocol { return shift->protocol_id }
 161
 162
 163 Chado::Assay->has_a(operator_id => 'Chado::Contact');
 164
 165 sub Chado::Assay::contact { return shift->operator_id }
 166
 167
 168 Chado::Assay->has_a(dbxref_id => 'Chado::Dbxref');
 169
 170 sub Chado::Assay::dbxref { return shift->dbxref_id }
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180 #
 181 # Has Many
 182 #
 183
 184 Chado::Assay->has_many('study_assay_assay_id', 'Chado::Study_Assay' => 'assay_id');
 185
 186 Chado::Assay->has_many('acquisition_assay_id', 'Chado::Acquisition' => 'assay_id');
 187
 188
 189 sub acquisitions { return shift->acquisition_assay_id }
 190
 191 Chado::Assay->has_many('assay_biomaterial_assay_id', 'Chado::Assay_Biomaterial' => 'assay_id');
 192
 193
 194 sub assay_biomaterials { return shift->assay_biomaterial_assay_id }
 195
 196 Chado::Assay->has_many('studyfactorvalue_assay_id', 'Chado::Studyfactorvalue' => 'assay_id');
 197
 198
 199 sub studyfactorvalues { return shift->studyfactorvalue_assay_id }
 200
 201 Chado::Assay->has_many('assay_project_assay_id', 'Chado::Assay_Project' => 'assay_id');
 202
 203 Chado::Assay->has_many('assayprop_assay_id', 'Chado::Assayprop' => 'assay_id');
 204
 205
 206 sub assayprops { return shift->assayprop_assay_id }
 207
 208 Chado::Assay->has_many('control_assay_id', 'Chado::Control' => 'assay_id');
 209
 210
 211 sub controls { return shift->control_assay_id }
 212
 213
 214
 215
 216 #
 217 # Has Compound Many (many to many relationships in all their flavors)
 218 #
 219
 220
 221
 222 sub study_assay_assays { return shift->study_assay_assay_id }
 223
 224
 225
 226 sub assay_project_assays { return shift->assay_project_assay_id }
 227
 228
 229 # one to many to one
 230
 231
 232 # one2one #
 233 sub studys { my $self = shift; return map $_->study_id, $self->study_assay_assay_id }
 234
 235
 236
 237 sub projects { my $self = shift; return map $_->project_id, $self->assay_project_assay_id }
 238
 239 # one to many to many
 240
 241
 242
 243 #many to many to one
 244
 245
 246
 247 #many to many to many
 248
 249
 250
 251
 252
 253 1;
 254
 255 ########Chado::Db########
 256
 257 package Chado::Db;
 258 use base 'Chado::DBI';
 259 use Class::DBI::Pager;
 260 no warnings qw(redefine);
 261
 262 Chado::Db->set_up_table('db');
 263
 264 #
 265 # Primary key accessors
 266 #
 267
 268 sub id { shift->db_id }
 269 sub db { shift->db_id }
 270
 271
 272
 273
 274 #
 275 # Has A
 276 #
 277
 278
 279 #
 280 # Has Many
 281 #
 282
 283 Chado::Db->has_many('dbxref_db_id', 'Chado::Dbxref' => 'db_id');
 284
 285
 286 sub dbxrefs { return shift->dbxref_db_id }
 287
 288
 289
 290 # one to many to one
 291
 292 # one to many to many
 293
 294 #many to many to one
 295
 296 #many to many to many
 297
 298
 299
 300 1;
 301
 302 ########Chado::Study_Assay########
 303
 304 package Chado::Study_Assay;
 305 use base 'Chado::DBI';
 306 use Class::DBI::Pager;
 307 no warnings qw(redefine);
 308
 309 Chado::Study_Assay->set_up_table('study_assay');
 310
 311 #
 312 # Primary key accessors
 313 #
 314
 315 sub id { shift->study_assay_id }
 316 sub study_assay { shift->study_assay_id }
 317
 318
 319
 320
 321 #
 322 # Has A
 323 #
 324
 325 Chado::Study_Assay->has_a(study_id => 'Chado::Study');
 326
 327 sub Chado::Study_Assay::study { return shift->study_id }
 328
 329
 330 Chado::Study_Assay->has_a(assay_id => 'Chado::Assay');
 331
 332 sub Chado::Study_Assay::assay { return shift->assay_id }
 333
 334
 335 #
 336 # Has Many
 337 #
 338
 339
 340
 341 # one to many to one
 342
 343 # one to many to many
 344
 345 #many to many to one
 346
 347 #many to many to many
 348
 349
 350
 351 1;
 352
 353 ########Chado::Feature_Dbxref########
 354
 355 package Chado::Feature_Dbxref;
 356 use base 'Chado::DBI';
 357 use Class::DBI::Pager;
 358 no warnings qw(redefine);
 359
 360 Chado::Feature_Dbxref->set_up_table('feature_dbxref');
 361
 362 #
 363 # Primary key accessors
 364 #
 365
 366 sub id { shift->feature_dbxref_id }
 367 sub feature_dbxref { shift->feature_dbxref_id }
 368
 369
 370
 371
 372 #
 373 # Has A
 374 #
 375
 376 Chado::Feature_Dbxref->has_a(feature_id => 'Chado::Feature');
 377
 378 sub Chado::Feature_Dbxref::feature { return shift->feature_id }
 379
 380
 381 Chado::Feature_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
 382
 383 sub Chado::Feature_Dbxref::dbxref { return shift->dbxref_id }
 384
 385
 386 #
 387 # Has Many
 388 #
 389
 390
 391
 392 # one to many to one
 393
 394 # one to many to many
 395
 396 #many to many to one
 397
 398 #many to many to many
 399
 400
 401
 402 1;
 403
 404 ########Chado::Studyfactor########
 405
 406 package Chado::Studyfactor;
 407 use base 'Chado::DBI';
 408 use Class::DBI::Pager;
 409 no warnings qw(redefine);
 410
 411 Chado::Studyfactor->set_up_table('studyfactor');
 412
 413 #
 414 # Primary key accessors
 415 #
 416
 417 sub id { shift->studyfactor_id }
 418 sub studyfactor { shift->studyfactor_id }
 419
 420
 421
 422
 423 #
 424 # Has A
 425 #
 426
 427 Chado::Studyfactor->has_a(studydesign_id => 'Chado::Studydesign');
 428
 429 sub Chado::Studyfactor::studydesign { return shift->studydesign_id }
 430
 431
 432 Chado::Studyfactor->has_a(type_id => 'Chado::Cvterm');
 433
 434 sub Chado::Studyfactor::cvterm { return shift->type_id }
 435
 436
 437
 438 #
 439 # Has Many
 440 #
 441
 442 Chado::Studyfactor->has_many('studyfactorvalue_studyfactor_id', 'Chado::Studyfactorvalue' => 'studyfactor_id');
 443
 444
 445 sub studyfactorvalues { return shift->studyfactorvalue_studyfactor_id }
 446
 447
 448
 449 # one to many to one
 450
 451 # one to many to many
 452
 453 #many to many to one
 454
 455 #many to many to many
 456
 457
 458
 459 1;
 460
 461 ########Chado::Quantification########
 462
 463 package Chado::Quantification;
 464 use base 'Chado::DBI';
 465 use Class::DBI::Pager;
 466 no warnings qw(redefine);
 467
 468 Chado::Quantification->set_up_table('quantification');
 469
 470 #
 471 # Primary key accessors
 472 #
 473
 474 sub id { shift->quantification_id }
 475 sub quantification { shift->quantification_id }
 476
 477
 478
 479
 480 #
 481 # Has A
 482 #
 483
 484 Chado::Quantification->has_a(acquisition_id => 'Chado::Acquisition');
 485
 486 sub Chado::Quantification::acquisition { return shift->acquisition_id }
 487
 488
 489 Chado::Quantification->has_a(operator_id => 'Chado::Contact');
 490
 491 sub Chado::Quantification::contact { return shift->operator_id }
 492
 493
 494 Chado::Quantification->has_a(protocol_id => 'Chado::Protocol');
 495
 496 sub Chado::Quantification::protocol { return shift->protocol_id }
 497
 498
 499 Chado::Quantification->has_a(analysis_id => 'Chado::Analysis');
 500
 501 sub Chado::Quantification::analysis { return shift->analysis_id }
 502
 503
 504
 505
 506
 507
 508 #
 509 # Has Many
 510 #
 511
 512 Chado::Quantification->has_many('quantification_relationship_subject_id', 'Chado::Quantification_Relationship' => 'subject_id');
 513
 514 Chado::Quantification->has_many('quantification_relationship_object_id', 'Chado::Quantification_Relationship' => 'object_id');
 515
 516 Chado::Quantification->has_many('elementresult_quantification_id', 'Chado::Elementresult' => 'quantification_id');
 517
 518
 519 sub elementresults { return shift->elementresult_quantification_id }
 520
 521 Chado::Quantification->has_many('quantificationprop_quantification_id', 'Chado::Quantificationprop' => 'quantification_id');
 522
 523
 524 sub quantificationprops { return shift->quantificationprop_quantification_id }
 525
 526
 527
 528
 529 #
 530 # Has Compound Many (many to many relationships in all their flavors)
 531 #
 532
 533
 534 sub quantification_relationship_subjects { return shift->quantification_relationship_subject_id }
 535
 536
 537
 538 sub quantification_relationship_objects { return shift->quantification_relationship_object_id }
 539
 540 # one to many to one
 541
 542
 543 # one to many to many
 544
 545
 546 #many to many to one
 547
 548
 549 # many2one #
 550
 551
 552 sub quantification_relationship_subject_types { my $self = shift; return map $_->type_id, $self->quantification_relationship_subject_id }
 553
 554
 555 sub quantification_relationship_object_types { my $self = shift; return map $_->type_id, $self->quantification_relationship_object_id }
 556
 557
 558 #many to many to many
 559
 560
 561
 562
 563 1;
 564
 565 ########Chado::Mageml########
 566
 567 package Chado::Mageml;
 568 use base 'Chado::DBI';
 569 use Class::DBI::Pager;
 570 no warnings qw(redefine);
 571
 572 Chado::Mageml->set_up_table('mageml');
 573
 574 #
 575 # Primary key accessors
 576 #
 577
 578 sub id { shift->mageml_id }
 579 sub mageml { shift->mageml_id }
 580
 581
 582
 583
 584 #
 585 # Has A
 586 #
 587
 588
 589 #
 590 # Has Many
 591 #
 592
 593 Chado::Mageml->has_many('magedocumentation_mageml_id', 'Chado::Magedocumentation' => 'mageml_id');
 594
 595
 596 sub magedocumentations { return shift->magedocumentation_mageml_id }
 597
 598
 599
 600 # one to many to one
 601
 602 # one to many to many
 603
 604 #many to many to one
 605
 606 #many to many to many
 607
 608
 609
 610 1;
 611
 612 ########Chado::Organism_Dbxref########
 613
 614 package Chado::Organism_Dbxref;
 615 use base 'Chado::DBI';
 616 use Class::DBI::Pager;
 617 no warnings qw(redefine);
 618
 619 Chado::Organism_Dbxref->set_up_table('organism_dbxref');
 620
 621 #
 622 # Primary key accessors
 623 #
 624
 625 sub id { shift->organism_dbxref_id }
 626 sub organism_dbxref { shift->organism_dbxref_id }
 627
 628
 629
 630
 631 #
 632 # Has A
 633 #
 634
 635 Chado::Organism_Dbxref->has_a(organism_id => 'Chado::Organism');
 636
 637 sub Chado::Organism_Dbxref::organism { return shift->organism_id }
 638
 639
 640 Chado::Organism_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
 641
 642 sub Chado::Organism_Dbxref::dbxref { return shift->dbxref_id }
 643
 644
 645 #
 646 # Has Many
 647 #
 648
 649
 650
 651 # one to many to one
 652
 653 # one to many to many
 654
 655 #many to many to one
 656
 657 #many to many to many
 658
 659
 660
 661 1;
 662
 663 ########Chado::Feature_Expression########
 664
 665 package Chado::Feature_Expression;
 666 use base 'Chado::DBI';
 667 use Class::DBI::Pager;
 668 no warnings qw(redefine);
 669
 670 Chado::Feature_Expression->set_up_table('feature_expression');
 671
 672 #
 673 # Primary key accessors
 674 #
 675
 676 sub id { shift->feature_expression_id }
 677 sub feature_expression { shift->feature_expression_id }
 678
 679
 680
 681
 682 #
 683 # Has A
 684 #
 685
 686 Chado::Feature_Expression->has_a(expression_id => 'Chado::Expression');
 687
 688 sub Chado::Feature_Expression::expression { return shift->expression_id }
 689
 690
 691 Chado::Feature_Expression->has_a(feature_id => 'Chado::Feature');
 692
 693 sub Chado::Feature_Expression::feature { return shift->feature_id }
 694
 695
 696 Chado::Feature_Expression->has_a(pub_id => 'Chado::Pub');
 697
 698 sub Chado::Feature_Expression::pub { return shift->pub_id }
 699
 700
 701
 702 #
 703 # Has Many
 704 #
 705
 706 Chado::Feature_Expression->has_many('feature_expressionprop_feature_expression_id', 'Chado::Feature_Expressionprop' => 'feature_expression_id');
 707
 708
 709 sub feature_expressionprops { return shift->feature_expressionprop_feature_expression_id }
 710
 711
 712
 713 # one to many to one
 714
 715 # one to many to many
 716
 717 #many to many to one
 718
 719 #many to many to many
 720
 721
 722
 723 1;
 724
 725 ########Chado::Feature_Cvterm########
 726
 727 package Chado::Feature_Cvterm;
 728 use base 'Chado::DBI';
 729 use Class::DBI::Pager;
 730 no warnings qw(redefine);
 731
 732 Chado::Feature_Cvterm->set_up_table('feature_cvterm');
 733
 734 #
 735 # Primary key accessors
 736 #
 737
 738 sub id { shift->feature_cvterm_id }
 739 sub feature_cvterm { shift->feature_cvterm_id }
 740
 741
 742
 743
 744 #
 745 # Has A
 746 #
 747
 748 Chado::Feature_Cvterm->has_a(feature_id => 'Chado::Feature');
 749
 750 sub Chado::Feature_Cvterm::feature { return shift->feature_id }
 751
 752
 753 Chado::Feature_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
 754
 755 sub Chado::Feature_Cvterm::cvterm { return shift->cvterm_id }
 756
 757
 758 Chado::Feature_Cvterm->has_a(pub_id => 'Chado::Pub');
 759
 760 sub Chado::Feature_Cvterm::pub { return shift->pub_id }
 761
 762
 763
 764
 765
 766 #
 767 # Has Many
 768 #
 769
 770 Chado::Feature_Cvterm->has_many('feature_cvterm_dbxref_feature_cvterm_id', 'Chado::Feature_Cvterm_Dbxref' => 'feature_cvterm_id');
 771
 772 Chado::Feature_Cvterm->has_many('feature_cvtermprop_feature_cvterm_id', 'Chado::Feature_Cvtermprop' => 'feature_cvterm_id');
 773
 774
 775 sub feature_cvtermprops { return shift->feature_cvtermprop_feature_cvterm_id }
 776
 777 Chado::Feature_Cvterm->has_many('feature_cvterm_pub_feature_cvterm_id', 'Chado::Feature_Cvterm_Pub' => 'feature_cvterm_id');
 778
 779
 780
 781
 782 #
 783 # Has Compound Many (many to many relationships in all their flavors)
 784 #
 785
 786
 787 sub feature_cvterm_dbxref_feature_cvterms { return shift->feature_cvterm_dbxref_feature_cvterm_id }
 788
 789
 790
 791
 792 sub feature_cvterm_pub_feature_cvterms { return shift->feature_cvterm_pub_feature_cvterm_id }
 793
 794
 795 # one to many to one
 796
 797
 798 # one2one #
 799 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->feature_cvterm_dbxref_feature_cvterm_id }
 800
 801
 802
 803 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_cvterm_pub_feature_cvterm_id }
 804
 805 # one to many to many
 806
 807
 808
 809 #many to many to one
 810
 811
 812
 813 #many to many to many
 814
 815
 816
 817
 818
 819 1;
 820
 821 ########Chado::Arraydesign########
 822
 823 package Chado::Arraydesign;
 824 use base 'Chado::DBI';
 825 use Class::DBI::Pager;
 826 no warnings qw(redefine);
 827
 828 Chado::Arraydesign->set_up_table('arraydesign');
 829
 830 #
 831 # Primary key accessors
 832 #
 833
 834 sub id { shift->arraydesign_id }
 835 sub arraydesign { shift->arraydesign_id }
 836
 837
 838
 839
 840 #
 841 # Has A
 842 #
 843
 844
 845 Chado::Arraydesign->has_a(manufacturer_id => 'Chado::Contact');
 846
 847 sub Chado::Arraydesign::contact { return shift->manufacturer_id }
 848
 849
 850 Chado::Arraydesign->has_a(platformtype_id => 'Chado::Cvterm');
 851
 852 sub platformtype { return shift->platformtype_id }
 853
 854
 855 Chado::Arraydesign->has_a(substratetype_id => 'Chado::Cvterm');
 856
 857 sub substratetype { return shift->substratetype_id }
 858
 859
 860 Chado::Arraydesign->has_a(protocol_id => 'Chado::Protocol');
 861
 862 sub Chado::Arraydesign::protocol { return shift->protocol_id }
 863
 864
 865 Chado::Arraydesign->has_a(dbxref_id => 'Chado::Dbxref');
 866
 867 sub Chado::Arraydesign::dbxref { return shift->dbxref_id }
 868
 869
 870
 871
 872 #
 873 # Has Many
 874 #
 875
 876 Chado::Arraydesign->has_many('assay_arraydesign_id', 'Chado::Assay' => 'arraydesign_id');
 877
 878
 879 sub assays { return shift->assay_arraydesign_id }
 880
 881 Chado::Arraydesign->has_many('element_arraydesign_id', 'Chado::Element' => 'arraydesign_id');
 882
 883 Chado::Arraydesign->has_many('arraydesignprop_arraydesign_id', 'Chado::Arraydesignprop' => 'arraydesign_id');
 884
 885
 886 sub arraydesignprops { return shift->arraydesignprop_arraydesign_id }
 887
 888
 889
 890
 891 #
 892 # Has Compound Many (many to many relationships in all their flavors)
 893 #
 894
 895
 896
 897 sub element_arraydesigns { return shift->element_arraydesign_id }
 898
 899
 900
 901 sub element_arraydesigns { return shift->element_arraydesign_id }
 902
 903
 904
 905
 906 sub element_arraydesigns { return shift->element_arraydesign_id }
 907
 908
 909 # one to many to one
 910
 911
 912 # one2one #
 913 sub features { my $self = shift; return map $_->feature_id, $self->element_arraydesign_id }
 914
 915
 916
 917 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->element_arraydesign_id }
 918
 919
 920
 921 sub cvterms { my $self = shift; return map $_->type_id, $self->element_arraydesign_id }
 922
 923 # one to many to many
 924
 925
 926
 927
 928 #many to many to one
 929
 930
 931
 932
 933 #many to many to many
 934
 935
 936
 937
 938
 939
 940 1;
 941
 942 ########Chado::Phylonodeprop########
 943
 944 package Chado::Phylonodeprop;
 945 use base 'Chado::DBI';
 946 use Class::DBI::Pager;
 947 no warnings qw(redefine);
 948
 949 Chado::Phylonodeprop->set_up_table('phylonodeprop');
 950
 951 #
 952 # Primary key accessors
 953 #
 954
 955 sub id { shift->phylonodeprop_id }
 956 sub phylonodeprop { shift->phylonodeprop_id }
 957
 958
 959
 960
 961 #
 962 # Has A
 963 #
 964
 965 Chado::Phylonodeprop->has_a(phylonode_id => 'Chado::Phylonode');
 966
 967 sub Chado::Phylonodeprop::phylonode { return shift->phylonode_id }
 968
 969
 970 Chado::Phylonodeprop->has_a(type_id => 'Chado::Cvterm');
 971
 972 sub Chado::Phylonodeprop::cvterm { return shift->type_id }
 973
 974
 975 #
 976 # Has Many
 977 #
 978
 979
 980
 981 # one to many to one
 982
 983 # one to many to many
 984
 985 #many to many to one
 986
 987 #many to many to many
 988
 989
 990
 991 1;
 992
 993 ########Chado::Study########
 994
 995 package Chado::Study;
 996 use base 'Chado::DBI';
 997 use Class::DBI::Pager;
 998 no warnings qw(redefine);
 999
1000 Chado::Study->set_up_table('study');
1001
1002 #
1003 # Primary key accessors
1004 #
1005
1006 sub id { shift->study_id }
1007 sub study { shift->study_id }
1008
1009
1010
1011
1012 #
1013 # Has A
1014 #
1015
1016
1017 Chado::Study->has_a(contact_id => 'Chado::Contact');
1018
1019 sub Chado::Study::contact { return shift->contact_id }
1020
1021
1022 Chado::Study->has_a(pub_id => 'Chado::Pub');
1023
1024 sub Chado::Study::pub { return shift->pub_id }
1025
1026
1027 Chado::Study->has_a(dbxref_id => 'Chado::Dbxref');
1028
1029 sub Chado::Study::dbxref { return shift->dbxref_id }
1030
1031
1032
1033 #
1034 # Has Many
1035 #
1036
1037 Chado::Study->has_many('study_assay_study_id', 'Chado::Study_Assay' => 'study_id');
1038
1039 Chado::Study->has_many('studydesign_study_id', 'Chado::Studydesign' => 'study_id');
1040
1041
1042 sub studydesigns { return shift->studydesign_study_id }
1043
1044
1045
1046
1047 #
1048 # Has Compound Many (many to many relationships in all their flavors)
1049 #
1050
1051
1052 sub study_assay_studys { return shift->study_assay_study_id }
1053
1054
1055 # one to many to one
1056
1057
1058 # one2one #
1059 sub assays { my $self = shift; return map $_->assay_id, $self->study_assay_study_id }
1060
1061 # one to many to many
1062
1063
1064 #many to many to one
1065
1066
1067 #many to many to many
1068
1069
1070
1071
1072 1;
1073
1074 ########Chado::Stock_Cvterm########
1075
1076 package Chado::Stock_Cvterm;
1077 use base 'Chado::DBI';
1078 use Class::DBI::Pager;
1079 no warnings qw(redefine);
1080
1081 Chado::Stock_Cvterm->set_up_table('stock_cvterm');
1082
1083 #
1084 # Primary key accessors
1085 #
1086
1087 sub id { shift->stock_cvterm_id }
1088 sub stock_cvterm { shift->stock_cvterm_id }
1089
1090
1091
1092
1093 #
1094 # Has A
1095 #
1096
1097 Chado::Stock_Cvterm->has_a(stock_id => 'Chado::Stock');
1098
1099 sub Chado::Stock_Cvterm::stock { return shift->stock_id }
1100
1101
1102 Chado::Stock_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
1103
1104 sub Chado::Stock_Cvterm::cvterm { return shift->cvterm_id }
1105
1106
1107 Chado::Stock_Cvterm->has_a(pub_id => 'Chado::Pub');
1108
1109 sub Chado::Stock_Cvterm::pub { return shift->pub_id }
1110
1111
1112 #
1113 # Has Many
1114 #
1115
1116
1117
1118 # one to many to one
1119
1120 # one to many to many
1121
1122 #many to many to one
1123
1124 #many to many to many
1125
1126
1127
1128 1;
1129
1130 ########Chado::Biomaterial_Relationship########
1131
1132 package Chado::Biomaterial_Relationship;
1133 use base 'Chado::DBI';
1134 use Class::DBI::Pager;
1135 no warnings qw(redefine);
1136
1137 Chado::Biomaterial_Relationship->set_up_table('biomaterial_relationship');
1138
1139 #
1140 # Primary key accessors
1141 #
1142
1143 sub id { shift->biomaterial_relationship_id }
1144 sub biomaterial_relationship { shift->biomaterial_relationship_id }
1145
1146
1147
1148
1149 #
1150 # Has A
1151 #
1152
1153 Chado::Biomaterial_Relationship->has_a(subject_id => 'Chado::Biomaterial');
1154
1155 sub subject { return shift->subject_id }
1156
1157
1158 Chado::Biomaterial_Relationship->has_a(type_id => 'Chado::Cvterm');
1159
1160 sub Chado::Biomaterial_Relationship::cvterm { return shift->type_id }
1161
1162
1163 Chado::Biomaterial_Relationship->has_a(object_id => 'Chado::Biomaterial');
1164
1165 sub object { return shift->object_id }
1166
1167
1168 #
1169 # Has Many
1170 #
1171
1172
1173
1174 # one to many to one
1175
1176 # one to many to many
1177
1178 #many to many to one
1179
1180 #many to many to many
1181
1182
1183
1184 1;
1185
1186 ########Chado::Expression_Image########
1187
1188 package Chado::Expression_Image;
1189 use base 'Chado::DBI';
1190 use Class::DBI::Pager;
1191 no warnings qw(redefine);
1192
1193 Chado::Expression_Image->set_up_table('expression_image');
1194
1195 #
1196 # Primary key accessors
1197 #
1198
1199 sub id { shift->expression_image_id }
1200 sub expression_image { shift->expression_image_id }
1201
1202
1203
1204
1205 #
1206 # Has A
1207 #
1208
1209 Chado::Expression_Image->has_a(expression_id => 'Chado::Expression');
1210
1211 sub Chado::Expression_Image::expression { return shift->expression_id }
1212
1213
1214 Chado::Expression_Image->has_a(eimage_id => 'Chado::Eimage');
1215
1216 sub Chado::Expression_Image::eimage { return shift->eimage_id }
1217
1218
1219 #
1220 # Has Many
1221 #
1222
1223
1224
1225 # one to many to one
1226
1227 # one to many to many
1228
1229 #many to many to one
1230
1231 #many to many to many
1232
1233
1234
1235 1;
1236
1237 ########Chado::Stockprop_Pub########
1238
1239 package Chado::Stockprop_Pub;
1240 use base 'Chado::DBI';
1241 use Class::DBI::Pager;
1242 no warnings qw(redefine);
1243
1244 Chado::Stockprop_Pub->set_up_table('stockprop_pub');
1245
1246 #
1247 # Primary key accessors
1248 #
1249
1250 sub id { shift->stockprop_pub_id }
1251 sub stockprop_pub { shift->stockprop_pub_id }
1252
1253
1254
1255
1256 #
1257 # Has A
1258 #
1259
1260 Chado::Stockprop_Pub->has_a(stockprop_id => 'Chado::Stockprop');
1261
1262 sub Chado::Stockprop_Pub::stockprop { return shift->stockprop_id }
1263
1264
1265 Chado::Stockprop_Pub->has_a(pub_id => 'Chado::Pub');
1266
1267 sub Chado::Stockprop_Pub::pub { return shift->pub_id }
1268
1269
1270 #
1271 # Has Many
1272 #
1273
1274
1275
1276 # one to many to one
1277
1278 # one to many to many
1279
1280 #many to many to one
1281
1282 #many to many to many
1283
1284
1285
1286 1;
1287
1288 ########Chado::Cvtermprop########
1289
1290 package Chado::Cvtermprop;
1291 use base 'Chado::DBI';
1292 use Class::DBI::Pager;
1293 no warnings qw(redefine);
1294
1295 Chado::Cvtermprop->set_up_table('cvtermprop');
1296
1297 #
1298 # Primary key accessors
1299 #
1300
1301 sub id { shift->cvtermprop_id }
1302 sub cvtermprop { shift->cvtermprop_id }
1303
1304
1305
1306
1307 #
1308 # Has A
1309 #
1310
1311 Chado::Cvtermprop->has_a(cvterm_id => 'Chado::Cvterm');
1312
1313 sub cvterm { return shift->cvterm_id }
1314
1315
1316 Chado::Cvtermprop->has_a(type_id => 'Chado::Cvterm');
1317
1318 sub type { return shift->type_id }
1319
1320
1321 #
1322 # Has Many
1323 #
1324
1325
1326
1327 # one to many to one
1328
1329 # one to many to many
1330
1331 #many to many to one
1332
1333 #many to many to many
1334
1335
1336
1337 1;
1338
1339 ########Chado::Feature_Phenotype########
1340
1341 package Chado::Feature_Phenotype;
1342 use base 'Chado::DBI';
1343 use Class::DBI::Pager;
1344 no warnings qw(redefine);
1345
1346 Chado::Feature_Phenotype->set_up_table('feature_phenotype');
1347
1348 #
1349 # Primary key accessors
1350 #
1351
1352 sub id { shift->feature_phenotype_id }
1353 sub feature_phenotype { shift->feature_phenotype_id }
1354
1355
1356
1357
1358 #
1359 # Has A
1360 #
1361
1362 Chado::Feature_Phenotype->has_a(feature_id => 'Chado::Feature');
1363
1364 sub Chado::Feature_Phenotype::feature { return shift->feature_id }
1365
1366
1367 Chado::Feature_Phenotype->has_a(phenotype_id => 'Chado::Phenotype');
1368
1369 sub Chado::Feature_Phenotype::phenotype { return shift->phenotype_id }
1370
1371
1372 #
1373 # Has Many
1374 #
1375
1376
1377
1378 # one to many to one
1379
1380 # one to many to many
1381
1382 #many to many to one
1383
1384 #many to many to many
1385
1386
1387
1388 1;
1389
1390 ########Chado::Quantification_Relationship########
1391
1392 package Chado::Quantification_Relationship;
1393 use base 'Chado::DBI';
1394 use Class::DBI::Pager;
1395 no warnings qw(redefine);
1396
1397 Chado::Quantification_Relationship->set_up_table('quantification_relationship');
1398
1399 #
1400 # Primary key accessors
1401 #
1402
1403 sub id { shift->quantification_relationship_id }
1404 sub quantification_relationship { shift->quantification_relationship_id }
1405
1406
1407
1408
1409 #
1410 # Has A
1411 #
1412
1413 Chado::Quantification_Relationship->has_a(subject_id => 'Chado::Quantification');
1414
1415 sub subject { return shift->subject_id }
1416
1417
1418 Chado::Quantification_Relationship->has_a(type_id => 'Chado::Cvterm');
1419
1420 sub Chado::Quantification_Relationship::cvterm { return shift->type_id }
1421
1422
1423 Chado::Quantification_Relationship->has_a(object_id => 'Chado::Quantification');
1424
1425 sub object { return shift->object_id }
1426
1427
1428 #
1429 # Has Many
1430 #
1431
1432
1433
1434 # one to many to one
1435
1436 # one to many to many
1437
1438 #many to many to one
1439
1440 #many to many to many
1441
1442
1443
1444 1;
1445
1446 ########Chado::Element########
1447
1448 package Chado::Element;
1449 use base 'Chado::DBI';
1450 use Class::DBI::Pager;
1451 no warnings qw(redefine);
1452
1453 Chado::Element->set_up_table('element');
1454
1455 #
1456 # Primary key accessors
1457 #
1458
1459 sub id { shift->element_id }
1460 sub element { shift->element_id }
1461
1462
1463
1464
1465 #
1466 # Has A
1467 #
1468
1469 Chado::Element->has_a(feature_id => 'Chado::Feature');
1470
1471 sub Chado::Element::feature { return shift->feature_id }
1472
1473
1474 Chado::Element->has_a(arraydesign_id => 'Chado::Arraydesign');
1475
1476 sub Chado::Element::arraydesign { return shift->arraydesign_id }
1477
1478
1479 Chado::Element->has_a(type_id => 'Chado::Cvterm');
1480
1481 sub Chado::Element::cvterm { return shift->type_id }
1482
1483
1484 Chado::Element->has_a(dbxref_id => 'Chado::Dbxref');
1485
1486 sub Chado::Element::dbxref { return shift->dbxref_id }
1487
1488
1489
1490
1491
1492 #
1493 # Has Many
1494 #
1495
1496 Chado::Element->has_many('elementresult_element_id', 'Chado::Elementresult' => 'element_id');
1497
1498
1499 sub elementresults { return shift->elementresult_element_id }
1500
1501 Chado::Element->has_many('element_relationship_subject_id', 'Chado::Element_Relationship' => 'subject_id');
1502
1503
1504 sub element_relationship_subject_ids { my $self = shift; return $self->element_relationship_subject_id(@_) }
1505
1506 Chado::Element->has_many('element_relationship_object_id', 'Chado::Element_Relationship' => 'object_id');
1507
1508
1509 sub element_relationship_object_ids { my $self = shift; return $self->element_relationship_object_id(@_) }
1510
1511
1512
1513 # one to many to one
1514
1515 # one to many to many
1516
1517 #many to many to one
1518
1519 #many to many to many
1520
1521
1522
1523 1;
1524
1525 ########Chado::Analysis########
1526
1527 package Chado::Analysis;
1528 use base 'Chado::DBI';
1529 use Class::DBI::Pager;
1530 no warnings qw(redefine);
1531
1532 Chado::Analysis->set_up_table('analysis');
1533
1534 #
1535 # Primary key accessors
1536 #
1537
1538 sub id { shift->analysis_id }
1539 sub analysis { shift->analysis_id }
1540
1541
1542
1543
1544 #
1545 # Has A
1546 #
1547
1548
1549
1550
1551
1552 #
1553 # Has Many
1554 #
1555
1556 Chado::Analysis->has_many('quantification_analysis_id', 'Chado::Quantification' => 'analysis_id');
1557
1558
1559 sub quantifications { return shift->quantification_analysis_id }
1560
1561 Chado::Analysis->has_many('analysisfeature_analysis_id', 'Chado::Analysisfeature' => 'analysis_id');
1562
1563
1564 sub analysisfeatures { return shift->analysisfeature_analysis_id }
1565
1566 Chado::Analysis->has_many('analysisprop_analysis_id', 'Chado::Analysisprop' => 'analysis_id');
1567
1568
1569 sub analysisprops { return shift->analysisprop_analysis_id }
1570
1571 Chado::Analysis->has_many('phylotree_analysis_id', 'Chado::Phylotree' => 'analysis_id');
1572
1573
1574 sub phylotrees { return shift->phylotree_analysis_id }
1575
1576
1577
1578 # one to many to one
1579
1580 # one to many to many
1581
1582 #many to many to one
1583
1584 #many to many to many
1585
1586
1587
1588 1;
1589
1590 ########Chado::Eimage########
1591
1592 package Chado::Eimage;
1593 use base 'Chado::DBI';
1594 use Class::DBI::Pager;
1595 no warnings qw(redefine);
1596
1597 Chado::Eimage->set_up_table('eimage');
1598
1599 #
1600 # Primary key accessors
1601 #
1602
1603 sub id { shift->eimage_id }
1604 sub eimage { shift->eimage_id }
1605
1606
1607
1608
1609 #
1610 # Has A
1611 #
1612
1613
1614 #
1615 # Has Many
1616 #
1617
1618 Chado::Eimage->has_many('expression_image_eimage_id', 'Chado::Expression_Image' => 'eimage_id');
1619
1620
1621
1622
1623 #
1624 # Has Compound Many (many to many relationships in all their flavors)
1625 #
1626
1627
1628
1629 sub expression_image_eimages { return shift->expression_image_eimage_id }
1630
1631 # one to many to one
1632
1633
1634 # one2one #
1635 sub expressions { my $self = shift; return map $_->expression_id, $self->expression_image_eimage_id }
1636
1637 # one to many to many
1638
1639
1640 #many to many to one
1641
1642
1643 #many to many to many
1644
1645
1646
1647
1648 1;
1649
1650 ########Chado::Phenotype_Comparison_Cvterm########
1651
1652 package Chado::Phenotype_Comparison_Cvterm;
1653 use base 'Chado::DBI';
1654 use Class::DBI::Pager;
1655 no warnings qw(redefine);
1656
1657 Chado::Phenotype_Comparison_Cvterm->set_up_table('phenotype_comparison_cvterm');
1658
1659 #
1660 # Primary key accessors
1661 #
1662
1663 sub id { shift->phenotype_comparison_cvterm_id }
1664 sub phenotype_comparison_cvterm { shift->phenotype_comparison_cvterm_id }
1665
1666
1667
1668
1669 #
1670 # Has A
1671 #
1672
1673 Chado::Phenotype_Comparison_Cvterm->has_a(phenotype_comparison_id => 'Chado::Phenotype_Comparison');
1674
1675 sub Chado::Phenotype_Comparison_Cvterm::phenotype_comparison { return shift->phenotype_comparison_id }
1676
1677
1678 Chado::Phenotype_Comparison_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
1679
1680 sub Chado::Phenotype_Comparison_Cvterm::cvterm { return shift->cvterm_id }
1681
1682
1683 #
1684 # Has Many
1685 #
1686
1687
1688
1689 # one to many to one
1690
1691 # one to many to many
1692
1693 #many to many to one
1694
1695 #many to many to many
1696
1697
1698
1699 1;
1700
1701 ########Chado::Arraydesignprop########
1702
1703 package Chado::Arraydesignprop;
1704 use base 'Chado::DBI';
1705 use Class::DBI::Pager;
1706 no warnings qw(redefine);
1707
1708 Chado::Arraydesignprop->set_up_table('arraydesignprop');
1709
1710 #
1711 # Primary key accessors
1712 #
1713
1714 sub id { shift->arraydesignprop_id }
1715 sub arraydesignprop { shift->arraydesignprop_id }
1716
1717
1718
1719
1720 #
1721 # Has A
1722 #
1723
1724 Chado::Arraydesignprop->has_a(arraydesign_id => 'Chado::Arraydesign');
1725
1726 sub Chado::Arraydesignprop::arraydesign { return shift->arraydesign_id }
1727
1728
1729 Chado::Arraydesignprop->has_a(type_id => 'Chado::Cvterm');
1730
1731 sub Chado::Arraydesignprop::cvterm { return shift->type_id }
1732
1733
1734 #
1735 # Has Many
1736 #
1737
1738
1739
1740 # one to many to one
1741
1742 # one to many to many
1743
1744 #many to many to one
1745
1746 #many to many to many
1747
1748
1749
1750 1;
1751
1752 ########Chado::Synonym########
1753
1754 package Chado::Synonym;
1755 use base 'Chado::DBI';
1756 use Class::DBI::Pager;
1757 no warnings qw(redefine);
1758
1759 Chado::Synonym->set_up_table('synonym');
1760
1761 #
1762 # Primary key accessors
1763 #
1764
1765 sub id { shift->synonym_id }
1766 sub synonym { shift->synonym_id }
1767
1768
1769
1770
1771 #
1772 # Has A
1773 #
1774
1775 Chado::Synonym->has_a(type_id => 'Chado::Cvterm');
1776
1777 sub Chado::Synonym::cvterm { return shift->type_id }
1778
1779
1780
1781
1782 #
1783 # Has Many
1784 #
1785
1786 Chado::Synonym->has_many('feature_synonym_synonym_id', 'Chado::Feature_Synonym' => 'synonym_id');
1787
1788
1789 sub feature_synonyms { return shift->feature_synonym_synonym_id }
1790
1791 Chado::Synonym->has_many('library_synonym_synonym_id', 'Chado::Library_Synonym' => 'synonym_id');
1792
1793
1794 sub library_synonyms { return shift->library_synonym_synonym_id }
1795
1796
1797
1798 # one to many to one
1799
1800 # one to many to many
1801
1802 #many to many to one
1803
1804 #many to many to many
1805
1806
1807
1808 1;
1809
1810 ########Chado::Cvtermpath########
1811
1812 package Chado::Cvtermpath;
1813 use base 'Chado::DBI';
1814 use Class::DBI::Pager;
1815 no warnings qw(redefine);
1816
1817 Chado::Cvtermpath->set_up_table('cvtermpath');
1818
1819 #
1820 # Primary key accessors
1821 #
1822
1823 sub id { shift->cvtermpath_id }
1824 sub cvtermpath { shift->cvtermpath_id }
1825
1826
1827
1828
1829 #
1830 # Has A
1831 #
1832
1833 Chado::Cvtermpath->has_a(type_id => 'Chado::Cvterm');
1834
1835 sub type { return shift->type_id }
1836
1837
1838 Chado::Cvtermpath->has_a(subject_id => 'Chado::Cvterm');
1839
1840 sub subject { return shift->subject_id }
1841
1842
1843 Chado::Cvtermpath->has_a(object_id => 'Chado::Cvterm');
1844
1845 sub object { return shift->object_id }
1846
1847
1848 Chado::Cvtermpath->has_a(cv_id => 'Chado::Cv');
1849
1850 sub Chado::Cvtermpath::cv { return shift->cv_id }
1851
1852
1853 #
1854 # Has Many
1855 #
1856
1857
1858
1859 # one to many to one
1860
1861 # one to many to many
1862
1863 #many to many to one
1864
1865 #many to many to many
1866
1867
1868
1869 1;
1870
1871 ########Chado::Biomaterial_Treatment########
1872
1873 package Chado::Biomaterial_Treatment;
1874 use base 'Chado::DBI';
1875 use Class::DBI::Pager;
1876 no warnings qw(redefine);
1877
1878 Chado::Biomaterial_Treatment->set_up_table('biomaterial_treatment');
1879
1880 #
1881 # Primary key accessors
1882 #
1883
1884 sub id { shift->biomaterial_treatment_id }
1885 sub biomaterial_treatment { shift->biomaterial_treatment_id }
1886
1887
1888
1889
1890 #
1891 # Has A
1892 #
1893
1894 Chado::Biomaterial_Treatment->has_a(biomaterial_id => 'Chado::Biomaterial');
1895
1896 sub Chado::Biomaterial_Treatment::biomaterial { return shift->biomaterial_id }
1897
1898
1899 Chado::Biomaterial_Treatment->has_a(treatment_id => 'Chado::Treatment');
1900
1901 sub Chado::Biomaterial_Treatment::treatment { return shift->treatment_id }
1902
1903
1904 Chado::Biomaterial_Treatment->has_a(unittype_id => 'Chado::Cvterm');
1905
1906 sub Chado::Biomaterial_Treatment::cvterm { return shift->unittype_id }
1907
1908
1909 #
1910 # Has Many
1911 #
1912
1913
1914
1915 # one to many to one
1916
1917 # one to many to many
1918
1919 #many to many to one
1920
1921 #many to many to many
1922
1923
1924
1925 1;
1926
1927 ########Chado::Expressionprop########
1928
1929 package Chado::Expressionprop;
1930 use base 'Chado::DBI';
1931 use Class::DBI::Pager;
1932 no warnings qw(redefine);
1933
1934 Chado::Expressionprop->set_up_table('expressionprop');
1935
1936 #
1937 # Primary key accessors
1938 #
1939
1940 sub id { shift->expressionprop_id }
1941 sub expressionprop { shift->expressionprop_id }
1942
1943
1944
1945
1946 #
1947 # Has A
1948 #
1949
1950 Chado::Expressionprop->has_a(expression_id => 'Chado::Expression');
1951
1952 sub Chado::Expressionprop::expression { return shift->expression_id }
1953
1954
1955 Chado::Expressionprop->has_a(type_id => 'Chado::Cvterm');
1956
1957 sub Chado::Expressionprop::cvterm { return shift->type_id }
1958
1959
1960 #
1961 # Has Many
1962 #
1963
1964
1965
1966 # one to many to one
1967
1968 # one to many to many
1969
1970 #many to many to one
1971
1972 #many to many to many
1973
1974
1975
1976 1;
1977
1978 ########Chado::Cvterm_Relationship########
1979
1980 package Chado::Cvterm_Relationship;
1981 use base 'Chado::DBI';
1982 use Class::DBI::Pager;
1983 no warnings qw(redefine);
1984
1985 Chado::Cvterm_Relationship->set_up_table('cvterm_relationship');
1986
1987 #
1988 # Primary key accessors
1989 #
1990
1991 sub id { shift->cvterm_relationship_id }
1992 sub cvterm_relationship { shift->cvterm_relationship_id }
1993
1994
1995
1996
1997 #
1998 # Has A
1999 #
2000
2001 Chado::Cvterm_Relationship->has_a(type_id => 'Chado::Cvterm');
2002
2003 sub type { return shift->type_id }
2004
2005
2006 Chado::Cvterm_Relationship->has_a(subject_id => 'Chado::Cvterm');
2007
2008 sub subject { return shift->subject_id }
2009
2010
2011 Chado::Cvterm_Relationship->has_a(object_id => 'Chado::Cvterm');
2012
2013 sub object { return shift->object_id }
2014
2015
2016 #
2017 # Has Many
2018 #
2019
2020
2021
2022 # one to many to one
2023
2024 # one to many to many
2025
2026 #many to many to one
2027
2028 #many to many to many
2029
2030
2031
2032 1;
2033
2034 ########Chado::Phylonode_Pub########
2035
2036 package Chado::Phylonode_Pub;
2037 use base 'Chado::DBI';
2038 use Class::DBI::Pager;
2039 no warnings qw(redefine);
2040
2041 Chado::Phylonode_Pub->set_up_table('phylonode_pub');
2042
2043 #
2044 # Primary key accessors
2045 #
2046
2047 sub id { shift->phylonode_pub_id }
2048 sub phylonode_pub { shift->phylonode_pub_id }
2049
2050
2051
2052
2053 #
2054 # Has A
2055 #
2056
2057 Chado::Phylonode_Pub->has_a(phylonode_id => 'Chado::Phylonode');
2058
2059 sub Chado::Phylonode_Pub::phylonode { return shift->phylonode_id }
2060
2061
2062 Chado::Phylonode_Pub->has_a(pub_id => 'Chado::Pub');
2063
2064 sub Chado::Phylonode_Pub::pub { return shift->pub_id }
2065
2066
2067 #
2068 # Has Many
2069 #
2070
2071
2072
2073 # one to many to one
2074
2075 # one to many to many
2076
2077 #many to many to one
2078
2079 #many to many to many
2080
2081
2082
2083 1;
2084
2085 ########Chado::Acquisitionprop########
2086
2087 package Chado::Acquisitionprop;
2088 use base 'Chado::DBI';
2089 use Class::DBI::Pager;
2090 no warnings qw(redefine);
2091
2092 Chado::Acquisitionprop->set_up_table('acquisitionprop');
2093
2094 #
2095 # Primary key accessors
2096 #
2097
2098 sub id { shift->acquisitionprop_id }
2099 sub acquisitionprop { shift->acquisitionprop_id }
2100
2101
2102
2103
2104 #
2105 # Has A
2106 #
2107
2108 Chado::Acquisitionprop->has_a(acquisition_id => 'Chado::Acquisition');
2109
2110 sub Chado::Acquisitionprop::acquisition { return shift->acquisition_id }
2111
2112
2113 Chado::Acquisitionprop->has_a(type_id => 'Chado::Cvterm');
2114
2115 sub Chado::Acquisitionprop::cvterm { return shift->type_id }
2116
2117
2118 #
2119 # Has Many
2120 #
2121
2122
2123
2124 # one to many to one
2125
2126 # one to many to many
2127
2128 #many to many to one
2129
2130 #many to many to many
2131
2132
2133
2134 1;
2135
2136 ########Chado::Phylonode_Organism########
2137
2138 package Chado::Phylonode_Organism;
2139 use base 'Chado::DBI';
2140 use Class::DBI::Pager;
2141 no warnings qw(redefine);
2142
2143 Chado::Phylonode_Organism->set_up_table('phylonode_organism');
2144
2145 #
2146 # Primary key accessors
2147 #
2148
2149 sub id { shift->phylonode_organism_id }
2150 sub phylonode_organism { shift->phylonode_organism_id }
2151
2152
2153
2154
2155 #
2156 # Has A
2157 #
2158
2159 Chado::Phylonode_Organism->has_a(phylonode_id => 'Chado::Phylonode');
2160
2161 sub Chado::Phylonode_Organism::phylonode { return shift->phylonode_id }
2162
2163
2164 Chado::Phylonode_Organism->has_a(organism_id => 'Chado::Organism');
2165
2166 sub Chado::Phylonode_Organism::organism { return shift->organism_id }
2167
2168
2169 #
2170 # Has Many
2171 #
2172
2173
2174
2175 # one to many to one
2176
2177 # one to many to many
2178
2179 #many to many to one
2180
2181 #many to many to many
2182
2183
2184
2185 1;
2186
2187 ########Chado::Studydesignprop########
2188
2189 package Chado::Studydesignprop;
2190 use base 'Chado::DBI';
2191 use Class::DBI::Pager;
2192 no warnings qw(redefine);
2193
2194 Chado::Studydesignprop->set_up_table('studydesignprop');
2195
2196 #
2197 # Primary key accessors
2198 #
2199
2200 sub id { shift->studydesignprop_id }
2201 sub studydesignprop { shift->studydesignprop_id }
2202
2203
2204
2205
2206 #
2207 # Has A
2208 #
2209
2210 Chado::Studydesignprop->has_a(studydesign_id => 'Chado::Studydesign');
2211
2212 sub Chado::Studydesignprop::studydesign { return shift->studydesign_id }
2213
2214
2215 Chado::Studydesignprop->has_a(type_id => 'Chado::Cvterm');
2216
2217 sub Chado::Studydesignprop::cvterm { return shift->type_id }
2218
2219
2220 #
2221 # Has Many
2222 #
2223
2224
2225
2226 # one to many to one
2227
2228 # one to many to many
2229
2230 #many to many to one
2231
2232 #many to many to many
2233
2234
2235
2236 1;
2237
2238 ########Chado::Acquisition########
2239
2240 package Chado::Acquisition;
2241 use base 'Chado::DBI';
2242 use Class::DBI::Pager;
2243 no warnings qw(redefine);
2244
2245 Chado::Acquisition->set_up_table('acquisition');
2246
2247 #
2248 # Primary key accessors
2249 #
2250
2251 sub id { shift->acquisition_id }
2252 sub acquisition { shift->acquisition_id }
2253
2254
2255
2256
2257 #
2258 # Has A
2259 #
2260
2261
2262
2263 Chado::Acquisition->has_a(assay_id => 'Chado::Assay');
2264
2265 sub Chado::Acquisition::assay { return shift->assay_id }
2266
2267
2268 Chado::Acquisition->has_a(protocol_id => 'Chado::Protocol');
2269
2270 sub Chado::Acquisition::protocol { return shift->protocol_id }
2271
2272
2273 Chado::Acquisition->has_a(channel_id => 'Chado::Channel');
2274
2275 sub Chado::Acquisition::channel { return shift->channel_id }
2276
2277
2278
2279
2280 #
2281 # Has Many
2282 #
2283
2284 Chado::Acquisition->has_many('quantification_acquisition_id', 'Chado::Quantification' => 'acquisition_id');
2285
2286
2287 sub quantifications { return shift->quantification_acquisition_id }
2288
2289 Chado::Acquisition->has_many('acquisitionprop_acquisition_id', 'Chado::Acquisitionprop' => 'acquisition_id');
2290
2291
2292 sub acquisitionprops { return shift->acquisitionprop_acquisition_id }
2293
2294 Chado::Acquisition->has_many('acquisition_relationship_subject_id', 'Chado::Acquisition_Relationship' => 'subject_id');
2295
2296
2297 sub acquisition_relationship_subject_ids { my $self = shift; return $self->acquisition_relationship_subject_id(@_) }
2298
2299 Chado::Acquisition->has_many('acquisition_relationship_object_id', 'Chado::Acquisition_Relationship' => 'object_id');
2300
2301
2302 sub acquisition_relationship_object_ids { my $self = shift; return $self->acquisition_relationship_object_id(@_) }
2303
2304
2305
2306 # one to many to one
2307
2308 # one to many to many
2309
2310 #many to many to one
2311
2312 #many to many to many
2313
2314
2315
2316 1;
2317
2318 ########Chado::Assay_Biomaterial########
2319
2320 package Chado::Assay_Biomaterial;
2321 use base 'Chado::DBI';
2322 use Class::DBI::Pager;
2323 no warnings qw(redefine);
2324
2325 Chado::Assay_Biomaterial->set_up_table('assay_biomaterial');
2326
2327 #
2328 # Primary key accessors
2329 #
2330
2331 sub id { shift->assay_biomaterial_id }
2332 sub assay_biomaterial { shift->assay_biomaterial_id }
2333
2334
2335
2336
2337 #
2338 # Has A
2339 #
2340
2341 Chado::Assay_Biomaterial->has_a(assay_id => 'Chado::Assay');
2342
2343 sub Chado::Assay_Biomaterial::assay { return shift->assay_id }
2344
2345
2346 Chado::Assay_Biomaterial->has_a(biomaterial_id => 'Chado::Biomaterial');
2347
2348 sub Chado::Assay_Biomaterial::biomaterial { return shift->biomaterial_id }
2349
2350
2351 Chado::Assay_Biomaterial->has_a(channel_id => 'Chado::Channel');
2352
2353 sub Chado::Assay_Biomaterial::channel { return shift->channel_id }
2354
2355
2356 #
2357 # Has Many
2358 #
2359
2360
2361
2362 # one to many to one
2363
2364 # one to many to many
2365
2366 #many to many to one
2367
2368 #many to many to many
2369
2370
2371
2372 1;
2373
2374 ########Chado::Biomaterial_Dbxref########
2375
2376 package Chado::Biomaterial_Dbxref;
2377 use base 'Chado::DBI';
2378 use Class::DBI::Pager;
2379 no warnings qw(redefine);
2380
2381 Chado::Biomaterial_Dbxref->set_up_table('biomaterial_dbxref');
2382
2383 #
2384 # Primary key accessors
2385 #
2386
2387 sub id { shift->biomaterial_dbxref_id }
2388 sub biomaterial_dbxref { shift->biomaterial_dbxref_id }
2389
2390
2391
2392
2393 #
2394 # Has A
2395 #
2396
2397 Chado::Biomaterial_Dbxref->has_a(biomaterial_id => 'Chado::Biomaterial');
2398
2399 sub Chado::Biomaterial_Dbxref::biomaterial { return shift->biomaterial_id }
2400
2401
2402 Chado::Biomaterial_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
2403
2404 sub Chado::Biomaterial_Dbxref::dbxref { return shift->dbxref_id }
2405
2406
2407 #
2408 # Has Many
2409 #
2410
2411
2412
2413 # one to many to one
2414
2415 # one to many to many
2416
2417 #many to many to one
2418
2419 #many to many to many
2420
2421
2422
2423 1;
2424
2425 ########Chado::Channel########
2426
2427 package Chado::Channel;
2428 use base 'Chado::DBI';
2429 use Class::DBI::Pager;
2430 no warnings qw(redefine);
2431
2432 Chado::Channel->set_up_table('channel');
2433
2434 #
2435 # Primary key accessors
2436 #
2437
2438 sub id { shift->channel_id }
2439 sub channel { shift->channel_id }
2440
2441
2442
2443
2444 #
2445 # Has A
2446 #
2447
2448
2449
2450 #
2451 # Has Many
2452 #
2453
2454 Chado::Channel->has_many('acquisition_channel_id', 'Chado::Acquisition' => 'channel_id');
2455
2456
2457 sub acquisitions { return shift->acquisition_channel_id }
2458
2459 Chado::Channel->has_many('assay_biomaterial_channel_id', 'Chado::Assay_Biomaterial' => 'channel_id');
2460
2461
2462 sub assay_biomaterials { return shift->assay_biomaterial_channel_id }
2463
2464
2465
2466 # one to many to one
2467
2468 # one to many to many
2469
2470 #many to many to one
2471
2472 #many to many to many
2473
2474
2475
2476 1;
2477
2478 ########Chado::Genotype########
2479
2480 package Chado::Genotype;
2481 use base 'Chado::DBI';
2482 use Class::DBI::Pager;
2483 no warnings qw(redefine);
2484
2485 Chado::Genotype->set_up_table('genotype');
2486
2487 #
2488 # Primary key accessors
2489 #
2490
2491 sub id { shift->genotype_id }
2492 sub genotype { shift->genotype_id }
2493
2494
2495
2496
2497 #
2498 # Has A
2499 #
2500
2501
2502
2503
2504
2505
2506
2507 #
2508 # Has Many
2509 #
2510
2511 Chado::Genotype->has_many('phenotype_comparison_genotype1_id', 'Chado::Phenotype_Comparison' => 'genotype1_id');
2512
2513 Chado::Genotype->has_many('phenotype_comparison_genotype2_id', 'Chado::Phenotype_Comparison' => 'genotype2_id');
2514
2515 Chado::Genotype->has_many('stock_genotype_genotype_id', 'Chado::Stock_Genotype' => 'genotype_id');
2516
2517 Chado::Genotype->has_many('feature_genotype_genotype_id', 'Chado::Feature_Genotype' => 'genotype_id');
2518
2519
2520 sub feature_genotypes { return shift->feature_genotype_genotype_id }
2521
2522 Chado::Genotype->has_many('phenstatement_genotype_id', 'Chado::Phenstatement' => 'genotype_id');
2523
2524 Chado::Genotype->has_many('phendesc_genotype_id', 'Chado::Phendesc' => 'genotype_id');
2525
2526
2527 sub phendescs { return shift->phendesc_genotype_id }
2528
2529
2530
2531
2532 #
2533 # Has Compound Many (many to many relationships in all their flavors)
2534 #
2535
2536
2537 sub phenotype_comparison_genotype1s { return shift->phenotype_comparison_genotype1_id }
2538
2539
2540
2541 sub phenotype_comparison_genotype2s { return shift->phenotype_comparison_genotype2_id }
2542
2543
2544
2545
2546 sub phenotype_comparison_genotype1s { return shift->phenotype_comparison_genotype1_id }
2547
2548
2549 sub phenotype_comparison_genotype2s { return shift->phenotype_comparison_genotype2_id }
2550
2551
2552
2553
2554 sub phenotype_comparison_genotype1s { return shift->phenotype_comparison_genotype1_id }
2555
2556
2557 sub phenotype_comparison_genotype2s { return shift->phenotype_comparison_genotype2_id }
2558
2559
2560
2561
2562 sub phenotype_comparison_genotype1s { return shift->phenotype_comparison_genotype1_id }
2563
2564
2565 sub phenotype_comparison_genotype2s { return shift->phenotype_comparison_genotype2_id }
2566
2567
2568
2569
2570
2571
2572 sub stock_genotype_genotypes { return shift->stock_genotype_genotype_id }
2573
2574
2575
2576 sub phenstatement_genotypes { return shift->phenstatement_genotype_id }
2577
2578
2579
2580
2581 sub phenstatement_genotypes { return shift->phenstatement_genotype_id }
2582
2583
2584
2585
2586 sub phenstatement_genotypes { return shift->phenstatement_genotype_id }
2587
2588
2589
2590
2591 sub phenstatement_genotypes { return shift->phenstatement_genotype_id }
2592
2593
2594 # one to many to one
2595
2596
2597
2598
2599
2600
2601 # one2one #
2602 sub stocks { my $self = shift; return map $_->stock_id, $self->stock_genotype_genotype_id }
2603
2604
2605
2606 sub environments { my $self = shift; return map $_->environment_id, $self->phenstatement_genotype_id }
2607
2608
2609
2610 sub cvterms { my $self = shift; return map $_->type_id, $self->phenstatement_genotype_id }
2611
2612
2613
2614 sub pubs { my $self = shift; return map $_->pub_id, $self->phenstatement_genotype_id }
2615
2616
2617
2618 sub phenotypes { my $self = shift; return map $_->phenotype_id, $self->phenstatement_genotype_id }
2619
2620 # one to many to many
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631 #many to many to one
2632
2633
2634
2635 # many2one #
2636
2637
2638 sub phenotype_comparison_genotype1_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_genotype1_id }
2639
2640
2641 sub phenotype_comparison_genotype2_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_genotype2_id }
2642
2643
2644
2645
2646
2647
2648 sub phenotype_comparison_genotype1_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_genotype1_id }
2649
2650
2651 sub phenotype_comparison_genotype2_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_genotype2_id }
2652
2653
2654
2655
2656
2657
2658
2659
2660 #many to many to many
2661
2662
2663
2664 # many2many #
2665
2666
2667
2668
2669 sub phenotype_comparison_genotype1_environment1s { my $self = shift; return map $_->phenotype_comparison_environment1s, $self->phenotype_comparison_genotype1s }
2670
2671
2672 sub phenotype_comparison_genotype1_environment2s { my $self = shift; return map $_->phenotype_comparison_environment2s, $self->phenotype_comparison_genotype1s }
2673
2674
2675
2676
2677
2678
2679 sub phenotype_comparison_genotype2_environment1s { my $self = shift; return map $_->phenotype_comparison_environment1s, $self->phenotype_comparison_genotype2s }
2680
2681
2682 sub phenotype_comparison_genotype2_environment2s { my $self = shift; return map $_->phenotype_comparison_environment2s, $self->phenotype_comparison_genotype2s }
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695 sub phenotype_comparison_genotype1_phenotype1s { my $self = shift; return map $_->phenotype_comparison_phenotype1s, $self->phenotype_comparison_genotype1s }
2696
2697
2698 sub phenotype_comparison_genotype1_phenotype2s { my $self = shift; return map $_->phenotype_comparison_phenotype2s, $self->phenotype_comparison_genotype1s }
2699
2700
2701
2702
2703
2704
2705 sub phenotype_comparison_genotype2_phenotype1s { my $self = shift; return map $_->phenotype_comparison_phenotype1s, $self->phenotype_comparison_genotype2s }
2706
2707
2708 sub phenotype_comparison_genotype2_phenotype2s { my $self = shift; return map $_->phenotype_comparison_phenotype2s, $self->phenotype_comparison_genotype2s }
2709
2710
2711
2712
2713
2714
2715
2716
2717
2718
2719 1;
2720
2721 ########Chado::Studyfactorvalue########
2722
2723 package Chado::Studyfactorvalue;
2724 use base 'Chado::DBI';
2725 use Class::DBI::Pager;
2726 no warnings qw(redefine);
2727
2728 Chado::Studyfactorvalue->set_up_table('studyfactorvalue');
2729
2730 #
2731 # Primary key accessors
2732 #
2733
2734 sub id { shift->studyfactorvalue_id }
2735 sub studyfactorvalue { shift->studyfactorvalue_id }
2736
2737
2738
2739
2740 #
2741 # Has A
2742 #
2743
2744 Chado::Studyfactorvalue->has_a(studyfactor_id => 'Chado::Studyfactor');
2745
2746 sub Chado::Studyfactorvalue::studyfactor { return shift->studyfactor_id }
2747
2748
2749 Chado::Studyfactorvalue->has_a(assay_id => 'Chado::Assay');
2750
2751 sub Chado::Studyfactorvalue::assay { return shift->assay_id }
2752
2753
2754 #
2755 # Has Many
2756 #
2757
2758
2759
2760 # one to many to one
2761
2762 # one to many to many
2763
2764 #many to many to one
2765
2766 #many to many to many
2767
2768
2769
2770 1;
2771
2772 ########Chado::Phylotree_Pub########
2773
2774 package Chado::Phylotree_Pub;
2775 use base 'Chado::DBI';
2776 use Class::DBI::Pager;
2777 no warnings qw(redefine);
2778
2779 Chado::Phylotree_Pub->set_up_table('phylotree_pub');
2780
2781 #
2782 # Primary key accessors
2783 #
2784
2785 sub id { shift->phylotree_pub_id }
2786 sub phylotree_pub { shift->phylotree_pub_id }
2787
2788
2789
2790
2791 #
2792 # Has A
2793 #
2794
2795 Chado::Phylotree_Pub->has_a(phylotree_id => 'Chado::Phylotree');
2796
2797 sub Chado::Phylotree_Pub::phylotree { return shift->phylotree_id }
2798
2799
2800 Chado::Phylotree_Pub->has_a(pub_id => 'Chado::Pub');
2801
2802 sub Chado::Phylotree_Pub::pub { return shift->pub_id }
2803
2804
2805 #
2806 # Has Many
2807 #
2808
2809
2810
2811 # one to many to one
2812
2813 # one to many to many
2814
2815 #many to many to one
2816
2817 #many to many to many
2818
2819
2820
2821 1;
2822
2823 ########Chado::Dbxref########
2824
2825 package Chado::Dbxref;
2826 use base 'Chado::DBI';
2827 use Class::DBI::Pager;
2828 no warnings qw(redefine);
2829
2830 Chado::Dbxref->set_up_table('dbxref');
2831
2832 #
2833 # Primary key accessors
2834 #
2835
2836 sub id { shift->dbxref_id }
2837 sub dbxref { shift->dbxref_id }
2838
2839
2840
2841
2842 #
2843 # Has A
2844 #
2845
2846
2847
2848
2849
2850
2851
2852
2853 Chado::Dbxref->has_a(db_id => 'Chado::Db');
2854
2855 sub Chado::Dbxref::db { return shift->db_id }
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870 #
2871 # Has Many
2872 #
2873
2874 Chado::Dbxref->has_many('assay_dbxref_id', 'Chado::Assay' => 'dbxref_id');
2875
2876
2877 sub assays { return shift->assay_dbxref_id }
2878
2879 Chado::Dbxref->has_many('feature_dbxref_dbxref_id', 'Chado::Feature_Dbxref' => 'dbxref_id');
2880
2881
2882 sub feature_dbxrefs { return shift->feature_dbxref_dbxref_id }
2883
2884 Chado::Dbxref->has_many('organism_dbxref_dbxref_id', 'Chado::Organism_Dbxref' => 'dbxref_id');
2885
2886 Chado::Dbxref->has_many('arraydesign_dbxref_id', 'Chado::Arraydesign' => 'dbxref_id');
2887
2888 sub arraydesign_dbxrefs { return shift->arraydesign_dbxref_id }
2889 #sub --arraydesign--dbxref_id-- {}
2890
2891 Chado::Dbxref->has_many('study_dbxref_id', 'Chado::Study' => 'dbxref_id');
2892
2893
2894 sub studys { return shift->study_dbxref_id }
2895
2896 Chado::Dbxref->has_many('element_dbxref_id', 'Chado::Element' => 'dbxref_id');
2897
2898 Chado::Dbxref->has_many('biomaterial_dbxref_dbxref_id', 'Chado::Biomaterial_Dbxref' => 'dbxref_id');
2899
2900 Chado::Dbxref->has_many('dbxrefprop_dbxref_id', 'Chado::Dbxrefprop' => 'dbxref_id');
2901
2902
2903 sub dbxrefprops { return shift->dbxrefprop_dbxref_id }
2904
2905 Chado::Dbxref->has_many('feature_cvterm_dbxref_dbxref_id', 'Chado::Feature_Cvterm_Dbxref' => 'dbxref_id');
2906
2907 Chado::Dbxref->has_many('protocol_dbxref_id', 'Chado::Protocol' => 'dbxref_id');
2908
2909
2910 sub protocols { return shift->protocol_dbxref_id }
2911
2912 Chado::Dbxref->has_many('feature_dbxref_id', 'Chado::Feature' => 'dbxref_id');
2913
2914 sub feature_dbxrefs { return shift->feature_dbxref_id }
2915 #sub --feature--dbxref_id-- {}
2916
2917 Chado::Dbxref->has_many('stock_dbxref_dbxref_id', 'Chado::Stock_Dbxref' => 'dbxref_id');
2918
2919
2920 sub stock_dbxrefs { return shift->stock_dbxref_dbxref_id }
2921
2922 Chado::Dbxref->has_many('cvterm_dbxref_dbxref_id', 'Chado::Cvterm_Dbxref' => 'dbxref_id');
2923
2924
2925 sub cvterm_dbxrefs { return shift->cvterm_dbxref_dbxref_id }
2926
2927 Chado::Dbxref->has_many('stock_dbxref_id', 'Chado::Stock' => 'dbxref_id');
2928
2929
2930 sub stocks { return shift->stock_dbxref_id }
2931
2932 Chado::Dbxref->has_many('phylonode_dbxref_dbxref_id', 'Chado::Phylonode_Dbxref' => 'dbxref_id');
2933
2934 Chado::Dbxref->has_many('cvterm_dbxref_id', 'Chado::Cvterm' => 'dbxref_id');
2935
2936 sub cvterm_dbxrefs { return shift->cvterm_dbxref_id }
2937 #sub --cvterm--dbxref_id-- {}
2938
2939 Chado::Dbxref->has_many('biomaterial_dbxref_id', 'Chado::Biomaterial' => 'dbxref_id');
2940
2941 sub biomaterial_dbxrefs { return shift->biomaterial_dbxref_id }
2942 #sub --biomaterial--dbxref_id-- {}
2943
2944 Chado::Dbxref->has_many('pub_dbxref_dbxref_id', 'Chado::Pub_Dbxref' => 'dbxref_id');
2945
2946
2947 sub pub_dbxrefs { return shift->pub_dbxref_dbxref_id }
2948
2949 Chado::Dbxref->has_many('phylotree_dbxref_id', 'Chado::Phylotree' => 'dbxref_id');
2950
2951
2952 sub phylotrees { return shift->phylotree_dbxref_id }
2953
2954
2955
2956
2957 #
2958 # Has Compound Many (many to many relationships in all their flavors)
2959 #
2960
2961
2962
2963 sub element_dbxrefs { return shift->element_dbxref_id }
2964
2965
2966
2967
2968 sub element_dbxrefs { return shift->element_dbxref_id }
2969
2970
2971
2972
2973 sub element_dbxrefs { return shift->element_dbxref_id }
2974
2975
2976
2977
2978 sub biomaterial_dbxref_dbxrefs { return shift->biomaterial_dbxref_dbxref_id }
2979
2980
2981
2982
2983 sub phylonode_dbxref_dbxrefs { return shift->phylonode_dbxref_dbxref_id }
2984
2985
2986
2987
2988 sub feature_cvterm_dbxref_dbxrefs { return shift->feature_cvterm_dbxref_dbxref_id }
2989
2990
2991
2992
2993 sub organism_dbxref_dbxrefs { return shift->organism_dbxref_dbxref_id }
2994
2995 # one to many to one
2996
2997
2998 # one2one #
2999 sub arraydesigns { my $self = shift; return map $_->arraydesign_id, $self->element_dbxref_id }
3000
3001
3002
3003 sub features { my $self = shift; return map $_->feature_id, $self->element_dbxref_id }
3004
3005
3006
3007 sub cvterms { my $self = shift; return map $_->type_id, $self->element_dbxref_id }
3008
3009
3010
3011 sub biomaterials { my $self = shift; return map $_->biomaterial_id, $self->biomaterial_dbxref_dbxref_id }
3012
3013
3014
3015 sub phylonodes { my $self = shift; return map $_->phylonode_id, $self->phylonode_dbxref_dbxref_id }
3016
3017
3018
3019 sub feature_cvterms { my $self = shift; return map $_->feature_cvterm_id, $self->feature_cvterm_dbxref_dbxref_id }
3020
3021
3022
3023 sub organisms { my $self = shift; return map $_->organism_id, $self->organism_dbxref_dbxref_id }
3024
3025 # one to many to many
3026
3027
3028
3029
3030
3031
3032
3033
3034 #many to many to one
3035
3036
3037
3038
3039
3040
3041
3042
3043 #many to many to many
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054 1;
3055
3056 ########Chado::Assay_Project########
3057
3058 package Chado::Assay_Project;
3059 use base 'Chado::DBI';
3060 use Class::DBI::Pager;
3061 no warnings qw(redefine);
3062
3063 Chado::Assay_Project->set_up_table('assay_project');
3064
3065 #
3066 # Primary key accessors
3067 #
3068
3069 sub id { shift->assay_project_id }
3070 sub assay_project { shift->assay_project_id }
3071
3072
3073
3074
3075 #
3076 # Has A
3077 #
3078
3079 Chado::Assay_Project->has_a(assay_id => 'Chado::Assay');
3080
3081 sub Chado::Assay_Project::assay { return shift->assay_id }
3082
3083
3084 Chado::Assay_Project->has_a(project_id => 'Chado::Project');
3085
3086 sub Chado::Assay_Project::project { return shift->project_id }
3087
3088
3089 #
3090 # Has Many
3091 #
3092
3093
3094
3095 # one to many to one
3096
3097 # one to many to many
3098
3099 #many to many to one
3100
3101 #many to many to many
3102
3103
3104
3105 1;
3106
3107 ########Chado::Assayprop########
3108
3109 package Chado::Assayprop;
3110 use base 'Chado::DBI';
3111 use Class::DBI::Pager;
3112 no warnings qw(redefine);
3113
3114 Chado::Assayprop->set_up_table('assayprop');
3115
3116 #
3117 # Primary key accessors
3118 #
3119
3120 sub id { shift->assayprop_id }
3121 sub assayprop { shift->assayprop_id }
3122
3123
3124
3125
3126 #
3127 # Has A
3128 #
3129
3130 Chado::Assayprop->has_a(assay_id => 'Chado::Assay');
3131
3132 sub Chado::Assayprop::assay { return shift->assay_id }
3133
3134
3135 Chado::Assayprop->has_a(type_id => 'Chado::Cvterm');
3136
3137 sub Chado::Assayprop::cvterm { return shift->type_id }
3138
3139
3140 #
3141 # Has Many
3142 #
3143
3144
3145
3146 # one to many to one
3147
3148 # one to many to many
3149
3150 #many to many to one
3151
3152 #many to many to many
3153
3154
3155
3156 1;
3157
3158 ########Chado::Environment_Cvterm########
3159
3160 package Chado::Environment_Cvterm;
3161 use base 'Chado::DBI';
3162 use Class::DBI::Pager;
3163 no warnings qw(redefine);
3164
3165 Chado::Environment_Cvterm->set_up_table('environment_cvterm');
3166
3167 #
3168 # Primary key accessors
3169 #
3170
3171 sub id { shift->environment_cvterm_id }
3172 sub environment_cvterm { shift->environment_cvterm_id }
3173
3174
3175
3176
3177 #
3178 # Has A
3179 #
3180
3181 Chado::Environment_Cvterm->has_a(environment_id => 'Chado::Environment');
3182
3183 sub Chado::Environment_Cvterm::environment { return shift->environment_id }
3184
3185
3186 Chado::Environment_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
3187
3188 sub Chado::Environment_Cvterm::cvterm { return shift->cvterm_id }
3189
3190
3191 #
3192 # Has Many
3193 #
3194
3195
3196
3197 # one to many to one
3198
3199 # one to many to many
3200
3201 #many to many to one
3202
3203 #many to many to many
3204
3205
3206
3207 1;
3208
3209 ########Chado::Contact_Relationship########
3210
3211 package Chado::Contact_Relationship;
3212 use base 'Chado::DBI';
3213 use Class::DBI::Pager;
3214 no warnings qw(redefine);
3215
3216 Chado::Contact_Relationship->set_up_table('contact_relationship');
3217
3218 #
3219 # Primary key accessors
3220 #
3221
3222 sub id { shift->contact_relationship_id }
3223 sub contact_relationship { shift->contact_relationship_id }
3224
3225
3226
3227
3228 #
3229 # Has A
3230 #
3231
3232 Chado::Contact_Relationship->has_a(type_id => 'Chado::Cvterm');
3233
3234 sub Chado::Contact_Relationship::cvterm { return shift->type_id }
3235
3236
3237 Chado::Contact_Relationship->has_a(subject_id => 'Chado::Contact');
3238
3239 sub subject { return shift->subject_id }
3240
3241
3242 Chado::Contact_Relationship->has_a(object_id => 'Chado::Contact');
3243
3244 sub object { return shift->object_id }
3245
3246
3247 #
3248 # Has Many
3249 #
3250
3251
3252
3253 # one to many to one
3254
3255 # one to many to many
3256
3257 #many to many to one
3258
3259 #many to many to many
3260
3261
3262
3263 1;
3264
3265 ########Chado::Tableinfo########
3266
3267 package Chado::Tableinfo;
3268 use base 'Chado::DBI';
3269 use Class::DBI::Pager;
3270 no warnings qw(redefine);
3271
3272 Chado::Tableinfo->set_up_table('tableinfo');
3273
3274 #
3275 # Primary key accessors
3276 #
3277
3278 sub id { shift->tableinfo_id }
3279 sub tableinfo { shift->tableinfo_id }
3280
3281
3282
3283
3284 #
3285 # Has A
3286 #
3287
3288
3289
3290 #
3291 # Has Many
3292 #
3293
3294 Chado::Tableinfo->has_many('magedocumentation_tableinfo_id', 'Chado::Magedocumentation' => 'tableinfo_id');
3295
3296
3297 sub magedocumentations { return shift->magedocumentation_tableinfo_id }
3298
3299 Chado::Tableinfo->has_many('control_tableinfo_id', 'Chado::Control' => 'tableinfo_id');
3300
3301
3302 sub controls { return shift->control_tableinfo_id }
3303
3304
3305
3306 # one to many to one
3307
3308 # one to many to many
3309
3310 #many to many to one
3311
3312 #many to many to many
3313
3314
3315
3316 1;
3317
3318 ########Chado::Pubauthor########
3319
3320 package Chado::Pubauthor;
3321 use base 'Chado::DBI';
3322 use Class::DBI::Pager;
3323 no warnings qw(redefine);
3324
3325 Chado::Pubauthor->set_up_table('pubauthor');
3326
3327 #
3328 # Primary key accessors
3329 #
3330
3331 sub id { shift->pubauthor_id }
3332 sub pubauthor { shift->pubauthor_id }
3333
3334
3335
3336
3337 #
3338 # Has A
3339 #
3340
3341 Chado::Pubauthor->has_a(pub_id => 'Chado::Pub');
3342
3343 sub Chado::Pubauthor::pub { return shift->pub_id }
3344
3345
3346 #
3347 # Has Many
3348 #
3349
3350
3351
3352 # one to many to one
3353
3354 # one to many to many
3355
3356 #many to many to one
3357
3358 #many to many to many
3359
3360
3361
3362 1;
3363
3364 ########Chado::Pub########
3365
3366 package Chado::Pub;
3367 use base 'Chado::DBI';
3368 use Class::DBI::Pager;
3369 no warnings qw(redefine);
3370
3371 Chado::Pub->set_up_table('pub');
3372
3373 #
3374 # Primary key accessors
3375 #
3376
3377 sub id { shift->pub_id }
3378 sub pub { shift->pub_id }
3379
3380
3381
3382
3383 #
3384 # Has A
3385 #
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396 Chado::Pub->has_a(type_id => 'Chado::Cvterm');
3397
3398 sub Chado::Pub::cvterm { return shift->type_id }
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422 #
3423 # Has Many
3424 #
3425
3426 Chado::Pub->has_many('expression_pub_pub_id', 'Chado::Expression_Pub' => 'pub_id');
3427
3428 Chado::Pub->has_many('feature_expression_pub_id', 'Chado::Feature_Expression' => 'pub_id');
3429
3430 Chado::Pub->has_many('feature_cvterm_pub_id', 'Chado::Feature_Cvterm' => 'pub_id');
3431
3432 sub feature_cvterm_pubs { return shift->feature_cvterm_pub_id }
3433 #sub --feature_cvterm--pub_id-- {}
3434
3435 Chado::Pub->has_many('study_pub_id', 'Chado::Study' => 'pub_id');
3436
3437
3438 sub studys { return shift->study_pub_id }
3439
3440 Chado::Pub->has_many('stock_cvterm_pub_id', 'Chado::Stock_Cvterm' => 'pub_id');
3441
3442 Chado::Pub->has_many('stockprop_pub_pub_id', 'Chado::Stockprop_Pub' => 'pub_id');
3443
3444 Chado::Pub->has_many('phylonode_pub_pub_id', 'Chado::Phylonode_Pub' => 'pub_id');
3445
3446 Chado::Pub->has_many('phylotree_pub_pub_id', 'Chado::Phylotree_Pub' => 'pub_id');
3447
3448 Chado::Pub->has_many('pubauthor_pub_id', 'Chado::Pubauthor' => 'pub_id');
3449
3450
3451 sub pubauthors { return shift->pubauthor_pub_id }
3452
3453 Chado::Pub->has_many('feature_pub_pub_id', 'Chado::Feature_Pub' => 'pub_id');
3454
3455 Chado::Pub->has_many('phenotype_comparison_pub_id', 'Chado::Phenotype_Comparison' => 'pub_id');
3456
3457 Chado::Pub->has_many('protocol_pub_id', 'Chado::Protocol' => 'pub_id');
3458
3459
3460 sub protocols { return shift->protocol_pub_id }
3461
3462 Chado::Pub->has_many('featureloc_pub_pub_id', 'Chado::Featureloc_Pub' => 'pub_id');
3463
3464 Chado::Pub->has_many('library_pub_pub_id', 'Chado::Library_Pub' => 'pub_id');
3465
3466 Chado::Pub->has_many('library_cvterm_pub_id', 'Chado::Library_Cvterm' => 'pub_id');
3467
3468 Chado::Pub->has_many('stock_relationship_pub_pub_id', 'Chado::Stock_Relationship_Pub' => 'pub_id');
3469
3470 Chado::Pub->has_many('feature_relationship_pub_pub_id', 'Chado::Feature_Relationship_Pub' => 'pub_id');
3471
3472 Chado::Pub->has_many('pubprop_pub_id', 'Chado::Pubprop' => 'pub_id');
3473
3474
3475 sub pubprops { return shift->pubprop_pub_id }
3476
3477 Chado::Pub->has_many('feature_cvterm_pub_pub_id', 'Chado::Feature_Cvterm_Pub' => 'pub_id');
3478
3479 Chado::Pub->has_many('stock_pub_pub_id', 'Chado::Stock_Pub' => 'pub_id');
3480
3481 Chado::Pub->has_many('feature_synonym_pub_id', 'Chado::Feature_Synonym' => 'pub_id');
3482
3483
3484 sub feature_synonyms { return shift->feature_synonym_pub_id }
3485
3486 Chado::Pub->has_many('featuremap_pub_pub_id', 'Chado::Featuremap_Pub' => 'pub_id');
3487
3488 Chado::Pub->has_many('feature_relationshipprop_pub_pub_id', 'Chado::Feature_Relationshipprop_Pub' => 'pub_id');
3489
3490 Chado::Pub->has_many('phenstatement_pub_id', 'Chado::Phenstatement' => 'pub_id');
3491
3492 Chado::Pub->has_many('pub_dbxref_pub_id', 'Chado::Pub_Dbxref' => 'pub_id');
3493
3494
3495 sub pub_dbxrefs { return shift->pub_dbxref_pub_id }
3496
3497 Chado::Pub->has_many('phendesc_pub_id', 'Chado::Phendesc' => 'pub_id');
3498
3499
3500 sub phendescs { return shift->phendesc_pub_id }
3501
3502 Chado::Pub->has_many('featureprop_pub_pub_id', 'Chado::Featureprop_Pub' => 'pub_id');
3503
3504 Chado::Pub->has_many('library_synonym_pub_id', 'Chado::Library_Synonym' => 'pub_id');
3505
3506
3507 sub library_synonyms { return shift->library_synonym_pub_id }
3508
3509 Chado::Pub->has_many('pub_relationship_subject_id', 'Chado::Pub_Relationship' => 'subject_id');
3510
3511 Chado::Pub->has_many('pub_relationship_object_id', 'Chado::Pub_Relationship' => 'object_id');
3512
3513
3514
3515
3516 #
3517 # Has Compound Many (many to many relationships in all their flavors)
3518 #
3519
3520
3521
3522 sub feature_expression_pubs { return shift->feature_expression_pub_id }
3523
3524
3525
3526
3527 sub feature_expression_pubs { return shift->feature_expression_pub_id }
3528
3529
3530
3531
3532 sub expression_pub_pubs { return shift->expression_pub_pub_id }
3533
3534
3535
3536
3537 sub library_pub_pubs { return shift->library_pub_pub_id }
3538
3539
3540
3541
3542
3543 sub phenotype_comparison_pubs { return shift->phenotype_comparison_pub_id }
3544
3545
3546
3547
3548
3549 sub phenotype_comparison_pubs { return shift->phenotype_comparison_pub_id }
3550
3551
3552
3553 sub phenotype_comparison_pubs { return shift->phenotype_comparison_pub_id }
3554
3555
3556
3557
3558
3559
3560 sub phenotype_comparison_pubs { return shift->phenotype_comparison_pub_id }
3561
3562
3563
3564
3565 sub stock_relationship_pub_pubs { return shift->stock_relationship_pub_pub_id }
3566
3567
3568
3569
3570 sub feature_pub_pubs { return shift->feature_pub_pub_id }
3571
3572
3573
3574
3575 sub stock_cvterm_pubs { return shift->stock_cvterm_pub_id }
3576
3577
3578
3579
3580 sub stock_cvterm_pubs { return shift->stock_cvterm_pub_id }
3581
3582
3583
3584
3585 sub featureprop_pub_pubs { return shift->featureprop_pub_pub_id }
3586
3587
3588
3589
3590 sub featureloc_pub_pubs { return shift->featureloc_pub_pub_id }
3591
3592
3593
3594
3595 sub phenstatement_pubs { return shift->phenstatement_pub_id }
3596
3597
3598
3599
3600 sub phenstatement_pubs { return shift->phenstatement_pub_id }
3601
3602
3603
3604
3605 sub phenstatement_pubs { return shift->phenstatement_pub_id }
3606
3607
3608
3609
3610 sub phenstatement_pubs { return shift->phenstatement_pub_id }
3611
3612
3613
3614
3615 sub phylotree_pub_pubs { return shift->phylotree_pub_pub_id }
3616
3617
3618
3619
3620 sub stockprop_pub_pubs { return shift->stockprop_pub_pub_id }
3621
3622
3623
3624
3625 sub feature_relationship_pub_pubs { return shift->feature_relationship_pub_pub_id }
3626
3627
3628
3629
3630 sub phylonode_pub_pubs { return shift->phylonode_pub_pub_id }
3631
3632
3633
3634
3635 sub stock_pub_pubs { return shift->stock_pub_pub_id }
3636
3637
3638
3639 sub pub_relationship_subjects { return shift->pub_relationship_subject_id }
3640
3641
3642 sub pub_relationship_objects { return shift->pub_relationship_object_id }
3643
3644
3645
3646
3647
3648 sub library_cvterm_pubs { return shift->library_cvterm_pub_id }
3649
3650
3651
3652
3653 sub library_cvterm_pubs { return shift->library_cvterm_pub_id }
3654
3655
3656
3657
3658 sub featuremap_pub_pubs { return shift->featuremap_pub_pub_id }
3659
3660
3661
3662
3663 sub feature_relationshipprop_pub_pubs { return shift->feature_relationshipprop_pub_pub_id }
3664
3665
3666
3667
3668 sub feature_cvterm_pub_pubs { return shift->feature_cvterm_pub_pub_id }
3669
3670 # one to many to one
3671
3672
3673 # one2one #
3674 sub features { my $self = shift; return map $_->feature_id, $self->feature_expression_pub_id }
3675
3676
3677
3678 sub expressions { my $self = shift; return map $_->expression_id, $self->feature_expression_pub_id }
3679
3680
3681
3682 sub expressions { my $self = shift; return map $_->expression_id, $self->expression_pub_pub_id }
3683
3684
3685
3686 sub librarys { my $self = shift; return map $_->library_id, $self->library_pub_pub_id }
3687
3688
3689
3690
3691
3692 sub organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_pub_id }
3693
3694
3695
3696
3697 sub stock_relationships { my $self = shift; return map $_->stock_relationship_id, $self->stock_relationship_pub_pub_id }
3698
3699
3700
3701 sub features { my $self = shift; return map $_->feature_id, $self->feature_pub_pub_id }
3702
3703
3704
3705 sub stocks { my $self = shift; return map $_->stock_id, $self->stock_cvterm_pub_id }
3706
3707
3708
3709 sub cvterms { my $self = shift; return map $_->cvterm_id, $self->stock_cvterm_pub_id }
3710
3711
3712
3713 sub featureprops { my $self = shift; return map $_->featureprop_id, $self->featureprop_pub_pub_id }
3714
3715
3716
3717 sub featurelocs { my $self = shift; return map $_->featureloc_id, $self->featureloc_pub_pub_id }
3718
3719
3720
3721 sub genotypes { my $self = shift; return map $_->genotype_id, $self->phenstatement_pub_id }
3722
3723
3724
3725 sub environments { my $self = shift; return map $_->environment_id, $self->phenstatement_pub_id }
3726
3727
3728
3729 sub cvterms { my $self = shift; return map $_->type_id, $self->phenstatement_pub_id }
3730
3731
3732
3733 sub phenotypes { my $self = shift; return map $_->phenotype_id, $self->phenstatement_pub_id }
3734
3735
3736
3737 sub phylotrees { my $self = shift; return map $_->phylotree_id, $self->phylotree_pub_pub_id }
3738
3739
3740
3741 sub stockprops { my $self = shift; return map $_->stockprop_id, $self->stockprop_pub_pub_id }
3742
3743
3744
3745 sub feature_relationships { my $self = shift; return map $_->feature_relationship_id, $self->feature_relationship_pub_pub_id }
3746
3747
3748
3749 sub phylonodes { my $self = shift; return map $_->phylonode_id, $self->phylonode_pub_pub_id }
3750
3751
3752
3753 sub stocks { my $self = shift; return map $_->stock_id, $self->stock_pub_pub_id }
3754
3755
3756
3757
3758 sub cvterms { my $self = shift; return map $_->cvterm_id, $self->library_cvterm_pub_id }
3759
3760
3761
3762 sub librarys { my $self = shift; return map $_->library_id, $self->library_cvterm_pub_id }
3763
3764
3765
3766 sub featuremaps { my $self = shift; return map $_->featuremap_id, $self->featuremap_pub_pub_id }
3767
3768
3769
3770 sub feature_relationshipprops { my $self = shift; return map $_->feature_relationshipprop_id, $self->feature_relationshipprop_pub_pub_id }
3771
3772
3773
3774 sub feature_cvterms { my $self = shift; return map $_->feature_cvterm_id, $self->feature_cvterm_pub_pub_id }
3775
3776 # one to many to many
3777
3778
3779
3780
3781
3782
3783 # one2many #
3784
3785
3786
3787
3788 sub phenotype_comparison_genotype1s { my $self = shift; return map $_->genotype1_id, $self->phenotype_comparison_pub_id }
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798 sub phenotype_comparison_environment1s { my $self = shift; return map $_->environment1_id, $self->phenotype_comparison_pub_id }
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809 sub phenotype_comparison_phenotype1s { my $self = shift; return map $_->phenotype1_id, $self->phenotype_comparison_pub_id }
3810
3811
3812
3813
3814
3815
3816
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
3830
3831
3832
3833
3834 #many to many to one
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860 # many2one #
3861
3862
3863 sub pub_relationship_subject_types { my $self = shift; return map $_->type_id, $self->pub_relationship_subject_id }
3864
3865
3866 sub pub_relationship_object_types { my $self = shift; return map $_->type_id, $self->pub_relationship_object_id }
3867
3868
3869
3870
3871
3872
3873
3874 #many to many to many
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907 1;
3908
3909 ########Chado::Organism########
3910
3911 package Chado::Organism;
3912 use base 'Chado::DBI';
3913 use Class::DBI::Pager;
3914 no warnings qw(redefine);
3915
3916 Chado::Organism->set_up_table('organism');
3917
3918 #
3919 # Primary key accessors
3920 #
3921
3922 sub id { shift->organism_id }
3923 sub organism { shift->organism_id }
3924
3925
3926
3927
3928 #
3929 # Has A
3930 #
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940 #
3941 # Has Many
3942 #
3943
3944 Chado::Organism->has_many('organism_dbxref_organism_id', 'Chado::Organism_Dbxref' => 'organism_id');
3945
3946 Chado::Organism->has_many('phylonode_organism_organism_id', 'Chado::Phylonode_Organism' => 'organism_id');
3947
3948 Chado::Organism->has_many('organismprop_organism_id', 'Chado::Organismprop' => 'organism_id');
3949
3950
3951 sub organismprops { return shift->organismprop_organism_id }
3952
3953 Chado::Organism->has_many('phenotype_comparison_organism_id', 'Chado::Phenotype_Comparison' => 'organism_id');
3954
3955 Chado::Organism->has_many('feature_organism_id', 'Chado::Feature' => 'organism_id');
3956
3957
3958 sub features { return shift->feature_organism_id }
3959
3960 Chado::Organism->has_many('stock_organism_id', 'Chado::Stock' => 'organism_id');
3961
3962
3963 sub stocks { return shift->stock_organism_id }
3964
3965 Chado::Organism->has_many('library_organism_id', 'Chado::Library' => 'organism_id');
3966
3967
3968 sub librarys { return shift->library_organism_id }
3969
3970 Chado::Organism->has_many('biomaterial_taxon_id', 'Chado::Biomaterial' => 'taxon_id');
3971
3972
3973 sub biomaterials { return shift->biomaterial_taxon_id }
3974
3975
3976
3977
3978 #
3979 # Has Compound Many (many to many relationships in all their flavors)
3980 #
3981
3982
3983
3984 sub phylonode_organism_organisms { return shift->phylonode_organism_organism_id }
3985
3986
3987
3988
3989
3990 sub phenotype_comparison_organisms { return shift->phenotype_comparison_organism_id }
3991
3992
3993
3994
3995
3996 sub phenotype_comparison_organisms { return shift->phenotype_comparison_organism_id }
3997
3998
3999
4000
4001 sub phenotype_comparison_organisms { return shift->phenotype_comparison_organism_id }
4002
4003
4004
4005
4006
4007 sub phenotype_comparison_organisms { return shift->phenotype_comparison_organism_id }
4008
4009
4010
4011 sub organism_dbxref_organisms { return shift->organism_dbxref_organism_id }
4012
4013
4014 # one to many to one
4015
4016
4017 # one2one #
4018 sub phylonodes { my $self = shift; return map $_->phylonode_id, $self->phylonode_organism_organism_id }
4019
4020
4021
4022
4023
4024 sub pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_organism_id }
4025
4026
4027
4028
4029 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->organism_dbxref_organism_id }
4030
4031 # one to many to many
4032
4033
4034
4035 # one2many #
4036
4037
4038
4039
4040 sub phenotype_comparison_genotype1s { my $self = shift; return map $_->genotype1_id, $self->phenotype_comparison_organism_id }
4041
4042
4043
4044
4045
4046
4047
4048
4049
4050 sub phenotype_comparison_environment1s { my $self = shift; return map $_->environment1_id, $self->phenotype_comparison_organism_id }
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061 sub phenotype_comparison_phenotype1s { my $self = shift; return map $_->phenotype1_id, $self->phenotype_comparison_organism_id }
4062
4063
4064
4065
4066 #many to many to one
4067
4068
4069
4070
4071
4072
4073
4074 #many to many to many
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084 1;
4085
4086 ########Chado::Organismprop########
4087
4088 package Chado::Organismprop;
4089 use base 'Chado::DBI';
4090 use Class::DBI::Pager;
4091 no warnings qw(redefine);
4092
4093 Chado::Organismprop->set_up_table('organismprop');
4094
4095 #
4096 # Primary key accessors
4097 #
4098
4099 sub id { shift->organismprop_id }
4100 sub organismprop { shift->organismprop_id }
4101
4102
4103
4104
4105 #
4106 # Has A
4107 #
4108
4109 Chado::Organismprop->has_a(organism_id => 'Chado::Organism');
4110
4111 sub Chado::Organismprop::organism { return shift->organism_id }
4112
4113
4114 Chado::Organismprop->has_a(type_id => 'Chado::Cvterm');
4115
4116 sub Chado::Organismprop::cvterm { return shift->type_id }
4117
4118
4119 #
4120 # Has Many
4121 #
4122
4123
4124
4125 # one to many to one
4126
4127 # one to many to many
4128
4129 #many to many to one
4130
4131 #many to many to many
4132
4133
4134
4135 1;
4136
4137 ########Chado::Featurerange########
4138
4139 package Chado::Featurerange;
4140 use base 'Chado::DBI';
4141 use Class::DBI::Pager;
4142 no warnings qw(redefine);
4143
4144 Chado::Featurerange->set_up_table('featurerange');
4145
4146 #
4147 # Primary key accessors
4148 #
4149
4150 sub id { shift->featurerange_id }
4151 sub featurerange { shift->featurerange_id }
4152
4153
4154
4155
4156 #
4157 # Has A
4158 #
4159
4160 Chado::Featurerange->has_a(featuremap_id => 'Chado::Featuremap');
4161
4162 sub Chado::Featurerange::featuremap { return shift->featuremap_id }
4163
4164
4165 Chado::Featurerange->has_a(feature_id => 'Chado::Feature');
4166
4167 sub feature { return shift->feature_id }
4168
4169
4170 Chado::Featurerange->has_a(leftstartf_id => 'Chado::Feature');
4171
4172 sub leftstartf { return shift->leftstartf_id }
4173
4174
4175 Chado::Featurerange->has_a(leftendf_id => 'Chado::Feature');
4176
4177 sub leftendf { return shift->leftendf_id }
4178
4179
4180 Chado::Featurerange->has_a(rightstartf_id => 'Chado::Feature');
4181
4182 sub rightstartf { return shift->rightstartf_id }
4183
4184
4185 Chado::Featurerange->has_a(rightendf_id => 'Chado::Feature');
4186
4187 sub rightendf { return shift->rightendf_id }
4188
4189
4190 #
4191 # Has Many
4192 #
4193
4194
4195
4196 # one to many to one
4197
4198 # one to many to many
4199
4200 #many to many to one
4201
4202 #many to many to many
4203
4204
4205
4206 1;
4207
4208 ########Chado::Dbxrefprop########
4209
4210 package Chado::Dbxrefprop;
4211 use base 'Chado::DBI';
4212 use Class::DBI::Pager;
4213 no warnings qw(redefine);
4214
4215 Chado::Dbxrefprop->set_up_table('dbxrefprop');
4216
4217 #
4218 # Primary key accessors
4219 #
4220
4221 sub id { shift->dbxrefprop_id }
4222 sub dbxrefprop { shift->dbxrefprop_id }
4223
4224
4225
4226
4227 #
4228 # Has A
4229 #
4230
4231 Chado::Dbxrefprop->has_a(dbxref_id => 'Chado::Dbxref');
4232
4233 sub Chado::Dbxrefprop::dbxref { return shift->dbxref_id }
4234
4235
4236 Chado::Dbxrefprop->has_a(type_id => 'Chado::Cvterm');
4237
4238 sub Chado::Dbxrefprop::cvterm { return shift->type_id }
4239
4240
4241 #
4242 # Has Many
4243 #
4244
4245
4246
4247 # one to many to one
4248
4249 # one to many to many
4250
4251 #many to many to one
4252
4253 #many to many to many
4254
4255
4256
4257 1;
4258
4259 ########Chado::Featureloc########
4260
4261 package Chado::Featureloc;
4262 use base 'Chado::DBI';
4263 use Class::DBI::Pager;
4264 no warnings qw(redefine);
4265
4266 Chado::Featureloc->set_up_table('featureloc');
4267
4268 #
4269 # Primary key accessors
4270 #
4271
4272 sub id { shift->featureloc_id }
4273 sub featureloc { shift->featureloc_id }
4274
4275
4276
4277
4278 #
4279 # Has A
4280 #
4281
4282 Chado::Featureloc->has_a(feature_id => 'Chado::Feature');
4283
4284 sub feature { return shift->feature_id }
4285
4286
4287 Chado::Featureloc->has_a(srcfeature_id => 'Chado::Feature');
4288
4289 sub srcfeature { return shift->srcfeature_id }
4290
4291
4292
4293 #
4294 # Has Many
4295 #
4296
4297 Chado::Featureloc->has_many('featureloc_pub_featureloc_id', 'Chado::Featureloc_Pub' => 'featureloc_id');
4298
4299
4300
4301
4302 #
4303 # Has Compound Many (many to many relationships in all their flavors)
4304 #
4305
4306
4307 sub featureloc_pub_featurelocs { return shift->featureloc_pub_featureloc_id }
4308
4309
4310 # one to many to one
4311
4312
4313 # one2one #
4314 sub pubs { my $self = shift; return map $_->pub_id, $self->featureloc_pub_featureloc_id }
4315
4316 # one to many to many
4317
4318
4319 #many to many to one
4320
4321
4322 #many to many to many
4323
4324
4325
4326
4327 1;
4328
4329 ########Chado::Analysisfeature########
4330
4331 package Chado::Analysisfeature;
4332 use base 'Chado::DBI';
4333 use Class::DBI::Pager;
4334 no warnings qw(redefine);
4335
4336 Chado::Analysisfeature->set_up_table('analysisfeature');
4337
4338 #
4339 # Primary key accessors
4340 #
4341
4342 sub id { shift->analysisfeature_id }
4343 sub analysisfeature { shift->analysisfeature_id }
4344
4345
4346
4347
4348 #
4349 # Has A
4350 #
4351
4352 Chado::Analysisfeature->has_a(feature_id => 'Chado::Feature');
4353
4354 sub Chado::Analysisfeature::feature { return shift->feature_id }
4355
4356
4357 Chado::Analysisfeature->has_a(analysis_id => 'Chado::Analysis');
4358
4359 sub Chado::Analysisfeature::analysis { return shift->analysis_id }
4360
4361
4362 #
4363 # Has Many
4364 #
4365
4366
4367
4368 # one to many to one
4369
4370 # one to many to many
4371
4372 #many to many to one
4373
4374 #many to many to many
4375
4376
4377
4378 1;
4379
4380 ########Chado::Feature_Cvterm_Dbxref########
4381
4382 package Chado::Feature_Cvterm_Dbxref;
4383 use base 'Chado::DBI';
4384 use Class::DBI::Pager;
4385 no warnings qw(redefine);
4386
4387 Chado::Feature_Cvterm_Dbxref->set_up_table('feature_cvterm_dbxref');
4388
4389 #
4390 # Primary key accessors
4391 #
4392
4393 sub id { shift->feature_cvterm_dbxref_id }
4394 sub feature_cvterm_dbxref { shift->feature_cvterm_dbxref_id }
4395
4396
4397
4398
4399 #
4400 # Has A
4401 #
4402
4403 Chado::Feature_Cvterm_Dbxref->has_a(feature_cvterm_id => 'Chado::Feature_Cvterm');
4404
4405 sub Chado::Feature_Cvterm_Dbxref::feature_cvterm { return shift->feature_cvterm_id }
4406
4407
4408 Chado::Feature_Cvterm_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
4409
4410 sub Chado::Feature_Cvterm_Dbxref::dbxref { return shift->dbxref_id }
4411
4412
4413 #
4414 # Has Many
4415 #
4416
4417
4418
4419 # one to many to one
4420
4421 # one to many to many
4422
4423 #many to many to one
4424
4425 #many to many to many
4426
4427
4428
4429 1;
4430
4431 ########Chado::Feature_Pub########
4432
4433 package Chado::Feature_Pub;
4434 use base 'Chado::DBI';
4435 use Class::DBI::Pager;
4436 no warnings qw(redefine);
4437
4438 Chado::Feature_Pub->set_up_table('feature_pub');
4439
4440 #
4441 # Primary key accessors
4442 #
4443
4444 sub id { shift->feature_pub_id }
4445 sub feature_pub { shift->feature_pub_id }
4446
4447
4448
4449
4450 #
4451 # Has A
4452 #
4453
4454 Chado::Feature_Pub->has_a(feature_id => 'Chado::Feature');
4455
4456 sub Chado::Feature_Pub::feature { return shift->feature_id }
4457
4458
4459 Chado::Feature_Pub->has_a(pub_id => 'Chado::Pub');
4460
4461 sub Chado::Feature_Pub::pub { return shift->pub_id }
4462
4463
4464
4465 #
4466 # Has Many
4467 #
4468
4469 Chado::Feature_Pub->has_many('feature_pubprop_feature_pub_id', 'Chado::Feature_Pubprop' => 'feature_pub_id');
4470
4471
4472 sub feature_pubprops { return shift->feature_pubprop_feature_pub_id }
4473
4474
4475
4476 # one to many to one
4477
4478 # one to many to many
4479
4480 #many to many to one
4481
4482 #many to many to many
4483
4484
4485
4486 1;
4487
4488 ########Chado::Feature_Relationship########
4489
4490 package Chado::Feature_Relationship;
4491 use base 'Chado::DBI';
4492 use Class::DBI::Pager;
4493 no warnings qw(redefine);
4494
4495 Chado::Feature_Relationship->set_up_table('feature_relationship');
4496
4497 #
4498 # Primary key accessors
4499 #
4500
4501 sub id { shift->feature_relationship_id }
4502 sub feature_relationship { shift->feature_relationship_id }
4503
4504
4505
4506
4507 #
4508 # Has A
4509 #
4510
4511 Chado::Feature_Relationship->has_a(subject_id => 'Chado::Feature');
4512
4513 sub subject { return shift->subject_id }
4514
4515
4516 Chado::Feature_Relationship->has_a(object_id => 'Chado::Feature');
4517
4518 sub object { return shift->object_id }
4519
4520
4521 Chado::Feature_Relationship->has_a(type_id => 'Chado::Cvterm');
4522
4523 sub Chado::Feature_Relationship::cvterm { return shift->type_id }
4524
4525
4526
4527
4528 #
4529 # Has Many
4530 #
4531
4532 Chado::Feature_Relationship->has_many('feature_relationship_pub_feature_relationship_id', 'Chado::Feature_Relationship_Pub' => 'feature_relationship_id');
4533
4534 Chado::Feature_Relationship->has_many('feature_relationshipprop_feature_relationship_id', 'Chado::Feature_Relationshipprop' => 'feature_relationship_id');
4535
4536
4537 sub feature_relationshipprops { return shift->feature_relationshipprop_feature_relationship_id }
4538
4539
4540
4541
4542 #
4543 # Has Compound Many (many to many relationships in all their flavors)
4544 #
4545
4546
4547 sub feature_relationship_pub_feature_relationships { return shift->feature_relationship_pub_feature_relationship_id }
4548
4549
4550 # one to many to one
4551
4552
4553 # one2one #
4554 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_relationship_pub_feature_relationship_id }
4555
4556 # one to many to many
4557
4558
4559 #many to many to one
4560
4561
4562 #many to many to many
4563
4564
4565
4566
4567 1;
4568
4569 ########Chado::Acquisition_Relationship########
4570
4571 package Chado::Acquisition_Relationship;
4572 use base 'Chado::DBI';
4573 use Class::DBI::Pager;
4574 no warnings qw(redefine);
4575
4576 Chado::Acquisition_Relationship->set_up_table('acquisition_relationship');
4577
4578 #
4579 # Primary key accessors
4580 #
4581
4582 sub id { shift->acquisition_relationship_id }
4583 sub acquisition_relationship { shift->acquisition_relationship_id }
4584
4585
4586
4587
4588 #
4589 # Has A
4590 #
4591
4592 Chado::Acquisition_Relationship->has_a(subject_id => 'Chado::Acquisition');
4593
4594 sub subject { return shift->subject_id }
4595
4596
4597 Chado::Acquisition_Relationship->has_a(type_id => 'Chado::Cvterm');
4598
4599 sub Chado::Acquisition_Relationship::cvterm { return shift->type_id }
4600
4601
4602 Chado::Acquisition_Relationship->has_a(object_id => 'Chado::Acquisition');
4603
4604 sub object { return shift->object_id }
4605
4606
4607 #
4608 # Has Many
4609 #
4610
4611
4612
4613 # one to many to one
4614
4615 # one to many to many
4616
4617 #many to many to one
4618
4619 #many to many to many
4620
4621
4622
4623 1;
4624
4625 ########Chado::Featurepos########
4626
4627 package Chado::Featurepos;
4628 use base 'Chado::DBI';
4629 use Class::DBI::Pager;
4630 no warnings qw(redefine);
4631
4632 Chado::Featurepos->set_up_table('featurepos');
4633
4634 #
4635 # Primary key accessors
4636 #
4637
4638 sub id { shift->featurepos_id }
4639 sub featurepos { shift->featurepos_id }
4640
4641
4642
4643
4644 #
4645 # Has A
4646 #
4647
4648 Chado::Featurepos->has_a(featuremap_id => 'Chado::Featuremap');
4649
4650 sub Chado::Featurepos::featuremap { return shift->featuremap_id }
4651
4652
4653 Chado::Featurepos->has_a(feature_id => 'Chado::Feature');
4654
4655 sub feature { return shift->feature_id }
4656
4657
4658 Chado::Featurepos->has_a(map_feature_id => 'Chado::Feature');
4659
4660 sub map_feature { return shift->map_feature_id }
4661
4662
4663 #
4664 # Has Many
4665 #
4666
4667
4668
4669 # one to many to one
4670
4671 # one to many to many
4672
4673 #many to many to one
4674
4675 #many to many to many
4676
4677
4678
4679 1;
4680
4681 ########Chado::Phenotype_Comparison########
4682
4683 package Chado::Phenotype_Comparison;
4684 use base 'Chado::DBI';
4685 use Class::DBI::Pager;
4686 no warnings qw(redefine);
4687
4688 Chado::Phenotype_Comparison->set_up_table('phenotype_comparison');
4689
4690 #
4691 # Primary key accessors
4692 #
4693
4694 sub id { shift->phenotype_comparison_id }
4695 sub phenotype_comparison { shift->phenotype_comparison_id }
4696
4697
4698
4699
4700 #
4701 # Has A
4702 #
4703
4704
4705 Chado::Phenotype_Comparison->has_a(genotype1_id => 'Chado::Genotype');
4706
4707 sub genotype1 { return shift->genotype1_id }
4708
4709
4710 Chado::Phenotype_Comparison->has_a(environment1_id => 'Chado::Environment');
4711
4712 sub environment1 { return shift->environment1_id }
4713
4714
4715 Chado::Phenotype_Comparison->has_a(genotype2_id => 'Chado::Genotype');
4716
4717 sub genotype2 { return shift->genotype2_id }
4718
4719
4720 Chado::Phenotype_Comparison->has_a(environment2_id => 'Chado::Environment');
4721
4722 sub environment2 { return shift->environment2_id }
4723
4724
4725 Chado::Phenotype_Comparison->has_a(phenotype1_id => 'Chado::Phenotype');
4726
4727 sub phenotype1 { return shift->phenotype1_id }
4728
4729
4730 Chado::Phenotype_Comparison->has_a(phenotype2_id => 'Chado::Phenotype');
4731
4732 sub phenotype2 { return shift->phenotype2_id }
4733
4734
4735 Chado::Phenotype_Comparison->has_a(pub_id => 'Chado::Pub');
4736
4737 sub Chado::Phenotype_Comparison::pub { return shift->pub_id }
4738
4739
4740 Chado::Phenotype_Comparison->has_a(organism_id => 'Chado::Organism');
4741
4742 sub Chado::Phenotype_Comparison::organism { return shift->organism_id }
4743
4744
4745 #
4746 # Has Many
4747 #
4748
4749 Chado::Phenotype_Comparison->has_many('phenotype_comparison_cvterm_phenotype_comparison_id', 'Chado::Phenotype_Comparison_Cvterm' => 'phenotype_comparison_id');
4750
4751
4752 sub phenotype_comparison_cvterms { return shift->phenotype_comparison_cvterm_phenotype_comparison_id }
4753
4754
4755
4756 # one to many to one
4757
4758 # one to many to many
4759
4760 #many to many to one
4761
4762 #many to many to many
4763
4764
4765
4766 1;
4767
4768 ########Chado::Feature_Cvtermprop########
4769
4770 package Chado::Feature_Cvtermprop;
4771 use base 'Chado::DBI';
4772 use Class::DBI::Pager;
4773 no warnings qw(redefine);
4774
4775 Chado::Feature_Cvtermprop->set_up_table('feature_cvtermprop');
4776
4777 #
4778 # Primary key accessors
4779 #
4780
4781 sub id { shift->feature_cvtermprop_id }
4782 sub feature_cvtermprop { shift->feature_cvtermprop_id }
4783
4784
4785
4786
4787 #
4788 # Has A
4789 #
4790
4791 Chado::Feature_Cvtermprop->has_a(feature_cvterm_id => 'Chado::Feature_Cvterm');
4792
4793 sub Chado::Feature_Cvtermprop::feature_cvterm { return shift->feature_cvterm_id }
4794
4795
4796 Chado::Feature_Cvtermprop->has_a(type_id => 'Chado::Cvterm');
4797
4798 sub Chado::Feature_Cvtermprop::cvterm { return shift->type_id }
4799
4800
4801 #
4802 # Has Many
4803 #
4804
4805
4806
4807 # one to many to one
4808
4809 # one to many to many
4810
4811 #many to many to one
4812
4813 #many to many to many
4814
4815
4816
4817 1;
4818
4819 ########Chado::Protocol########
4820
4821 package Chado::Protocol;
4822 use base 'Chado::DBI';
4823 use Class::DBI::Pager;
4824 no warnings qw(redefine);
4825
4826 Chado::Protocol->set_up_table('protocol');
4827
4828 #
4829 # Primary key accessors
4830 #
4831
4832 sub id { shift->protocol_id }
4833 sub protocol { shift->protocol_id }
4834
4835
4836
4837
4838 #
4839 # Has A
4840 #
4841
4842
4843
4844
4845
4846 Chado::Protocol->has_a(type_id => 'Chado::Cvterm');
4847
4848 sub Chado::Protocol::cvterm { return shift->type_id }
4849
4850
4851 Chado::Protocol->has_a(pub_id => 'Chado::Pub');
4852
4853 sub Chado::Protocol::pub { return shift->pub_id }
4854
4855
4856 Chado::Protocol->has_a(dbxref_id => 'Chado::Dbxref');
4857
4858 sub Chado::Protocol::dbxref { return shift->dbxref_id }
4859
4860
4861
4862
4863 #
4864 # Has Many
4865 #
4866
4867 Chado::Protocol->has_many('assay_protocol_id', 'Chado::Assay' => 'protocol_id');
4868
4869
4870 sub assays { return shift->assay_protocol_id }
4871
4872 Chado::Protocol->has_many('quantification_protocol_id', 'Chado::Quantification' => 'protocol_id');
4873
4874
4875 sub quantifications { return shift->quantification_protocol_id }
4876
4877 Chado::Protocol->has_many('arraydesign_protocol_id', 'Chado::Arraydesign' => 'protocol_id');
4878
4879
4880 sub arraydesigns { return shift->arraydesign_protocol_id }
4881
4882 Chado::Protocol->has_many('acquisition_protocol_id', 'Chado::Acquisition' => 'protocol_id');
4883
4884
4885 sub acquisitions { return shift->acquisition_protocol_id }
4886
4887 Chado::Protocol->has_many('treatment_protocol_id', 'Chado::Treatment' => 'protocol_id');
4888
4889
4890 sub treatments { return shift->treatment_protocol_id }
4891
4892 Chado::Protocol->has_many('protocolparam_protocol_id', 'Chado::Protocolparam' => 'protocol_id');
4893
4894
4895 sub protocolparams { return shift->protocolparam_protocol_id }
4896
4897
4898
4899 # one to many to one
4900
4901 # one to many to many
4902
4903 #many to many to one
4904
4905 #many to many to many
4906
4907
4908
4909 1;
4910
4911 ########Chado::Featureloc_Pub########
4912
4913 package Chado::Featureloc_Pub;
4914 use base 'Chado::DBI';
4915 use Class::DBI::Pager;
4916 no warnings qw(redefine);
4917
4918 Chado::Featureloc_Pub->set_up_table('featureloc_pub');
4919
4920 #
4921 # Primary key accessors
4922 #
4923
4924 sub id { shift->featureloc_pub_id }
4925 sub featureloc_pub { shift->featureloc_pub_id }
4926
4927
4928
4929
4930 #
4931 # Has A
4932 #
4933
4934 Chado::Featureloc_Pub->has_a(featureloc_id => 'Chado::Featureloc');
4935
4936 sub Chado::Featureloc_Pub::featureloc { return shift->featureloc_id }
4937
4938
4939 Chado::Featureloc_Pub->has_a(pub_id => 'Chado::Pub');
4940
4941 sub Chado::Featureloc_Pub::pub { return shift->pub_id }
4942
4943
4944 #
4945 # Has Many
4946 #
4947
4948
4949
4950 # one to many to one
4951
4952 # one to many to many
4953
4954 #many to many to one
4955
4956 #many to many to many
4957
4958
4959
4960 1;
4961
4962 ########Chado::Elementresult_Relationship########
4963
4964 package Chado::Elementresult_Relationship;
4965 use base 'Chado::DBI';
4966 use Class::DBI::Pager;
4967 no warnings qw(redefine);
4968
4969 Chado::Elementresult_Relationship->set_up_table('elementresult_relationship');
4970
4971 #
4972 # Primary key accessors
4973 #
4974
4975 sub id { shift->elementresult_relationship_id }
4976 sub elementresult_relationship { shift->elementresult_relationship_id }
4977
4978
4979
4980
4981 #
4982 # Has A
4983 #
4984
4985 Chado::Elementresult_Relationship->has_a(subject_id => 'Chado::Elementresult');
4986
4987 sub subject { return shift->subject_id }
4988
4989
4990 Chado::Elementresult_Relationship->has_a(type_id => 'Chado::Cvterm');
4991
4992 sub Chado::Elementresult_Relationship::cvterm { return shift->type_id }
4993
4994
4995 Chado::Elementresult_Relationship->has_a(object_id => 'Chado::Elementresult');
4996
4997 sub object { return shift->object_id }
4998
4999
5000 #
5001 # Has Many
5002 #
5003
5004
5005
5006 # one to many to one
5007
5008 # one to many to many
5009
5010 #many to many to one
5011
5012 #many to many to many
5013
5014
5015
5016 1;
5017
5018 ########Chado::Cvtermsynonym########
5019
5020 package Chado::Cvtermsynonym;
5021 use base 'Chado::DBI';
5022 use Class::DBI::Pager;
5023 no warnings qw(redefine);
5024
5025 Chado::Cvtermsynonym->set_up_table('cvtermsynonym');
5026
5027 #
5028 # Primary key accessors
5029 #
5030
5031 sub id { shift->cvtermsynonym_id }
5032 sub cvtermsynonym { shift->cvtermsynonym_id }
5033
5034
5035
5036
5037 #
5038 # Has A
5039 #
5040
5041 Chado::Cvtermsynonym->has_a(cvterm_id => 'Chado::Cvterm');
5042
5043 sub cvterm { return shift->cvterm_id }
5044
5045
5046 Chado::Cvtermsynonym->has_a(type_id => 'Chado::Cvterm');
5047
5048 sub type { return shift->type_id }
5049
5050
5051 #
5052 # Has Many
5053 #
5054
5055
5056
5057 # one to many to one
5058
5059 # one to many to many
5060
5061 #many to many to one
5062
5063 #many to many to many
5064
5065
5066
5067 1;
5068
5069 ########Chado::Phylonode########
5070
5071 package Chado::Phylonode;
5072 use base 'Chado::DBI';
5073 use Class::DBI::Pager;
5074 no warnings qw(redefine);
5075
5076 Chado::Phylonode->set_up_table('phylonode');
5077
5078 #
5079 # Primary key accessors
5080 #
5081
5082 sub id { shift->phylonode_id }
5083 sub phylonode { shift->phylonode_id }
5084
5085
5086
5087
5088 #
5089 # Has A
5090 #
5091
5092
5093
5094
5095 Chado::Phylonode->has_a(phylotree_id => 'Chado::Phylotree');
5096
5097 sub Chado::Phylonode::phylotree { return shift->phylotree_id }
5098
5099
5100 Chado::Phylonode->has_a(parent_phylonode_id => 'Chado::Phylonode');
5101
5102 sub Chado::Phylonode::phylonode { return shift->parent_phylonode_id }
5103
5104
5105
5106 Chado::Phylonode->has_a(type_id => 'Chado::Cvterm');
5107
5108 sub Chado::Phylonode::cvterm { return shift->type_id }
5109
5110
5111 Chado::Phylonode->has_a(feature_id => 'Chado::Feature');
5112
5113 sub Chado::Phylonode::feature { return shift->feature_id }
5114
5115
5116
5117
5118
5119 #
5120 # Has Many
5121 #
5122
5123 Chado::Phylonode->has_many('phylonodeprop_phylonode_id', 'Chado::Phylonodeprop' => 'phylonode_id');
5124
5125
5126 sub phylonodeprops { return shift->phylonodeprop_phylonode_id }
5127
5128 Chado::Phylonode->has_many('phylonode_pub_phylonode_id', 'Chado::Phylonode_Pub' => 'phylonode_id');
5129
5130 Chado::Phylonode->has_many('phylonode_organism_phylonode_id', 'Chado::Phylonode_Organism' => 'phylonode_id');
5131
5132 Chado::Phylonode->has_many('phylonode_parent_phylonode_id', 'Chado::Phylonode' => 'parent_phylonode_id');
5133
5134
5135 sub phylonode_parent_phylonode_ids { my $self = shift; return $self->phylonode_parent_phylonode_id(@_) }
5136
5137 Chado::Phylonode->has_many('phylonode_dbxref_phylonode_id', 'Chado::Phylonode_Dbxref' => 'phylonode_id');
5138
5139 Chado::Phylonode->has_many('phylonode_relationship_subject_id', 'Chado::Phylonode_Relationship' => 'subject_id');
5140
5141
5142 sub phylonode_relationship_subject_ids { my $self = shift; return $self->phylonode_relationship_subject_id(@_) }
5143
5144 Chado::Phylonode->has_many('phylonode_relationship_object_id', 'Chado::Phylonode_Relationship' => 'object_id');
5145
5146
5147 sub phylonode_relationship_object_ids { my $self = shift; return $self->phylonode_relationship_object_id(@_) }
5148
5149
5150
5151
5152 #
5153 # Has Compound Many (many to many relationships in all their flavors)
5154 #
5155
5156
5157 sub phylonode_organism_phylonodes { return shift->phylonode_organism_phylonode_id }
5158
5159
5160
5161
5162 sub phylonode_pub_phylonodes { return shift->phylonode_pub_phylonode_id }
5163
5164
5165
5166
5167 sub phylonode_dbxref_phylonodes { return shift->phylonode_dbxref_phylonode_id }
5168
5169
5170 # one to many to one
5171
5172
5173 # one2one #
5174 sub organisms { my $self = shift; return map $_->organism_id, $self->phylonode_organism_phylonode_id }
5175
5176
5177
5178 sub pubs { my $self = shift; return map $_->pub_id, $self->phylonode_pub_phylonode_id }
5179
5180
5181
5182 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->phylonode_dbxref_phylonode_id }
5183
5184 # one to many to many
5185
5186
5187
5188
5189 #many to many to one
5190
5191
5192
5193
5194 #many to many to many
5195
5196
5197
5198
5199
5200
5201 1;
5202
5203 ########Chado::Stock_Relationship########
5204
5205 package Chado::Stock_Relationship;
5206 use base 'Chado::DBI';
5207 use Class::DBI::Pager;
5208 no warnings qw(redefine);
5209
5210 Chado::Stock_Relationship->set_up_table('stock_relationship');
5211
5212 #
5213 # Primary key accessors
5214 #
5215
5216 sub id { shift->stock_relationship_id }
5217 sub stock_relationship { shift->stock_relationship_id }
5218
5219
5220
5221
5222 #
5223 # Has A
5224 #
5225
5226 Chado::Stock_Relationship->has_a(subject_id => 'Chado::Stock');
5227
5228 sub subject { return shift->subject_id }
5229
5230
5231 Chado::Stock_Relationship->has_a(object_id => 'Chado::Stock');
5232
5233 sub object { return shift->object_id }
5234
5235
5236 Chado::Stock_Relationship->has_a(type_id => 'Chado::Cvterm');
5237
5238 sub Chado::Stock_Relationship::cvterm { return shift->type_id }
5239
5240
5241
5242 #
5243 # Has Many
5244 #
5245
5246 Chado::Stock_Relationship->has_many('stock_relationship_pub_stock_relationship_id', 'Chado::Stock_Relationship_Pub' => 'stock_relationship_id');
5247
5248
5249
5250
5251 #
5252 # Has Compound Many (many to many relationships in all their flavors)
5253 #
5254
5255
5256 sub stock_relationship_pub_stock_relationships { return shift->stock_relationship_pub_stock_relationship_id }
5257
5258
5259 # one to many to one
5260
5261
5262 # one2one #
5263 sub pubs { my $self = shift; return map $_->pub_id, $self->stock_relationship_pub_stock_relationship_id }
5264
5265 # one to many to many
5266
5267
5268 #many to many to one
5269
5270
5271 #many to many to many
5272
5273
5274
5275
5276 1;
5277
5278 ########Chado::Feature########
5279
5280 package Chado::Feature;
5281 use base 'Chado::DBI';
5282 use Class::DBI::Pager;
5283 no warnings qw(redefine);
5284
5285 Chado::Feature->set_up_table('feature');
5286
5287 #
5288 # Primary key accessors
5289 #
5290
5291 sub id { shift->feature_id }
5292 sub feature { shift->feature_id }
5293
5294
5295
5296
5297 #
5298 # Has A
5299 #
5300
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320 Chado::Feature->has_a(dbxref_id => 'Chado::Dbxref');
5321
5322 sub Chado::Feature::dbxref { return shift->dbxref_id }
5323
5324
5325 Chado::Feature->has_a(organism_id => 'Chado::Organism');
5326
5327 sub Chado::Feature::organism { return shift->organism_id }
5328
5329
5330 Chado::Feature->has_a(type_id => 'Chado::Cvterm');
5331
5332 sub Chado::Feature::cvterm { return shift->type_id }
5333
5334
5335
5336
5337
5338
5339
5340 #
5341 # Has Many
5342 #
5343
5344 Chado::Feature->has_many('feature_dbxref_feature_id', 'Chado::Feature_Dbxref' => 'feature_id');
5345
5346
5347 sub feature_dbxrefs { return shift->feature_dbxref_feature_id }
5348
5349 Chado::Feature->has_many('feature_expression_feature_id', 'Chado::Feature_Expression' => 'feature_id');
5350
5351 Chado::Feature->has_many('feature_cvterm_feature_id', 'Chado::Feature_Cvterm' => 'feature_id');
5352
5353
5354 sub feature_cvterms { return shift->feature_cvterm_feature_id }
5355
5356 Chado::Feature->has_many('feature_phenotype_feature_id', 'Chado::Feature_Phenotype' => 'feature_id');
5357
5358 Chado::Feature->has_many('element_feature_id', 'Chado::Element' => 'feature_id');
5359
5360 Chado::Feature->has_many('featurerange_feature_id', 'Chado::Featurerange' => 'feature_id');
5361
5362
5363 sub featurerange_feature_ids { my $self = shift; return $self->featurerange_feature_id(@_) }
5364
5365 Chado::Feature->has_many('featurerange_leftstartf_id', 'Chado::Featurerange' => 'leftstartf_id');
5366
5367
5368 sub featurerange_leftstartf_ids { my $self = shift; return $self->featurerange_leftstartf_id(@_) }
5369
5370 Chado::Feature->has_many('featurerange_leftendf_id', 'Chado::Featurerange' => 'leftendf_id');
5371
5372
5373 sub featurerange_leftendf_ids { my $self = shift; return $self->featurerange_leftendf_id(@_) }
5374
5375 Chado::Feature->has_many('featurerange_rightstartf_id', 'Chado::Featurerange' => 'rightstartf_id');
5376
5377
5378 sub featurerange_rightstartf_ids { my $self = shift; return $self->featurerange_rightstartf_id(@_) }
5379
5380 Chado::Feature->has_many('featurerange_rightendf_id', 'Chado::Featurerange' => 'rightendf_id');
5381
5382
5383 sub featurerange_rightendf_ids { my $self = shift; return $self->featurerange_rightendf_id(@_) }
5384
5385 Chado::Feature->has_many('featureloc_feature_id', 'Chado::Featureloc' => 'feature_id');
5386
5387
5388 sub featureloc_feature_ids { my $self = shift; return $self->featureloc_feature_id(@_) }
5389
5390 Chado::Feature->has_many('featureloc_srcfeature_id', 'Chado::Featureloc' => 'srcfeature_id');
5391
5392
5393 sub featureloc_srcfeature_ids { my $self = shift; return $self->featureloc_srcfeature_id(@_) }
5394
5395 Chado::Feature->has_many('analysisfeature_feature_id', 'Chado::Analysisfeature' => 'feature_id');
5396
5397
5398 sub analysisfeatures { return shift->analysisfeature_feature_id }
5399
5400 Chado::Feature->has_many('feature_pub_feature_id', 'Chado::Feature_Pub' => 'feature_id');
5401
5402 Chado::Feature->has_many('feature_relationship_subject_id', 'Chado::Feature_Relationship' => 'subject_id');
5403
5404
5405 sub feature_relationship_subject_ids { my $self = shift; return $self->feature_relationship_subject_id(@_) }
5406
5407 Chado::Feature->has_many('feature_relationship_object_id', 'Chado::Feature_Relationship' => 'object_id');
5408
5409
5410 sub feature_relationship_object_ids { my $self = shift; return $self->feature_relationship_object_id(@_) }
5411
5412 Chado::Feature->has_many('featurepos_feature_id', 'Chado::Featurepos' => 'feature_id');
5413
5414
5415 sub featurepos_feature_ids { my $self = shift; return $self->featurepos_feature_id(@_) }
5416
5417 Chado::Feature->has_many('featurepos_map_feature_id', 'Chado::Featurepos' => 'map_feature_id');
5418
5419
5420 sub featurepos_map_feature_ids { my $self = shift; return $self->featurepos_map_feature_id(@_) }
5421
5422 Chado::Feature->has_many('phylonode_feature_id', 'Chado::Phylonode' => 'feature_id');
5423
5424
5425 sub phylonodes { return shift->phylonode_feature_id }
5426
5427 Chado::Feature->has_many('library_feature_feature_id', 'Chado::Library_Feature' => 'feature_id');
5428
5429 Chado::Feature->has_many('featureprop_feature_id', 'Chado::Featureprop' => 'feature_id');
5430
5431
5432 sub featureprops { return shift->featureprop_feature_id }
5433
5434 Chado::Feature->has_many('feature_synonym_feature_id', 'Chado::Feature_Synonym' => 'feature_id');
5435
5436
5437 sub feature_synonyms { return shift->feature_synonym_feature_id }
5438
5439 Chado::Feature->has_many('feature_genotype_feature_id', 'Chado::Feature_Genotype' => 'feature_id');
5440
5441
5442 sub feature_genotype_feature_ids { my $self = shift; return $self->feature_genotype_feature_id(@_) }
5443
5444 Chado::Feature->has_many('feature_genotype_chromosome_id', 'Chado::Feature_Genotype' => 'chromosome_id');
5445
5446
5447 sub feature_genotype_chromosome_ids { my $self = shift; return $self->feature_genotype_chromosome_id(@_) }
5448
5449
5450
5451
5452 #
5453 # Has Compound Many (many to many relationships in all their flavors)
5454 #
5455
5456
5457
5458 sub feature_expression_features { return shift->feature_expression_feature_id }
5459
5460
5461
5462 sub feature_expression_features { return shift->feature_expression_feature_id }
5463
5464
5465
5466
5467
5468 sub library_feature_features { return shift->library_feature_feature_id }
5469
5470
5471
5472 sub feature_pub_features { return shift->feature_pub_feature_id }
5473
5474
5475
5476
5477 sub element_features { return shift->element_feature_id }
5478
5479
5480
5481
5482 sub element_features { return shift->element_feature_id }
5483
5484
5485
5486
5487 sub element_features { return shift->element_feature_id }
5488
5489
5490
5491
5492 sub feature_phenotype_features { return shift->feature_phenotype_feature_id }
5493
5494
5495 # one to many to one
5496
5497
5498 # one2one #
5499 sub expressions { my $self = shift; return map $_->expression_id, $self->feature_expression_feature_id }
5500
5501
5502
5503 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_expression_feature_id }
5504
5505
5506
5507 sub librarys { my $self = shift; return map $_->library_id, $self->library_feature_feature_id }
5508
5509
5510
5511 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_pub_feature_id }
5512
5513
5514
5515 sub arraydesigns { my $self = shift; return map $_->arraydesign_id, $self->element_feature_id }
5516
5517
5518
5519 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->element_feature_id }
5520
5521
5522
5523 sub cvterms { my $self = shift; return map $_->type_id, $self->element_feature_id }
5524
5525
5526
5527 sub phenotypes { my $self = shift; return map $_->phenotype_id, $self->feature_phenotype_feature_id }
5528
5529 # one to many to many
5530
5531
5532
5533
5534
5535
5536
5537
5538
5539 #many to many to one
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549 #many to many to many
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561 1;
5562
5563 ########Chado::Feature_Pubprop########
5564
5565 package Chado::Feature_Pubprop;
5566 use base 'Chado::DBI';
5567 use Class::DBI::Pager;
5568 no warnings qw(redefine);
5569
5570 Chado::Feature_Pubprop->set_up_table('feature_pubprop');
5571
5572 #
5573 # Primary key accessors
5574 #
5575
5576 sub id { shift->feature_pubprop_id }
5577 sub feature_pubprop { shift->feature_pubprop_id }
5578
5579
5580
5581
5582 #
5583 # Has A
5584 #
5585
5586 Chado::Feature_Pubprop->has_a(feature_pub_id => 'Chado::Feature_Pub');
5587
5588 sub Chado::Feature_Pubprop::feature_pub { return shift->feature_pub_id }
5589
5590
5591 Chado::Feature_Pubprop->has_a(type_id => 'Chado::Cvterm');
5592
5593 sub Chado::Feature_Pubprop::cvterm { return shift->type_id }
5594
5595
5596 #
5597 # Has Many
5598 #
5599
5600
5601
5602 # one to many to one
5603
5604 # one to many to many
5605
5606 #many to many to one
5607
5608 #many to many to many
5609
5610
5611
5612 1;
5613
5614 ########Chado::Library_Pub########
5615
5616 package Chado::Library_Pub;
5617 use base 'Chado::DBI';
5618 use Class::DBI::Pager;
5619 no warnings qw(redefine);
5620
5621 Chado::Library_Pub->set_up_table('library_pub');
5622
5623 #
5624 # Primary key accessors
5625 #
5626
5627 sub id { shift->library_pub_id }
5628 sub library_pub { shift->library_pub_id }
5629
5630
5631
5632
5633 #
5634 # Has A
5635 #
5636
5637 Chado::Library_Pub->has_a(library_id => 'Chado::Library');
5638
5639 sub Chado::Library_Pub::library { return shift->library_id }
5640
5641
5642 Chado::Library_Pub->has_a(pub_id => 'Chado::Pub');
5643
5644 sub Chado::Library_Pub::pub { return shift->pub_id }
5645
5646
5647 #
5648 # Has Many
5649 #
5650
5651
5652
5653 # one to many to one
5654
5655 # one to many to many
5656
5657 #many to many to one
5658
5659 #many to many to many
5660
5661
5662
5663 1;
5664
5665 ########Chado::Stockcollection########
5666
5667 package Chado::Stockcollection;
5668 use base 'Chado::DBI';
5669 use Class::DBI::Pager;
5670 no warnings qw(redefine);
5671
5672 Chado::Stockcollection->set_up_table('stockcollection');
5673
5674 #
5675 # Primary key accessors
5676 #
5677
5678 sub id { shift->stockcollection_id }
5679 sub stockcollection { shift->stockcollection_id }
5680
5681
5682
5683
5684 #
5685 # Has A
5686 #
5687
5688 Chado::Stockcollection->has_a(type_id => 'Chado::Cvterm');
5689
5690 sub Chado::Stockcollection::cvterm { return shift->type_id }
5691
5692
5693 Chado::Stockcollection->has_a(contact_id => 'Chado::Contact');
5694
5695 sub Chado::Stockcollection::contact { return shift->contact_id }
5696
5697
5698
5699
5700 #
5701 # Has Many
5702 #
5703
5704 Chado::Stockcollection->has_many('stockcollection_stock_stockcollection_id', 'Chado::Stockcollection_Stock' => 'stockcollection_id');
5705
5706 Chado::Stockcollection->has_many('stockcollectionprop_stockcollection_id', 'Chado::Stockcollectionprop' => 'stockcollection_id');
5707
5708
5709 sub stockcollectionprops { return shift->stockcollectionprop_stockcollection_id }
5710
5711
5712
5713
5714 #
5715 # Has Compound Many (many to many relationships in all their flavors)
5716 #
5717
5718
5719 sub stockcollection_stock_stockcollections { return shift->stockcollection_stock_stockcollection_id }
5720
5721
5722 # one to many to one
5723
5724
5725 # one2one #
5726 sub stocks { my $self = shift; return map $_->stock_id, $self->stockcollection_stock_stockcollection_id }
5727
5728 # one to many to many
5729
5730
5731 #many to many to one
5732
5733
5734 #many to many to many
5735
5736
5737
5738
5739 1;
5740
5741 ########Chado::Biomaterialprop########
5742
5743 package Chado::Biomaterialprop;
5744 use base 'Chado::DBI';
5745 use Class::DBI::Pager;
5746 no warnings qw(redefine);
5747
5748 Chado::Biomaterialprop->set_up_table('biomaterialprop');
5749
5750 #
5751 # Primary key accessors
5752 #
5753
5754 sub id { shift->biomaterialprop_id }
5755 sub biomaterialprop { shift->biomaterialprop_id }
5756
5757
5758
5759
5760 #
5761 # Has A
5762 #
5763
5764 Chado::Biomaterialprop->has_a(biomaterial_id => 'Chado::Biomaterial');
5765
5766 sub Chado::Biomaterialprop::biomaterial { return shift->biomaterial_id }
5767
5768
5769 Chado::Biomaterialprop->has_a(type_id => 'Chado::Cvterm');
5770
5771 sub Chado::Biomaterialprop::cvterm { return shift->type_id }
5772
5773
5774 #
5775 # Has Many
5776 #
5777
5778
5779
5780 # one to many to one
5781
5782 # one to many to many
5783
5784 #many to many to one
5785
5786 #many to many to many
5787
5788
5789
5790 1;
5791
5792 ########Chado::Elementresult########
5793
5794 package Chado::Elementresult;
5795 use base 'Chado::DBI';
5796 use Class::DBI::Pager;
5797 no warnings qw(redefine);
5798
5799 Chado::Elementresult->set_up_table('elementresult');
5800
5801 #
5802 # Primary key accessors
5803 #
5804
5805 sub id { shift->elementresult_id }
5806 sub elementresult { shift->elementresult_id }
5807
5808
5809
5810
5811 #
5812 # Has A
5813 #
5814
5815
5816
5817 Chado::Elementresult->has_a(element_id => 'Chado::Element');
5818
5819 sub Chado::Elementresult::element { return shift->element_id }
5820
5821
5822 Chado::Elementresult->has_a(quantification_id => 'Chado::Quantification');
5823
5824 sub Chado::Elementresult::quantification { return shift->quantification_id }
5825
5826
5827 #
5828 # Has Many
5829 #
5830
5831 Chado::Elementresult->has_many('elementresult_relationship_subject_id', 'Chado::Elementresult_Relationship' => 'subject_id');
5832
5833
5834 sub elementresult_relationship_subject_ids { my $self = shift; return $self->elementresult_relationship_subject_id(@_) }
5835
5836 Chado::Elementresult->has_many('elementresult_relationship_object_id', 'Chado::Elementresult_Relationship' => 'object_id');
5837
5838
5839 sub elementresult_relationship_object_ids { my $self = shift; return $self->elementresult_relationship_object_id(@_) }
5840
5841
5842
5843 # one to many to one
5844
5845 # one to many to many
5846
5847 #many to many to one
5848
5849 #many to many to many
5850
5851
5852
5853 1;
5854
5855 ########Chado::Expression########
5856
5857 package Chado::Expression;
5858 use base 'Chado::DBI';
5859 use Class::DBI::Pager;
5860 no warnings qw(redefine);
5861
5862 Chado::Expression->set_up_table('expression');
5863
5864 #
5865 # Primary key accessors
5866 #
5867
5868 sub id { shift->expression_id }
5869 sub expression { shift->expression_id }
5870
5871
5872
5873
5874 #
5875 # Has A
5876 #
5877
5878
5879
5880
5881
5882
5883 #
5884 # Has Many
5885 #
5886
5887 Chado::Expression->has_many('expression_pub_expression_id', 'Chado::Expression_Pub' => 'expression_id');
5888
5889 Chado::Expression->has_many('feature_expression_expression_id', 'Chado::Feature_Expression' => 'expression_id');
5890
5891 Chado::Expression->has_many('expression_image_expression_id', 'Chado::Expression_Image' => 'expression_id');
5892
5893 Chado::Expression->has_many('expressionprop_expression_id', 'Chado::Expressionprop' => 'expression_id');
5894
5895
5896 sub expressionprops { return shift->expressionprop_expression_id }
5897
5898 Chado::Expression->has_many('expression_cvterm_expression_id', 'Chado::Expression_Cvterm' => 'expression_id');
5899
5900
5901 sub expression_cvterms { return shift->expression_cvterm_expression_id }
5902
5903
5904
5905
5906 #
5907 # Has Compound Many (many to many relationships in all their flavors)
5908 #
5909
5910
5911 sub feature_expression_expressions { return shift->feature_expression_expression_id }
5912
5913
5914
5915
5916 sub feature_expression_expressions { return shift->feature_expression_expression_id }
5917
5918
5919
5920
5921 sub expression_pub_expressions { return shift->expression_pub_expression_id }
5922
5923
5924
5925
5926 sub expression_image_expressions { return shift->expression_image_expression_id }
5927
5928
5929 # one to many to one
5930
5931
5932 # one2one #
5933 sub features { my $self = shift; return map $_->feature_id, $self->feature_expression_expression_id }
5934
5935
5936
5937 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_expression_expression_id }
5938
5939
5940
5941 sub pubs { my $self = shift; return map $_->pub_id, $self->expression_pub_expression_id }
5942
5943
5944
5945 sub eimages { my $self = shift; return map $_->eimage_id, $self->expression_image_expression_id }
5946
5947 # one to many to many
5948
5949
5950
5951
5952
5953 #many to many to one
5954
5955
5956
5957
5958
5959 #many to many to many
5960
5961
5962
5963
5964
5965
5966
5967 1;
5968
5969 ########Chado::Magedocumentation########
5970
5971 package Chado::Magedocumentation;
5972 use base 'Chado::DBI';
5973 use Class::DBI::Pager;
5974 no warnings qw(redefine);
5975
5976 Chado::Magedocumentation->set_up_table('magedocumentation');
5977
5978 #
5979 # Primary key accessors
5980 #
5981
5982 sub id { shift->magedocumentation_id }
5983 sub magedocumentation { shift->magedocumentation_id }
5984
5985
5986
5987
5988 #
5989 # Has A
5990 #
5991
5992 Chado::Magedocumentation->has_a(mageml_id => 'Chado::Mageml');
5993
5994 sub Chado::Magedocumentation::mageml { return shift->mageml_id }
5995
5996
5997 Chado::Magedocumentation->has_a(tableinfo_id => 'Chado::Tableinfo');
5998
5999 sub Chado::Magedocumentation::tableinfo { return shift->tableinfo_id }
6000
6001
6002 #
6003 # Has Many
6004 #
6005
6006
6007
6008 # one to many to one
6009
6010 # one to many to many
6011
6012 #many to many to one
6013
6014 #many to many to many
6015
6016
6017
6018 1;
6019
6020 ########Chado::Library_Cvterm########
6021
6022 package Chado::Library_Cvterm;
6023 use base 'Chado::DBI';
6024 use Class::DBI::Pager;
6025 no warnings qw(redefine);
6026
6027 Chado::Library_Cvterm->set_up_table('library_cvterm');
6028
6029 #
6030 # Primary key accessors
6031 #
6032
6033 sub id { shift->library_cvterm_id }
6034 sub library_cvterm { shift->library_cvterm_id }
6035
6036
6037
6038
6039 #
6040 # Has A
6041 #
6042
6043 Chado::Library_Cvterm->has_a(library_id => 'Chado::Library');
6044
6045 sub Chado::Library_Cvterm::library { return shift->library_id }
6046
6047
6048 Chado::Library_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
6049
6050 sub Chado::Library_Cvterm::cvterm { return shift->cvterm_id }
6051
6052
6053 Chado::Library_Cvterm->has_a(pub_id => 'Chado::Pub');
6054
6055 sub Chado::Library_Cvterm::pub { return shift->pub_id }
6056
6057
6058 #
6059 # Has Many
6060 #
6061
6062
6063
6064 # one to many to one
6065
6066 # one to many to many
6067
6068 #many to many to one
6069
6070 #many to many to many
6071
6072
6073
6074 1;
6075
6076 ########Chado::Stock_Relationship_Pub########
6077
6078 package Chado::Stock_Relationship_Pub;
6079 use base 'Chado::DBI';
6080 use Class::DBI::Pager;
6081 no warnings qw(redefine);
6082
6083 Chado::Stock_Relationship_Pub->set_up_table('stock_relationship_pub');
6084
6085 #
6086 # Primary key accessors
6087 #
6088
6089 sub id { shift->stock_relationship_pub_id }
6090 sub stock_relationship_pub { shift->stock_relationship_pub_id }
6091
6092
6093
6094
6095 #
6096 # Has A
6097 #
6098
6099 Chado::Stock_Relationship_Pub->has_a(stock_relationship_id => 'Chado::Stock_Relationship');
6100
6101 sub Chado::Stock_Relationship_Pub::stock_relationship { return shift->stock_relationship_id }
6102
6103
6104 Chado::Stock_Relationship_Pub->has_a(pub_id => 'Chado::Pub');
6105
6106 sub Chado::Stock_Relationship_Pub::pub { return shift->pub_id }
6107
6108
6109 #
6110 # Has Many
6111 #
6112
6113
6114
6115 # one to many to one
6116
6117 # one to many to many
6118
6119 #many to many to one
6120
6121 #many to many to many
6122
6123
6124
6125 1;
6126
6127 ########Chado::Feature_Relationship_Pub########
6128
6129 package Chado::Feature_Relationship_Pub;
6130 use base 'Chado::DBI';
6131 use Class::DBI::Pager;
6132 no warnings qw(redefine);
6133
6134 Chado::Feature_Relationship_Pub->set_up_table('feature_relationship_pub');
6135
6136 #
6137 # Primary key accessors
6138 #
6139
6140 sub id { shift->feature_relationship_pub_id }
6141 sub feature_relationship_pub { shift->feature_relationship_pub_id }
6142
6143
6144
6145
6146 #
6147 # Has A
6148 #
6149
6150 Chado::Feature_Relationship_Pub->has_a(feature_relationship_id => 'Chado::Feature_Relationship');
6151
6152 sub Chado::Feature_Relationship_Pub::feature_relationship { return shift->feature_relationship_id }
6153
6154
6155 Chado::Feature_Relationship_Pub->has_a(pub_id => 'Chado::Pub');
6156
6157 sub Chado::Feature_Relationship_Pub::pub { return shift->pub_id }
6158
6159
6160 #
6161 # Has Many
6162 #
6163
6164
6165
6166 # one to many to one
6167
6168 # one to many to many
6169
6170 #many to many to one
6171
6172 #many to many to many
6173
6174
6175
6176 1;
6177
6178 ########Chado::Analysisprop########
6179
6180 package Chado::Analysisprop;
6181 use base 'Chado::DBI';
6182 use Class::DBI::Pager;
6183 no warnings qw(redefine);
6184
6185 Chado::Analysisprop->set_up_table('analysisprop');
6186
6187 #
6188 # Primary key accessors
6189 #
6190
6191 sub id { shift->analysisprop_id }
6192 sub analysisprop { shift->analysisprop_id }
6193
6194
6195
6196
6197 #
6198 # Has A
6199 #
6200
6201 Chado::Analysisprop->has_a(analysis_id => 'Chado::Analysis');
6202
6203 sub Chado::Analysisprop::analysis { return shift->analysis_id }
6204
6205
6206 Chado::Analysisprop->has_a(type_id => 'Chado::Cvterm');
6207
6208 sub Chado::Analysisprop::cvterm { return shift->type_id }
6209
6210
6211 #
6212 # Has Many
6213 #
6214
6215
6216
6217 # one to many to one
6218
6219 # one to many to many
6220
6221 #many to many to one
6222
6223 #many to many to many
6224
6225
6226
6227 1;
6228
6229 ########Chado::Library_Feature########
6230
6231 package Chado::Library_Feature;
6232 use base 'Chado::DBI';
6233 use Class::DBI::Pager;
6234 no warnings qw(redefine);
6235
6236 Chado::Library_Feature->set_up_table('library_feature');
6237
6238 #
6239 # Primary key accessors
6240 #
6241
6242 sub id { shift->library_feature_id }
6243 sub library_feature { shift->library_feature_id }
6244
6245
6246
6247
6248 #
6249 # Has A
6250 #
6251
6252 Chado::Library_Feature->has_a(library_id => 'Chado::Library');
6253
6254 sub Chado::Library_Feature::library { return shift->library_id }
6255
6256
6257 Chado::Library_Feature->has_a(feature_id => 'Chado::Feature');
6258
6259 sub Chado::Library_Feature::feature { return shift->feature_id }
6260
6261
6262 #
6263 # Has Many
6264 #
6265
6266
6267
6268 # one to many to one
6269
6270 # one to many to many
6271
6272 #many to many to one
6273
6274 #many to many to many
6275
6276
6277
6278 1;
6279
6280 ########Chado::Stock_Dbxref########
6281
6282 package Chado::Stock_Dbxref;
6283 use base 'Chado::DBI';
6284 use Class::DBI::Pager;
6285 no warnings qw(redefine);
6286
6287 Chado::Stock_Dbxref->set_up_table('stock_dbxref');
6288
6289 #
6290 # Primary key accessors
6291 #
6292
6293 sub id { shift->stock_dbxref_id }
6294 sub stock_dbxref { shift->stock_dbxref_id }
6295
6296
6297
6298
6299 #
6300 # Has A
6301 #
6302
6303 Chado::Stock_Dbxref->has_a(stock_id => 'Chado::Stock');
6304
6305 sub Chado::Stock_Dbxref::stock { return shift->stock_id }
6306
6307
6308 Chado::Stock_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
6309
6310 sub Chado::Stock_Dbxref::dbxref { return shift->dbxref_id }
6311
6312
6313 #
6314 # Has Many
6315 #
6316
6317
6318
6319 # one to many to one
6320
6321 # one to many to many
6322
6323 #many to many to one
6324
6325 #many to many to many
6326
6327
6328
6329 1;
6330
6331 ########Chado::Cvterm_Dbxref########
6332
6333 package Chado::Cvterm_Dbxref;
6334 use base 'Chado::DBI';
6335 use Class::DBI::Pager;
6336 no warnings qw(redefine);
6337
6338 Chado::Cvterm_Dbxref->set_up_table('cvterm_dbxref');
6339
6340 #
6341 # Primary key accessors
6342 #
6343
6344 sub id { shift->cvterm_dbxref_id }
6345 sub cvterm_dbxref { shift->cvterm_dbxref_id }
6346
6347
6348
6349
6350 #
6351 # Has A
6352 #
6353
6354 Chado::Cvterm_Dbxref->has_a(cvterm_id => 'Chado::Cvterm');
6355
6356 sub Chado::Cvterm_Dbxref::cvterm { return shift->cvterm_id }
6357
6358
6359 Chado::Cvterm_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
6360
6361 sub Chado::Cvterm_Dbxref::dbxref { return shift->dbxref_id }
6362
6363
6364 #
6365 # Has Many
6366 #
6367
6368
6369
6370 # one to many to one
6371
6372 # one to many to many
6373
6374 #many to many to one
6375
6376 #many to many to many
6377
6378
6379
6380 1;
6381
6382 ########Chado::Feature_Relationshipprop########
6383
6384 package Chado::Feature_Relationshipprop;
6385 use base 'Chado::DBI';
6386 use Class::DBI::Pager;
6387 no warnings qw(redefine);
6388
6389 Chado::Feature_Relationshipprop->set_up_table('feature_relationshipprop');
6390
6391 #
6392 # Primary key accessors
6393 #
6394
6395 sub id { shift->feature_relationshipprop_id }
6396 sub feature_relationshipprop { shift->feature_relationshipprop_id }
6397
6398
6399
6400
6401 #
6402 # Has A
6403 #
6404
6405 Chado::Feature_Relationshipprop->has_a(feature_relationship_id => 'Chado::Feature_Relationship');
6406
6407 sub Chado::Feature_Relationshipprop::feature_relationship { return shift->feature_relationship_id }
6408
6409
6410 Chado::Feature_Relationshipprop->has_a(type_id => 'Chado::Cvterm');
6411
6412 sub Chado::Feature_Relationshipprop::cvterm { return shift->type_id }
6413
6414
6415
6416 #
6417 # Has Many
6418 #
6419
6420 Chado::Feature_Relationshipprop->has_many('feature_relationshipprop_pub_feature_relationshipprop_id', 'Chado::Feature_Relationshipprop_Pub' => 'feature_relationshipprop_id');
6421
6422
6423
6424
6425 #
6426 # Has Compound Many (many to many relationships in all their flavors)
6427 #
6428
6429
6430 sub feature_relationshipprop_pub_feature_relationshipprops { return shift->feature_relationshipprop_pub_feature_relationshipprop_id }
6431
6432
6433 # one to many to one
6434
6435
6436 # one2one #
6437 sub pubs { my $self = shift; return map $_->pub_id, $self->feature_relationshipprop_pub_feature_relationshipprop_id }
6438
6439 # one to many to many
6440
6441
6442 #many to many to one
6443
6444
6445 #many to many to many
6446
6447
6448
6449
6450 1;
6451
6452 ########Chado::Stockcollection_Stock########
6453
6454 package Chado::Stockcollection_Stock;
6455 use base 'Chado::DBI';
6456 use Class::DBI::Pager;
6457 no warnings qw(redefine);
6458
6459 Chado::Stockcollection_Stock->set_up_table('stockcollection_stock');
6460
6461 #
6462 # Primary key accessors
6463 #
6464
6465 sub id { shift->stockcollection_stock_id }
6466 sub stockcollection_stock { shift->stockcollection_stock_id }
6467
6468
6469
6470
6471 #
6472 # Has A
6473 #
6474
6475 Chado::Stockcollection_Stock->has_a(stockcollection_id => 'Chado::Stockcollection');
6476
6477 sub Chado::Stockcollection_Stock::stockcollection { return shift->stockcollection_id }
6478
6479
6480 Chado::Stockcollection_Stock->has_a(stock_id => 'Chado::Stock');
6481
6482 sub Chado::Stockcollection_Stock::stock { return shift->stock_id }
6483
6484
6485 #
6486 # Has Many
6487 #
6488
6489
6490
6491 # one to many to one
6492
6493 # one to many to many
6494
6495 #many to many to one
6496
6497 #many to many to many
6498
6499
6500
6501 1;
6502
6503 ########Chado::Stockcollectionprop########
6504
6505 package Chado::Stockcollectionprop;
6506 use base 'Chado::DBI';
6507 use Class::DBI::Pager;
6508 no warnings qw(redefine);
6509
6510 Chado::Stockcollectionprop->set_up_table('stockcollectionprop');
6511
6512 #
6513 # Primary key accessors
6514 #
6515
6516 sub id { shift->stockcollectionprop_id }
6517 sub stockcollectionprop { shift->stockcollectionprop_id }
6518
6519
6520
6521
6522 #
6523 # Has A
6524 #
6525
6526 Chado::Stockcollectionprop->has_a(stockcollection_id => 'Chado::Stockcollection');
6527
6528 sub Chado::Stockcollectionprop::stockcollection { return shift->stockcollection_id }
6529
6530
6531 Chado::Stockcollectionprop->has_a(type_id => 'Chado::Cvterm');
6532
6533 sub Chado::Stockcollectionprop::cvterm { return shift->type_id }
6534
6535
6536 #
6537 # Has Many
6538 #
6539
6540
6541
6542 # one to many to one
6543
6544 # one to many to many
6545
6546 #many to many to one
6547
6548 #many to many to many
6549
6550
6551
6552 1;
6553
6554 ########Chado::Element_Relationship########
6555
6556 package Chado::Element_Relationship;
6557 use base 'Chado::DBI';
6558 use Class::DBI::Pager;
6559 no warnings qw(redefine);
6560
6561 Chado::Element_Relationship->set_up_table('element_relationship');
6562
6563 #
6564 # Primary key accessors
6565 #
6566
6567 sub id { shift->element_relationship_id }
6568 sub element_relationship { shift->element_relationship_id }
6569
6570
6571
6572
6573 #
6574 # Has A
6575 #
6576
6577 Chado::Element_Relationship->has_a(subject_id => 'Chado::Element');
6578
6579 sub subject { return shift->subject_id }
6580
6581
6582 Chado::Element_Relationship->has_a(type_id => 'Chado::Cvterm');
6583
6584 sub Chado::Element_Relationship::cvterm { return shift->type_id }
6585
6586
6587 Chado::Element_Relationship->has_a(object_id => 'Chado::Element');
6588
6589 sub object { return shift->object_id }
6590
6591
6592 #
6593 # Has Many
6594 #
6595
6596
6597
6598 # one to many to one
6599
6600 # one to many to many
6601
6602 #many to many to one
6603
6604 #many to many to many
6605
6606
6607
6608 1;
6609
6610 ########Chado::Stock########
6611
6612 package Chado::Stock;
6613 use base 'Chado::DBI';
6614 use Class::DBI::Pager;
6615 no warnings qw(redefine);
6616
6617 Chado::Stock->set_up_table('stock');
6618
6619 #
6620 # Primary key accessors
6621 #
6622
6623 sub id { shift->stock_id }
6624 sub stock { shift->stock_id }
6625
6626
6627
6628
6629 #
6630 # Has A
6631 #
6632
6633
6634
6635
6636
6637
6638 Chado::Stock->has_a(dbxref_id => 'Chado::Dbxref');
6639
6640 sub Chado::Stock::dbxref { return shift->dbxref_id }
6641
6642
6643 Chado::Stock->has_a(organism_id => 'Chado::Organism');
6644
6645 sub Chado::Stock::organism { return shift->organism_id }
6646
6647
6648 Chado::Stock->has_a(type_id => 'Chado::Cvterm');
6649
6650 sub Chado::Stock::cvterm { return shift->type_id }
6651
6652
6653
6654
6655
6656 #
6657 # Has Many
6658 #
6659
6660 Chado::Stock->has_many('stock_cvterm_stock_id', 'Chado::Stock_Cvterm' => 'stock_id');
6661
6662 Chado::Stock->has_many('stock_relationship_subject_id', 'Chado::Stock_Relationship' => 'subject_id');
6663
6664
6665 sub stock_relationship_subject_ids { my $self = shift; return $self->stock_relationship_subject_id(@_) }
6666
6667 Chado::Stock->has_many('stock_relationship_object_id', 'Chado::Stock_Relationship' => 'object_id');
6668
6669
6670 sub stock_relationship_object_ids { my $self = shift; return $self->stock_relationship_object_id(@_) }
6671
6672 Chado::Stock->has_many('stock_dbxref_stock_id', 'Chado::Stock_Dbxref' => 'stock_id');
6673
6674
6675 sub stock_dbxrefs { return shift->stock_dbxref_stock_id }
6676
6677 Chado::Stock->has_many('stockcollection_stock_stock_id', 'Chado::Stockcollection_Stock' => 'stock_id');
6678
6679 Chado::Stock->has_many('stock_pub_stock_id', 'Chado::Stock_Pub' => 'stock_id');
6680
6681 Chado::Stock->has_many('stock_genotype_stock_id', 'Chado::Stock_Genotype' => 'stock_id');
6682
6683 Chado::Stock->has_many('stockprop_stock_id', 'Chado::Stockprop' => 'stock_id');
6684
6685
6686 sub stockprops { return shift->stockprop_stock_id }
6687
6688
6689
6690
6691 #
6692 # Has Compound Many (many to many relationships in all their flavors)
6693 #
6694
6695
6696 sub stock_cvterm_stocks { return shift->stock_cvterm_stock_id }
6697
6698
6699
6700
6701 sub stock_cvterm_stocks { return shift->stock_cvterm_stock_id }
6702
6703
6704
6705
6706 sub stock_genotype_stocks { return shift->stock_genotype_stock_id }
6707
6708
6709
6710
6711
6712 sub stockcollection_stock_stocks { return shift->stockcollection_stock_stock_id }
6713
6714
6715
6716 sub stock_pub_stocks { return shift->stock_pub_stock_id }
6717
6718
6719 # one to many to one
6720
6721
6722 # one2one #
6723 sub cvterms { my $self = shift; return map $_->cvterm_id, $self->stock_cvterm_stock_id }
6724
6725
6726
6727 sub pubs { my $self = shift; return map $_->pub_id, $self->stock_cvterm_stock_id }
6728
6729
6730
6731 sub genotypes { my $self = shift; return map $_->genotype_id, $self->stock_genotype_stock_id }
6732
6733
6734
6735 sub stockcollections { my $self = shift; return map $_->stockcollection_id, $self->stockcollection_stock_stock_id }
6736
6737
6738
6739 sub pubs { my $self = shift; return map $_->pub_id, $self->stock_pub_stock_id }
6740
6741 # one to many to many
6742
6743
6744
6745
6746
6747
6748 #many to many to one
6749
6750
6751
6752
6753
6754
6755 #many to many to many
6756
6757
6758
6759
6760
6761
6762
6763
6764 1;
6765
6766 ########Chado::Featuremap########
6767
6768 package Chado::Featuremap;
6769 use base 'Chado::DBI';
6770 use Class::DBI::Pager;
6771 no warnings qw(redefine);
6772
6773 Chado::Featuremap->set_up_table('featuremap');
6774
6775 #
6776 # Primary key accessors
6777 #
6778
6779 sub id { shift->featuremap_id }
6780 sub featuremap { shift->featuremap_id }
6781
6782
6783
6784
6785 #
6786 # Has A
6787 #
6788
6789
6790
6791 Chado::Featuremap->has_a(unittype_id => 'Chado::Cvterm');
6792
6793 sub Chado::Featuremap::cvterm { return shift->unittype_id }
6794
6795
6796
6797 #
6798 # Has Many
6799 #
6800
6801 Chado::Featuremap->has_many('featurerange_featuremap_id', 'Chado::Featurerange' => 'featuremap_id');
6802
6803
6804 sub featureranges { return shift->featurerange_featuremap_id }
6805
6806 Chado::Featuremap->has_many('featurepos_featuremap_id', 'Chado::Featurepos' => 'featuremap_id');
6807
6808
6809 sub featureposs { return shift->featurepos_featuremap_id }
6810
6811 Chado::Featuremap->has_many('featuremap_pub_featuremap_id', 'Chado::Featuremap_Pub' => 'featuremap_id');
6812
6813
6814
6815
6816 #
6817 # Has Compound Many (many to many relationships in all their flavors)
6818 #
6819
6820
6821 sub featuremap_pub_featuremaps { return shift->featuremap_pub_featuremap_id }
6822
6823
6824 # one to many to one
6825
6826
6827 # one2one #
6828 sub pubs { my $self = shift; return map $_->pub_id, $self->featuremap_pub_featuremap_id }
6829
6830 # one to many to many
6831
6832
6833 #many to many to one
6834
6835
6836 #many to many to many
6837
6838
6839
6840
6841 1;
6842
6843 ########Chado::Treatment########
6844
6845 package Chado::Treatment;
6846 use base 'Chado::DBI';
6847 use Class::DBI::Pager;
6848 no warnings qw(redefine);
6849
6850 Chado::Treatment->set_up_table('treatment');
6851
6852 #
6853 # Primary key accessors
6854 #
6855
6856 sub id { shift->treatment_id }
6857 sub treatment { shift->treatment_id }
6858
6859
6860
6861
6862 #
6863 # Has A
6864 #
6865
6866
6867 Chado::Treatment->has_a(biomaterial_id => 'Chado::Biomaterial');
6868
6869 sub Chado::Treatment::biomaterial { return shift->biomaterial_id }
6870
6871
6872 Chado::Treatment->has_a(type_id => 'Chado::Cvterm');
6873
6874 sub Chado::Treatment::cvterm { return shift->type_id }
6875
6876
6877 Chado::Treatment->has_a(protocol_id => 'Chado::Protocol');
6878
6879 sub Chado::Treatment::protocol { return shift->protocol_id }
6880
6881
6882 #
6883 # Has Many
6884 #
6885
6886 Chado::Treatment->has_many('biomaterial_treatment_treatment_id', 'Chado::Biomaterial_Treatment' => 'treatment_id');
6887
6888
6889 sub biomaterial_treatments { return shift->biomaterial_treatment_treatment_id }
6890
6891
6892
6893 # one to many to one
6894
6895 # one to many to many
6896
6897 #many to many to one
6898
6899 #many to many to many
6900
6901
6902
6903 1;
6904
6905 ########Chado::Pubprop########
6906
6907 package Chado::Pubprop;
6908 use base 'Chado::DBI';
6909 use Class::DBI::Pager;
6910 no warnings qw(redefine);
6911
6912 Chado::Pubprop->set_up_table('pubprop');
6913
6914 #
6915 # Primary key accessors
6916 #
6917
6918 sub id { shift->pubprop_id }
6919 sub pubprop { shift->pubprop_id }
6920
6921
6922
6923
6924 #
6925 # Has A
6926 #
6927
6928 Chado::Pubprop->has_a(pub_id => 'Chado::Pub');
6929
6930 sub Chado::Pubprop::pub { return shift->pub_id }
6931
6932
6933 Chado::Pubprop->has_a(type_id => 'Chado::Cvterm');
6934
6935 sub Chado::Pubprop::cvterm { return shift->type_id }
6936
6937
6938 #
6939 # Has Many
6940 #
6941
6942
6943
6944 # one to many to one
6945
6946 # one to many to many
6947
6948 #many to many to one
6949
6950 #many to many to many
6951
6952
6953
6954 1;
6955
6956 ########Chado::Phylonode_Dbxref########
6957
6958 package Chado::Phylonode_Dbxref;
6959 use base 'Chado::DBI';
6960 use Class::DBI::Pager;
6961 no warnings qw(redefine);
6962
6963 Chado::Phylonode_Dbxref->set_up_table('phylonode_dbxref');
6964
6965 #
6966 # Primary key accessors
6967 #
6968
6969 sub id { shift->phylonode_dbxref_id }
6970 sub phylonode_dbxref { shift->phylonode_dbxref_id }
6971
6972
6973
6974
6975 #
6976 # Has A
6977 #
6978
6979 Chado::Phylonode_Dbxref->has_a(phylonode_id => 'Chado::Phylonode');
6980
6981 sub Chado::Phylonode_Dbxref::phylonode { return shift->phylonode_id }
6982
6983
6984 Chado::Phylonode_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
6985
6986 sub Chado::Phylonode_Dbxref::dbxref { return shift->dbxref_id }
6987
6988
6989 #
6990 # Has Many
6991 #
6992
6993
6994
6995 # one to many to one
6996
6997 # one to many to many
6998
6999 #many to many to one
7000
7001 #many to many to many
7002
7003
7004
7005 1;
7006
7007 ########Chado::Libraryprop########
7008
7009 package Chado::Libraryprop;
7010 use base 'Chado::DBI';
7011 use Class::DBI::Pager;
7012 no warnings qw(redefine);
7013
7014 Chado::Libraryprop->set_up_table('libraryprop');
7015
7016 #
7017 # Primary key accessors
7018 #
7019
7020 sub id { shift->libraryprop_id }
7021 sub libraryprop { shift->libraryprop_id }
7022
7023
7024
7025
7026 #
7027 # Has A
7028 #
7029
7030 Chado::Libraryprop->has_a(library_id => 'Chado::Library');
7031
7032 sub Chado::Libraryprop::library { return shift->library_id }
7033
7034
7035 Chado::Libraryprop->has_a(type_id => 'Chado::Cvterm');
7036
7037 sub Chado::Libraryprop::cvterm { return shift->type_id }
7038
7039
7040 #
7041 # Has Many
7042 #
7043
7044
7045
7046 # one to many to one
7047
7048 # one to many to many
7049
7050 #many to many to one
7051
7052 #many to many to many
7053
7054
7055
7056 1;
7057
7058 ########Chado::Quantificationprop########
7059
7060 package Chado::Quantificationprop;
7061 use base 'Chado::DBI';
7062 use Class::DBI::Pager;
7063 no warnings qw(redefine);
7064
7065 Chado::Quantificationprop->set_up_table('quantificationprop');
7066
7067 #
7068 # Primary key accessors
7069 #
7070
7071 sub id { shift->quantificationprop_id }
7072 sub quantificationprop { shift->quantificationprop_id }
7073
7074
7075
7076
7077 #
7078 # Has A
7079 #
7080
7081 Chado::Quantificationprop->has_a(quantification_id => 'Chado::Quantification');
7082
7083 sub Chado::Quantificationprop::quantification { return shift->quantification_id }
7084
7085
7086 Chado::Quantificationprop->has_a(type_id => 'Chado::Cvterm');
7087
7088 sub Chado::Quantificationprop::cvterm { return shift->type_id }
7089
7090
7091 #
7092 # Has Many
7093 #
7094
7095
7096
7097 # one to many to one
7098
7099 # one to many to many
7100
7101 #many to many to one
7102
7103 #many to many to many
7104
7105
7106
7107 1;
7108
7109 ########Chado::Expression_Cvterm########
7110
7111 package Chado::Expression_Cvterm;
7112 use base 'Chado::DBI';
7113 use Class::DBI::Pager;
7114 no warnings qw(redefine);
7115
7116 Chado::Expression_Cvterm->set_up_table('expression_cvterm');
7117
7118 #
7119 # Primary key accessors
7120 #
7121
7122 sub id { shift->expression_cvterm_id }
7123 sub expression_cvterm { shift->expression_cvterm_id }
7124
7125
7126
7127
7128 #
7129 # Has A
7130 #
7131
7132 Chado::Expression_Cvterm->has_a(expression_id => 'Chado::Expression');
7133
7134 sub Chado::Expression_Cvterm::expression { return shift->expression_id }
7135
7136
7137 Chado::Expression_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
7138
7139 sub cvterm { return shift->cvterm_id }
7140
7141
7142 Chado::Expression_Cvterm->has_a(cvterm_type_id => 'Chado::Cvterm');
7143
7144 sub cvterm_type { return shift->cvterm_type_id }
7145
7146
7147
7148 #
7149 # Has Many
7150 #
7151
7152 Chado::Expression_Cvterm->has_many('expression_cvtermprop_expression_cvterm_id', 'Chado::Expression_Cvtermprop' => 'expression_cvterm_id');
7153
7154
7155 sub expression_cvtermprops { return shift->expression_cvtermprop_expression_cvterm_id }
7156
7157
7158
7159 # one to many to one
7160
7161 # one to many to many
7162
7163 #many to many to one
7164
7165 #many to many to many
7166
7167
7168
7169 1;
7170
7171 ########Chado::Cv########
7172
7173 package Chado::Cv;
7174 use base 'Chado::DBI';
7175 use Class::DBI::Pager;
7176 no warnings qw(redefine);
7177
7178 Chado::Cv->set_up_table('cv');
7179
7180 #
7181 # Primary key accessors
7182 #
7183
7184 sub id { shift->cv_id }
7185 sub cv { shift->cv_id }
7186
7187
7188
7189
7190 #
7191 # Has A
7192 #
7193
7194
7195
7196 #
7197 # Has Many
7198 #
7199
7200 Chado::Cv->has_many('cvtermpath_cv_id', 'Chado::Cvtermpath' => 'cv_id');
7201
7202
7203 sub cvtermpaths { return shift->cvtermpath_cv_id }
7204
7205 Chado::Cv->has_many('cvterm_cv_id', 'Chado::Cvterm' => 'cv_id');
7206
7207
7208 sub cvterms { return shift->cvterm_cv_id }
7209
7210
7211
7212 # one to many to one
7213
7214 # one to many to many
7215
7216 #many to many to one
7217
7218 #many to many to many
7219
7220
7221
7222 1;
7223
7224 ########Chado::Feature_Cvterm_Pub########
7225
7226 package Chado::Feature_Cvterm_Pub;
7227 use base 'Chado::DBI';
7228 use Class::DBI::Pager;
7229 no warnings qw(redefine);
7230
7231 Chado::Feature_Cvterm_Pub->set_up_table('feature_cvterm_pub');
7232
7233 #
7234 # Primary key accessors
7235 #
7236
7237 sub id { shift->feature_cvterm_pub_id }
7238 sub feature_cvterm_pub { shift->feature_cvterm_pub_id }
7239
7240
7241
7242
7243 #
7244 # Has A
7245 #
7246
7247 Chado::Feature_Cvterm_Pub->has_a(feature_cvterm_id => 'Chado::Feature_Cvterm');
7248
7249 sub Chado::Feature_Cvterm_Pub::feature_cvterm { return shift->feature_cvterm_id }
7250
7251
7252 Chado::Feature_Cvterm_Pub->has_a(pub_id => 'Chado::Pub');
7253
7254 sub Chado::Feature_Cvterm_Pub::pub { return shift->pub_id }
7255
7256
7257 #
7258 # Has Many
7259 #
7260
7261
7262
7263 # one to many to one
7264
7265 # one to many to many
7266
7267 #many to many to one
7268
7269 #many to many to many
7270
7271
7272
7273 1;
7274
7275 ########Chado::Project########
7276
7277 package Chado::Project;
7278 use base 'Chado::DBI';
7279 use Class::DBI::Pager;
7280 no warnings qw(redefine);
7281
7282 Chado::Project->set_up_table('project');
7283
7284 #
7285 # Primary key accessors
7286 #
7287
7288 sub id { shift->project_id }
7289 sub project { shift->project_id }
7290
7291
7292
7293
7294 #
7295 # Has A
7296 #
7297
7298
7299 #
7300 # Has Many
7301 #
7302
7303 Chado::Project->has_many('assay_project_project_id', 'Chado::Assay_Project' => 'project_id');
7304
7305
7306
7307
7308 #
7309 # Has Compound Many (many to many relationships in all their flavors)
7310 #
7311
7312
7313
7314 sub assay_project_projects { return shift->assay_project_project_id }
7315
7316 # one to many to one
7317
7318
7319 # one2one #
7320 sub assays { my $self = shift; return map $_->assay_id, $self->assay_project_project_id }
7321
7322 # one to many to many
7323
7324
7325 #many to many to one
7326
7327
7328 #many to many to many
7329
7330
7331
7332
7333 1;
7334
7335 ########Chado::Library########
7336
7337 package Chado::Library;
7338 use base 'Chado::DBI';
7339 use Class::DBI::Pager;
7340 no warnings qw(redefine);
7341
7342 Chado::Library->set_up_table('library');
7343
7344 #
7345 # Primary key accessors
7346 #
7347
7348 sub id { shift->library_id }
7349 sub library { shift->library_id }
7350
7351
7352
7353
7354 #
7355 # Has A
7356 #
7357
7358
7359
7360
7361
7362 Chado::Library->has_a(organism_id => 'Chado::Organism');
7363
7364 sub Chado::Library::organism { return shift->organism_id }
7365
7366
7367 Chado::Library->has_a(type_id => 'Chado::Cvterm');
7368
7369 sub Chado::Library::cvterm { return shift->type_id }
7370
7371
7372
7373 #
7374 # Has Many
7375 #
7376
7377 Chado::Library->has_many('library_pub_library_id', 'Chado::Library_Pub' => 'library_id');
7378
7379 Chado::Library->has_many('library_cvterm_library_id', 'Chado::Library_Cvterm' => 'library_id');
7380
7381 Chado::Library->has_many('library_feature_library_id', 'Chado::Library_Feature' => 'library_id');
7382
7383 Chado::Library->has_many('libraryprop_library_id', 'Chado::Libraryprop' => 'library_id');
7384
7385
7386 sub libraryprops { return shift->libraryprop_library_id }
7387
7388 Chado::Library->has_many('library_synonym_library_id', 'Chado::Library_Synonym' => 'library_id');
7389
7390
7391 sub library_synonyms { return shift->library_synonym_library_id }
7392
7393
7394
7395
7396 #
7397 # Has Compound Many (many to many relationships in all their flavors)
7398 #
7399
7400
7401 sub library_feature_librarys { return shift->library_feature_library_id }
7402
7403
7404
7405
7406 sub library_pub_librarys { return shift->library_pub_library_id }
7407
7408
7409
7410
7411 sub library_cvterm_librarys { return shift->library_cvterm_library_id }
7412
7413
7414
7415
7416 sub library_cvterm_librarys { return shift->library_cvterm_library_id }
7417
7418
7419 # one to many to one
7420
7421
7422 # one2one #
7423 sub features { my $self = shift; return map $_->feature_id, $self->library_feature_library_id }
7424
7425
7426
7427 sub pubs { my $self = shift; return map $_->pub_id, $self->library_pub_library_id }
7428
7429
7430
7431 sub cvterms { my $self = shift; return map $_->cvterm_id, $self->library_cvterm_library_id }
7432
7433
7434
7435 sub pubs { my $self = shift; return map $_->pub_id, $self->library_cvterm_library_id }
7436
7437 # one to many to many
7438
7439
7440
7441
7442
7443 #many to many to one
7444
7445
7446
7447
7448
7449 #many to many to many
7450
7451
7452
7453
7454
7455
7456
7457 1;
7458
7459 ########Chado::Contact########
7460
7461 package Chado::Contact;
7462 use base 'Chado::DBI';
7463 use Class::DBI::Pager;
7464 no warnings qw(redefine);
7465
7466 Chado::Contact->set_up_table('contact');
7467
7468 #
7469 # Primary key accessors
7470 #
7471
7472 sub id { shift->contact_id }
7473 sub contact { shift->contact_id }
7474
7475
7476
7477
7478 #
7479 # Has A
7480 #
7481
7482
7483
7484
7485
7486
7487
7488
7489 Chado::Contact->has_a(type_id => 'Chado::Cvterm');
7490
7491 sub Chado::Contact::cvterm { return shift->type_id }
7492
7493
7494
7495 #
7496 # Has Many
7497 #
7498
7499 Chado::Contact->has_many('assay_operator_id', 'Chado::Assay' => 'operator_id');
7500
7501
7502 sub assays { return shift->assay_operator_id }
7503
7504 Chado::Contact->has_many('quantification_operator_id', 'Chado::Quantification' => 'operator_id');
7505
7506
7507 sub quantifications { return shift->quantification_operator_id }
7508
7509 Chado::Contact->has_many('arraydesign_manufacturer_id', 'Chado::Arraydesign' => 'manufacturer_id');
7510
7511
7512 sub arraydesigns { return shift->arraydesign_manufacturer_id }
7513
7514 Chado::Contact->has_many('study_contact_id', 'Chado::Study' => 'contact_id');
7515
7516
7517 sub studys { return shift->study_contact_id }
7518
7519 Chado::Contact->has_many('contact_relationship_subject_id', 'Chado::Contact_Relationship' => 'subject_id');
7520
7521 Chado::Contact->has_many('contact_relationship_object_id', 'Chado::Contact_Relationship' => 'object_id');
7522
7523 Chado::Contact->has_many('stockcollection_contact_id', 'Chado::Stockcollection' => 'contact_id');
7524
7525
7526 sub stockcollections { return shift->stockcollection_contact_id }
7527
7528 Chado::Contact->has_many('biomaterial_biosourceprovider_id', 'Chado::Biomaterial' => 'biosourceprovider_id');
7529
7530
7531 sub biomaterials { return shift->biomaterial_biosourceprovider_id }
7532
7533
7534
7535
7536 #
7537 # Has Compound Many (many to many relationships in all their flavors)
7538 #
7539
7540
7541
7542 sub contact_relationship_subjects { return shift->contact_relationship_subject_id }
7543
7544
7545 sub contact_relationship_objects { return shift->contact_relationship_object_id }
7546
7547 # one to many to one
7548
7549
7550 # one to many to many
7551
7552
7553 #many to many to one
7554
7555
7556 # many2one #
7557
7558
7559 sub contact_relationship_subject_types { my $self = shift; return map $_->type_id, $self->contact_relationship_subject_id }
7560
7561
7562 sub contact_relationship_object_types { my $self = shift; return map $_->type_id, $self->contact_relationship_object_id }
7563
7564
7565 #many to many to many
7566
7567
7568
7569
7570 1;
7571
7572 ########Chado::Featureprop########
7573
7574 package Chado::Featureprop;
7575 use base 'Chado::DBI';
7576 use Class::DBI::Pager;
7577 no warnings qw(redefine);
7578
7579 Chado::Featureprop->set_up_table('featureprop');
7580
7581 #
7582 # Primary key accessors
7583 #
7584
7585 sub id { shift->featureprop_id }
7586 sub featureprop { shift->featureprop_id }
7587
7588
7589
7590
7591 #
7592 # Has A
7593 #
7594
7595 Chado::Featureprop->has_a(feature_id => 'Chado::Feature');
7596
7597 sub Chado::Featureprop::feature { return shift->feature_id }
7598
7599
7600 Chado::Featureprop->has_a(type_id => 'Chado::Cvterm');
7601
7602 sub Chado::Featureprop::cvterm { return shift->type_id }
7603
7604
7605
7606 #
7607 # Has Many
7608 #
7609
7610 Chado::Featureprop->has_many('featureprop_pub_featureprop_id', 'Chado::Featureprop_Pub' => 'featureprop_id');
7611
7612
7613
7614
7615 #
7616 # Has Compound Many (many to many relationships in all their flavors)
7617 #
7618
7619
7620 sub featureprop_pub_featureprops { return shift->featureprop_pub_featureprop_id }
7621
7622
7623 # one to many to one
7624
7625
7626 # one2one #
7627 sub pubs { my $self = shift; return map $_->pub_id, $self->featureprop_pub_featureprop_id }
7628
7629 # one to many to many
7630
7631
7632 #many to many to one
7633
7634
7635 #many to many to many
7636
7637
7638
7639
7640 1;
7641
7642 ########Chado::Phylonode_Relationship########
7643
7644 package Chado::Phylonode_Relationship;
7645 use base 'Chado::DBI';
7646 use Class::DBI::Pager;
7647 no warnings qw(redefine);
7648
7649 Chado::Phylonode_Relationship->set_up_table('phylonode_relationship');
7650
7651 #
7652 # Primary key accessors
7653 #
7654
7655 sub id { shift->phylonode_relationship_id }
7656 sub phylonode_relationship { shift->phylonode_relationship_id }
7657
7658
7659
7660
7661 #
7662 # Has A
7663 #
7664
7665 Chado::Phylonode_Relationship->has_a(subject_id => 'Chado::Phylonode');
7666
7667 sub subject { return shift->subject_id }
7668
7669
7670 Chado::Phylonode_Relationship->has_a(object_id => 'Chado::Phylonode');
7671
7672 sub object { return shift->object_id }
7673
7674
7675 Chado::Phylonode_Relationship->has_a(type_id => 'Chado::Cvterm');
7676
7677 sub Chado::Phylonode_Relationship::cvterm { return shift->type_id }
7678
7679
7680 Chado::Phylonode_Relationship->has_a(phylotree_id => 'Chado::Phylotree');
7681
7682 sub Chado::Phylonode_Relationship::phylotree { return shift->phylotree_id }
7683
7684
7685 #
7686 # Has Many
7687 #
7688
7689
7690
7691 # one to many to one
7692
7693 # one to many to many
7694
7695 #many to many to one
7696
7697 #many to many to many
7698
7699
7700
7701 1;
7702
7703 ########Chado::Stock_Pub########
7704
7705 package Chado::Stock_Pub;
7706 use base 'Chado::DBI';
7707 use Class::DBI::Pager;
7708 no warnings qw(redefine);
7709
7710 Chado::Stock_Pub->set_up_table('stock_pub');
7711
7712 #
7713 # Primary key accessors
7714 #
7715
7716 sub id { shift->stock_pub_id }
7717 sub stock_pub { shift->stock_pub_id }
7718
7719
7720
7721
7722 #
7723 # Has A
7724 #
7725
7726 Chado::Stock_Pub->has_a(stock_id => 'Chado::Stock');
7727
7728 sub Chado::Stock_Pub::stock { return shift->stock_id }
7729
7730
7731 Chado::Stock_Pub->has_a(pub_id => 'Chado::Pub');
7732
7733 sub Chado::Stock_Pub::pub { return shift->pub_id }
7734
7735
7736 #
7737 # Has Many
7738 #
7739
7740
7741
7742 # one to many to one
7743
7744 # one to many to many
7745
7746 #many to many to one
7747
7748 #many to many to many
7749
7750
7751
7752 1;
7753
7754 ########Chado::Stock_Genotype########
7755
7756 package Chado::Stock_Genotype;
7757 use base 'Chado::DBI';
7758 use Class::DBI::Pager;
7759 no warnings qw(redefine);
7760
7761 Chado::Stock_Genotype->set_up_table('stock_genotype');
7762
7763 #
7764 # Primary key accessors
7765 #
7766
7767 sub id { shift->stock_genotype_id }
7768 sub stock_genotype { shift->stock_genotype_id }
7769
7770
7771
7772
7773 #
7774 # Has A
7775 #
7776
7777 Chado::Stock_Genotype->has_a(stock_id => 'Chado::Stock');
7778
7779 sub Chado::Stock_Genotype::stock { return shift->stock_id }
7780
7781
7782 Chado::Stock_Genotype->has_a(genotype_id => 'Chado::Genotype');
7783
7784 sub Chado::Stock_Genotype::genotype { return shift->genotype_id }
7785
7786
7787 #
7788 # Has Many
7789 #
7790
7791
7792
7793 # one to many to one
7794
7795 # one to many to many
7796
7797 #many to many to one
7798
7799 #many to many to many
7800
7801
7802
7803 1;
7804
7805 ########Chado::Protocolparam########
7806
7807 package Chado::Protocolparam;
7808 use base 'Chado::DBI';
7809 use Class::DBI::Pager;
7810 no warnings qw(redefine);
7811
7812 Chado::Protocolparam->set_up_table('protocolparam');
7813
7814 #
7815 # Primary key accessors
7816 #
7817
7818 sub id { shift->protocolparam_id }
7819 sub protocolparam { shift->protocolparam_id }
7820
7821
7822
7823
7824 #
7825 # Has A
7826 #
7827
7828 Chado::Protocolparam->has_a(protocol_id => 'Chado::Protocol');
7829
7830 sub Chado::Protocolparam::protocol { return shift->protocol_id }
7831
7832
7833 Chado::Protocolparam->has_a(datatype_id => 'Chado::Cvterm');
7834
7835 sub datatype { return shift->datatype_id }
7836
7837
7838 Chado::Protocolparam->has_a(unittype_id => 'Chado::Cvterm');
7839
7840 sub unittype { return shift->unittype_id }
7841
7842
7843 #
7844 # Has Many
7845 #
7846
7847
7848
7849 # one to many to one
7850
7851 # one to many to many
7852
7853 #many to many to one
7854
7855 #many to many to many
7856
7857
7858
7859 1;
7860
7861 ########Chado::Feature_Synonym########
7862
7863 package Chado::Feature_Synonym;
7864 use base 'Chado::DBI';
7865 use Class::DBI::Pager;
7866 no warnings qw(redefine);
7867
7868 Chado::Feature_Synonym->set_up_table('feature_synonym');
7869
7870 #
7871 # Primary key accessors
7872 #
7873
7874 sub id { shift->feature_synonym_id }
7875 sub feature_synonym { shift->feature_synonym_id }
7876
7877
7878
7879
7880 #
7881 # Has A
7882 #
7883
7884 Chado::Feature_Synonym->has_a(synonym_id => 'Chado::Synonym');
7885
7886 sub Chado::Feature_Synonym::synonym { return shift->synonym_id }
7887
7888
7889 Chado::Feature_Synonym->has_a(feature_id => 'Chado::Feature');
7890
7891 sub Chado::Feature_Synonym::feature { return shift->feature_id }
7892
7893
7894 Chado::Feature_Synonym->has_a(pub_id => 'Chado::Pub');
7895
7896 sub Chado::Feature_Synonym::pub { return shift->pub_id }
7897
7898
7899 #
7900 # Has Many
7901 #
7902
7903
7904
7905 # one to many to one
7906
7907 # one to many to many
7908
7909 #many to many to one
7910
7911 #many to many to many
7912
7913
7914
7915 1;
7916
7917 ########Chado::Control########
7918
7919 package Chado::Control;
7920 use base 'Chado::DBI';
7921 use Class::DBI::Pager;
7922 no warnings qw(redefine);
7923
7924 Chado::Control->set_up_table('control');
7925
7926 #
7927 # Primary key accessors
7928 #
7929
7930 sub id { shift->control_id }
7931 sub control { shift->control_id }
7932
7933
7934
7935
7936 #
7937 # Has A
7938 #
7939
7940 Chado::Control->has_a(type_id => 'Chado::Cvterm');
7941
7942 sub Chado::Control::cvterm { return shift->type_id }
7943
7944
7945 Chado::Control->has_a(assay_id => 'Chado::Assay');
7946
7947 sub Chado::Control::assay { return shift->assay_id }
7948
7949
7950 Chado::Control->has_a(tableinfo_id => 'Chado::Tableinfo');
7951
7952 sub Chado::Control::tableinfo { return shift->tableinfo_id }
7953
7954
7955 #
7956 # Has Many
7957 #
7958
7959
7960
7961 # one to many to one
7962
7963 # one to many to many
7964
7965 #many to many to one
7966
7967 #many to many to many
7968
7969
7970
7971 1;
7972
7973 ########Chado::Phenotype_Cvterm########
7974
7975 package Chado::Phenotype_Cvterm;
7976 use base 'Chado::DBI';
7977 use Class::DBI::Pager;
7978 no warnings qw(redefine);
7979
7980 Chado::Phenotype_Cvterm->set_up_table('phenotype_cvterm');
7981
7982 #
7983 # Primary key accessors
7984 #
7985
7986 sub id { shift->phenotype_cvterm_id }
7987 sub phenotype_cvterm { shift->phenotype_cvterm_id }
7988
7989
7990
7991
7992 #
7993 # Has A
7994 #
7995
7996 Chado::Phenotype_Cvterm->has_a(phenotype_id => 'Chado::Phenotype');
7997
7998 sub Chado::Phenotype_Cvterm::phenotype { return shift->phenotype_id }
7999
8000
8001 Chado::Phenotype_Cvterm->has_a(cvterm_id => 'Chado::Cvterm');
8002
8003 sub Chado::Phenotype_Cvterm::cvterm { return shift->cvterm_id }
8004
8005
8006 #
8007 # Has Many
8008 #
8009
8010
8011
8012 # one to many to one
8013
8014 # one to many to many
8015
8016 #many to many to one
8017
8018 #many to many to many
8019
8020
8021
8022 1;
8023
8024 ########Chado::Stockprop########
8025
8026 package Chado::Stockprop;
8027 use base 'Chado::DBI';
8028 use Class::DBI::Pager;
8029 no warnings qw(redefine);
8030
8031 Chado::Stockprop->set_up_table('stockprop');
8032
8033 #
8034 # Primary key accessors
8035 #
8036
8037 sub id { shift->stockprop_id }
8038 sub stockprop { shift->stockprop_id }
8039
8040
8041
8042
8043 #
8044 # Has A
8045 #
8046
8047
8048 Chado::Stockprop->has_a(stock_id => 'Chado::Stock');
8049
8050 sub Chado::Stockprop::stock { return shift->stock_id }
8051
8052
8053 Chado::Stockprop->has_a(type_id => 'Chado::Cvterm');
8054
8055 sub Chado::Stockprop::cvterm { return shift->type_id }
8056
8057
8058 #
8059 # Has Many
8060 #
8061
8062 Chado::Stockprop->has_many('stockprop_pub_stockprop_id', 'Chado::Stockprop_Pub' => 'stockprop_id');
8063
8064
8065
8066
8067 #
8068 # Has Compound Many (many to many relationships in all their flavors)
8069 #
8070
8071
8072 sub stockprop_pub_stockprops { return shift->stockprop_pub_stockprop_id }
8073
8074
8075 # one to many to one
8076
8077
8078 # one2one #
8079 sub pubs { my $self = shift; return map $_->pub_id, $self->stockprop_pub_stockprop_id }
8080
8081 # one to many to many
8082
8083
8084 #many to many to one
8085
8086
8087 #many to many to many
8088
8089
8090
8091
8092 1;
8093
8094 ########Chado::Feature_Genotype########
8095
8096 package Chado::Feature_Genotype;
8097 use base 'Chado::DBI';
8098 use Class::DBI::Pager;
8099 no warnings qw(redefine);
8100
8101 Chado::Feature_Genotype->set_up_table('feature_genotype');
8102
8103 #
8104 # Primary key accessors
8105 #
8106
8107 sub id { shift->feature_genotype_id }
8108 sub feature_genotype { shift->feature_genotype_id }
8109
8110
8111
8112
8113 #
8114 # Has A
8115 #
8116
8117 Chado::Feature_Genotype->has_a(feature_id => 'Chado::Feature');
8118
8119 sub feature { return shift->feature_id }
8120
8121
8122 Chado::Feature_Genotype->has_a(genotype_id => 'Chado::Genotype');
8123
8124 sub Chado::Feature_Genotype::genotype { return shift->genotype_id }
8125
8126
8127 Chado::Feature_Genotype->has_a(chromosome_id => 'Chado::Feature');
8128
8129 sub chromosome { return shift->chromosome_id }
8130
8131
8132 Chado::Feature_Genotype->has_a(cvterm_id => 'Chado::Cvterm');
8133
8134 sub Chado::Feature_Genotype::cvterm { return shift->cvterm_id }
8135
8136
8137 #
8138 # Has Many
8139 #
8140
8141
8142
8143 # one to many to one
8144
8145 # one to many to many
8146
8147 #many to many to one
8148
8149 #many to many to many
8150
8151
8152
8153 1;
8154
8155 ########Chado::Featuremap_Pub########
8156
8157 package Chado::Featuremap_Pub;
8158 use base 'Chado::DBI';
8159 use Class::DBI::Pager;
8160 no warnings qw(redefine);
8161
8162 Chado::Featuremap_Pub->set_up_table('featuremap_pub');
8163
8164 #
8165 # Primary key accessors
8166 #
8167
8168 sub id { shift->featuremap_pub_id }
8169 sub featuremap_pub { shift->featuremap_pub_id }
8170
8171
8172
8173
8174 #
8175 # Has A
8176 #
8177
8178 Chado::Featuremap_Pub->has_a(featuremap_id => 'Chado::Featuremap');
8179
8180 sub Chado::Featuremap_Pub::featuremap { return shift->featuremap_id }
8181
8182
8183 Chado::Featuremap_Pub->has_a(pub_id => 'Chado::Pub');
8184
8185 sub Chado::Featuremap_Pub::pub { return shift->pub_id }
8186
8187
8188 #
8189 # Has Many
8190 #
8191
8192
8193
8194 # one to many to one
8195
8196 # one to many to many
8197
8198 #many to many to one
8199
8200 #many to many to many
8201
8202
8203
8204 1;
8205
8206 ########Chado::Feature_Relationshipprop_Pub########
8207
8208 package Chado::Feature_Relationshipprop_Pub;
8209 use base 'Chado::DBI';
8210 use Class::DBI::Pager;
8211 no warnings qw(redefine);
8212
8213 Chado::Feature_Relationshipprop_Pub->set_up_table('feature_relationshipprop_pub');
8214
8215 #
8216 # Primary key accessors
8217 #
8218
8219 sub id { shift->feature_relationshipprop_pub_id }
8220 sub feature_relationshipprop_pub { shift->feature_relationshipprop_pub_id }
8221
8222
8223
8224
8225 #
8226 # Has A
8227 #
8228
8229 Chado::Feature_Relationshipprop_Pub->has_a(feature_relationshipprop_id => 'Chado::Feature_Relationshipprop');
8230
8231 sub Chado::Feature_Relationshipprop_Pub::feature_relationshipprop { return shift->feature_relationshipprop_id }
8232
8233
8234 Chado::Feature_Relationshipprop_Pub->has_a(pub_id => 'Chado::Pub');
8235
8236 sub Chado::Feature_Relationshipprop_Pub::pub { return shift->pub_id }
8237
8238
8239 #
8240 # Has Many
8241 #
8242
8243
8244
8245 # one to many to one
8246
8247 # one to many to many
8248
8249 #many to many to one
8250
8251 #many to many to many
8252
8253
8254
8255 1;
8256
8257 ########Chado::Cvterm########
8258
8259 package Chado::Cvterm;
8260 use base 'Chado::DBI';
8261 use Class::DBI::Pager;
8262 no warnings qw(redefine);
8263
8264 Chado::Cvterm->set_up_table('cvterm');
8265
8266 #
8267 # Primary key accessors
8268 #
8269
8270 sub id { shift->cvterm_id }
8271 sub cvterm { shift->cvterm_id }
8272
8273
8274
8275
8276 #
8277 # Has A
8278 #
8279
8280
8281
8282
8283
8284
8285
8286
8287
8288
8289
8290
8291
8292
8293
8294
8295
8296
8297
8298
8299
8300
8301
8302
8303
8304
8305
8306
8307
8308
8309
8310
8311
8312
8313
8314
8315
8316
8317
8318
8319
8320
8321
8322
8323
8324
8325
8326
8327
8328
8329
8330
8331
8332
8333
8334
8335
8336
8337
8338
8339
8340
8341
8342
8343
8344
8345
8346
8347 Chado::Cvterm->has_a(cv_id => 'Chado::Cv');
8348
8349 sub Chado::Cvterm::cv { return shift->cv_id }
8350
8351
8352 Chado::Cvterm->has_a(dbxref_id => 'Chado::Dbxref');
8353
8354 sub Chado::Cvterm::dbxref { return shift->dbxref_id }
8355
8356
8357
8358
8359
8360
8361
8362
8363
8364
8365
8366
8367 #
8368 # Has Many
8369 #
8370
8371 Chado::Cvterm->has_many('studyfactor_type_id', 'Chado::Studyfactor' => 'type_id');
8372
8373
8374 sub studyfactors { return shift->studyfactor_type_id }
8375
8376 Chado::Cvterm->has_many('feature_cvterm_cvterm_id', 'Chado::Feature_Cvterm' => 'cvterm_id');
8377
8378
8379 sub feature_cvterms { return shift->feature_cvterm_cvterm_id }
8380
8381 Chado::Cvterm->has_many('arraydesign_platformtype_id', 'Chado::Arraydesign' => 'platformtype_id');
8382
8383 sub arraydesign_platformtypes { return shift->arraydesign_platformtype_id }
8384 #sub --arraydesign--platformtype_id-- {}
8385
8386 Chado::Cvterm->has_many('arraydesign_substratetype_id', 'Chado::Arraydesign' => 'substratetype_id');
8387
8388 sub arraydesign_substratetypes { return shift->arraydesign_substratetype_id }
8389 #sub --arraydesign--substratetype_id-- {}
8390
8391 Chado::Cvterm->has_many('phylonodeprop_type_id', 'Chado::Phylonodeprop' => 'type_id');
8392
8393
8394 sub phylonodeprops { return shift->phylonodeprop_type_id }
8395
8396 Chado::Cvterm->has_many('stock_cvterm_cvterm_id', 'Chado::Stock_Cvterm' => 'cvterm_id');
8397
8398 Chado::Cvterm->has_many('biomaterial_relationship_type_id', 'Chado::Biomaterial_Relationship' => 'type_id');
8399
8400 Chado::Cvterm->has_many('cvtermprop_cvterm_id', 'Chado::Cvtermprop' => 'cvterm_id');
8401
8402
8403 sub cvtermprop_cvterm_ids { my $self = shift; return $self->cvtermprop_cvterm_id(@_) }
8404
8405 Chado::Cvterm->has_many('cvtermprop_type_id', 'Chado::Cvtermprop' => 'type_id');
8406
8407
8408 sub cvtermprop_type_ids { my $self = shift; return $self->cvtermprop_type_id(@_) }
8409
8410 Chado::Cvterm->has_many('quantification_relationship_type_id', 'Chado::Quantification_Relationship' => 'type_id');
8411
8412 Chado::Cvterm->has_many('element_type_id', 'Chado::Element' => 'type_id');
8413
8414 Chado::Cvterm->has_many('phenotype_comparison_cvterm_cvterm_id', 'Chado::Phenotype_Comparison_Cvterm' => 'cvterm_id');
8415
8416
8417 sub phenotype_comparison_cvterms { return shift->phenotype_comparison_cvterm_cvterm_id }
8418
8419 Chado::Cvterm->has_many('arraydesignprop_type_id', 'Chado::Arraydesignprop' => 'type_id');
8420
8421
8422 sub arraydesignprops { return shift->arraydesignprop_type_id }
8423
8424 Chado::Cvterm->has_many('synonym_type_id', 'Chado::Synonym' => 'type_id');
8425
8426
8427 sub synonyms { return shift->synonym_type_id }
8428
8429 Chado::Cvterm->has_many('cvtermpath_type_id', 'Chado::Cvtermpath' => 'type_id');
8430
8431
8432 sub cvtermpath_type_ids { my $self = shift; return $self->cvtermpath_type_id(@_) }
8433
8434 Chado::Cvterm->has_many('cvtermpath_subject_id', 'Chado::Cvtermpath' => 'subject_id');
8435
8436
8437 sub cvtermpath_subject_ids { my $self = shift; return $self->cvtermpath_subject_id(@_) }
8438
8439 Chado::Cvterm->has_many('cvtermpath_object_id', 'Chado::Cvtermpath' => 'object_id');
8440
8441
8442 sub cvtermpath_object_ids { my $self = shift; return $self->cvtermpath_object_id(@_) }
8443
8444 Chado::Cvterm->has_many('biomaterial_treatment_unittype_id', 'Chado::Biomaterial_Treatment' => 'unittype_id');
8445
8446
8447 sub biomaterial_treatments { return shift->biomaterial_treatment_unittype_id }
8448
8449 Chado::Cvterm->has_many('expressionprop_type_id', 'Chado::Expressionprop' => 'type_id');
8450
8451
8452 sub expressionprops { return shift->expressionprop_type_id }
8453
8454 Chado::Cvterm->has_many('cvterm_relationship_type_id', 'Chado::Cvterm_Relationship' => 'type_id');
8455
8456 Chado::Cvterm->has_many('cvterm_relationship_subject_id', 'Chado::Cvterm_Relationship' => 'subject_id');
8457
8458 Chado::Cvterm->has_many('cvterm_relationship_object_id', 'Chado::Cvterm_Relationship' => 'object_id');
8459
8460 Chado::Cvterm->has_many('acquisitionprop_type_id', 'Chado::Acquisitionprop' => 'type_id');
8461
8462
8463 sub acquisitionprops { return shift->acquisitionprop_type_id }
8464
8465 Chado::Cvterm->has_many('studydesignprop_type_id', 'Chado::Studydesignprop' => 'type_id');
8466
8467
8468 sub studydesignprops { return shift->studydesignprop_type_id }
8469
8470 Chado::Cvterm->has_many('assayprop_type_id', 'Chado::Assayprop' => 'type_id');
8471
8472
8473 sub assayprops { return shift->assayprop_type_id }
8474
8475 Chado::Cvterm->has_many('environment_cvterm_cvterm_id', 'Chado::Environment_Cvterm' => 'cvterm_id');
8476
8477 Chado::Cvterm->has_many('contact_relationship_type_id', 'Chado::Contact_Relationship' => 'type_id');
8478
8479 Chado::Cvterm->has_many('pub_type_id', 'Chado::Pub' => 'type_id');
8480
8481 sub pub_types { return shift->pub_type_id }
8482 #sub --pub--type_id-- {}
8483
8484 Chado::Cvterm->has_many('organismprop_type_id', 'Chado::Organismprop' => 'type_id');
8485
8486
8487 sub organismprops { return shift->organismprop_type_id }
8488
8489 Chado::Cvterm->has_many('dbxrefprop_type_id', 'Chado::Dbxrefprop' => 'type_id');
8490
8491
8492 sub dbxrefprops { return shift->dbxrefprop_type_id }
8493
8494 Chado::Cvterm->has_many('feature_relationship_type_id', 'Chado::Feature_Relationship' => 'type_id');
8495
8496
8497 sub feature_relationships { return shift->feature_relationship_type_id }
8498
8499 Chado::Cvterm->has_many('acquisition_relationship_type_id', 'Chado::Acquisition_Relationship' => 'type_id');
8500
8501
8502 sub acquisition_relationships { return shift->acquisition_relationship_type_id }
8503
8504 Chado::Cvterm->has_many('feature_cvtermprop_type_id', 'Chado::Feature_Cvtermprop' => 'type_id');
8505
8506
8507 sub feature_cvtermprops { return shift->feature_cvtermprop_type_id }
8508
8509 Chado::Cvterm->has_many('protocol_type_id', 'Chado::Protocol' => 'type_id');
8510
8511
8512 sub protocols { return shift->protocol_type_id }
8513
8514 Chado::Cvterm->has_many('elementresult_relationship_type_id', 'Chado::Elementresult_Relationship' => 'type_id');
8515
8516
8517 sub elementresult_relationships { return shift->elementresult_relationship_type_id }
8518
8519 Chado::Cvterm->has_many('cvtermsynonym_cvterm_id', 'Chado::Cvtermsynonym' => 'cvterm_id');
8520
8521
8522 sub cvtermsynonym_cvterm_ids { my $self = shift; return $self->cvtermsynonym_cvterm_id(@_) }
8523
8524 Chado::Cvterm->has_many('cvtermsynonym_type_id', 'Chado::Cvtermsynonym' => 'type_id');
8525
8526
8527 sub cvtermsynonym_type_ids { my $self = shift; return $self->cvtermsynonym_type_id(@_) }
8528
8529 Chado::Cvterm->has_many('phylonode_type_id', 'Chado::Phylonode' => 'type_id');
8530
8531
8532 sub phylonodes { return shift->phylonode_type_id }
8533
8534 Chado::Cvterm->has_many('stock_relationship_type_id', 'Chado::Stock_Relationship' => 'type_id');
8535
8536
8537 sub stock_relationships { return shift->stock_relationship_type_id }
8538
8539 Chado::Cvterm->has_many('feature_type_id', 'Chado::Feature' => 'type_id');
8540
8541 sub feature_types { return shift->feature_type_id }
8542 #sub --feature--type_id-- {}
8543
8544 Chado::Cvterm->has_many('feature_pubprop_type_id', 'Chado::Feature_Pubprop' => 'type_id');
8545
8546
8547 sub feature_pubprops { return shift->feature_pubprop_type_id }
8548
8549 Chado::Cvterm->has_many('stockcollection_type_id', 'Chado::Stockcollection' => 'type_id');
8550
8551
8552 sub stockcollections { return shift->stockcollection_type_id }
8553
8554 Chado::Cvterm->has_many('biomaterialprop_type_id', 'Chado::Biomaterialprop' => 'type_id');
8555
8556
8557 sub biomaterialprops { return shift->biomaterialprop_type_id }
8558
8559 Chado::Cvterm->has_many('library_cvterm_cvterm_id', 'Chado::Library_Cvterm' => 'cvterm_id');
8560
8561 Chado::Cvterm->has_many('analysisprop_type_id', 'Chado::Analysisprop' => 'type_id');
8562
8563
8564 sub analysisprops { return shift->analysisprop_type_id }
8565
8566 Chado::Cvterm->has_many('cvterm_dbxref_cvterm_id', 'Chado::Cvterm_Dbxref' => 'cvterm_id');
8567
8568
8569 sub cvterm_dbxrefs { return shift->cvterm_dbxref_cvterm_id }
8570
8571 Chado::Cvterm->has_many('feature_relationshipprop_type_id', 'Chado::Feature_Relationshipprop' => 'type_id');
8572
8573
8574 sub feature_relationshipprops { return shift->feature_relationshipprop_type_id }
8575
8576 Chado::Cvterm->has_many('stockcollectionprop_type_id', 'Chado::Stockcollectionprop' => 'type_id');
8577
8578
8579 sub stockcollectionprops { return shift->stockcollectionprop_type_id }
8580
8581 Chado::Cvterm->has_many('element_relationship_type_id', 'Chado::Element_Relationship' => 'type_id');
8582
8583
8584 sub element_relationships { return shift->element_relationship_type_id }
8585
8586 Chado::Cvterm->has_many('stock_type_id', 'Chado::Stock' => 'type_id');
8587
8588 sub stock_types { return shift->stock_type_id }
8589 #sub --stock--type_id-- {}
8590
8591 Chado::Cvterm->has_many('featuremap_unittype_id', 'Chado::Featuremap' => 'unittype_id');
8592
8593
8594 sub featuremaps { return shift->featuremap_unittype_id }
8595
8596 Chado::Cvterm->has_many('treatment_type_id', 'Chado::Treatment' => 'type_id');
8597
8598
8599 sub treatments { return shift->treatment_type_id }
8600
8601 Chado::Cvterm->has_many('pubprop_type_id', 'Chado::Pubprop' => 'type_id');
8602
8603
8604 sub pubprops { return shift->pubprop_type_id }
8605
8606 Chado::Cvterm->has_many('libraryprop_type_id', 'Chado::Libraryprop' => 'type_id');
8607
8608
8609 sub libraryprops { return shift->libraryprop_type_id }
8610
8611 Chado::Cvterm->has_many('quantificationprop_type_id', 'Chado::Quantificationprop' => 'type_id');
8612
8613
8614 sub quantificationprops { return shift->quantificationprop_type_id }
8615
8616 Chado::Cvterm->has_many('expression_cvterm_cvterm_id', 'Chado::Expression_Cvterm' => 'cvterm_id');
8617
8618
8619 sub expression_cvterm_cvterm_ids { my $self = shift; return $self->expression_cvterm_cvterm_id(@_) }
8620
8621 Chado::Cvterm->has_many('expression_cvterm_cvterm_type_id', 'Chado::Expression_Cvterm' => 'cvterm_type_id');
8622
8623
8624 sub expression_cvterm_cvterm_type_ids { my $self = shift; return $self->expression_cvterm_cvterm_type_id(@_) }
8625
8626 Chado::Cvterm->has_many('library_type_id', 'Chado::Library' => 'type_id');
8627
8628 sub library_types { return shift->library_type_id }
8629 #sub --library--type_id-- {}
8630
8631 Chado::Cvterm->has_many('contact_type_id', 'Chado::Contact' => 'type_id');
8632
8633
8634 sub contacts { return shift->contact_type_id }
8635
8636 Chado::Cvterm->has_many('featureprop_type_id', 'Chado::Featureprop' => 'type_id');
8637
8638
8639 sub featureprops { return shift->featureprop_type_id }
8640
8641 Chado::Cvterm->has_many('phylonode_relationship_type_id', 'Chado::Phylonode_Relationship' => 'type_id');
8642
8643
8644 sub phylonode_relationships { return shift->phylonode_relationship_type_id }
8645
8646 Chado::Cvterm->has_many('protocolparam_datatype_id', 'Chado::Protocolparam' => 'datatype_id');
8647
8648
8649 sub protocolparam_datatype_ids { my $self = shift; return $self->protocolparam_datatype_id(@_) }
8650
8651 Chado::Cvterm->has_many('protocolparam_unittype_id', 'Chado::Protocolparam' => 'unittype_id');
8652
8653
8654 sub protocolparam_unittype_ids { my $self = shift; return $self->protocolparam_unittype_id(@_) }
8655
8656 Chado::Cvterm->has_many('control_type_id', 'Chado::Control' => 'type_id');
8657
8658
8659 sub controls { return shift->control_type_id }
8660
8661 Chado::Cvterm->has_many('phenotype_cvterm_cvterm_id', 'Chado::Phenotype_Cvterm' => 'cvterm_id');
8662
8663
8664 sub phenotype_cvterms { return shift->phenotype_cvterm_cvterm_id }
8665
8666 Chado::Cvterm->has_many('stockprop_type_id', 'Chado::Stockprop' => 'type_id');
8667
8668
8669 sub stockprops { return shift->stockprop_type_id }
8670
8671 Chado::Cvterm->has_many('feature_genotype_cvterm_id', 'Chado::Feature_Genotype' => 'cvterm_id');
8672
8673
8674 sub feature_genotypes { return shift->feature_genotype_cvterm_id }
8675
8676 Chado::Cvterm->has_many('phenstatement_type_id', 'Chado::Phenstatement' => 'type_id');
8677
8678 Chado::Cvterm->has_many('expression_cvtermprop_type_id', 'Chado::Expression_Cvtermprop' => 'type_id');
8679
8680
8681 sub expression_cvtermprops { return shift->expression_cvtermprop_type_id }
8682
8683 Chado::Cvterm->has_many('phenotype_observable_id', 'Chado::Phenotype' => 'observable_id');
8684
8685 sub phenotype_observables { return shift->phenotype_observable_id }
8686 #sub --phenotype--observable_id-- {}
8687
8688 Chado::Cvterm->has_many('phenotype_attr_id', 'Chado::Phenotype' => 'attr_id');
8689
8690 sub phenotype_attrs { return shift->phenotype_attr_id }
8691 #sub --phenotype--attr_id-- {}
8692
8693 Chado::Cvterm->has_many('phenotype_cvalue_id', 'Chado::Phenotype' => 'cvalue_id');
8694
8695 sub phenotype_cvalues { return shift->phenotype_cvalue_id }
8696 #sub --phenotype--cvalue_id-- {}
8697
8698 Chado::Cvterm->has_many('phenotype_assay_id', 'Chado::Phenotype' => 'assay_id');
8699
8700 sub phenotype_assays { return shift->phenotype_assay_id }
8701 #sub --phenotype--assay_id-- {}
8702
8703 Chado::Cvterm->has_many('phendesc_type_id', 'Chado::Phendesc' => 'type_id');
8704
8705
8706 sub phendescs { return shift->phendesc_type_id }
8707
8708 Chado::Cvterm->has_many('phylotree_type_id', 'Chado::Phylotree' => 'type_id');
8709
8710
8711 sub phylotrees { return shift->phylotree_type_id }
8712
8713 Chado::Cvterm->has_many('feature_expressionprop_type_id', 'Chado::Feature_Expressionprop' => 'type_id');
8714
8715
8716 sub feature_expressionprops { return shift->feature_expressionprop_type_id }
8717
8718 Chado::Cvterm->has_many('pub_relationship_type_id', 'Chado::Pub_Relationship' => 'type_id');
8719
8720
8721
8722
8723 #
8724 # Has Compound Many (many to many relationships in all their flavors)
8725 #
8726
8727
8728
8729 sub environment_cvterm_cvterms { return shift->environment_cvterm_cvterm_id }
8730
8731
8732
8733
8734 sub quantification_relationship_types { return shift->quantification_relationship_type_id }
8735
8736
8737
8738
8739
8740 sub stock_cvterm_cvterms { return shift->stock_cvterm_cvterm_id }
8741
8742
8743
8744 sub stock_cvterm_cvterms { return shift->stock_cvterm_cvterm_id }
8745
8746
8747
8748
8749 sub contact_relationship_types { return shift->contact_relationship_type_id }
8750
8751
8752
8753
8754
8755
8756 sub element_types { return shift->element_type_id }
8757
8758
8759
8760
8761 sub element_types { return shift->element_type_id }
8762
8763
8764
8765 sub element_types { return shift->element_type_id }
8766
8767
8768
8769
8770
8771 sub phenstatement_types { return shift->phenstatement_type_id }
8772
8773
8774
8775
8776 sub phenstatement_types { return shift->phenstatement_type_id }
8777
8778
8779
8780 sub phenstatement_types { return shift->phenstatement_type_id }
8781
8782
8783
8784
8785
8786 sub phenstatement_types { return shift->phenstatement_type_id }
8787
8788
8789
8790
8791 sub biomaterial_relationship_types { return shift->biomaterial_relationship_type_id }
8792
8793
8794
8795
8796 sub cvterm_relationship_types { return shift->cvterm_relationship_type_id }
8797
8798
8799 sub cvterm_relationship_subjects { return shift->cvterm_relationship_subject_id }
8800
8801
8802 sub cvterm_relationship_objects { return shift->cvterm_relationship_object_id }
8803
8804
8805
8806
8807
8808 sub pub_relationship_types { return shift->pub_relationship_type_id }
8809
8810
8811
8812
8813 sub library_cvterm_cvterms { return shift->library_cvterm_cvterm_id }
8814
8815
8816
8817 sub library_cvterm_cvterms { return shift->library_cvterm_cvterm_id }
8818
8819
8820 # one to many to one
8821
8822
8823 # one2one #
8824 sub environments { my $self = shift; return map $_->environment_id, $self->environment_cvterm_cvterm_id }
8825
8826
8827
8828
8829 sub stocks { my $self = shift; return map $_->stock_id, $self->stock_cvterm_cvterm_id }
8830
8831
8832
8833 sub pubs { my $self = shift; return map $_->pub_id, $self->stock_cvterm_cvterm_id }
8834
8835
8836
8837
8838 sub arraydesigns { my $self = shift; return map $_->arraydesign_id, $self->element_type_id }
8839
8840
8841
8842 sub features { my $self = shift; return map $_->feature_id, $self->element_type_id }
8843
8844
8845
8846 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->element_type_id }
8847
8848
8849
8850 sub genotypes { my $self = shift; return map $_->genotype_id, $self->phenstatement_type_id }
8851
8852
8853
8854 sub environments { my $self = shift; return map $_->environment_id, $self->phenstatement_type_id }
8855
8856
8857
8858 sub pubs { my $self = shift; return map $_->pub_id, $self->phenstatement_type_id }
8859
8860
8861
8862 sub phenotypes { my $self = shift; return map $_->phenotype_id, $self->phenstatement_type_id }
8863
8864
8865
8866
8867
8868 sub librarys { my $self = shift; return map $_->library_id, $self->library_cvterm_cvterm_id }
8869
8870
8871
8872 sub pubs { my $self = shift; return map $_->pub_id, $self->library_cvterm_cvterm_id }
8873
8874 # one to many to many
8875
8876
8877
8878 # one2many #
8879
8880
8881
8882
8883 sub quantification_relationship_subjects { my $self = shift; return map $_->subject_id, $self->quantification_relationship_type_id }
8884
8885
8886
8887
8888
8889
8890
8891
8892
8893
8894
8895 sub contact_relationship_subjects { my $self = shift; return map $_->subject_id, $self->contact_relationship_type_id }
8896
8897
8898
8899
8900
8901
8902
8903
8904
8905
8906
8907
8908
8909
8910
8911
8912 sub biomaterial_relationship_subjects { my $self = shift; return map $_->subject_id, $self->biomaterial_relationship_type_id }
8913
8914
8915
8916
8917
8918
8919
8920
8921
8922 sub pub_relationship_subjects { my $self = shift; return map $_->subject_id, $self->pub_relationship_type_id }
8923
8924
8925
8926
8927
8928 #many to many to one
8929
8930
8931
8932
8933
8934
8935
8936
8937
8938
8939
8940
8941
8942
8943
8944
8945
8946 #many to many to many
8947
8948
8949
8950
8951
8952
8953
8954
8955
8956
8957
8958
8959
8960
8961
8962
8963
8964
8965
8966 1;
8967
8968 ########Chado::Biomaterial########
8969
8970 package Chado::Biomaterial;
8971 use base 'Chado::DBI';
8972 use Class::DBI::Pager;
8973 no warnings qw(redefine);
8974
8975 Chado::Biomaterial->set_up_table('biomaterial');
8976
8977 #
8978 # Primary key accessors
8979 #
8980
8981 sub id { shift->biomaterial_id }
8982 sub biomaterial { shift->biomaterial_id }
8983
8984
8985
8986
8987 #
8988 # Has A
8989 #
8990
8991
8992
8993
8994
8995
8996
8997
8998 Chado::Biomaterial->has_a(taxon_id => 'Chado::Organism');
8999
9000 sub Chado::Biomaterial::organism { return shift->taxon_id }
9001
9002
9003 Chado::Biomaterial->has_a(biosourceprovider_id => 'Chado::Contact');
9004
9005 sub Chado::Biomaterial::contact { return shift->biosourceprovider_id }
9006
9007
9008 Chado::Biomaterial->has_a(dbxref_id => 'Chado::Dbxref');
9009
9010 sub Chado::Biomaterial::dbxref { return shift->dbxref_id }
9011
9012
9013 #
9014 # Has Many
9015 #
9016
9017 Chado::Biomaterial->has_many('biomaterial_relationship_subject_id', 'Chado::Biomaterial_Relationship' => 'subject_id');
9018
9019 Chado::Biomaterial->has_many('biomaterial_relationship_object_id', 'Chado::Biomaterial_Relationship' => 'object_id');
9020
9021 Chado::Biomaterial->has_many('biomaterial_treatment_biomaterial_id', 'Chado::Biomaterial_Treatment' => 'biomaterial_id');
9022
9023
9024 sub biomaterial_treatments { return shift->biomaterial_treatment_biomaterial_id }
9025
9026 Chado::Biomaterial->has_many('assay_biomaterial_biomaterial_id', 'Chado::Assay_Biomaterial' => 'biomaterial_id');
9027
9028
9029 sub assay_biomaterials { return shift->assay_biomaterial_biomaterial_id }
9030
9031 Chado::Biomaterial->has_many('biomaterial_dbxref_biomaterial_id', 'Chado::Biomaterial_Dbxref' => 'biomaterial_id');
9032
9033 Chado::Biomaterial->has_many('biomaterialprop_biomaterial_id', 'Chado::Biomaterialprop' => 'biomaterial_id');
9034
9035
9036 sub biomaterialprops { return shift->biomaterialprop_biomaterial_id }
9037
9038 Chado::Biomaterial->has_many('treatment_biomaterial_id', 'Chado::Treatment' => 'biomaterial_id');
9039
9040
9041 sub treatments { return shift->treatment_biomaterial_id }
9042
9043
9044
9045
9046 #
9047 # Has Compound Many (many to many relationships in all their flavors)
9048 #
9049
9050
9051 sub biomaterial_dbxref_biomaterials { return shift->biomaterial_dbxref_biomaterial_id }
9052
9053
9054
9055
9056 sub biomaterial_relationship_subjects { return shift->biomaterial_relationship_subject_id }
9057
9058
9059
9060 sub biomaterial_relationship_objects { return shift->biomaterial_relationship_object_id }
9061
9062 # one to many to one
9063
9064
9065 # one2one #
9066 sub dbxrefs { my $self = shift; return map $_->dbxref_id, $self->biomaterial_dbxref_biomaterial_id }
9067
9068
9069 # one to many to many
9070
9071
9072
9073 #many to many to one
9074
9075
9076
9077 # many2one #
9078
9079
9080 sub biomaterial_relationship_subject_types { my $self = shift; return map $_->type_id, $self->biomaterial_relationship_subject_id }
9081
9082
9083 sub biomaterial_relationship_object_types { my $self = shift; return map $_->type_id, $self->biomaterial_relationship_object_id }
9084
9085
9086 #many to many to many
9087
9088
9089
9090
9091
9092 1;
9093
9094 ########Chado::Environment########
9095
9096 package Chado::Environment;
9097 use base 'Chado::DBI';
9098 use Class::DBI::Pager;
9099 no warnings qw(redefine);
9100
9101 Chado::Environment->set_up_table('environment');
9102
9103 #
9104 # Primary key accessors
9105 #
9106
9107 sub id { shift->environment_id }
9108 sub environment { shift->environment_id }
9109
9110
9111
9112
9113 #
9114 # Has A
9115 #
9116
9117
9118
9119
9120
9121
9122 #
9123 # Has Many
9124 #
9125
9126 Chado::Environment->has_many('environment_cvterm_environment_id', 'Chado::Environment_Cvterm' => 'environment_id');
9127
9128 Chado::Environment->has_many('phenotype_comparison_environment1_id', 'Chado::Phenotype_Comparison' => 'environment1_id');
9129
9130 Chado::Environment->has_many('phenotype_comparison_environment2_id', 'Chado::Phenotype_Comparison' => 'environment2_id');
9131
9132 Chado::Environment->has_many('phenstatement_environment_id', 'Chado::Phenstatement' => 'environment_id');
9133
9134 Chado::Environment->has_many('phendesc_environment_id', 'Chado::Phendesc' => 'environment_id');
9135
9136
9137 sub phendescs { return shift->phendesc_environment_id }
9138
9139
9140
9141
9142 #
9143 # Has Compound Many (many to many relationships in all their flavors)
9144 #
9145
9146
9147 sub environment_cvterm_environments { return shift->environment_cvterm_environment_id }
9148
9149
9150
9151
9152
9153 sub phenotype_comparison_environment1s { return shift->phenotype_comparison_environment1_id }
9154
9155
9156
9157 sub phenotype_comparison_environment2s { return shift->phenotype_comparison_environment2_id }
9158
9159
9160
9161 sub phenotype_comparison_environment1s { return shift->phenotype_comparison_environment1_id }
9162
9163
9164 sub phenotype_comparison_environment2s { return shift->phenotype_comparison_environment2_id }
9165
9166
9167
9168
9169 sub phenotype_comparison_environment1s { return shift->phenotype_comparison_environment1_id }
9170
9171
9172 sub phenotype_comparison_environment2s { return shift->phenotype_comparison_environment2_id }
9173
9174
9175
9176
9177 sub phenotype_comparison_environment1s { return shift->phenotype_comparison_environment1_id }
9178
9179
9180 sub phenotype_comparison_environment2s { return shift->phenotype_comparison_environment2_id }
9181
9182
9183
9184
9185
9186
9187 sub phenstatement_environments { return shift->phenstatement_environment_id }
9188
9189
9190
9191 sub phenstatement_environments { return shift->phenstatement_environment_id }
9192
9193
9194
9195
9196 sub phenstatement_environments { return shift->phenstatement_environment_id }
9197
9198
9199
9200
9201 sub phenstatement_environments { return shift->phenstatement_environment_id }
9202
9203
9204 # one to many to one
9205
9206
9207 # one2one #
9208 sub cvterms { my $self = shift; return map $_->cvterm_id, $self->environment_cvterm_environment_id }
9209
9210
9211
9212
9213
9214
9215
9216 sub genotypes { my $self = shift; return map $_->genotype_id, $self->phenstatement_environment_id }
9217
9218
9219
9220 sub cvterms { my $self = shift; return map $_->type_id, $self->phenstatement_environment_id }
9221
9222
9223
9224 sub pubs { my $self = shift; return map $_->pub_id, $self->phenstatement_environment_id }
9225
9226
9227
9228 sub phenotypes { my $self = shift; return map $_->phenotype_id, $self->phenstatement_environment_id }
9229
9230 # one to many to many
9231
9232
9233
9234
9235
9236
9237
9238
9239
9240
9241 #many to many to one
9242
9243
9244
9245
9246 # many2one #
9247
9248
9249 sub phenotype_comparison_environment1_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_environment1_id }
9250
9251
9252 sub phenotype_comparison_environment2_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_environment2_id }
9253
9254
9255
9256
9257
9258
9259 sub phenotype_comparison_environment1_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_environment1_id }
9260
9261
9262 sub phenotype_comparison_environment2_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_environment2_id }
9263
9264
9265
9266
9267
9268
9269
9270 #many to many to many
9271
9272
9273
9274
9275 # many2many #
9276
9277
9278
9279
9280 sub phenotype_comparison_environment1_genotype1s { my $self = shift; return map $_->phenotype_comparison_genotype1s, $self->phenotype_comparison_environment1s }
9281
9282
9283 sub phenotype_comparison_environment1_genotype2s { my $self = shift; return map $_->phenotype_comparison_genotype2s, $self->phenotype_comparison_environment1s }
9284
9285
9286
9287
9288
9289
9290 sub phenotype_comparison_environment2_genotype1s { my $self = shift; return map $_->phenotype_comparison_genotype1s, $self->phenotype_comparison_environment2s }
9291
9292
9293 sub phenotype_comparison_environment2_genotype2s { my $self = shift; return map $_->phenotype_comparison_genotype2s, $self->phenotype_comparison_environment2s }
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306 sub phenotype_comparison_environment1_phenotype1s { my $self = shift; return map $_->phenotype_comparison_phenotype1s, $self->phenotype_comparison_environment1s }
9307
9308
9309 sub phenotype_comparison_environment1_phenotype2s { my $self = shift; return map $_->phenotype_comparison_phenotype2s, $self->phenotype_comparison_environment1s }
9310
9311
9312
9313
9314
9315
9316 sub phenotype_comparison_environment2_phenotype1s { my $self = shift; return map $_->phenotype_comparison_phenotype1s, $self->phenotype_comparison_environment2s }
9317
9318
9319 sub phenotype_comparison_environment2_phenotype2s { my $self = shift; return map $_->phenotype_comparison_phenotype2s, $self->phenotype_comparison_environment2s }
9320
9321
9322
9323
9324
9325
9326
9327
9328
9329 1;
9330
9331 ########Chado::Phenstatement########
9332
9333 package Chado::Phenstatement;
9334 use base 'Chado::DBI';
9335 use Class::DBI::Pager;
9336 no warnings qw(redefine);
9337
9338 Chado::Phenstatement->set_up_table('phenstatement');
9339
9340 #
9341 # Primary key accessors
9342 #
9343
9344 sub id { shift->phenstatement_id }
9345 sub phenstatement { shift->phenstatement_id }
9346
9347
9348
9349
9350 #
9351 # Has A
9352 #
9353
9354 Chado::Phenstatement->has_a(genotype_id => 'Chado::Genotype');
9355
9356 sub Chado::Phenstatement::genotype { return shift->genotype_id }
9357
9358
9359 Chado::Phenstatement->has_a(environment_id => 'Chado::Environment');
9360
9361 sub Chado::Phenstatement::environment { return shift->environment_id }
9362
9363
9364 Chado::Phenstatement->has_a(phenotype_id => 'Chado::Phenotype');
9365
9366 sub Chado::Phenstatement::phenotype { return shift->phenotype_id }
9367
9368
9369 Chado::Phenstatement->has_a(type_id => 'Chado::Cvterm');
9370
9371 sub Chado::Phenstatement::cvterm { return shift->type_id }
9372
9373
9374 Chado::Phenstatement->has_a(pub_id => 'Chado::Pub');
9375
9376 sub Chado::Phenstatement::pub { return shift->pub_id }
9377
9378
9379 #
9380 # Has Many
9381 #
9382
9383
9384
9385 # one to many to one
9386
9387 # one to many to many
9388
9389 #many to many to one
9390
9391 #many to many to many
9392
9393
9394
9395 1;
9396
9397 ########Chado::Studydesign########
9398
9399 package Chado::Studydesign;
9400 use base 'Chado::DBI';
9401 use Class::DBI::Pager;
9402 no warnings qw(redefine);
9403
9404 Chado::Studydesign->set_up_table('studydesign');
9405
9406 #
9407 # Primary key accessors
9408 #
9409
9410 sub id { shift->studydesign_id }
9411 sub studydesign { shift->studydesign_id }
9412
9413
9414
9415
9416 #
9417 # Has A
9418 #
9419
9420
9421
9422 Chado::Studydesign->has_a(study_id => 'Chado::Study');
9423
9424 sub Chado::Studydesign::study { return shift->study_id }
9425
9426
9427 #
9428 # Has Many
9429 #
9430
9431 Chado::Studydesign->has_many('studyfactor_studydesign_id', 'Chado::Studyfactor' => 'studydesign_id');
9432
9433
9434 sub studyfactors { return shift->studyfactor_studydesign_id }
9435
9436 Chado::Studydesign->has_many('studydesignprop_studydesign_id', 'Chado::Studydesignprop' => 'studydesign_id');
9437
9438
9439 sub studydesignprops { return shift->studydesignprop_studydesign_id }
9440
9441
9442
9443 # one to many to one
9444
9445 # one to many to many
9446
9447 #many to many to one
9448
9449 #many to many to many
9450
9451
9452
9453 1;
9454
9455 ########Chado::Pub_Dbxref########
9456
9457 package Chado::Pub_Dbxref;
9458 use base 'Chado::DBI';
9459 use Class::DBI::Pager;
9460 no warnings qw(redefine);
9461
9462 Chado::Pub_Dbxref->set_up_table('pub_dbxref');
9463
9464 #
9465 # Primary key accessors
9466 #
9467
9468 sub id { shift->pub_dbxref_id }
9469 sub pub_dbxref { shift->pub_dbxref_id }
9470
9471
9472
9473
9474 #
9475 # Has A
9476 #
9477
9478 Chado::Pub_Dbxref->has_a(pub_id => 'Chado::Pub');
9479
9480 sub Chado::Pub_Dbxref::pub { return shift->pub_id }
9481
9482
9483 Chado::Pub_Dbxref->has_a(dbxref_id => 'Chado::Dbxref');
9484
9485 sub Chado::Pub_Dbxref::dbxref { return shift->dbxref_id }
9486
9487
9488 #
9489 # Has Many
9490 #
9491
9492
9493
9494 # one to many to one
9495
9496 # one to many to many
9497
9498 #many to many to one
9499
9500 #many to many to many
9501
9502
9503
9504 1;
9505
9506 ########Chado::Expression_Cvtermprop########
9507
9508 package Chado::Expression_Cvtermprop;
9509 use base 'Chado::DBI';
9510 use Class::DBI::Pager;
9511 no warnings qw(redefine);
9512
9513 Chado::Expression_Cvtermprop->set_up_table('expression_cvtermprop');
9514
9515 #
9516 # Primary key accessors
9517 #
9518
9519 sub id { shift->expression_cvtermprop_id }
9520 sub expression_cvtermprop { shift->expression_cvtermprop_id }
9521
9522
9523
9524
9525 #
9526 # Has A
9527 #
9528
9529 Chado::Expression_Cvtermprop->has_a(expression_cvterm_id => 'Chado::Expression_Cvterm');
9530
9531 sub Chado::Expression_Cvtermprop::expression_cvterm { return shift->expression_cvterm_id }
9532
9533
9534 Chado::Expression_Cvtermprop->has_a(type_id => 'Chado::Cvterm');
9535
9536 sub Chado::Expression_Cvtermprop::cvterm { return shift->type_id }
9537
9538
9539 #
9540 # Has Many
9541 #
9542
9543
9544
9545 # one to many to one
9546
9547 # one to many to many
9548
9549 #many to many to one
9550
9551 #many to many to many
9552
9553
9554
9555 1;
9556
9557 ########Chado::Phenotype########
9558
9559 package Chado::Phenotype;
9560 use base 'Chado::DBI';
9561 use Class::DBI::Pager;
9562 no warnings qw(redefine);
9563
9564 Chado::Phenotype->set_up_table('phenotype');
9565
9566 #
9567 # Primary key accessors
9568 #
9569
9570 sub id { shift->phenotype_id }
9571 sub phenotype { shift->phenotype_id }
9572
9573
9574
9575
9576 #
9577 # Has A
9578 #
9579
9580
9581
9582
9583
9584
9585 Chado::Phenotype->has_a(observable_id => 'Chado::Cvterm');
9586
9587 sub observable { return shift->observable_id }
9588
9589
9590 Chado::Phenotype->has_a(attr_id => 'Chado::Cvterm');
9591
9592 sub attr { return shift->attr_id }
9593
9594
9595 Chado::Phenotype->has_a(cvalue_id => 'Chado::Cvterm');
9596
9597 sub cvalue { return shift->cvalue_id }
9598
9599
9600 Chado::Phenotype->has_a(assay_id => 'Chado::Cvterm');
9601
9602 sub assay { return shift->assay_id }
9603
9604
9605 #
9606 # Has Many
9607 #
9608
9609 Chado::Phenotype->has_many('feature_phenotype_phenotype_id', 'Chado::Feature_Phenotype' => 'phenotype_id');
9610
9611 Chado::Phenotype->has_many('phenotype_comparison_phenotype1_id', 'Chado::Phenotype_Comparison' => 'phenotype1_id');
9612
9613 Chado::Phenotype->has_many('phenotype_comparison_phenotype2_id', 'Chado::Phenotype_Comparison' => 'phenotype2_id');
9614
9615 Chado::Phenotype->has_many('phenotype_cvterm_phenotype_id', 'Chado::Phenotype_Cvterm' => 'phenotype_id');
9616
9617
9618 sub phenotype_cvterms { return shift->phenotype_cvterm_phenotype_id }
9619
9620 Chado::Phenotype->has_many('phenstatement_phenotype_id', 'Chado::Phenstatement' => 'phenotype_id');
9621
9622
9623
9624
9625 #
9626 # Has Compound Many (many to many relationships in all their flavors)
9627 #
9628
9629
9630
9631
9632 sub phenotype_comparison_phenotype1s { return shift->phenotype_comparison_phenotype1_id }
9633
9634
9635 sub phenotype_comparison_phenotype2s { return shift->phenotype_comparison_phenotype2_id }
9636
9637
9638
9639
9640
9641 sub phenotype_comparison_phenotype1s { return shift->phenotype_comparison_phenotype1_id }
9642
9643
9644 sub phenotype_comparison_phenotype2s { return shift->phenotype_comparison_phenotype2_id }
9645
9646
9647
9648 sub phenotype_comparison_phenotype1s { return shift->phenotype_comparison_phenotype1_id }
9649
9650
9651 sub phenotype_comparison_phenotype2s { return shift->phenotype_comparison_phenotype2_id }
9652
9653
9654
9655
9656 sub phenotype_comparison_phenotype1s { return shift->phenotype_comparison_phenotype1_id }
9657
9658
9659 sub phenotype_comparison_phenotype2s { return shift->phenotype_comparison_phenotype2_id }
9660
9661
9662
9663
9664
9665 sub phenstatement_phenotypes { return shift->phenstatement_phenotype_id }
9666
9667
9668
9669
9670 sub phenstatement_phenotypes { return shift->phenstatement_phenotype_id }
9671
9672
9673
9674 sub phenstatement_phenotypes { return shift->phenstatement_phenotype_id }
9675
9676
9677
9678
9679 sub phenstatement_phenotypes { return shift->phenstatement_phenotype_id }
9680
9681
9682
9683
9684
9685 sub feature_phenotype_phenotypes { return shift->feature_phenotype_phenotype_id }
9686
9687 # one to many to one
9688
9689
9690
9691
9692
9693
9694 # one2one #
9695 sub genotypes { my $self = shift; return map $_->genotype_id, $self->phenstatement_phenotype_id }
9696
9697
9698
9699 sub environments { my $self = shift; return map $_->environment_id, $self->phenstatement_phenotype_id }
9700
9701
9702
9703 sub cvterms { my $self = shift; return map $_->type_id, $self->phenstatement_phenotype_id }
9704
9705
9706
9707 sub pubs { my $self = shift; return map $_->pub_id, $self->phenstatement_phenotype_id }
9708
9709
9710
9711 sub features { my $self = shift; return map $_->feature_id, $self->feature_phenotype_phenotype_id }
9712
9713 # one to many to many
9714
9715
9716
9717
9718
9719
9720
9721
9722
9723
9724 #many to many to one
9725
9726
9727
9728
9729 # many2one #
9730
9731
9732 sub phenotype_comparison_phenotype1_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_phenotype1_id }
9733
9734
9735 sub phenotype_comparison_phenotype2_organisms { my $self = shift; return map $_->organism_id, $self->phenotype_comparison_phenotype2_id }
9736
9737
9738
9739
9740
9741
9742 sub phenotype_comparison_phenotype1_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_phenotype1_id }
9743
9744
9745 sub phenotype_comparison_phenotype2_pubs { my $self = shift; return map $_->pub_id, $self->phenotype_comparison_phenotype2_id }
9746
9747
9748
9749
9750
9751
9752
9753 #many to many to many
9754
9755
9756
9757 # many2many #
9758
9759
9760
9761
9762 sub phenotype_comparison_phenotype1_genotype1s { my $self = shift; return map $_->phenotype_comparison_genotype1s, $self->phenotype_comparison_phenotype1s }
9763
9764
9765 sub phenotype_comparison_phenotype1_genotype2s { my $self = shift; return map $_->phenotype_comparison_genotype2s, $self->phenotype_comparison_phenotype1s }
9766
9767
9768
9769
9770
9771
9772 sub phenotype_comparison_phenotype2_genotype1s { my $self = shift; return map $_->phenotype_comparison_genotype1s, $self->phenotype_comparison_phenotype2s }
9773
9774
9775 sub phenotype_comparison_phenotype2_genotype2s { my $self = shift; return map $_->phenotype_comparison_genotype2s, $self->phenotype_comparison_phenotype2s }
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786 sub phenotype_comparison_phenotype1_environment1s { my $self = shift; return map $_->phenotype_comparison_environment1s, $self->phenotype_comparison_phenotype1s }
9787
9788
9789 sub phenotype_comparison_phenotype1_environment2s { my $self = shift; return map $_->phenotype_comparison_environment2s, $self->phenotype_comparison_phenotype1s }
9790
9791
9792
9793
9794
9795
9796 sub phenotype_comparison_phenotype2_environment1s { my $self = shift; return map $_->phenotype_comparison_environment1s, $self->phenotype_comparison_phenotype2s }
9797
9798
9799 sub phenotype_comparison_phenotype2_environment2s { my $self = shift; return map $_->phenotype_comparison_environment2s, $self->phenotype_comparison_phenotype2s }
9800
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810
9811
9812 1;
9813
9814 ########Chado::Phendesc########
9815
9816 package Chado::Phendesc;
9817 use base 'Chado::DBI';
9818 use Class::DBI::Pager;
9819 no warnings qw(redefine);
9820
9821 Chado::Phendesc->set_up_table('phendesc');
9822
9823 #
9824 # Primary key accessors
9825 #
9826
9827 sub id { shift->phendesc_id }
9828 sub phendesc { shift->phendesc_id }
9829
9830
9831
9832
9833 #
9834 # Has A
9835 #
9836
9837 Chado::Phendesc->has_a(genotype_id => 'Chado::Genotype');
9838
9839 sub Chado::Phendesc::genotype { return shift->genotype_id }
9840
9841
9842 Chado::Phendesc->has_a(environment_id => 'Chado::Environment');
9843
9844 sub Chado::Phendesc::environment { return shift->environment_id }
9845
9846
9847 Chado::Phendesc->has_a(type_id => 'Chado::Cvterm');
9848
9849 sub Chado::Phendesc::cvterm { return shift->type_id }
9850
9851
9852 Chado::Phendesc->has_a(pub_id => 'Chado::Pub');
9853
9854 sub Chado::Phendesc::pub { return shift->pub_id }
9855
9856
9857 #
9858 # Has Many
9859 #
9860
9861
9862
9863 # one to many to one
9864
9865 # one to many to many
9866
9867 #many to many to one
9868
9869 #many to many to many
9870
9871
9872
9873 1;
9874
9875 ########Chado::Featureprop_Pub########
9876
9877 package Chado::Featureprop_Pub;
9878 use base 'Chado::DBI';
9879 use Class::DBI::Pager;
9880 no warnings qw(redefine);
9881
9882 Chado::Featureprop_Pub->set_up_table('featureprop_pub');
9883
9884 #
9885 # Primary key accessors
9886 #
9887
9888 sub id { shift->featureprop_pub_id }
9889 sub featureprop_pub { shift->featureprop_pub_id }
9890
9891
9892
9893
9894 #
9895 # Has A
9896 #
9897
9898 Chado::Featureprop_Pub->has_a(featureprop_id => 'Chado::Featureprop');
9899
9900 sub Chado::Featureprop_Pub::featureprop { return shift->featureprop_id }
9901
9902
9903 Chado::Featureprop_Pub->has_a(pub_id => 'Chado::Pub');
9904
9905 sub Chado::Featureprop_Pub::pub { return shift->pub_id }
9906
9907
9908 #
9909 # Has Many
9910 #
9911
9912
9913
9914 # one to many to one
9915
9916 # one to many to many
9917
9918 #many to many to one
9919
9920 #many to many to many
9921
9922
9923
9924 1;
9925
9926 ########Chado::Library_Synonym########
9927
9928 package Chado::Library_Synonym;
9929 use base 'Chado::DBI';
9930 use Class::DBI::Pager;
9931 no warnings qw(redefine);
9932
9933 Chado::Library_Synonym->set_up_table('library_synonym');
9934
9935 #
9936 # Primary key accessors
9937 #
9938
9939 sub id { shift->library_synonym_id }
9940 sub library_synonym { shift->library_synonym_id }
9941
9942
9943
9944
9945 #
9946 # Has A
9947 #
9948
9949 Chado::Library_Synonym->has_a(synonym_id => 'Chado::Synonym');
9950
9951 sub Chado::Library_Synonym::synonym { return shift->synonym_id }
9952
9953
9954 Chado::Library_Synonym->has_a(library_id => 'Chado::Library');
9955
9956 sub Chado::Library_Synonym::library { return shift->library_id }
9957
9958
9959 Chado::Library_Synonym->has_a(pub_id => 'Chado::Pub');
9960
9961 sub Chado::Library_Synonym::pub { return shift->pub_id }
9962
9963
9964 #
9965 # Has Many
9966 #
9967
9968
9969
9970 # one to many to one
9971
9972 # one to many to many
9973
9974 #many to many to one
9975
9976 #many to many to many
9977
9978
9979
9980 1;
9981
9982 ########Chado::Phylotree########
9983
9984 package Chado::Phylotree;
9985 use base 'Chado::DBI';
9986 use Class::DBI::Pager;
9987 no warnings qw(redefine);
9988
9989 Chado::Phylotree->set_up_table('phylotree');
9990
9991 #
9992 # Primary key accessors
9993 #
9994
9995 sub id { shift->phylotree_id }
9996 sub phylotree { shift->phylotree_id }
9997
9998
9999
10000
10001 #
10002 # Has A
10003 #
10004
10005
10006
10007
10008 Chado::Phylotree->has_a(dbxref_id => 'Chado::Dbxref');
10009
10010 sub Chado::Phylotree::dbxref { return shift->dbxref_id }
10011
10012
10013 Chado::Phylotree->has_a(type_id => 'Chado::Cvterm');
10014
10015 sub Chado::Phylotree::cvterm { return shift->type_id }
10016
10017
10018 Chado::Phylotree->has_a(analysis_id => 'Chado::Analysis');
10019
10020 sub Chado::Phylotree::analysis { return shift->analysis_id }
10021
10022
10023 #
10024 # Has Many
10025 #
10026
10027 Chado::Phylotree->has_many('phylotree_pub_phylotree_id', 'Chado::Phylotree_Pub' => 'phylotree_id');
10028
10029 Chado::Phylotree->has_many('phylonode_phylotree_id', 'Chado::Phylonode' => 'phylotree_id');
10030
10031
10032 sub phylonodes { return shift->phylonode_phylotree_id }
10033
10034 Chado::Phylotree->has_many('phylonode_relationship_phylotree_id', 'Chado::Phylonode_Relationship' => 'phylotree_id');
10035
10036
10037 sub phylonode_relationships { return shift->phylonode_relationship_phylotree_id }
10038
10039
10040
10041
10042 #
10043 # Has Compound Many (many to many relationships in all their flavors)
10044 #
10045
10046
10047 sub phylotree_pub_phylotrees { return shift->phylotree_pub_phylotree_id }
10048
10049
10050 # one to many to one
10051
10052
10053 # one2one #
10054 sub pubs { my $self = shift; return map $_->pub_id, $self->phylotree_pub_phylotree_id }
10055
10056 # one to many to many
10057
10058
10059 #many to many to one
10060
10061
10062 #many to many to many
10063
10064
10065
10066
10067 1;
10068
10069 ########Chado::Feature_Expressionprop########
10070
10071 package Chado::Feature_Expressionprop;
10072 use base 'Chado::DBI';
10073 use Class::DBI::Pager;
10074 no warnings qw(redefine);
10075
10076 Chado::Feature_Expressionprop->set_up_table('feature_expressionprop');
10077
10078 #
10079 # Primary key accessors
10080 #
10081
10082 sub id { shift->feature_expressionprop_id }
10083 sub feature_expressionprop { shift->feature_expressionprop_id }
10084
10085
10086
10087
10088 #
10089 # Has A
10090 #
10091
10092 Chado::Feature_Expressionprop->has_a(feature_expression_id => 'Chado::Feature_Expression');
10093
10094 sub Chado::Feature_Expressionprop::feature_expression { return shift->feature_expression_id }
10095
10096
10097 Chado::Feature_Expressionprop->has_a(type_id => 'Chado::Cvterm');
10098
10099 sub Chado::Feature_Expressionprop::cvterm { return shift->type_id }
10100
10101
10102 #
10103 # Has Many
10104 #
10105
10106
10107
10108 # one to many to one
10109
10110 # one to many to many
10111
10112 #many to many to one
10113
10114 #many to many to many
10115
10116
10117
10118 1;
10119
10120 ########Chado::Pub_Relationship########
10121
10122 package Chado::Pub_Relationship;
10123 use base 'Chado::DBI';
10124 use Class::DBI::Pager;
10125 no warnings qw(redefine);
10126
10127 Chado::Pub_Relationship->set_up_table('pub_relationship');
10128
10129 #
10130 # Primary key accessors
10131 #
10132
10133 sub id { shift->pub_relationship_id }
10134 sub pub_relationship { shift->pub_relationship_id }
10135
10136
10137
10138
10139 #
10140 # Has A
10141 #
10142
10143 Chado::Pub_Relationship->has_a(subject_id => 'Chado::Pub');
10144
10145 sub subject { return shift->subject_id }
10146
10147
10148 Chado::Pub_Relationship->has_a(object_id => 'Chado::Pub');
10149
10150 sub object { return shift->object_id }
10151
10152
10153 Chado::Pub_Relationship->has_a(type_id => 'Chado::Cvterm');
10154
10155 sub Chado::Pub_Relationship::cvterm { return shift->type_id }
10156
10157
10158 #
10159 # Has Many
10160 #
10161
10162
10163
10164 # one to many to one
10165
10166 # one to many to many
10167
10168 #many to many to one
10169
10170 #many to many to many
10171
10172
10173
10174 1;