Mercurial > repos > mahtabm > ensembl

comparison variant_effect_predictor/Bio/EnsEMBL/DBSQL/AnalysisAdaptor.pm @ 0:1f6dce3d34e0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded
author mahtabm
date Thu, 11 Apr 2013 02:01:53 -0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:1f6dce3d34e0
1 =head1 LICENSE
2
3 Copyright (c) 1999-2012 The European Bioinformatics Institute and
4 Genome Research Limited. All rights reserved.
5
6 This software is distributed under a modified Apache license.
7 For license details, please see
8
9 http://www.ensembl.org/info/about/code_licence.html
10
11 =head1 CONTACT
12
13 Please email comments or questions to the public Ensembl
14 developers list at <dev@ensembl.org>.
15
16 Questions may also be sent to the Ensembl help desk at
17 <helpdesk@ensembl.org>.
18
19 =cut
20
21 =head1 NAME
22
23 Bio::EnsEMBL::DBSQL::AnalysisAdaptor
24
25 =head1 SYNOPSIS
26
27 use Bio::EnsEMBL::Registry;
28
29 Bio::EnsEMBL::Registry->load_registry_from_db(
30 -host => 'ensembldb.ensembl.org',
31 -user => 'anonymous'
32 );
33
34 $analysis_adaptor =
35 Bio::EnsEMBL::Registry->get_adaptor( "human", "core", "analysis" );
36
37 my $analysis = $analysis_adaptor->fetch_by_logic_name('genscan');
38
39 =head1 DESCRIPTION
40
41 Module to encapsulate all db access for persistent class Analysis.
42 There should be just one per application and database connection.
43
44 =head1 METHODS
45
46 =cut
47
48
49 package Bio::EnsEMBL::DBSQL::AnalysisAdaptor;
50
51 use Bio::EnsEMBL::Analysis;
52 use Bio::EnsEMBL::DBSQL::BaseAdaptor;
53 use Bio::EnsEMBL::Utils::Exception;
54
55
56 use vars qw(@ISA);
57 use strict;
58
59 @ISA = qw( Bio::EnsEMBL::DBSQL::BaseAdaptor);
60
61
62 =head2 new
63
64 Args : Bio::EnsEMBL::DBSQL::DBAdaptor
65 Example : my $aa = new Bio::EnsEMBL::DBSQL::AnalysisAdaptor();
66 Description: Creates a new Bio::EnsEMBL::DBSQL::AnalysisAdaptor object and
67 internally loads and caches all the Analysis objects from the
68 database.
69 Returntype : Bio::EnsEMBL::DBSQL::AnalysisAdaptor
70 Exceptions : none
71 Caller : Bio::EnsEMBL::DBSQL::DBAdaptor
72 Status : Stable
73
74 =cut
75
76 sub new {
77 my ($class, $db) = @_;
78
79 my $self = $class->SUPER::new($db);
80
81 #load and cache all of the Analysis objects
82 $self->fetch_all;
83
84 return $self;
85 }
86
87
88 =head2 fetch_all
89
90 Args : none
91 Example : my @analysis = @{$analysis_adaptor->fetch_all()};
92 Description: fetches all of the Analysis objects from the database and caches
93 them internally.
94 Returntype : listref of Bio::EnsEMBL::Analysis retrieved from the database
95 Exceptions : none
96 Caller : AnalysisAdaptor::new
97 Status : Stable
98
99 =cut
100
101 sub fetch_all {
102 my $self = shift;
103 my ( $analysis, $dbID );
104 my $rowHashRef;
105
106 $self->{_cache} = {};
107 $self->{_logic_name_cache} = {};
108
109 my $sth = $self->prepare( q {
110 SELECT analysis.analysis_id, logic_name,
111 program, program_version, program_file,
112 db, db_version, db_file,
113 module, module_version,
114 gff_source, gff_feature,
115 created, parameters, description, display_label, displayable, web_data
116 FROM analysis
117 LEFT JOIN analysis_description
118 ON analysis.analysis_id = analysis_description.analysis_id } );
119 $sth->execute;
120
121 while( $rowHashRef = $sth->fetchrow_hashref ) {
122 my $analysis = $self->_objFromHashref( $rowHashRef );
123
124 $self->{_cache}->{$analysis->dbID} = $analysis;
125 $self->{_logic_name_cache}->{lc($analysis->logic_name())} = $analysis;
126 }
127
128 my @ana = values %{$self->{_cache}};
129
130 return \@ana;
131 }
132
133
134 =head2 fetch_all_by_feature_class
135
136 Arg [1] : string $feature_cless - The name of the feature class
137 Example : my @analyses = @{$analysis_adaptor->fetch_all_by_feature_class('Gene');
138 Description: Returns all analyses that correspond to a given
139 feature class; see feature_classes method for a list.
140 Returntype : Listref of Bio::EnsEMBL::Analysis
141 Exceptions : none
142 Caller : general
143 Status : Stable
144
145 =cut
146
147 sub fetch_all_by_feature_class {
148 my $self = shift;
149 deprecate("Deprecated. Hard-coded logic is not supported");
150 my $feat_class = shift || throw( "Need a feature type, e.g. SimpleFeature" );
151
152 my @feature_classes = $self->feature_classes; # List of all feature classes
153 my %feat_table_map;
154 foreach my $class( @feature_classes ){
155 # Map e.g. DnaAlignFeature to dna_align_feature
156 my $table = join( "_", map lc, ( $class =~ /([A-Z][a-z]+)/g ) );
157 $feat_table_map{$class} = $table;
158 }
159 $feat_table_map{DensityFeature}='density_type'; # analysis_id in diff table
160 my $feat_table = $feat_table_map{$feat_class} ||
161 ( warning( "No feature type corresponding to $feat_class" ) &&
162 return [] );
163
164 my $sql_t = qq|
165 SELECT DISTINCT analysis_id FROM %s |;
166
167 my $sql = sprintf( $sql_t, $feat_table );
168 my $sth = $self->prepare( $sql );
169 my $rv = $sth->execute();
170 my $res = $sth->fetchall_arrayref;
171 my @analyses;
172 foreach my $r( @{$res} ){
173 my $analysis = $self->fetch_by_dbID($r->[0])
174 || throw( "analysis_id $r->[0] from $feat_table table "
175 . "is not in the analysis table!" );
176 push @analyses, $analysis;
177 }
178 return [@analyses];
179 }
180
181
182 =head2 feature_classes
183
184 Arg [1] : NONE
185 Example : my @fclasses = $analysis_adaptor->feature_classes;
186 Description: Returns a list of the different classes of Ensembl feature
187 object that have an analysis
188 Returntype : List of feature classes
189 Exceptions : none
190 Caller : general
191 Status : Stable
192
193 =cut
194
195 sub feature_classes{
196 deprecate("Deprecated. Hard-coded logic is not supported");
197 # Can't think of a way to do this programatically, so hard-coded
198 return qw(
199 DensityFeature
200 DnaAlignFeature
201 Gene
202 MarkerFeature
203 PredictionTranscript
204 ProteinAlignFeature
205 ProteinFeature
206 QtlFeature
207 RepeatFeature
208 SimpleFeature
209 );
210 }
211
212 =head2 fetch_by_dbID
213
214 Arg [1] : int $internal_analysis_id - the database id of the analysis
215 record to retrieve
216 Example : my $analysis = $analysis_adaptor->fetch_by_dbID(1);
217 Description: Retrieves an Analysis object from the database via its internal
218 id.
219 Returntype : Bio::EnsEMBL::Analysis
220 Exceptions : none
221 Caller : general
222 Status : Stable
223
224 =cut
225
226 sub fetch_by_dbID {
227 my $self = shift;
228 my $id = shift;
229
230 if( defined $self->{_cache}->{$id} ) {
231 return $self->{_cache}->{$id};
232 }
233
234 my $query = q{
235 SELECT analysis.analysis_id, logic_name,
236 program, program_version, program_file,
237 db, db_version, db_file,
238 module, module_version,
239 gff_source, gff_feature,
240 created, parameters, description, display_label, displayable, web_data
241 FROM analysis
242 LEFT JOIN analysis_description
243 ON analysis.analysis_id = analysis_description.analysis_id
244 WHERE analysis.analysis_id = ? };
245
246 my $sth = $self->prepare($query);
247 $sth->bind_param(1,$id,SQL_INTEGER);
248 $sth->execute();
249 my $rowHashRef = $sth->fetchrow_hashref;
250 if( ! defined $rowHashRef ) {
251 return undef;
252 }
253
254 my $anal = $self->_objFromHashref( $rowHashRef );
255 $self->{_cache}->{$anal->dbID} = $anal;
256 $self->{_logic_name_cache}->{lc($anal->logic_name())} = $anal;
257 return $anal;
258 }
259
260
261 =head2 fetch_by_logic_name
262
263 Arg [1] : string $logic_name the logic name of the analysis to retrieve
264 Example : my $analysis = $a_adaptor->fetch_by_logic_name('Eponine');
265 Description: Retrieves an analysis object from the database using its unique
266 logic name.
267 Returntype : Bio::EnsEMBL::Analysis
268 Exceptions : none
269 Caller : general
270 Status : Stable
271
272 =cut
273
274 sub fetch_by_logic_name {
275 my ( $self, $logic_name ) = @_;
276
277 my $analysis;
278 my $rowHash;
279
280 # Check the cache for the logic name
281 if ( defined( $self->{_logic_name_cache}{ lc($logic_name) } ) ) {
282 return $self->{_logic_name_cache}{ lc($logic_name) };
283 }
284
285 my $sth = $self->prepare(
286 qq(
287 SELECT analysis.analysis_id,
288 logic_name,
289 program,
290 program_version,
291 program_file,
292 db,
293 db_version,
294 db_file,
295 module,
296 module_version,
297 gff_source,
298 gff_feature,
299 created,
300 parameters,
301 description,
302 display_label,
303 displayable,
304 web_data
305 FROM analysis
306 LEFT JOIN analysis_description
307 ON ( analysis.analysis_id = analysis_description.analysis_id )
308 WHERE LOWER(logic_name) = ?)
309 );
310
311 $sth->bind_param( 1, lc($logic_name), SQL_VARCHAR );
312 $sth->execute();
313 my $rowHashRef = $sth->fetchrow_hashref();
314
315 if ( !defined($rowHashRef) ) { return undef }
316
317 $analysis = $self->_objFromHashref($rowHashRef);
318
319 # place the analysis in the caches, cross referenced by dbID and
320 # logic_name
321 $self->{_cache}->{ $analysis->dbID() } = $analysis;
322 $self->{_logic_name_cache}->{ lc($logic_name) } = $analysis;
323
324 return $analysis;
325 } ## end sub fetch_by_logic_name
326
327
328 =head2 store
329
330 Arg [1] : Bio:EnsEMBL::Analysis $analysis
331 Example : $analysis_adaptor->store($analysis);
332 Description: Stores $analysis in db. If the analysis is already stored in
333 the database its dbID and adaptor are updated, but the analysis
334 is not stored a second time.
335 Sets created date if not already set. Sets dbID and adaptor
336 inside $analysis. Returns dbID.
337 Returntype : int - dbID of stored analysis
338 Exceptions : throw on incorrect argument
339 throw if analysis argument does not have a logic name
340 Caller : general
341 Status : Stable
342
343 =cut
344
345 sub store {
346 my $self = shift;
347 my $analysis = shift;
348
349 if(!ref($analysis) || !$analysis->isa('Bio::EnsEMBL::Analysis')) {
350 throw("Bio::EnsEMBL::Analysis argument expected.");
351 }
352
353 if($analysis->is_stored($self->db())) {
354 return $analysis->dbID();
355 }
356
357 if(!$analysis->logic_name()) {
358 throw("Analysis cannot be stored without a valid logic_name");
359 }
360
361 my $insertion_method = (lc($self->dbc->driver) eq 'sqlite') ? 'INSERT OR IGNORE' : 'INSERT IGNORE';
362
363 my $rows_inserted = 0;
364 my $sth;
365
366 if ( $analysis->created() ) {
367
368 # We use insert IGNORE so that this method can be used in a
369 # multi-process environment. If another process has already written
370 # this record then there will not be a problem.
371
372 $sth = $self->prepare(
373 qq{
374 $insertion_method INTO analysis
375 (created, logic_name, db, db_version, db_file, program, program_version, program_file, parameters, module, module_version, gff_source, gff_feature)
376 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
377 }
378 );
379 $sth->bind_param( 1, $analysis->created(), SQL_DATETIME );
380 $sth->bind_param( 2, lc( $analysis->logic_name() ), SQL_VARCHAR );
381 $sth->bind_param( 3, $analysis->db(), SQL_VARCHAR );
382 $sth->bind_param( 4, $analysis->db_version(), SQL_VARCHAR );
383 $sth->bind_param( 5, $analysis->db_file(), SQL_VARCHAR );
384 $sth->bind_param( 6, $analysis->program(), SQL_VARCHAR );
385 $sth->bind_param( 7, $analysis->program_version(), SQL_VARCHAR );
386 $sth->bind_param( 8, $analysis->program_file(), SQL_VARCHAR );
387 $sth->bind_param( 9, $analysis->parameters(), SQL_VARCHAR );
388 $sth->bind_param( 10, $analysis->module(), SQL_VARCHAR );
389 $sth->bind_param( 11, $analysis->module_version(), SQL_VARCHAR );
390 $sth->bind_param( 12, $analysis->gff_source(), SQL_VARCHAR );
391 $sth->bind_param( 13, $analysis->gff_feature(), SQL_VARCHAR );
392
393 $rows_inserted = $sth->execute();
394
395 } else {
396 $sth = $self->prepare(
397 qq{
398 $insertion_method INTO analysis
399 (created, logic_name, db, db_version, db_file, program, program_version, program_file, parameters, module, module_version, gff_source, gff_feature)
400 VALUES (CURRENT_TIMESTAMP, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
401 }
402 );
403
404 $sth->bind_param( 1, $analysis->logic_name, SQL_VARCHAR );
405 $sth->bind_param( 2, $analysis->db, SQL_VARCHAR );
406 $sth->bind_param( 3, $analysis->db_version, SQL_VARCHAR );
407 $sth->bind_param( 4, $analysis->db_file, SQL_VARCHAR );
408 $sth->bind_param( 5, $analysis->program, SQL_VARCHAR );
409 $sth->bind_param( 6, $analysis->program_version, SQL_VARCHAR );
410 $sth->bind_param( 7, $analysis->program_file, SQL_VARCHAR );
411 $sth->bind_param( 8, $analysis->parameters, SQL_VARCHAR );
412 $sth->bind_param( 9, $analysis->module, SQL_VARCHAR );
413 $sth->bind_param( 10, $analysis->module_version, SQL_VARCHAR );
414 $sth->bind_param( 11, $analysis->gff_source, SQL_VARCHAR );
415 $sth->bind_param( 12, $analysis->gff_feature, SQL_VARCHAR );
416
417 $rows_inserted = $sth->execute();
418
419 } ## end else [ if ( $analysis->created...)]
420
421 my $dbID;
422 # If we need to fetch the timestamp, or the insert failed due to
423 # existance of an existing entry, we need to retrieve the entry from
424 # the database. Note: $sth->execute() may return 0E0 on error which
425 # is zero, but true which is why the $rows_inserted clause was added.
426 if ( !$analysis->created() || !$rows_inserted || $rows_inserted == 0 )
427 {
428 my $new_analysis =
429 $self->fetch_by_logic_name( $analysis->logic_name );
430
431 if ( !$new_analysis ) {
432 throw("Could not retrieve just stored analysis from database.\n"
433 . "Possibly incorrect db permissions or missing analysis table\n"
434 );
435 }
436
437 $dbID = $new_analysis->dbID();
438 $analysis->created( $new_analysis->created() );
439 }
440
441 $dbID ||= $sth->{'mysql_insertid'};
442 $sth->finish();
443
444 # store description and display_label
445 if( defined( $analysis->description() ) || defined( $analysis->display_label() )|| defined( $analysis->web_data() )) {
446 $sth = $self->prepare( "INSERT IGNORE INTO analysis_description (analysis_id, display_label, description, displayable, web_data) VALUES (?,?,?,?, ?)");
447
448 $sth->bind_param(1,$dbID,SQL_INTEGER);
449 $sth->bind_param(2,$analysis->display_label(),SQL_VARCHAR);
450 $sth->bind_param(3,$analysis->description,SQL_LONGVARCHAR);
451 $sth->bind_param(4,$analysis->displayable,SQL_TINYINT);
452 #$sth->bind_param(5,$analysis->web_data(),SQL_LONGVARCHAR);
453 my $web_data;
454 $web_data = $self->dump_data($analysis->web_data()) if ($analysis->web_data());
455 $sth->bind_param(5,$web_data,SQL_LONGVARCHAR);
456 $sth->execute();
457
458 $sth->finish();
459 }
460
461
462
463 $self->{_cache}->{$dbID} = $analysis;
464 $self->{_logic_name_cache}{lc($analysis->logic_name)} = $analysis;
465
466 $analysis->adaptor( $self );
467 $analysis->dbID( $dbID );
468
469 return $dbID;
470 }
471
472
473
474 =head2 update
475
476 Arg [1] : Bio::EnsEMBL::Analysis $anal
477 Example : $adaptor->update($anal)
478 Description: Updates this analysis in the database
479 Returntype : int 1 if update is performed, undef if it is not
480 Exceptions : throw if arg is not an analysis object
481 Caller : ?
482 Status : Stable
483
484 =cut
485
486 sub update {
487 my $self = shift;
488 my $a = shift;
489
490 if (!ref($a) || !$a->isa('Bio::EnsEMBL::Analysis')) {
491 throw("Expected Bio::EnsEMBL::Analysis argument.");
492 }
493
494 if(!$a->is_stored($self->db())) {
495 return undef;
496 }
497
498 my $sth = $self->prepare
499 ("UPDATE analysis " .
500 "SET created = ?, logic_name = ?, db = ?, db_version = ?, db_file = ?, ".
501 " program = ?, program_version = ?, program_file = ?, ".
502 " parameters = ?, module = ?, module_version = ?, ".
503 " gff_source = ?, gff_feature = ? " .
504 "WHERE analysis_id = ?");
505
506
507
508 $sth->bind_param(1,$a->created,SQL_DATETIME);
509 $sth->bind_param(2,$a->logic_name,SQL_VARCHAR);
510 $sth->bind_param(3,$a->db,SQL_VARCHAR);
511 $sth->bind_param(4,$a->db_version,SQL_VARCHAR);
512 $sth->bind_param(5,$a->db_file,SQL_VARCHAR);
513 $sth->bind_param(6,$a->program,SQL_VARCHAR);
514 $sth->bind_param(7,$a->program_version,SQL_VARCHAR);
515 $sth->bind_param(8,$a->program_file,SQL_VARCHAR);
516 $sth->bind_param(9,$a->parameters,SQL_VARCHAR);
517 $sth->bind_param(10,$a->module,SQL_VARCHAR);
518 $sth->bind_param(11,$a->module_version,SQL_VARCHAR);
519 $sth->bind_param(12,$a->gff_source,SQL_VARCHAR);
520 $sth->bind_param(13,$a->gff_feature,SQL_VARCHAR);
521 $sth->bind_param(14,$a->dbID,SQL_INTEGER);
522
523 $sth->execute();
524
525 $sth->finish();
526
527 # also update description & display label - may need to create these if
528 # not already there
529 $sth = $self->prepare("SELECT description FROM analysis_description WHERE analysis_id= ?");
530 $sth->execute($a->dbID);
531 my $web_data; #this is an anonymous reference to a hash, will have to be dumped into string before writing to db
532 if ($sth->fetchrow_hashref) { # update if exists
533 $web_data = $self->dump_data($a->web_data()) if ($a->web_data());
534 $sth = $self->prepare
535 ("UPDATE analysis_description SET description = ?, display_label = ?, displayable = ?, web_data = ? WHERE analysis_id = ?");
536 $sth->bind_param(1,$a->description,SQL_LONGVARCHAR);
537 $sth->bind_param(2,$a->display_label(),SQL_VARCHAR);
538 $sth->bind_param(3,$a->displayable,SQL_TINYINT);
539 # print "after $web_data\n";
540 $sth->bind_param(4,$web_data,SQL_LONGVARCHAR);
541 $sth->bind_param(5,$a->dbID,SQL_INTEGER);
542 $sth->execute();
543
544 } else { # create new entry
545
546 if( $a->description() || $a->display_label() || $a->web_data) {
547 $web_data = $self->dump_data($a->web_data()) if ($a->web_data());
548 #my $web_data = $self->dump_data($a->web_data());
549 $sth = $self->prepare( "INSERT IGNORE INTO analysis_description (analysis_id, display_label, description, displayable, web_data) VALUES (?,?,?,?,?)");
550 $sth->bind_param(1,$a->dbID,SQL_INTEGER);
551 $sth->bind_param(2,$a->display_label(),SQL_VARCHAR);
552 $sth->bind_param(3,$a->description,SQL_LONGVARCHAR);
553 $sth->bind_param(4,$a->displayable,SQL_TINYINT);
554 #my $web_data = $self->dump_data($a->web_data());
555 $sth->bind_param(5,$web_data,SQL_LONGVARCHAR);
556 $sth->execute();
557
558 }
559
560 }
561
562
563 $sth->finish();
564
565 # the logic_name cache needs to be re-updated now, since we may have just
566 # changed the logic_name
567 $self->fetch_all();
568
569 return 1;
570 }
571
572
573
574 =head2 remove
575
576 Arg [1] : Bio::EnsEMBL::Analysis $anal
577 Example : $adaptor->remove($anal)
578 Description: Removes this analysis from the database. This is not really
579 safe to execute in a multi process environment, so programs
580 should not remove analysis while out on the farm.
581 Returntype : none
582 Exceptions : thrown if $anal arg is not an analysis object
583 Caller : ?
584 Status : Stable
585
586 =cut
587
588 sub remove {
589 my ($self, $analysis) = @_;
590
591 if (!defined $analysis || !ref $analysis) {
592 throw("called remove on AnalysisAdaptor with a [$analysis]");
593 }
594
595 if(!$analysis->is_stored($self->db())) {
596 return undef;
597 }
598
599 my $sth = $self->prepare("DELETE FROM analysis WHERE analysis_id = ?");
600 $sth->bind_param(1,$analysis->dbID,SQL_INTEGER);
601 $sth->execute();
602
603 $sth = $self->prepare("DELETE FROM analysis_description WHERE analysis_id = ?");
604 $sth->execute($analysis->dbID());
605
606 # remove this analysis from the cache
607 delete $self->{'_cache'}->{$analysis->dbID()};
608 delete $self->{'_logic_name_cache'}->{lc($analysis->logic_name)};
609
610
611 # unset the adaptor and dbID
612 $analysis->dbID(undef);
613 $analysis->adaptor(undef);
614
615 return;
616 }
617
618
619
620 =head2 exists
621
622 Arg [1] : Bio::EnsEMBL::Analysis $anal
623 Example : if($adaptor->exists($anal)) #do something
624 Description: Tests whether this Analysis already exists in the database
625 by checking first if the adaptor and dbID are set and
626 secondly by whether it is in this adaptors internal cache.
627 Note that this will not actually check the database and will
628 not find and analysis which were recently added by other
629 processes. You are better off simply trying to store an
630 analysis which will reliably ensure that it is not stored twice
631 in the database.
632 Returntype : int dbID if analysis is found, otherwise returns undef
633 Exceptions : thrown if $anal arg is not an analysis object
634 Caller : store
635 Status : Stable
636
637 =cut
638
639 sub exists {
640 my ($self,$anal) = @_;
641
642 if(!ref($anal) || !$anal->isa("Bio::EnsEMBL::Analysis")) {
643 throw("Object is not a Bio::EnsEMBL::Analysis");
644 }
645
646 #if this analysis is stored in this db already return its dbID
647 if($anal->is_stored($self->db())) {
648 return $anal->dbID();
649 }
650
651 #this analysis object is not stored but one exactly like it may have been
652 foreach my $cacheId (keys %{$self->{_cache}}) {
653 if ($self->{_cache}->{$cacheId}->compare($anal) >= 0) {
654 # $anal->dbID( $cacheId );
655 # $anal->adaptor( $self );
656 return $cacheId;
657 }
658 }
659
660 #no analysis like this one exists in the database
661 return undef;
662 }
663
664
665 =head2 _objFromHashref
666
667 Arg [1] : hashref $rowHash
668 Description: Private helper function generates an Analysis object from a
669 mysql row hash reference.
670 Returntype : Bio::EnsEMBL::Analysis
671 Exceptions : none
672 Caller : Bio::EnsEMBL::DBSQL::AnalsisAdaptor::fetch_* methods
673 Status : Stable
674
675 =cut
676
677 sub _objFromHashref {
678 my $self = shift;
679 my $h = shift;
680
681 my $web_data = $h->{web_data} ? $self->get_dumped_data($h->{web_data}) : '';
682
683 return Bio::EnsEMBL::Analysis->new_fast({
684 dbID => $h->{analysis_id},
685 adaptor => $self,
686 _db => $h->{db},
687 _db_file => $h->{db_file},
688 _db_version => $h->{db_version},
689 _program => $h->{program},
690 _program_version => $h->{program_version},
691 _program_file => $h->{program_file},
692 _gff_source => $h->{gff_source},
693 _gff_feature => $h->{gff_feature},
694 _module => $h->{module},
695 _module_version => $h->{module_version},
696 _parameters => $h->{parameters},
697 _created => $h->{created},
698 _logic_name => $h->{logic_name},
699 _description => $h->{description},
700 _display_label => $h->{display_label},
701 _displayable => $h->{displayable},
702 _web_data => $web_data,
703 });
704 }
705
706
707
708 1;