Inheritance diagram for Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor:

Public Member Functions
public Bio::EnsEMBL::BaseFeatureAdaptor	new ()

public Boolean	start_equals_end ()

public void	clear_cache ()

protected	_clear_slice_feature_cache ()

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

public Listref	fetch_all_by_Slice ()

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

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

public Listref	fetch_all_by_Slice_and_score ()

public Listref	fetch_all_by_Slice_constraint ()

public Listref	fetch_all_by_logic_name ()

public Listref	fetch_all_by_stable_id_list ()

protected	_create_feature ()

protected	_create_feature_fast ()

public Int	count_by_Slice_constraint ()

protected ArrayRef	_get_and_filter_Slice_projections ()

protected ArrayRef	_generate_feature_bounds ()

protected Listref	_get_by_Slice ()

protected	_slice_fetch ()

public	get_seq_region_id_external ()

public	get_seq_region_id_internal ()

protected	_pre_store ()

protected	_pre_store_userdata ()

protected	_check_start_end_strand ()

protected	_remap ()

protected	_seq_region_boundary_from_db ()

public void	store ()

public void	remove ()

public void	remove_by_Slice ()

protected	_max_feature_length ()

protected	_list_seq_region_ids ()

public	remove_by_analysis_id ()

public	remove_by_feature_id ()

public Bio::EnsEMBL::Feature	fetch_nearest_by_Feature ()

public Listref	fetch_all_by_outward_search ()

public Listref	fetch_all_nearest_by_Feature ()

public Listref	select_nearest ()

protected Int	_compute_nearest_end ()

protected Int	_compute_prime_distance ()

protected Int	_compute_midpoint ()

protected	_discard_excess_features_from_matrix ()

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

public DBI::StatementHandle	prepare ()

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

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

public Boolean	is_multispecies ()

public Int	species_id ()

protected	_list_dbIDs ()

protected	_straight_join ()

protected	_can_straight_join ()

public Listref	bind_param_generic_fetch ()

protected	_bind_param_generic_fetch ()

public String	generate_in_constraint ()

public Listref	generic_fetch ()

public Int	generic_count ()

protected	_generate_sql ()

public Bio::EnsEMBL::Feature	fetch_by_dbID ()

protected	_uncached_fetch_by_dbID ()

public Listref	fetch_all_by_dbID_list ()

protected	_uncached_fetch_all_by_dbID_list ()

protected ArrayRef	_uncached_fetch_all_by_id_list ()

public	fetch_all ()

public Scalar	last_insert_id ()

public	insert_ignore_clause ()

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

protected Boolean	_no_id_cache ()

public Boolean	ignore_cache_override ()

public Int	schema_version ()

protected	_tables ()

protected	_columns ()

protected	_default_where_clause ()

protected	_left_join ()

protected	_final_clause ()

protected	_objs_from_sth ()

protected	_build_id_cache ()

protected	_logic_name_to_constraint ()

Detailed Description

Synopsis

Abstract class - should not be instantiated. Implementation of

abstract methods must be performed by subclasses.

Description

This is a base adaptor for feature adaptors. This base class is simply a way
of eliminating code duplication through the implementation of methods
common to all feature adaptors.

Definition at line 24 of file BaseFeatureAdaptor.pm.

Member Function Documentation

◆ _check_start_end_strand()

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

Undocumented method

Code:

click to view

◆ _clear_slice_feature_cache()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_clear_slice_feature_cache ( )

Undocumented method

Code:

click to view

◆ _compute_midpoint()

protected Int Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_compute_midpoint ( )

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

$middle = $feature_adaptor->_compute_midpoint($feature);

  Description: Calculate the mid-point of a Feature. Used for comparing Features that overlap each other
               and determining a canonical distance between two Features for the majority of use cases.
  Returntype : Integer coordinate rounded down.
  Caller     : BaseFeatureAdaptor->select_nearest()

Code:

click to view

◆ _compute_nearest_end()

protected Int Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_compute_nearest_end ( )

  Arg [1]    : Reference feature start
  Arg [2]    : Reference feature mid-point
  Arg [3]    : Reference feature end
  Arg [4]    : Considered feature start
  Arg [5]    : Considered feature mid-point
  Arg [6]    : Considered feature end
  Example    :

$distance = $feature_adaptor->_compute_nearest_end($ref_start,$ref_midpoint,$ref_end,$f_start,$f_midpoint,$f_end)

  Description: For a given feature, calculate the smallest legitimate distance to a reference feature
               Calculate by mid-points to accommodate overlaps
  Returntype : Integer distance in base pairs
  Caller     : BaseFeatureAdaptor->select_nearest()

Code:

click to view

◆ _compute_prime_distance()

protected Int Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_compute_prime_distance ( )

  Arg [1]    : Reference feature start
  Arg [2]    : Reference feature mid-point
  Arg [3]    : Reference feature end
  Arg [4]    : Considered feature start
  Arg [5]    : Considered feature mid-point
  Arg [6]    : Considered feature end
  Arg [7]    : Considered feature strand
  Example    :

$distance,$weighted_centre_distance = $feature_adaptor->_compute_prime_distance($ref_start,$ref_midpoint,$ref_end,$f_start,$f_midpoint,$f_end,$f_strand)

  Description: Calculate the smallest distance to the 5' end of the considered feature
  Returntype : Integer distance in base pairs or a string warning that the result doesn't mean anything.
               Nearest 5' and 3' features shouldn't reside inside the reference Feature
  Caller     : BaseFeatureAdaptor->select_nearest()

Code:

click to view

◆ _create_feature()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_create_feature ( )

Undocumented method

Code:

click to view

◆ _create_feature_fast()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_create_feature_fast ( )

Undocumented method

Code:

click to view

◆ _discard_excess_features_from_matrix()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_discard_excess_features_from_matrix ( )

Undocumented method

Code:

click to view

◆ _generate_feature_bounds()

protected ArrayRef Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_generate_feature_bounds ( )

    Arg [1]     : Bio::EnsEMBL::Slice
    Description : Performs a projection of Slice and records the bounds
                  of that projection. This can be used later on to restrict
                  Features which overlap into unwanted areas such as
                  regions which exist on another HAP/PAR region.

                  Bounds are defined as projection_start - slice_start + 1.
    Example     :

my $bounds = $self->_generate_feature_bounds($slice);

    Returntype  : ArrayRef Integer; Returns the location of the bounds.

Code:

click to view

◆ _get_and_filter_Slice_projections()

protected ArrayRef Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_get_and_filter_Slice_projections ( )

    Arg [1]     : Bio::EnsEMBL::Slice
    Description : Delegates onto SliceAdaptor::fetch_normalized_slice_projection() 
                  with filtering on
    Returntype  : ArrayRef Bio::EnsEMBL::ProjectionSegment; Returns an array
                  of projected segments

Code:

click to view

◆ _get_by_Slice()

protected Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_get_by_Slice ( )

    Arg [0]    : Bio::EnsEMBL::Slice to find all the features within
    Arg [1]    : SQL constraint string
    Arg [2]    : Type of query to run. Default behaviour is to select, but 
                 'count' is also valid
    Description: Abstracted logic from _slice_fetch
    Returntype : Listref of Bio::EnsEMBL::Feature, or integers for counting mode

Code:

click to view

sub _get_by_Slice {
    my ($self, $slice, $orig_constraint, $query_type) = @_;
    
    # features can be scattered across multiple coordinate systems
    my @tables = $self->_tables;
    my ($table_name, $table_synonym) = @{ $tables[0] };
    my $mapper;
    my @feature_coord_systems;
    
    my $meta_values = $self->db->get_MetaContainer->list_value_by_key( $table_name."build.level");
    if ( @$meta_values and $slice->is_toplevel() ) {
        push @feature_coord_systems, $slice->coord_system();
    } else {
        @feature_coord_systems = @{ $self->db->get_MetaCoordContainer->fetch_all_CoordSystems_by_feature_type($table_name)};
    }
    
    my $assembly_mapper_adaptor = $self->db->get_AssemblyMapperAdaptor();
    my @pan_coord_features;
        
COORD_SYSTEM: foreach my $coord_system (@feature_coord_systems) {
        my @query_accumulator;
        # Build up a combination of query constraints that will quickly establish the result set
        my $constraint = $orig_constraint;
        if ( $coord_system->equals( $slice->coord_system ) ) {
            my $max_len = $self->_max_feature_length
                || $self->db->get_MetaCoordContainer
                    ->fetch_max_length_by_CoordSystem_feature_type( $coord_system,$table_name );
                       
            my $seq_region_id;
            if ( $slice->adaptor ) {
                $seq_region_id = $slice->adaptor->get_seq_region_id($slice);
            } else {
                $seq_region_id = $self->db->get_SliceAdaptor->get_seq_region_id($slice);
            }
            
            my @seq_region_ids = ($seq_region_id);
            while (1) {
                my $ext_seq_region_id = $self->get_seq_region_id_external($seq_region_id);
        
                if ( $ext_seq_region_id == $seq_region_id ) { last }
        
                push( @seq_region_ids, $ext_seq_region_id );
                $seq_region_id = $ext_seq_region_id;
            }
            
            $constraint .= " AND " if ($constraint);
 
            $constraint .= ${table_synonym}.".seq_region_id IN (". join( ',', @seq_region_ids ) . ") AND ";
            
            #faster query for 1bp slices where SNP data is not compressed
            if ( $self->start_equals_end && $slice->start == $slice->end ) {
                $constraint .= " AND ".$table_synonym.".seq_region_start = ".$slice->end .
                  " AND ".$table_synonym.".seq_region_end = ".$slice->start;
            
            } else {
                if ( !$slice->is_circular() ) {
                    # Deal with the default case of a non-circular chromosome.
                    $constraint .= $table_synonym.".seq_region_start <= ".$slice->end." AND "
                                   .$table_synonym.".seq_region_end >= ".$slice->start;
            
                    if ( $max_len ) {
                        my $min_start = $slice->start - $max_len;
                        $constraint .= " AND ".$table_synonym.".seq_region_start >= ".$min_start;
                    }
            
                } else {
                    # Deal with the case of a circular chromosome.
                    if ( $slice->start > $slice->end ) {
                        $constraint .= " ( ".$table_synonym.".seq_region_start >= ".$slice->start
                            . " OR ".$table_synonym.".seq_region_start <= ".$slice->end
                            . " OR ".$table_synonym.".seq_region_end >= ".$slice->start
                            . " OR ".$table_synonym.".seq_region_end <= ".$slice->end
                            . " OR ".$table_synonym.".seq_region_start > ".$table_synonym.".seq_region_end)";
                    } else {
                        $constraint .= " ((".$table_synonym.".seq_region_start <= ".$slice->end
                            . " AND ".$table_synonym.".seq_region_end >= ".$slice->start.") "
                            . "OR (".$table_synonym.".seq_region_start > ".$table_synonym.".seq_region_end"
                            . " AND (".$table_synonym.".seq_region_start <= ".$slice->end
                            . " OR ".$table_synonym.".seq_region_end >= ".$slice->start.")))";
                  }
              }
           }
           push @query_accumulator, [$constraint,undef,$slice]; # $mapper intentionally absent here.
           
        } else { 
            #coordinate systems do not match
            $mapper = $assembly_mapper_adaptor->fetch_by_CoordSystems( $slice->coord_system(), $coord_system );
            next unless defined $mapper;
 
            # Get list of coordinates and corresponding internal ids for
            # regions the slice spans
            my @coords = $mapper->map( $slice->seq_region_name, $slice->start, $slice->end,
                                    $slice->strand, $slice->coord_system );
 
            @coords = grep { !$_->isa('Bio::EnsEMBL::Mapper::Gap') } @coords;
 
            next COORD_SYSTEM if ( !@coords );
 
            my @ids = map { $_->id() } @coords;
            #coords are now id rather than name
            
            if ( @coords > $MAX_SPLIT_QUERY_SEQ_REGIONS && ! $slice->isa('Bio::EnsEMBL::LRGSlice') 
                    && $slice->coord_system->name() ne 'lrg') {
                $constraint = $orig_constraint;
                my $id_str = join( ',', @ids );
                $constraint .= " AND " if ($constraint);
                $constraint .= $table_synonym.".seq_region_id IN ($id_str)";
                
                push @query_accumulator, [$constraint,$mapper,$slice];
            } else {
                my $max_len = (
                    $self->_max_feature_length()
                    || $self->db->get_MetaCoordContainer
                       ->fetch_max_length_by_CoordSystem_feature_type($coord_system, $table_name) 
                );
 
                my $length = @coords;
                for ( my $i = 0; $i < $length; $i++ ) {
                    $constraint = $orig_constraint;
                    $constraint .= " AND " if ($constraint);
                    $constraint .= $table_synonym.".seq_region_id = "
                        . $ids[$i] . " AND "
                        . $table_synonym.".seq_region_start <= "
                        . $coords[$i]->end() . " AND "
                        . $table_synonym.".seq_region_end >= "
                        . $coords[$i]->start();
 
                    if ($max_len) {
                        my $min_start = $coords[$i]->start() - $max_len;
                        $constraint .= " AND ".$table_synonym.".seq_region_start >= ".$min_start;
                    }
                    
                    push @query_accumulator, [$constraint,$mapper,$slice];
                } # end multi-query cycle
        } # end else
            
     } # end else (coord sytems not matching)
     
     #Record the bind params if we have to do multiple queries
     my $bind_params = $self->bind_param_generic_fetch();
     
     foreach my $query (@query_accumulator) {
         my ($local_constraint,$local_mapper,$local_slice) = @$query;
         $self->_bind_param_generic_fetch($bind_params);
         if ($query_type and $query_type eq 'count') {
           push @pan_coord_features, $self->generic_count($local_constraint);
         } 
         else {
             my $features = $self->generic_fetch( $local_constraint, $local_mapper, $local_slice );
             $features = $self->_remap( $features, $local_mapper, $local_slice );
             push @pan_coord_features, @$features;
         }
     }
     $mapper = undef;
    } # End foreach
    $self->{_bind_param_generic_fetch} = undef;
    return \@pan_coord_features;
}

◆ _list_seq_region_ids()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_list_seq_region_ids ( )

Undocumented method

Code:

click to view

◆ _max_feature_length()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_max_feature_length ( )

Undocumented method

Code:

click to view

◆ _pre_store()

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

Undocumented method

Code:

click to view

◆ _pre_store_userdata()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_pre_store_userdata ( )

Undocumented method

Code:

click to view

◆ _remap()

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

Undocumented method

Code:

click to view

◆ _seq_region_boundary_from_db()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_seq_region_boundary_from_db ( )

Undocumented method

Code:

click to view

◆ _slice_feature_cache()

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

 
  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

◆ _slice_fetch()

protected Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::_slice_fetch ( )

Undocumented method

Code:

click to view

◆ clear_cache()

public void Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::clear_cache ( )

  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

◆ count_by_Slice_constraint()

public Int Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::count_by_Slice_constraint ( )

    Arg [1]     : Bio::EnsEMBL::Slice
    Arg [2]     : String Custom SQL constraint
    Arg [3]     : String Logic name to search by
    Description : Finds all features with at least partial overlap to the given
                  slice and sums them up.
                  Explanation of workings with projections:

                  |-------------------------Constraint Slice---------------------------------|
                  |             |                                           |                |
                  |--Segment 1--|                                           |                |
                  |             |--Segment 2, on desired Coordinate System--|                |
                  |             |                                           |---Segment 3----|
              #Feature 1#    #Feature 2#                               #Feature 3#           |
                  |         #####################Feature 4####################               |
                  | #Feature 5# |                                           |                |

                  Feature 1 is overlapping the original constraint. Counted in Segment 1
                  Feature 2,3 and 4  are counted when inspecting Segment 2
                  Feature 5 is counted in Segment 1

    Returntype  : Integer

Code:

click to view

sub count_by_Slice_constraint {
    my ($self, $slice, $constraint, $logic_name) = @_;
    
    assert_ref($slice, 'Bio::EnsEMBL::Slice', 'slice');
    
    my $count = 0;
    
    #Remember the bind params
    my $bind_params = $self->bind_param_generic_fetch();
    
    #Table synonym
    my @tables = $self->_tables;
    my ($table_name, $table_synonym) = @{ $tables[0] };
    
    # Basic constraints limit the feature hits to the starting Slice constraint
    $constraint ||= '';
    $constraint = $self->_logic_name_to_constraint( $constraint, $logic_name );
  
    return $count if ! defined $constraint;
  
    #Query logic
    my $sa = $slice->adaptor();
    my $projections = $self->_get_and_filter_Slice_projections($slice);
 
    my $segment_count = @{$projections};
    #Manual loop to support look-ahead/behind
    for (my $i = 0; $i < $segment_count; $i++) {
        my $seg = $projections->[$i];
        my $seg_slice = $seg->to_Slice();
        $self->_bind_param_generic_fetch($bind_params);
    
        # We cannot filter boundary crossing features in code, so we constrain the
        # SQL. We detect when we are not on the original query Slice and manually
        # filter by the segment Slice's start and end. If we are on "earlier" (5')
        # projection segments, we only limit by the *end* and when we are on the later
        # projection segments, we filter by the *start*.
        
        # This is the same as fetch_all_by_Slice_constraint()'s in-memory filtering
        # except we need to alter projected features in that code with an offset
        my $local_constraint = $constraint;
        if ( $seg_slice->name() ne $slice->name() ) {
            my ($limit_start, $limit_end) = (1,1); #fully constrained by default, flags are reset every iteration
            if($i == 0) {
                $limit_start = 0;
            } elsif ($i == ($segment_count - 1)) {
                $limit_end = 0; #don't check end as we are on the final projection
            }
            $local_constraint .= ' AND ' if $local_constraint;
            my @conditionals;
      
            if($limit_end) {
            # Restrict features to the end of this projection segment when after the named segment 
                push(@conditionals, sprintf('%1$s.seq_region_end <= %2$d', $table_synonym, $seg_slice->end));
            }
            if($limit_start) {
            #Do not cross the start boundary on this projection segment
                 push(@conditionals, sprintf('%1$s.seq_region_start >= %2$d', $table_synonym, $seg_slice->start));
            }
      
            $local_constraint .= join(q{ AND }, @conditionals);
        }
    
        my $count_array = $self->_get_by_Slice($seg_slice, $local_constraint, 'count');
        $count += $_ for @$count_array;
    }
    
    return $count;
}

◆ fetch_all_by_logic_name()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_logic_name ( )

  Arg [1]    : 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

◆ fetch_all_by_outward_search()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_outward_search ( )

  Arguments the same as fetch_all_nearest_by_Feature
  Arg [0]    : -MAX_RANGE : Set an upper limit on the search range, defaults to 10000 bp 
  Arg [1]    : -FEATURE ,Bio::EnsEMBL::Feature : 'Source' Feature to anchor the search for nearest Features
  Arg [2]    : -SAME_STRAND, Boolean (optional)  : Respect the strand of the source Feature with ref, only 
               returning Features on the same strand.
  Arg [3]    : -OPPOSITE_STRAND, Boolean (optional) : Find features on the opposite strand of the same
  Arg [4]    : -DOWNSTREAM/-UPSTREAM, (optional) : Search ONLY downstream or upstream from the source Feature.
               Can be omitted for searches in both directions.
  Arg [5]    : -RANGE, Int     : The size of the space to search for Features. Defaults to 1000 as a sensible starting point
  Arg [6]    : -NOT_OVERLAPPING, Boolean (optional) : Do not return Features that overlap the source Feature
  Arg [7]    : -FIVE_PRIME, Boolean (optional) : Determine range to a Feature by the 5' end, respecting strand
  Arg [8]    : -THREE_PRIME, Boolean (optional): Determine range to a Feature by the 3' end, respecting strand
  Arg [9]    : -LIMIT, Int     : The maximum number of Features to return, defaulting to one. Equally near features are all returned

  Description: Searches for features within the suggested -RANGE, and if it finds none, expands the search area
               until it satisfies -LIMIT or hits -MAX_RANGE. Useful if you don't know how far away the features
               might be, or if dealing with areas of high feature density. In the case of Variation Features, it is
               conceivable that a 2000 bp window might contain very many features, resulting in a slow and bloated
               response, thus the ability to explore outward in smaller sections can be useful.
  Returntype : Listref of [$feature,$distance]

Code:

click to view

◆ fetch_all_by_Slice()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice ( )

  Arg [1]    : Bio::EnsEMBL::Slice $slice
               the slice from which to obtain features
  Arg [2]    : (optional) string $logic_name
               the logic name of the type of features to obtain
  Example    :

$fts = $a->fetch_all_by_Slice($slice, 'Swall');

  Description: Returns a listref of features created from the database 
               which are on the Slice defined by $slice. If $logic_name is 
               defined only features with an analysis of type $logic_name 
               will be returned. 
               NOTE: only features that are entirely on the slice's seq_region
               will be returned (i.e. if they hang off the start/end of a
               seq_region they will be discarded). Features can extend over the
               slice boundaries though (in cases where you have a slice that
               doesn't span the whole seq_region).
  Returntype : listref of Bio::EnsEMBL::SeqFeatures in Slice coordinates
  Exceptions : none
  Caller     : Bio::EnsEMBL::Slice
  Status     : Stable

Code:

click to view

◆ fetch_all_by_Slice_and_score()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice_and_score ( )

  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

◆ fetch_all_by_Slice_constraint()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice_constraint ( )

  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;
 
  #Pull out here as we need to remember them & reset accordingly
  my $bind_params = $self->bind_param_generic_fetch();
 
  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::Variation::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 ) );
 
    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'} = ();
      #IMPORTANT: NEVER EVER RETURN A COPY OF THE DATA STRUCTURE.
      #           This will hold arrays of values. Since we've been doing
      #           this for so long people are expecting multiple calls
      #           to fetch_by_SliceXXXXX() methods to return the same
      #           array reference.
      return $cache->{$key};
    }
  } ## end if ( !( defined( $self...)))
 
 
  my $proj_ref = $self->_get_and_filter_Slice_projections($slice);
  my $bounds = $self->_generate_feature_bounds($slice); 
 
  # fetch features for the primary slice AND all symlinked slices
  foreach my $seg (@{$proj_ref}) {
    # re-bind the params
    $self->_bind_param_generic_fetch($bind_params); 
    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

◆ fetch_all_by_stable_id_list()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_stable_id_list ( )

  Arg [1]    : string $logic_name
               the logic name of the type of features to obtain
  Arg [2]    : Bio::EnsEMBL::Slice $slice
               the slice from which to obtain features
  Example    :

$fs = $a->fetch_all_by_stable_id_list(["ENSG00001","ENSG00002", ...]);

  Description: Returns a listref of features identified by their stable IDs.
               This method only fetches features of the same type as the calling
               adaptor. 
               Results are constrained to a slice if the slice is provided.
  Returntype : listref of Bio::EnsEMBL::Feature
  Exceptions : thrown if no stable ID list is provided.
  Caller     : General
  Status     : Stable

Code:

click to view

◆ fetch_all_nearest_by_Feature()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_nearest_by_Feature ( )

  Arg [1]    : -FEATURE ,Bio::EnsEMBL::Feature : 'Source' Feature to anchor the search for nearest Features
  Arg [2]    : -SAME_STRAND, Boolean (optional): Respect the strand of the source Feature with ref, only 
                                                 returning Features on the same strand
  Arg [3]    : -OPPOSITE_STRAND, Boolean (optional) : Find features on the opposite strand of the same
  Arg [4]    : -DOWNSTREAM/-UPSTREAM, (optional) : Search ONLY downstream or upstream from the source Feature.
               Can be omitted for searches in both directions.
  Arg [5]    : -RANGE, Int     : The size of the space to search for Features. Defaults to 1000 as a sensible starting point
  Arg [6]    : -NOT_OVERLAPPING, Boolean (optional) : Do not return Features that overlap the source Feature
  Arg [7]    : -FIVE_PRIME, Boolean (optional) : Determine range to a Feature by its 5' end, respecting strand
  Arg [8]    : -THREE_PRIME, Boolean (optional): Determine range to a Feature by its 3' end, respecting strand
  Arg [9]    : -LIMIT, Int     : The maximum number of Features to return, defaulting to one. Equally near features are all returned
  Example    :

#To fetch the gene(s) with the nearest 5' end:

$genes = $gene_adaptor->fetch_all_nearest_by_Feature(-FEATURE => $feat, -FIVE_PRIME => 1);

  Description: Gets the nearest Features to a given 'source' Feature. The Feature returned and the format of the result
               are non-obvious, please read on.

               When looking beyond the boundaries of the source Feature, the distance is measured to the nearest end 
               of that Feature to the nearby Feature's nearest end.
               If Features overlap the source Feature, then they are given a distance of zero but ordered by
               their proximity to the centre of the Feature.

               Features are found and prioritised within 1000 base pairs unless a -RANGE is given to the method. Any overlap with
               the search region is included, and the results can be restricted to upstream, downstream, forward strand or reverse

               The -FIVE_PRIME and -THREE_PRIME options allow searching for specific ends of nearby features, but still needs
               a -DOWN/UPSTREAM value and/or -NOT_OVERLAPPING to fulfil its most common application.

  Returntype : Listref containing an Arrayref of Bio::EnsEMBL::Feature objects and the distance
               [ [$feature, $distance] ... ]
  Caller     : general

Code:

click to view

sub fetch_all_nearest_by_Feature{
    my $self = shift;
    my ($ref_feature, $respect_strand, $opposite_strand, $downstream, $upstream, $search_range,$limit,$not_overlapping,$five_prime,$three_prime) =
        rearrange([qw(FEATURE SAME_STRAND OPPOSITE_STRAND DOWNSTREAM UPSTREAM RANGE LIMIT NOT_OVERLAPPING FIVE_PRIME THREE_PRIME)], @_);
    if ( !defined($search_range)) {
      $search_range ||= 1000;
    }
    $limit ||= 1;
 
    unless (defined($ref_feature) && $ref_feature->isa('Bio::EnsEMBL::Feature')) {
      throw ('fetch_all_nearest_by_Feature method requires a valid Ensembl Feature object to operate');
    }
    throw ('Do not specify both -upstream and -downstream. This is the same as no arguments') if ($upstream && $downstream);
    throw ('Do not use both -SAME_STRAND and -OPPOSITE_STRAND in one query') if ($opposite_strand && $respect_strand);
    my ($region_start,$region_end);
    
    # Define search box. Features overlapping the boundaries are found and considered
    my $slice = $ref_feature->feature_Slice;
 
    my $five_prime_expansion = 0;
    my $three_prime_expansion = 0;
    if ($upstream) {
      $five_prime_expansion = $search_range;
      $three_prime_expansion = $slice->length * -1;
      # shrinks the slice to exclude the features that do not exist beyond the end of the
      # considered feature
    } 
    elsif ($downstream) {
      $three_prime_expansion = $search_range;
      $five_prime_expansion = $slice->length * -1;
    } 
    else {
      $five_prime_expansion = $search_range;
      $three_prime_expansion = $search_range;
    }
 
    $slice = $slice->expand( $five_prime_expansion, $three_prime_expansion);
    my $sa = $self->db->get_SliceAdaptor;
    my @candidates; # Features in the search region
    @candidates = @{$self->fetch_all_by_Slice($slice)};
    if ($respect_strand) { @candidates = grep {$_->strand == $ref_feature->strand} @candidates }
    if ($opposite_strand) { @candidates = grep {$_->strand != $ref_feature->strand} @candidates }
    # When user chooses UPSTREAM/DOWNSTREAM && FIVE_PRIME/THREE_PRIME, discount any features with
    # their other end in the overlap region. fetch_all_by_Slice cannot filter these out.
    # fetch_all_by_Slice_constraint could in principle with the correct constraint.
    if (($upstream && $ref_feature->strand == 1) || ($downstream && $ref_feature->strand == -1)) {
      if ($five_prime) {
        @candidates = grep { ($_->strand == 1) ? $_->seq_region_start < $ref_feature->start : $_->seq_region_end < $ref_feature->start} @candidates;
      } elsif ($three_prime) {
        @candidates = grep { ($_->strand == 1) ? $_->seq_region_end < $ref_feature->start : $_->seq_region_start < $ref_feature->start} @candidates;
      }
    }
    if (($downstream && $ref_feature->strand == 1)|| ($upstream && $ref_feature->strand == -1)) {
      if ($five_prime) {
        @candidates = grep { ($_->strand == 1) ? $_->seq_region_start > $ref_feature->end : $_->seq_region_end > $ref_feature->end } @candidates;
      } elsif ($three_prime) {
        @candidates = grep { ($_->strand == 1) ? $_->seq_region_end > $ref_feature->end : $_->seq_region_start > $ref_feature->end } @candidates;
      }
    }
    # Then sort and prioritise the candidates
    my $finalists; # = [[feature, distance, centre-weighted distance, length, dbID],..]
    $finalists = $self->select_nearest($ref_feature,\@candidates,$limit,$not_overlapping,$five_prime,$three_prime);
    $finalists = [ map { [ splice @$_,0,2 ]} @$finalists ]; # Remove the ugly bits from the sight of users.
    return $finalists;
}

◆ fetch_Iterator_by_Slice()

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

  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);
@verbatim
         while(my $feature = $slice_iter->next && defined $feature){
           #Do something here
         }
@endverbatim

  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

◆ fetch_Iterator_by_Slice_method()

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

  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

◆ fetch_nearest_by_Feature()

public Bio::EnsEMBL::Feature Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_nearest_by_Feature ( )

  Arg [1]    : Reference Feature to start the search from
  Description: Searches iteratively outward from the starting feature until a nearby Feature is found
               If you require more than one result or more control of which features are returned, see
               fetch_all_nearest_by_Feature and fetch_all_by_outward_search. fetch_nearest_by_Feature
               is a convenience method.
  ReturnType : Bio::EnsEMBL::Feature

Code:

click to view

◆ get_seq_region_id_external()

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::get_seq_region_id_external ( )

Undocumented method

Code:

click to view

◆ get_seq_region_id_internal()

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::get_seq_region_id_internal ( )

Undocumented method

Code:

click to view

◆ new()

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

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

none

  Description: Constructor which warns if caching has been switched off
  Returntype : Bio::EnsEMBL::BaseFeatureAdaptor
  Exceptions : none
  Caller     : implementing subclass constructors
  Status     : Stable

Code:

click to view

◆ remove()

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

  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

◆ remove_by_analysis_id()

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_analysis_id ( )

Undocumented method

Code:

click to view

◆ remove_by_feature_id()

public Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_feature_id ( )

Undocumented method

Code:

click to view

◆ remove_by_Slice()

public void Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::remove_by_Slice ( )

  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

◆ select_nearest()

public Listref Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::select_nearest ( )

  Arg [1]    : Bio::Ensembl::Feature, a Feature to find the nearest neighbouring feature to.
  Arg [2]    : Listref of Features to be considered for nearness.
  Arg [3]    : Integer, limited number of Features to return. Equally near features are all returned in spite of this limit
  Arg [4]    : Boolean, Overlapping prohibition. Overlapped Features are forgotten
  Arg [5]    : Boolean, use the 5' ends of the nearby features for distance calculation
  Arg [6]    : Boolean, use the 3' ends of the nearby features for distance calculation
  Example    :

$feature_list = $feature_adaptor->select_nearest($ref_feature,\@candidates,$limit,$not_overlapping)

  Description: Take a list of possible features, and determine which is nearest. Nearness is a
               tricky concept. Beware of using the distance between Features, as it may not be the number you think
               it should be.
  Returntype : listref of Features ordered by proximity
  Caller     : BaseFeatureAdaptor->fetch_all_nearest_by_Feature

Code:

click to view

sub select_nearest {
    my $self = shift;
    my $ref_feature = shift;
    my $candidates = shift;
    my $limit = shift;
    my $not_overlapping = shift;
    my $five_prime = shift;
    my $three_prime = shift;
  
    # Convert circular coordinates to linear ones for distance calculation
    my $ref_start = ($ref_feature->start < $ref_feature->end) ? $ref_feature->start : $ref_feature->start - $ref_feature->length; # Not ->end, in case circular
    my $ref_end = $ref_feature->end;
    my $ref_midpoint = $self->_compute_midpoint($ref_feature);
 
    my $position_matrix = [];
    my $shortest_distance;
    my $adjusted_distance; # for when features overlap and we need another metric to order by
 
    foreach my $neighbour (@$candidates) {
        # rearrange coordinates into forward-stranded orientation, plus flatten circular features.
        my $neigh_start = ($neighbour->seq_region_start < $neighbour->seq_region_end) 
          ? $neighbour->seq_region_start : $neighbour->seq_region_start - $neighbour->length; # Not ->end, in case it is circular
        my $neigh_midpoint = $self->_compute_midpoint($neighbour);
        my $neigh_end = $neighbour->seq_region_end;
 
        # discard overlaps early if not required.
        next if ( $not_overlapping
          && (
               ( $neigh_start >= $ref_start && $neigh_end <= $ref_end )
            || ( $neigh_end <= $ref_end && $neigh_end >= $ref_start )
          )
        );
        my @args = ($ref_start,$ref_midpoint,$ref_end,$neigh_start,$neigh_midpoint,$neigh_end,$neighbour->strand);
        if ($five_prime || $three_prime) {
          my $five = $five_prime ? 1 : 0; # Choose 5' or 3' end
          ($shortest_distance,$adjusted_distance) = $self->_compute_prime_distance($five,@args);
          next unless ($shortest_distance || $adjusted_distance);
        }
        else {
          ($shortest_distance,$adjusted_distance) = $self->_compute_nearest_end(@args);
        }
        push @$position_matrix,[ $neighbour, $shortest_distance, $adjusted_distance, $neighbour->length, $neighbour->display_id] unless ($not_overlapping && $shortest_distance == 0);
    }
    
    # Order by distance, then centre-to-centre distance, then smallest feature first, then an arbitrary ID.
    # $position_matrix looks like this:
    # [ [ $feature, closest measure of distance, size, dbID ] ] 
    # Not proud of this line. It re-emits the original array in sorted order to favour better measures of order.
    my @ordered_matrix = map { [$_->[0],$_->[1],$_->[2],$_->[3],$_->[4]] } 
      sort { abs($a->[1]) <=> abs($b->[1]) || abs($a->[2]) <=> abs($b->[2]) || $a->[3] <=> $b->[3] || $a->[4] <=> $b->[4]} @$position_matrix;
    # Knock off unwanted hits. Equal distances are included, so more can be returned than asked for.
    @ordered_matrix = $self->_discard_excess_features_from_matrix(\@ordered_matrix,$limit);
    return \@ordered_matrix;
}

◆ start_equals_end()

public Boolean Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::start_equals_end ( )

  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

◆ store()

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

  Arg [1]    : list of Bio::EnsEMBL::SeqFeature
  Example    :

$adaptor->store(@feats);

  Description: ABSTRACT  Subclasses are responsible for implementing this 
               method.  It should take a list of features and store them in 
               the database.
  Returntype : none
  Exceptions : thrown method is not implemented by subclass
  Caller     : general
  Status     : At Risk
             : throws if called.

Code:

click to view

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

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

Public Member Functions

Detailed Description

Synopsis

Description

Member Function Documentation

◆ _check_start_end_strand()

◆ _clear_slice_feature_cache()

◆ _compute_midpoint()

◆ _compute_nearest_end()

◆ _compute_prime_distance()

◆ _create_feature()

◆ _create_feature_fast()

◆ _discard_excess_features_from_matrix()

◆ _generate_feature_bounds()

◆ _get_and_filter_Slice_projections()

◆ _get_by_Slice()

◆ _list_seq_region_ids()

◆ _max_feature_length()

◆ _pre_store()

◆ _pre_store_userdata()

◆ _remap()

◆ _seq_region_boundary_from_db()

◆ _slice_feature_cache()

◆ _slice_fetch()

◆ clear_cache()

◆ count_by_Slice_constraint()

◆ fetch_all_by_logic_name()

◆ fetch_all_by_outward_search()

◆ fetch_all_by_Slice()

◆ fetch_all_by_Slice_and_score()

◆ fetch_all_by_Slice_constraint()

◆ fetch_all_by_stable_id_list()

◆ fetch_all_nearest_by_Feature()

◆ fetch_Iterator_by_Slice()

◆ fetch_Iterator_by_Slice_method()

◆ fetch_nearest_by_Feature()

◆ get_seq_region_id_external()

◆ get_seq_region_id_internal()

◆ new()

◆ remove()

◆ remove_by_analysis_id()

◆ remove_by_feature_id()

◆ remove_by_Slice()

◆ select_nearest()

◆ start_equals_end()

◆ store()