[Bioperl-guts-l] bioperl-live/Bio/DB/GFF/Adaptor/dbi mysqlcmap.pm,
NONE, 1.1
Ben faga
faga at pub.open-bio.org
Tue Feb 15 23:19:53 EST 2005
Update of /home/repository/bioperl/bioperl-live/Bio/DB/GFF/Adaptor/dbi
In directory pub.open-bio.org:/tmp/cvs-serv9203/Bio/DB/GFF/Adaptor/dbi
Added Files:
mysqlcmap.pm
Log Message:
This module reads from a database adapted to serve both CMap and GBrowse.
--- NEW FILE: mysqlcmap.pm ---
package Bio::DB::GFF::Adaptor::dbi::mysqlcmap;
=head1 NAME
Bio::DB::GFF::Adaptor::dbi::mysqlcmap -- Database adaptor for an integraded
CMap/GBrowse mysql schema
=head1 SYNOPSIS
See L<Bio::DB::GFF>
=cut
# a simple mysql adaptor
use strict;
use Data::Dumper;
use Bio::DB::GFF::Adaptor::dbi;
use Bio::DB::GFF::Util::Rearrange; # for rearrange()
use Bio::DB::GFF::Util::Binning;
use vars qw(@ISA);
@ISA = qw(Bio::DB::GFF::Adaptor::dbi::mysql);
require Bio::DB::GFF::Adaptor::dbi::mysql;
use constant GETSEQCOORDS =><<END;
SELECT fref,
IF(ISNULL(gclass),'Sequence',gclass),
min(fstart),
max(fstop),
fstrand,
feature_name as gname
FROM fdata,cmap_feature
WHERE cmap_feature.feature_name=?
AND cmap_feature.gclass=?
AND cmap_feature.feature_id=fdata.feature_id
GROUP BY fref,fstrand,feature_name
END
;
use constant GETALIASCOORDS =><<END;
SELECT fref,
IF(ISNULL(gclass),'Sequence',gclass),
min(fstart),
max(fstop),
fstrand,
feature_name as gname
FROM fdata,cmap_feature,fattribute,fattribute_to_feature
WHERE fattribute_to_feature.fattribute_value=?
AND cmap_feature.gclass=?
AND cmap_feature.feature_id=fdata.feature_id
AND fattribute.fattribute_name='Alias'
AND fattribute_to_feature.fattribute_id=fattribute.fattribute_id
AND fattribute_to_feature.fid=fdata.fid
GROUP BY fref,fstrand,feature_name
END
;
use constant GETALIASLIKE =><<END;
SELECT fref,
IF(ISNULL(gclass),'Sequence',gclass),
min(fstart),
max(fstop),
fstrand,
feature_name as gname
FROM fdata,cmap_feature,fattribute,fattribute_to_feature
WHERE fattribute_to_feature.fattribute_value LIKE ?
AND cmap_feature.gclass=?
AND cmap_feature.feature_id=fdata.feature_id
AND fattribute.fattribute_name='Alias'
AND fattribute_to_feature.fattribute_id=fattribute.fattribute_id
AND fattribute_to_feature.fid=fdata.fid
GROUP BY fref,fstrand,feature_name
END
;
use constant GETFORCEDSEQCOORDS =><<END;
SELECT fref,
IF(ISNULL(gclass),'Sequence',gclass),
min(fstart),
max(fstop),
fstrand
FROM fdata,cmap_feature
WHERE cmap_feature.feature_name=?
AND cmap_feature.gclass=?
AND fdata.fref=?
AND cmap_feature.feature_id=fdata.feature_id
GROUP BY fref,fstrand
END
;
use constant FULLTEXTSEARCH => <<END;
SELECT distinct gclass,feature_name,fattribute_value,MATCH(fattribute_value) AGAINST (?) as score
FROM cmap_feature,fattribute_to_feature,fdata
WHERE cmap_feature.feature_id=fdata.feature_id
AND fdata.fid=fattribute_to_feature.fid
AND MATCH(fattribute_value) AGAINST (?)
END
;
=head1 DESCRIPTION
This adaptor implements a specific mysql database schema that is
compatible with Bio::DB::GFF. It inherits from
Bio::DB::GFF::Adaptor::dbi, which itself inherits from Bio::DB::GFF.
The schema uses several tables:
=over 4
=item fdata
This is the feature data table. Its columns are:
-
fid feature ID (integer)
fref reference sequence name (string)
fstart start position relative to reference (integer)
fstop stop postion relative to reference (integer)
ftypeid feature type ID (integer)
fscore feature score (float); may be null
fstrand strand; one of "+" or "-"; may be null
fphase phase; one of 0, 1 or 2; may be null
feature_id group ID used to be 'gid' (integer)
ftarget_start for similarity features, the target start position (integer)
ftarget_stop for similarity features, the target stop position (integer)
Note that it would be desirable to normalize the reference sequence
name, since there are usually many features that share the same
reference feature. However, in the current schema, query performance
suffers dramatically when this additional join is added.
=item cmap_feature (replaces fgroup)
This is the group table. There is one row for each group. This is the
shared table between CMap and GBrowse. There are many CMap related
columns but only a few that GBrowse uses.
GBrowse Columns:
feature_id the group ID (integer)
gclass the class of the group (string)
feature_name the name of the group (string)
The group table serves multiple purposes. As you might expect, it is
used to cluster features that logically belong together, such as the
multiple exons of the same transcript. It is also used to assign a
name and class to a singleton feature. Finally, the group table is
used to identify the target of a similarity hit. This is consistent
with the way in which the group field is used in the GFF version 2
format.
The cmap_feature.feature_id field joins with the fdata.feature_id field.
Examples:
mysql> select * from cmap_feature where feature_name='sjj_2L52.1';
+--------------+-------------+--------------+
| feature_id | gclass | feature_name |
+--------------+-------------+--------------+
| 69736 | PCR_product | sjj_2L52.1 |
+--------------+-------------+--------------+
1 row in set (0.70 sec)
mysql> select fref,fstart,fstop from fdata,cmap_feature
where gclass='PCR_product' and feature_name = 'sjj_2L52.1'
and fdata.feature_id=cmap_feature.feature_id;
+---------------+--------+-------+
| fref | fstart | fstop |
+---------------+--------+-------+
| CHROMOSOME_II | 1586 | 2355 |
+---------------+--------+-------+
1 row in set (0.03 sec)
=item ftype
This table contains the feature types, one per row. Columns are:
ftypeid the feature type ID (integer)
fmethod the feature type method name (string)
fsource the feature type source name (string)
The ftype.ftypeid field joins with the fdata.ftypeid field. Example:
mysql> select fref,fstart,fstop,fmethod,fsource from fdata,cmap_feature,ftype
where gclass='PCR_product'
and feature_name = 'sjj_2L52.1'
and fdata.feature_id=cmap_feature.feature_id
and fdata.ftypeid=ftype.ftypeid;
+---------------+--------+-------+-------------+-----------+
| fref | fstart | fstop | fmethod | fsource |
+---------------+--------+-------+-------------+-----------+
| CHROMOSOME_II | 1586 | 2355 | PCR_product | GenePairs |
+---------------+--------+-------+-------------+-----------+
1 row in set (0.08 sec)
=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"
The columns of this table are:
fid feature ID (integer)
fattribute_id ID of the attribute (integer)
fattribute_value text of the attribute (text)
The fdata.fid column joins with fattribute_to_feature.fid.
=item fattribute
This table holds the normalized names of the attributes. Fields are:
fattribute_id ID of the attribute (integer)
fattribute_name Name of the attribute (varchar)
=back
=head2 Data Loading Methods
In addition to implementing the abstract SQL-generating methods of
Bio::DB::GFF::Adaptor::dbi, this module also implements the data
loading functionality of Bio::DB::GFF.
=cut
=head2 new
Title : new
Usage : $db = Bio::DB::GFF->new(@args)
Function: create a new adaptor
Returns : a Bio::DB::GFF object
Args : see below
Status : Public
The new constructor is identical to the "dbi" adaptor's new() method,
except that the prefix "dbi:mysql" is added to the database DSN identifier
automatically if it is not there already.
Argument Description
-------- -----------
-dsn the DBI data source, e.g. 'dbi:mysql:ens0040' or "ens0040"
-user username for authentication
-pass the password for authentication
=cut
#'
#Defined in mysql.pm
=head2 get_dna
Title : get_dna
Usage : $string = $db->get_dna($name,$start,$stop,$class)
Function: get DNA string
Returns : a string
Args : name, class, start and stop of desired segment
Status : Public
This method performs the low-level fetch of a DNA substring given its
name, class and the desired range. This should probably be moved to
the parent class.
=cut
sub make_features_select_part {
my $self = shift;
my $options = shift || {};
my $s;
if (my $b = $options->{bin_width}) {
$s = <<END;
fref,
1+$b*floor(fstart/$b) as fstart,
$b*(1+floor(fstart/$b)) as fstop,
IF(ISNULL(fsource),fmethod,concat(fmethod,':',fsource)),'bin',
count(*) as fscore,
'.','.','bin',
IF(ISNULL(fsource),concat(fref,':',fmethod),concat(fref,':',fmethod,':',fsource)),
NULL,NULL,NULL,NULL
END
;
} else {
$s = <<END;
fref,fstart,fstop,fsource,fmethod,fscore,fstrand,fphase,gclass,feature_name as gname,ftarget_start,ftarget_stop,fdata.fid,fdata.feature_id
END
;
}
$s .= ",count(fdata.fid)" if $options->{attributes} && keys %{$options->{attributes}}>1;
$s;
}
# IMPORTANT NOTE:
# WHETHER OR NOT THIS WORKS IS CRITICALLY DEPENDENT ON THE RELATIVE MAGNITUDE OF THE
sub make_features_from_part {
my $self = shift;
my $sparse_types = shift;
my $options = shift || {};
my $sparse_groups = $options->{sparse_groups};
my $index = $sparse_groups ? ' USE INDEX(feature_id)'
: $sparse_types ? ' USE INDEX(ftypeid)'
: '';
return $options->{attributes} ? "fdata${index},ftype,cmap_feature,fattribute,fattribute_to_feature\n"
: "fdata${index},ftype,cmap_feature\n";
}
=head2 search_notes
Title : search_notes
Usage : @search_results = $db->search_notes("full text search string",$limit)
Function: Search the notes for a text string, using mysql full-text search
Returns : array of results
Args : full text search string, and an optional row limit
Status : public
This is a mysql-specific method. Given a search string, it performs a
full-text search of the notes table and returns an array of results.
Each row of the returned array is a arrayref containing the following fields:
column 1 A Bio::DB::GFF::Featname object, suitable for passing to segment()
column 2 The text of the note
column 3 A relevance score.
=cut
# sub search_notes {
# my $self = shift;
# my ($search_string,$limit) = @_;
# my $query = FULLTEXTSEARCH;
# $query .= " limit $limit" if defined $limit;
# my $sth = $self->dbh->do_query($query,$search_string,$search_string);
# my @results;
# while (my ($class,$name,$note,$relevance) = $sth->fetchrow_array) {
# next unless $class && $name; # sorry, ignore NULL objects
# $relevance = sprintf("%.2f",$relevance); # trim long floats
# my $featname = Bio::DB::GFF::Featname->new($class=>$name);
# push @results,[$featname,$note,$relevance];
# }
# @results;
# }
################################ loading and initialization ##################################
=head2 schema
Title : schema
Usage : $schema = $db->schema
Function: return the CREATE script for the schema
Returns : a list of CREATE statemetns
Args : none
Status : protected
This method returns a list containing the various CREATE statements
needed to initialize the database tables.
=cut
sub schema {
my %schema = (
fdata =>{
table=> q{
#create table fdata (
# fid int not null auto_increment,
# fref varchar(100) not null,
# fstart int unsigned not null,
# fstop int unsigned not null,
# ftypeid int not null,
# fscore float,
# fstrand enum('+','-'),
# fphase enum('0','1','2'),
# feature_id int not null,
# ftarget_start int unsigned,
# ftarget_stop int unsigned,
# primary key(fid),
# unique index(fref,fstart,fstop,ftypeid,feature_id),
# index(ftypeid),
# index(feature_id)
#) type=MyISAM
create table fdata (
fid int not null auto_increment,
fref varchar(100) not null,
fstart int unsigned not null,
fstop int unsigned not null,
fbin double(20,6) not null,
ftypeid int not null,
fscore float,
fstrand enum('+','-'),
fphase enum('0','1','2'),
feature_id int not null,
ftarget_start int unsigned,
ftarget_stop int unsigned,
primary key(fid),
unique index(fref,fbin,fstart,fstop,ftypeid,feature_id),
index(ftypeid),
index(feature_id)
) type=MyISAM
} # fdata table
}, # fdata
ftype => {
table=> q{
create table ftype (
ftypeid int not null auto_increment,
fmethod varchar(100) not null,
fsource varchar(100),
primary key(ftypeid),
index(fmethod),
index(fsource),
unique ftype (fmethod,fsource)
)type=MyISAM
} #ftype table
}, #ftype
fdna => {
table=> q{
create table fdna (
fref varchar(100) not null,
foffset int(10) unsigned not null,
fdna longblob,
primary key(fref,foffset)
)type=MyISAM
} # fdna table
},#fdna
fmeta => {
table=> q{
create table fmeta (
fname varchar(255) not null,
fvalue varchar(255) not null,
primary key(fname)
)type=MyISAM
} # fmeta table
},#fmeta
fattribute => {
table=> q{
create table fattribute (
fattribute_id int(10) unsigned not null auto_increment,
fattribute_name varchar(255) not null,
primary key(fattribute_id)
)type=MyISAM
} #fattribute table
},#fattribute
fattribute_to_feature => {
table=> q{
create table fattribute_to_feature (
fid int(10) not null,
fattribute_id int(10) not null,
fattribute_value text,
key(fid,fattribute_id),
key(fattribute_value(48)),
fulltext(fattribute_value)
)type=MyISAM
} # fattribute_to_feature table
}, # fattribute_to_feature
);
return \%schema;
}
=head2 make_classes_query
Title : make_classes_query
Usage : ($query, at 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)';
}
=head2 setup_load
Title : setup_load
Usage : $db->setup_load
Function: called before load_gff_line()
Returns : void
Args : none
Status : protected
This method performs schema-specific initialization prior to loading a
set of GFF records. It prepares a set of DBI statement handlers to be
used in loading the data.
=cut
sub setup_load {
my $self = shift;
my $dbh = $self->features_db;
if ($self->lock_on_load) {
my @tables = map { "$_ WRITE"} $self->tables;
my $tables = join ', ', at tables;
$dbh->do("LOCK TABLES $tables");
}
my $lookup_type = $dbh->prepare_delayed('SELECT ftypeid FROM ftype WHERE fmethod=? AND fsource=?');
my $insert_type = $dbh->prepare_delayed('INSERT INTO ftype (fmethod,fsource) VALUES (?,?)');
my $lookup_group = $dbh->prepare_delayed('SELECT feature_id FROM cmap_feature WHERE feature_name=? AND gclass=?');
my $insert_group = $dbh->prepare_delayed('INSERT INTO cmap_feature (feature_name,gclass) VALUES (?,?)');
my $lookup_attribute = $dbh->prepare_delayed('SELECT fattribute_id FROM fattribute WHERE fattribute_name=?');
my $insert_attribute = $dbh->prepare_delayed('INSERT INTO fattribute (fattribute_name) VALUES (?)');
my $insert_attribute_value = $dbh->prepare_delayed('INSERT INTO fattribute_to_feature (fid,fattribute_id,fattribute_value) VALUES (?,?,?)');
my $insert_data = $dbh->prepare_delayed(<<END);
INSERT INTO fdata (fref,fstart,fstop,fbin,ftypeid,fscore,
fstrand,fphase,feature_id,ftarget_start,ftarget_stop)
VALUES(?,?,?,?,?,?,?,?,?,?,?)
END
;
$self->{load_stuff}{sth}{lookup_ftype} = $lookup_type;
$self->{load_stuff}{sth}{insert_ftype} = $insert_type;
$self->{load_stuff}{sth}{lookup_cmap_feature} = $lookup_group;
$self->{load_stuff}{sth}{insert_cmap_feature} = $insert_group;
$self->{load_stuff}{sth}{insert_fdata} = $insert_data;
$self->{load_stuff}{sth}{lookup_fattribute} = $lookup_attribute;
$self->{load_stuff}{sth}{insert_fattribute} = $insert_attribute;
$self->{load_stuff}{sth}{insert_fattribute_value} = $insert_attribute_value;
$self->{load_stuff}{types} = {};
$self->{load_stuff}{groups} = {};
$self->{load_stuff}{counter} = 0;
}
=head2 load_gff_line
Title : load_gff_line
Usage : $db->load_gff_line($fields)
Function: called to load one parsed line of GFF
Returns : true if successfully inserted
Args : hashref containing GFF fields
Status : protected
This method is called once per line of the GFF and passed a series of
parsed data items that are stored into the hashref $fields. The keys are:
ref reference sequence
source annotation source
method annotation method
start annotation start
stop annotation stop
score annotation score (may be undef)
strand annotation strand (may be undef)
phase annotation phase (may be undef)
group_class class of annotation's group (may be undef)
group_name ID of annotation's group (may be undef)
target_start start of target of a similarity hit
target_stop stop of target of a similarity hit
attributes array reference of attributes, each of which is a [tag=>value] array ref
=cut
sub load_gff_line {
my $self = shift;
my $gff = shift;
my $s = $self->{load_stuff};
my $dbh = $self->features_db;
local $dbh->{PrintError} = 0;
defined(my $typeid = $self->get_table_id('ftype', $gff->{method} => $gff->{source})) or return;
defined(my $groupid = $self->get_table_id('cmap_feature',$gff->{gname} => $gff->{gclass})) or return;
if ($gff->{stop}-$gff->{start}+1 > $self->max_bin) {
warn "$gff->{gclass}:$gff->{gname} is longer than ",$self->_maxbin,".\n";
warn "Please set the maxbin value to a larger length than the largest feature you wish to store.\n";
warn "With the command-line tools you do with this with --maxfeature option.\n";
}
my $bin = bin($gff->{start},$gff->{stop},$self->min_bin);
my $result = $s->{sth}{insert_fdata}->execute($gff->{ref},
$gff->{start},$gff->{stop},$bin,
$typeid,
$gff->{score},$gff->{strand},$gff->{phase},
$groupid,
$gff->{tstart},$gff->{tstop});
warn $dbh->errstr,"\n" && return unless $result;
my $fid = $dbh->{mysql_insertid}
|| $self->get_feature_id($gff->{ref},$gff->{start},$gff->{stop},$typeid,$groupid);
# insert attributes
foreach (@{$gff->{attributes}}) {
defined(my $attribute_id = $self->get_table_id('fattribute',$_->[0])) or return;
$s->{sth}{insert_fattribute_value}->execute($fid,$attribute_id,$_->[1]);
}
if ( (++$s->{counter} % 1000) == 0) {
print STDERR "$s->{counter} records loaded...";
print STDERR -t STDOUT && !$ENV{EMACS} ? "\r" : "\n";
}
$fid;
}
=head2 get_feature_id
Title : get_feature_id
Usage : $integer = $db->get_feature_id($ref,$start,$stop,$typeid,$groupid)
Function: get the ID of a feature
Returns : an integer ID or undef
Args : none
Status : private
This internal method is called by load_gff_line to look up the integer
ID of an existing feature. It is ony needed when replacing a feature
with new information.
=cut
# this method is called when needed to look up a feature's ID
sub get_feature_id {
my $self = shift;
my ($ref,$start,$stop,$typeid,$groupid) = @_;
my $s = $self->{load_stuff};
unless ($s->{get_feature_id}) {
my $dbh = $self->features_db;
$s->{get_feature_id} =
$dbh->prepare_delayed('SELECT fid FROM fdata WHERE fref=? AND fstart=? AND fstop=? AND ftypeid=? AND feature_id=?');
}
my $sth = $s->{get_feature_id} or return;
$sth->execute($ref,$start,$stop,$typeid,$groupid) or return;
my ($fid) = $sth->fetchrow_array;
return $fid;
}
#-----------------------------------
=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/*/%/;
return ("cmap_feature.gclass=? AND cmap_feature.feature_name LIKE ?",$class,$name);
} else {
return ("cmap_feature.gclass=? AND cmap_feature.feature_name=?",$class,$name);
}
}
=head2 make_features_join_part
Title : make_features_join_part
Usage : $string = $db->make_features_join_part()
Function: make join part of the features query
Returns : a string
Args : none
Status : protected
This method creates the part of the features query that immediately
follows the WHERE keyword.
=cut
sub make_features_join_part {
my $self = shift;
my $options = shift || {};
return !$options->{attributes} ? <<END1 : <<END2;
cmap_feature.feature_id = fdata.feature_id
AND ftype.ftypeid = fdata.ftypeid
END1
cmap_feature.feature_id = fdata.feature_id
AND ftype.ftypeid = fdata.ftypeid
AND fattribute.fattribute_id=fattribute_to_feature.fattribute_id
AND fdata.fid=fattribute_to_feature.fid
END2
}
sub getseqcoords_query {
my $self = shift;
return GETSEQCOORDS ;
}
sub getaliascoords_query{
my $self = shift;
return GETALIASCOORDS ;
}
sub getforcedseqcoords_query{
my $self = shift;
return GETFORCEDSEQCOORDS ;
}
sub getaliaslike_query{
my $self = shift;
return GETALIASLIKE ;
}
=head2 search_notes
Title : search_notes
Usage : @search_results = $db->search_notes("full text search string",$limit)
Function: Search the notes for a text string, using mysql full-text search
Returns : array of results
Args : full text search string, and an optional row limit
Status : public
This is a mysql-specific method. Given a search string, it performs a
full-text search of the notes table and returns an array of results.
Each row of the returned array is a arrayref containing the following fields:
column 1 A Bio::DB::GFF::Featname object, suitable for passing to segment()
column 2 The text of the note
column 3 A relevance score.
=cut
sub search_notes {
my $self = shift;
my ($search_string,$limit) = @_;
my @words = $search_string =~ /(\w+)/g;
my $regex = join '|', at words;
my @searches = map {"fattribute_value LIKE '%${_}%'"} @words;
my $search = join(' OR ', at searches);
my $query = <<END;
SELECT distinct gclass,feature_name as gname,fattribute_value
FROM cmap_feature,fattribute_to_feature,fdata
WHERE cmap_feature.feature_id=fdata.feature_id
AND fdata.fid=fattribute_to_feature.fid
END
;
$query .= " AND ($search) " if ($search);
my $sth = $self->dbh->do_query($query);
my @results;
while (my ($class,$name,$note) = $sth->fetchrow_array) {
next unless $class && $name; # sorry, ignore NULL objects
my @matches = $note =~ /($regex)/g;
my $relevance = 10*@matches;
my $featname = Bio::DB::GFF::Featname->new($class=>$name);
push @results,[$featname,$note,$relevance];
last if $limit && @results >= $limit;
}
@results;
}
=head2 make_features_order_by_part
Title : make_features_order_by_part
Usage : ($query, at 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 "cmap_feature.feature_name";
}
1;
__END__
=head1 BUGS
none ;-)
=head1 SEE ALSO
L<Bio::DB::GFF>, L<bioperl>
=head1 AUTHOR
Ben Faga E<lt>faga at cshl.orgE<gt>.
Modified from mysql.pm by:
Lincoln Stein E<lt>lstein at cshl.orgE<gt>.
Copyright (c) 2002 Cold Spring Harbor Laboratory.
This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.
=cut
More information about the Bioperl-guts-l
mailing list