view release on metacpan or  search on metacpan

ExperimentSet/ExperimentSet.pm  view on Meta::CPAN

  $ExperimentSet->name($value);

  my $gs_fk_val = $ExperimentSet->gs_fk();
  $ExperimentSet->gs_fk($value);

  my $us_fk_val = $ExperimentSet->us_fk();
  $ExperimentSet->us_fk($value);

  my $cit_fk_val = $ExperimentSet->cit_fk();
  $ExperimentSet->cit_fk($value);

  my $provider_con_fk_val = $ExperimentSet->provider_con_fk();
  $ExperimentSet->provider_con_fk($value);

  my $group_can_update_val = $ExperimentSet->group_can_update();
  $ExperimentSet->group_can_update($value);

  my $biology_description_val = $ExperimentSet->biology_description();
  $ExperimentSet->biology_description($value);

  my $analysis_description_val = $ExperimentSet->analysis_description();
  $ExperimentSet->analysis_description($value);

  my $treatment_type_val = $ExperimentSet->treatment_type();
  $ExperimentSet->treatment_type($value);

  my $quantity_series_type_val = $ExperimentSet->quantity_series_type();
  $ExperimentSet->quantity_series_type($value);

  my $is_public_val = $ExperimentSet->is_public();
  $ExperimentSet->is_public($value);

  my $release_date_val = $ExperimentSet->release_date();
  $ExperimentSet->release_date($value);

  my $submission_date_val = $ExperimentSet->submission_date();
  $ExperimentSet->submission_date($value);

  my $local_accession_val = $ExperimentSet->local_accession();
  $ExperimentSet->local_accession($value);

  my $archive_bundle_ref_val = $ExperimentSet->archive_bundle_ref();
  $ExperimentSet->archive_bundle_ref($value);


=head1 DESCRIPTION

Each Genex class has a one to one correspondence with a GeneX DB table
of the same name (I<i.e.> the corresponding table for Bio::Genex::ExperimentSet is
ExperimentSet).


Most applications will first create an instance of Bio::Genex::ExperimentSet
and then fetch the data for the object from the DB by invoking
C<fetch()>. However, in cases where you may only be accessing a single
value from an object the built-in L<delayed fetch|/DELAYED_FETCH>
mechanism can be used. All objects are created without pre-fetching
any data from the DB. Whenever an attribute of the object is accessed
via a getter method, the data for that attribute will be fetched from
the DB if it has not already been. Delayed fetching happens
transparently without the user needing to enable or disable any
features. 

Since data is not be fetched from the DB I<until> it is accessed by
the calling application, it could presumably save a lot of access time
for large complicated objects when only a few attribute values are
needed.

=head1 ATTRIBUTES

There are three different types of attributes which instances of
Bio::Genex::ExperimentSet can access: I<raw> foreign key attributes,
Obect-Oriented foreign key attributes, and simple column attributes.

=over 4 

=item Raw Foreign Keys Attributes

=item Object Oriented Foreign Key Attributes

This mode presents foreign key attributes in a special way, with all
non-foreign key attributes presented normally. Foreign keys are first
retrieved from the DB, and then objects of the appropriate classes are
created and stored in slots. This mode is useful for applications that
want to process information from the DB because it automates looking
up information.

Specifying the 'C<recursive_fetch>' parameter when calling C<new()>,
modifies the behavior of this mode. The value given specifies the
number of levels deep that fetch will be invoked on sub-objects
created.

=item Simple Column Attributes

=back



=head1 CLASS VARIABLES

Class Bio::Genex::ExperimentSet defines the following utility variables for assisting
programmers to access the ExperimentSet table.

=over 4

=item $Bio::Genex::ExperimentSet::LIMIT

If defined, $LIMIT will set a limit on any select statements that can
return multiple instances of this class (for example C<get_objects()>
or any call to a C<ONE_TO_MANY> or C<LOOKUP_TABLE> foreign key
accessor method).


=item $Bio::Genex::ExperimentSet::USE_CACHE

This variable controls whether the class will cache any objects
created in calls to C<new()>. Objects are cached by primary key. The
caching is very simple, and no effort is made to track whether
different invocations of C<new()> are being made for an object with
the same primary key value, but with different options set. If you
desire to reinstantiate an object with a different set of parameters,