|
0
|
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::DBEntryAdaptor -
|
|
|
24 MySQL Database queries to load and store external object references.
|
|
|
25
|
|
|
26 =head1 SYNOPSIS
|
|
|
27
|
|
|
28 $db_entry_adaptor =
|
|
|
29 $registry->get_adaptor( 'Human', 'Core', 'DBEntry' );
|
|
|
30
|
|
|
31 $db_entry = $db_entry_adaptor->fetch_by_dbID($id);
|
|
|
32
|
|
|
33 my $gene_adaptor = $registry->get_adaptor( 'Human', 'Core', 'Gene' );
|
|
|
34
|
|
|
35 my $gene = $gene_adaptor->fetch_by_stable_id('ENSG00000101367');
|
|
|
36
|
|
|
37 @db_entries = @{ $db_entry_adaptor->fetch_all_by_Gene($gene) };
|
|
|
38 @gene_ids = $db_entry_adaptor->list_gene_ids_by_extids('BAB15482');
|
|
|
39
|
|
|
40 =head1 METHODS
|
|
|
41
|
|
|
42 =cut
|
|
|
43
|
|
|
44 package Bio::EnsEMBL::DBSQL::DBEntryAdaptor;
|
|
|
45
|
|
|
46 use Bio::EnsEMBL::DBSQL::BaseAdaptor;
|
|
|
47
|
|
|
48 use Bio::EnsEMBL::DBEntry;
|
|
|
49 use Bio::EnsEMBL::IdentityXref;
|
|
|
50 use Bio::EnsEMBL::OntologyXref;
|
|
|
51
|
|
|
52 use Bio::EnsEMBL::Utils::Exception qw(deprecate throw warning);
|
|
|
53
|
|
|
54 use vars qw(@ISA);
|
|
|
55 use strict;
|
|
|
56
|
|
|
57 @ISA = qw( Bio::EnsEMBL::DBSQL::BaseAdaptor );
|
|
|
58
|
|
|
59 =head2 fetch_by_dbID
|
|
|
60
|
|
|
61 Arg [1] : int $dbID
|
|
|
62 the unique database identifier for the DBEntry to retrieve
|
|
|
63 Example : my $db_entry = $db_entry_adaptor->fetch_by_dbID($dbID);
|
|
|
64 Description: Retrieves a dbEntry from the database via its unique
|
|
|
65 identifier.
|
|
|
66 Returntype : Bio::EnsEMBL::DBEntry
|
|
|
67 Exceptions : none
|
|
|
68 Caller : general
|
|
|
69 Status : Stable
|
|
|
70
|
|
|
71 =cut
|
|
|
72
|
|
|
73 sub fetch_by_dbID {
|
|
|
74 my ( $self, $dbID ) = @_;
|
|
|
75
|
|
|
76 my $sth = $self->prepare(
|
|
|
77 "SELECT xref.xref_id,
|
|
|
78 xref.dbprimary_acc,
|
|
|
79 xref.display_label,
|
|
|
80 xref.version,
|
|
|
81 exDB.priority,
|
|
|
82 exDB.db_name,
|
|
|
83 exDB.db_display_name,
|
|
|
84 exDB.db_release,
|
|
|
85 es.synonym,
|
|
|
86 xref.info_type,
|
|
|
87 xref.info_text,
|
|
|
88 exDB.type,
|
|
|
89 exDB.secondary_db_name,
|
|
|
90 exDB.secondary_db_table,
|
|
|
91 xref.description
|
|
|
92 FROM (xref, external_db exDB)
|
|
|
93 LEFT JOIN external_synonym es ON
|
|
|
94 es.xref_id = xref.xref_id
|
|
|
95 WHERE xref.xref_id = ?
|
|
|
96 AND xref.external_db_id = exDB.external_db_id" );
|
|
|
97
|
|
|
98 $sth->bind_param( 1, $dbID, SQL_INTEGER );
|
|
|
99 $sth->execute();
|
|
|
100
|
|
|
101 my $exDB;
|
|
|
102
|
|
|
103 my $max_rows = 1000;
|
|
|
104
|
|
|
105 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
106 #$description refers to the external_db description, while $desc was referring the xref description
|
|
|
107 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
108 my ( $refID, $dbprimaryId,
|
|
|
109 $displayid, $version,
|
|
|
110 $priority,
|
|
|
111 $dbname, $db_display_name,
|
|
|
112 $release, $synonym,
|
|
|
113 $info_type, $info_text,
|
|
|
114 $type, $secondary_db_name,
|
|
|
115 $secondary_db_table, $description
|
|
|
116 ) = @$arrayref;
|
|
|
117
|
|
|
118 if ( !defined($exDB) ) {
|
|
|
119 $exDB =
|
|
|
120 Bio::EnsEMBL::DBEntry->new(
|
|
|
121 -adaptor => $self,
|
|
|
122 -dbID => $dbID,
|
|
|
123 -primary_id => $dbprimaryId,
|
|
|
124 -display_id => $displayid,
|
|
|
125 -version => $version,
|
|
|
126 -release => $release,
|
|
|
127 -dbname => $dbname,
|
|
|
128 -priority => $priority,
|
|
|
129 -db_display_name => $db_display_name,
|
|
|
130 -info_type => $info_type,
|
|
|
131 -info_text => $info_text,
|
|
|
132 -type => $type,
|
|
|
133 -secondary_db_name => $secondary_db_name,
|
|
|
134 -secondary_db_table => $secondary_db_table,
|
|
|
135 -description => $description
|
|
|
136 );
|
|
|
137
|
|
|
138
|
|
|
139 }
|
|
|
140
|
|
|
141 if ( defined($synonym) ) { $exDB->add_synonym($synonym) }
|
|
|
142
|
|
|
143 } ## end while ( my $arrayref = shift...
|
|
|
144 } ## end while ( my $rowcache = $sth...
|
|
|
145
|
|
|
146 $sth->finish();
|
|
|
147
|
|
|
148 return $exDB;
|
|
|
149 } ## end sub fetch_by_dbID
|
|
|
150
|
|
|
151
|
|
|
152 sub _get_all_dm_loc_sth {
|
|
|
153 my ($self, $constraint ,$ensembl_object ) = @_;
|
|
|
154 my $object_type;
|
|
|
155 if($ensembl_object->isa("Bio::EnsEMBL::Gene")){
|
|
|
156 $object_type = "Gene";
|
|
|
157 }
|
|
|
158 elsif($ensembl_object->isa("Bio::EnsEMBL::Transcript")){
|
|
|
159 $object_type = "Transcript";
|
|
|
160 }
|
|
|
161 elsif($ensembl_object->isa("Bio::EnsEMBL::Translation")){
|
|
|
162 $object_type = "Translation";
|
|
|
163 }
|
|
|
164 elsif($ensembl_object->isa("Bio::EnsEMBL::Operon")){
|
|
|
165 $object_type = "Operon";
|
|
|
166 }
|
|
|
167 elsif($ensembl_object->isa("Bio::EnsEMBL::OperonTranscript")){
|
|
|
168 $object_type = "OperonTranscript";
|
|
|
169 }
|
|
|
170 else{
|
|
|
171 warn(ref($ensembl_object)." is not a Gene Transcript or Translation object??\n");
|
|
|
172 return undef;
|
|
|
173 }
|
|
|
174 my $sql = "SELECT xref.xref_id,
|
|
|
175 xref.dbprimary_acc,
|
|
|
176 xref.display_label,
|
|
|
177 xref.version,
|
|
|
178 exDB.priority,
|
|
|
179 exDB.db_name,
|
|
|
180 exDB.db_display_name,
|
|
|
181 exDB.db_release,
|
|
|
182 es.synonym,
|
|
|
183 xref.info_type,
|
|
|
184 xref.info_text,
|
|
|
185 exDB.type,
|
|
|
186 exDB.secondary_db_name,
|
|
|
187 exDB.secondary_db_table,
|
|
|
188 xref.description
|
|
|
189 FROM (xref, external_db exDB, dependent_xref dx, object_xref ox)
|
|
|
190 LEFT JOIN external_synonym es ON
|
|
|
191 es.xref_id = xref.xref_id
|
|
|
192 WHERE xref.external_db_id = exDB.external_db_id AND
|
|
|
193 ox.xref_id = xref.xref_id AND
|
|
|
194 ox.ensembl_object_type = \'$object_type\' AND
|
|
|
195 ox.ensembl_id = ".$ensembl_object->dbID();
|
|
|
196
|
|
|
197 if($constraint){
|
|
|
198 $sql .= " AND $constraint";
|
|
|
199 }
|
|
|
200 else{
|
|
|
201 die "NO constraint???\n";
|
|
|
202 }
|
|
|
203
|
|
|
204 my $sth = $self->prepare($sql) || die "Could not prepare $sql";
|
|
|
205
|
|
|
206 return $self->_get_all_dm($sth);
|
|
|
207 }
|
|
|
208
|
|
|
209 sub _get_all_dm_sth {
|
|
|
210 my ( $self, $constraint) = @_;
|
|
|
211
|
|
|
212 my $sql = "SELECT xref.xref_id,
|
|
|
213 xref.dbprimary_acc,
|
|
|
214 xref.display_label,
|
|
|
215 xref.version,
|
|
|
216 exDB.priority,
|
|
|
217 exDB.db_name,
|
|
|
218 exDB.db_display_name,
|
|
|
219 exDB.db_release,
|
|
|
220 es.synonym,
|
|
|
221 xref.info_type,
|
|
|
222 xref.info_text,
|
|
|
223 exDB.type,
|
|
|
224 exDB.secondary_db_name,
|
|
|
225 exDB.secondary_db_table,
|
|
|
226 xref.description
|
|
|
227 FROM (xref, external_db exDB, dependent_xref dx)
|
|
|
228 LEFT JOIN external_synonym es ON
|
|
|
229 es.xref_id = xref.xref_id
|
|
|
230 WHERE xref.external_db_id = exDB.external_db_id ";
|
|
|
231
|
|
|
232 if($constraint){
|
|
|
233 $sql .= "AND $constraint";
|
|
|
234 }
|
|
|
235 else{
|
|
|
236 die "NO constraint???\n";
|
|
|
237 }
|
|
|
238
|
|
|
239 my $sth = $self->prepare($sql) || die "Could not prepare $sql";
|
|
|
240
|
|
|
241 return $self->_get_all_dm($sth);
|
|
|
242 }
|
|
|
243
|
|
|
244
|
|
|
245 sub _get_all_dm{
|
|
|
246
|
|
|
247 my ($self, $sth) = @_;
|
|
|
248
|
|
|
249 # $sth->bind_param( 1, $dm_dbid, SQL_INTEGER );
|
|
|
250
|
|
|
251 # print $sth."\n";
|
|
|
252 $sth->execute() || die "Not able to execute statement handle";
|
|
|
253
|
|
|
254 my @list =();
|
|
|
255 my %seen;
|
|
|
256
|
|
|
257 my $max_rows = 1000;
|
|
|
258 while ( my $rowcache = $sth->fetchall_arrayref(undef, $max_rows) ) {
|
|
|
259 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
260 my ( $dbID, $dbprimaryId,
|
|
|
261 $displayid, $version,
|
|
|
262 $priority,
|
|
|
263 $dbname, $db_display_name,
|
|
|
264 $release, $synonym,
|
|
|
265 $info_type, $info_text,
|
|
|
266 $type, $secondary_db_name,
|
|
|
267 $secondary_db_table, $description
|
|
|
268 ) = @$arrayref;
|
|
|
269
|
|
|
270 if ( !defined($seen{$dbID}) ) {
|
|
|
271 my $exDB =
|
|
|
272 Bio::EnsEMBL::DBEntry->new(
|
|
|
273 -adaptor => $self,
|
|
|
274 -dbID => $dbID,
|
|
|
275 -primary_id => $dbprimaryId,
|
|
|
276 -display_id => $displayid,
|
|
|
277 -version => $version,
|
|
|
278 -release => $release,
|
|
|
279 -dbname => $dbname,
|
|
|
280 -priority => $priority,
|
|
|
281 -db_display_name => $db_display_name,
|
|
|
282 -info_type => $info_type,
|
|
|
283 -info_text => $info_text,
|
|
|
284 -type => $type,
|
|
|
285 -secondary_db_name => $secondary_db_name,
|
|
|
286 -secondary_db_table => $secondary_db_table,
|
|
|
287 -description => $description
|
|
|
288 );
|
|
|
289
|
|
|
290 if ($synonym) { $exDB->add_synonym($synonym) };
|
|
|
291 $seen{$dbID} = 1;
|
|
|
292 push @list, $exDB;
|
|
|
293 }
|
|
|
294
|
|
|
295
|
|
|
296
|
|
|
297 } ## end while ( my $arrayref = shift...
|
|
|
298 } ## end while ( my $rowcache = $sth...
|
|
|
299
|
|
|
300 $sth->finish();
|
|
|
301
|
|
|
302 return \@list;
|
|
|
303
|
|
|
304 }
|
|
|
305
|
|
|
306
|
|
|
307 =head2 get_all_dependents
|
|
|
308
|
|
|
309 Args[1] : dbID of the DBentry to get the dependents of.
|
|
|
310 Args[2] : (optional) Bio::EnsEMBL::Gene, Transcript or Translation object
|
|
|
311 Example : my @dependents = @{ $dbe_adaptor->get_all_dependents(1234) };
|
|
|
312 Description: Get a list of DBEntrys that are depenednet on the DBEntry.
|
|
|
313 if an ensembl gene transcript or translation is given then only
|
|
|
314 the ones on that object will be given
|
|
|
315 Returntype : listref of DBEntrys. May be empty.
|
|
|
316 Exceptions : none
|
|
|
317 Caller : DBEntry->get_all_dependnets
|
|
|
318 Status : UnStable
|
|
|
319
|
|
|
320 =cut
|
|
|
321
|
|
|
322 sub get_all_dependents {
|
|
|
323 my ( $self, $dbid, $ensembl_object) = @_;
|
|
|
324
|
|
|
325 if(defined($ensembl_object) and !($ensembl_object->isa("Bio::EnsEMBL::Feature") or $ensembl_object->isa("Bio::EnsEMBL::Translation"))){
|
|
|
326 die ref($ensembl_object)." is not an Gene Transcript or Translation";
|
|
|
327 }
|
|
|
328
|
|
|
329 my $constraint = " dx.master_xref_id = $dbid AND dx.dependent_xref_id = xref.xref_id";
|
|
|
330 if(defined($ensembl_object)){
|
|
|
331 return $self->_get_all_dm_loc_sth($constraint, $ensembl_object);
|
|
|
332 }
|
|
|
333 else{
|
|
|
334 return $self->_get_all_dm_sth($constraint, $ensembl_object);
|
|
|
335 }
|
|
|
336
|
|
|
337 }
|
|
|
338
|
|
|
339 =head2 get_all_masters
|
|
|
340
|
|
|
341 Args[1] : dbID of the DBentry to get the masters of.
|
|
|
342 Args[2] : (optional) Bio::EnsEMBL::Gene, Transcript or Translation object
|
|
|
343 Example : my @masters = @{ $dbe_adaptor->get_all_masters(1234) };
|
|
|
344 Description: Get a list of DBEntrys that are the masters of the DBEntry.
|
|
|
345 if an ensembl gene transcript or translation is given then only
|
|
|
346 the ones on that object will be given.
|
|
|
347 Returntype : listref of DBEntrys. May be empty.
|
|
|
348 Exceptions : none
|
|
|
349 Caller : DBEntry->get_all_masters
|
|
|
350 Status : UnStable
|
|
|
351
|
|
|
352 =cut
|
|
|
353
|
|
|
354 sub get_all_masters {
|
|
|
355 my ( $self, $dbid, $ensembl_object ) = @_;
|
|
|
356
|
|
|
357 if(defined($ensembl_object) and !($ensembl_object->isa("Bio::EnsEMBL::Feature") or $ensembl_object->isa("Bio::EnsEMBL::Translation"))){
|
|
|
358 die ref($ensembl_object)." is not an Gene Transcript or Translation";
|
|
|
359 }
|
|
|
360
|
|
|
361 my $constraint = "dx.dependent_xref_id = $dbid AND dx.master_xref_id = xref.xref_id";
|
|
|
362
|
|
|
363 if(defined($ensembl_object)){
|
|
|
364 return $self->_get_all_dm_loc_sth($constraint, $ensembl_object);
|
|
|
365 }
|
|
|
366 else{
|
|
|
367 return $self->_get_all_dm_sth($constraint, $ensembl_object);
|
|
|
368 }
|
|
|
369 # return $self->_get_all_dm($constraint, $ensembl_object);
|
|
|
370 }
|
|
|
371
|
|
|
372
|
|
|
373 =head fetch_all_by_name
|
|
|
374
|
|
|
375 Arg [1] : string $name - The name of the external reference.
|
|
|
376 found in accession, display_label or synonym
|
|
|
377 Arg [2] : (optional) string $dbname - The name of the database which
|
|
|
378 the provided name is for.
|
|
|
379
|
|
|
380 Example : my $xref = @{$dbea->fetch_all_by_name('BRAC2','HGNC')}[0];
|
|
|
381 print $xref->description(), "\n" if($xref);
|
|
|
382 Description: Retrieves list of DBEntrys (xrefs) via a name.
|
|
|
383 The accesion is looked for first then the synonym and finally
|
|
|
384 the display_label.
|
|
|
385 NOTE $dbname this is optional but adding this speeds the
|
|
|
386 process up if you know what you are looking for.
|
|
|
387
|
|
|
388 NOTE: In a multi-species database, this method will
|
|
|
389 return all the entries matching the search criteria, not
|
|
|
390 just the ones associated with the current species.
|
|
|
391 Returntype : Bio::EnsEMBL::DBSQL::DBEntry
|
|
|
392 Exceptions : thrown if arguments are incorrect
|
|
|
393 Caller : general, domainview
|
|
|
394 Status : Stable
|
|
|
395
|
|
|
396 =cut
|
|
|
397
|
|
|
398 sub fetch_all_by_name {
|
|
|
399 my ( $self, $name, $dbname ) = @_;
|
|
|
400
|
|
|
401 my $sql = (<<SQL);
|
|
|
402 SELECT xref.xref_id, xref.dbprimary_acc, xref.display_label, xref.version,
|
|
|
403 exDB.priority, exDB.db_name, exDB.db_display_name, exDB.db_release,
|
|
|
404 es.synonym, xref.info_type, xref.info_text,
|
|
|
405 exDB.type, exDB.secondary_db_name, exDB.secondary_db_table,
|
|
|
406 xref.description
|
|
|
407 FROM (xref, external_db exDB)
|
|
|
408 LEFT JOIN external_synonym es ON
|
|
|
409 es.xref_id = xref.xref_id
|
|
|
410 WHERE (xref.dbprimary_acc = ? or xref.display_label = ?)
|
|
|
411 AND xref.external_db_id = exDB.external_db_id
|
|
|
412 SQL
|
|
|
413
|
|
|
414 if(defined $dbname){
|
|
|
415 $sql .= " AND exDB.db_name = ?";
|
|
|
416 }
|
|
|
417 my $sth = $self->prepare($sql);
|
|
|
418 $sth->bind_param( 1, $name, SQL_VARCHAR );
|
|
|
419 $sth->bind_param( 2, $name, SQL_VARCHAR );
|
|
|
420 if(defined $dbname){
|
|
|
421 $sth->bind_param( 3 , $dbname, SQL_VARCHAR );
|
|
|
422 }
|
|
|
423 $sth->execute();
|
|
|
424
|
|
|
425
|
|
|
426 if ( !$sth->rows() && lc($dbname) eq 'interpro' ) {
|
|
|
427 # This is a minor hack that means that results still come back even
|
|
|
428 # when a mistake was made and no interpro accessions were loaded into
|
|
|
429 # the xref table. This has happened in the past and had the result of
|
|
|
430 # breaking domainview
|
|
|
431
|
|
|
432 $sth->finish();
|
|
|
433 $sth = $self->prepare(
|
|
|
434 "SELECT NULL,
|
|
|
435 i.interpro_ac,
|
|
|
436 i.id,
|
|
|
437 NULL,
|
|
|
438 NULL,
|
|
|
439 'Interpro',
|
|
|
440 NULL,
|
|
|
441 NULL
|
|
|
442 FROM interpro i
|
|
|
443 WHERE i.interpro_ac = ?" );
|
|
|
444
|
|
|
445 $sth->bind_param( 1, $name, SQL_VARCHAR );
|
|
|
446 $sth->execute();
|
|
|
447 }
|
|
|
448
|
|
|
449 my %exDB;
|
|
|
450 my @exDBlist;
|
|
|
451 my $max_rows = 1000;
|
|
|
452
|
|
|
453 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
454 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
455 my ( $dbID, $dbprimaryId,
|
|
|
456 $displayid, $version,
|
|
|
457 $priority,
|
|
|
458 $dbname, $db_display_name,
|
|
|
459 $release, $synonym,
|
|
|
460 $info_type, $info_text,
|
|
|
461 $type, $secondary_db_name,
|
|
|
462 $secondary_db_table, $description
|
|
|
463 ) = @$arrayref;
|
|
|
464
|
|
|
465 if ( !defined $exDB{$dbID} ) {
|
|
|
466 my $entrie =
|
|
|
467 Bio::EnsEMBL::DBEntry->new(
|
|
|
468 -adaptor => $self,
|
|
|
469 -dbID => $dbID,
|
|
|
470 -primary_id => $dbprimaryId,
|
|
|
471 -display_id => $displayid,
|
|
|
472 -version => $version,
|
|
|
473 -release => $release,
|
|
|
474 -dbname => $dbname,
|
|
|
475 -priority => $priority,
|
|
|
476 -db_display_name => $db_display_name,
|
|
|
477 -info_type => $info_type,
|
|
|
478 -info_text => $info_text,
|
|
|
479 -type => $type,
|
|
|
480 -secondary_db_name => $secondary_db_name,
|
|
|
481 -secondary_db_table => $secondary_db_table,
|
|
|
482 -description => $description
|
|
|
483 );
|
|
|
484 $exDB{$dbID} = $entrie;
|
|
|
485 push @exDBlist, $entrie;
|
|
|
486 }
|
|
|
487 if ($synonym) { $exDB{$dbID}->add_synonym($synonym) }
|
|
|
488
|
|
|
489 } ## end while ( my $arrayref = shift...
|
|
|
490 } ## end while ( my $rowcache = $sth...
|
|
|
491
|
|
|
492 $sth->finish();
|
|
|
493
|
|
|
494 return \@exDBlist;
|
|
|
495 } ## end sub fetch_all_by_name
|
|
|
496
|
|
|
497
|
|
|
498
|
|
|
499 =head2 fetch_by_db_accession
|
|
|
500
|
|
|
501 Arg [1] : string $dbname - The name of the database which the provided
|
|
|
502 accession is for.
|
|
|
503 Arg [2] : string $accession - The accesion of the external reference to
|
|
|
504 retrieve.
|
|
|
505 Example : my $xref = $dbea->fetch_by_db_accession('Interpro','IPR003439');
|
|
|
506 print $xref->description(), "\n" if($xref);
|
|
|
507 Description: Retrieves a DBEntry (xref) via the name of the database
|
|
|
508 it is from and its primary accession in that database.
|
|
|
509 Undef is returned if the xref cannot be found in the
|
|
|
510 database.
|
|
|
511 NOTE: In a multi-species database, this method will
|
|
|
512 return all the entries matching the search criteria, not
|
|
|
513 just the ones associated with the current species.
|
|
|
514 Returntype : Bio::EnsEMBL::DBSQL::DBEntry
|
|
|
515 Exceptions : thrown if arguments are incorrect
|
|
|
516 Caller : general, domainview
|
|
|
517 Status : Stable
|
|
|
518
|
|
|
519 =cut
|
|
|
520
|
|
|
521 sub fetch_by_db_accession {
|
|
|
522 my ( $self, $dbname, $accession ) = @_;
|
|
|
523
|
|
|
524 my $sth = $self->prepare(
|
|
|
525 "SELECT xref.xref_id,
|
|
|
526 xref.dbprimary_acc,
|
|
|
527 xref.display_label,
|
|
|
528 xref.version,
|
|
|
529 exDB.priority,
|
|
|
530 exDB.db_name,
|
|
|
531 exDB.db_display_name,
|
|
|
532 exDB.db_release,
|
|
|
533 es.synonym,
|
|
|
534 xref.info_type,
|
|
|
535 xref.info_text,
|
|
|
536 exDB.type,
|
|
|
537 exDB.secondary_db_name,
|
|
|
538 exDB.secondary_db_table,
|
|
|
539 xref.description
|
|
|
540 FROM (xref, external_db exDB)
|
|
|
541 LEFT JOIN external_synonym es ON
|
|
|
542 es.xref_id = xref.xref_id
|
|
|
543 WHERE xref.dbprimary_acc = ?
|
|
|
544 AND exDB.db_name = ?
|
|
|
545 AND xref.external_db_id = exDB.external_db_id" );
|
|
|
546
|
|
|
547 $sth->bind_param( 1, $accession, SQL_VARCHAR );
|
|
|
548 $sth->bind_param( 2, $dbname, SQL_VARCHAR );
|
|
|
549 $sth->execute();
|
|
|
550
|
|
|
551 if ( !$sth->rows() && lc($dbname) eq 'interpro' ) {
|
|
|
552 # This is a minor hack that means that results still come back even
|
|
|
553 # when a mistake was made and no interpro accessions were loaded into
|
|
|
554 # the xref table. This has happened in the past and had the result of
|
|
|
555 # breaking domainview
|
|
|
556
|
|
|
557 $sth->finish();
|
|
|
558 $sth = $self->prepare(
|
|
|
559 "SELECT NULL,
|
|
|
560 i.interpro_ac,
|
|
|
561 i.id,
|
|
|
562 NULL,
|
|
|
563 NULL,
|
|
|
564 'Interpro',
|
|
|
565 NULL,
|
|
|
566 NULL
|
|
|
567 FROM interpro i
|
|
|
568 WHERE i.interpro_ac = ?" );
|
|
|
569
|
|
|
570 $sth->bind_param( 1, $accession, SQL_VARCHAR );
|
|
|
571 $sth->execute();
|
|
|
572 }
|
|
|
573
|
|
|
574 my $exDB;
|
|
|
575
|
|
|
576 my $max_rows = 1000;
|
|
|
577
|
|
|
578 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
579 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
580 my ( $dbID, $dbprimaryId,
|
|
|
581 $displayid, $version,
|
|
|
582 $priority,
|
|
|
583 $dbname, $db_display_name,
|
|
|
584 $release, $synonym,
|
|
|
585 $info_type, $info_text,
|
|
|
586 $type, $secondary_db_name,
|
|
|
587 $secondary_db_table, $description
|
|
|
588 ) = @$arrayref;
|
|
|
589
|
|
|
590 if ( !defined($exDB) ) {
|
|
|
591 $exDB =
|
|
|
592 Bio::EnsEMBL::DBEntry->new(
|
|
|
593 -adaptor => $self,
|
|
|
594 -dbID => $dbID,
|
|
|
595 -primary_id => $dbprimaryId,
|
|
|
596 -display_id => $displayid,
|
|
|
597 -version => $version,
|
|
|
598 -release => $release,
|
|
|
599 -dbname => $dbname,
|
|
|
600 -priority => $priority,
|
|
|
601 -db_display_name => $db_display_name,
|
|
|
602 -info_type => $info_type,
|
|
|
603 -info_text => $info_text,
|
|
|
604 -type => $type,
|
|
|
605 -secondary_db_name => $secondary_db_name,
|
|
|
606 -secondary_db_table => $secondary_db_table,
|
|
|
607 -description => $description
|
|
|
608 );
|
|
|
609
|
|
|
610
|
|
|
611 }
|
|
|
612
|
|
|
613 if ($synonym) { $exDB->add_synonym($synonym) }
|
|
|
614
|
|
|
615 } ## end while ( my $arrayref = shift...
|
|
|
616 } ## end while ( my $rowcache = $sth...
|
|
|
617
|
|
|
618 $sth->finish();
|
|
|
619
|
|
|
620 return $exDB;
|
|
|
621 } ## end sub fetch_by_db_accession
|
|
|
622
|
|
|
623
|
|
|
624 =head2 store
|
|
|
625
|
|
|
626 Arg [1] : Bio::EnsEMBL::DBEntry $dbEntry
|
|
|
627 The DBEntry (xref) to be stored
|
|
|
628 Arg [2] : Int $ensID
|
|
|
629 The dbID of an EnsEMBL object to associate with this external
|
|
|
630 database entry
|
|
|
631 Arg [3] : string $ensType ('Transcript', 'Translation', 'Gene')
|
|
|
632 The type of EnsEMBL object that this external database entry is
|
|
|
633 being associated with.
|
|
|
634 Arg [4] : boolean $ignore_release
|
|
|
635 If unset or zero, will require that the release string
|
|
|
636 of the DBEntry object is identical to the release of the
|
|
|
637 external database. If set and non-zero, will ignore the
|
|
|
638 release information.
|
|
|
639 Example : $dbea->store($db_entry, $transcript_id, 'Transcript');
|
|
|
640 Description: Stores a reference to an external database (if it is not stored
|
|
|
641 already) and associates an EnsEMBL object of a specified type
|
|
|
642 with the external identifier.
|
|
|
643 Returntype : int - the dbID of the newly created external refernce
|
|
|
644 Exceptions : thrown when invalid dbID is passed to this method
|
|
|
645 Caller : scripts which load Xrefs and ObjectXrefs, etc. into Ensembl
|
|
|
646 Status : Stable
|
|
|
647
|
|
|
648 =cut
|
|
|
649
|
|
|
650 sub store {
|
|
|
651 my ( $self, $dbEntry, $ensID, $ensType, $ignore_release ) = @_;
|
|
|
652
|
|
|
653 my $dbJustInserted;
|
|
|
654
|
|
|
655 #
|
|
|
656 # backwards compatibility check:
|
|
|
657 # check if $ensID is an object; if so, use $obj->dbID
|
|
|
658 #
|
|
|
659 my $ensembl_id;
|
|
|
660
|
|
|
661 if ( defined($ensID) ) {
|
|
|
662 if ( $ensID =~ /^\d+$/ ) {
|
|
|
663 $ensembl_id = $ensID;
|
|
|
664 } elsif ( ref($ensID) eq 'Bio::EnsEMBL::Gene'
|
|
|
665 or ref($ensID) eq 'Bio::EnsEMBL::Transcript'
|
|
|
666 or ref($ensID) eq 'Bio::EnsEMBL::Translation'
|
|
|
667 or ref($ensID) eq 'Bio::EnsEMBL::OperonTranscript'
|
|
|
668 or ref($ensID) eq 'Bio::EnsEMBL::Operon'
|
|
|
669 )
|
|
|
670 {
|
|
|
671 warning( "You should pass DBEntryAdaptor->store() "
|
|
|
672 . "a dbID rather than an ensembl object "
|
|
|
673 . "to store the xref on" );
|
|
|
674
|
|
|
675 if ( defined( $ensID->dbID() ) ) {
|
|
|
676 $ensembl_id = $ensID->dbID();
|
|
|
677 } else {
|
|
|
678 throw( sprintf( "%s %s doesn't have a dbID, can't store xref",
|
|
|
679 $ensType, $ensID->display_id() ) );
|
|
|
680 }
|
|
|
681 } else {
|
|
|
682 throw("Invalid dbID passed to DBEntryAdaptor->store()");
|
|
|
683 }
|
|
|
684 }
|
|
|
685
|
|
|
686
|
|
|
687
|
|
|
688 # Ensure external_db contains a record of the intended xref source
|
|
|
689 my $dbRef;
|
|
|
690 $dbRef = $self->_check_external_db($dbEntry,$ignore_release);
|
|
|
691
|
|
|
692 # Attempt to insert DBEntry
|
|
|
693 my $xref_id = $self->_store_or_fetch_xref($dbEntry,$dbRef);
|
|
|
694 $dbEntry->dbID($xref_id); #keeps DBEntry in sync with database
|
|
|
695 ### Attempt to create an object->xref mapping
|
|
|
696 if ($ensembl_id) {$self->_store_object_xref_mapping($ensembl_id,$dbEntry,$ensType)};
|
|
|
697
|
|
|
698 return $xref_id;
|
|
|
699 }
|
|
|
700
|
|
|
701 sub _store_object_xref_mapping {
|
|
|
702 my $self = shift;
|
|
|
703 my $ensembl_id = shift;
|
|
|
704 my $dbEntry = shift;
|
|
|
705 my $ensembl_type = shift;
|
|
|
706
|
|
|
707 if (not defined ($ensembl_type)) { warning("No Ensembl data type provided for new xref");}
|
|
|
708
|
|
|
709 my $analysis_id;
|
|
|
710 if ( $dbEntry->analysis() ) {
|
|
|
711 $analysis_id = $self->db()->get_AnalysisAdaptor->store( $dbEntry->analysis() );
|
|
|
712 } else {
|
|
|
713 $analysis_id = 0; ## This used to be undef, but uniqueness in mysql requires a value
|
|
|
714 }
|
|
|
715
|
|
|
716 my $sth = $self->prepare(qq(
|
|
|
717 INSERT IGNORE INTO object_xref
|
|
|
718 SET xref_id = ?,
|
|
|
719 ensembl_object_type = ?,
|
|
|
720 ensembl_id = ?,
|
|
|
721 linkage_annotation = ?,
|
|
|
722 analysis_id = ? )
|
|
|
723 );
|
|
|
724 $sth->bind_param( 1, $dbEntry->dbID(), SQL_INTEGER );
|
|
|
725 $sth->bind_param( 2, $ensembl_type, SQL_VARCHAR );
|
|
|
726 $sth->bind_param( 3, $ensembl_id, SQL_INTEGER );
|
|
|
727 $sth->bind_param( 4, $dbEntry->linkage_annotation(),SQL_VARCHAR );
|
|
|
728 $sth->bind_param( 5, $analysis_id, SQL_INTEGER );
|
|
|
729 $sth->execute();
|
|
|
730 $sth->finish();
|
|
|
731 my $object_xref_id = $self->last_insert_id();
|
|
|
732
|
|
|
733 $dbEntry->adaptor($self); # hand Adaptor to dbEntry for future use with OntologyXrefs
|
|
|
734
|
|
|
735 if ($object_xref_id) {
|
|
|
736 #no existing object_xref, therefore
|
|
|
737 if ( $dbEntry->isa('Bio::EnsEMBL::IdentityXref') ) {
|
|
|
738 $sth = $self->prepare( "
|
|
|
739 INSERT ignore INTO identity_xref
|
|
|
740 SET object_xref_id = ?,
|
|
|
741 xref_identity = ?,
|
|
|
742 ensembl_identity = ?,
|
|
|
743 xref_start = ?,
|
|
|
744 xref_end = ?,
|
|
|
745 ensembl_start = ?,
|
|
|
746 ensembl_end = ?,
|
|
|
747 cigar_line = ?,
|
|
|
748 score = ?,
|
|
|
749 evalue = ?" );
|
|
|
750 $sth->bind_param( 1, $object_xref_id, SQL_INTEGER );
|
|
|
751 $sth->bind_param( 2, $dbEntry->xref_identity, SQL_INTEGER );
|
|
|
752 $sth->bind_param( 3, $dbEntry->ensembl_identity, SQL_INTEGER );
|
|
|
753 $sth->bind_param( 4, $dbEntry->xref_start, SQL_INTEGER );
|
|
|
754 $sth->bind_param( 5, $dbEntry->xref_end, SQL_INTEGER );
|
|
|
755 $sth->bind_param( 6, $dbEntry->ensembl_start, SQL_INTEGER );
|
|
|
756 $sth->bind_param( 7, $dbEntry->ensembl_end, SQL_INTEGER );
|
|
|
757 $sth->bind_param( 8, $dbEntry->cigar_line, SQL_LONGVARCHAR );
|
|
|
758 $sth->bind_param( 9, $dbEntry->score, SQL_DOUBLE );
|
|
|
759 $sth->bind_param( 10, $dbEntry->evalue, SQL_DOUBLE );
|
|
|
760 $sth->execute();
|
|
|
761 } elsif ( $dbEntry->isa('Bio::EnsEMBL::OntologyXref') ) {
|
|
|
762 $sth = $self->prepare( "
|
|
|
763 INSERT ignore INTO ontology_xref
|
|
|
764 SET object_xref_id = ?,
|
|
|
765 source_xref_id = ?,
|
|
|
766 linkage_type = ? " );
|
|
|
767 foreach my $info ( @{ $dbEntry->get_all_linkage_info() } ) {
|
|
|
768 my ( $linkage_type, $sourceXref ) = @{$info};
|
|
|
769 my $sourceXid = undef;
|
|
|
770 if ($sourceXref) {
|
|
|
771 $sourceXref->is_stored( $self->dbc ) || $self->store($sourceXref);
|
|
|
772 $sourceXid = $sourceXref->dbID;
|
|
|
773 }
|
|
|
774 $sth->bind_param( 1, $object_xref_id, SQL_INTEGER );
|
|
|
775 $sth->bind_param( 2, $sourceXid, SQL_INTEGER );
|
|
|
776 $sth->bind_param( 3, $linkage_type, SQL_VARCHAR );
|
|
|
777 $sth->execute();
|
|
|
778 } #end foreach
|
|
|
779 } #end elsif
|
|
|
780 } # end if ($object_xref_id)
|
|
|
781 return $object_xref_id;
|
|
|
782 }
|
|
|
783
|
|
|
784 =head2 _check_external_db
|
|
|
785
|
|
|
786 Arg [1] : DBEntry object
|
|
|
787 Arg [2] : Ignore version flag
|
|
|
788 Description: Looks for a record of the given external database
|
|
|
789 Exceptions : Throws on missing external database entry
|
|
|
790 Returntype : Int
|
|
|
791
|
|
|
792 =cut
|
|
|
793
|
|
|
794 sub _check_external_db {
|
|
|
795 my ($self,$db_entry,$ignore) = @_;
|
|
|
796 my ($sql,@bound_params,$sql_helper,$db_name,$db_release);
|
|
|
797
|
|
|
798 $db_name = $db_entry->dbname();
|
|
|
799 $db_release = $db_entry->release();
|
|
|
800 $sql_helper = $self->dbc->sql_helper;
|
|
|
801
|
|
|
802 $sql = 'SELECT external_db_id FROM external_db WHERE db_name = ?';
|
|
|
803 push @bound_params,$db_name;
|
|
|
804 unless ($ignore) {
|
|
|
805 if ($db_release) {
|
|
|
806 $sql .= ' AND db_release = ?';
|
|
|
807 push @bound_params,$db_release;
|
|
|
808 } else {
|
|
|
809 $sql .= ' AND db_release is NULL';
|
|
|
810 }
|
|
|
811 }
|
|
|
812
|
|
|
813 my ($db_id) = @{ $sql_helper->execute_simple(-SQL => $sql, -PARAMS => \@bound_params) };
|
|
|
814
|
|
|
815 if ($db_id) {
|
|
|
816 return $db_id;
|
|
|
817 }
|
|
|
818 else {
|
|
|
819 throw( sprintf( "external_db [%s] release [%s] does not exist",
|
|
|
820 $db_name, $db_release)
|
|
|
821 );
|
|
|
822 }
|
|
|
823 }
|
|
|
824
|
|
|
825 =head2 _store_or_fetch_xref
|
|
|
826
|
|
|
827 Arg [1] : DBEntry object
|
|
|
828 Arg [2] : Database accession for external database
|
|
|
829 Description: Thread-safe method for adding xrefs, or otherwise returning
|
|
|
830 an xref ID for the inserted or retrieved xref. Also inserts
|
|
|
831 synonyms for that xref when entire new
|
|
|
832 Returns : Int - the DB ID of the xref after insertion
|
|
|
833 =cut
|
|
|
834
|
|
|
835 sub _store_or_fetch_xref {
|
|
|
836 my $self = shift;
|
|
|
837 my $dbEntry = shift;
|
|
|
838 my $dbRef = shift;
|
|
|
839 my $xref_id;
|
|
|
840
|
|
|
841 my $sth = $self->prepare( "
|
|
|
842 INSERT IGNORE INTO xref
|
|
|
843 SET dbprimary_acc = ?,
|
|
|
844 display_label = ?,
|
|
|
845 version = ?,
|
|
|
846 description = ?,
|
|
|
847 external_db_id = ?,
|
|
|
848 info_type = ?,
|
|
|
849 info_text = ?");
|
|
|
850 $sth->bind_param(1, $dbEntry->primary_id,SQL_VARCHAR);
|
|
|
851 $sth->bind_param(2, $dbEntry->display_id,SQL_VARCHAR);
|
|
|
852 $sth->bind_param(3, ($dbEntry->version || q{0}),SQL_VARCHAR);
|
|
|
853 $sth->bind_param(4, $dbEntry->description,SQL_VARCHAR);
|
|
|
854 $sth->bind_param(5, $dbRef,SQL_INTEGER);
|
|
|
855 $sth->bind_param(6, ($dbEntry->info_type || 'NONE'), SQL_VARCHAR);
|
|
|
856 $sth->bind_param(7, ($dbEntry->info_text || ''), SQL_VARCHAR);
|
|
|
857
|
|
|
858 $sth->execute();
|
|
|
859 $xref_id = $self->last_insert_id('xref_id',undef,'xref');
|
|
|
860 $sth->finish();
|
|
|
861
|
|
|
862 if ($xref_id) { #insert was successful, store supplementary synonyms
|
|
|
863 # thread safety no longer an issue.
|
|
|
864 my $synonym_check_sth = $self->prepare(
|
|
|
865 "SELECT xref_id, synonym
|
|
|
866 FROM external_synonym
|
|
|
867 WHERE xref_id = ?
|
|
|
868 AND synonym = ?");
|
|
|
869
|
|
|
870 my $synonym_store_sth = $self->prepare(
|
|
|
871 "INSERT ignore INTO external_synonym
|
|
|
872 SET xref_id = ?, synonym = ?");
|
|
|
873
|
|
|
874 my $synonyms = $dbEntry->get_all_synonyms();
|
|
|
875 foreach my $syn ( @$synonyms ) {
|
|
|
876 $synonym_check_sth->bind_param(1,$xref_id,SQL_INTEGER);
|
|
|
877 $synonym_check_sth->bind_param(2,$syn,SQL_VARCHAR);
|
|
|
878 $synonym_check_sth->execute();
|
|
|
879 my ($dbSyn) = $synonym_check_sth->fetchrow_array();
|
|
|
880 $synonym_store_sth->bind_param(1,$xref_id,SQL_INTEGER);
|
|
|
881 $synonym_store_sth->bind_param(2,$syn,SQL_VARCHAR);
|
|
|
882 $synonym_store_sth->execute() if(!$dbSyn);
|
|
|
883 }
|
|
|
884 $synonym_check_sth->finish();
|
|
|
885 $synonym_store_sth->finish();
|
|
|
886
|
|
|
887 } else { # xref_id already exists, retrieve it according to fields in the unique key
|
|
|
888 my $sql = 'SELECT xref_id FROM xref
|
|
|
889 WHERE dbprimary_acc = ?
|
|
|
890 AND version =?
|
|
|
891 AND external_db_id = ?
|
|
|
892 AND info_type = ?
|
|
|
893 AND info_text = ?';
|
|
|
894 my $info_type = $dbEntry->info_type() || 'NONE';
|
|
|
895 my $info_text = $dbEntry->info_text() || q{};
|
|
|
896 my $version = $dbEntry->version() || q{0};
|
|
|
897 $sth = $self->prepare( $sql );
|
|
|
898 $sth->bind_param(1, $dbEntry->primary_id,SQL_VARCHAR);
|
|
|
899 $sth->bind_param(2, $version, SQL_VARCHAR);
|
|
|
900 $sth->bind_param(3, $dbRef, SQL_INTEGER);
|
|
|
901 $sth->bind_param(4, $info_type, SQL_VARCHAR);
|
|
|
902 $sth->bind_param(5, $info_text, SQL_VARCHAR);
|
|
|
903 $sth->execute();
|
|
|
904 ($xref_id) = $sth->fetchrow_array();
|
|
|
905 $sth->finish;
|
|
|
906 if(!$xref_id) {
|
|
|
907 my $msg = 'Cannot find an xref id for %s (version=%d) with external db id %d.';
|
|
|
908 throw(sprintf($msg, $dbEntry->primary_id(), $version, $dbRef))
|
|
|
909 }
|
|
|
910 }
|
|
|
911
|
|
|
912 return $xref_id;
|
|
|
913 }
|
|
|
914
|
|
|
915 =head2 exists
|
|
|
916
|
|
|
917 Arg [1] : Bio::EnsEMBL::DBEntry $dbe
|
|
|
918 Example : if($dbID = $db_entry_adaptor->exists($dbe)) { do stuff; }
|
|
|
919 Description: Returns the db id of this DBEntry if it exists in this database
|
|
|
920 otherwise returns undef. Exists is defined as an entry with
|
|
|
921 the same external_db and display_id
|
|
|
922 Returntype : int
|
|
|
923 Exceptions : thrown on incorrect args
|
|
|
924 Caller : GeneAdaptor::store, TranscriptAdaptor::store
|
|
|
925 Status : Stable
|
|
|
926
|
|
|
927 =cut
|
|
|
928
|
|
|
929 sub exists {
|
|
|
930 my ($self, $dbe) = @_ ;
|
|
|
931
|
|
|
932 unless($dbe && ref $dbe && $dbe->isa('Bio::EnsEMBL::DBEntry')) {
|
|
|
933 throw("arg must be a Bio::EnsEMBL::DBEntry not [$dbe]");
|
|
|
934 }
|
|
|
935
|
|
|
936 my $sth = $self->prepare('SELECT x.xref_id
|
|
|
937 FROM xref x, external_db xdb
|
|
|
938 WHERE x.external_db_id = xdb.external_db_id
|
|
|
939 AND x.display_label = ?
|
|
|
940 AND xdb.db_name = ?
|
|
|
941 AND x.dbprimary_acc = ?');
|
|
|
942
|
|
|
943 $sth->bind_param(1,$dbe->display_id,SQL_VARCHAR);
|
|
|
944 $sth->bind_param(2,$dbe->dbname,SQL_VARCHAR);
|
|
|
945 $sth->bind_param(3,$dbe->primary_id,SQL_VARCHAR);
|
|
|
946 $sth->execute();
|
|
|
947
|
|
|
948 my ($dbID) = $sth->fetchrow_array;
|
|
|
949
|
|
|
950 $sth->finish;
|
|
|
951
|
|
|
952 return $dbID;
|
|
|
953 }
|
|
|
954
|
|
|
955
|
|
|
956 =head2 fetch_all_by_Gene
|
|
|
957
|
|
|
958 Arg [1] : Bio::EnsEMBL::Gene $gene
|
|
|
959 (The gene to retrieve DBEntries for)
|
|
|
960 Arg [2] : optional external database name. SQL wildcards are accepted
|
|
|
961 Arg [3] : optional external_db type. SQL wildcards are accepted
|
|
|
962 Example : @db_entries = @{$db_entry_adaptor->fetch_all_by_Gene($gene)};
|
|
|
963 Description: This returns a list of DBEntries associated with this gene.
|
|
|
964 Note that this method was changed in release 15. Previously
|
|
|
965 it set the DBLinks attribute of the gene passed in to contain
|
|
|
966 all of the gene, transcript, and translation xrefs associated
|
|
|
967 with this gene.
|
|
|
968 Returntype : listref of Bio::EnsEMBL::DBEntries; may be of type IdentityXref if
|
|
|
969 there is mapping data, or OntologyXref if there is linkage data.
|
|
|
970 Exceptions : thows if gene object not passed
|
|
|
971 Caller : Bio::EnsEMBL::Gene
|
|
|
972 Status : Stable
|
|
|
973
|
|
|
974 =cut
|
|
|
975
|
|
|
976 sub fetch_all_by_Gene {
|
|
|
977 my ( $self, $gene, $ex_db_reg, $exdb_type ) = @_;
|
|
|
978
|
|
|
979 if(!ref($gene) || !$gene->isa('Bio::EnsEMBL::Gene')) {
|
|
|
980 throw("Bio::EnsEMBL::Gene argument expected.");
|
|
|
981 }
|
|
|
982
|
|
|
983 return $self->_fetch_by_object_type($gene->dbID(), 'Gene', $ex_db_reg, $exdb_type);
|
|
|
984 }
|
|
|
985
|
|
|
986 =head2 fetch_all_by_Operon
|
|
|
987
|
|
|
988 Arg [1] : Bio::EnsEMBL::Operon $operon
|
|
|
989 (The operon to retrieve DBEntries for)
|
|
|
990 Arg [2] : optional external database name. SQL wildcards are accepted
|
|
|
991 Arg [3] : optional external_db type. SQL wildcards are accepted
|
|
|
992 Example : @db_entries = @{$db_entry_adaptor->fetch_all_by_Operon($operon)};
|
|
|
993 Description: This returns a list of DBEntries associated with this operon.
|
|
|
994 Returntype : listref of Bio::EnsEMBL::DBEntries; may be of type IdentityXref if
|
|
|
995 there is mapping data, or OntologyXref if there is linkage data.
|
|
|
996 Exceptions : thows if operon object not passed
|
|
|
997 Caller : general
|
|
|
998
|
|
|
999 =cut
|
|
|
1000
|
|
|
1001 sub fetch_all_by_Operon {
|
|
|
1002 my ( $self, $gene, $ex_db_reg, $exdb_type ) = @_;
|
|
|
1003
|
|
|
1004 if(!ref($gene) || !$gene->isa('Bio::EnsEMBL::Operon')) {
|
|
|
1005 throw("Bio::EnsEMBL::Operon argument expected.");
|
|
|
1006 }
|
|
|
1007
|
|
|
1008 return $self->_fetch_by_object_type($gene->dbID(), 'Operon', $ex_db_reg, $exdb_type);
|
|
|
1009 }
|
|
|
1010
|
|
|
1011
|
|
|
1012 =head2 fetch_all_by_Transcript
|
|
|
1013
|
|
|
1014 Arg [1] : Bio::EnsEMBL::Transcript
|
|
|
1015 Arg [2] : optional external database name. SQL wildcards are accepted
|
|
|
1016 Arg [3] : optional external_db type. SQL wildcards are accepted
|
|
|
1017 Example : @db_entries = @{$db_entry_adaptor->fetch_all_by_Transcript($trans)};
|
|
|
1018 Description: This returns a list of DBEntries associated with this
|
|
|
1019 transcript. Note that this method was changed in release 15.
|
|
|
1020 Previously it set the DBLinks attribute of the gene passed in
|
|
|
1021 to contain all of the gene, transcript, and translation xrefs
|
|
|
1022 associated with this gene.
|
|
|
1023 Returntype : listref of Bio::EnsEMBL::DBEntries; may be of type IdentityXref if
|
|
|
1024 there is mapping data, or OntologyXref if there is linkage data.
|
|
|
1025 Exceptions : throes if transcript argument not passed
|
|
|
1026 Caller : Bio::EnsEMBL::Transcript
|
|
|
1027 Status : Stable
|
|
|
1028
|
|
|
1029 =cut
|
|
|
1030
|
|
|
1031 sub fetch_all_by_Transcript {
|
|
|
1032 my ( $self, $trans, $ex_db_reg, $exdb_type ) = @_;
|
|
|
1033
|
|
|
1034 if(!ref($trans) || !$trans->isa('Bio::EnsEMBL::Transcript')) {
|
|
|
1035 throw("Bio::EnsEMBL::Transcript argument expected.");
|
|
|
1036 }
|
|
|
1037
|
|
|
1038 return $self->_fetch_by_object_type( $trans->dbID(), 'Transcript', $ex_db_reg, $exdb_type);
|
|
|
1039 }
|
|
|
1040
|
|
|
1041
|
|
|
1042 =head2 fetch_all_by_Translation
|
|
|
1043
|
|
|
1044 Arg [1] : Bio::EnsEMBL::Translation $trans
|
|
|
1045 (The translation to fetch database entries for)
|
|
|
1046 Arg [2] : optional external database name. SQL wildcards are accepted
|
|
|
1047 Arg [3] : optional externaldb type. SQL wildcards are accepted
|
|
|
1048 Example : @db_entries = @{$db_entry_adptr->fetch_all_by_Translation($trans)};
|
|
|
1049 Description: Retrieves external database entries for an EnsEMBL translation
|
|
|
1050 Returntype : listref of Bio::EnsEMBL::DBEntries; may be of type IdentityXref if
|
|
|
1051 there is mapping data, or OntologyXref if there is linkage data.
|
|
|
1052 Exceptions : throws if translation object not passed
|
|
|
1053 Caller : general
|
|
|
1054 Status : Stable
|
|
|
1055
|
|
|
1056 =cut
|
|
|
1057
|
|
|
1058 sub fetch_all_by_Translation {
|
|
|
1059 my ( $self, $trans, $ex_db_reg, $exdb_type ) = @_;
|
|
|
1060
|
|
|
1061 if(!ref($trans) || !$trans->isa('Bio::EnsEMBL::Translation')) {
|
|
|
1062 throw('Bio::EnsEMBL::Translation argument expected.');
|
|
|
1063 }
|
|
|
1064 if( ! $trans->dbID ){
|
|
|
1065 warning( "Cannot fetch_all_by_Translation without a dbID" );
|
|
|
1066 return [];
|
|
|
1067 }
|
|
|
1068
|
|
|
1069 return $self->_fetch_by_object_type( $trans->dbID(), 'Translation', $ex_db_reg, $exdb_type );
|
|
|
1070 }
|
|
|
1071
|
|
|
1072
|
|
|
1073
|
|
|
1074 =head2 remove_from_object
|
|
|
1075
|
|
|
1076 Arg [1] : Bio::EnsEMBL::DBEntry $dbe - The external reference which
|
|
|
1077 is to be disassociated from an ensembl object.
|
|
|
1078 Arg [2] : Bio::EnsEMBL::Storable $object - The ensembl object the
|
|
|
1079 external reference is to be disassociated from
|
|
|
1080 Arg [3] : string $object_type - The type of the ensembl object.
|
|
|
1081 E.g. 'Gene', 'Transcript', 'Translation'
|
|
|
1082 Example :
|
|
|
1083 # remove all dbentries from this translation
|
|
|
1084 foreach my $dbe (@{$translation->get_all_DBEntries()}) {
|
|
|
1085 $dbe_adaptor->remove($dbe, $translation, 'Translation');
|
|
|
1086 }
|
|
|
1087 Description: Removes an association between an ensembl object and a
|
|
|
1088 DBEntry (xref). This does not remove the actual xref from
|
|
|
1089 the database, only its linkage to the ensembl object.
|
|
|
1090 Returntype : none
|
|
|
1091 Exceptions : Throw on incorrect arguments.
|
|
|
1092 Warning if object or dbentry is not stored in this database.
|
|
|
1093 Caller : TranscriptAdaptor::remove, GeneAdaptor::remove,
|
|
|
1094 TranslationAdaptor::remove
|
|
|
1095 Status : Stable
|
|
|
1096
|
|
|
1097 =cut
|
|
|
1098
|
|
|
1099 sub remove_from_object {
|
|
|
1100 my $self = shift;
|
|
|
1101 my $dbe = shift;
|
|
|
1102 my $object = shift;
|
|
|
1103 my $object_type = shift;
|
|
|
1104
|
|
|
1105 if(!ref($dbe) || !$dbe->isa('Bio::EnsEMBL::DBEntry')) {
|
|
|
1106 throw("Bio::EnsEMBL::DBEntry argument expected.");
|
|
|
1107 }
|
|
|
1108
|
|
|
1109 if(!ref($object) || !$dbe->isa('Bio::EnsEMBL::Storable')) {
|
|
|
1110 throw("Bio::EnsEMBL::Storable argument expected.");
|
|
|
1111 }
|
|
|
1112
|
|
|
1113 if(!$object_type) {
|
|
|
1114 throw("object_type string argument expected.");
|
|
|
1115 }
|
|
|
1116
|
|
|
1117 # make sure both the dbentry and the object it is allegedly linked to
|
|
|
1118 # are stored in this database
|
|
|
1119
|
|
|
1120 if(!$object->is_stored($self->db())) {
|
|
|
1121 warning("Cannot remove DBEntries for $object_type " . $object->dbID() .
|
|
|
1122 ". Object is not stored in this database.");
|
|
|
1123 return;
|
|
|
1124 }
|
|
|
1125
|
|
|
1126 if(!$dbe->is_stored($self->db())) {
|
|
|
1127 warning("Cannot remove DBEntry ".$dbe->dbID() . ". Is not stored " .
|
|
|
1128 "in this database.");
|
|
|
1129 return;
|
|
|
1130 }
|
|
|
1131
|
|
|
1132 # obtain the identifier of the link from the object_xref table
|
|
|
1133 #No need to compare linkage_annotation here
|
|
|
1134 my $sth = $self->prepare
|
|
|
1135 ("SELECT ox.object_xref_id " .
|
|
|
1136 "FROM object_xref ox ".
|
|
|
1137 "WHERE ox.xref_id = ? " .
|
|
|
1138 "AND ox.ensembl_id = ? " .
|
|
|
1139 "AND ox.ensembl_object_type = ?");
|
|
|
1140 $sth->bind_param(1,$dbe->dbID,SQL_INTEGER);
|
|
|
1141 $sth->bind_param(2,$object->dbID,SQL_INTEGER);
|
|
|
1142 $sth->bind_param(3,$object_type,SQL_VARCHAR);
|
|
|
1143 $sth->execute();
|
|
|
1144
|
|
|
1145 if(!$sth->rows() == 1) {
|
|
|
1146 $sth->finish();
|
|
|
1147 return;
|
|
|
1148 }
|
|
|
1149
|
|
|
1150 my ($ox_id) = $sth->fetchrow_array();
|
|
|
1151 $sth->finish();
|
|
|
1152
|
|
|
1153 # delete from the tables which contain additional linkage information
|
|
|
1154
|
|
|
1155 $sth = $self->prepare("DELETE FROM ontology_xref WHERE object_xref_id = ?");
|
|
|
1156 $sth->bind_param(1,$ox_id,SQL_INTEGER);
|
|
|
1157 $sth->execute();
|
|
|
1158 $sth->finish();
|
|
|
1159
|
|
|
1160 $sth = $self->prepare("DELETE FROM identity_xref WHERE object_xref_id = ?");
|
|
|
1161 $sth->bind_param(1,$ox_id,SQL_INTEGER);
|
|
|
1162 $sth->execute();
|
|
|
1163 $sth->finish();
|
|
|
1164
|
|
|
1165 # delete the actual linkage itself
|
|
|
1166 $sth = $self->prepare("DELETE FROM object_xref WHERE object_xref_id = ?");
|
|
|
1167 $sth->bind_param(1,$ox_id,SQL_INTEGER);
|
|
|
1168 $sth->execute();
|
|
|
1169 $sth->finish();
|
|
|
1170
|
|
|
1171 return;
|
|
|
1172 }
|
|
|
1173
|
|
|
1174
|
|
|
1175 =head2 _fetch_by_object_type
|
|
|
1176
|
|
|
1177 Arg [1] : string $ensID
|
|
|
1178 Arg [2] : string $ensType (object type to be returned)
|
|
|
1179 Arg [3] : optional $exdbname (external database name)
|
|
|
1180 (may be an SQL pattern containing '%' which matches any
|
|
|
1181 number of characters)
|
|
|
1182 Arg [4] : optional $exdb_type (external database type)
|
|
|
1183 (may be an SQL pattern containing '%' which matches any
|
|
|
1184 number of characters)
|
|
|
1185 Example : $self->_fetch_by_object_type( $translation_id, 'Translation' )
|
|
|
1186 Description: Fetches DBEntry by Object type
|
|
|
1187 NOTE: In a multi-species database, this method will
|
|
|
1188 return all the entries matching the search criteria, not
|
|
|
1189 just the ones associated with the current species.
|
|
|
1190
|
|
|
1191
|
|
|
1192 Returntype : arrayref of DBEntry objects; may be of type IdentityXref if
|
|
|
1193 there is mapping data, or OntologyXref if there is linkage data.
|
|
|
1194 Exceptions : none
|
|
|
1195 Caller : fetch_all_by_Gene
|
|
|
1196 fetch_all_by_Translation
|
|
|
1197 fetch_all_by_Transcript
|
|
|
1198 Status : Stable
|
|
|
1199
|
|
|
1200 =cut
|
|
|
1201
|
|
|
1202 sub _fetch_by_object_type {
|
|
|
1203 my ( $self, $ensID, $ensType, $exdbname, $exdb_type ) = @_;
|
|
|
1204
|
|
|
1205 my @out;
|
|
|
1206
|
|
|
1207 if ( !defined($ensID) ) {
|
|
|
1208 throw("Can't fetch_by_EnsObject_type without an object");
|
|
|
1209 }
|
|
|
1210
|
|
|
1211 if ( !defined($ensType) ) {
|
|
|
1212 throw("Can't fetch_by_EnsObject_type without a type");
|
|
|
1213 }
|
|
|
1214
|
|
|
1215 # my $sth = $self->prepare("
|
|
|
1216 my $sql = (<<SSQL);
|
|
|
1217 SELECT xref.xref_id, xref.dbprimary_acc, xref.display_label, xref.version,
|
|
|
1218 exDB.priority,
|
|
|
1219 exDB.db_name, exDB.db_release, exDB.status, exDB.db_display_name,
|
|
|
1220 exDB.secondary_db_name, exDB.secondary_db_table,
|
|
|
1221 oxr.object_xref_id,
|
|
|
1222 es.synonym,
|
|
|
1223 idt.xref_identity, idt.ensembl_identity, idt.xref_start,
|
|
|
1224 idt.xref_end, idt.ensembl_start, idt.ensembl_end,
|
|
|
1225 idt.cigar_line, idt.score, idt.evalue, oxr.analysis_id,
|
|
|
1226 gx.linkage_type,
|
|
|
1227 xref.info_type, xref.info_text, exDB.type, gx.source_xref_id,
|
|
|
1228 oxr.linkage_annotation, xref.description
|
|
|
1229 FROM (xref xref, external_db exDB, object_xref oxr)
|
|
|
1230 LEFT JOIN external_synonym es on es.xref_id = xref.xref_id
|
|
|
1231 LEFT JOIN identity_xref idt on idt.object_xref_id = oxr.object_xref_id
|
|
|
1232 LEFT JOIN ontology_xref gx on gx.object_xref_id = oxr.object_xref_id
|
|
|
1233 WHERE xref.xref_id = oxr.xref_id
|
|
|
1234 AND xref.external_db_id = exDB.external_db_id
|
|
|
1235 AND oxr.ensembl_id = ?
|
|
|
1236 AND oxr.ensembl_object_type = ?
|
|
|
1237 SSQL
|
|
|
1238
|
|
|
1239 if ( defined($exdbname) ) {
|
|
|
1240 if ( index( $exdbname, '%' ) != -1 ) {
|
|
|
1241 $sql .= " AND exDB.db_name LIKE "
|
|
|
1242 . $self->dbc()->db_handle()->quote( $exdbname, SQL_VARCHAR );
|
|
|
1243 } else {
|
|
|
1244 $sql .= " AND exDB.db_name = "
|
|
|
1245 . $self->dbc()->db_handle()->quote( $exdbname, SQL_VARCHAR );
|
|
|
1246 }
|
|
|
1247 }
|
|
|
1248
|
|
|
1249 if ( defined($exdb_type) ) {
|
|
|
1250 if ( index( $exdb_type, '%' ) != -1 ) {
|
|
|
1251 $sql .= " AND exDB.type LIKE "
|
|
|
1252 . $self->dbc()->db_handle()->quote( $exdb_type, SQL_VARCHAR );
|
|
|
1253 } else {
|
|
|
1254 $sql .= " AND exDB.type = "
|
|
|
1255 . $self->dbc()->db_handle()->quote( $exdb_type, SQL_VARCHAR );
|
|
|
1256 }
|
|
|
1257 }
|
|
|
1258
|
|
|
1259 my $sth = $self->prepare($sql);
|
|
|
1260
|
|
|
1261 $sth->bind_param( 1, $ensID, SQL_INTEGER );
|
|
|
1262 $sth->bind_param( 2, $ensType, SQL_VARCHAR );
|
|
|
1263 $sth->execute();
|
|
|
1264
|
|
|
1265 my ( %seen, %linkage_types, %synonyms );
|
|
|
1266
|
|
|
1267 my $max_rows = 1000;
|
|
|
1268
|
|
|
1269 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
1270 while ( my $arrRef = shift( @{$rowcache} ) ) {
|
|
|
1271 my ( $refID, $dbprimaryId,
|
|
|
1272 $displayid, $version,
|
|
|
1273 $priority,
|
|
|
1274 $dbname, $release,
|
|
|
1275 $exDB_status, $exDB_db_display_name,
|
|
|
1276 $exDB_secondary_db_name, $exDB_secondary_db_table,
|
|
|
1277 $objid, $synonym,
|
|
|
1278 $xrefid, $ensemblid,
|
|
|
1279 $xref_start, $xref_end,
|
|
|
1280 $ensembl_start, $ensembl_end,
|
|
|
1281 $cigar_line, $score,
|
|
|
1282 $evalue, $analysis_id,
|
|
|
1283 $linkage_type, $info_type,
|
|
|
1284 $info_text, $type,
|
|
|
1285 $source_xref_id, $link_annotation,
|
|
|
1286 $description
|
|
|
1287 ) = @$arrRef;
|
|
|
1288
|
|
|
1289 my $linkage_key =
|
|
|
1290 ( $linkage_type || '' ) . ( $source_xref_id || '' );
|
|
|
1291
|
|
|
1292
|
|
|
1293 my $analysis = undef;
|
|
|
1294 if ( defined($analysis_id) ) {
|
|
|
1295 $analysis =
|
|
|
1296 $self->db()->get_AnalysisAdaptor()->fetch_by_dbID($analysis_id);
|
|
|
1297 }
|
|
|
1298
|
|
|
1299 my %obj_hash = ( 'adaptor' => $self,
|
|
|
1300 'dbID' => $refID,
|
|
|
1301 'primary_id' => $dbprimaryId,
|
|
|
1302 'display_id' => $displayid,
|
|
|
1303 'version' => $version,
|
|
|
1304 'release' => $release,
|
|
|
1305 'info_type' => $info_type,
|
|
|
1306 'info_text' => $info_text,
|
|
|
1307 'type' => $type,
|
|
|
1308 'secondary_db_name' => $exDB_secondary_db_name,
|
|
|
1309 'secondary_db_table' => $exDB_secondary_db_table,
|
|
|
1310 'dbname' => $dbname,
|
|
|
1311 'description' => $description,
|
|
|
1312 'linkage_annotation' => $link_annotation,
|
|
|
1313 'analysis' => $analysis,
|
|
|
1314 'ensembl_object_type' => $ensType,
|
|
|
1315 'ensembl_id' => $ensID );
|
|
|
1316
|
|
|
1317 # Using an outer join on the synonyms as well as on identity_xref,
|
|
|
1318 # we now have to filter out the duplicates (see v.1.18 for
|
|
|
1319 # original). Since there is at most one identity_xref row per
|
|
|
1320 # xref, this is easy enough; all the 'extra' bits are synonyms.
|
|
|
1321 my $source_xref;
|
|
|
1322 if ( !$seen{$refID} ) {
|
|
|
1323
|
|
|
1324 my $exDB;
|
|
|
1325 if ( ( defined($xrefid) ) ) { # an xref with similarity scores
|
|
|
1326 $exDB = Bio::EnsEMBL::IdentityXref->new_fast( \%obj_hash );
|
|
|
1327 $exDB->xref_identity($xrefid);
|
|
|
1328 $exDB->ensembl_identity($ensemblid);
|
|
|
1329
|
|
|
1330 $exDB->cigar_line($cigar_line);
|
|
|
1331 $exDB->xref_start($xref_start);
|
|
|
1332 $exDB->xref_end($xref_end); # was not here before 14th Jan 2009 ????
|
|
|
1333 $exDB->ensembl_start($ensembl_start);
|
|
|
1334 $exDB->ensembl_end($ensembl_end);
|
|
|
1335 $exDB->score($score);
|
|
|
1336 $exDB->evalue($evalue);
|
|
|
1337
|
|
|
1338 } elsif ( defined $linkage_type && $linkage_type ne "" ) {
|
|
|
1339 $exDB = Bio::EnsEMBL::OntologyXref->new_fast( \%obj_hash );
|
|
|
1340 $source_xref = ( defined($source_xref_id)
|
|
|
1341 ? $self->fetch_by_dbID($source_xref_id)
|
|
|
1342 : undef );
|
|
|
1343 $exDB->add_linkage_type( $linkage_type, $source_xref || () );
|
|
|
1344 $linkage_types{$refID}->{$linkage_key} = 1;
|
|
|
1345
|
|
|
1346 } else {
|
|
|
1347 $exDB = Bio::EnsEMBL::DBEntry->new_fast( \%obj_hash );
|
|
|
1348 }
|
|
|
1349
|
|
|
1350 if ( defined($exDB_status) ) { $exDB->status($exDB_status) }
|
|
|
1351
|
|
|
1352 $exDB->priority($priority);
|
|
|
1353 $exDB->db_display_name($exDB_db_display_name);
|
|
|
1354
|
|
|
1355 push( @out, $exDB );
|
|
|
1356 $seen{$refID} = $exDB;
|
|
|
1357
|
|
|
1358 } ## end if ( !$seen{$refID} )
|
|
|
1359
|
|
|
1360 # $exDB still points to the same xref, so we can keep adding GO
|
|
|
1361 # evidence tags or synonyms.
|
|
|
1362
|
|
|
1363 if ( defined($synonym) && !$synonyms{$refID}->{$synonym} ) {
|
|
|
1364 if ( defined($synonym) ) {
|
|
|
1365 $seen{$refID}->add_synonym($synonym);
|
|
|
1366 }
|
|
|
1367 $synonyms{$refID}->{$synonym} = 1;
|
|
|
1368 }
|
|
|
1369
|
|
|
1370 if ( defined($linkage_type)
|
|
|
1371 && $linkage_type ne ""
|
|
|
1372 && !$linkage_types{$refID}->{$linkage_key} )
|
|
|
1373 {
|
|
|
1374 $source_xref = ( defined($source_xref_id)
|
|
|
1375 ? $self->fetch_by_dbID($source_xref_id)
|
|
|
1376 : undef );
|
|
|
1377 $seen{$refID}
|
|
|
1378 ->add_linkage_type( $linkage_type, $source_xref || () );
|
|
|
1379 $linkage_types{$refID}->{$linkage_key} = 1;
|
|
|
1380 }
|
|
|
1381 } ## end while ( my $arrRef = shift...
|
|
|
1382 } ## end while ( my $rowcache = $sth...
|
|
|
1383
|
|
|
1384 return \@out;
|
|
|
1385 } ## end sub _fetch_by_object_type
|
|
|
1386
|
|
|
1387 =head2 list_gene_ids_by_external_db_id
|
|
|
1388
|
|
|
1389 Arg [1] : string $external_id
|
|
|
1390 Example : @gene_ids = $dbea->list_gene_ids_by_external_db_id(1020);
|
|
|
1391 Description: Retrieve a list of geneid by an external identifier that
|
|
|
1392 is linked to any of the genes transcripts, translations
|
|
|
1393 or the gene itself.
|
|
|
1394 NOTE: If more than one external identifier has the
|
|
|
1395 same primary accession then genes for each of these is
|
|
|
1396 returned.
|
|
|
1397 NOTE: In a multi-species database, this method will
|
|
|
1398 return all the entries matching the search criteria, not
|
|
|
1399 just the ones associated with the current species.
|
|
|
1400 Returntype : list of ints
|
|
|
1401 Exceptions : none
|
|
|
1402 Caller : unknown
|
|
|
1403 Status : Stable
|
|
|
1404
|
|
|
1405 =cut
|
|
|
1406
|
|
|
1407 sub list_gene_ids_by_external_db_id{
|
|
|
1408 my ($self,$external_db_id) = @_;
|
|
|
1409
|
|
|
1410 my %T = map { ($_, 1) }
|
|
|
1411 $self->_type_by_external_db_id( $external_db_id, 'Translation', 'gene' ),
|
|
|
1412 $self->_type_by_external_db_id( $external_db_id, 'Transcript', 'gene' ),
|
|
|
1413 $self->_type_by_external_db_id( $external_db_id, 'Gene' );
|
|
|
1414 return keys %T;
|
|
|
1415 }
|
|
|
1416
|
|
|
1417 =head2 list_gene_ids_by_extids
|
|
|
1418
|
|
|
1419 Arg [1] : string $external_name
|
|
|
1420 Arg [2] : (optional) string $external_db_name
|
|
|
1421 Arg [3] : Boolean override, see _type_by_external_id
|
|
|
1422 Example : @gene_ids = $dbea->list_gene_ids_by_extids('CDPX');
|
|
|
1423 Description: Retrieve a list of geneid by an external identifier that is
|
|
|
1424 linked to any of the genes transcripts, translations or the
|
|
|
1425 gene itself
|
|
|
1426 Returntype : list of ints
|
|
|
1427 Exceptions : none
|
|
|
1428 Caller : unknown
|
|
|
1429 Status : Stable
|
|
|
1430
|
|
|
1431 =cut
|
|
|
1432
|
|
|
1433 sub list_gene_ids_by_extids {
|
|
|
1434 my ( $self, $external_name, $external_db_name, $override ) = @_;
|
|
|
1435
|
|
|
1436 my %T = map { ( $_, 1 ) }
|
|
|
1437 $self->_type_by_external_id( $external_name, 'Translation', 'gene',
|
|
|
1438 $external_db_name, $override ),
|
|
|
1439 $self->_type_by_external_id( $external_name, 'Transcript', 'gene',
|
|
|
1440 $external_db_name, $override ),
|
|
|
1441 $self->_type_by_external_id( $external_name, 'Gene', undef,
|
|
|
1442 $external_db_name, $override );
|
|
|
1443
|
|
|
1444 return keys %T;
|
|
|
1445 }
|
|
|
1446
|
|
|
1447
|
|
|
1448 =head2 list_transcript_ids_by_extids
|
|
|
1449
|
|
|
1450 Arg [1] : string $external_name
|
|
|
1451 Arg [2] : (optional) string $external_db_name
|
|
|
1452 Arg [3] : Boolean override, see _type_by_external_id
|
|
|
1453 Example : @tr_ids = $dbea->list_transcript_ids_by_extids('BCRA2');
|
|
|
1454 Description: Retrieve a list transcript ids by an external identifier that
|
|
|
1455 is linked to any of the genes transcripts, translations or the
|
|
|
1456 gene itself
|
|
|
1457 Returntype : list of ints
|
|
|
1458 Exceptions : none
|
|
|
1459 Caller : unknown
|
|
|
1460 Status : Stable
|
|
|
1461
|
|
|
1462 =cut
|
|
|
1463
|
|
|
1464 sub list_transcript_ids_by_extids {
|
|
|
1465 my ( $self, $external_name, $external_db_name, $override ) = @_;
|
|
|
1466
|
|
|
1467 my %T = map { ( $_, 1 ) }
|
|
|
1468 $self->_type_by_external_id( $external_name, 'Translation',
|
|
|
1469 'transcript', $external_db_name, $override
|
|
|
1470 ),
|
|
|
1471 $self->_type_by_external_id( $external_name, 'Transcript', undef,
|
|
|
1472 $external_db_name, $override );
|
|
|
1473
|
|
|
1474 return keys %T;
|
|
|
1475 }
|
|
|
1476
|
|
|
1477
|
|
|
1478 =head2 list_translation_ids_by_extids
|
|
|
1479
|
|
|
1480 Arg [1] : string $external_name
|
|
|
1481 Arg [2] : (optional) string $external_db_name
|
|
|
1482 Arg [3] : Boolean override, see _type_by_external_id
|
|
|
1483 Example : @tr_ids = $dbea->list_translation_ids_by_extids('GO:0004835');
|
|
|
1484 Description: Gets a list of translation IDs by external display IDs
|
|
|
1485 Returntype : list of Ints
|
|
|
1486 Exceptions : none
|
|
|
1487 Caller : unknown
|
|
|
1488 Status : Stable
|
|
|
1489
|
|
|
1490 =cut
|
|
|
1491
|
|
|
1492 sub list_translation_ids_by_extids {
|
|
|
1493 my ( $self, $external_name, $external_db_name, $override ) = @_;
|
|
|
1494
|
|
|
1495 return
|
|
|
1496 $self->_type_by_external_id( $external_name, 'Translation', undef,
|
|
|
1497 $external_db_name, $override );
|
|
|
1498 }
|
|
|
1499
|
|
|
1500 =head2 _type_by_external_id
|
|
|
1501
|
|
|
1502 Arg [1] : string $name - dbprimary_acc
|
|
|
1503 Arg [2] : string $ensType - ensembl_object_type
|
|
|
1504 Arg [3] : (optional) string $extraType
|
|
|
1505 Arg [4] : (optional) string $external_db_name
|
|
|
1506 other object type to be returned
|
|
|
1507 Arg [5] : Boolean override to force _ to be treated as an SQL 'any'
|
|
|
1508 This is usually optimised out for query speed due to
|
|
|
1509 large numbers of names like NM_00...
|
|
|
1510 Example : $self->_type_by_external_id($name, 'Translation');
|
|
|
1511 NOTE: In a multi-species database, this method will
|
|
|
1512 return all the entries matching the search criteria, not
|
|
|
1513 just the ones associated with the current species.
|
|
|
1514 SQL wildcards can be used in the external id,
|
|
|
1515 but overly generic queries (two characters) will be prevented.
|
|
|
1516 Description: Gets
|
|
|
1517 Returntype : list of dbIDs (gene_id, transcript_id, etc.)
|
|
|
1518 Exceptions : none
|
|
|
1519 Caller : list_translation_ids_by_extids
|
|
|
1520 translationids_by_extids
|
|
|
1521 geneids_by_extids
|
|
|
1522 Status : Stable
|
|
|
1523
|
|
|
1524 =cut
|
|
|
1525
|
|
|
1526 sub _type_by_external_id {
|
|
|
1527 my ( $self, $name, $ensType, $extraType, $external_db_name, $override ) = @_;
|
|
|
1528
|
|
|
1529 # $name has SQL wildcard support
|
|
|
1530 # = or LIKE put into SQL statement, and open queries like % or A% are rejected.
|
|
|
1531 my $comparison_operator;
|
|
|
1532 if ($name =~ /[_%\[]/ ) {
|
|
|
1533 $comparison_operator = "LIKE";
|
|
|
1534 if ($name =~ /^.?%/ && !$override) {
|
|
|
1535 warn "External $ensType name $name is too vague and will monopolise database resources. Please use a more specific $ensType name.\n";
|
|
|
1536 return;
|
|
|
1537 }
|
|
|
1538 elsif ($name =~ /^\w\w_/ && !$override) {
|
|
|
1539 # For entries such as NM_00000065, escape the _ so that SQL LIKE does not have to scan entire table
|
|
|
1540 # Escape only the _ in the third character position
|
|
|
1541 $name =~ s/(?<=\w\w)(?=_)/\\/;
|
|
|
1542 }
|
|
|
1543 }
|
|
|
1544 else {
|
|
|
1545 $comparison_operator = "=";
|
|
|
1546 }
|
|
|
1547
|
|
|
1548
|
|
|
1549 my $from_sql = '';
|
|
|
1550 my $where_sql = '';
|
|
|
1551 my $ID_sql = 'oxr.ensembl_id';
|
|
|
1552
|
|
|
1553 if ( defined($extraType) ) {
|
|
|
1554 if ( lc($extraType) eq 'translation' ) {
|
|
|
1555 $ID_sql = 'tl.translation_id';
|
|
|
1556 } else {
|
|
|
1557 $ID_sql = "t.${extraType}_id";
|
|
|
1558 }
|
|
|
1559
|
|
|
1560 if ( lc($ensType) eq 'translation' ) {
|
|
|
1561 $from_sql = 'transcript t, translation tl, ';
|
|
|
1562 $where_sql = qq(
|
|
|
1563 t.transcript_id = tl.transcript_id AND
|
|
|
1564 tl.translation_id = oxr.ensembl_id AND
|
|
|
1565 t.is_current = 1 AND
|
|
|
1566 );
|
|
|
1567 } else {
|
|
|
1568 $from_sql = 'transcript t, ';
|
|
|
1569 $where_sql = 't.'
|
|
|
1570 . lc($ensType)
|
|
|
1571 . '_id = oxr.ensembl_id AND '
|
|
|
1572 . 't.is_current = 1 AND ';
|
|
|
1573 }
|
|
|
1574 }
|
|
|
1575
|
|
|
1576 my $multispecies = $self->db()->is_multispecies();
|
|
|
1577
|
|
|
1578 if ( lc($ensType) eq 'gene' ) {
|
|
|
1579 $from_sql = 'gene g, ';
|
|
|
1580 $from_sql .= 'seq_region s, coord_system cs, ' if $multispecies;
|
|
|
1581
|
|
|
1582 $where_sql = 'g.gene_id = oxr.ensembl_id AND g.is_current = 1 AND ';
|
|
|
1583 if($multispecies) {
|
|
|
1584 $where_sql .= <<'SQL';
|
|
|
1585 g.seq_region_id = s.seq_region_id AND
|
|
|
1586 s.coord_system_id = cs.coord_system_id AND
|
|
|
1587 cs.species_id = ? AND
|
|
|
1588 SQL
|
|
|
1589 }
|
|
|
1590 }
|
|
|
1591 elsif ( lc($ensType) eq 'transcript' ) {
|
|
|
1592 $from_sql = 'transcript t, ';
|
|
|
1593 $from_sql .= 'seq_region s, coord_system cs, ' if $multispecies;
|
|
|
1594
|
|
|
1595 $where_sql = 't.transcript_id = oxr.ensembl_id AND t.is_current = 1 AND ';
|
|
|
1596 if($multispecies) {
|
|
|
1597 $where_sql .= <<'SQL';
|
|
|
1598 t.seq_region_id = s.seq_region_id AND
|
|
|
1599 s.coord_system_id = cs.coord_system_id AND
|
|
|
1600 cs.species_id = ? AND
|
|
|
1601 SQL
|
|
|
1602 }
|
|
|
1603 }
|
|
|
1604 elsif ( lc($ensType) eq 'translation' ) {
|
|
|
1605 $from_sql = 'translation tl, transcript t, ';
|
|
|
1606 $from_sql .= 'seq_region s, coord_system cs, ' if $multispecies;
|
|
|
1607
|
|
|
1608 $where_sql = 't.transcript_id = tl.transcript_id AND tl.translation_id = oxr.ensembl_id AND t.is_current = 1 AND ';
|
|
|
1609 if($multispecies) {
|
|
|
1610 $where_sql .= <<'SQL';
|
|
|
1611 t.seq_region_id = s.seq_region_id AND
|
|
|
1612 s.coord_system_id = cs.coord_system_id AND
|
|
|
1613 cs.species_id = ? AND
|
|
|
1614 SQL
|
|
|
1615 }
|
|
|
1616 }
|
|
|
1617
|
|
|
1618 if ( defined($external_db_name) ) {
|
|
|
1619 # Involve the 'external_db' table to limit the hits to a particular
|
|
|
1620 # external database.
|
|
|
1621
|
|
|
1622 $from_sql .= 'external_db xdb, ';
|
|
|
1623 $where_sql .=
|
|
|
1624 'xdb.db_name LIKE '
|
|
|
1625 . $self->dbc()->db_handle()->quote( $external_db_name . '%' )
|
|
|
1626 . ' AND xdb.external_db_id = x.external_db_id AND';
|
|
|
1627 }
|
|
|
1628
|
|
|
1629 my $query1 = qq(
|
|
|
1630 SELECT $ID_sql
|
|
|
1631 FROM $from_sql
|
|
|
1632 xref x,
|
|
|
1633 object_xref oxr
|
|
|
1634 WHERE $where_sql
|
|
|
1635 ( x.dbprimary_acc $comparison_operator ? OR x.display_label $comparison_operator ? )
|
|
|
1636 AND x.xref_id = oxr.xref_id
|
|
|
1637 AND oxr.ensembl_object_type = ?
|
|
|
1638 );
|
|
|
1639
|
|
|
1640 my $query2;
|
|
|
1641
|
|
|
1642 if ( defined($external_db_name) ) {
|
|
|
1643 # If we are given the name of an external database, we need to join
|
|
|
1644 # between the 'xref' and the 'object_xref' tables on 'xref_id'.
|
|
|
1645
|
|
|
1646 $query2 = qq(
|
|
|
1647 SELECT $ID_sql
|
|
|
1648 FROM $from_sql
|
|
|
1649 external_synonym syn,
|
|
|
1650 object_xref oxr,
|
|
|
1651 xref x
|
|
|
1652 WHERE $where_sql
|
|
|
1653 syn.synonym $comparison_operator ?
|
|
|
1654 AND syn.xref_id = oxr.xref_id
|
|
|
1655 AND oxr.ensembl_object_type = ?
|
|
|
1656 AND x.xref_id = oxr.xref_id);
|
|
|
1657
|
|
|
1658 } else {
|
|
|
1659 # If we weren't given an external database name, we can get away
|
|
|
1660 # with less joins here.
|
|
|
1661
|
|
|
1662 $query2 = qq(
|
|
|
1663 SELECT $ID_sql
|
|
|
1664 FROM $from_sql
|
|
|
1665 external_synonym syn,
|
|
|
1666 object_xref oxr
|
|
|
1667 WHERE $where_sql
|
|
|
1668 syn.synonym $comparison_operator ?
|
|
|
1669 AND syn.xref_id = oxr.xref_id
|
|
|
1670 AND oxr.ensembl_object_type = ?);
|
|
|
1671
|
|
|
1672 }
|
|
|
1673
|
|
|
1674 my %result;
|
|
|
1675
|
|
|
1676 my $sth = $self->prepare($query1);
|
|
|
1677
|
|
|
1678 my $queryBind = 1;
|
|
|
1679 $sth->bind_param( $queryBind++, $self->species_id(), SQL_INTEGER ) if $multispecies;
|
|
|
1680 $sth->bind_param( $queryBind++, $name, SQL_VARCHAR );
|
|
|
1681 $sth->bind_param( $queryBind++, $name, SQL_VARCHAR );
|
|
|
1682 $sth->bind_param( $queryBind++, $ensType, SQL_VARCHAR );
|
|
|
1683 $sth->execute();
|
|
|
1684 my $r;
|
|
|
1685 while ( $r = $sth->fetchrow_array() ) { $result{$r} = 1 }
|
|
|
1686
|
|
|
1687 $sth = $self->prepare($query2);
|
|
|
1688
|
|
|
1689 $queryBind = 1;
|
|
|
1690 $sth->bind_param( $queryBind++, $self->species_id(), SQL_INTEGER ) if $multispecies;
|
|
|
1691 $sth->bind_param( $queryBind++, $name, SQL_VARCHAR );
|
|
|
1692 $sth->bind_param( $queryBind++, $ensType, SQL_VARCHAR );
|
|
|
1693 $sth->execute();
|
|
|
1694
|
|
|
1695 while ( $r = $sth->fetchrow_array() ) { $result{$r} = 1 }
|
|
|
1696
|
|
|
1697 return keys(%result);
|
|
|
1698
|
|
|
1699 } ## end sub _type_by_external_id
|
|
|
1700
|
|
|
1701 =head2 _type_by_external_db_id
|
|
|
1702
|
|
|
1703 Arg [1] : integer $type - external_db_id
|
|
|
1704 Arg [2] : string $ensType - ensembl_object_type
|
|
|
1705 Arg [3] : (optional) string $extraType
|
|
|
1706 other object type to be returned
|
|
|
1707 Example : $self->_type_by_external_db_id(1030, 'Translation');
|
|
|
1708 Description: Gets.
|
|
|
1709 NOTE: In a multi-species database, this method will
|
|
|
1710 return all the entries matching the search criteria, not
|
|
|
1711 just the ones associated with the current species.
|
|
|
1712 Returntype : list of dbIDs (gene_id, transcript_id, etc.)
|
|
|
1713 Exceptions : none
|
|
|
1714 Caller : list_translation_ids_by_extids
|
|
|
1715 translationids_by_extids
|
|
|
1716 geneids_by_extids
|
|
|
1717 Status : Stable
|
|
|
1718
|
|
|
1719 =cut
|
|
|
1720
|
|
|
1721 sub _type_by_external_db_id{
|
|
|
1722 my ($self, $external_db_id, $ensType, $extraType) = @_;
|
|
|
1723
|
|
|
1724 my $from_sql = '';
|
|
|
1725 my $where_sql = '';
|
|
|
1726 my $ID_sql = "oxr.ensembl_id";
|
|
|
1727
|
|
|
1728 if (defined $extraType) {
|
|
|
1729 if (lc($extraType) eq 'translation') {
|
|
|
1730 $ID_sql = "tl.translation_id";
|
|
|
1731 } else {
|
|
|
1732 $ID_sql = "t.${extraType}_id";
|
|
|
1733 }
|
|
|
1734
|
|
|
1735 if (lc($ensType) eq 'translation') {
|
|
|
1736 $from_sql = 'transcript t, translation tl, ';
|
|
|
1737 $where_sql = qq(
|
|
|
1738 t.transcript_id = tl.transcript_id AND
|
|
|
1739 tl.translation_id = oxr.ensembl_id AND
|
|
|
1740 t.is_current = 1 AND
|
|
|
1741 );
|
|
|
1742 } else {
|
|
|
1743 $from_sql = 'transcript t, ';
|
|
|
1744 $where_sql = 't.'.lc($ensType).'_id = oxr.ensembl_id AND '.
|
|
|
1745 't.is_current = 1 AND ';
|
|
|
1746 }
|
|
|
1747 }
|
|
|
1748
|
|
|
1749 if (lc($ensType) eq 'gene') {
|
|
|
1750 $from_sql = 'gene g, ';
|
|
|
1751 $where_sql = 'g.gene_id = oxr.ensembl_id AND g.is_current = 1 AND ';
|
|
|
1752 } elsif (lc($ensType) eq 'transcript') {
|
|
|
1753 $from_sql = 'transcript t, ';
|
|
|
1754 $where_sql = 't.transcript_id = oxr.ensembl_id AND t.is_current = 1 AND ';
|
|
|
1755 } elsif (lc($ensType) eq 'translation') {
|
|
|
1756 $from_sql = 'transcript t, translation tl, ';
|
|
|
1757 $where_sql = qq(
|
|
|
1758 t.transcript_id = tl.transcript_id AND
|
|
|
1759 tl.translation_id = oxr.ensembl_id AND
|
|
|
1760 t.is_current = 1 AND
|
|
|
1761 );
|
|
|
1762 }
|
|
|
1763
|
|
|
1764 my $query =
|
|
|
1765 "SELECT $ID_sql
|
|
|
1766 FROM $from_sql xref x, object_xref oxr
|
|
|
1767 WHERE $where_sql x.external_db_id = ? AND
|
|
|
1768 x.xref_id = oxr.xref_id AND oxr.ensembl_object_type= ?";
|
|
|
1769
|
|
|
1770 my %result;
|
|
|
1771
|
|
|
1772 my $sth = $self->prepare($query);
|
|
|
1773
|
|
|
1774 $sth->bind_param( 1, "$external_db_id", SQL_VARCHAR );
|
|
|
1775 $sth->bind_param( 2, $ensType, SQL_VARCHAR );
|
|
|
1776 $sth->execute();
|
|
|
1777
|
|
|
1778 while ( my $r = $sth->fetchrow_array() ) { $result{$r} = 1 }
|
|
|
1779
|
|
|
1780 return keys(%result);
|
|
|
1781 }
|
|
|
1782
|
|
|
1783
|
|
|
1784 =head2 fetch_all_by_description
|
|
|
1785
|
|
|
1786 Arg [1] : string description to search for. Include % etc in this string
|
|
|
1787 Arg [2] : <optional> string $dbname. Name of the database to search
|
|
|
1788
|
|
|
1789 Example : @canc_refs = @{$db_entry_adaptor->fetch_all_by_description("%cancer%")};
|
|
|
1790 @db_entries = @{$db_entry_adaptor->fetch_all_by_description("%cancer%","MIM_MORBID")};
|
|
|
1791 Description: Retrieves DBEntries that match the description.
|
|
|
1792 Optionally you can search on external databases type.
|
|
|
1793 NOTE: In a multi-species database, this method will
|
|
|
1794 return all the entries matching the search criteria, not
|
|
|
1795 just the ones associated with the current species.
|
|
|
1796 Returntype : ref to array of Bio::EnsEMBL::DBSQL::DBEntry
|
|
|
1797 Exceptions : None.
|
|
|
1798 Caller : General
|
|
|
1799 Status : At Risk
|
|
|
1800
|
|
|
1801 =cut
|
|
|
1802
|
|
|
1803 sub fetch_all_by_description {
|
|
|
1804 my ( $self, $description, $dbname ) = @_;
|
|
|
1805
|
|
|
1806 my @results = ();
|
|
|
1807
|
|
|
1808 my $sql =
|
|
|
1809 "SELECT xref.xref_id, xref.dbprimary_acc, xref.display_label,
|
|
|
1810 xref.version,
|
|
|
1811 exDB.priority,
|
|
|
1812 exDB.db_name, exDB.db_display_name, exDB.db_release, es.synonym,
|
|
|
1813 xref.info_type, xref.info_text, exDB.type, exDB.secondary_db_name,
|
|
|
1814 exDB.secondary_db_table, xref.description
|
|
|
1815 FROM (xref, external_db exDB)
|
|
|
1816 LEFT JOIN external_synonym es on es.xref_id = xref.xref_id
|
|
|
1817 WHERE xref.description like ?
|
|
|
1818 AND xref.external_db_id = exDB.external_db_id";
|
|
|
1819
|
|
|
1820 if ( defined($dbname) ) { $sql .= " AND exDB.db_name = ? " }
|
|
|
1821
|
|
|
1822 my $sth = $self->prepare($sql);
|
|
|
1823
|
|
|
1824 $sth->bind_param( 1, $description, SQL_VARCHAR );
|
|
|
1825
|
|
|
1826 if ( defined($dbname) ) {
|
|
|
1827 $sth->bind_param( 2, $dbname, SQL_VARCHAR );
|
|
|
1828 }
|
|
|
1829
|
|
|
1830 $sth->execute();
|
|
|
1831
|
|
|
1832 my $max_rows = 1000;
|
|
|
1833
|
|
|
1834 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
1835 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
1836 my ( $dbID, $dbprimaryId,
|
|
|
1837 $displayid, $version,
|
|
|
1838 $priority,
|
|
|
1839 $ex_dbname, $db_display_name,
|
|
|
1840 $release, $synonym,
|
|
|
1841 $info_type, $info_text,
|
|
|
1842 $type, $secondary_db_name,
|
|
|
1843 $secondary_db_table, $description
|
|
|
1844 ) = @$arrayref;
|
|
|
1845
|
|
|
1846 my $exDB =
|
|
|
1847 Bio::EnsEMBL::DBEntry->new(
|
|
|
1848 -adaptor => $self,
|
|
|
1849 -dbID => $dbID,
|
|
|
1850 -primary_id => $dbprimaryId,
|
|
|
1851 -display_id => $displayid,
|
|
|
1852 -version => $version,
|
|
|
1853 -release => $release,
|
|
|
1854 -dbname => $ex_dbname,
|
|
|
1855 -priority => $priority,
|
|
|
1856 -db_display_name => $db_display_name,
|
|
|
1857 -info_type => $info_type,
|
|
|
1858 -info_text => $info_text,
|
|
|
1859 -type => $type,
|
|
|
1860 -secondary_db_name => $secondary_db_name,
|
|
|
1861 -secondary_db_table => $secondary_db_table,
|
|
|
1862 -description => $description
|
|
|
1863 );
|
|
|
1864
|
|
|
1865 if ($synonym) { $exDB->add_synonym($synonym) }
|
|
|
1866
|
|
|
1867 push @results, $exDB;
|
|
|
1868
|
|
|
1869 } ## end while ( my $arrayref = shift...
|
|
|
1870 } ## end while ( my $rowcache = $sth...
|
|
|
1871
|
|
|
1872 $sth->finish();
|
|
|
1873
|
|
|
1874 return \@results;
|
|
|
1875 } ## end sub fetch_all_by_description
|
|
|
1876
|
|
|
1877
|
|
|
1878 =head2 fetch_all_by_source
|
|
|
1879
|
|
|
1880 Arg [1] : string source to search for. Include % etc in this string
|
|
|
1881 if you want to use SQL patterns
|
|
|
1882
|
|
|
1883 Example : @unigene_refs = @{$db_entry_adaptor->fetch_all_by_source("%unigene%")};
|
|
|
1884 Description: Retrieves DBEntrys that match the source name.
|
|
|
1885 Returntype : ref to array of Bio::EnsEMBL::DBSQL::DBEntry
|
|
|
1886 Exceptions : None.
|
|
|
1887 Caller : General
|
|
|
1888 Status : At Risk
|
|
|
1889
|
|
|
1890 =cut
|
|
|
1891
|
|
|
1892 sub fetch_all_by_source {
|
|
|
1893 my ( $self, $source ) = @_;
|
|
|
1894
|
|
|
1895 my @results = ();
|
|
|
1896
|
|
|
1897 my $sql =
|
|
|
1898 "SELECT xref.xref_id, xref.dbprimary_acc, xref.display_label,
|
|
|
1899 xref.version,
|
|
|
1900 exDB.priority,
|
|
|
1901 exDB.db_name, exDB.db_display_name, exDB.db_release, es.synonym,
|
|
|
1902 xref.info_type, xref.info_text, exDB.type, exDB.secondary_db_name,
|
|
|
1903 exDB.secondary_db_table, xref.description
|
|
|
1904 FROM (xref, external_db exDB)
|
|
|
1905 LEFT JOIN external_synonym es on es.xref_id = xref.xref_id
|
|
|
1906 WHERE exDB.db_name like ?
|
|
|
1907 AND xref.external_db_id = exDB.external_db_id";
|
|
|
1908
|
|
|
1909
|
|
|
1910 my $sth = $self->prepare($sql);
|
|
|
1911
|
|
|
1912 $sth->bind_param( 1, $source, SQL_VARCHAR );
|
|
|
1913
|
|
|
1914 $sth->execute();
|
|
|
1915
|
|
|
1916 my $max_rows = 1000;
|
|
|
1917
|
|
|
1918 while ( my $rowcache = $sth->fetchall_arrayref( undef, $max_rows ) ) {
|
|
|
1919 while ( my $arrayref = shift( @{$rowcache} ) ) {
|
|
|
1920 my ( $dbID, $dbprimaryId,
|
|
|
1921 $displayid, $version,
|
|
|
1922 $priority,
|
|
|
1923 $dbname, $db_display_name,
|
|
|
1924 $release, $synonym,
|
|
|
1925 $info_type, $info_text,
|
|
|
1926 $type, $secondary_db_name,
|
|
|
1927 $secondary_db_table, $description
|
|
|
1928 ) = @$arrayref;
|
|
|
1929
|
|
|
1930 my $exDB =
|
|
|
1931 Bio::EnsEMBL::DBEntry->new(
|
|
|
1932 -adaptor => $self,
|
|
|
1933 -dbID => $dbID,
|
|
|
1934 -primary_id => $dbprimaryId,
|
|
|
1935 -display_id => $displayid,
|
|
|
1936 -version => $version,
|
|
|
1937 -release => $release,
|
|
|
1938 -dbname => $dbname,
|
|
|
1939 -priority => $priority,
|
|
|
1940 -db_display_name => $db_display_name,
|
|
|
1941 -info_type => $info_type,
|
|
|
1942 -info_text => $info_text,
|
|
|
1943 -type => $type,
|
|
|
1944 -secondary_db_name => $secondary_db_name,
|
|
|
1945 -secondary_db_table => $secondary_db_table,
|
|
|
1946 -description => $description
|
|
|
1947 );
|
|
|
1948
|
|
|
1949 if ($synonym) { $exDB->add_synonym($synonym) }
|
|
|
1950
|
|
|
1951 push @results, $exDB;
|
|
|
1952
|
|
|
1953 } ## end while ( my $arrayref = shift...
|
|
|
1954 } ## end while ( my $rowcache = $sth...
|
|
|
1955
|
|
|
1956 $sth->finish();
|
|
|
1957
|
|
|
1958 return \@results;
|
|
|
1959 } ## end sub fetch_all_by_source
|
|
|
1960
|
|
|
1961
|
|
|
1962 =head2 fetch_all_synonyms
|
|
|
1963
|
|
|
1964 Arg [1] : dbID of DBEntry to fetch synonyms for. Used in lazy loading of synonyms.
|
|
|
1965
|
|
|
1966 Example : @canc_refs = @{$db_entry_adaptor->fetch_all_synonyms(1234)};
|
|
|
1967 Description: Fetches the synonyms for a particular DBEntry.
|
|
|
1968 Returntype : listref of synonyms. List referred to may be empty if there are no synonyms.
|
|
|
1969 Exceptions : None.
|
|
|
1970 Caller : General
|
|
|
1971 Status : At Risk
|
|
|
1972
|
|
|
1973 =cut
|
|
|
1974
|
|
|
1975
|
|
|
1976 sub fetch_all_synonyms {
|
|
|
1977 my ( $self, $dbID ) = @_;
|
|
|
1978
|
|
|
1979 my @synonyms = ();
|
|
|
1980
|
|
|
1981 my $sth =
|
|
|
1982 $self->prepare( "SELECT synonym "
|
|
|
1983 . "FROM external_synonym "
|
|
|
1984 . "WHERE xref_id = ?" );
|
|
|
1985
|
|
|
1986 $sth->bind_param( 1, $dbID, SQL_INTEGER );
|
|
|
1987
|
|
|
1988 $sth->execute();
|
|
|
1989
|
|
|
1990 my $synonym;
|
|
|
1991 $sth->bind_col(1, \$synonym);
|
|
|
1992
|
|
|
1993 while ( $sth->fetch() ) {
|
|
|
1994 push( @synonyms, $synonym );
|
|
|
1995 }
|
|
|
1996
|
|
|
1997 return \@synonyms;
|
|
|
1998 }
|
|
|
1999
|
|
|
2000
|
|
|
2001 =head2 get_db_name_from_external_db_id
|
|
|
2002
|
|
|
2003 Arg [1] : external_dbid of database to get the database_name
|
|
|
2004 Example : my $db_name = $db_entry_adaptor->get_db_name_from_external_db_id(1100);
|
|
|
2005 Description: Gets the database name for a certain external_db_id
|
|
|
2006 Returntype : scalar
|
|
|
2007 Exceptions : None.
|
|
|
2008 Caller : General
|
|
|
2009 Status : At Risk
|
|
|
2010
|
|
|
2011 =cut
|
|
|
2012
|
|
|
2013 sub get_db_name_from_external_db_id{
|
|
|
2014 my $self = shift;
|
|
|
2015 my $external_db_id = shift;
|
|
|
2016
|
|
|
2017 my $sth = $self->prepare("SELECT db_name FROM external_db WHERE external_db_id = ?");
|
|
|
2018
|
|
|
2019 $sth->bind_param(1, $external_db_id, SQL_INTEGER);
|
|
|
2020 $sth->execute();
|
|
|
2021 my ($db_name) = $sth->fetchrow_array();
|
|
|
2022 $sth->finish();
|
|
|
2023 return $db_name;
|
|
|
2024
|
|
|
2025 }
|
|
|
2026
|
|
|
2027 =head2 geneids_by_extids
|
|
|
2028
|
|
|
2029 Description: DEPRECATED use list_gene_ids_by_extids instead
|
|
|
2030
|
|
|
2031 =cut
|
|
|
2032
|
|
|
2033 sub geneids_by_extids{
|
|
|
2034 my ($self,$name) = @_;
|
|
|
2035 deprecate(" use 'list_gene_ids_by_extids instead");
|
|
|
2036 return $self->list_gene_ids_by_extids( $name );
|
|
|
2037 }
|
|
|
2038
|
|
|
2039
|
|
|
2040 =head2 translationids_by_extids
|
|
|
2041
|
|
|
2042 DEPRECATED use list_translation_ids_by_extids instead
|
|
|
2043
|
|
|
2044 =cut
|
|
|
2045
|
|
|
2046 sub translationids_by_extids{
|
|
|
2047 my ($self,$name) = @_;
|
|
|
2048 deprecate("Use list_translation_ids_by_extids instead");
|
|
|
2049 return $self->list_translation_ids_by_extids( $name );
|
|
|
2050 }
|
|
|
2051
|
|
|
2052
|
|
|
2053 =head2 transcriptids_by_extids
|
|
|
2054
|
|
|
2055 DEPRECATED use transcriptids_by_extids instead
|
|
|
2056
|
|
|
2057 =cut
|
|
|
2058
|
|
|
2059 sub transcriptids_by_extids{
|
|
|
2060 my ($self,$name) = @_;
|
|
|
2061 deprecate("Use list_transcript_ids_by_extids instead.");
|
|
|
2062 return $self->list_transcript_ids_by_extids( $name );
|
|
|
2063 }
|
|
|
2064
|
|
|
2065
|
|
|
2066 1;
|
|
|
2067
|
