[Bio] / SeedViewer / MetagenomeAnalysis.pm Repository:
ViewVC logotype

Annotation of /SeedViewer/MetagenomeAnalysis.pm

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.16 - (view) (download) (as text)

1 : paarmann 1.1 package SeedViewer::MetagenomeAnalysis;
2 :    
3 : paczian 1.14 # $Id: MetagenomeAnalysis.pm,v 1.13 2008/06/11 21:17:56 olson Exp $
4 : paarmann 1.1
5 :     use strict;
6 :     use warnings;
7 :    
8 :     use FIG_Config;
9 :     use DBI;
10 : olson 1.13 use Data::Dumper;
11 : paarmann 1.1
12 :     1;
13 :    
14 : paarmann 1.3 use constant QUERY_DEFAULTS =>
15 :     { 1 => { evalue => '1e-05', align_len => 50 }, # RDP
16 :     2 => { evalue => '0.01' }, # SEED
17 :     3 => { evalue => '1e-05', align_len => 50 }, # Greengenes
18 :     4 => { evalue => '1e-05', align_len => 50 }, # LSU
19 :     5 => { evalue => '1e-05', align_len => 50 }, # SSU
20 :     6 => { evalue => '0.01' }, # Subsystem
21 :     };
22 :    
23 : paarmann 1.1 sub new {
24 :     my ($class, $job) = @_;
25 :    
26 :     # check job
27 :     unless (ref $job and $job->isa('RAST::Job') and $job->metagenome) {
28 :     return undef;
29 :     }
30 :    
31 :     # connect to database
32 :     my $dbh;
33 :     eval {
34 :    
35 : olson 1.7 my $dbms = $FIG_Config::mgrast_dbms;
36 : paarmann 1.1 my $host = $FIG_Config::mgrast_dbhost;
37 :     my $database = $FIG_Config::mgrast_db;
38 :     my $user = $FIG_Config::mgrast_dbuser;
39 :     my $password = '';
40 : olson 1.7
41 :     if ($dbms eq 'Pg')
42 :     {
43 : jared 1.8 $dbh = DBI->connect("DBI:Pg:dbname=$database;host=$host", $user, $password,
44 : olson 1.7 { RaiseError => 1, AutoCommit => 0, PrintError => 0 }) ||
45 :     die "database connect error.";
46 :     }
47 :     elsif ($dbms eq 'mysql' or $dbms eq '') # Default to mysql
48 :     {
49 :     $dbh = DBI->connect("DBI:mysql:database=$database;host=$host", $user, $password,
50 : paarmann 1.1 { RaiseError => 1, AutoCommit => 0, PrintError => 0 }) ||
51 : olson 1.7 die "database connect error.";
52 :     }
53 :     else
54 :     {
55 :     die "MetagenomeAnalysis: unknown dbms '$dbms'";
56 :     }
57 :    
58 : paarmann 1.1 };
59 :     if ($@) {
60 :     warn "Unable to connect to metagenomics database: $@\n";
61 :     return undef;
62 :     }
63 :    
64 :     # create object
65 :     my $self = { job => $job,
66 :     dbh => $dbh,
67 :     key2taxa => undef,
68 : paarmann 1.3 query => {},
69 : olson 1.13 dbid_cache => {},
70 : paarmann 1.1 };
71 :     bless $self, $class;
72 :    
73 :     # load key2taxa mapping
74 :     $self->get_key2taxa_mapping();
75 :    
76 :     return $self;
77 :    
78 :     }
79 :    
80 :     sub job {
81 :     return $_[0]->{job};
82 :     }
83 :    
84 :    
85 :     sub dbh {
86 :     return $_[0]->{dbh};
87 :     }
88 :    
89 :    
90 :     sub dbtable {
91 :     unless (defined $_[0]->{dbtable}) {
92 :     $_[0]->{dbtable} = 'tax_sim_'.$_[0]->job->id;
93 :     }
94 :     return $_[0]->{dbtable};
95 :     }
96 :    
97 : jared 1.9 sub dbtable_best_psc {
98 :     unless (defined $_[0]->{dbtable}) {
99 :     $_[0]->{dbtable} = 'tax_sim_best_by_psc_'.$_[0]->job->id;
100 :     }
101 :     return $_[0]->{dbtable};
102 :     }
103 :    
104 :     sub dbtable_best_iden {
105 :     unless (defined $_[0]->{dbtable}) {
106 :     $_[0]->{dbtable} = 'tax_sim_best_by_iden_'.$_[0]->job->id;
107 :     }
108 :     return $_[0]->{dbtable};
109 :     }
110 : paarmann 1.1
111 :     sub get_key2taxa_mapping {
112 :    
113 :     unless (defined($_[0]->{key2taxa})) {
114 :     my $sth = $_[0]->dbh->prepare("select dbkey, str from tax_item");
115 :     $sth->execute;
116 :     $_[0]->{key2taxa} = $sth->fetchall_hashref('dbkey');
117 :     }
118 :    
119 :     return $_[0]->{key2taxa};
120 :    
121 :     }
122 :    
123 :    
124 :     sub key2taxa {
125 :     if(defined $_[1]) {
126 :     my $t = $_[0]->{key2taxa}->{$_[1]}->{str};
127 :     $t =~ s/\t+$//;
128 :     return $t;
129 :     }
130 :     return '';
131 :     }
132 :    
133 :    
134 :     sub split_taxstr {
135 :     my @r = split(':', $_[1]);
136 :     return \@r;
137 :     }
138 :    
139 :     sub join_taxstr {
140 :     # do I really want an ending colon?
141 :     return join(':', @{$_[1]}).':';
142 :     }
143 :    
144 :    
145 :     sub evalue2log {
146 :     return 10 * (log($_[1]) / log(10));
147 :     }
148 :    
149 :     sub log2evalue {
150 :     return 10**($_[1]/10);
151 :     }
152 :    
153 :    
154 : olson 1.13 #
155 :     # Determine the correct dbid for this job. Use sims.database_list
156 :     # to find the version that the analysis was run with.
157 :     #
158 : paarmann 1.1 sub get_dataset_id {
159 : olson 1.13 my($self, $dataset) = @_;
160 :    
161 :     my $id = $self->{dbid_cache}->{$dataset};
162 :     return $id if defined($id);
163 :    
164 :     my($dbname, $type) = split(/:/, $dataset);
165 :    
166 :     my $dbs = $self->job->metaxml->get_metadata('sims.database_list');
167 :    
168 :     my @this = grep { $_->{name} eq $dbname } @$dbs;
169 :     if (@this)
170 :     {
171 :     my $vers = $this[0]->{version};
172 :    
173 :     #
174 :     # Now we can find the dbid ni the database.
175 :     #
176 :     my $res = $self->dbh->selectcol_arrayref(qq(SELECT dbid
177 :     FROM seq_db
178 :     WHERE name = ? AND version = ?
179 :     AND tax_db_name = ?), undef,
180 :     $dbname, $vers, $type);
181 :     if (@$res)
182 :     {
183 : paczian 1.14 #print STDERR "Found @$res for $dbname $type $vers\n";
184 : olson 1.13 $id = $res->[0];
185 :     $self->{dbid_cache}->{$dataset} = $id;
186 :     return $id;
187 :     }
188 :     print STDERR "Did not find anything for dataset='$dataset' '$dbname' '$type' '$vers'\n";
189 :     }
190 :     print STDERR "did not find a vers for dataset='$dataset' $dbname $type\n" . Dumper($dbs);
191 : paarmann 1.1 }
192 :    
193 : paarmann 1.3 #******************************************************************************
194 :     #* MANAGING QUERY CRITERIA
195 :     #******************************************************************************
196 :    
197 :     =pod
198 :    
199 : parrello 1.6 =over 4
200 :    
201 : paarmann 1.3 =item * B<query_evalue> (I<evalue>)
202 :    
203 :     Set/get the expectation value which is currently used to query the database.
204 :     Parameter I<evalue> has to be a float or in '1e-5'-like format or undef.
205 :    
206 :     =cut
207 :    
208 :     sub query_evalue {
209 :     if(scalar(@_)>1) {
210 :     $_[0]->{query}->{evalue} = $_[1];
211 :     }
212 :     return $_[0]->{query}->{evalue};
213 :     }
214 :    
215 :    
216 :     =pod
217 :    
218 :     =item * B<query_bitscore> (I<score>)
219 :    
220 :     Set/get the bitscore which is currently used to query the database.
221 :     Parameter I<score> has to be a float or undef.
222 :    
223 :     =cut
224 :    
225 :     sub query_bitscore {
226 :     if(scalar(@_)>1) {
227 :     $_[0]->{query}->{bitscore} = $_[1];
228 :     }
229 :     return $_[0]->{query}->{bitscore};
230 :     }
231 :    
232 :    
233 :     =pod
234 :    
235 :     =item * B<query_align_len> (I<length>)
236 :    
237 :     Set/get the minimum alignment which is currently used to query the database.
238 :     Parameter I<length> has to be a positive integer or undef.
239 :    
240 :     =cut
241 :    
242 :     sub query_align_len {
243 :     if(scalar(@_)>1) {
244 :     if($_[1] and $_[1]<0) {
245 :     die "Alignment length has to be positive: ".$_[1];
246 :     }
247 :     $_[0]->{query}->{align_len} = $_[1];
248 :     }
249 :     return $_[0]->{query}->{align_len};
250 :     }
251 :    
252 :    
253 :     =pod
254 :    
255 :     =item * B<query_identity> (I<percent>)
256 :    
257 :     Set/get the minimum percent identity which is currently used to query the database.
258 :     Parameter I<percent> has to be a number in 0..100 or undef.
259 :    
260 :     =cut
261 :    
262 :     sub query_identity {
263 :     if(scalar(@_)>1) {
264 :     if($_[1] and ($_[1]<0 or $_[1]>100)) {
265 :     die "Identity has to be between 0 and 100: ".$_[1];
266 :     }
267 :     $_[0]->{query}->{identity} = $_[1];
268 :     }
269 :     return $_[0]->{query}->{identity};
270 :     }
271 :    
272 :    
273 :     =pod
274 :    
275 :     =item * B<query_load_from_cgi> (I<cgi>, [I<dataset>])
276 :    
277 :     Sets all query parameter to the values provided in the CGI query object I<cgi>.
278 :     This method recognises 'evalue', 'pvalue' (bitscore), 'alignment_length' and
279 :     'percent_identity' as query criteria. Any missing param will be set to undef.
280 :     If the optional parameter I<dataset> is set to one of the accepted datasets
281 :     (db types), the method will additionally load the defaults for this type into
282 :     the CGI object.
283 :    
284 :    
285 :     =cut
286 :    
287 :     sub query_load_from_cgi {
288 :     my ($self, $cgi, $dataset) = @_;
289 :    
290 :     unless(ref $cgi and $cgi->isa("CGI")) {
291 :     die "Query load from cgi requires a valid CGI object.";
292 :     }
293 :    
294 :     # load the defaults if necessary
295 :     if($dataset and $self->get_dataset_id($dataset)) {
296 :    
297 :     my $d = $self->get_dataset_id($dataset);
298 :    
299 :     my @v = qw( evalue bitscore align_len identity );
300 :     foreach my $v (@v) {
301 :     if(!defined($cgi->param($v)) and QUERY_DEFAULTS->{$d}->{$v}) {
302 :     $cgi->param($v, QUERY_DEFAULTS->{$d}->{$v});
303 :     }
304 :     }
305 :     }
306 :    
307 :     # set the query params
308 :     my $evalue = $cgi->param('evalue') || '';
309 :     $self->query_evalue($evalue);
310 :    
311 :     my $bitscore = $cgi->param('bitscore') || '';
312 :     $self->query_bitscore($bitscore);
313 :    
314 :     my $align_len = $cgi->param('align_len') || '';
315 :     $self->query_align_len($align_len);
316 :    
317 :     my $identity = $cgi->param('identity') || '';
318 :     $self->query_identity($identity);
319 :    
320 :     return $self;
321 :    
322 :     }
323 :    
324 :    
325 :     =pod
326 :    
327 :     =item * B<get_where_clause> ()
328 :    
329 :     Returns for the current query parameters the where clause as applicable to the
330 :     tax_sim_XYZ table SQL queries. The method will take care of all conversions to
331 :     eg the logscore evalues.
332 :    
333 :     =cut
334 :    
335 :     sub get_where_clause {
336 :     my ($self) = @_;
337 :    
338 :     my @params;
339 :    
340 :     if($self->{query}->{evalue}) {
341 :     push @params, "logpsc<=".$self->evalue2log($self->{query}->{evalue});
342 :     }
343 :    
344 :     if($self->{query}->{bitscore}) {
345 :     push @params, "bsc>=".$self->{query}->{bitscore};
346 :     }
347 :    
348 :     if($self->{query}->{align_len}) {
349 :     push @params, "ali_ln>=".$self->{query}->{align_len};
350 :     }
351 :    
352 :     if($self->{query}->{identity}) {
353 :     push @params, "iden>=".$self->{query}->{identity};
354 :     }
355 :    
356 :     return join(' and ', @params);
357 :    
358 :     }
359 :    
360 :    
361 :    
362 :     #******************************************************************************
363 :     #* OTHER
364 :     #******************************************************************************
365 :    
366 :    
367 :     =pod
368 :    
369 : paarmann 1.1 =item * B<get_sequence> (I<sequence_id>)
370 :    
371 :     Retrieve the sequence I<sequence_id> from the metagenome job directory.
372 :    
373 :     =cut
374 :    
375 :     sub get_sequence {
376 :     my ($self, $id) = @_;
377 :    
378 :     my $sequence_file = $self->job->org_dir.'/contigs';
379 :    
380 :     my $sequence = '';
381 :     open(FASTA, "<$sequence_file") or die "Unable to read metagenome sequences: $!";
382 :     while(<FASTA>) {
383 :     next unless /^\>$id/;
384 :    
385 :     while(<FASTA>) {
386 :     last if /^>/;
387 :     chomp;
388 :     $sequence .= $_;
389 :     }
390 :     }
391 :    
392 :     return $sequence;
393 :    
394 :     }
395 :    
396 : paczian 1.15 =pod
397 :    
398 :     =item * B<get_sequences_fasta> (I<sequence_ids>)
399 :    
400 :     Retrieve the sequences for a given list of I<sequence_ids> from the metagenome job directory in fasta format.
401 :    
402 :     =cut
403 :    
404 :     sub get_sequences_fasta {
405 :     my ($self, $ids) = @_;
406 :    
407 :     # get the path to the sequence file
408 :     my $sequence_file = $self->job->org_dir.'/contigs';
409 :    
410 :     # hash the ids
411 :     my %idh = map { $_ => 1 } @$ids;
412 :    
413 :     # store the result
414 :     my $sequence = '';
415 :    
416 :     # iterate over the sequence file
417 :     open(FASTA, "<$sequence_file") or die "Unable to read metagenome sequences: $!";
418 :     while(<FASTA>) {
419 :    
420 :     # look only at id lines
421 :     next unless /^\>/;
422 :    
423 :     # get the id
424 :     my ($id) = /^\>(.+)/;
425 :     chomp($id);
426 :    
427 :     # find the id in the requested id hash
428 :     next unless exists ($idh{$id});
429 :    
430 :     # id was found, delete it from the hash
431 :     delete $idh{$id};
432 :    
433 :     # print the header line
434 :     $sequence .= $_;
435 :    
436 :     # print all the following lines to the result
437 :     while(<FASTA>) {
438 :     last if /^>/;
439 :     $sequence .= $_;
440 :     }
441 :    
442 :     last unless (scalar(keys(%idh)));
443 :     }
444 :    
445 :     return $sequence;
446 :    
447 :     }
448 : paarmann 1.1
449 : paarmann 1.3 =pod
450 : paarmann 1.1
451 : paarmann 1.3 =item * B<get_hits_count> (I<dataset_name>)
452 :    
453 :     Given a dataset name (db_id), this method returns
454 : paarmann 1.1 the total number of sequences that contain a hit.
455 :    
456 :     =cut
457 :    
458 :     sub get_hits_count {
459 : paarmann 1.3 my ($self, $dataset) = @_;
460 : jared 1.10
461 :     my $table = $self->dbtable_best_psc;
462 : paarmann 1.1 my $dbid = $self->get_dataset_id($dataset);
463 : paarmann 1.3 my $where = $self->get_where_clause();
464 :     $where = ($where) ? "and $where" : '';
465 : paarmann 1.1
466 : jared 1.10 my $sth = $self->dbh->prepare("select count(distinct id1) from $table where dbid=$dbid $where");
467 : paarmann 1.1 $sth->execute;
468 :     my ($result) = $sth->fetchrow_array;
469 :    
470 :     return $result;
471 :    
472 :     }
473 :    
474 :    
475 : paarmann 1.3 =pod
476 :    
477 :     =item * B<get_group_counts> (I<dataset_name>, [I<group>, I<filter1>, I<filter2>])
478 :    
479 :     Given a dataset name (db_id), this method returns the total counts for all
480 :     taxonomy groups of a certain depth which are hit. If no group name I<group>
481 :     was given, the method returns counts for tax_group_1.
482 :     Optionally, I<group> may be 'tax_group_2' or 'tax_group_3' and in that case
483 :     any optional provided filters I<filter1> and I<filter2> will be applied to
484 :     the column 'tax_group_1' and 'tax_group_2' respectively.
485 :    
486 :     =cut
487 :    
488 :     sub get_group_counts {
489 :     my ($self, $dataset, $group, $filter1, $filter2) = @_;
490 :    
491 : jared 1.10 my $table = $self->dbtable_best_psc;
492 : paarmann 1.3 my $dbid = $self->get_dataset_id($dataset);
493 :     my $where = $self->get_where_clause();
494 :     $where = ($where) ? "and $where" : '';
495 :     $group = 'tax_group_1' unless($group);
496 :    
497 :     my @filters;
498 :     push @filters, "tax_group_1='$filter1'" if($filter1);
499 :     push @filters, "tax_group_2='$filter2'" if($filter2);
500 :     my $filter = (scalar(@filters)) ? 'and '.join(' and ', @filters) : '';
501 :    
502 : jared 1.10 my $sth = $self->dbh->prepare("select $group as tax, count(*) as num from $table where dbid=$dbid $where $filter group by tax");
503 : paarmann 1.3 $sth->execute;
504 :     my $result = $sth->fetchall_arrayref();
505 :    
506 : olson 1.13 print STDERR "get_group_counts: ds=$dataset group=$group filter1=$filter1 filter2=$filter2\n";
507 :     print STDERR Dumper($result);
508 : paarmann 1.3 return $result;
509 :    
510 :     }
511 :    
512 :    
513 :     =pod
514 :    
515 :     =item * B<get_taxa_counts> (I<dataset_name>)
516 :    
517 :     Given a dataset name (db_id), this method returns the total counts for all
518 :     taxonomy strings which are hit.
519 :    
520 :     =cut
521 :    
522 :     sub get_taxa_counts {
523 :     my ($self, $dataset) = @_;
524 :    
525 : jared 1.9 my $table = $self->dbtable_best_psc;
526 : paarmann 1.3 my $dbid = $self->get_dataset_id($dataset);
527 :     my $where = $self->get_where_clause();
528 :     $where = ($where) ? "and $where" : '';
529 :    
530 : paczian 1.16 my $sth = $self->dbh->prepare("select tax_str as tax, count(*) from $table where dbid=$dbid $where group by tax");
531 : paarmann 1.3
532 :     $sth->execute;
533 :     my $result = $sth->fetchall_arrayref();
534 :    
535 :     return $result;
536 :    
537 :     }
538 :    
539 :    
540 :     =pod
541 :    
542 :     =item * B<get_subsystem_counts> (I<dataset_name>)
543 :    
544 :     Given a dataset name (db_id), this method returns the total counts for all
545 :     subsystems which are hit.
546 :    
547 :     =cut
548 :    
549 :     sub get_subsystem_counts {
550 :     my ($self, $dataset) = @_;
551 :    
552 : jared 1.9 my $table = $self->dbtable_best_psc;
553 : paarmann 1.3 my $dbid = $self->get_dataset_id($dataset);
554 :     my $where = $self->get_where_clause();
555 :     $where = ($where) ? "and $where" : '';
556 : paarmann 1.4
557 : jared 1.9 my $sth = $self->dbh->prepare("select tax_group_1, tax_group_2, tax_group_3, tax_str, count(*) as num from $table where dbid=$dbid group by tax_group_1, tax_group_2, tax_group_3, tax_str");
558 : paarmann 1.3
559 :     $sth->execute;
560 :     my $result = $sth->fetchall_arrayref();
561 :    
562 :     return $result;
563 :    
564 :     }
565 :    
566 :    
567 :     =pod
568 :    
569 :     =item * B<get_sequence_subset> (I<dataset_name>, I<filter>)
570 :    
571 :     Given a dataset name (db_id), this method returns all sequence ids,
572 :     the alignment length, the match id and the taxonomy string for all
573 :     sequences which match the criteria and have their tax_str start with
574 :     the filter string I<filter>.
575 :    
576 :     =cut
577 :    
578 :     sub get_sequence_subset {
579 :     my ($self, $dataset, $filter) = @_;
580 :    
581 : jared 1.10 my $table = $self->dbtable_best_psc;
582 : paarmann 1.3 my $dbid = $self->get_dataset_id($dataset);
583 :     my $where = $self->get_where_clause();
584 :     $where = ($where) ? "and $where" : '';
585 :    
586 : paczian 1.15 $filter =~ s/'/''/g;
587 :    
588 : jared 1.10 my $sth = $self->dbh->prepare("select id1, ali_ln, id2, tax_str from $table where dbid=$dbid $where and tax_str like '$filter%'");
589 : paarmann 1.3 $sth->execute;
590 :     my $result = $sth->fetchall_arrayref();
591 :    
592 :     return $result;
593 :    
594 :     }
595 :    
596 :    
597 : paarmann 1.4 =pod
598 :    
599 : jared 1.5 =item * B<get_recruitment_plot_data> (I<genome>)
600 :    
601 :     Given a genome id (83333.1), this method returns all sequence ids,
602 :     the alignment length, the match id and the taxonomy string for all
603 :     sequences which match the criteria and have their tax_str start equal
604 :     the genome tax string I<filter>.
605 :    
606 :     =cut
607 :    
608 :     sub get_recruitment_plot_data {
609 :     my ($self, $genome) = @_;
610 :    
611 : jared 1.9 my $table = $self->dbtable_best_psc;
612 : olson 1.13 my $dbid = $self->get_dataset_id("SEED:seed_genome_tax");
613 : jared 1.5 my $where = $self->get_where_clause();
614 :     $where = ($where) ? "and $where" : '';
615 :    
616 : olson 1.13 my ($tax_id) = $self->dbh->selectrow_array(qq(SELECT tax_str
617 :     FROM rdp_to_tax
618 :     WHERE seq_num= ?), undef, $genome);
619 : jared 1.5
620 : jared 1.9 if($tax_id =~ /(\S+)\s/){
621 :     $tax_id = $1;
622 :     }
623 : jared 1.5
624 : olson 1.13 my $sth = $self->dbh->prepare(qq(SELECT id1, id2, b2, e2, logpsc
625 :     FROM $table
626 :     WHERE dbid=? $where and tax_str=?));
627 :    
628 :    
629 :     $sth->execute($dbid, $tax_id);
630 : jared 1.5 my $result = $sth->fetchall_arrayref();
631 :    
632 :     return $result;
633 :    
634 :     }
635 :    
636 :    
637 :    
638 :    
639 :     =pod
640 :    
641 : paarmann 1.4 =item * B<get_hits_for_sequence> (I<seq_id>, I<dataset>, I<limit>)
642 :    
643 :     Given a sequence id I<seq_id> (id1) and a dataset name (db_id), this method returns
644 :     the first I<limit> rows of hit data for this sequence. If no I<limit> is provided, it
645 :     will default to 10.
646 :     It returns (match id, taxonomy string, log evalue, bitscore, alignment length,
647 :     percent identity, start1, end1) per hit.
648 :    
649 :     =cut
650 :    
651 :     sub get_hits_for_sequence {
652 :     my ($self, $id, $dataset, $limit) = @_;
653 :    
654 :     my $table = $self->dbtable;
655 :     my $dbid = $self->get_dataset_id($dataset);
656 :     $limit = 10 unless ($limit);
657 :    
658 : olson 1.13 my $sth = $self->dbh->prepare(qq(SELECT id2, tax_str, logpsc, bsc, ali_ln,
659 :     iden, b1, e1
660 :     FROM $table
661 :     WHERE id1=? AND dbid=? AND rank_psc < ?));
662 :     $sth->execute($id, $dbid, $limit);
663 : paarmann 1.4 my $result = $sth->fetchall_arrayref();
664 :    
665 :     return $result;
666 :    
667 :     }
668 :    
669 :    
670 : paarmann 1.3 =pod
671 :    
672 : paarmann 1.1 =item * B<get_align_len_range> (I<dataset_name>)
673 :    
674 :     Given a dataset name (db_id), this method returns
675 :     the minimum and maximum alignment length.
676 :    
677 :     =cut
678 :    
679 :     sub get_align_len_range {
680 :     my ($self, $dataset) = @_;
681 :    
682 :     my $table = $self->dbtable;
683 :     my $dbid = $self->get_dataset_id($dataset);
684 :    
685 : paarmann 1.3 my $sth = $self->dbh->prepare("select min(ali_ln), max(ali_ln) from $table where dbid=$dbid");
686 : paarmann 1.1 $sth->execute;
687 :     my ($min, $max) = $sth->fetchrow_array;
688 :    
689 :     return ($min, $max);
690 :    
691 :     }
692 :    
693 : jared 1.11 =pod
694 :    
695 :     =item * B<get_genome_id> (I<tax_str>)
696 :    
697 :     =cut
698 :    
699 :     sub get_genome_id {
700 :     my ($self, $tax_str) = @_;
701 : paczian 1.14 $tax_str =~ s/'/''/g;
702 :     my $retval = $self->dbh->selectrow_array("select seq_num from rdp_to_tax where tax_str='". $tax_str . "'");
703 :     if (ref($retval) eq 'ARRAY') {
704 :     return $retval->[0];
705 :     } else {
706 :     return $retval;
707 :     }
708 : jared 1.11 }
709 :    
710 : parrello 1.6 =pod
711 :    
712 :     =back
713 : paarmann 1.1
714 : parrello 1.6 =cut

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3