Inheritance diagram for Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor:

Class Summary

Synopsis

  my $dfa = $database_adaptor-\>get_DensityFeatureAdaptor();

  my $interpolate   = 1;
  my $blocks_wanted = 50;

  @dense_feats = @{
    $dfa-\>fetch_all_by_Slice( $slice, 'SNPDensity', $blocks_wanted,
      $interpolate );
    }

Description

Density Feature Adaptor - An adaptor responsible for the creation of density
features from the database.

Definition at line 31 of file DensityFeatureAdaptor.pm.

Available Methods
protected	_check_start_end_strand ()
protected	_columns ()
protected	_create_feature ()
protected	_create_feature_fast ()
protected	_default_where_clause ()
protected	_final_clause ()
protected	_left_join ()
protected	_list_dbIDs ()
protected	_list_seq_region_ids ()
protected	_logic_name_to_constraint ()
protected	_max_feature_length ()
protected	_objs_from_sth ()
protected	_pre_store ()
protected	_pre_store_userdata ()
protected	_remap ()
protected Bio::EnsEMBL::Utils::Cache	_slice_feature_cache ()
protected	_slice_fetch ()
protected	_straight_join ()
protected	_tables ()
public Listref	bind_param_generic_fetch ()
public void	clear_cache ()
public Bio::EnsEMBL::DBSQL::DBAdaptor	db ()
public Bio::EnsEMBL::DBSQL::DBConnection	dbc ()
public	dump_data ()
public	fetch_all ()
public Listref	fetch_all_by_dbID_list ()
public Listref	fetch_all_by_logic_name ()
public	fetch_all_by_RawContig ()
public	fetch_all_by_RawContig_and_score ()
public	fetch_all_by_RawContig_constraint ()
public Bio::EnsEMBL::DensityFeature	fetch_all_by_Slice ()
public Listref	fetch_all_by_Slice_and_score ()
public Listref	fetch_all_by_Slice_constraint ()
public Bio::EnsEMBL::Feature	fetch_by_dbID ()
public Bio::EnsEMBL::DensityFeatureSet	fetch_Featureset_by_Slice ()
public Bio::EnsEMBL::Utils::Iterator	fetch_Iterator_by_Slice ()
public Bio::EnsEMBL::Utils::Iterator	fetch_Iterator_by_Slice_method ()
public Listref	generic_fetch ()
public	get_dumped_data ()
public	get_seq_region_id_external ()
public	get_seq_region_id_internal ()
public Boolean	is_multispecies ()
public Scalar	last_insert_id ()
public List	list_dbIDs ()
public Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor	new ()
public DBI::StatementHandle	prepare ()
public void	remove ()
public	remove_by_analysis_id ()
public	remove_by_feature_id ()
public	remove_by_RawContig ()
public void	remove_by_Slice ()
public Int	species_id ()
public Boolean	start_equals_end ()
public void	store ()

Method Documentation

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_check_start_end_strand ( ) [inherited]

Undocumented method

Code:

click to view

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

Undocumented method

Code:

click to view

Reimplemented from Bio::EnsEMBL::DBSQL::BaseAdaptor.

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_create_feature ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_create_feature_fast ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseAdaptor::_default_where_clause ( ) [inherited]

Undocumented method

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::MiscFeatureAdaptor, Bio::EnsEMBL::DBSQL::RepeatFeatureAdaptor, Bio::EnsEMBL::Map::DBSQL::MarkerFeatureAdaptor, and Bio::EnsEMBL::Map::DBSQL::QtlFeatureAdaptor.

protected Bio::EnsEMBL::DBSQL::BaseAdaptor::_final_clause ( ) [inherited]

Undocumented method

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::ExonAdaptor, Bio::EnsEMBL::DBSQL::MiscFeatureAdaptor, and Bio::EnsEMBL::DBSQL::PredictionExonAdaptor.

protected Bio::EnsEMBL::DBSQL::BaseAdaptor::_left_join ( ) [inherited]

Undocumented method

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::DnaAlignFeatureAdaptor, Bio::EnsEMBL::DBSQL::GeneAdaptor, Bio::EnsEMBL::DBSQL::MiscFeatureAdaptor, Bio::EnsEMBL::DBSQL::ProteinAlignFeatureAdaptor, Bio::EnsEMBL::DBSQL::SplicingEventAdaptor, Bio::EnsEMBL::DBSQL::TranscriptAdaptor, Bio::EnsEMBL::DBSQL::UnmappedObjectAdaptor, Bio::EnsEMBL::Map::DBSQL::MarkerFeatureAdaptor, and Bio::EnsEMBL::Map::DBSQL::QtlFeatureAdaptor.

protected Bio::EnsEMBL::DBSQL::BaseAdaptor::_list_dbIDs ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_list_seq_region_ids ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_logic_name_to_constraint ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_max_feature_length ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::_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 have been used.
  #

  my $sa = $self->db()->get_SliceAdaptor();
  my $dta = $self->db()->get_DensityTypeAdaptor();

  my @features;
  my %dtype_hash;
  my %slice_hash;
  my %sr_name_hash;
  my %sr_cs_hash;

  my($density_feature_id, $seq_region_id, $seq_region_start, $seq_region_end,
     $density_value, $density_type_id );

  $sth->bind_columns(\$density_feature_id, \$seq_region_id, \$seq_region_start,
                     \$seq_region_end, \$density_value, \$density_type_id);

  my $asm_cs;
  my $cmp_cs;
  my $asm_cs_vers;
  my $asm_cs_name;
  my $cmp_cs_vers;
  my $cmp_cs_name;
  if($mapper) {
    $asm_cs = $mapper->assembled_CoordSystem();
    $cmp_cs = $mapper->component_CoordSystem();
    $asm_cs_name = $asm_cs->name();
    $asm_cs_vers = $asm_cs->version();
    $cmp_cs_name = $cmp_cs->name();
    $cmp_cs_vers = $cmp_cs->version();
  }

  my $dest_slice_start;
  my $dest_slice_end;
  my $dest_slice_strand;
  my $dest_slice_length;
  my $dest_slice_sr_name;
  my $dest_slice_sr_id;

  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_sr_name = $dest_slice->seq_region_name();
    $dest_slice_sr_id  = $dest_slice->get_seq_region_id();
  }

  FEATURE: while($sth->fetch()) {
    #get the density type object
    my $density_type = $dtype_hash{$density_type_id} ||=
      $dta->fetch_by_dbID($density_type_id);

    #get the slice object
    #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();
    }

    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) {

      my $len = $seq_region_end - $seq_region_start + 1;

      my @coords =
        $mapper->map($sr_name, $seq_region_start, $seq_region_end,1, $sr_cs);

      #filter out gaps
      @coords = grep {!$_->isa('Bio::EnsEMBL::Mapper::Gap')} @coords;

      #throw out density features mapped to gaps, or split
      next FEATURE if(@coords != 1);

      $seq_region_start  = $coords[0]->{'start'};
      $seq_region_end    = $coords[0]->{'end'};
      $seq_region_id     = $coords[0]->{'id'};

      if($density_type->value_type() eq 'sum') {
        #adjust density value so it reflects length of feature actually used
        my $newlen = $seq_region_end - $seq_region_start +1;
        $density_value *= $newlen/$len if($newlen != $len);
      }

      #get a slice in the coord system we just mapped to
#      if($asm_cs == $sr_cs || ($cmp_cs != $sr_cs && $asm_cs->equals($sr_cs))) {
        $slice = $slice_hash{"ID:".$seq_region_id} ||=
          $sa->fetch_by_seq_region_id($seq_region_id);
#      } else {
#        $slice = $slice_hash{"NAME:$sr_name:$asm_cs_name:$asm_cs_vers"} ||=
#          $sa->fetch_by_region($asm_cs_name, $sr_name, undef, undef, undef,
#                               $asm_cs_vers);
#      }
    }

    #
    # If a destination slice was provided convert the coords
    # If the dest_slice starts at 1 and is foward strand, nothing needs doing
    #
    if($dest_slice) {
      if($dest_slice_start != 1 || $dest_slice_strand != 1) {
        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;
        } else {
          my $tmp_seq_region_start = $seq_region_start;
          $seq_region_start = $dest_slice_end - $seq_region_end + 1;
          $seq_region_end   = $dest_slice_end - $tmp_seq_region_start + 1;
        }
      }

      #throw away features entirely off the end of the requested slice
      if($seq_region_end < 1 || $seq_region_start > $dest_slice_length ||
     ( $dest_slice_sr_id ne $seq_region_id )) {
    next FEATURE;
      }
      $slice = $dest_slice;
    }

    push( @features,
          $self->_create_feature( 'Bio::EnsEMBL::DensityFeature', {
                                    -dbID       => $density_feature_id,
                                    -adaptor    => $self,
                                    -start      => $seq_region_start,
                                    -end        => $seq_region_end,
                                    -seq_region => $slice,
                                    -density_value => $density_value,
                                    -density_type  => $density_type
                                  } ) );

  }

  return \@features;
}

Reimplemented from Bio::EnsEMBL::DBSQL::BaseAdaptor.

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_pre_store ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_pre_store_userdata ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_remap ( ) [inherited]

Undocumented method

Code:

click to view

protected Bio::EnsEMBL::Utils::Cache Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_slice_feature_cache ( ) [inherited]

 
  Description	: Returns the feature cache if we are allowed to cache and
                will build it if we need to. We will never return a reference
                to the hash to avoid unintentional auto-vivfying caching
  Returntype 	: Bio::EnsEMBL::Utils::Cache
  Exceptions 	: None
  Caller     	: Internal

Code:

click to view

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_slice_fetch ( ) [inherited]

Undocumented method

Code:

click to view

sub _slice_fetch {
  my ( $self, $slice, $orig_constraint ) = @_;

  my $slice_start         = $slice->start();
  my $slice_end           = $slice->end();
  my $slice_strand        = $slice->strand();
  my $slice_cs            = $slice->coord_system();
  my $slice_seq_region    = $slice->seq_region_name();
  my $slice_seq_region_id = $slice->get_seq_region_id();

  #get the synonym and name of the primary_table
  my @tabs = $self->_tables;
  my ( $tab_name, $tab_syn ) = @{ $tabs[0] };

  #find out what coordinate systems the features are in
  my $mcc      = $self->db->get_MetaCoordContainer();
  my @feat_css = ();

  my $mca        = $self->db->get_MetaContainer();
  my $value_list = $mca->list_value_by_key( $tab_name . "build.level" );
  if ( @$value_list and $slice->is_toplevel() ) {
    push @feat_css, $slice_cs;
  } else {
    @feat_css =
      @{ $mcc->fetch_all_CoordSystems_by_feature_type($tab_name) };
  }

  my $asma = $self->db->get_AssemblyMapperAdaptor();
  my @features;

  # fetch the features from each coordinate system they are stored in
COORD_SYSTEM: foreach my $feat_cs (@feat_css) {
    my $mapper;
    my @coords;
    my @ids;

    if ( $feat_cs->equals($slice_cs) ) {
      # no mapping is required if this is the same coord system

      my $max_len = $self->_max_feature_length()
        || $mcc->fetch_max_length_by_CoordSystem_feature_type( $feat_cs,
                                                            $tab_name );

      my $constraint = $orig_constraint;

      my $sr_id;
      if ( $slice->adaptor() ) {
        $sr_id = $slice->adaptor()->get_seq_region_id($slice);
      } else {
        $sr_id =
          $self->db()->get_SliceAdaptor()->get_seq_region_id($slice);
      }

      # If there is mapping information, use the external_seq_region_id
      # to get features.

      my @sr_ids = ($sr_id);

      while (1) {
        my $ext_sr_id = $self->get_seq_region_id_external($sr_id);

        if ( $ext_sr_id == $sr_id ) { last }

        push( @sr_ids, $ext_sr_id );
        $sr_id = $ext_sr_id;
      }

      $constraint .= " AND " if ($constraint);

      
      $constraint .= "${tab_syn}.seq_region_id IN ("
          . join( ',', @sr_ids ) . ") AND";

      #faster query for 1bp slices where SNP data is not compressed
      if ( $self->start_equals_end && $slice_start == $slice_end ) {
      $constraint .=
          " AND ${tab_syn}.seq_region_start = $slice_end" .
          " AND ${tab_syn}.seq_region_end = $slice_start";

      } else {

      if ( !$slice->is_circular() ) {
          # Deal with the default case of a non-circular chromosome.
          $constraint .= " ${tab_syn}.seq_region_start <= $slice_end AND "
          . "${tab_syn}.seq_region_end >= $slice_start";

          if ( $max_len ) {
          my $min_start = $slice_start - $max_len;
          $constraint .= " AND ${tab_syn}.seq_region_start >= $min_start";
          }

      } else {
          # Deal with the case of a circular chromosome.
          if ( $slice_start > $slice_end ) {
          $constraint .= " ( ${tab_syn}.seq_region_start >= $slice_start "
              . "OR ${tab_syn}.seq_region_start <= $slice_end "
              . "OR ${tab_syn}.seq_region_end >= $slice_start "
              . "OR ${tab_syn}.seq_region_end <= $slice_end "
              . "OR ${tab_syn}.seq_region_start > ${tab_syn}.seq_region_end)";

          } else {
          $constraint .= " ((${tab_syn}.seq_region_start <= $slice_end "
              . "AND ${tab_syn}.seq_region_end >= $slice_start) "
              . "OR (${tab_syn}.seq_region_start > ${tab_syn}.seq_region_end "
              . "AND (${tab_syn}.seq_region_start <= $slice_end "
              . "OR ${tab_syn}.seq_region_end >= $slice_start)))";
          }
      }

      }

      my $fs = $self->generic_fetch( $constraint, undef, $slice );

    # features may still have to have coordinates made relative to slice
    # start
      $fs = $self->_remap( $fs, $mapper, $slice );

      push @features, @$fs;
    } else {
      $mapper = $asma->fetch_by_CoordSystems( $slice_cs, $feat_cs );

      next unless defined $mapper;

      # Get list of coordinates and corresponding internal ids for
      # regions the slice spans
      @coords =
        $mapper->map( $slice_seq_region, $slice_start, $slice_end,
                      $slice_strand, $slice_cs );

      @coords = grep { !$_->isa('Bio::EnsEMBL::Mapper::Gap') } @coords;

      next COORD_SYSTEM if ( !@coords );

      @ids = map { $_->id() } @coords;
      #coords are now id rather than name
      #      @ids = @{$asma->seq_regions_to_ids($feat_cs, \@ids)};

      # When regions are large and only partially spanned
      # by slice it is faster to to limit the query with
      # start and end constraints.  Take simple approach:
      # use regional constraints if there are less than a
      # specific number of regions covered.

      if ( @coords > $MAX_SPLIT_QUERY_SEQ_REGIONS ) {
        my $constraint = $orig_constraint;
        my $id_str = join( ',', @ids );
        $constraint .= " AND " if ($constraint);
        $constraint .= "${tab_syn}.seq_region_id IN ($id_str)";
        my $fs = $self->generic_fetch( $constraint, $mapper, $slice );

        $fs = $self->_remap( $fs, $mapper, $slice );

        push @features, @$fs;

      } else {
        # do multiple split queries using start / end constraints

        my $max_len = (
                $self->_max_feature_length()
                  || $mcc->fetch_max_length_by_CoordSystem_feature_type(
                                                     $feat_cs, $tab_name
                  ) );

        my $len = @coords;
        for ( my $i = 0; $i < $len; $i++ ) {
          my $constraint = $orig_constraint;
          $constraint .= " AND " if ($constraint);
          $constraint .=
              "${tab_syn}.seq_region_id = "
            . $ids[$i] . " AND "
            . "${tab_syn}.seq_region_start <= "
            . $coords[$i]->end() . " AND "
            . "${tab_syn}.seq_region_end >= "
            . $coords[$i]->start();

          if ($max_len) {
            my $min_start = $coords[$i]->start() - $max_len;
            $constraint .=
              " AND ${tab_syn}.seq_region_start >= $min_start";
          }
          my $fs = $self->generic_fetch( $constraint, $mapper, $slice );

          $fs = $self->_remap( $fs, $mapper, $slice );

          push @features, @$fs;
        }
      } ## end else [ if ( @coords > $MAX_SPLIT_QUERY_SEQ_REGIONS)]
    } ## end else [ if ( $feat_cs->equals(...))]
  } ## end foreach my $feat_cs (@feat_css)

  return \@features;
} ## end sub _slice_fetch

protected Bio::EnsEMBL::DBSQL::BaseAdaptor::_straight_join ( ) [inherited]

Undocumented method

Code:

click to view

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

Undocumented method

Code:

click to view

Reimplemented from Bio::EnsEMBL::DBSQL::BaseAdaptor.

public Listref Bio::EnsEMBL::DBSQL::BaseAdaptor::bind_param_generic_fetch ( ) [inherited]

 Arg [1]   : (optional)  scalar $param
              This is the parameter to bind
 Arg [2]   : (optional) int $sql_type
              Type of the parameter (from DBI (:sql_types))
 Example   :  $adaptor->bind_param_generic_fetch($stable_id,SQL_VARCHAR);
              $adaptor->generic_fetch();
 Description:  When using parameters for the query, will call the bind_param to avoid
               some security issues. If there are no arguments, will return the bind_parameters
 ReturnType : listref
 Exceptions:  if called with one argument

Code:

click to view

public void Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::clear_cache ( ) [inherited]

  Args      : None
  Example   : my $sa =
                $registry->get_adaptor( 'Mus musculus', 'Core',
                                        'Slice' );
              my $ga =
                $registry->get_adaptor( 'Mus musculus', 'Core',
                                        'Gene' );

              my $slice =
                $sa->fetch_by_region( 'Chromosome', '1', 1e8,
                                      1.05e8 );

              my $genes = $ga->fetch_all_by_Slice($slice);

              $ga->clear_cache();

  Description   : Empties the feature cache associated with this
                  feature adaptor.
  Return type   : None
  Exceptions    : None
  Caller        : General
  Status        : At risk (under development)

Code:

click to view

public Bio::EnsEMBL::DBSQL::DBAdaptor Bio::EnsEMBL::DBSQL::BaseAdaptor::db ( ) [inherited]

  Arg [1]    : (optional) Bio::EnsEMBL::DBSQL::DBAdaptor $obj 
               the database this adaptor is using.
  Example    : $db = $adaptor->db();
  Description: Getter/Setter for the DatabaseConnection that this adaptor is 
               using.
  Returntype : Bio::EnsEMBL::DBSQL::DBAdaptor
  Exceptions : none
  Caller     : Adaptors inherited from BaseAdaptor
  Status     : Stable

Code:

click to view

public Bio::EnsEMBL::DBSQL::DBConnection Bio::EnsEMBL::DBSQL::BaseAdaptor::dbc ( ) [inherited]

  Arg [1]    : (optional) Bio::EnsEMBL::DBSQL::DBConnection $obj 
               the database this adaptor is using.
  Example    : $db = $adaptor->db();
  Description: Getter/Setter for the DatabaseConnection that this adaptor is 
               using.
  Returntype : Bio::EnsEMBL::DBSQL::DBConnection
  Exceptions : none
  Caller     : Adaptors inherited from BaseAdaptor
  Status     : Stable

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseAdaptor::dump_data ( ) [inherited]

Undocumented method

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseAdaptor::fetch_all ( ) [inherited]

Undocumented method

Code:

click to view

public Listref Bio::EnsEMBL::DBSQL::BaseAdaptor::fetch_all_by_dbID_list ( ) [inherited]

  Arg [1]    : listref of integers $id_list
               The unique database identifiers for the features to
               be obtained.
  Arg [2]    : optional - Bio::EnsEMBL::Slice to map features onto.
  Example    : @feats = @{$adaptor->fetch_all_by_dbID_list([1234, 2131, 982]))};
  Description: Returns the features created from the database
               defined by the the IDs in contained in the provided
               ID list $id_list.  The features will be returned
               in their native coordinate system.  That is, the
               coordinate system in which they are stored in the
               database.  In order to convert the features to a
               particular coordinate system use the transfer() or
               transform() method.  If none of the features are
               found in the database a reference to an empty list is
               returned.
  Returntype : listref of Bio::EnsEMBL::Features
  Exceptions : thrown if $id arg is not provided
               does not exist
  Caller     : general
  Status     : Stable

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::OntologyTermAdaptor.

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_logic_name ( ) [inherited]

  Arg [3]    : string $logic_name
               the logic name of the type of features to obtain
  Example    : $fs = $a->fetch_all_by_logic_name('foobar');
  Description: Returns a listref of features created from the database.
               only features with an analysis of type $logic_name will
               be returned.  If the logic name is invalid (not in the
               analysis table), a reference to an empty list will be
               returned.
  Returntype : listref of Bio::EnsEMBL::SeqFeatures
  Exceptions : thrown if no $logic_name
  Caller     : General
  Status     : Stable

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_RawContig ( ) [inherited]

Description:

Deprecated:: use fetch_all_by_Slice instead

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_RawContig_and_score ( ) [inherited]

Description:

Deprecated:: use fetch_all_by_Slice_and_score instead

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_RawContig_constraint ( ) [inherited]

Description:

Deprecated:: use fetch_all_by_RawContig_constraint instead

Code:

click to view

public Bio::EnsEMBL::DensityFeature Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::fetch_all_by_Slice ( )

  Arg [1]    : Bio::EnsEMBL::Slice $slice - The slice representing the region
               to retrieve density features from.
  Arg [2]    : string $logic_name - The logic name of the density features to
               retrieve.
  Arg [3]    : int $num_blocks (optional; default = 50) - The number of
               features that are desired. The ratio between the size of these
               features and the size of the features in the database will be
               used to determine which database features will be used.
  Arg [4]    : boolean $interpolate (optional; default = 0) - A flag indicating
               whether the features in the database should be interpolated to
               fit them to the requested number of features.  If true the
               features will be interpolated to provide $num_blocks features.
               This will not guarantee that exactly $num_blocks features are
               returned due to rounding etc. but it will be close.
  Arg [5]    : float $max_ratio - The maximum ratio between the size of the
               requested features (as determined by $num_blocks) and the actual
               size of the features in the database.  If this value is exceeded
               then an empty list will be returned.  This can be used to
               prevent excessive interpolation of the database values.
  Example    : #interpolate:
               $feats = $dfa->fetch_all_by_Slice($slice,'SNPDensity', 10, 1);
               #do not interpoloate, get what is in the database:
               $feats = $dfa->fetch_all_by_Slice($slice,'SNPDensity', 50);
               #interpolate, but not too much
               $feats = $dfa->fetch_all_by_Slice($slice,'SNPDensity',50,1,5.0);
  Description: Retrieves a set of density features which overlap the region
               of this slice. Density features are a discrete representation
               of a continuous value along a sequence, such as a density or
               percent coverage.  Density Features may be stored in chunks of
               different sizes in the database, and interpolated to fit the
               desired size for the requested region.  For example the database
               may store a single density value for each 1KB and also for each
               1MB.  When fetching for an entire chromosome the 1MB density
               chunks will be used if the requested number of blocks is not
               very high.
               Note that features which have been interpolated are not stored
               in the database and as such will have no dbID or adaptor set.
  Returntype : Bio::EnsEMBL::DensityFeature
  Exceptions : warning on invalid $num_blocks argument
               warning if no features with logic_name $logic_name exist
               warning if density_type table has invalid block_size value
  Caller     : general
  Status     : Stable

Code:

click to view

sub fetch_all_by_Slice {
  my ($self, $slice, $logic_name, $num_blocks, $interpolate, $max_ratio) = @_;

  if(defined($num_blocks) && $num_blocks < 1) {
    warning("Invalid number of density blocks [$num_blocks] requested.\n" .
       "Returning empty list.");
    return [];
  }

  $num_blocks ||= 50;
  my $length = $slice->length();

  my $wanted_block_size = POSIX::ceil($length/$num_blocks);

  #
  # get out all of the density types and choose the one with the
  # block size closest to our desired block size
  #

  my $dta = $self->db()->get_DensityTypeAdaptor();

  my @dtypes = @{$dta->fetch_all_by_logic_name($logic_name)};
  if( ! @dtypes ){
    my @all_dtypes =  @{ $dta->fetch_all() };
    @all_dtypes or warning( "No DensityTypes in $dta" ) && return [];
    my $valid_list = join( ", ", map{$_->analysis->logic_name} @all_dtypes );
    warning( "No DensityTypes for logic name $logic_name. ".
         "Select from $valid_list" );
    return [];
  }

  my $best_ratio   = undef;
  my $density_type = undef;
  my $best_ratio_large = undef;
  my $density_type_large = undef;
  my %dt_ratio_hash;

  foreach my $dt (@dtypes) {

    my $ratio;
    if( $dt->block_size() > 0 ) {
      $ratio = $wanted_block_size/$dt->block_size();
    } else {
      # This is only valid if the requested seq_region is the one the 
      # features are stored on. Please use sensibly. Or find better implementation.

      my $block_size = $slice->seq_region_length() / $dt->region_features();
      $ratio = $wanted_block_size / $block_size;
    }
    
    # we prefer to use a block size that's smaller than the required one
    # (better results on interpolation).
    # give larger bits a disadvantage and make them comparable
    if( $ratio < 1 ) {
      $ratio = 5/$ratio;
    }

    $dt_ratio_hash{ $ratio } = $dt;
  }

  $best_ratio = (sort {$a<=>$b} (keys %dt_ratio_hash))[0];
  
  #the ratio was not good enough, or this logic name was not in the
  #density type table, return an empty list
  if(!defined($best_ratio) ||
     (defined($max_ratio) && $best_ratio > $max_ratio)) {
    return [];
  }

  $density_type = $dt_ratio_hash{$best_ratio};

  my $constraint = "df.density_type_id = " . $density_type->dbID();

  my @features =
    @{$self->fetch_all_by_Slice_constraint($slice,$constraint)};

  return \@features if(!$interpolate);

  #interpolate the features into new features of a different size
  my @out;
  #sort the features on start position
  @features = sort( { $a->start() <=> $b->start() } @features );

  #resize the features that were returned
  my $start = 1;
  my $end   = $start+$wanted_block_size-1;

  my $value_type = $density_type->value_type();

  # create a new density type object for the interpolated features that
  # is not stored in the database
  $density_type = Bio::EnsEMBL::DensityType->new
    (-VALUE_TYPE => $value_type,
     -ANALYSIS   => $density_type->analysis(),
     -BLOCK_SIZE => $wanted_block_size);

  while($start < $length) {
#    $end = $length if($end > $length);

    my $density_value = 0.0;
    my ($f, $fstart, $fend, $portion);
    my @dvalues;

    #construct a new feature using all of the old density features that
    #we overlapped
    while(($f = shift(@features)) && $end > $f->{'start'}) {

      #what portion of this feature are we using to construct our new block?
      $fstart = ($f->{'start'} < $start) ? $start : $f->{'start'};
      $fend   = ($f->{'end'}   > $end  ) ? $end   : $f->{'end'};
      $fend   = $length if($fend > $length);

      if($value_type eq 'sum') {

        $portion = ($fend-$fstart+1)/$f->length();

        #take a percentage of density value, depending on how much of the
        #feature we overlapped
        $density_value += $portion * $f->{'density_value'};

      } elsif($value_type eq 'ratio') {

        #maintain a running total of the length used from each feature
        #and its value
        push(@dvalues,[$fend-$fstart+1,$f->{'density_value'}]);

      } else {
        throw("Unknown density value type [$value_type].");
      }

      #do not want to look at next feature if we only used part of this one:
      last if($fend < $f->{'end'});
    }

    #if we did not completely overlap the last feature, put it back on so
    #it can be partially used by the next block
    if(defined($f) && (!defined($fend) || $fend < $f->{'end'})) {
      unshift(@features, $f);
    }

    if($value_type eq 'ratio') {
      #take a weighted average of the all the density values of the features
      #used to construct this one
      my $total_len = $end - $start + 1;
      if($total_len > 0) {
        foreach my $pair (@dvalues) {
          my ($dlen, $dval) = @$pair;
          $density_value += $dval * ($dlen/$total_len);
        }
      }
    }

    # interpolated features are not stored in the db so do not set the dbID
    # or the adaptor
    push @out, Bio::EnsEMBL::DensityFeature->new
      (-seq_region    => $slice,
       -start         => $start,
       -end           => $end,
       -density_type  => $density_type,
       -density_value => $density_value);

    $start = $end + 1;
    $end  += $wanted_block_size;
  }

  return \@out;
}

Reimplemented from Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor.

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice_and_score ( ) [inherited]

  Arg [1]    : Bio::EnsEMBL::Slice $slice
               the slice from which to obtain features
  Arg [2]    : (optional) float $score
               lower bound of the the score of the features retrieved
  Arg [3]    : (optional) string $logic_name
               the logic name of the type of features to obtain
  Example    : $fts = $a->fetch_all_by_Slice_and_score($slice,90,'Swall');
  Description: Returns a list of features created from the database which are 
               are on the Slice defined by $slice and which have a score 
               greater than $score. If $logic_name is defined, 
               only features with an analysis of type $logic_name will be 
               returned. 
  Returntype : listref of Bio::EnsEMBL::SeqFeatures in Slice coordinates
  Exceptions : none
  Caller     : Bio::EnsEMBL::Slice
  Status     : Stable

Code:

click to view

Reimplemented in Bio::EnsEMBL::Map::DBSQL::MarkerFeatureAdaptor.

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice_constraint ( ) [inherited]

  Arg [1]    : Bio::EnsEMBL::Slice $slice
               the slice from which to obtain features
  Arg [2]    : (optional) string $constraint
               An SQL query constraint (i.e. part of the WHERE clause)
  Arg [3]    : (optional) string $logic_name
               the logic name of the type of features to obtain
  Example    : $fs = $a->fetch_all_by_Slice_constraint($slc, 'perc_ident > 5');
  Description: Returns a listref of features created from the database which 
               are on the Slice defined by $slice and fulfill the SQL 
               constraint defined by $constraint. If logic name is defined, 
               only features with an analysis of type $logic_name will be 
               returned. 
  Returntype : listref of Bio::EnsEMBL::SeqFeatures in Slice coordinates
  Exceptions : thrown if $slice is not defined
  Caller     : Bio::EnsEMBL::Slice
  Status     : Stable

Code:

click to view

sub fetch_all_by_Slice_constraint {
  my ( $self, $slice, $constraint, $logic_name ) = @_;


  my @result = ();

  if ( !ref($slice)
       || !(    $slice->isa('Bio::EnsEMBL::Slice')
             or $slice->isa('Bio::EnsEMBL::LRGSlice') ) )
  {
    throw("Bio::EnsEMBL::Slice argument expected.");
  }

  $constraint ||= '';
  $constraint =
    $self->_logic_name_to_constraint( $constraint, $logic_name );

  # If the logic name was invalid, undef was returned
  if ( !defined($constraint) ) { return [] }

  my $key;
  my $cache;

  # Will only use feature_cache if hasn't been no_cache attribute set
  if (
    !( defined( $self->db()->no_cache() ) && $self->db()->no_cache() ) )
  {

    #strain test and add to constraint if so to stop caching.
    if ( $slice->isa('Bio::EnsEMBL::StrainSlice') ) {
      my $string =
        $self->dbc()->db_handle()->quote( $slice->strain_name() );

      if ( $constraint ne "" ) {
        $constraint .= " AND $string = $string ";
      } else {
        $constraint .= " $string = $string ";
      }
    }

    # Check the cache and return the cached results if we have already
    # done this query.  The cache key is the made up from the slice
    # name, the constraint, and the bound parameters (if there are any).
    $key = uc( join( ':', $slice->name(), $constraint ) );

    my $bind_params = $self->bind_param_generic_fetch();

    if ( defined($bind_params) ) {
      $key .= ':'
        . join( ':', map { $_->[0] . '/' . $_->[1] } @{$bind_params} );
    }

    $cache = $self->_slice_feature_cache();
    if ( exists( $cache->{$key} ) ) {
      # Clear the bound parameters and return the cached data.
      $self->{'_bind_param_generic_fetch'} = ();
      return $cache->{$key};
    }
  } ## end if ( !( defined( $self...)))

  my $sa = $slice->adaptor();

  # Hap/PAR support: retrieve normalized 'non-symlinked' slices.
  my @proj = @{ $sa->fetch_normalized_slice_projection($slice) };


 
  if ( !@proj ) {
    throw( 'Could not retrieve normalized Slices. '
         . 'Database contains incorrect assembly_exception information.'
    );
  }

  # Want to get features on the FULL original slice as well as any
  # symlinked slices.

  # Filter out partial slices from projection that are on same
  # seq_region as original slice.

  my $sr_id = $slice->get_seq_region_id();

  @proj = grep { $_->to_Slice->get_seq_region_id() != $sr_id } @proj;

  my $segment = bless( [ 1, $slice->length(), $slice ],
                       'Bio::EnsEMBL::ProjectionSegment' );
  push( @proj, $segment );

  # construct list of Hap/PAR boundaries for entire seq region
  my @bounds;

  my $ent_slice = $sa->fetch_by_seq_region_id($sr_id);
  if ( $slice->strand() == -1 ) {
    $ent_slice = $ent_slice->invert();
  }

  my @ent_proj =
    @{ $sa->fetch_normalized_slice_projection($ent_slice) };
  shift(@ent_proj);    # skip first

  @bounds = map { $_->from_start() - $slice->start() + 1 } @ent_proj;


  # fetch features for the primary slice AND all symlinked slices
  foreach my $seg (@proj) {


    my $offset    = $seg->from_start();
    my $seg_slice = $seg->to_Slice();
    my $features =
      $self->_slice_fetch( $seg_slice, $constraint );

    # If this was a symlinked slice offset the feature coordinates as
    # needed.
    if ( $seg_slice->name() ne $slice->name() ) {

    FEATURE:
      foreach my $f ( @{$features} ) {
        if ( $offset != 1 ) {
          $f->{'start'} += $offset - 1;
          $f->{'end'}   += $offset - 1;
        }

        # discard boundary crossing features from symlinked regions
        foreach my $bound (@bounds) {
          if ( $f->{'start'} < $bound && $f->{'end'} >= $bound ) {
            next FEATURE;
          }
        }

        $f->{'slice'} = $slice;
        push( @result, $f );
      }
    } else {
      push( @result, @{$features} );
    }
  } ## end foreach my $seg (@proj)

  # Will only use feature_cache when set attribute no_cache in DBAdaptor
  if ( defined($key) ) {
    $cache->{$key} = \@result;
  }

  return \@result;
} ## end sub fetch_all_by_Slice_constraint

public Bio::EnsEMBL::Feature Bio::EnsEMBL::DBSQL::BaseAdaptor::fetch_by_dbID ( ) [inherited]

  Arg [1]    : int $id
               The unique database identifier for the feature to be obtained
  Example    : $feat = $adaptor->fetch_by_dbID(1234));
               $feat = $feat->transform('contig');
  Description: Returns the feature created from the database defined by the
               the id $id.  The feature will be returned in its native
               coordinate system.  That is, the coordinate system in which it
               is stored in the database.  In order to convert it to a
               particular coordinate system use the transfer() or transform()
               method.  If the feature is not found in the database then
               undef is returned instead
  Returntype : Bio::EnsEMBL::Feature or undef
  Exceptions : thrown if $id arg is not provided
               does not exist
  Caller     : general
  Status     : Stable

Code:

click to view

public Bio::EnsEMBL::DensityFeatureSet Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::fetch_Featureset_by_Slice ( )

  Arg [1-5]  : see
               Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::fetch_all_by_Slice()
               for argument documentation
  Example    : $featureset = $dfa->fetch_FeatureSet_by_Slice($slice,'SNPDensity', 10, 1);
  Description: wrapper around
               Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::fetch_all_by_Slice()
               which returns a Bio::EnsEMBL::DensityFeatureSet and also caches
               results
  Returntype : Bio::EnsEMBL::DensityFeatureSet
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

public Bio::EnsEMBL::Utils::Iterator Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_Iterator_by_Slice ( ) [inherited]

  Arg [1]    : Bio::EnsEMBL::Slice
  Arg [2]    : Optional string: logic name of analysis
  Arg [3]    : Optional int: Chunk size to iterate over. Default is 500000
  Example    : my $slice_iter = $feature_adaptor->fetch_Iterator_by_Slice($slice);

               while(my $feature = $slice_iter->next && defined $feature){
                 #Do something here
               }

  Description: Creates an Iterator which chunks the query Slice to facilitate
               large Slice queries which would have previously run out of memory
  Returntype : Bio::EnsEMBL::Utils::Iterator
  Exceptions : None
  Caller     : general
  Status     : at risk

Code:

click to view

public Bio::EnsEMBL::Utils::Iterator Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_Iterator_by_Slice_method ( ) [inherited]

  Arg [1]    : CODE ref of Slice fetch method
  Arg [2]    : ARRAY ref of parameters for Slice fetch method
  Arg [3]    : Optional int: Slice index in parameters array
  Arg [4]    : Optional int: Slice chunk size. Default=500000
  Example    : my $slice_iter = $feature_adaptor->fetch_Iterator_by_Slice_method
                               	      ($feature_adaptor->can('fetch_all_by_Slice_Arrays'),
	                                   \@fetch_method_params,
	                                   0,#Slice idx
	                                  );

               while(my $feature = $slice_iter->next && defined $feature){
                 #Do something here
               }

  Description: Creates an Iterator which chunks the query Slice to facilitate
               large Slice queries which would have previously run out of memory
  Returntype : Bio::EnsEMBL::Utils::Iterator
  Exceptions : Throws if mandatory params not valid
  Caller     : general
  Status     : at risk

Code:

click to view

public Listref Bio::EnsEMBL::DBSQL::BaseAdaptor::generic_fetch ( ) [inherited]

  Arg [1]    : (optional) string $constraint
               An SQL query constraint (i.e. part of the WHERE clause)
  Arg [2]    : (optional) Bio::EnsEMBL::AssemblyMapper $mapper
               A mapper object used to remap features
               as they are retrieved from the database
  Arg [3]    : (optional) Bio::EnsEMBL::Slice $slice
               A slice that features should be remapped to
  Example    : $fts = $a->generic_fetch('contig_id in (1234, 1235)', 'Swall');
  Description: Performs a database fetch and returns feature objects in
               contig coordinates.
  Returntype : listref of Bio::EnsEMBL::SeqFeature in contig coordinates
  Exceptions : none
  Caller     : BaseFeatureAdaptor, ProxyDnaAlignFeatureAdaptor::generic_fetch
  Status     : Stable

Code:

click to view

sub generic_fetch {
  my ($self, $constraint, $mapper, $slice) = @_;

  my @tabs = $self->_tables();

  my $extra_default_where;

  # Hack for feature types that needs to be restricted to species_id (in
  # coord_system).
  if (    $self->is_multispecies()
       && $self->isa('Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor')
       && !$self->isa('Bio::EnsEMBL::DBSQL::UnmappedObjectAdaptor') )
  {
    # We do a check to see if there is already seq_region
    # and coord_system defined to ensure we get the right
    # alias.  We then do the extra query irrespectively of
    # what has already been specified by the user.
    my %thash = map { $_->[0] => $_->[1] } @tabs;

    my $sr_alias =
      ( exists( $thash{seq_region} ) ? $thash{seq_region} : 'sr' );
    my $cs_alias =
      ( exists( $thash{coord_system} ) ? $thash{coord_system} : 'cs' );

    if ( !exists( $thash{seq_region} ) ) {
      push( @tabs, [ 'seq_region', $sr_alias ] );
    }
    if ( !exists( $thash{coord_system} ) ) {
      push( @tabs, [ 'coord_system', $cs_alias ] );
    }

    $extra_default_where = sprintf(
                      '%s.seq_region_id = %s.seq_region_id '
                        . 'AND %s.coord_system_id = %s.coord_system_id '
                        . 'AND %s.species_id = ?',
                      $tabs[0]->[1], $sr_alias, $sr_alias,
                      $cs_alias,     $cs_alias );

    $self->bind_param_generic_fetch( $self->species_id(), SQL_INTEGER );
  } ## end if ( $self->is_multispecies...)

  my $columns = join(', ', $self->_columns());

  my $db = $self->db();

  #
  # Construct a left join statement if one was defined, and remove the
  # left-joined table from the table list
  #
  my @left_join_list = $self->_left_join();
  my $left_join_prefix = '';
  my $left_join = '';
  my @tables;
  if(@left_join_list) {
    my %left_join_hash = map { $_->[0] => $_->[1] } @left_join_list;
    while(my $t = shift @tabs) {
        my $t_alias = $t->[0] . " " . $t->[1];
      if( exists $left_join_hash{ $t->[0] } || exists $left_join_hash{$t_alias}) {
        my $condition = $left_join_hash{ $t->[0] };
        $condition ||= $left_join_hash{$t_alias};
        my $syn = $t->[1];
        $left_join .=
          "\n  LEFT JOIN " . $t->[0] . " $syn ON $condition ) ";
        $left_join_prefix .= '(';
      } else {
        push @tables, $t;
      }
    }
  } else {
    @tables = @tabs;
  }

  my $straight_join = '';

  if($self->_straight_join()) {
    $straight_join = "STRAIGHT_JOIN";
  }

  #construct a nice table string like 'table1 t1, table2 t2'
  my $tablenames = join(', ', map({ join(' ', @$_) } @tables));

  my $sql =
      "SELECT $straight_join $columns\n"
    . "FROM $left_join_prefix ($tablenames) $left_join";

  my $default_where = $self->_default_where_clause();
  my $final_clause = $self->_final_clause;

  if ($extra_default_where) {
    if ($default_where) {
      $default_where .= "\n AND $extra_default_where";
    } else {
      $default_where = $extra_default_where;
    }
  }

  #append a where clause if it was defined
  if ($constraint) {
    $sql .= "\n WHERE $constraint ";
    if ($default_where) {
      $sql .= " AND\n       $default_where ";
    }
  } elsif ($default_where) {
    $sql .= "\n WHERE $default_where ";
  }

  #append additional clauses which may have been defined
  $sql .= "\n$final_clause";


  # FOR DEBUG:
  #printf(STDERR "SQL:\n%s\n", $sql);
  
  
  my $sth = $db->dbc->prepare($sql);
  my $bind_parameters = $self->bind_param_generic_fetch();
  if (defined $bind_parameters){
      #if we have bind the parameters, call the DBI to bind them
      my $i = 1;
      foreach my $param (@{$bind_parameters}){
        $sth->bind_param($i,$param->[0],$param->[1]);
        $i++;
      }
      #after binding parameters, undef for future queries
      $self->{'_bind_param_generic_fetch'} = ();
  }
  eval { $sth->execute() };
  if ($@) {
    throw("Detected an error whilst executing SQL '${sql}': $@");
  }

  my $res = $self->_objs_from_sth($sth, $mapper, $slice);
  $sth->finish();
  return $res;
}

Reimplemented in Bio::EnsEMBL::DBSQL::DataFileAdaptor.

public Bio::EnsEMBL::DBSQL::BaseAdaptor::get_dumped_data ( ) [inherited]

Undocumented method

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::get_seq_region_id_external ( ) [inherited]

Undocumented method

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::get_seq_region_id_internal ( ) [inherited]

Undocumented method

Code:

click to view

public Boolean Bio::EnsEMBL::DBSQL::BaseAdaptor::is_multispecies ( ) [inherited]

  Arg [1]    : (optional) boolean $arg
  Example    : if ($adaptor->is_multispecies()) { }
  Description: Getter/Setter for the is_multispecies boolean of
               to use for this adaptor.
  Returntype : boolean
  Exceptions : none
  Caller     : general
  Status     : Stable

Code:

click to view

public Scalar Bio::EnsEMBL::DBSQL::BaseAdaptor::last_insert_id ( ) [inherited]

  Arg [1]     : (optional) $field the name of the field the inserted ID was pushed 
                into
  Arg [2]     : (optional) HashRef used to pass extra attributes through to the 
                DBD driver
  Description : Delegating method which uses DBI to extract the last inserted 
                identifier. If using MySQL we just call the DBI method 
                DBI::last_insert_id() since MySQL ignores any extra
                arguments. See DBI for more information about this 
                delegated method. 
  Example     : my $id = $self->last_insert_id('my_id'); my $other_id = $self->last_insert_id();
  Returntype  : Scalar or undef

Code:

click to view

public List Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::list_dbIDs ( )

  Arg [1]    : none
  Example    : @feature_ids = @{$density_feature_adaptor->list_dbIDs()};
  Description: Gets an array of internal ids for all density features in the
               current db
  Arg[1]     : <optional> int. not set to 0 for the ids to be sorted by the seq_region.
  Returntype : list of ints
  Exceptions : none
  Caller     : ?
  Status     : Stable

Code:

click to view

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

  Arg [1]    : list of args @args
               Superclass constructor arguments
  Example    : none
  Description: Constructor which just initializes internal cache structures
  Returntype : Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor
  Exceptions : none
  Caller     : implementing subclass constructors
  Status     : Stable

Code:

click to view

Reimplemented from Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor.

public DBI::StatementHandle Bio::EnsEMBL::DBSQL::BaseAdaptor::prepare ( ) [inherited]

  Arg [1]    : string $string
               a SQL query to be prepared by this adaptors database
  Example    : $sth = $adaptor->prepare("select yadda from blabla")
  Description: provides a DBI statement handle from the adaptor. A convenience
               function so you dont have to write $adaptor->db->prepare all the
               time
  Returntype : DBI::StatementHandle
  Exceptions : none
  Caller     : Adaptors inherited from BaseAdaptor
  Status     : Stable

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::SliceAdaptor, and Bio::EnsEMBL::External::BlastAdaptor.

public void Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove ( ) [inherited]

  Arg [1]    : A feature $feature 
  Example    : $feature_adaptor->remove($feature);
  Description: This removes a feature from the database.  The table the
               feature is removed from is defined by the abstract method
               _tablename, and the primary key of the table is assumed
               to be _tablename() . '_id'.  The feature argument must 
               be an object implementing the dbID method, and for the
               feature to be removed from the database a dbID value must
               be returned.
  Returntype : none
  Exceptions : thrown if $feature arg does not implement dbID(), or if
               $feature->dbID is not a true value
  Caller     : general
  Status     : Stable

Code:

click to view

Reimplemented in Bio::EnsEMBL::DBSQL::ExonAdaptor, Bio::EnsEMBL::DBSQL::GeneAdaptor, Bio::EnsEMBL::DBSQL::OperonAdaptor, Bio::EnsEMBL::DBSQL::OperonTranscriptAdaptor, Bio::EnsEMBL::DBSQL::PredictionExonAdaptor, Bio::EnsEMBL::DBSQL::PredictionTranscriptAdaptor, and Bio::EnsEMBL::DBSQL::TranscriptAdaptor.

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_analysis_id ( ) [inherited]

Undocumented method

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_feature_id ( ) [inherited]

Undocumented method

Code:

click to view

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_RawContig ( ) [inherited]

Description:

Deprecated:: use remove_by_Slice instead

Code:

click to view

public void Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_Slice ( ) [inherited]

  Arg [1]    : Bio::Ensembl::Slice $slice
  Example    : $feature_adaptor->remove_by_Slice($slice);
  Description: This removes features from the database which lie on a region
               represented by the passed in slice.  Only features which are
               fully contained by the slice are deleted; features which overlap
               the edge of the slice are not removed.
               The table the features are removed from is defined by
               the abstract method_tablename.
  Returntype : none
  Exceptions : thrown if no slice is supplied
  Caller     : general
  Status     : Stable

Code:

click to view

public Int Bio::EnsEMBL::DBSQL::BaseAdaptor::species_id ( ) [inherited]

  Arg [1]    : (optional) int $species_id
               The internal ID of the species in a multi-species database.
  Example    : $db = $adaptor->db();
  Description: Getter/Setter for the internal ID of the species in a
               multi-species database.  The default species ID is 1.
  Returntype : Integer
  Exceptions : none
  Caller     : Adaptors inherited from BaseAdaptor
  Status     : Stable

Code:

click to view

public Boolean Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::start_equals_end ( ) [inherited]

  Arg [1]    : (optional) boolean $newval
  Example    : $bfa->start_equals_end(1);
  Description: Getter/Setter for the start_equals_end flag.  If set
               to true sub _slice_fetch will use a simplified sql to retrieve 1bp slices.
  Returntype : boolean
  Exceptions : none
  Caller     : EnsemblGenomes variation DB build
  Status     : Stable

Code:

click to view

public void Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::store ( )

  Arg [1]    : list of Bio::EnsEMBL::DensityFeatures @df
               the simple features to store in the database
  Example    : $density_feature_adaptor->store(1234, @density_feats);
  Description: Stores a list of density feature objects in the database
  Returntype : none
  Exceptions : thrown if @df is not defined, if any of the features do not
               have an attached slice.
               or if any elements of @df are not Bio::EnsEMBL::SeqFeatures 
  Caller     : general
  Status     : Stable

Code:

click to view

sub store{
  my ($self,@df) = @_;

  if( scalar(@df) == 0 ) {
    throw("Must call store with list of DensityFeatures");
  }
#mysql> desc density_feature;
#+--------------------+---------+------+-----+---------+----------------+
#| Field              | Type    | Null | Key | Default | Extra          |
#+--------------------+---------+------+-----+---------+----------------+
#| density_feature_id | int(11) |      | PRI | NULL    | auto_increment |
#| density_type_id    | int(11) |      | MUL | 0       |                |
#| seq_region_id      | int(11) |      |     | 0       |                |
#| seq_region_start   | int(11) |      |     | 0       |                |
#| seq_region_end     | int(11) |      |     | 0       |                |
#| density_value      | float   |      |     | 0       |                |
#+--------------------+---------+------+-----+---------+----------------+

  my $sth = $self->prepare
    ("INSERT INTO density_feature (seq_region_id, seq_region_start, " .
                                  "seq_region_end, density_type_id, " .
                                  "density_value) " .
     "VALUES (?,?,?,?,?)");

  my $db = $self->db();
  my $analysis_adaptor = $db->get_AnalysisAdaptor();

 FEATURE: foreach my $df ( @df ) {

    if( !ref $df || !$df->isa("Bio::EnsEMBL::DensityFeature") ) {
      throw("DensityFeature must be an Ensembl DensityFeature, " .
            "not a [".ref($df)."]");
    }
    
    # we dont store 0 value density features
    next if( $df->density_value == 0 );
    if($df->is_stored($db)) {
      warning("DensityFeature [".$df->dbID."] is already stored" .
              " in this database.");
      next FEATURE;
    }

    if(!defined($df->density_type)) {
      throw("A density type must be attached to the features to be stored.");
    }

    #store the density_type if it has not been stored yet

    if(!$df->density_type->is_stored($db)) {
      my $dta = $db->get_DensityTypeAdaptor();
      $dta->store($df->density_type());
    }

    my $original = $df;
    my $seq_region_id;
    ($df, $seq_region_id) = $self->_pre_store($df);

    $sth->bind_param(1,$seq_region_id,SQL_INTEGER);
    $sth->bind_param(2,$df->start,SQL_INTEGER);
    $sth->bind_param(3,$df->end,SQL_INTEGER);
    $sth->bind_param(4,$df->density_type->dbID,SQL_INTEGER);
    $sth->bind_param(5,$df->density_value,SQL_FLOAT);
    $sth->execute();

    $original->dbID($sth->{'mysql_insertid'});
    $original->adaptor($self);
  }
}

Reimplemented from Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor.

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

Bio/EnsEMBL/DBSQL/DensityFeatureAdaptor.pm

Class Summary

Synopsis

Description

Available Methods

Method Documentation