Mercurial > repos > mahtabm > ensembl
comparison variant_effect_predictor/Bio/EnsEMBL/DBSQL/UnmappedObjectAdaptor.pm @ 0:1f6dce3d34e0
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::UnmappedObjectAdaptor | |
24 | |
25 =head1 SYNOPSIS | |
26 | |
27 my $uoa = $database_adaptor->get_UnmappedObjectAdaptor(); | |
28 | |
29 my $missed = @{ $uoa->fetch_all_by_type('xref') }; | |
30 | |
31 =head1 DESCRIPTION | |
32 | |
33 Unmapped ObjectAdaptor - An adaptor responsible for the creation, | |
34 editing, retrieval of Unmapped Objects. These being the Objects that | |
35 where not mapped in a specific process i.e. xref, cDNA, Markers. | |
36 | |
37 =head1 METHODS | |
38 | |
39 =cut | |
40 | |
41 package Bio::EnsEMBL::DBSQL::UnmappedObjectAdaptor; | |
42 use vars qw(@ISA); | |
43 use strict; | |
44 | |
45 | |
46 use POSIX; | |
47 use Bio::EnsEMBL::Utils::Cache; | |
48 use Bio::EnsEMBL::Utils::Exception qw(throw warning); | |
49 use Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor; | |
50 use Bio::EnsEMBL::UnmappedObject; | |
51 use Bio::EnsEMBL::Analysis; | |
52 @ISA = qw(Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor); | |
53 | |
54 our %desc_to_id; | |
55 | |
56 =head2 new | |
57 | |
58 Arg [1] : list of args @args | |
59 Superclass constructor arguments | |
60 Example : none | |
61 Description: Constructor which just initializes internal cache structures | |
62 Returntype : Bio::EnsEMBL::DBSQL::UnmappedObjectAdaptor | |
63 Exceptions : none | |
64 Caller : implementing subclass constructors | |
65 Status : At Risk | |
66 | |
67 =cut | |
68 | |
69 sub new { | |
70 my $proto = shift; | |
71 | |
72 my $class = ref($proto) || $proto; | |
73 | |
74 my $self = $class->SUPER::new(@_); | |
75 | |
76 my $sth = | |
77 $self->prepare( "SELECT unmapped_reason_id, full_description " | |
78 . "FROM unmapped_reason" ); | |
79 | |
80 $sth->execute(); | |
81 | |
82 my ( $id, $desc ); | |
83 $sth->bind_columns( \( $id, $desc ) ); | |
84 | |
85 while ( $sth->fetch() ) { | |
86 $desc_to_id{$desc} = $id; | |
87 } | |
88 | |
89 $sth->finish(); | |
90 | |
91 return $self; | |
92 } | |
93 | |
94 | |
95 # _tables | |
96 # Arg [1] : none | |
97 # Description: PROTECTED implementation of superclass abstract method | |
98 # returns the names, aliases of the tables to use for queries | |
99 # Returntype : list of listrefs of strings | |
100 # Exceptions : none | |
101 # Caller : internal | |
102 # Status : At Risk | |
103 sub _tables { | |
104 my $self = shift; | |
105 | |
106 return (['unmapped_object', 'uo'], | |
107 ['unmapped_reason', 'ur']); | |
108 } | |
109 | |
110 | |
111 # _columns | |
112 # Arg [1] : none | |
113 # Example : none | |
114 # Description: PROTECTED implementation of superclass abstract method | |
115 # returns a list of columns to use for queries | |
116 # Returntype : list of strings | |
117 # Exceptions : none | |
118 # Caller : internal | |
119 # Status : At Risk | |
120 | |
121 sub _columns { | |
122 my $self = shift; | |
123 | |
124 return qw(uo.unmapped_object_id uo.type uo.analysis_id uo.external_db_id | |
125 uo.identifier uo.unmapped_reason_id uo.query_score uo.target_score | |
126 uo.ensembl_id uo.ensembl_object_type | |
127 ur.summary_description ur.full_description); | |
128 } | |
129 | |
130 sub _left_join { | |
131 return ( [ | |
132 'unmapped_object', "uo.unmapped_reason_id = ur.unmapped_reason_id" | |
133 ] ); | |
134 } | |
135 | |
136 =head2 list_dbIDs | |
137 | |
138 Arg [1] : none | |
139 Example : @unmapped_object_ids = @{$unmapped_object_adaptor->list_dbIDs()}; | |
140 Description: Gets an array of internal ids for all unmapped_objects in the current db | |
141 Returntype : list of ints | |
142 Exceptions : none | |
143 Caller : ? | |
144 Status : Stable | |
145 | |
146 =cut | |
147 | |
148 sub list_dbIDs { | |
149 my ($self) = @_; | |
150 | |
151 return $self->_list_dbIDs("unmapped_object"); | |
152 } | |
153 | |
154 =head2 list_unmapped_reasons | |
155 | |
156 Arg [1] : none | |
157 Example : @unmapped_object_reason+ids = | |
158 @{$unmapped_object_adaptor->list_unmapped_reasons()}; | |
159 Description: Gets an array of internal ids for all unmapped_objects in the current db | |
160 Returntype : list of ints | |
161 Exceptions : none | |
162 Caller : ? | |
163 Status : Stable | |
164 | |
165 =cut | |
166 | |
167 sub list_unmapped_reasons { | |
168 my ($self) = @_; | |
169 | |
170 return $self->_list_dbIDs("unmapped_reason"); | |
171 } | |
172 | |
173 | |
174 # _objs_from_sth | |
175 | |
176 # Arg [1] : StatementHandle $sth | |
177 # Example : none | |
178 # Description: PROTECTED implementation of abstract superclass method. | |
179 # responsible for the creation of UnmappedObjects | |
180 # Returntype : listref of Bio::EnsEMBL::UnmappedObjects | |
181 # Exceptions : none | |
182 # Caller : internal | |
183 # Status : At Risk | |
184 | |
185 sub _objs_from_sth { | |
186 my ($self, $sth) = @_; | |
187 | |
188 my($unmapped_object_id, $type, $analysis_id, $external_db_id, $identifier, | |
189 $unmapped_reason_id, $query_score, $target_score, $ensembl_id, | |
190 $ensembl_object_type, $summary, $full_desc); | |
191 | |
192 $sth->bind_columns(\$unmapped_object_id,\$type, \$analysis_id, | |
193 \$external_db_id, \$identifier, \$unmapped_reason_id, | |
194 \$query_score, \$target_score, \$ensembl_id, | |
195 \$ensembl_object_type, \$summary, \$full_desc); | |
196 | |
197 my $analysis_adaptor = $self->db->get_AnalysisAdaptor(); | |
198 | |
199 my @features; | |
200 while($sth->fetch()) { | |
201 my $analysis = $analysis_adaptor->fetch_by_dbID($analysis_id); | |
202 | |
203 #print "$identifier\n"; | |
204 | |
205 push( @features, | |
206 $self->_create_feature( | |
207 'Bio::EnsEMBL::UnmappedObject', { | |
208 -unmapped_object_id => $unmapped_object_id, | |
209 -unmapped_reason_id => $unmapped_reason_id, | |
210 -type => $type, | |
211 -analysis => $analysis, | |
212 -external_db_id => $external_db_id, | |
213 -identifier => $identifier, | |
214 -query_score => $query_score, | |
215 -target_score => $target_score, | |
216 -ensembl_id => $ensembl_id, | |
217 -ensembl_object_type => $ensembl_object_type, | |
218 -summary => $summary, | |
219 -full_desc => $full_desc, | |
220 -adaptor => $self | |
221 } ) ); | |
222 | |
223 } | |
224 return \@features; | |
225 } | |
226 | |
227 | |
228 | |
229 =head2 store | |
230 | |
231 Arg [1] : list of Bio::EnsEMBL::UnmappedObjects @uo | |
232 the unmapped objects to store in the database | |
233 Example : $ou_adaptor->store(@uo); | |
234 Description: Stores a list of unmapped objects in the database | |
235 Returntype : none | |
236 Exceptions : thrown if no Analysis, or no list of objects to store. | |
237 Caller : general | |
238 Status : Stable | |
239 | |
240 =cut | |
241 | |
242 sub store{ | |
243 my ($self,@uos) = @_; | |
244 | |
245 if( scalar(@uos) == 0 ) { | |
246 throw("Must call store with list of UnmappedObjects"); | |
247 } | |
248 | |
249 | |
250 my $db = $self->db(); | |
251 my $analysis_adaptor = $db->get_AnalysisAdaptor(); | |
252 | |
253 my $sth_reason = $self->prepare | |
254 ("INSERT INTO unmapped_reason (summary_description, full_description)". | |
255 " VALUES (?,?)"); | |
256 | |
257 my $sth_unmapped_object = $self->prepare | |
258 ("INSERT INTO unmapped_object (type, analysis_id, external_db_id, | |
259 identifier, unmapped_reason_id, query_score, target_score, | |
260 ensembl_id, ensembl_object_type)". | |
261 " VALUES (?,?,?,?,?,?,?,?,?)"); | |
262 | |
263 FEATURE: foreach my $uo ( @uos ) { | |
264 | |
265 if( !ref $uo || !$uo->isa("Bio::EnsEMBL::UnmappedObject") ) { | |
266 throw("UnmappedObject must be an Ensembl UnmappedObject, " . | |
267 "not a [".ref($uo)."]"); | |
268 } | |
269 if($uo->is_stored($db)){ | |
270 next; | |
271 } | |
272 | |
273 my $analysis = $uo->analysis(); | |
274 throw("UnmappedObject must have an analysis object.".$uo->analysis."\n") if(!defined($analysis)); | |
275 | |
276 my $analysis_id; | |
277 if($analysis->is_stored($db)) { | |
278 $analysis_id = $analysis->dbID(); | |
279 } else { | |
280 $analysis_id = $db->get_AnalysisAdaptor->store($analysis); | |
281 } | |
282 | |
283 #First check to see unmapped reason is stored | |
284 if(!defined($desc_to_id{$uo->{'description'}})){ | |
285 $sth_reason->bind_param(1,$uo->{'summary'},SQL_VARCHAR); | |
286 $sth_reason->bind_param(2,$uo->{'description'},SQL_VARCHAR); | |
287 $sth_reason->execute(); | |
288 $uo->{'unmapped_reason_id'} = $desc_to_id{$uo->{'description'}} | |
289 = $sth_reason->{'mysql_insertid'}; | |
290 | |
291 } | |
292 else{ | |
293 $uo->{'unmapped_reason_id'} = $desc_to_id{$uo->{'description'}} ; | |
294 } | |
295 $sth_unmapped_object->bind_param(1,$uo->{'type'},SQL_VARCHAR); | |
296 $sth_unmapped_object->bind_param(2,$uo->analysis->dbID,SQL_INTEGER); | |
297 $sth_unmapped_object->bind_param(3,$uo->{'external_db_id'},SQL_INTEGER); | |
298 $sth_unmapped_object->bind_param(4,$uo->{'identifier'},SQL_VARCHAR); | |
299 $sth_unmapped_object->bind_param(5,$uo->{'unmapped_reason_id'},SQL_VARCHAR); | |
300 $sth_unmapped_object->bind_param(6,$uo->{'query_score'},SQL_DOUBLE); | |
301 $sth_unmapped_object->bind_param(7,$uo->{'target_score'},SQL_DOUBLE); | |
302 $sth_unmapped_object->bind_param(8,$uo->{'ensembl_id'},SQL_INTEGER); | |
303 $sth_unmapped_object->bind_param(9,$uo->{'ensembl_object_type'},SQL_VARCHAR); | |
304 $sth_unmapped_object->execute(); | |
305 $uo->dbID($sth_unmapped_object->{'mysql_insertid'}); | |
306 } | |
307 $sth_reason->finish(); | |
308 return; | |
309 } | |
310 | |
311 | |
312 =head2 fetch_all_by_type | |
313 | |
314 Arg [1] : string type. The type of unmapped objects | |
315 Example : @unmapped_object = @{$uoa->fetch_all_by_type('xref')}; | |
316 Description : Retrieves all the unmapped object for a particular | |
317 type. e.g. 'xref','cDNA', 'marker' | |
318 Returntype : Array ref of Bio::EnsEMBL::UnmappedObject | |
319 Exceptions : none | |
320 Caller : general | |
321 Status : At Risk | |
322 | |
323 =cut | |
324 | |
325 sub fetch_all_by_type { | |
326 my ($self, $type) = @_; | |
327 | |
328 unless($type) { | |
329 throw("type argument is required"); | |
330 } | |
331 $self->bind_param_generic_fetch($type,SQL_VARCHAR); | |
332 $self->generic_fetch("uo.type = ?"); | |
333 | |
334 } | |
335 | |
336 =head2 fetch_all_by_analysis | |
337 | |
338 Arg [1] : Bio:EnsEMBL::Analysis object | |
339 Arg [2] : (optional) string database name | |
340 Example : @unmapped_object = @{$uoa->fetch_all_by_analysis($analysis)}; | |
341 Description : Retrieves all the unmapped object for a particular | |
342 analysis type with the the option of a particular | |
343 database type. | |
344 Returntype : array ref of Bio::EnsEMBL::UnmappedObject | |
345 Exceptions : thorws if first argument is not an anaylisi object | |
346 Caller : general | |
347 Status : At Risk | |
348 | |
349 =cut | |
350 | |
351 sub fetch_all_by_analysis { | |
352 my ($self, $analysis,$dbname) = @_; | |
353 | |
354 unless($analysis) { | |
355 throw("analysis argument is required"); | |
356 } | |
357 $self->bind_param_generic_fetch($analysis->dbID,SQL_INTEGER); | |
358 my $constraint = "uo.analysis_id = ?"; | |
359 if(defined($dbname)){ | |
360 my $db_id =0; | |
361 my $sth = $self->prepare('select external_db_id from external_db where db_name like "'. | |
362 $dbname.'"'); | |
363 $sth->execute; | |
364 $sth->bind_columns(\$db_id); | |
365 $sth->fetch(); | |
366 if(!defined($db_id) or $db_id == 0){ | |
367 throw("$dbname could not be found in the external database table\n"); | |
368 } | |
369 $self->bind_param_generic_fetch($db_id,SQL_INTEGER); | |
370 $constraint .= " AND uo.external_db_id = ?"; | |
371 } | |
372 $self->generic_fetch($constraint); | |
373 | |
374 } | |
375 | |
376 =head2 fetch_by_identifier | |
377 | |
378 Arg [1] : string type. The type of unmapped objects | |
379 Arg [2] : (optional) string database name | |
380 Example : @unmapped_object = @{$uoa->fetch_by_identifier('Q123345')}; | |
381 Description : Retrieves the unmapped object for a particular | |
382 identifier/accession | |
383 Returntype : array ref of Bio::EnsEMBL::UnmappedObject | |
384 Exceptions : none | |
385 Caller : general | |
386 Status : At Risk | |
387 | |
388 =cut | |
389 | |
390 sub fetch_by_identifier { | |
391 my ($self, $identifier, $dbname) = @_; | |
392 | |
393 unless($identifier) { | |
394 throw("identifier argument is required"); | |
395 } | |
396 $self->bind_param_generic_fetch($identifier,SQL_VARCHAR); | |
397 my $constraint = 'uo.identifier like ?'; | |
398 | |
399 if(defined($dbname)){ | |
400 my $db_id =0; | |
401 my $sth = $self->prepare('select external_db_id from external_db where db_name like "'. | |
402 $dbname.'"'); | |
403 $sth->execute; | |
404 $sth->bind_columns(\$db_id); | |
405 $sth->fetch(); | |
406 if(!defined($db_id) or $db_id == 0){ | |
407 throw("$dbname could not be found in the external database table\n"); | |
408 } | |
409 $self->bind_param_generic_fetch($db_id,SQL_INTEGER); | |
410 $constraint .= " AND uo.external_db_id = ?"; | |
411 } | |
412 return $self->generic_fetch($constraint); | |
413 } | |
414 | |
415 =head2 fetch_all_by_object_type_id | |
416 | |
417 Arg [1] : string - The object type of the ensembl object e.g. Gene | |
418 Arg [2] : int - The internal dbID of the ensembl object | |
419 Example : my @unmapped_objects = @{$uoa->fetch_all_by_object_type_id('Gene', 12341)}; | |
420 Description : Retrieves the unmapped objects for a particular ensembl object | |
421 This is a base method which should be called by wrapper methods | |
422 defining the correct object type e.g. $uoa->fetch_all_by_Gene($gene) | |
423 Returntype : array ref of Bio::EnsEMBL::UnmappedObject objects | |
424 Exceptions : Throws if arguments are not defined | |
425 Caller : general | |
426 Status : At Risk | |
427 | |
428 =cut | |
429 | |
430 sub fetch_all_by_object_type_id { | |
431 my ($self, $object_type, $dbid) = @_; | |
432 | |
433 if(! ($object_type && $dbid)){ | |
434 throw("object_type and dbid arguments required"); | |
435 } | |
436 | |
437 $self->bind_param_generic_fetch($object_type, SQL_VARCHAR); | |
438 $self->bind_param_generic_fetch($dbid, SQL_INTEGER); | |
439 | |
440 my $constraint = 'uo.ensembl_object_type=? and uo.ensembl_id=?'; | |
441 | |
442 return $self->generic_fetch($constraint); | |
443 } | |
444 | |
445 | |
446 | |
447 1; |