1 /* @source ensontology ********************************************************
2 **
3 ** Ensembl Ontology functions
4 **
5 ** @author Copyright (C) 1999 Ensembl Developers
6 ** @author Copyright (C) 2006 Michael K. Schuster
7 ** @version $Revision: 1.17 $
8 ** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
9 ** @modified $Date: 2013/02/17 13:02:10 $ by $Author: mks $
10 ** @@
11 **
12 ** This library is free software; you can redistribute it and/or
13 ** modify it under the terms of the GNU Lesser General Public
14 ** License as published by the Free Software Foundation; either
15 ** version 2.1 of the License, or (at your option) any later version.
16 **
17 ** This library is distributed in the hope that it will be useful,
18 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ** Lesser General Public License for more details.
21 **
22 ** You should have received a copy of the GNU Lesser General Public
23 ** License along with this library; if not, write to the Free Software
24 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
25 ** MA 02110-1301, USA.
26 **
27 ******************************************************************************/
28
29 /* ========================================================================= */
30 /* ============================= include files ============================= */
31 /* ========================================================================= */
32
33 #include "ensontology.h"
34 #include "enstable.h"
35
36
37
38
39 /* ========================================================================= */
40 /* =============================== constants =============================== */
41 /* ========================================================================= */
42
43
44
45
46 /* ========================================================================= */
47 /* =========================== global variables ============================ */
48 /* ========================================================================= */
49
50
51
52
53 /* ========================================================================= */
54 /* ============================= private data ============================== */
55 /* ========================================================================= */
56
57
58
59
60 /* ========================================================================= */
61 /* =========================== private constants =========================== */
62 /* ========================================================================= */
63
64 /* @conststatic ontologyadaptorKTablenames ************************************
65 **
66 ** Array of Ensembl Ontology Adaptor SQL table names
67 **
68 ******************************************************************************/
69
70 static const char *const ontologyadaptorKTablenames[] =
71 {
72 "ontology",
73 (const char *) NULL
74 };
75
76
77
78
79 /* @conststatic ontologyadaptorKColumnnames ***********************************
80 **
81 ** Array of Ensembl Ontology Adaptor SQL column names
82 **
83 ******************************************************************************/
84
85 static const char *const ontologyadaptorKColumnnames[] =
86 {
87 "ontology.ontology_id",
88 "ontology.name",
89 "ontology.namespace",
90 (const char *) NULL
91 };
92
93
94
95
96 /* @conststatic ontologytermadaptorKTablenames ********************************
97 **
98 ** Array of Ensembl Ontology Term Adaptor SQL table names
99 **
100 ******************************************************************************/
101
102 static const char *const ontologytermadaptorKTablenames[] =
103 {
104 "term",
105 (const char *) NULL
106 };
107
108
109
110
111 /* @conststatic ontologytermadaptorKColumnnames *******************************
112 **
113 ** Array of Ensembl Ontology Term Adaptor SQL column names
114 **
115 ******************************************************************************/
116
117 static const char *const ontologytermadaptorKColumnnames[] =
118 {
119 "term.term_id",
120 "term.ontology_id",
121 "term.accession",
122 "term.name",
123 "term.definition",
124 (const char *) NULL
125 };
126
127
128
129
130 /* ========================================================================= */
131 /* =========================== private variables =========================== */
132 /* ========================================================================= */
133
134
135
136
137 /* ========================================================================= */
138 /* =========================== private functions =========================== */
139 /* ========================================================================= */
140
141 static AjBool ontologyadaptorFetchAllbyStatement(
142 EnsPBaseadaptor ba,
143 const AjPStr statement,
144 EnsPAssemblymapper am,
145 EnsPSlice slice,
146 AjPList ontologies);
147
148 static AjBool ontologyadaptorCacheInit(EnsPOntologyadaptor oa);
149
150 static AjBool ontologyadaptorCacheInsert(EnsPOntologyadaptor oa,
151 EnsPOntology *Pontology);
152
153 static void ontologyadaptorFetchAll(const void *key,
154 void **Pvalue,
155 void *cl);
156
157 static AjBool ontologytermadaptorFetchAllbyStatement(
158 EnsPBaseadaptor ba,
159 const AjPStr statement,
160 EnsPAssemblymapper am,
161 EnsPSlice slice,
162 AjPList ots);
163
164 static void ontologytermListOntologytermValdel(void **Pvalue);
165
166
167
168
169 /* ========================================================================= */
170 /* ======================= All functions by section ======================== */
171 /* ========================================================================= */
172
173
174
175
176 /* @filesection ensontology ***************************************************
177 **
178 ** @nam1rule ens Function belongs to the Ensembl library
179 **
180 ******************************************************************************/
181
182
183
184
185 /* @datasection [EnsPOntology] Ensembl Ontology *******************************
186 **
187 ** @nam2rule Ontology Functions for manipulating Ensembl Ontology objects
188 **
189 ** @cc Split out of the Bio::EnsEMBL::OntologyTerm class
190 **
191 ******************************************************************************/
192
193
194
195
196 /* @section constructors ******************************************************
197 **
198 ** All constructors return a new Ensembl Ontology by pointer.
199 ** It is the responsibility of the user to first destroy any previous
200 ** Ensembl Ontology.
201 ** The target pointer does not need to be initialised to NULL, but it is good
202 ** programming practice to do so anyway.
203 **
204 ** @fdata [EnsPOntology]
205 **
206 ** @nam3rule New Constructor
207 ** @nam4rule Cpy Constructor with existing object
208 ** @nam4rule Ini Constructor with initial values
209 ** @nam4rule Ref Constructor by incrementing the reference counter
210 **
211 ** @argrule Cpy ontology [const EnsPOntology] Ensembl Ontology
212 ** @argrule Ini oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
213 ** @argrule Ini identifier [ajuint] SQL database-internal identifier
214 ** @argrule Ini name [AjPStr] Name
215 ** @argrule Ini space [AjPStr] Name space
216 ** @argrule Ref ontology [EnsPOntology] Ensembl Ontology
217 **
218 ** @valrule * [EnsPOntology] Ensembl Ontology or NULL
219 **
220 ** @fcategory new
221 ******************************************************************************/
222
223
224
225
226 /* @func ensOntologyNewCpy ****************************************************
227 **
228 ** Object-based constructor function, which returns an independent object.
229 **
230 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
231 **
232 ** @return [EnsPOntology] Ensembl Ontology or NULL
233 **
234 ** @release 6.5.0
235 ** @@
236 ******************************************************************************/
237
ensOntologyNewCpy(const EnsPOntology ontology)238 EnsPOntology ensOntologyNewCpy(const EnsPOntology ontology)
239 {
240 EnsPOntology pthis = NULL;
241
242 if (!ontology)
243 return NULL;
244
245 AJNEW0(pthis);
246
247 pthis->Use = 1U;
248 pthis->Identifier = ontology->Identifier;
249 pthis->Adaptor = ontology->Adaptor;
250
251 if (ontology->Name)
252 pthis->Name = ajStrNewRef(ontology->Name);
253
254 if (ontology->Space)
255 pthis->Space = ajStrNewRef(ontology->Space);
256
257 return pthis;
258 }
259
260
261
262
263 /* @func ensOntologyNewIni ****************************************************
264 **
265 ** Constructor for an Ensembl Ontology object with initial values.
266 **
267 ** @cc Bio::EnsEMBL::Storable::new
268 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
269 ** @param [r] identifier [ajuint] SQL database-internal identifier
270 ** @cc Bio::EnsEMBL::Ontology::new
271 ** @param [u] name [AjPStr] Name
272 ** @param [u] space [AjPStr] Name space
273 **
274 ** @return [EnsPOntology] Ensembl Ontology or NULL
275 **
276 ** @release 6.5.0
277 ** @@
278 ******************************************************************************/
279
ensOntologyNewIni(EnsPOntologyadaptor oa,ajuint identifier,AjPStr name,AjPStr space)280 EnsPOntology ensOntologyNewIni(EnsPOntologyadaptor oa,
281 ajuint identifier,
282 AjPStr name,
283 AjPStr space)
284 {
285 EnsPOntology ontology = NULL;
286
287 if (!name)
288 return NULL;
289
290 AJNEW0(ontology);
291
292 ontology->Use = 1U;
293 ontology->Identifier = identifier;
294 ontology->Adaptor = oa;
295
296 if (name)
297 ontology->Name = ajStrNewRef(name);
298
299 if (space)
300 ontology->Space = ajStrNewRef(space);
301
302 return ontology;
303 }
304
305
306
307
308 /* @func ensOntologyNewRef ****************************************************
309 **
310 ** Ensembl Object referencing function, which returns a pointer to the
311 ** Ensembl Object passed in and increases its reference count.
312 **
313 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
314 **
315 ** @return [EnsPOntology] Ensembl Ontology or NULL
316 **
317 ** @release 6.5.0
318 ** @@
319 ******************************************************************************/
320
ensOntologyNewRef(EnsPOntology ontology)321 EnsPOntology ensOntologyNewRef(EnsPOntology ontology)
322 {
323 if (!ontology)
324 return NULL;
325
326 ontology->Use++;
327
328 return ontology;
329 }
330
331
332
333
334 /* @section destructors *******************************************************
335 **
336 ** Destruction destroys all internal data structures and frees the memory
337 ** allocated for an Ensembl Ontology object.
338 **
339 ** @fdata [EnsPOntology]
340 **
341 ** @nam3rule Del Destroy (free) an Ensembl Ontology
342 **
343 ** @argrule * Pontology [EnsPOntology*] Ensembl Ontology address
344 **
345 ** @valrule * [void]
346 **
347 ** @fcategory delete
348 ******************************************************************************/
349
350
351
352
353 /* @func ensOntologyDel *******************************************************
354 **
355 ** Default destructor for an Ensembl Ontology.
356 **
357 ** @param [d] Pontology [EnsPOntology*] Ensembl Ontology address
358 **
359 ** @return [void]
360 **
361 ** @release 6.5.0
362 ** @@
363 ******************************************************************************/
364
ensOntologyDel(EnsPOntology * Pontology)365 void ensOntologyDel(EnsPOntology *Pontology)
366 {
367 EnsPOntology pthis = NULL;
368
369 if (!Pontology)
370 return;
371
372 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
373 if (ajDebugTest("ensOntologyDel"))
374 {
375 ajDebug("ensOntologyDel\n"
376 " *Pontology %p\n",
377 *Pontology);
378
379 ensOntologyTrace(*Pontology, 1);
380 }
381 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
382
383 if (!(pthis = *Pontology) || --pthis->Use)
384 {
385 *Pontology = NULL;
386
387 return;
388 }
389
390 ajStrDel(&pthis->Name);
391 ajStrDel(&pthis->Space);
392
393 ajMemFree((void **) Pontology);
394
395 return;
396 }
397
398
399
400
401 /* @section member retrieval **************************************************
402 **
403 ** Functions for returning members of an Ensembl Ontology object.
404 **
405 ** @fdata [EnsPOntology]
406 **
407 ** @nam3rule Get Return Ensembl Ontology attribute(s)
408 ** @nam4rule Adaptor Return the Ensembl Ontology Adaptor
409 ** @nam4rule Identifier Return the SQL database-internal identifier
410 ** @nam4rule Name Return the name
411 ** @nam4rule Space Return the name space
412 **
413 ** @argrule * ontology [const EnsPOntology] Ensembl Ontology
414 **
415 ** @valrule Adaptor [EnsPOntologyadaptor] Ensembl Ontology Adaptor or NULL
416 ** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
417 ** @valrule Name [AjPStr] Name or NULL
418 ** @valrule Space [AjPStr] Space or NULL
419 **
420 ** @fcategory use
421 ******************************************************************************/
422
423
424
425
426 /* @func ensOntologyGetAdaptor ************************************************
427 **
428 ** Get the Ensembl Ontology Adaptor member of an Ensembl Ontology.
429 **
430 ** @cc Bio::EnsEMBL::Storable::adaptor
431 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
432 **
433 ** @return [EnsPOntologyadaptor] Ensembl Ontology Adaptor or NULL
434 **
435 ** @release 6.5.0
436 ** @@
437 ******************************************************************************/
438
ensOntologyGetAdaptor(const EnsPOntology ontology)439 EnsPOntologyadaptor ensOntologyGetAdaptor(const EnsPOntology ontology)
440 {
441 return (ontology) ? ontology->Adaptor : NULL;
442 }
443
444
445
446
447 /* @func ensOntologyGetIdentifier *********************************************
448 **
449 ** Get the SQL database-internal identifier member of an Ensembl Ontology.
450 **
451 ** @cc Bio::EnsEMBL::Storable::dbID
452 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
453 **
454 ** @return [ajuint] SQL database-internal identifier or 0U
455 **
456 ** @release 6.5.0
457 ** @@
458 ******************************************************************************/
459
ensOntologyGetIdentifier(const EnsPOntology ontology)460 ajuint ensOntologyGetIdentifier(const EnsPOntology ontology)
461 {
462 return (ontology) ? ontology->Identifier : 0U;
463 }
464
465
466
467
468 /* @func ensOntologyGetName ***************************************************
469 **
470 ** Get the name member of an Ensembl Ontology.
471 **
472 ** @cc Bio::EnsEMBL::OntologyTerm::ontology
473 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
474 **
475 ** @return [AjPStr] Name or NULL
476 **
477 ** @release 6.5.0
478 ** @@
479 ******************************************************************************/
480
ensOntologyGetName(const EnsPOntology ontology)481 AjPStr ensOntologyGetName(const EnsPOntology ontology)
482 {
483 return (ontology) ? ontology->Name : NULL;
484 }
485
486
487
488
489 /* @func ensOntologyGetSpace **************************************************
490 **
491 ** Get the name space member of an Ensembl Ontology.
492 **
493 ** @cc Bio::EnsEMBL::OntologyTerm::namespace
494 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
495 **
496 ** @return [AjPStr] Name space or NULL
497 **
498 ** @release 6.5.0
499 ** @@
500 ******************************************************************************/
501
ensOntologyGetSpace(const EnsPOntology ontology)502 AjPStr ensOntologyGetSpace(const EnsPOntology ontology)
503 {
504 return (ontology) ? ontology->Space : NULL;
505 }
506
507
508
509
510 /* @section member assignment *************************************************
511 **
512 ** Functions for assigning members of an Ensembl Ontology object.
513 **
514 ** @fdata [EnsPOntology]
515 **
516 ** @nam3rule Set Set one member of an Ensembl Ontology
517 ** @nam4rule Adaptor Set the Ensembl Ontology Adaptor
518 ** @nam4rule Identifier Set the SQL database-internal identifier
519 ** @nam4rule Name Set the name
520 ** @nam4rule Space Set the name space
521 **
522 ** @argrule * ontology [EnsPOntology] Ensembl Ontology object
523 ** @argrule Adaptor oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
524 ** @argrule Identifier identifier [ajuint] SQL database-internal identifier
525 ** @argrule Name name [AjPStr] Name
526 ** @argrule Space space [AjPStr] Name space
527 **
528 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
529 **
530 ** @fcategory modify
531 ******************************************************************************/
532
533
534
535
536 /* @func ensOntologySetAdaptor ************************************************
537 **
538 ** Set the Ensembl Ontology Adaptor member of an Ensembl Ontology.
539 **
540 ** @cc Bio::EnsEMBL::Storable::adaptor
541 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
542 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
543 **
544 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
545 **
546 ** @release 6.5.0
547 ** @@
548 ******************************************************************************/
549
ensOntologySetAdaptor(EnsPOntology ontology,EnsPOntologyadaptor oa)550 AjBool ensOntologySetAdaptor(EnsPOntology ontology,
551 EnsPOntologyadaptor oa)
552 {
553 if (!ontology)
554 return ajFalse;
555
556 ontology->Adaptor = oa;
557
558 return ajTrue;
559 }
560
561
562
563
564 /* @func ensOntologySetIdentifier *********************************************
565 **
566 ** Set the SQL database-internal identifier member of an Ensembl Ontology.
567 **
568 ** @cc Bio::EnsEMBL::Storable::dbID
569 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
570 ** @param [r] identifier [ajuint] SQL database-internal identifier
571 **
572 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
573 **
574 ** @release 6.5.0
575 ** @@
576 ******************************************************************************/
577
ensOntologySetIdentifier(EnsPOntology ontology,ajuint identifier)578 AjBool ensOntologySetIdentifier(EnsPOntology ontology,
579 ajuint identifier)
580 {
581 if (!ontology)
582 return ajFalse;
583
584 ontology->Identifier = identifier;
585
586 return ajTrue;
587 }
588
589
590
591
592 /* @func ensOntologySetName ***************************************************
593 **
594 ** Set the name member of an Ensembl Ontology.
595 **
596 ** @cc Bio::EnsEMBL::OntologyTerm::ontology
597 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
598 ** @param [u] name [AjPStr] Name
599 **
600 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
601 **
602 ** @release 6.5.0
603 ** @@
604 ******************************************************************************/
605
ensOntologySetName(EnsPOntology ontology,AjPStr name)606 AjBool ensOntologySetName(EnsPOntology ontology,
607 AjPStr name)
608 {
609 if (!ontology)
610 return ajFalse;
611
612 ajStrDel(&ontology->Name);
613
614 if (name)
615 ontology->Name = ajStrNewRef(name);
616
617 return ajTrue;
618 }
619
620
621
622
623 /* @func ensOntologySetSpace **************************************************
624 **
625 ** Set the name space member of an Ensembl Ontology.
626 **
627 ** @cc Bio::EnsEMBL::OntologyTerm::namespace
628 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
629 ** @param [u] space [AjPStr] Name space
630 **
631 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
632 **
633 ** @release 6.5.0
634 ** @@
635 ******************************************************************************/
636
ensOntologySetSpace(EnsPOntology ontology,AjPStr space)637 AjBool ensOntologySetSpace(EnsPOntology ontology,
638 AjPStr space)
639 {
640 if (!ontology)
641 return ajFalse;
642
643 ajStrDel(&ontology->Space);
644
645 if (space)
646 ontology->Space = ajStrNewRef(space);
647
648 return ajTrue;
649 }
650
651
652
653
654 /* @section debugging *********************************************************
655 **
656 ** Functions for reporting of an Ensembl Ontology object.
657 **
658 ** @fdata [EnsPOntology]
659 **
660 ** @nam3rule Trace Report Ensembl Ontology members to debug file.
661 **
662 ** @argrule Trace ontology [const EnsPOntology] Ensembl Ontology
663 ** @argrule Trace level [ajuint] Indentation level
664 **
665 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
666 **
667 ** @fcategory misc
668 ******************************************************************************/
669
670
671
672
673 /* @func ensOntologyTrace *****************************************************
674 **
675 ** Trace an Ensembl Ontology.
676 **
677 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
678 ** @param [r] level [ajuint] Indentation level
679 **
680 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
681 **
682 ** @release 6.5.0
683 ** @@
684 ******************************************************************************/
685
ensOntologyTrace(const EnsPOntology ontology,ajuint level)686 AjBool ensOntologyTrace(const EnsPOntology ontology, ajuint level)
687 {
688 AjPStr indent = NULL;
689
690 if (!ontology)
691 return ajFalse;
692
693 indent = ajStrNew();
694
695 ajStrAppendCountK(&indent, ' ', level * 2);
696
697 ajDebug("%SensOntologyTrace %p\n"
698 "%S Use %u\n"
699 "%S Identifier %u\n"
700 "%S Adaptor %p\n"
701 "%S Name '%S'\n"
702 "%S Space '%S'\n",
703 indent, ontology,
704 indent, ontology->Use,
705 indent, ontology->Identifier,
706 indent, ontology->Adaptor,
707 indent, ontology->Name,
708 indent, ontology->Space);
709
710 ajStrDel(&indent);
711
712 return ajTrue;
713 }
714
715
716
717
718 /* @section calculate *********************************************************
719 **
720 ** Functions for calculating information from an Ensembl Ontology object.
721 **
722 ** @fdata [EnsPOntology]
723 **
724 ** @nam3rule Calculate Calculate Ensembl Ontology information
725 ** @nam4rule Memsize Calculate the memory size in bytes
726 **
727 ** @argrule * ontology [const EnsPOntology] Ensembl Ontology
728 **
729 ** @valrule Memsize [size_t] Memory size in bytes or 0
730 **
731 ** @fcategory misc
732 ******************************************************************************/
733
734
735
736
737 /* @func ensOntologyCalculateMemsize ******************************************
738 **
739 ** Get the memory size in bytes of an Ensembl Ontology.
740 **
741 ** @param [r] ontology [const EnsPOntology] Ensembl Ontology
742 **
743 ** @return [size_t] Memory size in bytes or 0
744 **
745 ** @release 6.5.0
746 ** @@
747 ******************************************************************************/
748
ensOntologyCalculateMemsize(const EnsPOntology ontology)749 size_t ensOntologyCalculateMemsize(const EnsPOntology ontology)
750 {
751 size_t size = 0;
752
753 if (!ontology)
754 return 0;
755
756 size += sizeof (EnsOOntology);
757
758 if (ontology->Name)
759 {
760 size += sizeof (AjOStr);
761
762 size += ajStrGetRes(ontology->Name);
763 }
764
765 if (ontology->Space)
766 {
767 size += sizeof (AjOStr);
768
769 size += ajStrGetRes(ontology->Space);
770 }
771
772 return size;
773 }
774
775
776
777
778 /* @datasection [EnsPOntologyadaptor] Ensembl Ontology Adaptor ****************
779 **
780 ** @nam2rule Ontologyadaptor Functions for manipulating
781 ** Ensembl Ontology Adaptor objects
782 **
783 ** @cc Split out of the Bio::EnsEMBL::DBSQL::OntologyTermAdaptor class
784 **
785 ******************************************************************************/
786
787
788
789
790 /* @funcstatic ontologyadaptorFetchAllbyStatement *****************************
791 **
792 ** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
793 ** results into an AJAX List of Ensembl Ontology objects.
794 **
795 ** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
796 ** @param [r] statement [const AjPStr] SQL statement
797 ** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
798 ** @param [uN] slice [EnsPSlice] Ensembl Slice
799 ** @param [u] ontologies [AjPList] AJAX List of Ensembl Ontology objects
800 **
801 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
802 **
803 ** @release 6.5.0
804 ** @@
805 ******************************************************************************/
806
ontologyadaptorFetchAllbyStatement(EnsPBaseadaptor ba,const AjPStr statement,EnsPAssemblymapper am,EnsPSlice slice,AjPList ontologies)807 static AjBool ontologyadaptorFetchAllbyStatement(
808 EnsPBaseadaptor ba,
809 const AjPStr statement,
810 EnsPAssemblymapper am,
811 EnsPSlice slice,
812 AjPList ontologies)
813 {
814 ajuint identifier = 0U;
815
816 AjPSqlstatement sqls = NULL;
817 AjISqlrow sqli = NULL;
818 AjPSqlrow sqlr = NULL;
819
820 AjPStr name = NULL;
821 AjPStr space = NULL;
822
823 EnsPDatabaseadaptor dba = NULL;
824
825 EnsPOntology ontology = NULL;
826 EnsPOntologyadaptor oa = NULL;
827
828 if (ajDebugTest("ontologyadaptorFetchAllbyStatement"))
829 ajDebug("ontologyadaptorFetchAllbyStatement\n"
830 " ba %p\n"
831 " statement %p\n"
832 " am %p\n"
833 " slice %p\n"
834 " ontologies %p\n",
835 ba,
836 statement,
837 am,
838 slice,
839 ontologies);
840
841 if (!ba)
842 return ajFalse;
843
844 if (!statement)
845 return ajFalse;
846
847 if (!ontologies)
848 return ajFalse;
849
850 dba = ensBaseadaptorGetDatabaseadaptor(ba);
851
852 oa = ensRegistryGetOntologyadaptor(dba);
853
854 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
855
856 sqli = ajSqlrowiterNew(sqls);
857
858 while (!ajSqlrowiterDone(sqli))
859 {
860 identifier = 0;
861 name = ajStrNew();
862 space = ajStrNew();
863
864 sqlr = ajSqlrowiterGet(sqli);
865
866 ajSqlcolumnToUint(sqlr, &identifier);
867 ajSqlcolumnToStr(sqlr, &name);
868 ajSqlcolumnToStr(sqlr, &space);
869
870 ontology = ensOntologyNewIni(oa, identifier, name, space);
871
872 ajListPushAppend(ontologies, (void *) ontology);
873
874 ajStrDel(&name);
875 ajStrDel(&space);
876 }
877
878 ajSqlrowiterDel(&sqli);
879
880 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
881
882 return ajTrue;
883 }
884
885
886
887
888 /* @section constructors ******************************************************
889 **
890 ** All constructors return a new Ensembl Ontology Adaptor by pointer.
891 ** It is the responsibility of the user to first destroy any previous
892 ** Ensembl Ontology Adaptor.
893 ** The target pointer does not need to be initialised to NULL, but it is good
894 ** programming practice to do so anyway.
895 **
896 ** @fdata [EnsPOntologyadaptor]
897 **
898 ** @nam3rule New Constructor
899 **
900 ** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
901 **
902 ** @valrule * [EnsPOntologyadaptor] Ensembl Ontology Adaptor or NULL
903 **
904 ** @fcategory new
905 ******************************************************************************/
906
907
908
909
910 /* @func ensOntologyadaptorNew ************************************************
911 **
912 ** Default constructor for an Ensembl Ontology Adaptor.
913 **
914 ** Ensembl Object Adaptors are singleton objects in the sense that a single
915 ** instance of an Ensembl Object Adaptor connected to a particular database is
916 ** sufficient to instantiate any number of Ensembl Objects from the database.
917 ** Each Ensembl Object will have a weak reference to the Object Adaptor that
918 ** instantiated it. Therefore, Ensembl Object Adaptors should not be
919 ** instantiated directly, but rather obtained from the Ensembl Registry,
920 ** which will in turn call this function if neccessary.
921 **
922 ** @see ensRegistryGetDatabaseadaptor
923 ** @see ensRegistryGetOntologyadaptor
924 **
925 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
926 **
927 ** @return [EnsPOntologyadaptor] Ensembl Ontology Adaptor or NULL
928 **
929 ** @release 6.5.0
930 ** @@
931 ******************************************************************************/
932
ensOntologyadaptorNew(EnsPDatabaseadaptor dba)933 EnsPOntologyadaptor ensOntologyadaptorNew(
934 EnsPDatabaseadaptor dba)
935 {
936 EnsPOntologyadaptor oa = NULL;
937
938 if (!dba)
939 return NULL;
940
941 if (ajDebugTest("ensOntologyadaptorNew"))
942 ajDebug("ensOntologyadaptorNew\n"
943 " dba %p\n",
944 dba);
945
946 AJNEW0(oa);
947
948 oa->Adaptor = ensBaseadaptorNew(
949 dba,
950 ontologyadaptorKTablenames,
951 ontologyadaptorKColumnnames,
952 (const EnsPBaseadaptorLeftjoin) NULL,
953 (const char *) NULL,
954 (const char *) NULL,
955 &ontologyadaptorFetchAllbyStatement);
956
957 /*
958 ** NOTE: The cache cannot be initialised here because the
959 ** ontologyadaptorCacheInit function calls
960 ** ensBaseadaptorFetchAllbyConstraint,
961 ** which calls ontologyadaptorFetchAllbyStatement, which calls
962 ** ensRegistryGetOntologyadaptor. At that point, however,
963 ** the Ensembl Ontology Adaptor has not been stored in the Registry.
964 ** Therefore, each ensOntologyadaptorFetch function has to test the
965 ** presence of the adaptor-internal cache and eventually initialise
966 ** before accessing it.
967 **
968 ** ontologyadaptorCacheInit(oa);
969 */
970
971 return oa;
972 }
973
974
975
976
977 /* @section cache *************************************************************
978 **
979 ** Functions for maintaining the Ensembl Ontology Adaptor-internal cache of
980 ** Ensembl Ontology objects.
981 **
982 ** @fdata [EnsPOntologyadaptor]
983 **
984 ** @nam3rule Cache Process an Ensembl Ontology Adaptor-internal cache
985 ** @nam4rule Clear Clear the Ensembl Ontology Adaptor-internal cache
986 **
987 ** @argrule * oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
988 **
989 ** @valrule * [AjBool] True on success, ajFalse otherwise
990 **
991 ** @fcategory use
992 ******************************************************************************/
993
994
995
996
997 /* @funcstatic ontologyadaptorCacheInit ***************************************
998 **
999 ** Initialise the internal Ensembl Ontology cache of an
1000 ** Ensembl Ontology Adaptor.
1001 **
1002 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1003 **
1004 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1005 **
1006 ** @release 6.5.0
1007 ** @@
1008 ******************************************************************************/
1009
ontologyadaptorCacheInit(EnsPOntologyadaptor oa)1010 static AjBool ontologyadaptorCacheInit(EnsPOntologyadaptor oa)
1011 {
1012 AjPList ontologies = NULL;
1013
1014 EnsPOntology ontology = NULL;
1015
1016 if (ajDebugTest("ontologyadaptorCacheInit"))
1017 ajDebug("ontologyadaptorCacheInit\n"
1018 " oa %p\n",
1019 oa);
1020
1021 if (!oa)
1022 return ajFalse;
1023
1024 if (oa->CacheByIdentifier)
1025 return ajFalse;
1026 else
1027 {
1028 oa->CacheByIdentifier = ajTableuintNew(0U);
1029
1030 ajTableSetDestroyvalue(
1031 oa->CacheByIdentifier,
1032 (void (*)(void **)) &ensOntologyDel);
1033 }
1034
1035 if (oa->CacheByNamespace)
1036 return ajFalse;
1037 else
1038 {
1039 oa->CacheByNamespace = ajTablestrNew(0U);
1040
1041 ajTableSetDestroyvalue(
1042 oa->CacheByNamespace,
1043 (void (*)(void **)) &ensOntologyDel);
1044 }
1045
1046 ontologies = ajListNew();
1047
1048 ensBaseadaptorFetchAllbyConstraint(
1049 ensOntologyadaptorGetBaseadaptor(oa),
1050 (const AjPStr) NULL,
1051 (EnsPAssemblymapper) NULL,
1052 (EnsPSlice) NULL,
1053 ontologies);
1054
1055 while (ajListPop(ontologies, (void **) &ontology))
1056 {
1057 ontologyadaptorCacheInsert(oa, &ontology);
1058
1059 /*
1060 ** Both caches hold internal references to the
1061 ** Ensembl Ontology objects.
1062 */
1063
1064 ensOntologyDel(&ontology);
1065 }
1066
1067 ajListFree(&ontologies);
1068
1069 return ajTrue;
1070 }
1071
1072
1073
1074
1075 /* @funcstatic ontologyadaptorCacheInsert *************************************
1076 **
1077 ** Insert an Ensembl Ontology into the Ensembl Ontology Adaptor-internal cache.
1078 ** If an Ensembl Ontology with the same name member is already present in the
1079 ** Ensembl Ontology Adaptor-internal cache, the Ensembl Ontology is deleted and
1080 ** a pointer to the cached Ensembl Ontology is returned.
1081 **
1082 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1083 ** @param [u] Pontology [EnsPOntology*] Ensembl Ontology address
1084 **
1085 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1086 **
1087 ** @release 6.5.0
1088 ** @@
1089 ******************************************************************************/
1090
ontologyadaptorCacheInsert(EnsPOntologyadaptor oa,EnsPOntology * Pontology)1091 static AjBool ontologyadaptorCacheInsert(EnsPOntologyadaptor oa,
1092 EnsPOntology *Pontology)
1093 {
1094 ajuint *Pidentifier = NULL;
1095
1096 AjPStr key = NULL;
1097
1098 EnsPOntology ontology1 = NULL;
1099 EnsPOntology ontology2 = NULL;
1100
1101 if (!oa)
1102 return ajFalse;
1103
1104 if (!oa->CacheByIdentifier)
1105 return ajFalse;
1106
1107 if (!oa->CacheByNamespace)
1108 return ajFalse;
1109
1110 if (!Pontology)
1111 return ajFalse;
1112
1113 if (!*Pontology)
1114 return ajFalse;
1115
1116 /* Search the identifer cache. */
1117
1118 ontology1 = (EnsPOntology) ajTableFetchmodV(
1119 oa->CacheByIdentifier,
1120 (const void *) &((*Pontology)->Identifier));
1121
1122 /* Search the name cache. */
1123
1124 key = ajFmtStr("%S:%S", (*Pontology)->Name, (*Pontology)->Space);
1125
1126 ontology2 = (EnsPOntology) ajTableFetchmodS(oa->CacheByNamespace, key);
1127
1128 if ((!ontology1) && (!ontology2))
1129 {
1130 /* Insert into the identifier cache. */
1131
1132 AJNEW0(Pidentifier);
1133
1134 *Pidentifier = (*Pontology)->Identifier;
1135
1136 ajTablePut(oa->CacheByIdentifier,
1137 (void *) Pidentifier,
1138 (void *) ensOntologyNewRef(*Pontology));
1139
1140 /* Insert into the namespace cache. */
1141
1142 ajTablePut(oa->CacheByNamespace,
1143 (void *) ajStrNewS(key),
1144 (void *) ensOntologyNewRef(*Pontology));
1145 }
1146
1147 if (ontology1 && ontology2 && (ontology1 == ontology2))
1148 {
1149 ajDebug("ontologyadaptorCacheInsert replaced Ensembl Ontology %p "
1150 "with one already cached %p.\n",
1151 *Pontology, ontology1);
1152
1153 ensOntologyDel(Pontology);
1154
1155 ensOntologyNewRef(ontology1);
1156
1157 Pontology = &ontology1;
1158 }
1159
1160 if (ontology1 && ontology2 && (ontology1 != ontology2))
1161 ajDebug("ontologyadaptorCacheInsert detected Ensembl Ontology objects "
1162 "in the identifier and namespace cache with identical keys "
1163 "('%S:%S' and '%S:%S') but different addresses (%p and %p).\n",
1164 ontology1->Name, ontology1->Space,
1165 ontology2->Name, ontology2->Space,
1166 ontology1, ontology2);
1167
1168 if (ontology1 && (!ontology2))
1169 ajDebug("ontologyadaptorCacheInsert detected an Ensembl Ontology "
1170 "in the identifier, but not in the namespace cache.\n");
1171
1172 if ((!ontology1) && ontology2)
1173 ajDebug("ontologyadaptorCacheInsert detected an Ensembl Ontology "
1174 "in the namespace, but not in the identifier cache.\n");
1175
1176 ajStrDel(&key);
1177
1178 return ajTrue;
1179 }
1180
1181
1182
1183
1184 #if AJFALSE
1185 /* @funcstatic ontologyadaptorCacheRemove *************************************
1186 **
1187 ** Remove an Ensembl Ontology from the Ensembl Ontology Adaptor-internal cache.
1188 **
1189 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1190 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
1191 **
1192 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1193 **
1194 ** @release 6.5.0
1195 ** @@
1196 ******************************************************************************/
1197
ontologyadaptorCacheRemove(EnsPOntologyadaptor oa,EnsPOntology ontology)1198 static AjBool ontologyadaptorCacheRemove(EnsPOntologyadaptor oa,
1199 EnsPOntology ontology)
1200 {
1201 AjPStr key = NULL;
1202
1203 EnsPOntology ontology1 = NULL;
1204 EnsPOntology ontology2 = NULL;
1205
1206 if (!oa)
1207 return ajFalse;
1208
1209 if (!ontology)
1210 return ajFalse;
1211
1212 ontology1 = (EnsPOntology) ajTableRemove(
1213 oa->CacheByIdentifier,
1214 (const void *) &ontology->Identifier);
1215
1216 key = ajFmtStr("%S:%S", ontology->Name, ontology->Space);
1217
1218 ontology2 = (EnsPOntology) ajTableRemove(
1219 oa->CacheByNamespace,
1220 (const void *) key);
1221
1222 if (ontology1 && (!ontology2))
1223 ajWarn("ontologyadaptorCacheRemove could remove Ensembl Ontology with "
1224 "identifier %u and key '%S' only from the identifier cache.\n",
1225 ontology->Identifier,
1226 newkey);
1227
1228 if ((!ontology1) && ontology2)
1229 ajWarn("ontologyadaptorCacheRemove could remove Ensembl Ontology with "
1230 "identifier %u and key '%S' only from the name cache.\n",
1231 ontology->Identifier,
1232 newkey);
1233
1234 ajStrDel(&key);
1235
1236 ensOntologyDel(&ontology1);
1237 ensOntologyDel(&ontology2);
1238
1239 return ajTrue;
1240 }
1241
1242 #endif /* AJFALSE */
1243
1244
1245
1246
1247 /* @section destructors *******************************************************
1248 **
1249 ** Destruction destroys all internal data structures and frees the memory
1250 ** allocated for an Ensembl Ontology Adaptor object.
1251 **
1252 ** @fdata [EnsPOntologyadaptor]
1253 **
1254 ** @nam3rule Del Destroy (free) an Ensembl Ontology Adaptor
1255 **
1256 ** @argrule * Poa [EnsPOntologyadaptor*] Ensembl Ontology Adaptor address
1257 **
1258 ** @valrule * [void]
1259 **
1260 ** @fcategory delete
1261 ******************************************************************************/
1262
1263
1264
1265
1266 /* @func ensOntologyadaptorDel ************************************************
1267 **
1268 ** Default destructor for an Ensembl Ontology Adaptor.
1269 **
1270 ** This function also clears the internal caches.
1271 **
1272 ** Ensembl Object Adaptors are singleton objects that are registered in the
1273 ** Ensembl Registry and weakly referenced by Ensembl Objects that have been
1274 ** instantiated by it. Therefore, Ensembl Object Adaptors should never be
1275 ** destroyed directly. Upon exit, the Ensembl Registry will call this function
1276 ** if required.
1277 **
1278 ** @param [d] Poa [EnsPOntologyadaptor*] Ensembl Ontology Adaptor address
1279 **
1280 ** @return [void]
1281 **
1282 ** @release 6.5.0
1283 ** @@
1284 ******************************************************************************/
1285
ensOntologyadaptorDel(EnsPOntologyadaptor * Poa)1286 void ensOntologyadaptorDel(EnsPOntologyadaptor *Poa)
1287 {
1288 EnsPOntologyadaptor pthis = NULL;
1289
1290 if (!Poa)
1291 return;
1292
1293 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1294 if (ajDebugTest("ensOntologyadaptorDel"))
1295 ajDebug("ensOntologyadaptorDel\n"
1296 " *Poa %p\n",
1297 *Poa);
1298 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1299
1300 if (!(pthis = *Poa))
1301 return;
1302
1303 ajTableDel(&pthis->CacheByIdentifier);
1304 ajTableDel(&pthis->CacheByNamespace);
1305
1306 ensBaseadaptorDel(&pthis->Adaptor);
1307
1308 ajMemFree((void **) Poa);
1309
1310 return;
1311 }
1312
1313
1314
1315
1316 /* @section member retrieval **************************************************
1317 **
1318 ** Functions for returning members of an Ensembl Ontology Adaptor object.
1319 **
1320 ** @fdata [EnsPOntologyadaptor]
1321 **
1322 ** @nam3rule Get Return Ensembl Ontology Adaptor attribute(s)
1323 ** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
1324 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
1325 **
1326 ** @argrule * oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1327 **
1328 ** @valrule Baseadaptor [EnsPBaseadaptor]
1329 ** Ensembl Base Adaptor or NULL
1330 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
1331 ** Ensembl Database Adaptor or NULL
1332 **
1333 ** @fcategory use
1334 ******************************************************************************/
1335
1336
1337
1338
1339 /* @func ensOntologyadaptorGetBaseadaptor *************************************
1340 **
1341 ** Get the Ensembl Base Adaptor member of an Ensembl Ontology Adaptor.
1342 **
1343 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1344 **
1345 ** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
1346 **
1347 ** @release 6.5.0
1348 ** @@
1349 ******************************************************************************/
1350
ensOntologyadaptorGetBaseadaptor(EnsPOntologyadaptor oa)1351 EnsPBaseadaptor ensOntologyadaptorGetBaseadaptor(
1352 EnsPOntologyadaptor oa)
1353 {
1354 if (!oa)
1355 return NULL;
1356
1357 return (oa) ? oa->Adaptor : NULL;
1358 }
1359
1360
1361
1362
1363 /* @func ensOntologyadaptorGetDatabaseadaptor *********************************
1364 **
1365 ** Get the Ensembl Database Adaptor member of an Ensembl Ontology Adaptor.
1366 **
1367 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1368 **
1369 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
1370 **
1371 ** @release 6.5.0
1372 ** @@
1373 ******************************************************************************/
1374
ensOntologyadaptorGetDatabaseadaptor(EnsPOntologyadaptor oa)1375 EnsPDatabaseadaptor ensOntologyadaptorGetDatabaseadaptor(
1376 EnsPOntologyadaptor oa)
1377 {
1378 if (!oa)
1379 return NULL;
1380
1381 return ensBaseadaptorGetDatabaseadaptor(
1382 ensOntologyadaptorGetBaseadaptor(oa));
1383 }
1384
1385
1386
1387
1388 /* @section object retrieval **************************************************
1389 **
1390 ** Functions for fetching Ensembl Ontology objects from an
1391 ** Ensembl SQL database.
1392 **
1393 ** @fdata [EnsPOntologyadaptor]
1394 **
1395 ** @nam3rule Fetch Fetch Ensembl Ontology object(s)
1396 ** @nam4rule All Fetch all Ensembl Ontology objects
1397 ** @nam4rule Allby Fetch all Ensembl Ontology objects matching a criterion
1398 ** @nam4rule By Fetch one Ensembl Ontology object matching a criterion
1399 ** @nam5rule Identifier Fetch by an SQL database internal identifier
1400 ** @nam5rule Name Fetch by a name
1401 **
1402 ** @argrule * oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1403 ** @argrule All ontologies [AjPList] AJAX List of Ensembl Ontology objects
1404 ** @argrule AllbyName name [const AjPStr] Ensembl Ontology name
1405 ** @argrule Allby ontologies [AjPList] AJAX List of Ensembl Ontology objects
1406 ** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
1407 ** @argrule ByName name [const AjPStr] Ensembl Ontology name
1408 ** @argrule ByName space [const AjPStr] Ensembl Ontology name space
1409 ** @argrule By Pontology [EnsPOntology*] Ensembl Ontology address
1410 **
1411 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
1412 **
1413 ** @fcategory use
1414 ******************************************************************************/
1415
1416
1417
1418
1419 /* @funcstatic ontologyadaptorFetchAll ****************************************
1420 **
1421 ** An ajTableMap "apply" function to return all Ensembl Ontology objects from
1422 ** the Ensembl Ontology Adaptor-internal cache.
1423 **
1424 ** @param [u] key [const void*] AJAX unsigned integer key data address
1425 ** @param [u] Pvalue [void**] Ensembl Ontology value data address
1426 ** @param [u] cl [void*]
1427 ** AJAX List of Ensembl Ontology objects, passed in via ajTableMap
1428 ** @see ajTableMap
1429 **
1430 ** @return [void]
1431 **
1432 ** @release 6.5.0
1433 ** @@
1434 ******************************************************************************/
1435
ontologyadaptorFetchAll(const void * key,void ** Pvalue,void * cl)1436 static void ontologyadaptorFetchAll(const void *key,
1437 void **Pvalue,
1438 void *cl)
1439 {
1440 if (!key)
1441 return;
1442
1443 if (!Pvalue)
1444 return;
1445
1446 if (!*Pvalue)
1447 return;
1448
1449 if (!cl)
1450 return;
1451
1452 ajListPushAppend((AjPList) cl,
1453 (void *) ensOntologyNewRef(*((EnsPOntology *) Pvalue)));
1454
1455 return;
1456 }
1457
1458
1459
1460
1461 /* @func ensOntologyadaptorFetchAll *******************************************
1462 **
1463 ** Fetch all Ensembl Ontology objects.
1464 **
1465 ** The caller is responsible for deleting the Ensembl Ontology objects before
1466 ** deleting the AJAX List object.
1467 **
1468 ** @cc Bio::EnsEMBL::DBSQL::OntologyAdaptor::fetch_all
1469 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1470 ** @param [u] ontologies [AjPList] AJAX List of Ensembl Ontology objects
1471 **
1472 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1473 **
1474 ** @release 6.5.0
1475 ** @@
1476 ******************************************************************************/
1477
ensOntologyadaptorFetchAll(EnsPOntologyadaptor oa,AjPList ontologies)1478 AjBool ensOntologyadaptorFetchAll(EnsPOntologyadaptor oa,
1479 AjPList ontologies)
1480 {
1481 if (!oa)
1482 return ajFalse;
1483
1484 if (!ontologies)
1485 return ajFalse;
1486
1487 if (!oa->CacheByIdentifier)
1488 ontologyadaptorCacheInit(oa);
1489
1490 ajTableMap(oa->CacheByIdentifier,
1491 &ontologyadaptorFetchAll,
1492 (void *) ontologies);
1493
1494 return ajTrue;
1495 }
1496
1497
1498
1499
1500 /* @func ensOntologyadaptorFetchAllbyName *************************************
1501 **
1502 ** Fetch all Ensembl Ontology objects by a name.
1503 **
1504 ** The caller is responsible for deleting the Ensembl Ontology objects before
1505 ** deleting the AJAX List object.
1506 **
1507 ** @cc Bio::EnsEMBL::DBSQL::OntologyAdaptor::???
1508 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1509 ** @param [r] name [const AjPStr] Ensembl Ontology name
1510 ** @param [u] ontologies [AjPList] AJAX List of Ensembl Ontology objects
1511 **
1512 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1513 **
1514 ** @release 6.5.0
1515 ** @@
1516 ******************************************************************************/
1517
ensOntologyadaptorFetchAllbyName(EnsPOntologyadaptor oa,const AjPStr name,AjPList ontologies)1518 AjBool ensOntologyadaptorFetchAllbyName(EnsPOntologyadaptor oa,
1519 const AjPStr name,
1520 AjPList ontologies)
1521 {
1522 void **valarray = NULL;
1523
1524 register ajuint i = 0U;
1525
1526 if (!oa)
1527 return ajFalse;
1528
1529 if (!(name && ajStrGetLen(name)))
1530 return ajFalse;
1531
1532 if (!ontologies)
1533 return ajFalse;
1534
1535 if (!oa->CacheByIdentifier)
1536 ontologyadaptorCacheInit(oa);
1537
1538 ajTableToarrayValues(oa->CacheByIdentifier, &valarray);
1539
1540 for (i = 0U; valarray[i]; i++)
1541 if (ajStrMatchS(ensOntologyGetName((EnsPOntology) valarray[i]), name))
1542 ajListPushAppend(
1543 ontologies,
1544 (void *) ensOntologyNewRef((EnsPOntology) valarray[i]));
1545
1546 AJFREE(valarray);
1547
1548 return ajTrue;
1549 }
1550
1551
1552
1553
1554 /* @func ensOntologyadaptorFetchByIdentifier **********************************
1555 **
1556 ** Fetch an Ensembl Ontology by its SQL database-internal identifier.
1557 ** The caller is responsible for deleting the Ensembl Ontology.
1558 **
1559 ** @cc Bio::EnsEMBL::DBSQL::OntologyAdaptor::fetch_by_dbID
1560 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1561 ** @param [r] identifier [ajuint] SQL database-internal identifier
1562 ** @param [wP] Pontology [EnsPOntology*] Ensembl Ontology address
1563 **
1564 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1565 **
1566 ** @release 6.5.0
1567 ** @@
1568 ******************************************************************************/
1569
ensOntologyadaptorFetchByIdentifier(EnsPOntologyadaptor oa,ajuint identifier,EnsPOntology * Pontology)1570 AjBool ensOntologyadaptorFetchByIdentifier(EnsPOntologyadaptor oa,
1571 ajuint identifier,
1572 EnsPOntology *Pontology)
1573 {
1574 AjBool result = AJFALSE;
1575
1576 if (!oa)
1577 return ajFalse;
1578
1579 if (!identifier)
1580 return ajFalse;
1581
1582 if (!Pontology)
1583 return ajFalse;
1584
1585 /*
1586 ** Initially, search the identifier cache.
1587 ** For any object returned by the AJAX Table the reference counter needs
1588 ** to be incremented manually.
1589 */
1590
1591 if (!oa->CacheByIdentifier)
1592 ontologyadaptorCacheInit(oa);
1593
1594 *Pontology = (EnsPOntology) ajTableFetchmodV(oa->CacheByIdentifier,
1595 (const void *) &identifier);
1596
1597 if (*Pontology)
1598 {
1599 ensOntologyNewRef(*Pontology);
1600
1601 return ajTrue;
1602 }
1603
1604 /* For a cache miss re-query the database. */
1605
1606 result = ensBaseadaptorFetchByIdentifier(
1607 ensOntologyadaptorGetBaseadaptor(oa),
1608 identifier,
1609 (void **) Pontology);
1610
1611 ontologyadaptorCacheInsert(oa, Pontology);
1612
1613 return result;
1614 }
1615
1616
1617
1618
1619 /* @func ensOntologyadaptorFetchByName ****************************************
1620 **
1621 ** Fetch an Ensembl Ontology by its name.
1622 ** The caller is responsible for deleting the Ensembl Ontology.
1623 **
1624 ** @cc Bio::EnsEMBL::DBSQL::OntologyAdaptor::fetch_by_logic_name
1625 ** @param [u] oa [EnsPOntologyadaptor] Ensembl Ontology Adaptor
1626 ** @param [r] name [const AjPStr] Ensembl Ontology name
1627 ** @param [r] space [const AjPStr] Ensembl Ontology name space
1628 ** @param [wP] Pontology [EnsPOntology*] Ensembl Ontology address
1629 **
1630 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1631 **
1632 ** @release 6.5.0
1633 ** @@
1634 ******************************************************************************/
1635
ensOntologyadaptorFetchByName(EnsPOntologyadaptor oa,const AjPStr name,const AjPStr space,EnsPOntology * Pontology)1636 AjBool ensOntologyadaptorFetchByName(EnsPOntologyadaptor oa,
1637 const AjPStr name,
1638 const AjPStr space,
1639 EnsPOntology *Pontology)
1640 {
1641 char *txtname = NULL;
1642 char *txtspace = NULL;
1643
1644 AjBool result = AJFALSE;
1645
1646 AjPList ontologies = NULL;
1647
1648 AjPStr constraint = NULL;
1649 AjPStr key = NULL;
1650
1651 EnsPBaseadaptor ba = NULL;
1652
1653 EnsPOntology ontology = NULL;
1654
1655 if (!oa)
1656 return ajFalse;
1657
1658 if (!(name && ajStrGetLen(name)))
1659 return ajFalse;
1660
1661 if (!(space && ajStrGetLen(space)))
1662 return ajFalse;
1663
1664 if (!Pontology)
1665 return ajFalse;
1666
1667 /*
1668 ** Initially, search the name cache.
1669 ** For any object returned by the AJAX Table the reference counter needs
1670 ** to be incremented manually.
1671 */
1672
1673 if (!oa->CacheByNamespace)
1674 ontologyadaptorCacheInit(oa);
1675
1676 key = ajFmtStr("%S:%S", name, space);
1677
1678 *Pontology = (EnsPOntology) ajTableFetchmodV(oa->CacheByNamespace,
1679 (const void *) key);
1680
1681 if (*Pontology)
1682 {
1683 ensOntologyNewRef(*Pontology);
1684
1685 return ajTrue;
1686 }
1687
1688 /* In case of a cache miss, re-query the database. */
1689
1690 ba = ensOntologyadaptorGetBaseadaptor(oa);
1691
1692 ensBaseadaptorEscapeC(ba, &txtname, name);
1693 ensBaseadaptorEscapeC(ba, &txtspace, space);
1694
1695 constraint = ajFmtStr("ontology.name = '%s' AND ontology.namespace = '%s'",
1696 txtname, txtspace);
1697
1698 ajCharDel(&txtname);
1699 ajCharDel(&txtspace);
1700
1701 ontologies = ajListNew();
1702
1703 result = ensBaseadaptorFetchAllbyConstraint(
1704 ba,
1705 constraint,
1706 (EnsPAssemblymapper) NULL,
1707 (EnsPSlice) NULL,
1708 ontologies);
1709
1710 if (ajListGetLength(ontologies) > 1)
1711 ajWarn("ensOntologyadaptorFetchByName got more than one "
1712 "Ensembl Ontology for (UNIQUE) name '%S'.\n",
1713 name);
1714
1715 ajListPop(ontologies, (void **) Pontology);
1716
1717 ontologyadaptorCacheInsert(oa, Pontology);
1718
1719 while (ajListPop(ontologies, (void **) &ontology))
1720 {
1721 ontologyadaptorCacheInsert(oa, &ontology);
1722
1723 ensOntologyDel(&ontology);
1724 }
1725
1726 ajListFree(&ontologies);
1727
1728 ajStrDel(&constraint);
1729
1730 return result;
1731 }
1732
1733
1734
1735
1736 /* @datasection [EnsPOntologysynonym] Ensembl Ontology Synonym ****************
1737 **
1738 ** @nam2rule Ontologysynonym Functions for manipulating
1739 ** Ensembl Ontology Synonym objects
1740 **
1741 ** @cc Split out of the Bio::EnsEMBL::OntologyTerm class
1742 **
1743 ******************************************************************************/
1744
1745
1746
1747
1748 /* @section constructors ******************************************************
1749 **
1750 ** All constructors return a new Ensembl Ontology Synonym by pointer.
1751 ** It is the responsibility of the user to first destroy any previous
1752 ** Ensembl Ontology Synonym.
1753 ** The target pointer does not need to be initialised to NULL, but it is good
1754 ** programming practice to do so anyway.
1755 **
1756 ** @fdata [EnsPOntologysynonym]
1757 **
1758 ** @nam3rule New Constructor
1759 ** @nam4rule Cpy Constructor with existing object
1760 ** @nam4rule Ini Constructor with initial values
1761 ** @nam4rule Ref Constructor by incrementing the reference counter
1762 **
1763 ** @argrule Cpy os [const EnsPOntologysynonym] Ensembl Ontology Synonym
1764 ** @argrule Ini ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
1765 ** @argrule Ini identifier [ajuint] SQL database-internal identifier
1766 ** @argrule Ini name [AjPStr] Name
1767 ** @argrule Ref os [EnsPOntologysynonym] Ensembl Ontology Synonym
1768 **
1769 ** @valrule * [EnsPOntologysynonym] Ensembl Ontology Synonym or NULL
1770 **
1771 ** @fcategory new
1772 ******************************************************************************/
1773
1774
1775
1776
1777 /* @func ensOntologysynonymNewCpy *********************************************
1778 **
1779 ** Object-based constructor function, which returns an independent object.
1780 **
1781 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
1782 **
1783 ** @return [EnsPOntologysynonym] Ensembl Ontology Synonym or NULL
1784 **
1785 ** @release 6.5.0
1786 ** @@
1787 ******************************************************************************/
1788
ensOntologysynonymNewCpy(const EnsPOntologysynonym os)1789 EnsPOntologysynonym ensOntologysynonymNewCpy(const EnsPOntologysynonym os)
1790 {
1791 EnsPOntologysynonym pthis = NULL;
1792
1793 if (!os)
1794 return NULL;
1795
1796 AJNEW0(pthis);
1797
1798 pthis->Use = 1U;
1799 pthis->Identifier = os->Identifier;
1800 pthis->Adaptor = os->Adaptor;
1801
1802 if (os->Name)
1803 pthis->Name = ajStrNewRef(os->Name);
1804
1805 return pthis;
1806 }
1807
1808
1809
1810
1811 /* @func ensOntologysynonymNewIni *********************************************
1812 **
1813 ** Constructor for an Ensembl Ontology Synonym object with initial values.
1814 **
1815 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
1816 ** @param [r] identifier [ajuint] SQL database-internal identifier
1817 ** @param [u] name [AjPStr] Name
1818 **
1819 ** @return [EnsPOntologysynonym] Ensembl Ontology Synonym or NULL
1820 **
1821 ** @release 6.5.0
1822 ** @@
1823 ******************************************************************************/
1824
ensOntologysynonymNewIni(EnsPOntologytermadaptor ota,ajuint identifier,AjPStr name)1825 EnsPOntologysynonym ensOntologysynonymNewIni(EnsPOntologytermadaptor ota,
1826 ajuint identifier,
1827 AjPStr name)
1828 {
1829 EnsPOntologysynonym os = NULL;
1830
1831 if (!name)
1832 return NULL;
1833
1834 AJNEW0(os);
1835
1836 os->Use = 1U;
1837 os->Identifier = identifier;
1838 os->Adaptor = ota;
1839
1840 if (name)
1841 os->Name = ajStrNewRef(name);
1842
1843 return os;
1844 }
1845
1846
1847
1848
1849 /* @func ensOntologysynonymNewRef *********************************************
1850 **
1851 ** Ensembl Object referencing function, which returns a pointer to the
1852 ** Ensembl Object passed in and increases its reference count.
1853 **
1854 ** @param [u] os [EnsPOntologysynonym] Ensembl Ontology Synonym
1855 **
1856 ** @return [EnsPOntologysynonym] Ensembl Ontology Synonym or NULL
1857 **
1858 ** @release 6.5.0
1859 ** @@
1860 ******************************************************************************/
1861
ensOntologysynonymNewRef(EnsPOntologysynonym os)1862 EnsPOntologysynonym ensOntologysynonymNewRef(EnsPOntologysynonym os)
1863 {
1864 if (!os)
1865 return NULL;
1866
1867 os->Use++;
1868
1869 return os;
1870 }
1871
1872
1873
1874
1875 /* @section destructors *******************************************************
1876 **
1877 ** Destruction destroys all internal data structures and frees the memory
1878 ** allocated for an Ensembl Ontology Synonym object.
1879 **
1880 ** @fdata [EnsPOntologysynonym]
1881 **
1882 ** @nam3rule Del Destroy (free) an Ensembl Ontology Synonym
1883 **
1884 ** @argrule * Pos [EnsPOntologysynonym*] Ensembl Ontology Synonym address
1885 **
1886 ** @valrule * [void]
1887 **
1888 ** @fcategory delete
1889 ******************************************************************************/
1890
1891
1892
1893
1894 /* @func ensOntologysynonymDel ************************************************
1895 **
1896 ** Default destructor for an Ensembl Ontology Synonym.
1897 **
1898 ** @param [d] Pos [EnsPOntologysynonym*] Ensembl Ontology Synonym address
1899 **
1900 ** @return [void]
1901 **
1902 ** @release 6.5.0
1903 ** @@
1904 ******************************************************************************/
1905
ensOntologysynonymDel(EnsPOntologysynonym * Pos)1906 void ensOntologysynonymDel(EnsPOntologysynonym *Pos)
1907 {
1908 EnsPOntologysynonym pthis = NULL;
1909
1910 if (!Pos)
1911 return;
1912
1913 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1914 if (ajDebugTest("ensOntologysynonymDel"))
1915 {
1916 ajDebug("ensOntologysynonymDel\n"
1917 " *Pos %p\n",
1918 *Pos);
1919
1920 ensOntologysynonymTrace(*Pos, 1);
1921 }
1922 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1923
1924 if (!(pthis = *Pos) || --pthis->Use)
1925 {
1926 *Pos = NULL;
1927
1928 return;
1929 }
1930
1931 ajStrDel(&pthis->Name);
1932
1933 ajMemFree((void **) Pos);
1934
1935 return;
1936 }
1937
1938
1939
1940
1941 /* @section member retrieval **************************************************
1942 **
1943 ** Functions for returning members of an Ensembl Ontology Synonym object.
1944 **
1945 ** @fdata [EnsPOntologysynonym]
1946 **
1947 ** @nam3rule Get Return Ensembl Ontology Synonym attribute(s)
1948 ** @nam4rule Adaptor Return the Ensembl Ontology Term Adaptor
1949 ** @nam4rule Identifier Return the SQL database-internal identifier
1950 ** @nam4rule Name Return the name
1951 **
1952 ** @argrule * os [const EnsPOntologysynonym] Ensembl Ontology Synonym
1953 **
1954 ** @valrule Adaptor [EnsPOntologytermadaptor]
1955 ** Ensembl Ontology Term Adaptor or NULL
1956 ** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
1957 ** @valrule Name [AjPStr] Name or NULL
1958 **
1959 ** @fcategory use
1960 ******************************************************************************/
1961
1962
1963
1964
1965 /* @func ensOntologysynonymGetAdaptor *****************************************
1966 **
1967 ** Get the Ensembl Ontology Term Adaptor member of an
1968 ** Ensembl Ontology Synonym.
1969 **
1970 ** @cc Bio::EnsEMBL::Storable::adaptor
1971 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
1972 **
1973 ** @return [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor or NULL
1974 **
1975 ** @release 6.5.0
1976 ** @@
1977 ******************************************************************************/
1978
ensOntologysynonymGetAdaptor(const EnsPOntologysynonym os)1979 EnsPOntologytermadaptor ensOntologysynonymGetAdaptor(
1980 const EnsPOntologysynonym os)
1981 {
1982 return (os) ? os->Adaptor : NULL;
1983 }
1984
1985
1986
1987
1988 /* @func ensOntologysynonymGetIdentifier **************************************
1989 **
1990 ** Get the SQL database-internal identifier member of an
1991 ** Ensembl Ontology Synonym.
1992 **
1993 ** @cc Bio::EnsEMBL::Storable::dbID
1994 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
1995 **
1996 ** @return [ajuint] SQL database-internal identifier or 0U
1997 **
1998 ** @release 6.5.0
1999 ** @@
2000 ******************************************************************************/
2001
ensOntologysynonymGetIdentifier(const EnsPOntologysynonym os)2002 ajuint ensOntologysynonymGetIdentifier(
2003 const EnsPOntologysynonym os)
2004 {
2005 return (os) ? os->Identifier : 0U;
2006 }
2007
2008
2009
2010
2011 /* @func ensOntologysynonymGetName ********************************************
2012 **
2013 ** Get the name member of an Ensembl Ontology Synonym.
2014 **
2015 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
2016 **
2017 ** @return [AjPStr] Name or NULL
2018 **
2019 ** @release 6.5.0
2020 ** @@
2021 ******************************************************************************/
2022
ensOntologysynonymGetName(const EnsPOntologysynonym os)2023 AjPStr ensOntologysynonymGetName(
2024 const EnsPOntologysynonym os)
2025 {
2026 return (os) ? os->Name : NULL;
2027 }
2028
2029
2030
2031
2032 /* @section member assignment *************************************************
2033 **
2034 ** Functions for assigning members of an Ensembl Ontology Synonym object.
2035 **
2036 ** @fdata [EnsPOntologysynonym]
2037 **
2038 ** @nam3rule Set Set one member of an Ensembl Ontology Synonym
2039 ** @nam4rule Adaptor Set the Ensembl Ontology Term Adaptor
2040 ** @nam4rule Identifier Set the SQL database-internal identifier
2041 ** @nam4rule Name Set the name
2042 **
2043 ** @argrule * os [EnsPOntologysynonym] Ensembl Ontology Synonym object
2044 ** @argrule Adaptor ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2045 ** @argrule Identifier identifier [ajuint] SQL database-internal identifier
2046 ** @argrule Name name [AjPStr] Name
2047 **
2048 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2049 **
2050 ** @fcategory modify
2051 ******************************************************************************/
2052
2053
2054
2055
2056 /* @func ensOntologysynonymSetAdaptor *****************************************
2057 **
2058 ** Set the Ensembl Ontology Term Adaptor member of an
2059 ** Ensembl Ontology Synonym.
2060 **
2061 ** @cc Bio::EnsEMBL::Storable::adaptor
2062 ** @param [u] os [EnsPOntologysynonym] Ensembl Ontology Synonym
2063 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2064 **
2065 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2066 **
2067 ** @release 6.5.0
2068 ** @@
2069 ******************************************************************************/
2070
ensOntologysynonymSetAdaptor(EnsPOntologysynonym os,EnsPOntologytermadaptor ota)2071 AjBool ensOntologysynonymSetAdaptor(EnsPOntologysynonym os,
2072 EnsPOntologytermadaptor ota)
2073 {
2074 if (!os)
2075 return ajFalse;
2076
2077 os->Adaptor = ota;
2078
2079 return ajTrue;
2080 }
2081
2082
2083
2084
2085 /* @func ensOntologysynonymSetIdentifier **************************************
2086 **
2087 ** Set the SQL database-internal identifier member of an
2088 ** Ensembl Ontology Synonym.
2089 **
2090 ** @cc Bio::EnsEMBL::Storable::dbID
2091 ** @param [u] os [EnsPOntologysynonym] Ensembl Ontology Synonym
2092 ** @param [r] identifier [ajuint] SQL database-internal identifier
2093 **
2094 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2095 **
2096 ** @release 6.5.0
2097 ** @@
2098 ******************************************************************************/
2099
ensOntologysynonymSetIdentifier(EnsPOntologysynonym os,ajuint identifier)2100 AjBool ensOntologysynonymSetIdentifier(EnsPOntologysynonym os,
2101 ajuint identifier)
2102 {
2103 if (!os)
2104 return ajFalse;
2105
2106 os->Identifier = identifier;
2107
2108 return ajTrue;
2109 }
2110
2111
2112
2113
2114 /* @func ensOntologysynonymSetName ********************************************
2115 **
2116 ** Set the name member of an Ensembl Ontology Synonym.
2117 **
2118 ** @param [u] os [EnsPOntologysynonym] Ensembl Ontology Synonym
2119 ** @param [u] name [AjPStr] Name
2120 **
2121 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2122 **
2123 ** @release 6.5.0
2124 ** @@
2125 ******************************************************************************/
2126
ensOntologysynonymSetName(EnsPOntologysynonym os,AjPStr name)2127 AjBool ensOntologysynonymSetName(EnsPOntologysynonym os,
2128 AjPStr name)
2129 {
2130 if (!os)
2131 return ajFalse;
2132
2133 ajStrDel(&os->Name);
2134
2135 if (name)
2136 os->Name = ajStrNewRef(name);
2137
2138 return ajTrue;
2139 }
2140
2141
2142
2143
2144 /* @section debugging *********************************************************
2145 **
2146 ** Functions for reporting of an Ensembl Ontology Synonym object.
2147 **
2148 ** @fdata [EnsPOntologysynonym]
2149 **
2150 ** @nam3rule Trace Report Ensembl Ontology Synonym members to debug file.
2151 **
2152 ** @argrule Trace os [const EnsPOntologysynonym] Ensembl Ontology Synonym
2153 ** @argrule Trace level [ajuint] Indentation level
2154 **
2155 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2156 **
2157 ** @fcategory misc
2158 ******************************************************************************/
2159
2160
2161
2162
2163 /* @func ensOntologysynonymTrace **********************************************
2164 **
2165 ** Trace an Ensembl Ontology Synonym.
2166 **
2167 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
2168 ** @param [r] level [ajuint] Indentation level
2169 **
2170 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2171 **
2172 ** @release 6.5.0
2173 ** @@
2174 ******************************************************************************/
2175
ensOntologysynonymTrace(const EnsPOntologysynonym os,ajuint level)2176 AjBool ensOntologysynonymTrace(const EnsPOntologysynonym os, ajuint level)
2177 {
2178 AjPStr indent = NULL;
2179
2180 if (!os)
2181 return ajFalse;
2182
2183 indent = ajStrNew();
2184
2185 ajStrAppendCountK(&indent, ' ', level * 2);
2186
2187 ajDebug("%SensOntologysynonymTrace %p\n"
2188 "%S Use %u\n"
2189 "%S Identifier %u\n"
2190 "%S Adaptor %p\n"
2191 "%S Name '%S'\n",
2192 indent, os,
2193 indent, os->Use,
2194 indent, os->Identifier,
2195 indent, os->Adaptor,
2196 indent, os->Name);
2197
2198 ajStrDel(&indent);
2199
2200 return ajTrue;
2201 }
2202
2203
2204
2205
2206 /* @section calculate *********************************************************
2207 **
2208 ** Functions for calculating information from an
2209 ** Ensembl Ontology Synonym object.
2210 **
2211 ** @fdata [EnsPOntologysynonym]
2212 **
2213 ** @nam3rule Calculate Calculate Ensembl Ontology Synonym information
2214 ** @nam4rule Memsize Calculate the memory size in bytes
2215 **
2216 ** @argrule * os [const EnsPOntologysynonym] Ensembl Ontology Synonym
2217 **
2218 ** @valrule Memsize [size_t] Memory size in bytes or 0
2219 **
2220 ** @fcategory misc
2221 ******************************************************************************/
2222
2223
2224
2225
2226 /* @func ensOntologysynonymCalculateMemsize ***********************************
2227 **
2228 ** Get the memory size in bytes of an Ensembl Ontology Synonym.
2229 **
2230 ** @param [r] os [const EnsPOntologysynonym] Ensembl Ontology Synonym
2231 **
2232 ** @return [size_t] Memory size in bytes or 0
2233 **
2234 ** @release 6.5.0
2235 ** @@
2236 ******************************************************************************/
2237
ensOntologysynonymCalculateMemsize(const EnsPOntologysynonym os)2238 size_t ensOntologysynonymCalculateMemsize(const EnsPOntologysynonym os)
2239 {
2240 size_t size = 0;
2241
2242 if (!os)
2243 return 0;
2244
2245 size += sizeof (EnsOOntologysynonym);
2246
2247 if (os->Name)
2248 {
2249 size += sizeof (AjOStr);
2250
2251 size += ajStrGetRes(os->Name);
2252 }
2253
2254 return size;
2255 }
2256
2257
2258
2259
2260 /* @datasection [EnsPOntologyterm] Ensembl Ontology Term **********************
2261 **
2262 ** @nam2rule Ontologyterm Functions for manipulating
2263 ** Ensembl Ontology Term objects
2264 **
2265 ** @cc Bio::EnsEMBL::OntologyTerm
2266 ** @cc CVS Revision: 1.18
2267 ** @cc CVS Tag: branch-ensembl-68
2268 **
2269 ******************************************************************************/
2270
2271
2272
2273
2274 /* @section constructors ******************************************************
2275 **
2276 ** All constructors return a new Ensembl Ontology Term by pointer.
2277 ** It is the responsibility of the user to first destroy any previous
2278 ** Ensembl Ontology Term.
2279 ** The target pointer does not need to be initialised to NULL, but it is good
2280 ** programming practice to do so anyway.
2281 **
2282 ** @fdata [EnsPOntologyterm]
2283 **
2284 ** @nam3rule New Constructor
2285 ** @nam4rule Cpy Constructor with existing object
2286 ** @nam4rule Ini Constructor with initial values
2287 ** @nam4rule Ref Constructor by incrementing the reference counter
2288 **
2289 ** @argrule Cpy ot [const EnsPOntologyterm] Ensembl Ontology Term
2290 ** @argrule Ini ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2291 ** @argrule Ini identifier [ajuint] SQL database-internal identifier
2292 ** @argrule Ini ontology [EnsPOntology] Ensembl Ontology
2293 ** @argrule Ini accession [AjPStr] Accession
2294 ** @argrule Ini definition [AjPStr] Definition
2295 ** @argrule Ini name [AjPStr] Name
2296 ** @argrule Ini subsets [AjPStr] Sub-sets
2297 ** @argrule Ref ot [EnsPOntologyterm] Ensembl Ontology Term
2298 **
2299 ** @valrule * [EnsPOntologyterm] Ensembl Ontology Term or NULL
2300 **
2301 ** @fcategory new
2302 ******************************************************************************/
2303
2304
2305
2306
2307 /* @func ensOntologytermNewCpy ************************************************
2308 **
2309 ** Object-based constructor function, which returns an independent object.
2310 **
2311 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2312 **
2313 ** @return [EnsPOntologyterm] Ensembl Ontology Term or NULL
2314 **
2315 ** @release 6.5.0
2316 ** @@
2317 ******************************************************************************/
2318
ensOntologytermNewCpy(const EnsPOntologyterm ot)2319 EnsPOntologyterm ensOntologytermNewCpy(const EnsPOntologyterm ot)
2320 {
2321 AjIList iter = NULL;
2322
2323 EnsPOntologysynonym os = NULL;
2324
2325 EnsPOntologyterm pthis = NULL;
2326
2327 if (!ot)
2328 return NULL;
2329
2330 AJNEW0(pthis);
2331
2332 pthis->Use = 1U;
2333 pthis->Identifier = ot->Identifier;
2334 pthis->Adaptor = ot->Adaptor;
2335 pthis->Ontology = ensOntologyNewRef(ot->Ontology);
2336
2337 if (ot->Accession)
2338 pthis->Accession = ajStrNewRef(ot->Accession);
2339
2340 if (ot->Definition)
2341 pthis->Definition = ajStrNewRef(ot->Definition);
2342
2343 if (ot->Name)
2344 pthis->Name = ajStrNewRef(ot->Name);
2345
2346 if (ot->Subsets)
2347 pthis->Subsets = ajStrNewRef(ot->Subsets);
2348
2349 /*
2350 ** FIXME: The AJAX Table objects for child and parent
2351 ** Ensembl Ontology Term objects are not copied.
2352 */
2353
2354 if (ot->Ontologysynonyms)
2355 {
2356 pthis->Ontologysynonyms = ajListNew();
2357
2358 iter = ajListIterNew(ot->Ontologysynonyms);
2359
2360 while (!ajListIterDone(iter))
2361 {
2362 os = (EnsPOntologysynonym) ajListIterGet(iter);
2363
2364 ajListPushAppend(pthis->Ontologysynonyms,
2365 (void *) ensOntologysynonymNewRef(os));
2366 }
2367
2368 ajListIterDel(&iter);
2369 }
2370
2371 return pthis;
2372 }
2373
2374
2375
2376
2377 /* @func ensOntologytermNewIni ************************************************
2378 **
2379 ** Constructor for an Ensembl Ontology Term object with initial values.
2380 **
2381 ** @cc Bio::EnsEMBL::Storable::new
2382 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2383 ** @param [r] identifier [ajuint] SQL database-internal identifier
2384 ** @cc Bio::EnsEMBL::OntologyTerm::new
2385 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
2386 ** @param [uN] accession [AjPStr] Accession
2387 ** @param [uN] definition [AjPStr] Definition
2388 ** @param [uN] name [AjPStr] Name
2389 ** @param [uN] subsets [AjPStr] Sub-sets
2390 **
2391 ** @return [EnsPOntologyterm] Ensembl Ontology Term or NULL
2392 **
2393 ** @release 6.5.0
2394 ** @@
2395 ******************************************************************************/
2396
ensOntologytermNewIni(EnsPOntologytermadaptor ota,ajuint identifier,EnsPOntology ontology,AjPStr accession,AjPStr definition,AjPStr name,AjPStr subsets)2397 EnsPOntologyterm ensOntologytermNewIni(EnsPOntologytermadaptor ota,
2398 ajuint identifier,
2399 EnsPOntology ontology,
2400 AjPStr accession,
2401 AjPStr definition,
2402 AjPStr name,
2403 AjPStr subsets)
2404 {
2405 EnsPOntologyterm ot = NULL;
2406
2407 if (!ontology)
2408 return NULL;
2409
2410 AJNEW0(ot);
2411
2412 ot->Use = 1U;
2413 ot->Identifier = identifier;
2414 ot->Adaptor = ota;
2415 ot->Ontology = ensOntologyNewRef(ontology);
2416
2417 if (accession)
2418 ot->Accession = ajStrNewRef(accession);
2419
2420 if (definition)
2421 ot->Definition = ajStrNewRef(definition);
2422
2423 if (name)
2424 ot->Name = ajStrNewRef(name);
2425
2426 if (subsets)
2427 ot->Subsets = ajStrNewRef(subsets);
2428
2429 return ot;
2430 }
2431
2432
2433
2434
2435 /* @func ensOntologytermNewRef ************************************************
2436 **
2437 ** Ensembl Object referencing function, which returns a pointer to the
2438 ** Ensembl Object passed in and increases its reference count.
2439 **
2440 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2441 **
2442 ** @return [EnsPOntologyterm] Ensembl Ontology Term or NULL
2443 **
2444 ** @release 6.5.0
2445 ** @@
2446 ******************************************************************************/
2447
ensOntologytermNewRef(EnsPOntologyterm ot)2448 EnsPOntologyterm ensOntologytermNewRef(EnsPOntologyterm ot)
2449 {
2450 if (!ot)
2451 return NULL;
2452
2453 ot->Use++;
2454
2455 return ot;
2456 }
2457
2458
2459
2460
2461 /* @section destructors *******************************************************
2462 **
2463 ** Destruction destroys all internal data structures and frees the memory
2464 ** allocated for an Ensembl Ontology Term object.
2465 **
2466 ** @fdata [EnsPOntologyterm]
2467 **
2468 ** @nam3rule Del Destroy (free) an Ensembl Ontology Term
2469 **
2470 ** @argrule * Pot [EnsPOntologyterm*] Ensembl Ontology Term address
2471 **
2472 ** @valrule * [void]
2473 **
2474 ** @fcategory delete
2475 ******************************************************************************/
2476
2477
2478
2479
2480 /* @func ensOntologytermDel ***************************************************
2481 **
2482 ** Default destructor for an Ensembl Ontology Term.
2483 **
2484 ** @param [d] Pot [EnsPOntologyterm*] Ensembl Ontology Term address
2485 **
2486 ** @return [void]
2487 **
2488 ** @release 6.5.0
2489 ** @@
2490 ******************************************************************************/
2491
ensOntologytermDel(EnsPOntologyterm * Pot)2492 void ensOntologytermDel(EnsPOntologyterm *Pot)
2493 {
2494 EnsPOntologysynonym os = NULL;
2495
2496 EnsPOntologyterm pthis = NULL;
2497
2498 if (!Pot)
2499 return;
2500
2501 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
2502 if (ajDebugTest("ensOntologytermDel"))
2503 {
2504 ajDebug("ensOntologytermDel\n"
2505 " *Pot %p\n",
2506 *Pot);
2507
2508 ensOntologytermTrace(*Pot, 1);
2509 }
2510 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
2511
2512 if (!(pthis = *Pot) || --pthis->Use)
2513 {
2514 *Pot = NULL;
2515
2516 return;
2517 }
2518
2519 ensOntologyDel(&pthis->Ontology);
2520
2521 ajStrDel(&pthis->Accession);
2522 ajStrDel(&pthis->Definition);
2523 ajStrDel(&pthis->Name);
2524 ajStrDel(&pthis->Subsets);
2525
2526 ajTableDel(&pthis->Children);
2527 ajTableDel(&pthis->Parents);
2528
2529 while (ajListPop(pthis->Ontologysynonyms, (void **) &os))
2530 ensOntologysynonymDel(&os);
2531
2532 ajListFree(&pthis->Ontologysynonyms);
2533
2534 ajMemFree((void **) Pot);
2535
2536 return;
2537 }
2538
2539
2540
2541
2542 /* @section member retrieval **************************************************
2543 **
2544 ** Functions for returning members of an Ensembl Ontology Term object.
2545 **
2546 ** @fdata [EnsPOntologyterm]
2547 **
2548 ** @nam3rule Get Return Ensembl Ontology Term attribute(s)
2549 ** @nam4rule Accession Return the accession
2550 ** @nam4rule Adaptor Return the Ensembl Ontology Term Adaptor
2551 ** @nam4rule Definition Return the definition
2552 ** @nam4rule Identifier Return the SQL database-internal identifier
2553 ** @nam4rule Name Return the name
2554 ** @nam4rule Ontology Return the Ensembl Ontology
2555 ** @nam4rule Subsets Return the sub-sets
2556 **
2557 ** @argrule * ot [const EnsPOntologyterm] Ensembl Ontology Term
2558 **
2559 ** @valrule Accession [AjPStr] Accession or NULL
2560 ** @valrule Adaptor [EnsPOntologytermadaptor]
2561 ** Ensembl Ontology Term Adaptor or NULL
2562 ** @valrule Definition [AjPStr] Definition or NULL
2563 ** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
2564 ** @valrule Name [AjPStr] Name or NULL
2565 ** @valrule Ontology [EnsPOntology] Ensembl Ontology or NULL
2566 ** @valrule Subsets [AjPStr] Sub-sets
2567 **
2568 ** @fcategory use
2569 ******************************************************************************/
2570
2571
2572
2573
2574 /* @func ensOntologytermGetAccession ******************************************
2575 **
2576 ** Get the accession member of an Ensembl Ontology Term.
2577 **
2578 ** @cc Bio::EnsEMBL::OntologyTerm::accession
2579 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2580 **
2581 ** @return [AjPStr] Accession or NULL
2582 **
2583 ** @release 6.5.0
2584 ** @@
2585 ******************************************************************************/
2586
ensOntologytermGetAccession(const EnsPOntologyterm ot)2587 AjPStr ensOntologytermGetAccession(const EnsPOntologyterm ot)
2588 {
2589 return (ot) ? ot->Accession : NULL;
2590 }
2591
2592
2593
2594
2595 /* @func ensOntologytermGetAdaptor ********************************************
2596 **
2597 ** Get the Ensembl Ontology Term Adaptor member of an
2598 ** Ensembl Ontology Term.
2599 **
2600 ** @cc Bio::EnsEMBL::Storable::adaptor
2601 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2602 **
2603 ** @return [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor or NULL
2604 **
2605 ** @release 6.5.0
2606 ** @@
2607 ******************************************************************************/
2608
ensOntologytermGetAdaptor(const EnsPOntologyterm ot)2609 EnsPOntologytermadaptor ensOntologytermGetAdaptor(const EnsPOntologyterm ot)
2610 {
2611 return (ot) ? ot->Adaptor : NULL;
2612 }
2613
2614
2615
2616
2617 /* @func ensOntologytermGetDefinition *****************************************
2618 **
2619 ** Get the definition member of an Ensembl Ontology Term.
2620 **
2621 ** @cc Bio::EnsEMBL::OntologyTerm::definition
2622 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2623 **
2624 ** @return [AjPStr] Definition or NULL
2625 **
2626 ** @release 6.5.0
2627 ** @@
2628 ******************************************************************************/
2629
ensOntologytermGetDefinition(const EnsPOntologyterm ot)2630 AjPStr ensOntologytermGetDefinition(const EnsPOntologyterm ot)
2631 {
2632 return (ot) ? ot->Definition : NULL;
2633 }
2634
2635
2636
2637
2638 /* @func ensOntologytermGetIdentifier *****************************************
2639 **
2640 ** Get the SQL database-internal identifier member of an
2641 ** Ensembl Ontology Term.
2642 **
2643 ** @cc Bio::EnsEMBL::Storable::dbID
2644 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2645 **
2646 ** @return [ajuint] SQL database-internal identifier or 0U
2647 **
2648 ** @release 6.5.0
2649 ** @@
2650 ******************************************************************************/
2651
ensOntologytermGetIdentifier(const EnsPOntologyterm ot)2652 ajuint ensOntologytermGetIdentifier(const EnsPOntologyterm ot)
2653 {
2654 return (ot) ? ot->Identifier : 0U;
2655 }
2656
2657
2658
2659
2660 /* @func ensOntologytermGetName ***********************************************
2661 **
2662 ** Get the name member of an Ensembl Ontology Term.
2663 **
2664 ** @cc Bio::EnsEMBL::OntologyTerm::name
2665 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2666 **
2667 ** @return [AjPStr] Name or NULL
2668 **
2669 ** @release 6.5.0
2670 ** @@
2671 ******************************************************************************/
2672
ensOntologytermGetName(const EnsPOntologyterm ot)2673 AjPStr ensOntologytermGetName(const EnsPOntologyterm ot)
2674 {
2675 return (ot) ? ot->Name : NULL;
2676 }
2677
2678
2679
2680
2681 /* @func ensOntologytermGetOntology *******************************************
2682 **
2683 ** Get the Ensembl Ontology member of an
2684 ** Ensembl Ontology Term.
2685 **
2686 ** @cc Bio::EnsEMBL::OntologyTerm::ontology
2687 ** @cc Bio::EnsEMBL::OntologyTerm::namespace
2688 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2689 **
2690 ** @return [EnsPOntology] Ensembl Ontology or NULL
2691 **
2692 ** @release 6.5.0
2693 ** @@
2694 ******************************************************************************/
2695
ensOntologytermGetOntology(const EnsPOntologyterm ot)2696 EnsPOntology ensOntologytermGetOntology(const EnsPOntologyterm ot)
2697 {
2698 return (ot) ? ot->Ontology : NULL;
2699 }
2700
2701
2702
2703
2704 /* @func ensOntologytermGetSubsets ********************************************
2705 **
2706 ** Get the sub-sets member of an Ensembl Ontology Term.
2707 **
2708 ** @cc Bio::EnsEMBL::OntologyTerm::subsets
2709 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
2710 **
2711 ** @return [AjPStr] Sub-sets or NULL
2712 **
2713 ** @release 6.5.0
2714 ** @@
2715 ******************************************************************************/
2716
ensOntologytermGetSubsets(const EnsPOntologyterm ot)2717 AjPStr ensOntologytermGetSubsets(const EnsPOntologyterm ot)
2718 {
2719 return (ot) ? ot->Subsets : NULL;
2720 }
2721
2722
2723
2724
2725 /* @section load on demand ****************************************************
2726 **
2727 ** Functions for returning members of an Ensembl Ontology Term object,
2728 ** which may need loading from an Ensembl SQL database on demand.
2729 **
2730 ** @fdata [EnsPOntologyterm]
2731 **
2732 ** @nam3rule Load Return Ensembl Ontology Term attribute(s) loaded on demand
2733 ** @nam4rule Ontologysynonyms Return all Ensembl Ontology Synonym objects
2734 **
2735 ** @argrule * ot [EnsPOntologyterm] Ensembl Ontology Term
2736 **
2737 ** @valrule Ontologysynonyms [const AjPList]
2738 ** AJAX List of Ensembl Ontology Synonym objects or NULL
2739 **
2740 ** @fcategory use
2741 ******************************************************************************/
2742
2743
2744
2745
2746 /* @func ensOntologytermLoadOntologysynonyms **********************************
2747 **
2748 ** Load all Ensembl Ontology Synonym objects of an Ensembl Ontology Term.
2749 **
2750 ** This is not a simple accessor function, it will fetch
2751 ** Ensembl Ontology Synonym objects from an Ensembl SQL database in case the
2752 ** AJAX List is not defined.
2753 **
2754 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2755 **
2756 ** @return [const AjPList]
2757 ** AJAX List of Ensembl Ontology Synonym objects or NULL
2758 **
2759 ** @release 6.4.0
2760 ** @@
2761 ******************************************************************************/
2762
ensOntologytermLoadOntologysynonyms(EnsPOntologyterm ot)2763 const AjPList ensOntologytermLoadOntologysynonyms(EnsPOntologyterm ot)
2764 {
2765 if (!ot)
2766 return NULL;
2767
2768 if (ot->Ontologysynonyms)
2769 return ot->Ontologysynonyms;
2770
2771 if (!ot->Adaptor)
2772 {
2773 ajDebug("ensOntologytermLoadOntologysynonyms cannot fetch "
2774 "Ensembl Ontology Synonym objects for an "
2775 "Ensembl Ontology Term without an "
2776 "Ensembl Ontology Term Adaptor.\n");
2777
2778 return NULL;
2779 }
2780
2781 ot->Ontologysynonyms = ajListNew();
2782
2783 ensOntologytermadaptorRetrieveAllOntologysynonyms(ot->Adaptor,
2784 ot,
2785 ot->Ontologysynonyms);
2786
2787 return ot->Ontologysynonyms;
2788 }
2789
2790
2791
2792
2793 /* @section member assignment *************************************************
2794 **
2795 ** Functions for assigning members of an Ensembl Ontology Term object.
2796 **
2797 ** @fdata [EnsPOntologyterm]
2798 **
2799 ** @nam3rule Set Set one member of an Ensembl Ontology Term
2800 ** @nam4rule Accession Set the accession
2801 ** @nam4rule Adaptor Set the Ensembl Ontology Term Adaptor
2802 ** @nam4rule Definition Set the definition
2803 ** @nam4rule Identifier Set the SQL database-internal identifier
2804 ** @nam4rule Name Set the name
2805 ** @nam4rule Ontology Set the Ensembl Ontology
2806 ** @nam4rule Subsets Set sub-sets
2807 **
2808 ** @argrule * ot [EnsPOntologyterm] Ensembl Ontology Term object
2809 ** @argrule Accession accession [AjPStr] Accession
2810 ** @argrule Adaptor ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2811 ** @argrule Definition definition [AjPStr] Definition
2812 ** @argrule Identifier identifier [ajuint] SQL database-internal identifier
2813 ** @argrule Name name [AjPStr] Name
2814 ** @argrule Ontology ontology [EnsPOntology] Ensembl Ontology
2815 ** @argrule Subsets subsets [AjPStr] Sub-sets
2816 **
2817 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2818 **
2819 ** @fcategory modify
2820 ******************************************************************************/
2821
2822
2823
2824
2825 /* @func ensOntologytermSetAccession ******************************************
2826 **
2827 ** Set the accession member of an Ensembl Ontology Term.
2828 **
2829 ** @cc Bio::EnsEMBL::OntologyTerm::accession
2830 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2831 ** @param [u] accession [AjPStr] Accession
2832 **
2833 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2834 **
2835 ** @release 6.5.0
2836 ** @@
2837 ******************************************************************************/
2838
ensOntologytermSetAccession(EnsPOntologyterm ot,AjPStr accession)2839 AjBool ensOntologytermSetAccession(EnsPOntologyterm ot,
2840 AjPStr accession)
2841 {
2842 if (!ot)
2843 return ajFalse;
2844
2845 ajStrDel(&ot->Accession);
2846
2847 if (accession)
2848 ot->Accession = ajStrNewRef(accession);
2849
2850 return ajTrue;
2851 }
2852
2853
2854
2855
2856 /* @func ensOntologytermSetAdaptor ********************************************
2857 **
2858 ** Set the Ensembl Ontology Term Adaptor member of an Ensembl Ontology Term.
2859 **
2860 ** @cc Bio::EnsEMBL::Storable::adaptor
2861 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2862 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
2863 **
2864 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2865 **
2866 ** @release 6.5.0
2867 ** @@
2868 ******************************************************************************/
2869
ensOntologytermSetAdaptor(EnsPOntologyterm ot,EnsPOntologytermadaptor ota)2870 AjBool ensOntologytermSetAdaptor(EnsPOntologyterm ot,
2871 EnsPOntologytermadaptor ota)
2872 {
2873 if (!ot)
2874 return ajFalse;
2875
2876 ot->Adaptor = ota;
2877
2878 return ajTrue;
2879 }
2880
2881
2882
2883
2884 /* @func ensOntologytermSetDefinition *****************************************
2885 **
2886 ** Set the definition member of an Ensembl Ontology Term.
2887 **
2888 ** @cc Bio::EnsEMBL::OntologyTerm::definition
2889 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2890 ** @param [u] definition [AjPStr] Definition
2891 **
2892 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2893 **
2894 ** @release 6.5.0
2895 ** @@
2896 ******************************************************************************/
2897
ensOntologytermSetDefinition(EnsPOntologyterm ot,AjPStr definition)2898 AjBool ensOntologytermSetDefinition(EnsPOntologyterm ot,
2899 AjPStr definition)
2900 {
2901 if (!ot)
2902 return ajFalse;
2903
2904 ajStrDel(&ot->Definition);
2905
2906 if (definition)
2907 ot->Definition = ajStrNewRef(definition);
2908
2909 return ajTrue;
2910 }
2911
2912
2913
2914
2915 /* @func ensOntologytermSetIdentifier *****************************************
2916 **
2917 ** Set the SQL database-internal identifier member of an
2918 ** Ensembl Ontology Term.
2919 **
2920 ** @cc Bio::EnsEMBL::Storable::dbID
2921 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2922 ** @param [r] identifier [ajuint] SQL database-internal identifier
2923 **
2924 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2925 **
2926 ** @release 6.5.0
2927 ** @@
2928 ******************************************************************************/
2929
ensOntologytermSetIdentifier(EnsPOntologyterm ot,ajuint identifier)2930 AjBool ensOntologytermSetIdentifier(EnsPOntologyterm ot,
2931 ajuint identifier)
2932 {
2933 if (!ot)
2934 return ajFalse;
2935
2936 ot->Identifier = identifier;
2937
2938 return ajTrue;
2939 }
2940
2941
2942
2943
2944 /* @func ensOntologytermSetName ***********************************************
2945 **
2946 ** Set the name member of an Ensembl Ontology Term.
2947 **
2948 ** @cc Bio::EnsEMBL::OntologyTerm::name
2949 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2950 ** @param [u] name [AjPStr] Name
2951 **
2952 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2953 **
2954 ** @release 6.5.0
2955 ** @@
2956 ******************************************************************************/
2957
ensOntologytermSetName(EnsPOntologyterm ot,AjPStr name)2958 AjBool ensOntologytermSetName(EnsPOntologyterm ot,
2959 AjPStr name)
2960 {
2961 if (!ot)
2962 return ajFalse;
2963
2964 ajStrDel(&ot->Name);
2965
2966 if (name)
2967 ot->Name = ajStrNewRef(name);
2968
2969 return ajTrue;
2970 }
2971
2972
2973
2974
2975 /* @func ensOntologytermSetOntology *******************************************
2976 **
2977 ** Set the Ensembl Ontology member of an Ensembl Ontology Term.
2978 **
2979 ** @cc Bio::EnsEMBL::OntologyTerm::ontology
2980 ** @cc Bio::EnsEMBL::OntologyTerm::namespace
2981 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
2982 ** @param [u] ontology [EnsPOntology] Ensembl Ontology
2983 **
2984 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2985 **
2986 ** @release 6.5.0
2987 ** @@
2988 ******************************************************************************/
2989
ensOntologytermSetOntology(EnsPOntologyterm ot,EnsPOntology ontology)2990 AjBool ensOntologytermSetOntology(EnsPOntologyterm ot,
2991 EnsPOntology ontology)
2992 {
2993 if (!ot)
2994 return ajFalse;
2995
2996 ensOntologyDel(&ot->Ontology);
2997
2998 ot->Ontology = ensOntologyNewRef(ontology);
2999
3000 return ajTrue;
3001 }
3002
3003
3004
3005
3006 /* @func ensOntologytermSetSubsets ********************************************
3007 **
3008 ** Set the sub-sets member of an Ensembl Ontology Term.
3009 **
3010 ** @cc Bio::EnsEMBL::OntologyTerm::subsets
3011 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
3012 ** @param [u] subsets [AjPStr] Sub-sets
3013 **
3014 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3015 **
3016 ** @release 6.5.0
3017 ** @@
3018 ******************************************************************************/
3019
ensOntologytermSetSubsets(EnsPOntologyterm ot,AjPStr subsets)3020 AjBool ensOntologytermSetSubsets(EnsPOntologyterm ot,
3021 AjPStr subsets)
3022 {
3023 if (!ot)
3024 return ajFalse;
3025
3026 ajStrDel(&ot->Subsets);
3027
3028 if (subsets)
3029 ot->Subsets = ajStrNewRef(subsets);
3030
3031 return ajTrue;
3032 }
3033
3034
3035
3036
3037 /* @section debugging *********************************************************
3038 **
3039 ** Functions for reporting of an Ensembl Ontology Term object.
3040 **
3041 ** @fdata [EnsPOntologyterm]
3042 **
3043 ** @nam3rule Trace Report Ensembl Ontology Term members to debug file.
3044 **
3045 ** @argrule Trace ot [const EnsPOntologyterm] Ensembl Ontology Term
3046 ** @argrule Trace level [ajuint] Indentation level
3047 **
3048 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3049 **
3050 ** @fcategory misc
3051 ******************************************************************************/
3052
3053
3054
3055
3056 /* @func ensOntologytermTrace *************************************************
3057 **
3058 ** Trace an Ensembl Ontology Term.
3059 **
3060 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
3061 ** @param [r] level [ajuint] Indentation level
3062 **
3063 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3064 **
3065 ** @release 6.5.0
3066 ** @@
3067 ******************************************************************************/
3068
ensOntologytermTrace(const EnsPOntologyterm ot,ajuint level)3069 AjBool ensOntologytermTrace(const EnsPOntologyterm ot, ajuint level)
3070 {
3071 AjPStr indent = NULL;
3072
3073 if (!ot)
3074 return ajFalse;
3075
3076 indent = ajStrNew();
3077
3078 ajStrAppendCountK(&indent, ' ', level * 2);
3079
3080 ajDebug("%SensOntologytermTrace %p\n"
3081 "%S Use %u\n"
3082 "%S Identifier %u\n"
3083 "%S Adaptor %p\n"
3084 "%S Accession '%S'\n"
3085 "%S Definition '%S'\n"
3086 "%S Name '%S'\n"
3087 "%S Ontology %p\n"
3088 "%S Subsets '%S'\n",
3089 indent, ot,
3090 indent, ot->Use,
3091 indent, ot->Identifier,
3092 indent, ot->Adaptor,
3093 indent, ot->Accession,
3094 indent, ot->Definition,
3095 indent, ot->Name,
3096 indent, ot->Ontology,
3097 indent, ot->Subsets);
3098
3099 ensOntologyTrace(ot->Ontology, level + 1);
3100
3101 ajStrDel(&indent);
3102
3103 return ajTrue;
3104 }
3105
3106
3107
3108
3109 /* @section calculate *********************************************************
3110 **
3111 ** Functions for calculating information from an Ensembl Ontology Term object.
3112 **
3113 ** @fdata [EnsPOntologyterm]
3114 **
3115 ** @nam3rule Calculate Calculate Ensembl Ontology Term information
3116 ** @nam4rule Memsize Calculate the memory size in bytes
3117 **
3118 ** @argrule * ot [const EnsPOntologyterm] Ensembl Ontology Term
3119 **
3120 ** @valrule Memsize [size_t] Memory size in bytes or 0
3121 **
3122 ** @fcategory misc
3123 ******************************************************************************/
3124
3125
3126
3127
3128 /* @func ensOntologytermCalculateMemsize **************************************
3129 **
3130 ** Get the memory size in bytes of an Ensembl Ontology Term.
3131 **
3132 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
3133 **
3134 ** @return [size_t] Memory size in bytes or 0
3135 **
3136 ** @release 6.5.0
3137 ** @@
3138 ******************************************************************************/
3139
ensOntologytermCalculateMemsize(const EnsPOntologyterm ot)3140 size_t ensOntologytermCalculateMemsize(const EnsPOntologyterm ot)
3141 {
3142 size_t size = 0;
3143
3144 if (!ot)
3145 return 0;
3146
3147 size += sizeof (EnsOOntologyterm);
3148
3149 if (ot->Accession)
3150 {
3151 size += sizeof (AjOStr);
3152
3153 size += ajStrGetRes(ot->Accession);
3154 }
3155
3156 if (ot->Definition)
3157 {
3158 size += sizeof (AjOStr);
3159
3160 size += ajStrGetRes(ot->Definition);
3161 }
3162
3163 if (ot->Name)
3164 {
3165 size += sizeof (AjOStr);
3166
3167 size += ajStrGetRes(ot->Name);
3168 }
3169
3170 size += ensOntologyCalculateMemsize(ot->Ontology);
3171
3172 if (ot->Subsets)
3173 {
3174 size += sizeof (AjOStr);
3175
3176 size += ajStrGetRes(ot->Subsets);
3177 }
3178
3179 return size;
3180 }
3181
3182
3183
3184
3185 /* @datasection [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor *******
3186 **
3187 ** @nam2rule Ontologytermadaptor Functions for manipulating
3188 ** Ensembl Ontology Term Adaptor objects
3189 **
3190 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor
3191 ** @cc CVS Revision: 1.45
3192 ** @cc CVS Tag: branch-ensembl-68
3193 **
3194 ******************************************************************************/
3195
3196
3197
3198
3199 /* @funcstatic ontologytermadaptorFetchAllbyStatement *************************
3200 **
3201 ** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
3202 ** results into an AJAX List of Ensembl Ontology Term objects.
3203 **
3204 ** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
3205 ** @param [r] statement [const AjPStr] SQL statement
3206 ** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
3207 ** @param [uN] slice [EnsPSlice] Ensembl Slice
3208 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
3209 **
3210 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3211 **
3212 ** @release 6.5.0
3213 ** @@
3214 ******************************************************************************/
3215
ontologytermadaptorFetchAllbyStatement(EnsPBaseadaptor ba,const AjPStr statement,EnsPAssemblymapper am,EnsPSlice slice,AjPList ots)3216 static AjBool ontologytermadaptorFetchAllbyStatement(
3217 EnsPBaseadaptor ba,
3218 const AjPStr statement,
3219 EnsPAssemblymapper am,
3220 EnsPSlice slice,
3221 AjPList ots)
3222 {
3223 ajuint identifier = 0U;
3224 ajuint oid = 0U;
3225
3226 AjPSqlstatement sqls = NULL;
3227 AjISqlrow sqli = NULL;
3228 AjPSqlrow sqlr = NULL;
3229
3230 AjPStr accession = NULL;
3231 AjPStr definition = NULL;
3232 AjPStr name = NULL;
3233 AjPStr subsets = NULL;
3234
3235 EnsPDatabaseadaptor dba = NULL;
3236
3237 EnsPOntology ontology = NULL;
3238 EnsPOntologyadaptor oa = NULL;
3239
3240 EnsPOntologyterm ot = NULL;
3241 EnsPOntologytermadaptor ota = NULL;
3242
3243 if (ajDebugTest("ontologytermadaptorFetchAllbyStatement"))
3244 ajDebug("ontologytermadaptorFetchAllbyStatement\n"
3245 " ba %p\n"
3246 " statement %p\n"
3247 " am %p\n"
3248 " slice %p\n"
3249 " ots %p\n",
3250 ba,
3251 statement,
3252 am,
3253 slice,
3254 ots);
3255
3256 if (!ba)
3257 return ajFalse;
3258
3259 if (!statement)
3260 return ajFalse;
3261
3262 if (!ots)
3263 return ajFalse;
3264
3265 dba = ensBaseadaptorGetDatabaseadaptor(ba);
3266
3267 oa = ensRegistryGetOntologyadaptor(dba);
3268 ota = ensRegistryGetOntologytermadaptor(dba);
3269
3270 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
3271
3272 sqli = ajSqlrowiterNew(sqls);
3273
3274 while (!ajSqlrowiterDone(sqli))
3275 {
3276 identifier = 0;
3277 oid = 0;
3278 accession = ajStrNew();
3279 name = ajStrNew();
3280 definition = ajStrNew();
3281 subsets = ajStrNew();
3282
3283 sqlr = ajSqlrowiterGet(sqli);
3284
3285 ajSqlcolumnToUint(sqlr, &identifier);
3286 ajSqlcolumnToUint(sqlr, &oid);
3287 ajSqlcolumnToStr(sqlr, &accession);
3288 ajSqlcolumnToStr(sqlr, &name);
3289 ajSqlcolumnToStr(sqlr, &definition);
3290 ajSqlcolumnToStr(sqlr, &subsets);
3291
3292 ensOntologyadaptorFetchByIdentifier(oa, oid, &ontology);
3293
3294 ot = ensOntologytermNewIni(ota,
3295 identifier,
3296 ontology,
3297 accession,
3298 definition,
3299 name,
3300 subsets);
3301
3302 ajListPushAppend(ots, (void *) ot);
3303
3304 ensOntologyDel(&ontology);
3305
3306 ajStrDel(&accession);
3307 ajStrDel(&name);
3308 ajStrDel(&definition);
3309 ajStrDel(&subsets);
3310 }
3311
3312 ajSqlrowiterDel(&sqli);
3313
3314 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
3315
3316 return ajTrue;
3317 }
3318
3319
3320
3321
3322 /* @section constructors ******************************************************
3323 **
3324 ** All constructors return a new Ensembl Ontology Term Adaptor by pointer.
3325 ** It is the responsibility of the user to first destroy any previous
3326 ** Ensembl Ontology Term Adaptor.
3327 ** The target pointer does not need to be initialised to NULL, but it is good
3328 ** programming practice to do so anyway.
3329 **
3330 ** @fdata [EnsPOntologytermadaptor]
3331 **
3332 ** @nam3rule New Constructor
3333 **
3334 ** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3335 **
3336 ** @valrule * [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor or NULL
3337 **
3338 ** @fcategory new
3339 ******************************************************************************/
3340
3341
3342
3343
3344 /* @func ensOntologytermadaptorNew ********************************************
3345 **
3346 ** Default constructor for an Ensembl Ontology Term Adaptor.
3347 **
3348 ** Ensembl Object Adaptors are singleton objects in the sense that a single
3349 ** instance of an Ensembl Object Adaptor connected to a particular database is
3350 ** sufficient to instantiate any number of Ensembl Objects from the database.
3351 ** Each Ensembl Object will have a weak reference to the Object Adaptor that
3352 ** instantiated it. Therefore, Ensembl Object Adaptors should not be
3353 ** instantiated directly, but rather obtained from the Ensembl Registry,
3354 ** which will in turn call this function if neccessary.
3355 **
3356 ** @see ensRegistryGetDatabaseadaptor
3357 ** @see ensRegistryGetOntologytermadaptor
3358 **
3359 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::new
3360 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3361 **
3362 ** @return [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor or NULL
3363 **
3364 ** @release 6.5.0
3365 ** @@
3366 ******************************************************************************/
3367
ensOntologytermadaptorNew(EnsPDatabaseadaptor dba)3368 EnsPOntologytermadaptor ensOntologytermadaptorNew(
3369 EnsPDatabaseadaptor dba)
3370 {
3371 return ensBaseadaptorNew(
3372 dba,
3373 ontologytermadaptorKTablenames,
3374 ontologytermadaptorKColumnnames,
3375 (const EnsPBaseadaptorLeftjoin) NULL,
3376 (const char *) NULL,
3377 (const char *) NULL,
3378 &ontologytermadaptorFetchAllbyStatement);
3379 }
3380
3381
3382
3383
3384 /* @section destructors *******************************************************
3385 **
3386 ** Destruction destroys all internal data structures and frees the memory
3387 ** allocated for an Ensembl Ontology Term Adaptor object.
3388 **
3389 ** @fdata [EnsPOntologytermadaptor]
3390 **
3391 ** @nam3rule Del Destroy (free) an Ensembl Ontology Term Adaptor
3392 **
3393 ** @argrule * Pota [EnsPOntologytermadaptor*]
3394 ** Ensembl Ontology Term Adaptor address
3395 **
3396 ** @valrule * [void]
3397 **
3398 ** @fcategory delete
3399 ******************************************************************************/
3400
3401
3402
3403
3404 /* @func ensOntologytermadaptorDel ********************************************
3405 **
3406 ** Default destructor for an Ensembl Ontology Term Adaptor.
3407 **
3408 ** This function also clears the internal caches.
3409 **
3410 ** Ensembl Object Adaptors are singleton objects that are registered in the
3411 ** Ensembl Registry and weakly referenced by Ensembl Objects that have been
3412 ** instantiated by it. Therefore, Ensembl Object Adaptors should never be
3413 ** destroyed directly. Upon exit, the Ensembl Registry will call this function
3414 ** if required.
3415 **
3416 ** @param [d] Pota [EnsPOntologytermadaptor*]
3417 ** Ensembl Ontology Term Adaptor address
3418 **
3419 ** @return [void]
3420 **
3421 ** @release 6.5.0
3422 ** @@
3423 ******************************************************************************/
3424
ensOntologytermadaptorDel(EnsPOntologytermadaptor * Pota)3425 void ensOntologytermadaptorDel(EnsPOntologytermadaptor *Pota)
3426 {
3427 ensBaseadaptorDel(Pota);
3428
3429 return;
3430 }
3431
3432
3433
3434
3435 /* @section member retrieval **************************************************
3436 **
3437 ** Functions for returning members of an
3438 ** Ensembl Ontology Term Adaptor object.
3439 **
3440 ** @fdata [EnsPOntologytermadaptor]
3441 **
3442 ** @nam3rule Get Return Ensembl Ontology Term Adaptor attribute(s)
3443 ** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
3444 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
3445 **
3446 ** @argrule * ota [EnsPOntologytermadaptor]
3447 ** Ensembl Ontology Term Adaptor
3448 **
3449 ** @valrule Baseadaptor [EnsPBaseadaptor]
3450 ** Ensembl Base Adaptor or NULL
3451 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
3452 ** Ensembl Database Adaptor or NULL
3453 **
3454 ** @fcategory use
3455 ******************************************************************************/
3456
3457
3458
3459
3460 /* @func ensOntologytermadaptorGetBaseadaptor *********************************
3461 **
3462 ** Get the Ensembl Base Adaptor member of an
3463 ** Ensembl Ontology Term Adaptor.
3464 **
3465 ** @param [u] ota [EnsPOntologytermadaptor]
3466 ** Ensembl Ontology Term Adaptor
3467 **
3468 ** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
3469 **
3470 ** @release 6.5.0
3471 ** @@
3472 ******************************************************************************/
3473
ensOntologytermadaptorGetBaseadaptor(EnsPOntologytermadaptor ota)3474 EnsPBaseadaptor ensOntologytermadaptorGetBaseadaptor(
3475 EnsPOntologytermadaptor ota)
3476 {
3477 return ota;
3478 }
3479
3480
3481
3482
3483 /* @func ensOntologytermadaptorGetDatabaseadaptor *****************************
3484 **
3485 ** Get the Ensembl Database Adaptor member of an
3486 ** Ensembl Ontology Term Adaptor.
3487 **
3488 ** @param [u] ota [EnsPOntologytermadaptor]
3489 ** Ensembl Ontology Term Adaptor
3490 **
3491 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3492 **
3493 ** @release 6.5.0
3494 ** @@
3495 ******************************************************************************/
3496
ensOntologytermadaptorGetDatabaseadaptor(EnsPOntologytermadaptor ota)3497 EnsPDatabaseadaptor ensOntologytermadaptorGetDatabaseadaptor(
3498 EnsPOntologytermadaptor ota)
3499 {
3500 return ensBaseadaptorGetDatabaseadaptor(
3501 ensOntologytermadaptorGetBaseadaptor(ota));
3502 }
3503
3504
3505
3506
3507 /* @section object retrieval **************************************************
3508 **
3509 ** Functions for fetching Ensembl Ontology Term objects from an
3510 ** Ensembl SQL database.
3511 **
3512 ** @fdata [EnsPOntologytermadaptor]
3513 **
3514 ** @nam3rule Fetch Fetch Ensembl Ontology Term object(s)
3515 ** @nam4rule All Fetch all Ensembl Ontology Term objects
3516 ** @nam4rule Allby Fetch all Ensembl Ontology Term objects matching a criterion
3517 ** @nam5rule Ancestor Fetch all descendant Ensembl Ontology Term objects,
3518 ** down to and including any leaf Ensembl Ontology Term objects.
3519 ** @nam5rule Child Fetch all immediate parent Ensembl Ontology Term objects
3520 ** by a child Ensembl Ontology Term
3521 ** @nam5rule Descendant Fetch all ancestor Ensembl Ontology Term objects,
3522 ** up to and including any any root Ensembl Ontology Term objects.
3523 ** @nam5rule Name Fetch all by a name
3524 ** @nam5rule Parent Fetch all immediate child Ensembl Ontology Term objects
3525 ** by a parent Ensembl Ontology Term
3526 ** @nam4rule By Fetch one Ensembl Ontology Term object matching a criterion
3527 ** @nam5rule Accession Fetch by an accession number
3528 ** @nam5rule Identifier Fetch by an SQL database internal identifier
3529 ** @nam5rule Name Fetch by a name
3530 **
3531 ** @argrule * ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
3532 ** @argrule All ots [AjPList] AJAX List of Ensembl Ontology Term objects
3533 ** @argrule AllbyAncestor ot [EnsPOntologyterm] Ensembl Ontology Term
3534 ** @argrule AllbyChild ot [EnsPOntologyterm] Ensembl Ontology Term
3535 ** @argrule AllbyDescendant ot [EnsPOntologyterm] Ensembl Ontology Term
3536 ** @argrule AllbyDescendant subset [const AjPStr] Ontology subset
3537 ** @argrule AllbyDescendant closest [AjBool] Closest only
3538 ** @argrule AllbyDescendant zerodistance [AjBool]
3539 ** Return Ensembl Ontology Term objects with zero distance or
3540 ** only above the current level
3541 ** @argrule AllbyName termname [const AjPStr] Term name
3542 ** @argrule AllbyName ontologyname [const AjPStr] Ontology name
3543 ** @argrule AllbyParent ot [EnsPOntologyterm] Ensembl Ontology Term
3544 ** @argrule Allby ots [AjPList] AJAX List of Ensembl Ontology Term objects
3545 ** @argrule ByAccession accession [const AjPStr] Accession number
3546 ** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
3547 ** @argrule ByName name [const AjPStr] Ensembl Ontology Term name
3548 ** @argrule By Pot [EnsPOntologyterm*] Ensembl Ontology Term address
3549 **
3550 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3551 **
3552 ** @fcategory use
3553 ******************************************************************************/
3554
3555
3556
3557
3558 /* @func ensOntologytermadaptorFetchAll ***************************************
3559 **
3560 ** Fetch all Ensembl Ontology Term objects.
3561 **
3562 ** The caller is responsible for deleting the Ensembl Ontology Term objects
3563 ** before deleting the AJAX List object.
3564 **
3565 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all
3566 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
3567 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
3568 **
3569 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3570 **
3571 ** @release 6.5.0
3572 ** @@
3573 ******************************************************************************/
3574
ensOntologytermadaptorFetchAll(EnsPOntologytermadaptor ota,AjPList ots)3575 AjBool ensOntologytermadaptorFetchAll(
3576 EnsPOntologytermadaptor ota,
3577 AjPList ots)
3578 {
3579 return ensBaseadaptorFetchAll(
3580 ensOntologytermadaptorGetBaseadaptor(ota),
3581 ots);
3582 }
3583
3584
3585
3586
3587 /* @func ensOntologytermadaptorFetchAllbyAncestor *****************************
3588 **
3589 ** Fetch all descendant Ensembl Ontology Term objects, down to and including
3590 ** any leaf Ensembl Ontology Term objects.
3591 **
3592 ** The caller is responsible for deleting the Ensembl Ontology Term objects
3593 ** before deleting the AJAX List object.
3594 **
3595 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all_by_ancestor_term
3596 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
3597 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
3598 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
3599 **
3600 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3601 **
3602 ** @release 6.5.0
3603 ** @@
3604 ******************************************************************************/
3605
ensOntologytermadaptorFetchAllbyAncestor(EnsPOntologytermadaptor ota,EnsPOntologyterm ot,AjPList ots)3606 AjBool ensOntologytermadaptorFetchAllbyAncestor(
3607 EnsPOntologytermadaptor ota,
3608 EnsPOntologyterm ot,
3609 AjPList ots)
3610 {
3611 ajuint identifier = 0U;
3612 ajuint oid = 0U;
3613
3614 AjPSqlstatement sqls = NULL;
3615 AjISqlrow sqli = NULL;
3616 AjPSqlrow sqlr = NULL;
3617
3618 AjPStr accession = NULL;
3619 AjPStr definition = NULL;
3620 AjPStr name = NULL;
3621 AjPStr statement = NULL;
3622 AjPStr subsets = NULL;
3623
3624 EnsPDatabaseadaptor dba = NULL;
3625
3626 EnsPOntology ontology = NULL;
3627 EnsPOntologyadaptor oa = NULL;
3628
3629 EnsPOntologyterm pot = NULL;
3630
3631 if (!ota)
3632 return ajFalse;
3633
3634 if (!ot)
3635 return ajFalse;
3636
3637 if (!ots)
3638 return ajFalse;
3639
3640 dba = ensOntologytermadaptorGetDatabaseadaptor(ota);
3641
3642 oa = ensRegistryGetOntologyadaptor(dba);
3643
3644 statement = ajFmtStr(
3645 "SELECT DISTINCT "
3646 "child_term.term_id, "
3647 "child_term.ontology_id, "
3648 "child_term.accession, "
3649 "child_term.name, "
3650 "child_term.definition, "
3651 "child_term.subsets "
3652 "FROM "
3653 "term child_term "
3654 "JOIN "
3655 "closure "
3656 "ON "
3657 "(closure.child_term_id = child_term.term_id) "
3658 "WHERE "
3659 "closure.parent_term_id = %u "
3660 "AND "
3661 "closure.distance > 0 "
3662 "ORDER BY "
3663 "closure.distance, "
3664 "child_term.accession",
3665 ot->Identifier);
3666
3667 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
3668
3669 sqli = ajSqlrowiterNew(sqls);
3670
3671 while (!ajSqlrowiterDone(sqli))
3672 {
3673 identifier = 0;
3674 oid = 0;
3675 accession = ajStrNew();
3676 name = ajStrNew();
3677 definition = ajStrNew();
3678 subsets = ajStrNew();
3679
3680 sqlr = ajSqlrowiterGet(sqli);
3681
3682 ajSqlcolumnToUint(sqlr, &identifier);
3683 ajSqlcolumnToUint(sqlr, &oid);
3684 ajSqlcolumnToStr(sqlr, &accession);
3685 ajSqlcolumnToStr(sqlr, &name);
3686 ajSqlcolumnToStr(sqlr, &definition);
3687 ajSqlcolumnToStr(sqlr, &subsets);
3688
3689 ensOntologyadaptorFetchByIdentifier(oa, oid, &ontology);
3690
3691 pot = ensOntologytermNewIni(ota,
3692 identifier,
3693 ontology,
3694 accession,
3695 definition,
3696 name,
3697 subsets);
3698
3699 ajListPushAppend(ots, (void *) pot);
3700
3701 ensOntologyDel(&ontology);
3702
3703 ajStrDel(&accession);
3704 ajStrDel(&name);
3705 ajStrDel(&definition);
3706 ajStrDel(&subsets);
3707 }
3708
3709 ajSqlrowiterDel(&sqli);
3710
3711 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
3712
3713 ajStrDel(&statement);
3714
3715 return ajTrue;
3716 }
3717
3718
3719
3720
3721 /* @funcstatic ontologytermListOntologytermValdel *****************************
3722 **
3723 ** An ajTableSetDestroyvalue "valdel" function to clear AJAX Table value data.
3724 ** This function removes and deletes Ensembl Ontology Term objects
3725 ** from an AJAX List object, before deleting the AJAX List object.
3726 **
3727 ** @param [d] Pvalue [void**] AJAX List address
3728 ** @see ajTableSetDestroyvalue
3729 **
3730 ** @return [void]
3731 **
3732 ** @release 6.5.0
3733 ** @@
3734 ******************************************************************************/
3735
ontologytermListOntologytermValdel(void ** Pvalue)3736 static void ontologytermListOntologytermValdel(void **Pvalue)
3737 {
3738 EnsPOntologyterm ot = NULL;
3739
3740 if (!Pvalue)
3741 return;
3742
3743 if (!*Pvalue)
3744 return;
3745
3746 while (ajListPop(*((AjPList *) Pvalue), (void **) &ot))
3747 ensOntologytermDel(&ot);
3748
3749 ajListFree((AjPList *) Pvalue);
3750
3751 return;
3752 }
3753
3754
3755
3756
3757 /* @func ensOntologytermadaptorFetchAllbyChild ********************************
3758 **
3759 ** Fetch all immediate parent Ensembl Ontology Term objects
3760 ** by a child Ensembl Ontology Term.
3761 **
3762 ** The caller is responsible for deleting the Ensembl Ontology Term objects
3763 ** before deleting the AJAX List object.
3764 **
3765 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all_by_parent_term
3766 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
3767 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
3768 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
3769 **
3770 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3771 **
3772 ** @release 6.5.0
3773 ** @@
3774 ******************************************************************************/
3775
ensOntologytermadaptorFetchAllbyChild(EnsPOntologytermadaptor ota,EnsPOntologyterm ot,AjPList ots)3776 AjBool ensOntologytermadaptorFetchAllbyChild(
3777 EnsPOntologytermadaptor ota,
3778 EnsPOntologyterm ot,
3779 AjPList ots)
3780 {
3781 void **valarray = NULL;
3782
3783 register ajuint i = 0U;
3784
3785 ajuint identifier = 0U;
3786 ajuint oid = 0U;
3787
3788 AjIList iter = NULL;
3789 AjPList list = NULL;
3790
3791 AjPSqlstatement sqls = NULL;
3792 AjISqlrow sqli = NULL;
3793 AjPSqlrow sqlr = NULL;
3794
3795 AjPStr accession = NULL;
3796 AjPStr definition = NULL;
3797 AjPStr name = NULL;
3798 AjPStr relation = NULL;
3799 AjPStr statement = NULL;
3800 AjPStr subsets = NULL;
3801
3802 EnsPDatabaseadaptor dba = NULL;
3803
3804 EnsPOntology ontology = NULL;
3805 EnsPOntologyadaptor oa = NULL;
3806
3807 EnsPOntologyterm pot = NULL;
3808
3809 if (!ota)
3810 return ajFalse;
3811
3812 if (!ot)
3813 return ajFalse;
3814
3815 if (!ots)
3816 return ajFalse;
3817
3818 if (!ot->Parents)
3819 {
3820 ot->Parents = ajTablestrNew(0U);
3821
3822 ajTableSetDestroyvalue(
3823 ot->Parents,
3824 &ontologytermListOntologytermValdel);
3825
3826 dba = ensOntologytermadaptorGetDatabaseadaptor(ota);
3827
3828 oa = ensRegistryGetOntologyadaptor(dba);
3829
3830 statement = ajFmtStr(
3831 "SELECT "
3832 "parent_term.term_id, "
3833 "parent_term.ontology_id, "
3834 "parent_term.accession, "
3835 "parent_term.name, "
3836 "parent_term.definition, "
3837 "parent_term.subsets, "
3838 "relation_type.name "
3839 "FROM "
3840 "term parent_term "
3841 "JOIN "
3842 "relation "
3843 "ON "
3844 "(relation.parent_term_id = parent_term.term_id) "
3845 "JOIN "
3846 "relation_type "
3847 "USING "
3848 "(relation_type_id) "
3849 "WHERE "
3850 "relation.child_term_id = %u",
3851 ensOntologytermGetIdentifier(ot));
3852
3853 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
3854
3855 sqli = ajSqlrowiterNew(sqls);
3856
3857 while (!ajSqlrowiterDone(sqli))
3858 {
3859 identifier = 0;
3860 oid = 0;
3861 accession = ajStrNew();
3862 name = ajStrNew();
3863 definition = ajStrNew();
3864 subsets = ajStrNew();
3865 relation = ajStrNew();
3866
3867 sqlr = ajSqlrowiterGet(sqli);
3868
3869 ajSqlcolumnToUint(sqlr, &identifier);
3870 ajSqlcolumnToUint(sqlr, &oid);
3871 ajSqlcolumnToStr(sqlr, &accession);
3872 ajSqlcolumnToStr(sqlr, &name);
3873 ajSqlcolumnToStr(sqlr, &definition);
3874 ajSqlcolumnToStr(sqlr, &subsets);
3875 ajSqlcolumnToStr(sqlr, &relation);
3876
3877 ensOntologyadaptorFetchByIdentifier(oa, oid, &ontology);
3878
3879 pot = ensOntologytermNewIni(ota,
3880 identifier,
3881 ontology,
3882 accession,
3883 definition,
3884 name,
3885 subsets);
3886
3887 list = ajTableFetchmodS(ot->Parents, relation);
3888
3889 if (list == NULL)
3890 {
3891 list = ajListNew();
3892
3893 ajTablePut(ot->Parents,
3894 (void *) ajStrNewS(relation),
3895 (void *) list);
3896 }
3897
3898 ajListPushAppend(list, (void *) pot);
3899
3900 ensOntologyDel(&ontology);
3901
3902 ajStrDel(&accession);
3903 ajStrDel(&name);
3904 ajStrDel(&definition);
3905 ajStrDel(&subsets);
3906 ajStrDel(&relation);
3907 }
3908
3909 ajSqlrowiterDel(&sqli);
3910
3911 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
3912
3913 ajStrDel(&statement);
3914 }
3915
3916 ajTableToarrayValues(ot->Parents, &valarray);
3917
3918 for (i = 0U; valarray[i]; i++)
3919 {
3920 iter = ajListIterNew((AjPList) valarray[i]);
3921
3922 while (!ajListIterDone(iter))
3923 {
3924 pot = (EnsPOntologyterm) ajListIterGet(iter);
3925
3926 ajListPushAppend(ots, (void *) ensOntologytermNewRef(pot));
3927 }
3928
3929 ajListIterDel(&iter);
3930 }
3931
3932 AJFREE(valarray);
3933
3934 return ajTrue;
3935 }
3936
3937
3938
3939
3940 /* @func ensOntologytermadaptorFetchAllbyDescendant ***************************
3941 **
3942 ** Fetch all ancestor Ensembl Ontology Term objects, up to and including any
3943 ** any root Ensembl Ontology Term objects.
3944 **
3945 ** The caller is responsible for deleting the Ensembl Ontology Term objects
3946 ** before deleting the AJAX List object.
3947 **
3948 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all_by_ancestor_term
3949 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
3950 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
3951 ** @param [rN] subset [const AjPStr] The subset within the ontolgy to which
3952 ** the query should be restricted. The subset may be specified as a SQL
3953 ** pattern, e.g., "%goslim%" (but "goslim%" might not do what you expect),
3954 ** or as a specific subset name, e.g., "goslim_generic".
3955 ** @param [r] closest [AjBool] Closest only
3956 ** @param [r] zerodistance [AjBool]
3957 ** Return Ensembl Ontology Term objects with zero distance or
3958 ** only above the current level
3959 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
3960 **
3961 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3962 **
3963 ** @release 6.5.0
3964 ** @@
3965 ******************************************************************************/
3966
ensOntologytermadaptorFetchAllbyDescendant(EnsPOntologytermadaptor ota,EnsPOntologyterm ot,const AjPStr subset,AjBool closest,AjBool zerodistance,AjPList ots)3967 AjBool ensOntologytermadaptorFetchAllbyDescendant(
3968 EnsPOntologytermadaptor ota,
3969 EnsPOntologyterm ot,
3970 const AjPStr subset,
3971 AjBool closest,
3972 AjBool zerodistance,
3973 AjPList ots)
3974 {
3975 char *txtsubset = NULL;
3976
3977 ajint qrydistance = 0;
3978
3979 ajuint identifier = 0U;
3980 ajuint distance = 0U;
3981 ajuint oid = 0U;
3982 ajuint mindistance = 0U;
3983
3984 AjBool lastrecord = ajFalse;
3985
3986 AjPSqlstatement sqls = NULL;
3987 AjISqlrow sqli = NULL;
3988 AjPSqlrow sqlr = NULL;
3989
3990 AjPStr accession = NULL;
3991 AjPStr definition = NULL;
3992 AjPStr name = NULL;
3993 AjPStr statement = NULL;
3994 AjPStr subsets = NULL;
3995
3996 EnsPDatabaseadaptor dba = NULL;
3997
3998 EnsPOntology ontology = NULL;
3999 EnsPOntologyadaptor oa = NULL;
4000
4001 EnsPOntologyterm pot = NULL;
4002
4003 if (!ota)
4004 return ajFalse;
4005
4006 if (!ot)
4007 return ajFalse;
4008
4009 if (!ots)
4010 return ajFalse;
4011
4012 dba = ensOntologytermadaptorGetDatabaseadaptor(ota);
4013
4014 oa = ensRegistryGetOntologyadaptor(dba);
4015
4016 qrydistance = (zerodistance) ? -1 : 0;
4017
4018 statement = ajFmtStr(
4019 "SELECT DISTINCT "
4020 "parent_term.term_id, "
4021 "parent_term.ontology_id, "
4022 "parent_term.accession, "
4023 "parent_term.name, "
4024 "parent_term.definition, "
4025 "parent_term.subsets, "
4026 "closure.distance "
4027 "FROM "
4028 "term parent_term "
4029 "JOIN "
4030 "closure "
4031 "ON "
4032 "(closure.parent_term_id = parent_term.term_id) "
4033 "WHERE "
4034 "closure.child_term_id = %u "
4035 "AND "
4036 "closure.distance > %d",
4037 ot->Identifier,
4038 qrydistance);
4039
4040 if (subset && ajStrGetLen(subset))
4041 {
4042 ensDatabaseadaptorEscapeC(dba, &txtsubset, subset);
4043
4044 if (ajStrFindC(subset, "%") != -1)
4045 ajFmtPrintAppS(&statement,
4046 " AND parent_term.subsets LIKE '%s'",
4047 txtsubset);
4048 else
4049 ajFmtPrintAppS(&statement,
4050 " AND FIND_IN_SET('%s', parent_term.subsets) > 0",
4051 txtsubset);
4052
4053 ajCharDel(&txtsubset);
4054 }
4055
4056 ajStrAppendC(&statement,
4057 " ORDER BY closure.distance, parent_term.accession");
4058
4059 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4060
4061 sqli = ajSqlrowiterNew(sqls);
4062
4063 while (!ajSqlrowiterDone(sqli))
4064 {
4065 identifier = 0U;
4066 oid = 0U;
4067 accession = ajStrNew();
4068 name = ajStrNew();
4069 definition = ajStrNew();
4070 subsets = ajStrNew();
4071 distance = 0U;
4072
4073 sqlr = ajSqlrowiterGet(sqli);
4074
4075 ajSqlcolumnToUint(sqlr, &identifier);
4076 ajSqlcolumnToUint(sqlr, &oid);
4077 ajSqlcolumnToStr(sqlr, &accession);
4078 ajSqlcolumnToStr(sqlr, &name);
4079 ajSqlcolumnToStr(sqlr, &definition);
4080 ajSqlcolumnToStr(sqlr, &subsets);
4081 ajSqlcolumnToUint(sqlr, &distance);
4082
4083 mindistance = (mindistance) ? mindistance : distance;
4084
4085 if ((!closest) || (distance == mindistance))
4086 {
4087 ensOntologyadaptorFetchByIdentifier(oa, oid, &ontology);
4088
4089 pot = ensOntologytermNewIni(ota,
4090 identifier,
4091 ontology,
4092 accession,
4093 definition,
4094 name,
4095 subsets);
4096
4097 ajListPushAppend(ots, (void *) pot);
4098
4099 ensOntologyDel(&ontology);
4100 }
4101 else
4102 lastrecord = ajTrue;
4103
4104 ajStrDel(&accession);
4105 ajStrDel(&name);
4106 ajStrDel(&definition);
4107 ajStrDel(&subsets);
4108
4109 if (lastrecord)
4110 break;
4111 }
4112
4113 ajSqlrowiterDel(&sqli);
4114
4115 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4116
4117 ajStrDel(&statement);
4118
4119 return ajTrue;
4120 }
4121
4122
4123
4124
4125 /* @func ensOntologytermadaptorFetchAllbyName *********************************
4126 **
4127 ** Fetch all Ensembl Ontology Term objects by a name.
4128 **
4129 ** The caller is responsible for deleting the Ensembl Ontology Term objects
4130 ** before deleting the AJAX List object.
4131 **
4132 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all_by_name
4133 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4134 ** @param [r] termname [const AjPStr] Term name
4135 ** @param [rN] ontologyname [const AjPStr] Ontology name
4136 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
4137 **
4138 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4139 **
4140 ** @release 6.5.0
4141 ** @@
4142 ******************************************************************************/
4143
ensOntologytermadaptorFetchAllbyName(EnsPOntologytermadaptor ota,const AjPStr termname,const AjPStr ontologyname,AjPList ots)4144 AjBool ensOntologytermadaptorFetchAllbyName(
4145 EnsPOntologytermadaptor ota,
4146 const AjPStr termname,
4147 const AjPStr ontologyname,
4148 AjPList ots)
4149 {
4150 char *txtname = NULL;
4151
4152 AjBool result = AJFALSE;
4153
4154 AjPStr statement = NULL;
4155
4156 EnsPBaseadaptor ba = NULL;
4157
4158 if (!ota)
4159 return ajFalse;
4160
4161 if (!termname)
4162 return ajFalse;
4163
4164 if (!ots)
4165 return ajFalse;
4166
4167 ba = ensOntologytermadaptorGetBaseadaptor(ota);
4168
4169 ensBaseadaptorEscapeC(ba, &txtname, termname);
4170
4171 statement = ajStrNewC(
4172 "SELECT "
4173 "DISTINCT "
4174 "term.term_id, "
4175 "term.ontology_id, "
4176 "term.accession, "
4177 "term.name, "
4178 "term.definition, "
4179 "term.subsets "
4180 "FROM ");
4181
4182 if ((ontologyname != NULL) && (ajStrGetLen(ontologyname) > 0))
4183 ajStrAppendC(
4184 &statement,
4185 "ontology "
4186 "JOIN "
4187 "term "
4188 "USING "
4189 "(ontology_id) ");
4190 else
4191 ajStrAppendC(
4192 &statement,
4193 "term ");
4194
4195 ajFmtPrintAppS(
4196 &statement,
4197 "LEFT JOIN "
4198 "synonym "
4199 "USING "
4200 "(term_id) "
4201 "WHERE "
4202 "(term.name LIKE '%s' OR synonym.name LIKE '%s')",
4203 txtname, txtname);
4204
4205 ajCharDel(&txtname);
4206
4207 if ((ontologyname != NULL) && (ajStrGetLen(ontologyname) > 0))
4208 {
4209 ensBaseadaptorEscapeC(ba, &txtname, ontologyname);
4210 ajFmtPrintAppS(&statement, " AND ontology.name = '%s'", txtname);
4211 ajCharDel(&txtname);
4212 }
4213
4214 result = ontologytermadaptorFetchAllbyStatement(
4215 ota,
4216 statement,
4217 (EnsPAssemblymapper) NULL,
4218 (EnsPSlice) NULL,
4219 ots);
4220
4221 ajStrDel(&statement);
4222
4223 return result;
4224 }
4225
4226
4227
4228
4229 /* @func ensOntologytermadaptorFetchAllbyParent *******************************
4230 **
4231 ** Fetch all immediate child Ensembl Ontology Term objects
4232 ** by a parent Ensembl Ontology Term.
4233 **
4234 ** The caller is responsible for deleting the Ensembl Ontology Term objects
4235 ** before deleting the AJAX List object.
4236 **
4237 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_all_by_parent_term
4238 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4239 ** @param [u] ot [EnsPOntologyterm] Ensembl Ontology Term
4240 ** @param [u] ots [AjPList] AJAX List of Ensembl Ontology Term objects
4241 **
4242 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4243 **
4244 ** @release 6.5.0
4245 ** @@
4246 ******************************************************************************/
4247
ensOntologytermadaptorFetchAllbyParent(EnsPOntologytermadaptor ota,EnsPOntologyterm ot,AjPList ots)4248 AjBool ensOntologytermadaptorFetchAllbyParent(
4249 EnsPOntologytermadaptor ota,
4250 EnsPOntologyterm ot,
4251 AjPList ots)
4252 {
4253 void **valarray = NULL;
4254
4255 register ajuint i = 0U;
4256
4257 ajuint identifier = 0U;
4258 ajuint oid = 0U;
4259
4260 AjIList iter = NULL;
4261 AjPList list = NULL;
4262
4263 AjPSqlstatement sqls = NULL;
4264 AjISqlrow sqli = NULL;
4265 AjPSqlrow sqlr = NULL;
4266
4267 AjPStr accession = NULL;
4268 AjPStr definition = NULL;
4269 AjPStr name = NULL;
4270 AjPStr relation = NULL;
4271 AjPStr statement = NULL;
4272 AjPStr subsets = NULL;
4273
4274 EnsPDatabaseadaptor dba = NULL;
4275
4276 EnsPOntology ontology = NULL;
4277 EnsPOntologyadaptor oa = NULL;
4278
4279 EnsPOntologyterm pot = NULL;
4280
4281 if (!ota)
4282 return ajFalse;
4283
4284 if (!ot)
4285 return ajFalse;
4286
4287 if (!ots)
4288 return ajFalse;
4289
4290 if (!ot->Children)
4291 {
4292 ot->Children = ajTablestrNew(0U);
4293
4294 ajTableSetDestroyvalue(
4295 ot->Children,
4296 &ontologytermListOntologytermValdel);
4297
4298 dba = ensOntologytermadaptorGetDatabaseadaptor(ota);
4299
4300 oa = ensRegistryGetOntologyadaptor(dba);
4301
4302 statement = ajFmtStr(
4303 "SELECT "
4304 "child_term.term_id, "
4305 "child_term.ontology_id, "
4306 "child_term.accession, "
4307 "child_term.name, "
4308 "child_term.definition, "
4309 "child_term.subsets, "
4310 "relation_type.name "
4311 "FROM "
4312 "term child_term "
4313 "JOIN "
4314 "relation "
4315 "ON "
4316 "(relation.child_term_id = child_term.term_id) "
4317 "JOIN "
4318 "relation_type "
4319 "USING "
4320 "(relation_type_id) "
4321 "WHERE "
4322 "relation.parent_term_id = %u",
4323 ensOntologytermGetIdentifier(ot));
4324
4325 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4326
4327 sqli = ajSqlrowiterNew(sqls);
4328
4329 while (!ajSqlrowiterDone(sqli))
4330 {
4331 identifier = 0;
4332 oid = 0;
4333 accession = ajStrNew();
4334 name = ajStrNew();
4335 definition = ajStrNew();
4336 subsets = ajStrNew();
4337 relation = ajStrNew();
4338
4339 sqlr = ajSqlrowiterGet(sqli);
4340
4341 ajSqlcolumnToUint(sqlr, &identifier);
4342 ajSqlcolumnToUint(sqlr, &oid);
4343 ajSqlcolumnToStr(sqlr, &accession);
4344 ajSqlcolumnToStr(sqlr, &name);
4345 ajSqlcolumnToStr(sqlr, &definition);
4346 ajSqlcolumnToStr(sqlr, &subsets);
4347 ajSqlcolumnToStr(sqlr, &relation);
4348
4349 ensOntologyadaptorFetchByIdentifier(oa, oid, &ontology);
4350
4351 pot = ensOntologytermNewIni(ota,
4352 identifier,
4353 ontology,
4354 accession,
4355 definition,
4356 name,
4357 subsets);
4358
4359 list = ajTableFetchmodS(ot->Children, relation);
4360
4361 if (list == NULL)
4362 {
4363 list = ajListNew();
4364
4365 ajTablePut(ot->Children,
4366 (void *) ajStrNewS(relation),
4367 (void *) list);
4368 }
4369
4370 ajListPushAppend(list, (void *) pot);
4371
4372 ensOntologyDel(&ontology);
4373
4374 ajStrDel(&accession);
4375 ajStrDel(&name);
4376 ajStrDel(&definition);
4377 ajStrDel(&subsets);
4378 ajStrDel(&relation);
4379 }
4380
4381 ajSqlrowiterDel(&sqli);
4382
4383 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4384
4385 ajStrDel(&statement);
4386 }
4387
4388 ajTableToarrayValues(ot->Children, &valarray);
4389
4390 for (i = 0U; valarray[i]; i++)
4391 {
4392 iter = ajListIterNew((AjPList) valarray[i]);
4393
4394 while (!ajListIterDone(iter))
4395 {
4396 pot = (EnsPOntologyterm) ajListIterGet(iter);
4397
4398 ajListPushAppend(ots, (void *) ensOntologytermNewRef(pot));
4399 }
4400
4401 ajListIterDel(&iter);
4402 }
4403
4404 AJFREE(valarray);
4405
4406 return ajTrue;
4407 }
4408
4409
4410
4411
4412 /* @func ensOntologytermadaptorFetchByAccession *******************************
4413 **
4414 ** Fetch an Ensembl Ontology Term by its accession number.
4415 ** The caller is responsible for deleting the Ensembl Ontology Term.
4416 **
4417 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_by_accession
4418 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4419 ** @param [r] accession [const AjPStr] Accession number
4420 ** @param [wP] Pot [EnsPOntologyterm*] Ensembl Ontology Term address
4421 **
4422 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4423 **
4424 ** @release 6.5.0
4425 ** @@
4426 ******************************************************************************/
4427
ensOntologytermadaptorFetchByAccession(EnsPOntologytermadaptor ota,const AjPStr accession,EnsPOntologyterm * Pot)4428 AjBool ensOntologytermadaptorFetchByAccession(
4429 EnsPOntologytermadaptor ota,
4430 const AjPStr accession,
4431 EnsPOntologyterm *Pot)
4432 {
4433 char *txtaccession = NULL;
4434
4435 AjBool result = AJFALSE;
4436
4437 AjPList ots = NULL;
4438
4439 AjPStr statement = NULL;
4440
4441 EnsPOntologyterm ot = NULL;
4442
4443 if (!ota)
4444 return ajFalse;
4445
4446 if ((accession == NULL) || (ajStrGetLen(accession) == 0))
4447 return ajFalse;
4448
4449 if (!Pot)
4450 return ajFalse;
4451
4452 ensBaseadaptorEscapeC(
4453 ensOntologytermadaptorGetBaseadaptor(ota),
4454 &txtaccession,
4455 accession);
4456
4457 statement = ajFmtStr(
4458 "SELECT "
4459 "term.term_id, "
4460 "term.ontology_id, "
4461 "term.accession, "
4462 "term.name, "
4463 "term.definition, "
4464 "term.subsets "
4465 "FROM "
4466 "term "
4467 "WHERE "
4468 "term.accession = '%s'",
4469 txtaccession);
4470
4471 ajCharDel(&txtaccession);
4472
4473 ots = ajListNew();
4474
4475 result = ontologytermadaptorFetchAllbyStatement(
4476 ota,
4477 statement,
4478 (EnsPAssemblymapper) NULL,
4479 (EnsPSlice) NULL,
4480 ots);
4481
4482 if (ajListGetLength(ots) > 1)
4483 ajDebug("ensOntologytermadaptorFetchByAccession got more than one "
4484 "Ensembl Ontology Term for accession '%S'.\n",
4485 accession);
4486
4487 ajListPop(ots, (void **) Pot);
4488
4489 while (ajListPop(ots, (void **) &ot))
4490 ensOntologytermDel(&ot);
4491
4492 ajListFree(&ots);
4493
4494 ajStrDel(&statement);
4495
4496 return result;
4497 }
4498
4499
4500
4501
4502 /* @func ensOntologytermadaptorFetchByIdentifier ******************************
4503 **
4504 ** Fetch an Ensembl Ontology Term by its SQL database-internal identifier.
4505 ** The caller is responsible for deleting the Ensembl Ontology Term.
4506 **
4507 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::fetch_by_dbID
4508 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4509 ** @param [r] identifier [ajuint] SQL database-internal identifier
4510 ** @param [wP] Pot [EnsPOntologyterm*] Ensembl Ontology Term address
4511 **
4512 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4513 **
4514 ** @release 6.5.0
4515 ** @@
4516 ******************************************************************************/
4517
ensOntologytermadaptorFetchByIdentifier(EnsPOntologytermadaptor ota,ajuint identifier,EnsPOntologyterm * Pot)4518 AjBool ensOntologytermadaptorFetchByIdentifier(
4519 EnsPOntologytermadaptor ota,
4520 ajuint identifier,
4521 EnsPOntologyterm *Pot)
4522 {
4523 return ensBaseadaptorFetchByIdentifier(
4524 ensOntologytermadaptorGetBaseadaptor(ota),
4525 identifier,
4526 (void **) Pot);
4527 }
4528
4529
4530
4531
4532 /* @section accessory object retrieval ****************************************
4533 **
4534 ** Functions for retrieving objects releated to Ensembl Ontology Term objects
4535 ** from an Ensembl SQL database.
4536 **
4537 ** @fdata [EnsPOntologytermadaptor]
4538 **
4539 ** @nam3rule Retrieve Retrieve Ensembl Ontology Term-releated object(s)
4540 ** @nam4rule All Retrieve all Ensembl Ontology Term-releated objects
4541 ** @nam5rule Ontologysynonyms Retrieve all Ensembl Ontology Synonym objects
4542 **
4543 ** @argrule * ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4544 ** @argrule Ontologysynonyms ot [const EnsPOntologyterm] Ensembl Ontology Term
4545 ** @argrule Ontologysynonyms oss [AjPList]
4546 ** AJAX List of Ensembl Ontology Synonym objects
4547 **
4548 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
4549 **
4550 ** @fcategory use
4551 ******************************************************************************/
4552
4553
4554
4555
4556 /* @func ensOntologytermadaptorRetrieveAllOntologysynonyms ********************
4557 **
4558 ** Retrieve all Ensembl Ontology Synonym objects of Ensembl Ontology Term.
4559 **
4560 ** The caller is responsible for deleting the Ensembl Ontology Synonym objects
4561 ** before deleting the AJAX List.
4562 **
4563 ** @cc Bio::EnsEMBL::DBSQL::OntologyTermAdaptor::_fetch_synonyms_by_dbID
4564 ** @param [u] ota [EnsPOntologytermadaptor] Ensembl Ontology Term Adaptor
4565 ** @param [r] ot [const EnsPOntologyterm] Ensembl Ontology Term
4566 ** @param [u] oss [AjPList] AJAX List of Ensembl Ontology Synonym objects
4567 **
4568 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4569 **
4570 ** @release 6.4.0
4571 ** @@
4572 ******************************************************************************/
4573
ensOntologytermadaptorRetrieveAllOntologysynonyms(EnsPOntologytermadaptor ota,const EnsPOntologyterm ot,AjPList oss)4574 AjBool ensOntologytermadaptorRetrieveAllOntologysynonyms(
4575 EnsPOntologytermadaptor ota,
4576 const EnsPOntologyterm ot,
4577 AjPList oss)
4578 {
4579 ajuint identifier = 0U;
4580
4581 AjPSqlstatement sqls = NULL;
4582 AjISqlrow sqli = NULL;
4583 AjPSqlrow sqlr = NULL;
4584
4585 AjPStr name = NULL;
4586 AjPStr statement = NULL;
4587
4588 EnsPDatabaseadaptor dba = NULL;
4589
4590 EnsPOntologysynonym os = NULL;
4591
4592 if (!ota)
4593 return ajFalse;
4594
4595 if (!ot)
4596 return ajFalse;
4597
4598 if (!oss)
4599 return ajFalse;
4600
4601 dba = ensOntologytermadaptorGetDatabaseadaptor(ota);
4602
4603 statement = ajFmtStr(
4604 "SELECT "
4605 "synonym.name "
4606 "FROM "
4607 "synonym "
4608 "WHERE "
4609 "synonym.term_id = %u",
4610 ensOntologytermGetIdentifier(ot));
4611
4612 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4613
4614 sqli = ajSqlrowiterNew(sqls);
4615
4616 while (!ajSqlrowiterDone(sqli))
4617 {
4618 identifier = 0;
4619 name = ajStrNew();
4620
4621 sqlr = ajSqlrowiterGet(sqli);
4622
4623 ajSqlcolumnToUint(sqlr, &identifier);
4624 ajSqlcolumnToStr(sqlr, &name);
4625
4626 os = ensOntologysynonymNewIni(ota, identifier, name);
4627
4628 ajListPushAppend(oss, (void *) os);
4629
4630 ajStrDel(&name);
4631 }
4632
4633 ajSqlrowiterDel(&sqli);
4634
4635 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4636
4637 return ajTrue;
4638 }
4639