Inheritance diagram for Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor:

Public Member Functions
public Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor	new ()

public Reference	fetch_all ()

public Bio::EnsEMBL::AssemblyExceptionFeature	fetch_by_dbID ()

public Reference	fetch_all_by_Slice ()

protected	_remap ()

public Int	store ()

protected	_pre_store ()

protected	_check_start_end_strand ()

public void	remove ()

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 $assembly_exception_feature_adaptor =
  $database_adaptor->get_AssemblyExceptionFeatureAdaptor();
 
@assembly_exception_features =
  $assembly_exception_feature_adaptor->fetch_all_by_Slice($slice);

Description

Assembly Exception Feature Adaptor - database access for assembly
exception features.

Definition at line 25 of file AssemblyExceptionFeatureAdaptor.pm.

Member Function Documentation

◆ _check_start_end_strand()

protected Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::_check_start_end_strand ( )

Undocumented method

Code:

click to view

◆ _pre_store()

protected Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::_pre_store ( )

Undocumented method

Code:

click to view

◆ _remap()

protected Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::_remap ( )

Undocumented method

Code:

click to view

sub _remap {
  my ($self, $features, $mapper, $slice) = @_;
 
  # check if any remapping is actually needed
  if(@$features && (!$features->[0]->isa('Bio::EnsEMBL::Feature') ||
                    $features->[0]->slice == $slice)) {
    return $features;
  }
  # remapping has not been done, we have to do our own conversion from
  # to slice coords
 
  my @out;
 
  my $slice_start = $slice->start();
  my $slice_end   = $slice->end();
  my $slice_strand = $slice->strand();
  my $slice_cs    = $slice->coord_system();
 
  my ($seq_region, $start, $end, $strand, $seq_region_name);
 
  my $slice_seq_region = $slice->seq_region_name();
 
  foreach my $f (@$features) {
    # since feats were obtained in contig coords, attached seq is a contig
    my $fslice = $f->slice();
    if(!$fslice) {
      throw("Feature does not have attached slice.\n");
    }
    my $fseq_region = $fslice->seq_region_name();
    my $fcs = $fslice->coord_system();
    if(!$slice_cs->equals($fcs)) {
      # slice of feature in different coord system, mapping required
      ($seq_region, $start, $end, $strand) =
        $mapper->fastmap($fseq_region,$f->start(),$f->end(),$f->strand(),$fcs);
      # undefined start means gap
      next if(!defined $start);
 
      my $slice_adaptor = $self->db()->get_SliceAdaptor();
      $seq_region_name = $slice_adaptor->fetch_by_seq_region_id($seq_region)->seq_region_name;
 
    } else {
      $start           = $f->start();
      $end             = $f->end();
      $strand          = $f->strand();
      $seq_region_name = $f->slice->seq_region_name();
    }
 
    # maps to region outside desired area
    next if ($start > $slice_end) || ($end < $slice_start) || 
      ($slice_seq_region ne $seq_region_name);
 
    # create new copies of successfully mapped feaatures with shifted start,
    # end and strand
    my ($new_start, $new_end);
    my $seq_region_len = $slice->seq_region_length();
 
    if ($slice_strand == 1) { # Positive strand
        
      $new_start = $start - $slice_start + 1;
      $new_end   = $end - $slice_start + 1;
 
      if ($slice->is_circular()) {
        # Handle circular chromosomes.
 
        if ($new_start > $new_end) {
          # Looking at a feature overlapping the chromsome origin.
          if ($new_end > $slice_start) {
            # Looking at the region in the beginning of the chromosome.
            $new_start -= $seq_region_len;
          }
          if ($new_end < 0) {
            $new_end += $seq_region_len;
          }
        } else {
          if (   $slice_start > $slice_end && $new_end < 0) {
            # Looking at the region overlapping the chromosome
            # origin and a feature which is at the beginning of the
            # chromosome.
            $new_start += $seq_region_len;
            $new_end   += $seq_region_len;
          }
        }
      }   ## end if ($dest_slice->is_circular...)
    } else {  # Negative strand
 
      $new_start = $slice_end - $end + 1;
      $new_end = $slice_end - $start + 1;
 
      if ($slice->is_circular()) {
 
        if ($slice_start > $slice_end) { 
        # slice spans origin or replication
 
          if ($start >= $slice_start) {
            $new_end += $seq_region_len;
            $new_start += $seq_region_len if $end > $slice_start;
 
          } elsif ($start <= $slice_end) {
            # do nothing
          } elsif ($end >= $slice_start) {
            $new_start += $seq_region_len;
            $new_end += $seq_region_len;
 
          } elsif ($end <= $slice_end) {
            $new_end += $seq_region_len if $new_end < 0;
          } elsif ($start > $end) {
            $new_end += $seq_region_len;
          } else {
 
          }
              
        } else {
 
          if ($start <= $slice_end and $end >= $slice_start) {
            # do nothing
          } elsif ($start > $end) {
            if ($start <= $slice_end) {
          
              $new_start -= $seq_region_len;
 
            } elsif ($end >= $slice_start) {
              $new_end += $seq_region_len;
            } else {
 
            }
          }
        }
 
      }
 
    }    ## end else [ if ($dest_slice_strand...)]
    push @out, Bio::EnsEMBL::AssemblyExceptionFeature->new(
            '-dbID'            => $f->dbID,
            '-start'           => $new_start,
            '-end'             => $new_end,
            '-strand'          => $strand * $slice_strand,
            '-adaptor'         => $self,
            '-slice'           => $slice,
            '-alternate_slice' => $f->alternate_slice,
            '-type'            => $f->type,
    );
  }  # end foreach assembly exception
 
  return \@out;
}

◆ fetch_all()

public Reference Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::fetch_all ( )

  Arg [1]    : none
  Example    :

my @axfs = @{$axfa->fetch_all()};

  Description: Retrieves all assembly exception features which are in the
               database and builds internal caches of the features.
  Returntype : reference to list of Bio::EnsEMBL::AssemblyExceptionFeatures
  Exceptions : none
  Caller     : fetch_by_dbID, fetch_by_Slice
  Status     : Stable

Code:

click to view

sub fetch_all {
  my $self = shift;
 
  # this is the "global" cache for all assembly exception features in the db
  if(defined($self->{'_aexc_cache'})) {
    return $self->{'_aexc_cache'};
  }
 
  my $statement = qq(
  SELECT    ae.assembly_exception_id,
            ae.seq_region_id,
            ae.seq_region_start,
            ae.seq_region_end,
            ae.exc_type,
            ae.exc_seq_region_id,
            ae.exc_seq_region_start,
            ae.exc_seq_region_end,
            ae.ori
  FROM      assembly_exception ae,
            coord_system cs,
            seq_region sr
  WHERE     cs.species_id = ?
    AND     sr.coord_system_id = cs.coord_system_id
    AND     sr.seq_region_id = ae.seq_region_id);
 
  my $sth = $self->prepare($statement);
 
  $sth->bind_param( 1, $self->species_id(), SQL_INTEGER );
 
  $sth->execute();
 
  my ($ax_id, $sr_id, $sr_start, $sr_end,
      $x_type, $x_sr_id, $x_sr_start, $x_sr_end, $ori);
 
  $sth->bind_columns(\$ax_id, \$sr_id, \$sr_start, \$sr_end,
                     \$x_type, \$x_sr_id, \$x_sr_start, \$x_sr_end, \$ori);
 
  my @features;
  my $sa = $self->db()->get_SliceAdaptor();
 
  $self->{'_aexc_dbID_cache'} = {};
 
  while($sth->fetch()) {
    my $slice   = $sa->fetch_by_seq_region_id($sr_id);
    my $x_slice = $sa->fetch_by_seq_region_id($x_sr_id);
 
    # each row creates TWO features, each of which has alternate_slice
    # pointing to the "other" one
 
   
    my $a = Bio::EnsEMBL::AssemblyExceptionFeature->new
          ('-dbID'            => $ax_id,
           '-start'           => $sr_start,
           '-end'             => $sr_end,
           '-strand'          => 1,
           '-adaptor'         => $self,
           '-slice'           => $slice,
           '-alternate_slice' => $x_slice->sub_Slice($x_sr_start, $x_sr_end),
           '-type'            => $x_type);
   
    push @features, $a;
    $self->{'_aexc_dbID_cache'}->{$ax_id} = $a;
 
    push @features, Bio::EnsEMBL::AssemblyExceptionFeature->new
          ('-dbID'            => $ax_id,
           '-start'           => $x_sr_start,
           '-end'             => $x_sr_end,
           '-strand'          => 1,
           '-adaptor'         => $self,
           '-slice'           => $x_slice,
           '-alternate_slice' => $slice->sub_Slice($sr_start, $sr_end),
           '-type'            => "$x_type REF" );
  }
 
  $sth->finish();
 
  $self->{'_aexc_cache'} = \@features;
  
  return \@features;
}

◆ fetch_all_by_Slice()

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

  Arg [1]    : Bio::EnsEMBL::Slice $slice
  Example    :

my @axfs = @{$axfa->fetch_all_by_Slice($slice)};

  Description: Retrieves all assembly exception features which overlap the
               provided slice.  The returned features will be in coordinate
               system of the slice.
  Returntype : reference to list of Bio::EnsEMBL::AssemblyException features
  Exceptions : none
  Caller     : Feature::get_all_alt_locations, general
  Status     : Stable

Code:

click to view

◆ fetch_by_dbID()

public Bio::EnsEMBL::AssemblyExceptionFeature Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::fetch_by_dbID ( )

  Arg [1]    : int $dbID
  Example    :

my $axf = $axfa->fetch_by_dbID(3);

  Description: Retrieves a single assembly exception feature via its internal
               identifier.  Note that this only retrieves one of the two
               assembly exception features which are represented by a single
               row in the assembly_exception table.
  Returntype : Bio::EnsEMBL::AssemblyExceptionFeature
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

◆ new()

public Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::new ( )

  Arg [1]    : list of args @args
               Superclass constructor arguments
  Example    :

none

  Description: Constructor which just initializes internal cache structures
  Returntype : Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor
  Exceptions : none
  Caller     : implementing subclass constructors
  Status     : Stable

Code:

click to view

◆ remove()

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

  Arg [1]    : $asx Bio::EnsEMBL::AssemblyFeatureException 
  Example    :

$asx_adaptor->remove($asx);

  Description: This removes a assembly exception feature from the database.  
  Returntype : none
  Exceptions : thrown if $asx arg does not implement dbID(), or if
               $asx->dbID is not a true value
  Caller     : general
  Status     : Stable

Code:

click to view

◆ store()

public Int Bio::EnsEMBL::DBSQL::AssemblyExceptionFeatureAdaptor::store ( )

    Arg[1]       : Bio::EnsEMBL::AssemblyException $asx
    Arg[2]       : Bio::EnsEMBL::AssemblyException $asx2

    Example      :

$asx = Bio::EnsEMBL::AssemblyExceptionFeature->new(...)
                  $asx2 = Bio::EnsEMBL::AssemblyExceptionFeature->new(...)
                  $asx_seq_region_id = $asx_adaptor->store($asx);

    Description:  This stores a assembly exception feature in the 
                  assembly_exception table and returns the assembly_exception_id.
                  Needs 2 features: one pointing to the Assembly_exception, and the
                  other pointing to the region in the reference that is being mapped to
                  Will check that start, end and type are defined, and the alternate
                  slice is present as well.
    ReturnType:   int
    Exceptions:   throw if assembly exception not defined (needs start, end,
          type and alternate_slice) of if $asx not a Bio::EnsEMBL::AssemblyException
    Caller:       general
    Status:       Stable

Code:

click to view

sub store{
  my $self = shift;
  my $asx = shift;
  my $asx2 = shift;
 
 
  if (! $asx->isa('Bio::EnsEMBL::AssemblyExceptionFeature')){
    throw("$asx is not a Ensembl assemlby exception -- not stored");
  }
  #if already present, return ID in the database
  my $db = $self->db();
  if ($asx->is_stored($db)){
    return $asx->dbID();
  }
  #do some checkings for the object
  #at the moment, the orientation is always 1
  if (! $asx->start || ! $asx->end ){
    throw("Assembly exception does not have coordinates");
  }
  if ($asx->type !~ /PAR|HAP|PATCH_NOVEL|PATCH_FIX/){
    throw("Only types of assembly exception features valid are PAR, HAP, PATCH_FIX or PATCH_NOVEL");
  }
  if ( !($asx->alternate_slice->isa('Bio::EnsEMBL::Slice')) ){
    throw("Alternate slice should be a Bio::EnsEMBL::Slice");
  }
  #now check the other Assembly exception feature, the one pointing to the REF
  # region
  if (!$asx2->isa('Bio::EnsEMBL::AssemblyExceptionFeature')){
    throw("$asx2 is not a Ensembl assemlby exception -- not stored");
  }
  if (! $asx2->start || ! $asx2->end ){
    throw("Assembly exception does not have coordinates");
  }
  if ($asx2->type !~ /HAP REF|PAR REF|PATCH_NOVEL REF|PATCH_FIX REF/){
    throw("$asx2 should have  type of assembly exception features HAP REF, PAR REF, PATCH_FIX REF or PATCH_NOVEL REF");
  }
  if (! ($asx2->alternate_slice->isa('Bio::EnsEMBL::Slice')) ){
    throw("Alternate slice should be a Bio::EnsEMBL::Slice");
  }
  #finally check that both features are pointing to each other slice
  if ($asx->slice != $asx2->alternate_slice || $asx->alternate_slice != $asx2->slice){
    throw("Slice and alternate slice in both features are not pointing to each other");
  }
  #prepare the SQL
  my $asx_sql = q{
    INSERT INTO assembly_exception( seq_region_id, seq_region_start,
                    seq_region_end, 
                    exc_type, exc_seq_region_id,
                    exc_seq_region_start, exc_seq_region_end,
                    ori)
        VALUES (?, ?, ?, ?, ?, ?, ?, 1)
    };
  
  my $asx_st = $self->prepare($asx_sql);
  my $asx_id = undef;
  my $asx_seq_region_id;
  my $asx2_seq_region_id;
  my $original = $asx;
  my $original2 = $asx2;
  #check all feature information
  ($asx, $asx_seq_region_id) = $self->_pre_store($asx);
  ($asx2, $asx2_seq_region_id) = $self->_pre_store($asx2);
  
  #and store it
  $asx_st->bind_param(1, $asx_seq_region_id, SQL_INTEGER);
  $asx_st->bind_param(2, $asx->start(), SQL_INTEGER);
  $asx_st->bind_param(3, $asx->end(), SQL_INTEGER);
  $asx_st->bind_param(4, $asx->type(), SQL_VARCHAR);
  $asx_st->bind_param(5, $asx2_seq_region_id, SQL_INTEGER);
  $asx_st->bind_param(6, $asx2->start(), SQL_INTEGER);
  $asx_st->bind_param(7, $asx2->end(), SQL_INTEGER);
  
  $asx_st->execute();
  $asx_id = $self->last_insert_id('assembly_exception_id', undef, 'assembly_exception');
  
  #finally, update the dbID and adaptor of the asx and asx2
  $original->adaptor($self);
  $original->dbID($asx_id);
  $original2->adaptor($self);
  $original2->dbID($asx_id);
  #and finally update dbID cache with new assembly exception
  $self->{'_aexc_dbID_cache'}->{$asx_id} = $original;
  #and update the other caches as well
  push @{$self->{'_aexc_slice_cache'}->{uc($asx->slice->name)}},$original, $original2;
  push @{$self->{'_aexc_cache'}}, $original, $original2;
  
  return $asx_id;
}

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

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

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ _check_start_end_strand()

◆ _pre_store()

◆ _remap()

◆ fetch_all()

◆ fetch_all_by_Slice()

◆ fetch_by_dbID()

◆ new()

◆ remove()

◆ store()