Inheritance diagram for Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor:

Public Member Functions
public Bio::EnsEMBL::ArchiveStableId	fetch_by_stable_id ()

protected Bio::EnsEMBL::ArchiveStableId	_fetch_by_stable_id ()

public Bio::EnsEMBL::ArchiveStableId	fetch_by_stable_id_version ()

public Bio::EnsEMBL::ArchiveStableId	fetch_by_stable_id_dbname ()

protected	_fetch_archive_id ()

public Listref	fetch_all_by_archive_id ()

public Listref	fetch_associated_archived ()

public Listref	fetch_predecessors_by_archive_id ()

public Listref	fetch_successors_by_archive_id ()

public Bio::EnsEMBL::StableIdHistoryTree	fetch_history_tree_by_stable_id ()

public void	add_all_current_to_history ()

public Listref	fetch_successor_history ()

public Listref	fetch_predecessor_history ()

public Bio::EnsEMBL::StableIdEvent	fetch_stable_id_event ()

public Listref	list_dbnames ()

public String	previous_dbname ()

public String	next_dbname ()

protected	_dbname_index ()

public String	get_peptide ()

public Int	get_current_release ()

public String	get_current_assembly ()

public Boolean	lookup_current ()

protected	_resolve_type ()

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 $registry = "Bio::EnsEMBL::Registry";
 
my $archiveStableIdAdaptor =
  $registry->get_adaptor( 'Human', 'Core', 'ArchiveStableId' );
 
my $stable_id = 'ENSG00000068990';
 
my $arch_id = $archiveStableIdAdaptor->fetch_by_stable_id($stable_id);
 
print("Latest incarnation of this stable ID:\n");
printf( "  Stable ID: %s.%d\n",
  $arch_id->stable_id(), $arch_id->version() );
print("  Release: "
    . $arch_id->release() . " ("
    . $arch_id->assembly() . ", "
    . $arch_id->db_name()
    . ")\n" );
 
print "\nStable ID history:\n\n";
 
my $history =
  $archiveStableIdAdaptor->fetch_history_tree_by_stable_id(
  $stable_id);
 
foreach my $a ( @{ $history->get_all_ArchiveStableIds } ) {
  printf( "  Stable ID: %s.%d\n", $a->stable_id(), $a->version() );
  print("  Release: "
      . $a->release() . " ("
      . $a->assembly() . ", "
      . $a->db_name()
      . ")\n\n" );
}

Description

ArchiveStableIdAdaptor does all SQL to create ArchiveStableIds and works
of

  stable_id_event
  mapping_session
  peptite_archive
  gene_archive

tables inside the core database.

This whole module has a status of At Risk as it is under development.

Definition at line 63 of file ArchiveStableIdAdaptor.pm.

Member Function Documentation

◆ _dbname_index()

protected Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::_dbname_index ( )

Undocumented method

Code:

click to view

◆ _fetch_archive_id()

protected Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::_fetch_archive_id ( )

Undocumented method

Code:

click to view

◆ _fetch_by_stable_id()

protected Bio::EnsEMBL::ArchiveStableId Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::_fetch_by_stable_id ( )

  Arg [1]     : string $stable_id
  Arg [2]     : (optional) string $type
  Example     :

none

  Description : Retrives an ArchiveStableId that is the latest incarnation of
                given stable_id. Helper function to fetch_by_stable_id, should
                not be directly called.
  Returntype  : Bio::EnsEMBL::ArchiveStableId or undef if not in database
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ _resolve_type()

protected Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::_resolve_type ( )

Undocumented method

Code:

click to view

◆ add_all_current_to_history()

public void Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::add_all_current_to_history ( )

  Arg[1]      : Bio::EnsEMBL::StableIdHistoryTree $history -
                the StableIdHistoryTree object to add the current IDs to
  Description : This method adds the current versions of all stable IDs found
                in a StableIdHistoryTree object to the tree, by creating
                appropriate Events for the stable IDs found in the *_stable_id
                tables. This is a helper method for
                fetch_history_tree_by_stable_id(), see there for more
                documentation.
  Return type : none (passed-in object is manipulated)
  Exceptions  : thrown on missing or wrong argument
  Caller      : internal
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_all_by_archive_id()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_all_by_archive_id ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId $archive_id
  Arg [2]     : String $return_type - type of ArchiveStableId to fetch
  Example     :

my $arch_id = $arch_adaptor->fetch_by_stable_id('ENSG0001');
               my @archived_transcripts =
                $arch_adaptor->fetch_all_by_archive_id($arch_id, 'Transcript');

  Description : Given a ArchiveStableId it retrieves associated ArchiveStableIds
                of specified type (e.g. retrieve transcripts for genes or vice
                versa).

                See also fetch_associated_archived() for a different approach to
                retrieve this data.
  Returntype  : listref Bio::EnsEMBL::ArchiveStableId
  Exceptions  : none
  Caller      : Bio::EnsEMBL::ArchiveStableId->get_all_gene_archive_ids,
                get_all_transcript_archive_ids, get_all_translation_archive_ids
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_associated_archived()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_associated_archived ( )

  Arg[1]      : Bio::EnsEMBL::ArchiveStableId $arch_id -
                the ArchiveStableId to fetch associated archived IDs for
  Example     :

my ($arch_gene, $arch_tr, $arch_tl, $pep_seq) =

@{ $archive_adaptor->fetch_associated_archived($arch_id) };

  Description : Fetches associated archived stable IDs from the db for a given
                ArchiveStableId (version is taken into account).
  Return type : Listref of
                  ArchiveStableId archived gene
                  ArchiveStableId archived transcript
                  (optional) ArchiveStableId archived translation
                  (optional) peptide sequence
  Exceptions  : thrown on missing or wrong argument
                thrown if ArchiveStableID has no type
  Caller      : Bio::EnsEMBL::ArchiveStableId->get_all_associated_archived()
  Status      : At Risk
              : under development

Code:

click to view

sub fetch_associated_archived {
  my $self = shift;
  my $arch_id = shift;
 
  throw("Need a Bio::EnsEMBL::ArchiveStableId") unless ($arch_id
    and ref($arch_id) and $arch_id->isa('Bio::EnsEMBL::ArchiveStableId'));
 
  my $type = $arch_id->type();
 
  if ( !defined($type) ) {
    throw("Can't deduce ArchiveStableId type.");
  }
 
  $type = lc($type);
 
  my $sql = qq(
    SELECT  ga.gene_stable_id,
            ga.gene_version,
            ga.transcript_stable_id,
            ga.transcript_version,
            ga.translation_stable_id,
            ga.translation_version,
            pa.peptide_seq,
            ms.old_release,
            ms.old_assembly,
            ms.old_db_name
    FROM (mapping_session ms, gene_archive ga)
    LEFT JOIN peptide_archive pa
      ON ga.peptide_archive_id = pa.peptide_archive_id
    WHERE ga.mapping_session_id = ms.mapping_session_id
    AND ga.${type}_stable_id = ?
    AND ga.${type}_version = ?
  );
 
  my $sth = $self->prepare($sql);
  $sth->bind_param(1, $arch_id->stable_id, SQL_VARCHAR);
  $sth->bind_param(2, $arch_id->version, SQL_SMALLINT);
  $sth->execute;
 
  my @result = ();
 
  while (my $r = $sth->fetchrow_hashref) {
 
    my @row = ();
 
    # create ArchiveStableIds genes, transcripts and translations
    push @row, Bio::EnsEMBL::ArchiveStableId->new(
       -stable_id => $r->{'gene_stable_id'},
       -version => $r->{'gene_version'},
       -db_name => $r->{'old_db_name'},
       -release => $r->{'old_release'},
       -assembly => $r->{'old_assembly'},
       -type => 'Gene',
       -adaptor => $self
    );
    
    push @row, Bio::EnsEMBL::ArchiveStableId->new(
       -stable_id => $r->{'transcript_stable_id'},
       -version => $r->{'transcript_version'},
       -db_name => $r->{'old_db_name'},
       -release => $r->{'old_release'},
       -assembly => $r->{'old_assembly'},
       -type => 'Transcript',
       -adaptor => $self
    );
 
    if ($r->{'translation_stable_id'}) {
      push @row, Bio::EnsEMBL::ArchiveStableId->new(
         -stable_id => $r->{'translation_stable_id'},
         -version => $r->{'translation_version'},
         -db_name => $r->{'old_db_name'},
         -release => $r->{'old_release'},
         -assembly => $r->{'old_assembly'},
         -type => 'Translation',
         -adaptor => $self
      );
 
      # push peptide sequence onto result list
      push @row, $r->{'peptide_seq'};
    }
    
    push @result, \@row;
  }
 
  return \@result;
}

◆ fetch_by_stable_id()

public Bio::EnsEMBL::ArchiveStableId Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_by_stable_id ( )

  Arg [1]     : string $stable_id
  Arg [2]     : (optional) string $type
  Example     :

none

  Description : Retrives an ArchiveStableId that is the latest incarnation of
                given stable_id. If the lookup fails, attempts to check for a
                version id delimited by a period (.) and lookup again using the
                version id.
  Returntype  : Bio::EnsEMBL::ArchiveStableId or undef if not in database
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_by_stable_id_dbname()

public Bio::EnsEMBL::ArchiveStableId Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_by_stable_id_dbname ( )

  Arg [1]     : string $stable_id
  Arg [2]     : string $db_name
  Example     :

none

  Description : Create an ArchiveStableId from given arguments.
  Returntype  : Bio::EnsEMBL::ArchiveStableId or undef if not in database
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_by_stable_id_version()

public Bio::EnsEMBL::ArchiveStableId Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_by_stable_id_version ( )

  Arg [1]     : string $stable_id
  Arg [2]     : int $version
  Example     :

none

  Description : Retrieve an ArchiveStableId with given version and stable ID.
  Returntype  : Bio::EnsEMBL::ArchiveStableId 
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_history_tree_by_stable_id()

public Bio::EnsEMBL::StableIdHistoryTree Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_history_tree_by_stable_id ( )

  Arg [1]     : String $stable_id - the stable ID to fetch the history tree for
  Arg [2]     : (optional) Int $num_high_scorers
                number of mappings per stable ID allowed when filtering
  Arg [3]     : (optional) Int $max_rows
                maximum number of stable IDs in history tree (used for
                filtering)
  Arg [4]     : (optional) Float $time_limit
                Optimise tree normally runs until it hits a minimised state
                but this can take a very long time. Therefore you can
                opt to bail out of the optimisation early. Specify the
                time in seconds. Floating point values are supported should you
                require sub-second limits
  Example     :

my $history = $archive_adaptor->fetch_history_tree_by_stable_id(

'ENSG00023747897');

  Description : Returns the history tree for a given stable ID. This will
                include a network of all stable IDs it is related to. The
                method will try to return a minimal (sparse) set of nodes
                (ArchiveStableIds) and links (StableIdEvents) by removing any
                redundant entries and consolidating mapping events so that only
                changes are recorded.
  Return type : Bio::EnsEMBL::StableIdHistoryTree
  Exceptions  : thrown on missing argument
  Caller      : Bio::EnsEMBL::ArchiveStableId::get_history_tree, general
  Status      : At Risk
              : under development

Code:

click to view

sub fetch_history_tree_by_stable_id {
  my ($self, $stable_id, $num_high_scorers, $max_rows, $time_limit) = @_;
 
  throw("Expecting a stable ID argument.") unless $stable_id;
 
  $num_high_scorers ||= NUM_HIGH_SCORERS;
  $max_rows ||= MAX_ROWS;
 
  # using a UNION is much faster in this query than somthing like
  # "... AND (sie.old_stable_id = ?) OR (sie.new_stable_id = ?)"
  #
  # SQLite uses the fully qualified column name as the key in
  # fetchrow_hashref() when there's a UNION, hence the need to
  # avoid table names qualifiers in the column lists.
  my $sql = qq(
    SELECT old_stable_id, old_version,
           old_db_name, old_release, old_assembly,
           new_stable_id, new_version,
           new_db_name, new_release, new_assembly,
           type, score
    FROM stable_id_event sie, mapping_session ms
    WHERE sie.mapping_session_id = ms.mapping_session_id
    AND sie.old_stable_id = ?
    UNION
    SELECT old_stable_id, old_version,
           old_db_name, old_release, old_assembly,
           new_stable_id, new_version,
           new_db_name, new_release, new_assembly,
           type, score
    FROM stable_id_event sie, mapping_session ms
    WHERE sie.mapping_session_id = ms.mapping_session_id
    AND sie.new_stable_id = ?
  );
  
  my $sth = $self->prepare($sql);
 
  my $history = Bio::EnsEMBL::StableIdHistoryTree->new(
      -CURRENT_DBNAME => $self->dbc->dbname,
      -CURRENT_RELEASE => $self->get_current_release,
      -CURRENT_ASSEMBLY => $self->get_current_assembly,
  );
 
  # remember stable IDs you need to do and those that are done. Initialise the
  # former hash with the focus stable ID
  my %do = ($stable_id => 1);
  my %done;
 
  # while we got someting to do
  while (my ($id) = keys(%do)) {
 
    # if we already have more than MAX_ROWS stable IDs in this tree, we can't
    # build the full tree. Return undef.
    if (scalar(keys(%done)) > $max_rows) {
      # warning("Too many related stable IDs (".scalar(keys(%done)).") to draw a history tree.");
      $history->is_incomplete(1);
      $sth->finish;
      last;
    }
 
    # mark this stable ID as done
    delete $do{$id};
    $done{$id} = 1;
 
    # fetch all stable IDs related to this one from the database
    $sth->bind_param(1, $id, SQL_VARCHAR);
    $sth->bind_param(2, $id, SQL_VARCHAR);
    $sth->execute;
 
    my @events;
 
    while (my $r = $sth->fetchrow_hashref) {
      
      #
      # create old and new ArchiveStableIds and a StableIdEvent to link them
      # add all of these to the history tree
      #
      my ($old_id, $new_id);
 
      if ($r->{'old_stable_id'}) {
        $old_id = Bio::EnsEMBL::ArchiveStableId->new(
          -stable_id => $r->{'old_stable_id'},
          -version => $r->{'old_version'},
          -db_name => $r->{'old_db_name'},
          -release => $r->{'old_release'},
          -assembly => $r->{'old_assembly'},
          -type => $r->{'type'},
          -adaptor => $self
        );
      }
       
      if ($r->{'new_stable_id'}) {
        $new_id = Bio::EnsEMBL::ArchiveStableId->new(
          -stable_id => $r->{'new_stable_id'},
          -version => $r->{'new_version'},
          -db_name => $r->{'new_db_name'},
          -release => $r->{'new_release'},
          -assembly => $r->{'new_assembly'},
          -type => $r->{'type'},
          -adaptor => $self
        );
      }
 
      my $event = Bio::EnsEMBL::StableIdEvent->new(
        -old_id => $old_id,
        -new_id => $new_id,
        -score => $r->{'score'}
      );
 
      push @events, $event;
 
    }
 
    # filter out low-scoring events; the number of highest scoring events
    # returned is defined by NUM_HIGH_SCORERS
    my @others;
 
    foreach my $event (@events) {
      
      my $old_id = $event->old_ArchiveStableId;
      my $new_id = $event->new_ArchiveStableId;
      
      # creation, deletion and mapping-to-self events are added to the history
      # tree directly
      if (!$old_id || !$new_id || ($old_id->stable_id eq $new_id->stable_id)) {
        $history->add_StableIdEvents($event);
      } else {
        push @others, $event;
      }
      
    }
 
    #if (scalar(@others) > $num_high_scorers) {
    #  warn "Filtering ".(scalar(@others) - $num_high_scorers).
    #    " low-scoring events.\n";
    #}
 
    my $k = 0;
    foreach my $event (sort { $b->score <=> $a->score } @others) {
      $history->add_StableIdEvents($event);
      
      # mark stable IDs as todo if appropriate
      $do{$event->old_ArchiveStableId->stable_id} = 1
        unless $done{$event->old_ArchiveStableId->stable_id};
      $do{$event->new_ArchiveStableId->stable_id} = 1
        unless $done{$event->new_ArchiveStableId->stable_id};
      
      last if (++$k == $num_high_scorers);
    }
    
  }
 
  $sth->finish;
  
  # try to consolidate the tree (remove redundant nodes, bridge gaps)
  $history->consolidate_tree;
 
  # now add ArchiveStableIds for current Ids not found in the archive
  $self->add_all_current_to_history($history);
  
  # calculate grid coordinates for the sorted tree; this will also try to
  # untangle the tree
  $history->calculate_coords($time_limit);
  
  return $history;
}

◆ fetch_predecessor_history()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_predecessor_history ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId $arch_id
  Example     :

none

  Description : Gives back a list of archive stable ids which are predecessors
                in the stable_id_event tree of the given stable_id. Might well
                be empty.

                This method is valid, but in most cases you will rather
                want to use fetch_history_tree_by_stable_id().
  Returntype  : listref Bio::EnsEMBL::ArchiveStableId
                Since every ArchiveStableId knows about it's successors, this is
                a linked tree.
  Exceptions  : none
  Caller      : webcode for archive
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_predecessors_by_archive_id()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_predecessors_by_archive_id ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId
  Example     :

none

  Description : Retrieve a list of ArchiveStableIds that were mapped to the 
                given one. This method goes back only one level, to retrieve
                a full predecessor history use fetch_predecessor_history, or 
                ideally fetch_history_tree_by_stable_id for the complete
                history network.
  Returntype  : listref Bio::EnsEMBL::ArchiveStableId
  Exceptions  : none
  Caller      : Bio::EnsEMBL::ArchiveStableId->get_all_predecessors
  Status      : At Risk
              : under development

Code:

click to view

sub fetch_predecessors_by_archive_id {
  my $self = shift;
  my $arch_id = shift;
  
  my @result;
  
  if( ! ( defined $arch_id->stable_id() &&
      defined $arch_id->db_name() )) {
    throw( "Need db_name for predecessor retrieval" );
  }
 
  my $sql = qq(
    SELECT
          sie.old_stable_id,
          sie.old_version,
          sie.type,
          m.old_db_name,
          m.old_release,
          m.old_assembly
    FROM  mapping_session m, stable_id_event sie
    WHERE sie.mapping_session_id = m.mapping_session_id
    AND   sie.new_stable_id = ?
    AND   m.new_db_name = ? 
  );
 
  my $sth = $self->prepare($sql);
  $sth->bind_param(1, $arch_id->stable_id, SQL_VARCHAR);
  $sth->bind_param(2, $arch_id->db_name, SQL_VARCHAR);
  $sth->execute();
  
  my ($old_stable_id, $old_version, $type, $old_db_name, $old_release, $old_assembly);
  $sth->bind_columns(\$old_stable_id, \$old_version, \$type, \$old_db_name, \$old_release, \$old_assembly);
  
  while ($sth->fetch) {
    if (defined $old_stable_id) {
      my $old_arch_id = Bio::EnsEMBL::ArchiveStableId->new( 
     -stable_id => $old_stable_id,
     -version => $old_version,
     -db_name => $old_db_name,
         -release => $old_release,
         -assembly => $old_assembly,
         -type => $type,
     -adaptor => $self
      );
      push( @result, $old_arch_id );
    }
  }
  $sth->finish();
 
  # if you didn't find any predecessors, there might be a gap in the
  # mapping_session history (i.e. databases in mapping_session don't chain). To
  # bridge the gap, look in the previous mapping_session for identical
  # stable_id.version
  unless (@result) {
 
    $sql = qq(
      SELECT
            sie.new_stable_id,
            sie.new_version,
            sie.type,
            m.new_db_name,
            m.new_release,
            m.new_assembly
      FROM  mapping_session m, stable_id_event sie
      WHERE sie.mapping_session_id = m.mapping_session_id
      AND   sie.new_stable_id = ?
      AND   m.new_db_name = ?   
    );
 
    $sth = $self->prepare($sql);
 
    my $curr_dbname = $arch_id->db_name;
    
    PREV:
    while (my $prev_dbname = $self->previous_dbname($curr_dbname)) {
    
      $sth->bind_param(1,$arch_id->stable_id, SQL_VARCHAR);
      $sth->bind_param(2,$prev_dbname, SQL_VARCHAR);
      $sth->execute();
      
      $sth->bind_columns(\$old_stable_id, \$old_version, \$type, \$old_db_name, \$old_release, \$old_assembly);
      
      while( $sth->fetch() ) {
        if (defined $old_stable_id) {
          my $old_arch_id = Bio::EnsEMBL::ArchiveStableId->new( 
             -stable_id => $old_stable_id,
             -version => $old_version,
             -db_name => $old_db_name,
             -release => $old_release,
             -assembly => $old_assembly,
             -type => $type,
             -adaptor => $self
          );
          push( @result, $old_arch_id );
 
          last PREV;
        }
      }
 
      $curr_dbname = $prev_dbname;
 
    }
      
    $sth->finish();
  }
 
  return \@result;
}

◆ fetch_stable_id_event()

public Bio::EnsEMBL::StableIdEvent Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_stable_id_event ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId $arch_id
  Arg [2]     : stable_id
  Example     :

my $archive = $archive_stable_id_adaptor->fetch_by_stable_id($id);

my $event = $archive_stable_id_adaptor($archive, $id2);

  Description : Gives back the event that links an archive stable id
                to a specific stable id

  Returntype  : Bio::EnsEMBL::StableIdEvent
                Undef if no event was found
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

sub fetch_stable_id_event {
  my $self = shift;
  my $arch_id = shift;
  my $stable_id = shift;
 
  my $event;
 
  my $sql = qq(
    SELECT sie.old_stable_id, sie.old_version, sie.new_stable_id, sie.new_version, sie.type, sie.score,
           ms.old_db_name, ms.new_db_name, ms.old_release, ms.new_release, ms.old_assembly, ms.new_assembly
    FROM stable_id_event sie, mapping_session ms
    WHERE ms.mapping_session_id = sie.mapping_session_id
    AND (old_stable_id = ? AND ms.old_db_name = ? AND old_release = ? AND old_assembly = ? AND new_stable_id = ?)
    OR (new_stable_id = ? AND ms.new_db_name = ? AND new_release = ? AND new_assembly = ? AND old_stable_id = ?)
  );
 
  my $sth = $self->prepare($sql);
  $sth->bind_param(1, $arch_id->stable_id, SQL_VARCHAR);
  $sth->bind_param(2, $arch_id->db_name, SQL_VARCHAR);
  $sth->bind_param(3, $arch_id->release, SQL_INTEGER);
  $sth->bind_param(4, $arch_id->assembly, SQL_VARCHAR);
  $sth->bind_param(5, $stable_id, SQL_VARCHAR);
  $sth->bind_param(6, $arch_id->stable_id, SQL_VARCHAR);
  $sth->bind_param(7, $arch_id->db_name, SQL_VARCHAR);
  $sth->bind_param(8, $arch_id->release, SQL_INTEGER);
  $sth->bind_param(9, $arch_id->assembly, SQL_VARCHAR);
  $sth->bind_param(10, $stable_id, SQL_VARCHAR);
  $sth->execute();
 
  my ($old_stable_id, $old_version, $new_stable_id, $new_version, $type, $score);
  my ($old_db_name, $new_db_name, $old_release, $new_release, $old_assembly, $new_assembly);
  $sth->bind_columns(\$old_stable_id, \$old_version, \$new_stable_id, \$new_version, \$type, \$score,
                     \$old_db_name, \$new_db_name, \$old_release, \$new_release, \$old_assembly, \$new_assembly);
 
  while ($sth->fetch) {
    if ($new_stable_id eq $stable_id) {
 
      my $alt_id = Bio::EnsEMBL::ArchiveStableId->new(
          -stable_id => $new_stable_id,
          -version => $new_version,
          -db_name => $new_db_name,
          -release => $new_release,
          -assembly => $new_assembly,
          -type => $type,
          -adaptor => $self
      );
 
      $event = Bio::EnsEMBL::StableIdEvent->new(
        -old_id => $arch_id,
        -new_id => $alt_id,
        -score => $score
      );
 
    } elsif ($old_stable_id eq $stable_id) {
 
      my $alt_id = Bio::EnsEMBL::ArchiveStableId->new(
          -stable_id => $old_stable_id,
          -version => $old_version,
          -db_name => $old_db_name,
          -release => $old_release,
          -assembly => $old_assembly,
          -type => $type,
          -adaptor => $self
      );
 
      $event = Bio::EnsEMBL::StableIdEvent->new(
        -old_id => $alt_id,
        -new_id => $arch_id,
        -score => $score
      );
 
    }
  }
  $sth->finish();
 
  return $event;
}

◆ fetch_successor_history()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_successor_history ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId $arch_id
  Example     :

none

  Description : Gives back a list of archive stable ids which are successors in
                the stable_id_event tree of the given stable_id. Might well be
                empty.

                This method is valid, but in most cases you will rather
                want to use fetch_history_tree_by_stable_id().
  Returntype  : listref Bio::EnsEMBL::ArchiveStableId
                Since every ArchiveStableId knows about it's successors, this is
                a linked tree.
  Exceptions  : none
  Caller      : webcode for archive
  Status      : At Risk
              : under development

Code:

click to view

◆ fetch_successors_by_archive_id()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::fetch_successors_by_archive_id ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId
  Example     :

none

  Description : Retrieve a list of ArchiveStableIds that the given one was 
                mapped to. This method goes forward only one level, to retrieve
                a full successor history use fetch_successor_history, or 
                ideally fetch_history_tree_by_stable_id for the complete
                history network.
  Returntype  : listref Bio::EnsEMBL::ArchiveStableId
  Exceptions  : none
  Caller      : Bio::EnsEMBL::ArchiveStableId->get_all_successors
  Status      : At Risk
              : under development

Code:

click to view

sub fetch_successors_by_archive_id {
  my $self = shift;
  my $arch_id = shift;
  my @result;
 
  
  if( ! ( defined $arch_id->stable_id() &&
      defined $arch_id->db_name() )) {
    throw( "Need db_name for successor retrieval" );
  }
 
  my $sql = qq(
    SELECT
          sie.new_stable_id,
          sie.new_version,
          sie.type,
          m.new_db_name,
          m.new_release,
          m.new_assembly
    FROM  mapping_session m, stable_id_event sie
    WHERE sie.mapping_session_id = m.mapping_session_id
    AND   sie.old_stable_id = ?
    AND   m.old_db_name = ? 
  );
 
  my $sth = $self->prepare( $sql );
  $sth->bind_param(1,$arch_id->stable_id,SQL_VARCHAR);
  $sth->bind_param(2,$arch_id->db_name,SQL_VARCHAR);
  $sth->execute();
  
  my ($new_stable_id, $new_version, $type, $new_db_name, $new_release, $new_assembly);
  $sth->bind_columns(\$new_stable_id, \$new_version, \$type, \$new_db_name, \$new_release, \$new_assembly);
  
  while( $sth->fetch() ) {
    if( defined $new_stable_id ) {
      my $new_arch_id = Bio::EnsEMBL::ArchiveStableId->new( 
     -stable_id => $new_stable_id,
     -version => $new_version,
     -db_name => $new_db_name,
         -release => $new_release,
         -assembly => $new_assembly,
         -type => $type,
     -adaptor => $self
      );
        
      push( @result, $new_arch_id );
    }
  }
  $sth->finish();
  
  # if you didn't find any successors, there might be a gap in the
  # mapping_session history (i.e. databases in mapping_session don't chain). To
  # bridge the gap, look in the next mapping_session for identical
  # stable_id.version
  unless (@result) {
 
    $sql = qq(
      SELECT
            sie.old_stable_id,
            sie.old_version,
            sie.type,
            m.old_db_name,
            m.old_release,
            m.old_assembly
      FROM  mapping_session m, stable_id_event sie
      WHERE sie.mapping_session_id = m.mapping_session_id
      AND   sie.old_stable_id = ?
      AND   m.old_db_name = ?   
    );
 
    $sth = $self->prepare($sql);
 
    my $curr_dbname = $arch_id->db_name;
    
    NEXTDB:
    while (my $next_dbname = $self->next_dbname($curr_dbname)) {
 
      $sth->bind_param(1, $arch_id->stable_id, SQL_VARCHAR);
      $sth->bind_param(2, $next_dbname, SQL_VARCHAR);
      $sth->execute();
      
      $sth->bind_columns(\$new_stable_id, \$new_version, \$type, \$new_db_name, \$new_release, \$new_assembly);
      
      while( $sth->fetch() ) {
        if (defined $new_stable_id) {
          my $new_arch_id = Bio::EnsEMBL::ArchiveStableId->new( 
             -stable_id => $new_stable_id,
             -version => $new_version,
             -db_name => $new_db_name,
             -release => $new_release,
             -assembly => $new_assembly,
             -type => $type,
             -adaptor => $self
          );
            
          push( @result, $new_arch_id );
 
          last NEXTDB;
        }
      }
      
      $curr_dbname = $next_dbname;
 
    }
 
    $sth->finish();
  }
 
  return \@result;
}

◆ get_current_assembly()

public String Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::get_current_assembly ( )

  Example     :

my $current_assembly = $archive_adaptor->get_current_assembly;

  Description : Returns the current assembly version (as found in the meta
                table).
  Return type : String
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ get_current_release()

public Int Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::get_current_release ( )

  Example     :

my $current_release = $archive_adaptor->get_current_release;

  Description : Returns the current release number (as found in the meta table).
  Return type : Int
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ get_peptide()

public String Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::get_peptide ( )

  Arg [1]     : Bio::EnsEMBL::ArchiveStableId $arch_id
  Example     :

none

  Description : Retrieves the peptide string for given ArchiveStableId. If its
                not a peptide or not in the database returns undef.
  Returntype  : string or undef
  Exceptions  : none
  Caller      : Bio::EnsEMBL::ArchiveStableId->get_peptide, general
  Status      : At Risk
              : under development

Code:

click to view

◆ list_dbnames()

public Listref Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::list_dbnames ( )

  Args        : none
  Example     :

none

  Description : A list of available database names from the latest (current) to
                the oldest (ordered).
  Returntype  : listref of strings
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ lookup_current()

public Boolean Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::lookup_current ( )

  Arg[1]      : Bio::EnsEMBL::ArchiveStableId $arch_id -
                the stalbe ID to find the current version for
  Example     :

if ($self->lookup_version($arch_id) {
                 $arch_id->version($arch_id->current_version);
                 $arch_id->db_name($self->dbc->dbname);

  Description : Look in [gene|transcript|translation]_stable_id if you can find
                a current version for this stable ID. Set
                ArchiveStableId->current_version if found.
  Return type : Boolean (TRUE if current version found, else FALSE)
  Exceptions  : none
  Caller      : general
  Status      : At Risk
              : under development

Code:

click to view

◆ next_dbname()

public String Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::next_dbname ( )

  Arg[1]      : String $dbname - focus db name
  Example     :

my $prev_db = $self->next_dbname($curr_db);

  Description : Returns the name of the next newest database which has mapping
                session information.
  Return type : String (or undef if not available)
  Exceptions  : none
  Caller      : general
  Status      : At Risk

Code:

click to view

◆ previous_dbname()

public String Bio::EnsEMBL::DBSQL::ArchiveStableIdAdaptor::previous_dbname ( )

  Arg[1]      : String $dbname - focus db name
  Example     :

my $prev_db = $self->previous_dbname($curr_db);

  Description : Returns the name of the next oldest database which has mapping
                session information.
  Return type : String (or undef if not available)
  Exceptions  : none
  Caller      : general
  Status      : At Risk

Code:

click to view

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

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

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ _dbname_index()

◆ _fetch_archive_id()

◆ _fetch_by_stable_id()

◆ _resolve_type()

◆ add_all_current_to_history()

◆ fetch_all_by_archive_id()

◆ fetch_associated_archived()

◆ fetch_by_stable_id()

◆ fetch_by_stable_id_dbname()

◆ fetch_by_stable_id_version()

◆ fetch_history_tree_by_stable_id()

◆ fetch_predecessor_history()

◆ fetch_predecessors_by_archive_id()

◆ fetch_stable_id_event()

◆ fetch_successor_history()

◆ fetch_successors_by_archive_id()

◆ get_current_assembly()

◆ get_current_release()

◆ get_peptide()

◆ list_dbnames()

◆ lookup_current()

◆ next_dbname()

◆ previous_dbname()