Bio-DB-GFF
view release on metacpan or search on metacpan
lib/Bio/DB/GFF.pm view on Meta::CPAN
sequence similarity hits, and miscellaneous notes. See the next
section for a description of how to describe similarity targets.
The format of the group fields is "Class ID" with a single space (not
a tab) separating the class from the ID. It is VERY IMPORTANT to
follow this format, or grouping will not work properly.
=back
The sequences used to establish the coordinate system for annotations
can correspond to sequenced clones, clone fragments, contigs or
super-contigs. Thus, this module can be used throughout the lifecycle
of a sequencing project.
In addition to a group ID, the GFF format allows annotations to have a
group class. For example, in the ACeDB representation, RNA
interference experiments have a class of "RNAi" and an ID that is
unique among the RNAi experiments. Since not all databases support
this notion, the class is optional in all calls to this module, and
defaults to "Sequence" when not provided.
lib/Bio/DB/GFF.pm view on Meta::CPAN
-off,-len Aliases for -offset and -length
-seqclass Alias for -class
Here's an example to explain how this works:
my $db = Bio::DB::GFF->new(-dsn => 'dbi:mysql:human',-adaptor=>'dbi::mysql');
If successful, $db will now hold the database accessor object. We now
try to fetch the fragment of sequence whose ID is A0000182 and class
is "Accession."
my $segment = $db->segment(-name=>'A0000182',-class=>'Accession');
If successful, $segment now holds the entire segment corresponding to
this accession number. By default, the sequence is used as its own
reference sequence, so its first base will be 1 and its last base will
be the length of the accession.
Assuming that this sequence belongs to a longer stretch of DNA, say a
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
$sth = $self->dbh->do_query('select fdna,foffset from fdna where fref=? and foffset>=? order by foffset',
$ref,$offset_start);
}
else { # both start and stop defined
$sth = $self->dbh->do_query('select fdna,foffset from fdna where fref=? and foffset>=? and foffset<=? order by foffset',
$ref,$offset_start,$offset_stop);
}
my $dna = '';
while (my($frag,$offset) = $sth->fetchrow_array) {
substr($frag,0,$start-$offset) = '' if $has_start && $start > $offset;
$dna .= $frag;
}
substr($dna,$stop-$start+1) = '' if $has_stop && $stop-$start+1 < length($dna);
if ($reversed) {
$dna = reverse $dna;
$dna =~ tr/gatcGATC/ctagCTAG/;
}
$sth->finish;
$dna;
}
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
while (my ($c) = $sth->fetchrow_array) {
push @classes,$c;
}
@classes;
}
=head2 make_classes_query
Title : make_classes_query
Usage : ($query,@args) = $db->make_classes_query
Function: return query fragment for generating list of reference classes
Returns : a query and args
Args : none
Status : public
=cut
sub make_classes_query {
my $self = shift;
return;
}
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
($q1,@args) = make_types_select_part(@args);
($q2,@args) = make_types_from_part(@args);
($q3,@args) = make_types_where_part(@args);
($q4,@args) = make_types_join_part(@args);
($q5,@args) = make_types_group_part(@args);
The components are then combined as follows:
$query = "SELECT $q1 FROM $q2 WHERE $q3 AND $q4 GROUP BY $q5";
If any of the query fragments contain the ? bind variable, then the
same number of bind arguments must be provided in @args. The
fragment-generating functions are described below.
=cut
sub get_types {
my $self = shift;
my ($srcseq,$class,$start,$stop,$want_count,$typelist) = @_;
my $straight = $self->do_straight_join($srcseq,$start,$stop,[]) ? 'straight_join' : '';
my ($select,@args1) = $self->make_types_select_part($srcseq,$start,$stop,$want_count,$typelist);
my ($from,@args2) = $self->make_types_from_part($srcseq,$start,$stop,$want_count,$typelist);
my ($join,@args3) = $self->make_types_join_part($srcseq,$start,$stop,$want_count,$typelist);
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
to similarly-named arguments passed to range_query().
=cut
sub do_straight_join { 0 } # false by default
=head2 string_match
Title : string_match
Usage : $string = $db->string_match($field,$value)
Function: create a SQL fragment for performing exact or regexp string matching
Returns : query string
Args : the table field and match value
Status : public
This method examines the passed value for meta characters. If so it
produces a SQL fragment that performs a regular expression match.
Otherwise, it produces a fragment that performs an exact string match.
This method is not used in the module, but is available for use by
subclasses.
=cut
sub string_match {
my $self = shift;
my ($field,$value) = @_;
return qq($field = ?) if $value =~ /^[!@%&a-zA-Z0-9_\'\" ~-]+$/;
return qq($field REGEXP ?);
}
=head2 exact_match
Title : exact_match
Usage : $string = $db->exact_match($field,$value)
Function: create a SQL fragment for performing exact string matching
Returns : query string
Args : the table field and match value
Status : public
This method produces the SQL fragment for matching a field name to a
constant string value.
=cut
sub exact_match {
my $self = shift;
my ($field,$value) = @_;
return qq($field = ?);
}
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
Usage : $value = $db->meta($name [,$newval])
Function: get or set a meta variable
Returns : a string
Args : meta variable name and optionally value
Status : public
Get or set a named metavariable for the database. Metavariables can
be used for database-specific settings. This method calls two
class-specific methods which must be implemented:
make_meta_get_query() Returns a sql fragment which given a meta
parameter name, returns its value. One bind
variable.
make_meta_set_query() Returns a sql fragment which takes two bind
arguments, the parameter name and its value
Don't make changes unless you know what you're doing! It will affect the
persistent database.
=cut
sub meta {
my $self = shift;
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
$sth->finish;
return $self->{meta}{$param_name} = $value;
}
}
=head2 make_meta_get_query
Title : make_meta_get_query
Usage : $sql = $db->make_meta_get_query
Function: return SQL fragment for getting a meta parameter
Returns : SQL fragment
Args : none
Status : public
By default this does nothing; meta parameters are not stored or
retrieved.
=cut
sub make_meta_get_query {
return 'SELECT fvalue FROM fmeta WHERE fname=?';
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
sub dna_chunk_size {
my $self = shift;
$self->meta('chunk_size') || DNA_CHUNK_SIZE;
}
=head2 make_meta_set_query
Title : make_meta_set_query
Usage : $sql = $db->make_meta_set_query
Function: return SQL fragment for setting a meta parameter
Returns : SQL fragment
Args : none
Status : public
By default this does nothing; meta parameters are not stored or
retrieved.
=cut
sub make_meta_set_query {
return;
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
sub clone {
my $self = shift;
$self->features_db->clone;
}
=head1 QUERIES TO IMPLEMENT
The following astract methods either return DBI statement handles or
fragments of SQL. They must be implemented by subclasses of this
module. See Bio::DB::GFF::Adaptor::dbi::mysql for examples.
=head2 drop_other_schema_objects
Title : drop_other_schema_objects
Usage : $self->create_other_schema_objects($table_name)
Function: create other schema objects like : indexes, sequences, triggers
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
#########################################
## Moved from mysql.pm and mysqlopt.pm ##
#########################################
=head2 make_features_by_name_where_part
Title : make_features_by_name_where_part
Usage : $db->make_features_by_name_where_part
Function: create the SQL fragment needed to select a feature by its group name & class
Returns : a SQL fragment and bind arguments
Args : see below
Status : Protected
=cut
sub make_features_by_name_where_part {
my $self = shift;
my ($class,$name) = @_;
if ($name =~ /\*/) {
$name =~ s/%/\\%/g;
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
push @sql,"(fattribute.fattribute_name=? AND fattribute_to_feature.fattribute_value=?)";
push @args,($_,$attributes->{$_});
}
return (join(' OR ',@sql),@args);
}
=head2 make_features_by_id_where_part
Title : make_features_by_id_where_part
Usage : $db->make_features_by_id_where_part($ids)
Function: create the SQL fragment needed to select a set of features by their ids
Returns : a SQL fragment and bind arguments
Args : arrayref of IDs
Status : Protected
=cut
sub make_features_by_id_where_part {
my $self = shift;
my $ids = shift;
my $set = join ",",@$ids;
return ("fdata.fid IN ($set)");
}
=head2 make_features_by_gid_where_part
Title : make_features_by_id_where_part
Usage : $db->make_features_by_gid_where_part($ids)
Function: create the SQL fragment needed to select a set of features by their ids
Returns : a SQL fragment and bind arguments
Args : arrayref of IDs
Status : Protected
=cut
sub make_features_by_gid_where_part {
my $self = shift;
my $ids = shift;
my $set = join ",",@$ids;
return ("fgroup.gid IN ($set)");
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
AND fattribute.fattribute_id=fattribute_to_feature.fattribute_id
AND fdata.fid=fattribute_to_feature.fid
END2
}
=head2 make_features_order_by_part
Title : make_features_order_by_part
Usage : ($query,@args) = $db->make_features_order_by_part()
Function: make the ORDER BY part of the features() query
Returns : a SQL fragment and bind arguments, if any
Args : none
Status : protected
This method creates the part of the features query that immediately
follows the ORDER BY part of the query issued by features() and
related methods.
=cut
sub make_features_order_by_part {
my $self = shift;
my $options = shift || {};
return "fgroup.gname";
}
=head2 make_features_group_by_part
Title : make_features_group_by_part
Usage : ($query,@args) = $db->make_features_group_by_part()
Function: make the GROUP BY part of the features() query
Returns : a SQL fragment and bind arguments, if any
Args : none
Status : protected
This method creates the part of the features query that immediately
follows the GROUP BY part of the query issued by features() and
related methods.
=cut
sub make_features_group_by_part {
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
elsif (my $b = $options->{bin_width}) {
return "fref,fstart,fdata.ftypeid";
}
}
=head2 refseq_query
Title : refseq_query
Usage : ($query,@args) = $db->refseq_query($name,$class)
Function: create SQL fragment that selects the desired reference sequence
Returns : a list containing the query and bind arguments
Args : reference sequence name and class
Status : protected
This method is called by make_features_by_range_where_part() to
construct the part of the select WHERE section that selects a
particular reference sequence. It returns a mult-element list in
which the first element is the SQL fragment and subsequent elements
are bind values.
For example:
sub refseq_query {
my ($name,$class) = @_;
return ('gff.refseq=? AND gff.refclass=?',
$name,$class);
}
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
$sth->finish;
return @result;
}
=head2 overlap_query_nobin
Title : overlap_query
Usage : ($query,@args) = $db->overlap_query($start,$stop)
Function: create SQL fragment that selects the desired features by range
Returns : a list containing the query and bind arguments
Args : the start and stop of a range, inclusive
Status : protected
This method is called by make_features_byrange_where_part() to construct the
part of the select WHERE section that selects a set of features that
overlap a range. It returns a multi-element list in which the first
element is the SQL fragment and subsequent elements are bind values.
sub overlap_query_nobin {
my ($start,$stop) = @_;
return ('gff.stopE<gt>=? AND gff.startE<lt>=?',
$start,$stop);
=cut
# find features that overlap a given range
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
my ($start,$stop) = @_;
my $query = qq(fdata.fstop>=? AND fdata.fstart<=?);
return wantarray ? ($query,$start,$stop) : $self->dbh->dbi_quote($query,$start,$stop);
}
=head2 contains_query_nobin
Title : contains_query
Usage : ($query,@args) = $db->contains_query_nobin($start,$stop)
Function: create SQL fragment that selects the desired features by range
Returns : a list containing the query and bind arguments
Args : the start and stop of a range, inclusive
Status : protected
This method is called by make_features_byrange_where_part() to construct the
part of the select WHERE section that selects a set of features
entirely enclosed by a range. It returns a multi-element list in which
the first element is the SQL fragment and subsequent elements are bind
values. For example:
sub contains_query_nobin {
my ($start,$stop) = @_;
return ('gff.start>=? AND gff.stop<=?',
$start,$stop);
=cut
# find features that are completely contained within a range
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
my $self = shift;
my ($start,$stop) = @_;
my $query = qq(fdata.fstart>=? AND fdata.fstop<=?);
return wantarray ? ($query,$start,$stop) : $self->dbh->dbi_quote($query,$start,$stop);
}
=head2 contained_in_query_nobin
Title : contained_in_query_nobin
Usage : ($query,@args) = $db->contained_in_query($start,$stop)
Function: create SQL fragment that selects the desired features by range
Returns : a list containing the query and bind arguments
Args : the start and stop of a range, inclusive
Status : protected
This method is called by make_features_byrange_where_part() to construct the
part of the select WHERE section that selects a set of features
entirely enclosed by a range. It returns a multi-element list in which
the first element is the SQL fragment and subsequent elements are bind
values.For example:
sub contained_in_query_nobin {
my ($start,$stop) = @_;
return ('gff.start<=? AND gff.stop>=?',
$start,$stop);
}
=cut
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
my $self = shift;
my ($start,$stop) = @_;
my $query = qq(fdata.fstart<=? AND fdata.fstop>=?);
return wantarray ? ($query,$start,$stop) : $self->dbh->dbi_quote($query,$start,$stop);
}
=head2 types_query
Title : types_query
Usage : ($query,@args) = $db->types_query($types)
Function: create SQL fragment that selects the desired features by type
Returns : a list containing the query and bind arguments
Args : an array reference containing the types
Status : protected
This method is called by make_features_byrange_where_part() to construct the
part of the select WHERE section that selects a set of features based
on their type. It returns a multi-element list in which the first
element is the SQL fragment and subsequent elements are bind values.
The argument is an array reference containing zero or more
[$method,$source] pairs.
=cut
# generate the fragment of SQL responsible for searching for
# features with particular types and methods
sub types_query {
my $self = shift;
my $types = shift;
my @method_queries;
my @args;
for my $type (@$types) {
my ($method,$source) = @$type;
my ($mlike, $slike) = (0, 0);
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
=head2 make_types_select_part
Title : make_types_select_part
Usage : ($string,@args) = $db->make_types_select_part(@args)
Function: create the select portion of the SQL for fetching features type list
Returns : query string and bind arguments
Args : see below
Status : protected
This method is called by get_types() to generate the query fragment
and bind arguments for the SELECT part of the query that retrieves
lists of feature types. The four positional arguments are as follows:
$refseq reference sequence name
$start start of region
$stop end of region
$want_count true to return the count of this feature type
If $want_count is false, the SQL fragment returned must produce a list
of feature types in the format (method, source).
If $want_count is true, the returned fragment must produce a list of
feature types in the format (method, source, count).
=cut
#------------------------- support for the types() query ------------------------
sub make_types_select_part {
my $self = shift;
my ($srcseq,$start,$stop,$want_count) = @_;
my $query = $want_count ? 'ftype.fmethod,ftype.fsource,count(fdata.ftypeid)'
: 'fmethod,fsource';
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
=head2 make_types_from_part
Title : make_types_from_part
Usage : ($string,@args) = $db->make_types_from_part(@args)
Function: create the FROM portion of the SQL for fetching features type lists
Returns : query string and bind arguments
Args : see below
Status : protected
This method is called by get_types() to generate the query fragment
and bind arguments for the FROM part of the query that retrieves lists
of feature types. The four positional arguments are as follows:
$refseq reference sequence name
$start start of region
$stop end of region
$want_count true to return the count of this feature type
If $want_count is false, the SQL fragment returned must produce a list
of feature types in the format (method, source).
If $want_count is true, the returned fragment must produce a list of
feature types in the format (method, source, count).
=cut
sub make_types_from_part {
my $self = shift;
my ($srcseq,$start,$stop,$want_count) = @_;
my $query = defined($srcseq) || $want_count ? 'fdata,ftype' : 'ftype';
return $query;
}
=head2 make_types_join_part
Title : make_types_join_part
Usage : ($string,@args) = $db->make_types_join_part(@args)
Function: create the JOIN portion of the SQL for fetching features type lists
Returns : query string and bind arguments
Args : see below
Status : protected
This method is called by get_types() to generate the query fragment
and bind arguments for the JOIN part of the query that retrieves lists
of feature types. The four positional arguments are as follows:
$refseq reference sequence name
$start start of region
$stop end of region
$want_count true to return the count of this feature type
=cut
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
=head2 make_types_where_part
Title : make_types_where_part
Usage : ($string,@args) = $db->make_types_where_part(@args)
Function: create the WHERE portion of the SQL for fetching features type lists
Returns : query string and bind arguments
Args : see below
Status : protected
This method is called by get_types() to generate the query fragment
and bind arguments for the WHERE part of the query that retrieves
lists of feature types. The four positional arguments are as follows:
$refseq reference sequence name
$start start of region
$stop end of region
$want_count true to return the count of this feature type
=cut
lib/Bio/DB/GFF/Adaptor/dbi.pm view on Meta::CPAN
=head2 make_types_group_part
Title : make_types_group_part
Usage : ($string,@args) = $db->make_types_group_part(@args)
Function: create the GROUP BY portion of the SQL for fetching features type lists
Returns : query string and bind arguments
Args : see below
Status : protected
This method is called by get_types() to generate the query fragment
and bind arguments for the GROUP BY part of the query that retrieves
lists of feature types. The four positional arguments are as follows:
$refseq reference sequence name
$start start of region
$stop end of region
$want_count true to return the count of this feature type
=cut
lib/Bio/DB/GFF/Adaptor/dbi/mysql.pm view on Meta::CPAN
=item fdna
This table holds the raw DNA of the reference sequences. It has three
columns:
fref reference sequence name (string)
foffset offset of this sequence
fdna the DNA sequence (longblob)
To overcome problems loading large blobs, DNA is automatically
fragmented into multiple segments when loading, and the position of
each segment is stored in foffset. The fragment size is controlled by
the -clump_size argument during initialization.
=item fattribute_to_feature
This table holds "attributes", which are tag/value pairs stuffed into
the GFF line. The first tag/value pair is treated as the group, and
anything else is treated as an attribute (weird, huh?).
CHR_I assembly_tag Finished 2032 2036 . + . Note "Right: cTel33B"
CHR_I assembly_tag Polymorphism 668 668 . + . Note "A->C in cTel33B"
lib/Bio/DB/GFF/Adaptor/dbi/mysql.pm view on Meta::CPAN
);
return \%schema;
}
=head2 make_classes_query
Title : make_classes_query
Usage : ($query,@args) = $db->make_classes_query
Function: return query fragment for generating list of reference classes
Returns : a query and args
Args : none
Status : public
=cut
sub make_classes_query {
my $self = shift;
return 'SELECT DISTINCT gclass FROM fgroup WHERE NOT ISNULL(gclass)';
}
=head2 make_meta_set_query
Title : make_meta_set_query
Usage : $sql = $db->make_meta_set_query
Function: return SQL fragment for setting a meta parameter
Returns : SQL fragment
Args : none
Status : public
By default this does nothing; meta parameters are not stored or
retrieved.
=cut
sub make_meta_set_query {
return 'REPLACE INTO fmeta VALUES (?,?)';
lib/Bio/DB/GFF/Adaptor/dbi/mysqlcmap.pm view on Meta::CPAN
=item fdna
This table holds the raw DNA of the reference sequences. It has three
columns:
fref reference sequence name (string)
foffset offset of this sequence
fdna the DNA sequence (longblob)
To overcome problems loading large blobs, DNA is automatically
fragmented into multiple segments when loading, and the position of
each segment is stored in foffset. The fragment size is controlled by
the -clump_size argument during initialization.
=item fattribute_to_feature
This table holds "attributes", which are tag/value pairs stuffed into
the GFF line. The first tag/value pair is treated as the group, and
anything else is treated as an attribute (weird, huh?).
CHR_I assembly_tag Finished 2032 2036 . + . Note "Right: cTel33B"
CHR_I assembly_tag Polymorphism 668 668 . + . Note "A->C in cTel33B"
lib/Bio/DB/GFF/Adaptor/dbi/mysqlcmap.pm view on Meta::CPAN
);
return \%schema;
}
=head2 make_classes_query
Title : make_classes_query
Usage : ($query,@args) = $db->make_classes_query
Function: return query fragment for generating list of reference classes
Returns : a query and args
Args : none
Status : public
=cut
sub make_classes_query {
my $self = shift;
return 'SELECT DISTINCT gclass FROM cmap_feature WHERE NOT ISNULL(gclass)';
}
lib/Bio/DB/GFF/Adaptor/dbi/mysqlcmap.pm view on Meta::CPAN
}
#-----------------------------------
=head2 make_features_by_name_where_part
Title : make_features_by_name_where_part
Usage : $db->make_features_by_name_where_part
Function: create the SQL fragment needed to select a feature by its group name & class
Returns : a SQL fragment and bind arguments
Args : see below
Status : Protected
=cut
sub make_features_by_name_where_part {
my $self = shift;
my ($class,$name) = @_;
if ($name =~ /\*/) {
$name =~ tr/*/%/;
lib/Bio/DB/GFF/Adaptor/dbi/mysqlcmap.pm view on Meta::CPAN
# push @results,[$featname,$note,$relevance];
# }
# @results;
# }
=head2 make_features_order_by_part
Title : make_features_order_by_part
Usage : ($query,@args) = $db->make_features_order_by_part()
Function: make the ORDER BY part of the features() query
Returns : a SQL fragment and bind arguments, if any
Args : none
Status : protected
This method creates the part of the features query that immediately
follows the ORDER BY part of the query issued by features() and
related methods.
=cut
sub make_features_order_by_part {
lib/Bio/DB/GFF/Adaptor/dbi/oracle.pm view on Meta::CPAN
=item fdna
This table holds the raw DNA of the reference sequences. It has three
columns:
fref reference sequence name (string)
foffset offset of this sequence
fdna the DNA sequence (longblob)
To overcome problems loading large blobs, DNA is automatically
fragmented into multiple segments when loading, and the position of
each segment is stored in foffset. The fragment size is controlled by
the -clump_size argument during initialization.
=item fattribute_to_feature
This table holds "attributes", which are tag/value pairs stuffed into
the GFF line. The first tag/value pair is treated as the group, and
anything else is treated as an attribute (weird, huh?).
CHR_I assembly_tag Finished 2032 2036 . + . Note "Right: cTel33B"
CHR_I assembly_tag Polymorphism 668 668 . + . Note "A->C in cTel33B"
lib/Bio/DB/GFF/Adaptor/dbi/oracle.pm view on Meta::CPAN
push @results,[$featname,$note,$relevance,$type];
last if $limit && @results >= $limit;
}
@results;
}
=head2 make_meta_set_query
Title : make_meta_set_query
Usage : $sql = $db->make_meta_set_query
Function: return SQL fragment for setting a meta parameter
Returns : SQL fragment
Args : none
Status : public
By default this does nothing; meta parameters are not stored or
retrieved.
=cut
sub make_meta_set_query {
return 'INSERT INTO fmeta VALUES (?,?)';
lib/Bio/DB/GFF/Adaptor/dbi/pg.pm view on Meta::CPAN
=item fdna
This table holds the raw DNA of the reference sequences. It has three
columns:
fref reference sequence name (string)
foffset offset of this sequence
fdna the DNA sequence (longblob)
To overcome problems loading large blobs, DNA is automatically
fragmented into multiple segments when loading, and the position of
each segment is stored in foffset. The fragment size is controlled by
the -clump_size argument during initialization.
=item fattribute_to_feature
This table holds "attributes", which are tag/value pairs stuffed into
the GFF line. The first tag/value pair is treated as the group, and
anything else is treated as an attribute (weird, huh?).
CHR_I assembly_tag Finished 2032 2036 . + . Note "Right: cTel33B"
CHR_I assembly_tag Polymorphism 668 668 . + . Note "A->C in cTel33B"
lib/Bio/DB/GFF/Adaptor/dbi/pg.pm view on Meta::CPAN
# warn @results;
#
# return @results;
}
=head2 make_meta_set_query
Title : make_meta_set_query
Usage : $sql = $db->make_meta_set_query
Function: return SQL fragment for setting a meta parameter
Returns : SQL fragment
Args : none
Status : public
By default this does nothing; meta parameters are not stored or
retrieved.
=cut
sub make_meta_set_query {
return 'INSERT INTO fmeta VALUES (?,?)';
lib/Bio/DB/GFF/Adaptor/dbi/pg.pm view on Meta::CPAN
1;
}
=head2 make_features_by_name_where_part
Title : make_features_by_name_where_part
Usage : $db->make_features_by_name_where_part
Function: Overrides a function in Bio::DB::GFF::Adaptor::dbi to insure
that searches will be case insensitive. It creates the SQL
fragment needed to select a feature by its group name & class
Returns : a SQL fragment and bind arguments
Args : see below
Status : Protected
=cut
sub make_features_by_name_where_part {
my $self = shift;
my ($class,$name) = @_;
if ($name !~ /\*/) {
lib/Bio/DB/GFF/Adaptor/dbi/pg.pm view on Meta::CPAN
$sth = $self->dbh->do_query('select fdna,foffset from fdna where lower(fref)=lower(?) and foffset>=? order by foffset',
$ref,$offset_start);
}
else { # both start and stop defined
$sth = $self->dbh->do_query('select fdna,foffset from fdna where lower(fref)=lower(?) and foffset>=? and foffset<=? order by foffset',
$ref,$offset_start,$offset_stop);
}
my $dna = '';
while (my($frag,$offset) = $sth->fetchrow_array) {
substr($frag,0,$start-$offset) = '' if $has_start && $start > $offset;
$dna .= $frag;
}
substr($dna,$stop-$start+1) = '' if $has_stop && $stop-$start+1 < length($dna);
if ($reversed) {
$dna = reverse $dna;
$dna =~ tr/gatcGATC/ctagCTAG/;
}
$sth->finish;
$dna;
}
( run in 1.115 second using v1.01-cache-2.11-cpan-364913b4093 )