Bio::DB::GFF::Adaptor::dbi::mysql.3pm

Langue: en

Version: 2009-03-10 (debian - 07/07/09)

Section: 3 (Bibliothèques de fonctions)

NAME

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

SYNOPSIS

See Bio::DB::GFF

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.

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.
 
 

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.

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
 
 

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.

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
 
 

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.

BUGS

none ;-)

SEE ALSO

Bio::DB::GFF, bioperl

AUTHOR

Lincoln Stein <lstein@cshl.org>.

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.