NAME

Bio::DB::GFF::Adaptor::dbi::mysql -- Database adaptor for a specific mysql schema

SYNOPSIS

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:

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
gid            group ID (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.

fgroup

This is the group table. There is one row for each group. Columns:

gid	      the group ID (integer)
gclass    the class of the group (string)
gname     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 fgroup.gid field joins with the fdata.gid field.

Examples:

mysql> select * from fgroup where gname='sjj_2L52.1';
+-------+-------------+------------+
| gid   | gclass      | gname      |
+-------+-------------+------------+
| 69736 | PCR_product | sjj_2L52.1 |
+-------+-------------+------------+
1 row in set (0.70 sec)

mysql> select fref,fstart,fstop from fdata,fgroup 
          where gclass='PCR_product' and gname = 'sjj_2L52.1' 
                and fdata.gid=fgroup.gid;
+---------------+--------+-------+
| fref          | fstart | fstop |
+---------------+--------+-------+
| CHROMOSOME_II |   1586 |  2355 |
+---------------+--------+-------+
1 row in set (0.03 sec)

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,fgroup,ftype 
       where gclass='PCR_product' 
             and gname = 'sjj_2L52.1'
             and fdata.gid=fgroup.gid
             and fdata.ftypeid=ftype.ftypeid;
+---------------+--------+-------+-------------+-----------+
| fref          | fstart | fstop | fmethod     | fsource   |
+---------------+--------+-------+-------------+-----------+
| CHROMOSOME_II |   1586 |  2355 | PCR_product | GenePairs |
+---------------+--------+-------+-------------+-----------+
1 row in set (0.08 sec)

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.

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.

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)

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.

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

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.

make_abscoord_query

Title   : make_abscoord_query
Usage   : $sth = $db->make_abscoord_query($name,$class);
Function: create query that finds the reference sequence coordinates given a landmark & classa
Returns : a DBI statement handle
Args    : name and class of landmark
Status  : protected

The statement handler should return rows containing five fields:

1. reference sequence name
2. reference sequence class
3. start position
4. stop position
5. strand ("+" or "-")

This query always returns "Sequence" as the class of the reference sequence.

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

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

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

make_features_select_part

Title   : make_features_select_part
Usage   : $string = $db->make_features_select_part()
Function: make select 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 SELECT keyword.

make_features_from_part

Title   : make_features_from_part
Usage   : $string = $db->make_features_from_part()
Function: make from 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 FROM keyword.

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.

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.

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.

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.

The current schema does not distinguish among different classes of reference sequence.

attributes

Title   : attributes
Usage   : @attributes = $db->attributes($id,$name)
Function: get the attributes on a particular feature
Returns : an array of string
Args    : feature ID
Status  : public

Some GFF version 2 files use the groups column to store a series of attribute/value pairs. In this interpretation of GFF, the first such pair is treated as the primary group for the feature; subsequent pairs are treated as attributes. Two attributes have special meaning: "Note" is for backward compatibility and is used for unstructured text remarks. "Alias" is considered as a synonym for the feature name.

If no name is provided, then attributes() returns a flattened hash, of attribute=>value pairs. This lets you do:

%attributes = $db->attributes($id);

Normally, attributes() will be called by the feature:

@notes = $feature->attributes('Note');

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.

overlap_query

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.

contains_query

Title   : contains_query
Usage   : ($query,@args) = $db->contains_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.

contained_in_query

Title   : contained_in_query
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

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.

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

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

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

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

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

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

tables

Title   : tables
Usage   : @tables = $db->tables
Function: return list of tables that belong to this module
Returns : list of tables
Args    : none
Status  : protected

This method lists the tables known to the module, namely qw(fdata fref fgroup ftype fdna fnote fmeta).

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.

default_meta_values

Title   : default_meta_values
Usage   : %values = $db->default_meta_values
Function: empty the database
Returns : a list of tag=>value pairs
Args    : none
Status  : protected

This method returns a list of tag=>value pairs that contain default meta information about the database. It is invoked by initialize() to write out the default meta values. The base class version returns an empty list.

For things to work properly, meta value names must be UPPERCASE.

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.

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.

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.

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

finish_load

Title   : finish_load
Usage   : $db->finish_load
Function: called after load_gff_line()
Returns : number of records loaded
Args    : none
Status  : protected

This method performs schema-specific cleanup after loading a set of GFF records. It finishes each of the statement handlers prepared by setup_load().

get_table_id

Title   : get_table_id
Usage   : $integer = $db->get_table_id($table,@ids)
Function: get the ID of a group or type
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 type or group. The arguments are the name of the table, and two string identifiers. For feature types, the identifiers are the method and source. For groups, the identifiers are group name and class.

This method requires that a statement handler named lookup_$table, have been created previously by setup_load(). It is here to overcome deficiencies in mysql's INSERT syntax.

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.

To install Bio::Seq, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Bio::Seq

CPAN shell

perl -MCPAN -e shell
install Bio::Seq

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

SYNOPSIS

DESCRIPTION

Data Loading Methods

new

get_dna

make_abscoord_query

make_features_by_name_where_part

make_features_by_id_where_part

make_features_by_gid_where_part

make_features_select_part

make_features_from_part

make_features_join_part

make_features_order_by_part

make_features_group_by_part

refseq_query

attributes

search_notes

overlap_query

contains_query

contained_in_query

types_query

make_types_select_part

make_types_from_part

make_types_join_part

make_types_where_part

make_types_group_part

make_classes_query

tables

schema

default_meta_values

make_meta_set_query

make_meta_get_query

setup_load

load_gff_line

finish_load

get_table_id

get_feature_id

Module Install Instructions