Inheritance diagram for Bio::EnsEMBL::DBSQL::OperonAdaptor:

Public Member Functions
protected	_tables ()

protected	_columns ()

public Listref	list_dbIDs ()

public Reference	list_stable_ids ()

public	list_seq_region_ids ()

public Bio::EnsEMBL::Operon	fetch_by_name ()

public Bio::EnsEMBL::Operon	fetch_by_stable_id ()

public Bio::EnsEMBL::Operon	fetch_by_stable_id_version ()

public	fetch_all ()

public Listref	fetch_all_versions_by_stable_id ()

public Reference	fetch_all_by_Slice ()

public	fetch_by_operon_transcript_id ()

public Bio::EnsEMBL::Operon	fetch_by_operon_transcript_stable_id ()

public	fetch_by_operon_transcript ()

public The	store ()

public void	remove ()

protected	_objs_from_sth ()

Public Member Functions inherited from Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor
public Bio::EnsEMBL::BaseFeatureAdaptor	new ()

public Boolean	start_equals_end ()

public void	clear_cache ()

protected	_clear_slice_feature_cache ()

protected Bio::EnsEMBL::Utils::Cache	_slice_feature_cache ()

public Listref	fetch_all_by_Slice ()

public Bio::EnsEMBL::Utils::Iterator	fetch_Iterator_by_Slice_method ()

public Bio::EnsEMBL::Utils::Iterator	fetch_Iterator_by_Slice ()

public Listref	fetch_all_by_Slice_and_score ()

public Listref	fetch_all_by_Slice_constraint ()

public Listref	fetch_all_by_logic_name ()

public Listref	fetch_all_by_stable_id_list ()

protected	_create_feature ()

protected	_create_feature_fast ()

public Int	count_by_Slice_constraint ()

protected ArrayRef	_get_and_filter_Slice_projections ()

protected ArrayRef	_generate_feature_bounds ()

protected Listref	_get_by_Slice ()

protected	_slice_fetch ()

public	get_seq_region_id_external ()

public	get_seq_region_id_internal ()

protected	_pre_store ()

protected	_pre_store_userdata ()

protected	_check_start_end_strand ()

protected	_remap ()

protected	_seq_region_boundary_from_db ()

public void	store ()

public void	remove ()

public void	remove_by_Slice ()

protected	_max_feature_length ()

protected	_list_seq_region_ids ()

public	remove_by_analysis_id ()

public	remove_by_feature_id ()

public Bio::EnsEMBL::Feature	fetch_nearest_by_Feature ()

public Listref	fetch_all_by_outward_search ()

public Listref	fetch_all_nearest_by_Feature ()

public Listref	select_nearest ()

protected Int	_compute_nearest_end ()

protected Int	_compute_prime_distance ()

protected Int	_compute_midpoint ()

protected	_discard_excess_features_from_matrix ()

Public Member Functions inherited from Bio::EnsEMBL::DBSQL::BaseAdaptor
public Bio::EnsEMBL::DBSQL::BaseAdaptor	new ()

public DBI::StatementHandle	prepare ()

public Bio::EnsEMBL::DBSQL::DBAdaptor	db ()

public Bio::EnsEMBL::DBSQL::DBConnection	dbc ()

public Boolean	is_multispecies ()

public Int	species_id ()

protected	_list_dbIDs ()

protected	_straight_join ()

protected	_can_straight_join ()

public Listref	bind_param_generic_fetch ()

protected	_bind_param_generic_fetch ()

public String	generate_in_constraint ()

public Listref	generic_fetch ()

public Int	generic_count ()

protected	_generate_sql ()

public Bio::EnsEMBL::Feature	fetch_by_dbID ()

protected	_uncached_fetch_by_dbID ()

public Listref	fetch_all_by_dbID_list ()

protected	_uncached_fetch_all_by_dbID_list ()

protected ArrayRef	_uncached_fetch_all_by_id_list ()

public	fetch_all ()

public Scalar	last_insert_id ()

public	insert_ignore_clause ()

protected Bio::EnsEMBL::DBSQL::Support::BaseCache	_id_cache ()

protected Boolean	_no_id_cache ()

public Boolean	ignore_cache_override ()

public Int	schema_version ()

protected	_tables ()

protected	_columns ()

protected	_default_where_clause ()

protected	_left_join ()

protected	_final_clause ()

protected	_objs_from_sth ()

protected	_build_id_cache ()

protected	_logic_name_to_constraint ()

Detailed Description

Synopsis

my $operon_adaptor =  Bio::EnsEMBL::DBSQL::OperonAdaptor->new($dba);
$operon_adaptor->store($operon);
my $operon2 = $operon_adaptor->fetch_by_dbID( $operon->dbID() );

Description

This is a database aware adaptor for the retrieval and storage of operon
objects.

Definition at line 24 of file OperonAdaptor.pm.

Member Function Documentation

◆ _columns()

protected Bio::EnsEMBL::DBSQL::OperonAdaptor::_columns ( )

Undocumented method

Code:

click to view

◆ _objs_from_sth()

protected Bio::EnsEMBL::DBSQL::OperonAdaptor::_objs_from_sth ( )

Undocumented method

Code:

click to view

sub _objs_from_sth {
  my ($self, $sth, $mapper, $dest_slice) = @_;
 
  #
  # This code is ugly because an attempt has been made to remove as many
  # function calls as possible for speed purposes.  Thus many caches and
  # a fair bit of gymnastics is used.
  #
 
  my $sa = $self->db()->get_SliceAdaptor();
  my $aa = $self->db()->get_AnalysisAdaptor();
 
  my @operons;
  my %analysis_hash;
  my %slice_hash;
  my %sr_name_hash;
  my %sr_cs_hash;
 
  my (
          $operon_id,      $seq_region_id,     $seq_region_start,
          $seq_region_end, $seq_region_strand, $display_label,
          $analysis_id,    $stable_id,         $version, 
          $created_date,   $modified_date
        );
 
  $sth->bind_columns( \(
                             $operon_id,         $seq_region_id,     $seq_region_start,
                             $seq_region_end,    $seq_region_strand, $display_label,
                             $analysis_id,       $stable_id,         $version,
                             $created_date,      $modified_date ));
 
  my $dest_slice_start;
  my $dest_slice_end;
  my $dest_slice_strand;
  my $dest_slice_length;
  my $dest_slice_cs;
  my $dest_slice_sr_name;
  my $dest_slice_sr_id;
  my $asma;
 
  if ($dest_slice) {
    $dest_slice_start   = $dest_slice->start();
    $dest_slice_end     = $dest_slice->end();
    $dest_slice_strand  = $dest_slice->strand();
    $dest_slice_length  = $dest_slice->length();
    $dest_slice_cs      = $dest_slice->coord_system();
    $dest_slice_sr_name = $dest_slice->seq_region_name();
    $dest_slice_sr_id   = $dest_slice->get_seq_region_id();
    $asma               = $self->db->get_AssemblyMapperAdaptor();
  }
 
  OPERON: while ( $sth->fetch() ) {
 
    #get the analysis object
    my $analysis = $analysis_hash{$analysis_id} ||= $aa->fetch_by_dbID($analysis_id);
    $analysis_hash{$analysis_id} = $analysis;
 
    #need to get the internal_seq_region, if present
    $seq_region_id = $self->get_seq_region_id_internal($seq_region_id);
    my $slice = $slice_hash{"ID:".$seq_region_id};
 
    if (!$slice) {
      $slice                            = $sa->fetch_by_seq_region_id($seq_region_id);
      $slice_hash{"ID:".$seq_region_id} = $slice;
      $sr_name_hash{$seq_region_id}     = $slice->seq_region_name();
      $sr_cs_hash{$seq_region_id}       = $slice->coord_system();
    }
 
    #obtain a mapper if none was defined, but a dest_seq_region was
    if(!$mapper && $dest_slice && !$dest_slice_cs->equals($slice->coord_system)) {
      $mapper = $asma->fetch_by_CoordSystems($dest_slice_cs, $slice->coord_system);
    }
 
    my $sr_name = $sr_name_hash{$seq_region_id};
    my $sr_cs   = $sr_cs_hash{$seq_region_id};
 
    #
    # remap the feature coordinates to another coord system
    # if a mapper was provided
    #
 
    if ($mapper) {
 
      if (defined $dest_slice && $mapper->isa('Bio::EnsEMBL::ChainedAssemblyMapper') ) {
        ($seq_region_id, $seq_region_start, $seq_region_end, $seq_region_strand) =
         $mapper->map($sr_name, $seq_region_start, $seq_region_end, $seq_region_strand, $sr_cs, 1, $dest_slice);
 
      } else {
        ($seq_region_id, $seq_region_start, $seq_region_end, $seq_region_strand) =
         $mapper->fastmap($sr_name, $seq_region_start, $seq_region_end, $seq_region_strand, $sr_cs);
      }
 
      #skip features that map to gaps or coord system boundaries
      next OPERON if (!defined($seq_region_id));
 
      #get a slice in the coord system we just mapped to
      $slice = $slice_hash{"ID:".$seq_region_id} ||= $sa->fetch_by_seq_region_id($seq_region_id);
    }
 
    #
    # If a destination slice was provided convert the coords.
    #
    if (defined($dest_slice)) {
      my $seq_region_len = $dest_slice->seq_region_length();
 
      if ( $dest_slice_strand == 1 ) {
        $seq_region_start = $seq_region_start - $dest_slice_start + 1;
        $seq_region_end   = $seq_region_end - $dest_slice_start + 1;
 
        if ( $dest_slice->is_circular ) {
        # Handle circular chromosomes.
 
          if ( $seq_region_start > $seq_region_end ) {
            # Looking at a feature overlapping the chromosome origin.
 
            if ( $seq_region_end > $dest_slice_start ) {
              # Looking at the region in the beginning of the chromosome
              $seq_region_start -= $seq_region_len;
            }
            if ( $seq_region_end < 0 ) {
              $seq_region_end += $seq_region_len;
            }
          } else {
            if ($dest_slice_start > $dest_slice_end && $seq_region_end < 0) {
              # Looking at the region overlapping the chromosome
              # origin and a feature which is at the beginning of the
              # chromosome.
              $seq_region_start += $seq_region_len;
              $seq_region_end   += $seq_region_len;
            }
          }
        }
      } else {
 
        my $start = $dest_slice_end - $seq_region_end + 1;
        my $end = $dest_slice_end - $seq_region_start + 1;
 
        if ($dest_slice->is_circular()) {
 
          if ($dest_slice_start > $dest_slice_end) {
            # slice spans origin or replication
 
            if ($seq_region_start >= $dest_slice_start) {
              $end += $seq_region_len;
              $start += $seq_region_len if $seq_region_end > $dest_slice_start;
 
            } elsif ($seq_region_start <= $dest_slice_end) {
              # do nothing
            } elsif ($seq_region_end >= $dest_slice_start) {
              $start += $seq_region_len;
              $end += $seq_region_len;
 
            } elsif ($seq_region_end <= $dest_slice_end) {
              $end += $seq_region_len if $end < 0;
 
            } elsif ($seq_region_start > $seq_region_end) {
              $end += $seq_region_len;
            }
 
          } else {
 
            if ($seq_region_start <= $dest_slice_end and $seq_region_end >= $dest_slice_start) {
              # do nothing
            } elsif ($seq_region_start > $seq_region_end) {
              if ($seq_region_start <= $dest_slice_end) {
                $start -= $seq_region_len;
              } elsif ($seq_region_end >= $dest_slice_start) {
                $end += $seq_region_len;
              }
            }
          }
        }
 
        $seq_region_start = $start;
        $seq_region_end = $end;
        $seq_region_strand *= -1;
 
      } ## end else [ if ( $dest_slice_strand...)]
 
      # Throw away features off the end of the requested slice or on
      # different seq_region.
      if ($seq_region_end < 1
          || $seq_region_start > $dest_slice_length
          || ($dest_slice_sr_id != $seq_region_id)) {
        next OPERON;
      }
      $slice = $dest_slice;
    } ## end if ($dest_slice)
 
    push( @operons,
        Bio::EnsEMBL::Operon->new(
                    -START         => $seq_region_start,
                    -END           => $seq_region_end,
                    -STRAND        => $seq_region_strand,
                    -SLICE         => $slice,
                    -DISPLAY_LABEL => $display_label,
                    -ADAPTOR       => $self,
                    -DBID          => $operon_id,
                    -STABLE_ID     => $stable_id,
                    -VERSION       => $version,
                    -CREATED_DATE  => $created_date || undef,
                    -MODIFIED_DATE => $modified_date || undef,
                    -ANALYSIS      => $analysis ) );
 
  } ## end while ( $sth->fetch() )
 
  return \@operons;
} ## end sub _objs_from_sth

◆ _tables()

protected Bio::EnsEMBL::DBSQL::OperonAdaptor::_tables ( )

Undocumented method

Code:

click to view

◆ fetch_all()

public Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_all ( )

  Example     :

$operons = $operon_adaptor->fetch_all();

  Description : Similar to fetch_by_stable_id, but retrieves all
                operons stored in the database.
  Returntype  : listref of Bio::EnsEMBL::Operon
  Caller      : general
  Status      : At Risk

/**

Undocumented method

Code:

click to view

◆ fetch_all_by_Slice()

public Reference Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_all_by_Slice ( )

  Arg [1]    : Bio::EnsEMBL::Slice $slice
               The slice to fetch operons on.
  Arg [2]    : (optional) string $logic_name
               the logic name of the type of features to obtain
  Arg [3]    : (optional) boolean $load_transcripts
               if true, transcripts will be loaded immediately rather than
               lazy loaded later.
  Arg [4]    : (optional) string $source
               the source name of the features to obtain.
  Arg [5]    : (optional) string biotype
                the biotype of the features to obtain.
  Example    :

@operons = @{$operon_adaptor->fetch_all_by_Slice()};

  Description: Overrides superclass method to optionally load transcripts
               immediately rather than lazy-loading them later.  This
               is more efficient when there are a lot of operons whose
               transcripts are going to be used.
  Returntype : reference to list of operons 
  Exceptions : thrown if exon cannot be placed on transcript slice
  Caller     : Slice::get_all_operons
  Status     : Stable

Code:

click to view

sub fetch_all_by_Slice {
  my ( $self, $slice, $logic_name, $load_transcripts ) = @_;
 
  my $constraint = '';
  my $operons =
    $self->SUPER::fetch_all_by_Slice_constraint( $slice, $constraint,
                         $logic_name );
 
  # If there are less than two operons, still do lazy-loading.
  if ( !$load_transcripts || @$operons < 2 ) {
    return $operons;
  }
 
  # Preload all of the transcripts now, instead of lazy loading later,
  # faster than one query per transcript.
 
  # First check if transcripts are already preloaded.
  # FIXME: Should check all transcripts.
  if ( exists( $operons->[0]->{'_operon_transcript_array'} ) ) {
    return $operons;
  }
 
  # Get extent of region spanned by transcripts.
  my ($min_start, $max_end);
  my $ext_slice;
 
  unless ($slice->is_circular()) {
    foreach my $o (@$operons) {
      if (!defined($min_start) || $o->seq_region_start() < $min_start) {
    $min_start = $o->seq_region_start();
      }
      if (!defined($max_end) || $o->seq_region_end() > $max_end) {
    $max_end = $o->seq_region_end();
      }
    }
 
    if ($min_start >= $slice->start() && $max_end <= $slice->end()) {
      $ext_slice = $slice;
    } else {
      my $sa = $self->db()->get_SliceAdaptor();
      $ext_slice = $sa->fetch_by_region($slice->coord_system->name(), $slice->seq_region_name(), $min_start, $max_end, $slice->strand(), $slice->coord_system->version());
    }
 
  } else {
    # feature might be crossing the origin of replication (i.e. seq_region_start > seq_region_end)
    # the computation of min_start|end based on seq_region_start|end is not safe
    # use feature start/end relative to the slice instead
    my ($min_start_feature, $max_end_feature);
    foreach my $o (@$operons) {
      if (!defined($min_start) || ($o->start() >= 0 && $o->start() < $min_start)) {
    $min_start = $o->start();
    $min_start_feature = $o;
      }
      if (!defined($max_end) || ($o->end() >= 0 && $o->end() > $max_end)) {
    $max_end = $o->end();
    $max_end_feature = $o;
      }
    }
    
    # now we can reassign min_start|end to seq_region_start|end of
    # the feature which spans the largest region
    $min_start = $min_start_feature->seq_region_start();
    $max_end = $max_end_feature->seq_region_end();
 
    my $sa = $self->db()->get_SliceAdaptor();
    $ext_slice = 
      $sa->fetch_by_region($slice->coord_system->name(), 
               $slice->seq_region_name(), 
               $min_start, 
               $max_end, 
               $slice->strand(), 
               $slice->coord_system->version());
  }
 
 
  # Associate transcript identifiers with operons.
 
  my %o_hash = map { $_->dbID => $_ } @{$operons};
 
  my $o_id_str = join( ',', keys(%o_hash) );
 
  my $sth =
    $self->prepare(   "SELECT operon_id, operon_transcript_id "
              . "FROM   operon_transcript "
              . "WHERE  operon_id IN ($o_id_str)" );
 
  $sth->execute();
 
  my ( $o_id, $tr_id );
  $sth->bind_columns( \( $o_id, $tr_id ) );
 
  my %tr_o_hash;
 
  while ( $sth->fetch() ) {
    $tr_o_hash{$tr_id} = $o_hash{$o_id};
  }
 
  my $ta = $self->db()->get_OperonTranscriptAdaptor();
  my $transcripts =
    $ta->fetch_all_by_Slice( $ext_slice,
                 1, undef,
                 sprintf( "ot.operon_transcript_id IN (%s)",
                      join( ',',
                        sort { $a <=> $b }
                        keys(%tr_o_hash) ) ) );
 
  # Move transcripts onto operon slice, and add them to operons.
  foreach my $tr ( @{$transcripts} ) {
    if ( !exists( $tr_o_hash{ $tr->dbID() } ) ) {
      next;
    }
 
    my $new_tr;
    if ( $slice != $ext_slice ) {
      $new_tr = $tr->transfer($slice);
      if ( !defined($new_tr) ) {
    throw(   "Unexpected. "
         . "Transcript could not be transfered onto operon slice."
         );
      }
    } else {
      $new_tr = $tr;
    }
 
    $tr_o_hash{ $tr->dbID() }->add_OperonTranscript($new_tr);
  }
 
  return $operons;
}               ## end sub fetch_all_by_Slice

◆ fetch_all_versions_by_stable_id()

public Listref Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_all_versions_by_stable_id ( )

  Arg [1]     : String $stable_id 
                The stable ID of the operon to retrieve
  Example     :

$operon = $operon_adaptor->fetch_all_versions_by_stable_id

('ENSG00000148944');

  Description : Similar to fetch_by_stable_id, but retrieves all versions of a
                operon stored in the database.
  Returntype  : listref of Bio::EnsEMBL::Operon
  Exceptions  : if we cant get the operon in given coord system
  Caller      : general
  Status      : At Risk

Code:

click to view

◆ fetch_by_name()

public Bio::EnsEMBL::Operon Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_name ( )

  Arg [1]    : String $label - name of operon to fetch
  Example    :

my $operon = $operonAdaptor->fetch_by_name("accBC");

  Description: Returns the operon which has the given display label or undef if
               there is none. If there are more than 1, only the first is
               reported.
  Returntype : Bio::EnsEMBL::Operon
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

◆ fetch_by_operon_transcript()

public Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_operon_transcript ( )

Undocumented method

Code:

click to view

◆ fetch_by_operon_transcript_id()

public Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_operon_transcript_id ( )

Undocumented method

Code:

click to view

◆ fetch_by_operon_transcript_stable_id()

public Bio::EnsEMBL::Operon Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_operon_transcript_stable_id ( )

  Arg [1]    : string $trans_stable_id
               transcript stable ID whose operon should be retrieved
  Example    :

my $operon = $operon_adaptor->fetch_by_operon_transcript_stable_id

('ENST0000234');

  Description: Retrieves a operon from the database via the stable ID of one of
               its transcripts
  Returntype : Bio::EnsEMBL::Operon
  Exceptions : none
  Caller     : operonral
  Status     : Stable

Code:

click to view

◆ fetch_by_stable_id()

public Bio::EnsEMBL::Operon Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_stable_id ( )

  Arg [1]    : String $id 
               The stable ID of the operon to retrieve
  Example    :

$operon = $operon_adaptor->fetch_by_stable_id('ENSG00000148944');

  Description: Retrieves a operon object from the database via its stable id.
               The operon will be retrieved in its native coordinate system (i.e.
               in the coordinate system it is stored in the database). It may
               be converted to a different coordinate system through a call to
               transform() or transfer(). If the operon or exon is not found
               undef is returned instead.
  Returntype : Bio::EnsEMBL::Operon or undef
  Exceptions : if we cant get the operon in given coord system
  Caller     : general
  Status     : Stable

Code:

click to view

◆ fetch_by_stable_id_version()

public Bio::EnsEMBL::Operon Bio::EnsEMBL::DBSQL::OperonAdaptor::fetch_by_stable_id_version ( )

  Arg [1]    : String $id 
               The stable ID of the operon to retrieve
  Arg [2]    : Integer $version
               The version of the stable_id to retrieve
  Example    :

$operon = $operon_adaptor->fetch_by_stable_id('16152-16153-4840', 2);

  Description: Retrieves an operon object from the database via its stable id and version.
               The operon will be retrieved in its native coordinate system (i.e.
               in the coordinate system it is stored in the database). It may
               be converted to a different coordinate system through a call to
               transform() or transfer(). If the operon is not found
               undef is returned instead.
  Returntype : Bio::EnsEMBL::Operon or undef
  Exceptions : if we cant get the operon in given coord system
  Caller     : general
  Status     : Stable

Code:

click to view

◆ list_dbIDs()

public Listref Bio::EnsEMBL::DBSQL::OperonAdaptor::list_dbIDs ( )

  Example    :

@operon_ids = @{$operon_adaptor->list_dbIDs()};

  Description: Gets an array of internal ids for all operons in the current db
  Arg[1]     : <optional> int. not 0 for the ids to be sorted by the seq_region.
  Returntype : Listref of Ints
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

◆ list_seq_region_ids()

public Bio::EnsEMBL::DBSQL::OperonAdaptor::list_seq_region_ids ( )

Undocumented method

Code:

click to view

◆ list_stable_ids()

public Reference Bio::EnsEMBL::DBSQL::OperonAdaptor::list_stable_ids ( )

  Example    :

@stable_operon_ids = @{$operon_adaptor->list_stable_ids()};

  Description: Gets an listref of stable ids for all operons in the current db
  Returntype : reference to a list of strings
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

◆ remove()

public void Bio::EnsEMBL::DBSQL::OperonAdaptor::remove ( )

  Arg [1]    : Bio::EnsEMBL::Operon $operon
               the operon to remove from the database
  Example    :

$operon_adaptor->remove($operon);

  Description: Removes a operon completely from the database. All associated
               transcripts, exons, stable_identifiers, descriptions, etc.
               are removed as well. Use with caution!
  Returntype : none
  Exceptions : throw on incorrect arguments 
               warning if operon is not stored in this database
  Caller     : general
  Status     : Stable

Code:

click to view

◆ store()

public The Bio::EnsEMBL::DBSQL::OperonAdaptor::store ( )

  Arg [1]    : Bio::EnsEMBL::Operon $operon
               The operon to store in the database
  Arg [2]    : ignore_release in xrefs [default 1] set to 0 to use release info 
               in external database references
  Example    :

$operon_adaptor->store($operon);

  Description: Stores a operon in the database.
  Returntype : the database identifier (dbID) of the newly stored operon
  Exceptions : thrown if the $operon is not a Bio::EnsEMBL::Operon or if 
               $operon does not have an analysis object
  Caller     : general
  Status     : Stable

Code:

click to view

sub store {
    my ( $self, $operon, $ignore_release ) = @_;
 
    if ( !ref $operon || !$operon->isa('Bio::EnsEMBL::Operon') ) {
        throw("Must store a operon object, not a $operon");
    }
 
    my $db = $self->db();
 
    if ( $operon->is_stored($db) ) {
        return $operon->dbID();
    }
            my $analysis = $operon->analysis();
  throw("Operons must have an analysis object.") if(!defined($analysis));
    my $analysis_id;
    if ( $analysis->is_stored($db) ) {
        $analysis_id = $analysis->dbID();
    } else {
        $analysis_id = $db->get_AnalysisAdaptor->store( $analysis );
    }
    # ensure coords are correct before storing
    #$operon->recalculate_coordinates();
 
    my $seq_region_id;
 
    ( $operon, $seq_region_id ) = $self->_pre_store($operon);
 
    my @columns = qw(
               seq_region_id
               seq_region_start
               seq_region_end
               seq_region_strand
               display_label
               analysis_id
        );
    my @canned_columns;
  my @canned_values;
 
    if ( defined($operon->stable_id()) ) {
        push @columns, qw(
          stable_id
          version
        );
        my $created = $self->db->dbc->from_seconds_to_date($operon->created_date());
        my $modified = $self->db->dbc->from_seconds_to_date($operon->modified_date());
 
        if ($created) {
          push @canned_columns, 'created_date';
          push @canned_values,  $created;
        }
        if ($modified) {
          push @canned_columns, 'modified_date';
          push @canned_values,  $modified;
        }
    }
 
  my $i_columns = join(', ', @columns, @canned_columns);
  my $i_values  = join(', ', (('?') x scalar(@columns)), @canned_values);
  my $store_operon_sql = qq(
    INSERT INTO operon ( ${i_columns} ) VALUES ( $i_values )
  );
 
    my $sth = $self->prepare($store_operon_sql);
    $sth->bind_param( 1, $seq_region_id,           SQL_INTEGER );
    $sth->bind_param( 2, $operon->start(),         SQL_INTEGER );
    $sth->bind_param( 3, $operon->end(),           SQL_INTEGER );
    $sth->bind_param( 4, $operon->strand(),        SQL_TINYINT );
    $sth->bind_param( 5, $operon->display_label(), SQL_VARCHAR );
    $sth->bind_param( 6, $analysis_id,             SQL_INTEGER );
 
    if ( defined($operon->stable_id()) ) {
        $sth->bind_param( 7, $operon->stable_id(), SQL_VARCHAR );
        my $version = ($operon->version()) ? $operon->version() : 1;
        $sth->bind_param( 8, $version,             SQL_INTEGER );
    }
    $sth->execute();
    $sth->finish();
 
    my $operon_dbID = $self->last_insert_id('operon_id', undef, 'operon');
 
    my $transcripts = $operon->get_all_OperonTranscripts();
 
    if ( $transcripts && scalar @$transcripts ) {
        my $transcript_adaptor = $db->get_OperonTranscriptAdaptor();
        for my $transcript (@$transcripts) {
            $transcript_adaptor->store( $transcript, $operon_dbID );
        }
    }
 
    # store the dbentries associated with this operon
    my $dbEntryAdaptor = $db->get_DBEntryAdaptor();
 
    foreach my $dbe ( @{ $operon->get_all_DBEntries } ) {
        $dbEntryAdaptor->store( $dbe, $operon_dbID, "Operon", $ignore_release );
    }
 
    # store operon attributes if there are any
    my $attrs = $operon->get_all_Attributes();
    if ( $attrs && scalar @$attrs ) {
        my $attr_adaptor = $db->get_AttributeAdaptor();
        $attr_adaptor->store_on_Operon( $operon, $attrs );
    }
 
    # set the adaptor and dbID on the original passed in operon not the
    # transfered copy
    $operon->adaptor($self);
    $operon->dbID($operon_dbID);
 
    return $operon_dbID;
} ## end sub store

The documentation for this class was generated from the following file:

ensembl/modules/Bio/EnsEMBL/DBSQL/OperonAdaptor.pm

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ _columns()

◆ _objs_from_sth()

◆ _tables()

◆ fetch_all()

◆ fetch_all_by_Slice()

◆ fetch_all_versions_by_stable_id()

◆ fetch_by_name()

◆ fetch_by_operon_transcript()

◆ fetch_by_operon_transcript_id()

◆ fetch_by_operon_transcript_stable_id()

◆ fetch_by_stable_id()

◆ fetch_by_stable_id_version()

◆ list_dbIDs()

◆ list_seq_region_ids()

◆ list_stable_ids()

◆ remove()

◆ store()