tripal_feature.api.inc

  1. 2.x tripal_feature/api/tripal_feature.api.inc
  2. 1.x tripal_feature/api/tripal_feature.api.inc

Provides an application programming interface (API) for working with features

tripal_feature_api Feature Module API

File

tripal_feature/api/tripal_feature.api.inc
View source
  1. <?php
  2. /**
  3. * @file
  4. * Provides an application programming interface (API) for working with features
  5. *
  6. * @defgroup tripal_feature_api Feature Module API
  7. * @ingroup tripal_api
  8. */
  9. /**
  10. * Retrieve properties from the analysisfeatureprop table for a feature.
  11. *
  12. * @param $analysis_id
  13. * The analysis ID for the analysis feature. This argument is optional but
  14. * if specified it must also be accompanied with a feature ID.
  15. * @param $feature_id
  16. * The feature ID for the analysis feature. This argument is optional but
  17. * if specified it must also be accompanied with an analysis ID.
  18. * @param $analysisfeature_id
  19. * The analysis feature ID for the analysis feature. This argument is
  20. * optional and can be used rather than specifying the $analysis_id and
  21. * $feature_id arguments. If all three arguments are specified (e.g.
  22. * an $analysis_id, $feature_id and $analysisfeature_id, then the
  23. * $analysisfeature_id is used and the other two arguments are ignored.
  24. * @param $property
  25. * The cvterm name of the properties to retrieve
  26. * @param $cv_name
  27. * Optional. The name of the cv to which the property belongs. By
  28. * default this is the 'tripal' cv.
  29. *
  30. * @return
  31. * An analysisfeature chado variable with the specified properties expanded
  32. *
  33. * @ingroup tripal_feature_api
  34. */
  35. function tripal_feature_analysis_get_property($analysis_id = NULL, $feature_id = NUll,
  36. $analysisfeature_id = NULL, $property, $cv_name = 'tripal') {
  37. // check that the incoming arguments are correct
  38. if (($analysis_id and !$feature_id) or
  39. (!$analysis_id and $feature_id)) {
  40. watchdog('tripal_feature',
  41. 'tripal_feature_analysis_get_property: Both an analysis ID and feature ID should be specified',
  42. array(), WATCHDOG_WARNING);
  43. }
  44. // get the analysisfeature_id if one is not provided
  45. if (!$analysisfeature_id) {
  46. $columns = array('analysisfeature_id');
  47. $values = array('analysis_id' => $analysis_id, 'feature_id' => $feature_id);
  48. $result = tripal_core_chado_select('analysisfeature', $columns, $values);
  49. $analysisfeature_id = $result[0]->analysisfeature_id;
  50. }
  51. // get the property.
  52. return tripal_core_get_property('analysisfeature', $analysisfeature_id, $property, $cv_name);
  53. }
  54. /**
  55. * Insert a property for an analysis feature
  56. *
  57. * @param $analysis_id
  58. * The analysis ID for the analysis feature. This argument is optional but
  59. * if specified it must also be accompanied with a feature ID.
  60. * @param $feature_id
  61. * The feature ID for the analysis feature. This argument is optional but
  62. * if specified it must also be accompanied with an analysis ID.
  63. * @param $analysisfeature_id
  64. * The analysis feature ID for the analysis feature. This argument is
  65. * optional and can be used rather than specifying the $analysis_id and
  66. * $feature_id arguments. If all three arguments are specified (e.g.
  67. * an $analysis_id, $feature_id and $analysisfeature_id, then the
  68. * $analysisfeature_id is used and the other two arguments are ignored.
  69. * @param $property
  70. * The cvterm name of the property to insert
  71. * @param $value
  72. * The value of the property to insert
  73. * @param $update_if_present
  74. * A boolean indicated whether to update the record if it's already present
  75. * @param $cv_name
  76. * Optional. The name of the cv to which the property belongs. By
  77. * default this is the 'tripal' cv.
  78. *
  79. * @return
  80. * True of success, False otherwise
  81. *
  82. * @ingroup tripal_feature_api
  83. */
  84. function tripal_feature_analysis_insert_property($analysis_id = NULL, $feature_id = NUll,
  85. $analysisfeature_id = NULL, $property, $value, $update_if_present = 0, $cv_name = 'tripal') {
  86. // check that the incoming arguments are correct
  87. if (($analysis_id and !$feature_id) or
  88. (!$analysis_id and $feature_id)) {
  89. watchdog('tripal_feature',
  90. 'tripal_feature_analysis_insert_property: Both an analysis ID and feature ID should be specified',
  91. array(), WATCHDOG_WARNING);
  92. }
  93. // get the analysisfeature_id if one is not provided
  94. if (!$analysisfeature_id) {
  95. $columns = array('analysisfeature_id');
  96. $values = array('analysis_id' => $analysis_id, 'feature_id' => $feature_id);
  97. $result = tripal_core_chado_select('analysisfeature', $columns, $values);
  98. $analysisfeature_id = $result[0]->analysisfeature_id;
  99. }
  100. // insert the property.
  101. $success = tripal_core_insert_property('analysisfeature', $analysisfeature_id,
  102. $property, $cv_name, $value, $update_if_present);
  103. if (!$success) {
  104. watchdog('tripal_feature',
  105. 'tripal_feature_analysis_insert_property: Failed to insert analysis feature property',
  106. array(), WATCHDOG_WARNING);
  107. return FALSE;
  108. }
  109. return $success;
  110. }
  111. /**
  112. * Update an analysis feature property using the property name. Use this
  113. * when a property only exists once for a given analysis feature. When more
  114. * than one value can exist for the same property use the
  115. * tripal_feature_analysis_update_property_by_id() function.
  116. *
  117. * @param $analysis_id
  118. * The analysis ID for the analysis feature. This argument is optional but
  119. * if specified it must also be accompanied with a feature ID.
  120. * @param $feature_id
  121. * The feature ID for the analysis feature. This argument is optional but
  122. * if specified it must also be accompanied with an analysis ID.
  123. * @param $analysisfeature_id
  124. * The analysis feature ID for the analysis feature. This argument is
  125. * optional and can be used rather than specifying the $analysis_id and
  126. * $feature_id arguments. If all three arguments are specified (e.g.
  127. * an $analysis_id, $feature_id and $analysisfeature_id, then the
  128. * $analysisfeature_id is used and the other two arguments are ignored.
  129. * @param $property
  130. * The cvterm name of the property to update
  131. * @param $value
  132. * The value of the property to update
  133. * @param $insert_if_missing
  134. * A boolean indicated whether to insert the record if it's absent
  135. * @param $cv_name
  136. * Optional. The name of the cv to which the property belongs. By
  137. * default this is the 'tripal' cv.
  138. *
  139. * Note: The property will be identified using the unique combination of the $analysis_id and $property
  140. * and then it will be updated with the supplied value
  141. *
  142. * @return
  143. * True of success, False otherwise
  144. *
  145. * @ingroup tripal_feature_api
  146. */
  147. function tripal_feature_analysis_update_property($analysis_id = NULL, $feature_id = NUll,
  148. $analysisfeature_id = NULL, $property, $value, $insert_if_missing = 0,
  149. $cv_name = 'tripal') {
  150. // check that the incoming arguments are correct
  151. if (($analysis_id and !$feature_id) or
  152. (!$analysis_id and $feature_id)) {
  153. watchdog('tripal_feature',
  154. 'tripal_feature_analysis_update_property: Both an analysis ID and feature ID should be specified',
  155. array(), WATCHDOG_WARNING);
  156. }
  157. // get the analysisfeature_id if one is not provided
  158. if (!$analysisfeature_id) {
  159. $columns = array('analysisfeature_id');
  160. $values = array('analysis_id' => $analysis_id, 'feature_id' => $feature_id);
  161. $result = tripal_core_chado_select('analysisfeature', $columns, $values);
  162. $analysisfeature_id = $result[0]->analysisfeature_id;
  163. }
  164. // update the property.
  165. return tripal_core_update_property('analysisfeature', $analysisfeature_id, $property, $cv_name, $value, $insert_if_missing);
  166. }
  167. /**
  168. * Update a property for an analysis feature using the analysisfeatureprop_id.
  169. *
  170. * @param $analysisfeatureprop_id
  171. * The analysis feature property ID for the analysis feature.
  172. * @param $property
  173. * The cvterm name of the property
  174. * @param $value
  175. * The value of the property
  176. * @param $cv_name
  177. * Optional. The name of the cv to which the property belongs. By
  178. * default this is the 'tripal' cv.
  179. * *
  180. * @return
  181. * True of success, False otherwise
  182. *
  183. * @ingroup tripal_feature_api
  184. */
  185. function tripal_feature_analysis_update_property_by_id($analysisfeatureprop_id,
  186. $property, $value, $cv_name = 'tripal') {
  187. // update the property.
  188. return tripal_core_update_property_by_id('analysisfeature',
  189. $analysisfeatureprop_id, $property, $cv_name, $value);
  190. }
  191. /**
  192. * Delete an analysis feature property using the property name. Use this
  193. * when a property only exists once for a given analysis feature. When more
  194. * than one value can exist for the same property use the
  195. * tripal_feature_analysis_delete_property_by_id() function.
  196. *
  197. * @param $analysis_id
  198. * The analysis ID for the analysis feature. This argument is optional but
  199. * if specified it must also be accompanied with a feature ID.
  200. * @param $feature_id
  201. * The feature ID for the analysis feature. This argument is optional but
  202. * if specified it must also be accompanied with an analysis ID.
  203. * @param $analysisfeature_id
  204. * The analysis feature ID for the analysis feature. This argument is
  205. * optional and can be used rather than specifying the $analysis_id and
  206. * $feature_id arguments. If all three arguments are specified (e.g.
  207. * an $analysis_id, $feature_id and $analysisfeature_id, then the
  208. * $analysisfeature_id is used and the other two arguments are ignored.
  209. * @param $property
  210. * The cvterm name of the property to delete
  211. * @param $cv_name
  212. * Optional. The name of the cv to which the property belongs. By
  213. * default this is the 'tripal' cv.
  214. *
  215. * Note: The property will be identified using the unique combination of the $analysis_id and $property
  216. * and then it will be deleted
  217. *
  218. * @return
  219. * True of success, False otherwise
  220. *
  221. * @ingroup tripal_feature_api
  222. */
  223. function tripal_feature_analysis_delete_property($analysis_id = NULL, $feature_id = NUll,
  224. $analysisfeature_id = NULL, $property, $cv_name = 'tripal') {
  225. // check that the incoming arguments are correct
  226. if (($analysis_id and !$feature_id) or
  227. (!$analysis_id and $feature_id)) {
  228. watchdog('tripal_feature',
  229. 'tripal_feature_analysis_delete_property: Both an analysis ID and feature ID should be specified',
  230. array(), WATCHDOG_WARNING);
  231. }
  232. // get the analysisfeature_id if one is not provided
  233. if (!$analysisfeature_id) {
  234. $columns = array('analysisfeature_id');
  235. $values = array('analysis_id' => $analysis_id, 'feature_id' => $feature_id);
  236. $result = tripal_core_chado_select('analysisfeature', $columns, $values);
  237. $analysisfeature_id = $result[0]->analysisfeature_id;
  238. }
  239. // get the property.
  240. return tripal_core_delete_property('analysisfeature', $analysisfeature_id, $property, $cv_name);
  241. }
  242. /**
  243. * Delete a property using the analysisfeatureprop_id
  244. *
  245. * @param $analysisfeatureprop_id
  246. * The analysis feature property ID for the analysis feature.
  247. *
  248. * @return
  249. * True of success, False otherwise
  250. *
  251. * @ingroup tripal_feature_api
  252. */
  253. function tripal_feature_analysis_delete_property_by_id($analysisfeatureprop_id) {
  254. // get the property.
  255. return tripal_core_delete_property_by_id('analysisfeature', $analysisfeatureprop_id);
  256. }
  257. /**
  258. * Retrieve properties of a given type for a given feature
  259. *
  260. * @param $feature_id
  261. * The feature_id of the properties you would like to retrieve
  262. * @param $property
  263. * The cvterm name of the properties to retrieve
  264. * @param $cv_name
  265. * Optional. The name of the cv to which the property belongs. By
  266. * default this is the 'tripal' cv.
  267. *
  268. * @return
  269. * A feature chado variable with the specified properties expanded
  270. *
  271. * @ingroup tripal_feature_api
  272. */
  273. function tripal_feature_get_property($feature_id, $property, $cv_name='tripal') {
  274. return tripal_core_get_property('feature', $feature_id, $property, $cv_name);
  275. }
  276. /**
  277. * Insert a given property
  278. *
  279. * @param $feature_id
  280. * The feature_id of the property to insert
  281. * @param $property
  282. * The cvterm name of the property to insert
  283. * @param $value
  284. * The value of the property to insert
  285. * @param $update_if_present
  286. * A boolean indicated whether to update the record if it's already present
  287. * @param $cv_name
  288. * Optional. The name of the cv to which the property belongs. By
  289. * default this is the 'tripal' cv.
  290. *
  291. * @return
  292. * True of success, False otherwise
  293. *
  294. * @ingroup tripal_feature_api
  295. */
  296. function tripal_feature_insert_property($feature_id, $property, $value,
  297. $update_if_present = 0, $cv_name = 'tripal') {
  298. return tripal_core_insert_property('feature', $feature_id, $property,
  299. $cv_name, $value, $update_if_present);
  300. }
  301. /**
  302. * Update a feature property using the property name. Only use this
  303. * if the property is unique and only exist once for the feature.
  304. *
  305. * @param $feature_id
  306. * The feature_id of the property to update
  307. * @param $property
  308. * The cvterm name of the property to update
  309. * @param $value
  310. * The value of the property to update
  311. * @param $insert_if_missing
  312. * A boolean indicated whether to insert the record if it's absent
  313. * @param $cv_name
  314. * Optional. The name of the cv to which the property belongs. By
  315. * default this is the 'tripal' cv.
  316. *
  317. * Note: The property will be identified using the unique combination of the $feature_id and $property
  318. * and then it will be updated with the supplied value
  319. *
  320. * @return
  321. * True of success, False otherwise
  322. *
  323. * @ingroup tripal_feature_api
  324. */
  325. function tripal_feature_update_property($feature_id, $property,
  326. $value, $insert_if_missing = 0, $cv_name = 'tripal') {
  327. return tripal_core_update_property('feature', $feature_id, $property, $cv_name, $value, $insert_if_missing);
  328. }
  329. /**
  330. * Update a given feature property using the featureprop_id
  331. *
  332. * @param $featureprop_id
  333. * The featureprop_id of the property to update
  334. * @param $property
  335. * The cvterm name of the property
  336. * @param $value
  337. * The value of the property
  338. * @param $cv_name
  339. * Optional. The name of the cv to which the property belongs. By
  340. * default this is the 'tripal' cv.
  341. *
  342. * @return
  343. * True of success, False otherwise
  344. *
  345. * @ingroup tripal_feature_api
  346. */
  347. function tripal_feature_update_property_by_id($featureprop_id, $property,
  348. $value, $cv_name = 'tripal') {
  349. return tripal_core_update_property_by_id('feature', $featureprop_id, $property, $cv_name, $value);
  350. }
  351. /**
  352. * Delete a given feature property using the property name. Only use this
  353. * if the property is unique and only exists once for the feature.
  354. *
  355. * @param $feature_id
  356. * The feature_id of the property to delete
  357. * @param $property
  358. * The cvterm name of the property to delete
  359. * @param $cv_name
  360. * Optional. The name of the cv to which the property belongs. By
  361. * default this is the 'tripal' cv.
  362. *
  363. * Note: The property will be identified using the unique combination of the $feature_id and $property
  364. * and then it will be deleted
  365. *
  366. * @return
  367. * True of success, False otherwise
  368. *
  369. * @ingroup tripal_feature_api
  370. */
  371. function tripal_feature_delete_property($feature_id, $property, $cv_name='tripal') {
  372. return tripal_core_delete_property('feature', $feature_id, $property, $cv_name);
  373. }
  374. /**
  375. * Delete a given feature property using the featureprop_id
  376. *
  377. * @param $featureprop_id
  378. * The feature_id of the property to delete
  379. *
  380. * @return
  381. * True of success, False otherwise
  382. *
  383. * @ingroup tripal_feature_api
  384. */
  385. function tripal_feature_delete_property_by_id($featureprop_id) {
  386. return tripal_core_delete_property_by_id('feature', $featureprop_id);
  387. }
  388. /**
  389. * Performs a reverse compliment of a nucleotide sequence
  390. *
  391. * @param $sequence
  392. * The nucelotide sequence
  393. *
  394. * @return
  395. * an upper-case reverse complemented sequence
  396. *
  397. * @ingroup tripal_feature_api
  398. */
  399. function tripal_feature_reverse_complement($sequence) {
  400. $seq = strtoupper($sequence);
  401. $seq = strrev($seq);
  402. $seq = str_replace("A", "t", $seq);
  403. $seq = str_replace("T", "a", $seq);
  404. $seq = str_replace("G", "c", $seq);
  405. $seq = str_replace("C", "g", $seq);
  406. $seq = str_replace("Y", "r", $seq);
  407. $seq = str_replace("R", "y", $seq);
  408. $seq = str_replace("W", "w", $seq);
  409. $seq = str_replace("S", "s", $seq);
  410. $seq = str_replace("K", "m", $seq);
  411. $seq = str_replace("M", "k", $seq);
  412. $seq = str_replace("D", "h", $seq);
  413. $seq = str_replace("V", "b", $seq);
  414. $seq = str_replace("H", "d", $seq);
  415. $seq = str_replace("B", "v", $seq);
  416. return strtoupper($seq);
  417. }
  418. /**
  419. * Retrieves the sequence for a feature.
  420. *
  421. * @param $feature_id
  422. * The feature_id of the feature for which the sequence will be retrieved
  423. * @param $feature_name
  424. * The feature name. This will appear on the FASTA definition line
  425. * @param $num_bases_per_line
  426. * Indicate the number of bases to use per line. A new line will be added
  427. * after the specified number of bases on each line.
  428. * @param $derive_from_parent
  429. * Set to '1' if the sequence should be obtained from the parent to which
  430. * this feature is aligned.
  431. * @param $aggregate
  432. * Set to '1' if the sequence should only contain sub features, excluding
  433. * intra sub feature sequence. For example, set this option to obtain just
  434. * the coding sequence of an mRNA.
  435. * @param $output_format
  436. * The type of format. Valid formats include 'fasta_html', 'fasta_txt' and
  437. * 'raw'. The format 'fasta_txt' outputs line
  438. * breaks as <br> tags and the entire return value is in a <span> tag
  439. * with a fixed-width font definition. 'fasta_txt' outputs line breaks with
  440. * windows format carriage returns (e.g. \r\n) with no other formatting. The
  441. * raw format is simply the sequence with now FASTA formatting and no
  442. * line breaks.
  443. * @param $upstream
  444. * An integer specifing the number of upstream bases to include in the output
  445. * @param $downstream
  446. * An integer specifying the number of downstream bases to include in the
  447. * output.
  448. * @param $sub_features
  449. * Only include sub features (or child features) of the types provided in the array
  450. * @param $relationship
  451. * If a relationship name is provided (e.g. sequence_of) then any sequences that
  452. * are in relationships of this type with matched sequences are also included
  453. * @param $rel_part
  454. * If a relationship is provided in the preceeding argument then the rel_part
  455. * must be either 'object' or 'subject' to indicate which side of the
  456. * relationship the matched features belong
  457. *
  458. * @return
  459. * The DNA/protein sequence formated as requested.
  460. *
  461. * @ingroup tripal_feature_api
  462. */
  463. function tripal_feature_get_formatted_sequence($feature_id, $feature_name,
  464. $num_bases_per_line, $derive_from_parent, $aggregate, $output_format,
  465. $upstream, $downstream, $sub_features = array(), $relationship = '', $rel_part = '') {
  466. // to speed things up we need to make sure we have a persistent connection
  467. $connection = tripal_db_persistent_chado();
  468. if (!$upstream) {
  469. $upstream = 0;
  470. }
  471. if (!$downstream) {
  472. $downstream = 0;
  473. }
  474. if ($rel_part == "object" or $rel_part == "subject") {
  475. if($rel_part == "subject") {
  476. $psql = '
  477. PREPARE feature_rel_get_object (int, text) AS
  478. SELECT FO.feature_id, FO.name, FO.uniquename, CVTO.name as feature_type, O.genus, O.species
  479. FROM feature FS
  480. INNER JOIN feature_relationship FR ON FR.subject_id = FS.feature_id
  481. INNER JOIN cvterm CVTFR ON CVTFR.cvterm_id = FR.type_id
  482. INNER JOIN feature FO ON FO.feature_id = FR.object_id
  483. INNER JOIN cvterm CVTO ON CVTO.cvterm_id = FO.type_id
  484. INNER JOIN organism O ON O.organism_id = FO.organism_id
  485. WHERE
  486. FS.feature_id = $1 AND
  487. CVTFR.name = $2
  488. ';
  489. $status = tripal_core_chado_prepare('feature_rel_get_object', $psql, array('int', 'text'));
  490. if (!$status) {
  491. watchdog('tripal_feature', "init: not able to prepare SQL statement '%name'",
  492. array('%name' => 'feature_by_subject'), 'WATCHDOG ERROR');
  493. }
  494. $sql = "EXECUTE feature_rel_get_object(%d,'%s')";
  495. $features = chado_query($sql, $feature_id, $relationship);
  496. }
  497. if($rel_part == "object") {
  498. $psql = '
  499. PREPARE feature_rel_get_subject (int, text) AS
  500. SELECT FS.feature_id, FS.name, FS.uniquename, CVTO.name as feature_type, O.genus, O.species
  501. FROM feature FO
  502. INNER JOIN feature_relationship FR ON FR.object_id = FO.feature_id
  503. INNER JOIN cvterm CVTFR ON CVTFR.cvterm_id = FR.type_id
  504. INNER JOIN feature FS ON FS.feature_id = FR.subject_id
  505. INNER JOIN cvterm CVTO ON CVTO.cvterm_id = FS.type_id
  506. INNER JOIN organism O ON O.organism_id = FS.organism_id
  507. WHERE
  508. FO.feature_id = $1 AND
  509. CVTFR.name = $2
  510. ';
  511. $status = tripal_core_chado_prepare('feature_rel_get_subject', $psql, array('int', 'text'));
  512. if (!$status) {
  513. watchdog('tripal_feature', "init: not able to prepare SQL statement '%name'",
  514. array('%name' => 'feature_by_object'), 'WATCHDOG ERROR');
  515. }
  516. $sql = "EXECUTE feature_rel_get_subject(%d,'%s')";
  517. $features = chado_query($sql, $feature_id, $relationship);
  518. }
  519. $sequences = '';
  520. while ($feature = db_fetch_object($features)) {
  521. // recurse and get the sequences for these in the relationship
  522. if ($rel_part == "subject") {
  523. $defline = "$feature_name, $relationship, $feature->uniquename $feature->feature_type ($feature->genus $feature->species)";
  524. }
  525. if ($rel_part == "object") {
  526. $defline = "$feature->uniquename $feature->feature_type ($feature->genus $feature->species), $relationship, $feature_name";
  527. }
  528. $sequences .= tripal_feature_get_formatted_sequence($feature->feature_id, $defline,
  529. $num_bases_per_line, $derive_from_parent, $aggregate, $output_format,
  530. $upstream, $downstream, $sub_features,'','');
  531. }
  532. return $sequences;
  533. }
  534. // prepare statements we'll need to use later
  535. if (!tripal_core_is_sql_prepared('sequence_by_parent')) {
  536. // prepare the queries we're going to use later during the render phase
  537. // This SQL statement uses conditionals in the select clause to handle
  538. // cases cases where the alignment is in the reverse direction and when
  539. // the upstream and downstream extensions go beyond the lenght of the
  540. // parent sequence.
  541. $psql ='
  542. PREPARE sequence_by_parent (int, int, int) AS
  543. SELECT srcname, srcfeature_id, strand, srctypename, typename,
  544. fmin, fmax, upstream, downstream, adjfmin, adjfmax,
  545. substring(residues from (adjfmin + 1) for (upstream + (fmax - fmin) + downstream)) as residues,
  546. genus, species
  547. FROM (
  548. SELECT
  549. OF.name srcname, FL.srcfeature_id, FL.strand,
  550. OCVT.name as srctypename, SCVT.name as typename,
  551. FL.fmin, FL.fmax, OO.genus, OO.species,
  552. CASE
  553. WHEN FL.strand >= 0 THEN
  554. CASE
  555. WHEN FL.fmin - $1 <= 0 THEN 0
  556. ELSE FL.fmin - $1
  557. END
  558. WHEN FL.strand < 0 THEN
  559. CASE
  560. WHEN FL.fmin - $2 <= 0 THEN 0
  561. ELSE FL.fmin - $2
  562. END
  563. END as adjfmin,
  564. CASE
  565. WHEN FL.strand >= 0 THEN
  566. CASE
  567. WHEN FL.fmax + $2 > OF.seqlen THEN OF.seqlen
  568. ELSE FL.fmax + $2
  569. END
  570. WHEN FL.strand < 0 THEN
  571. CASE
  572. WHEN FL.fmax + $1 > OF.seqlen THEN OF.seqlen
  573. ELSE FL.fmax + $1
  574. END
  575. END as adjfmax,
  576. CASE
  577. WHEN FL.strand >= 0 THEN
  578. CASE
  579. WHEN FL.fmin - $1 <= 0 THEN FL.fmin
  580. ELSE $1
  581. END
  582. ELSE
  583. CASE
  584. WHEN FL.fmax + $1 > OF.seqlen THEN OF.seqlen - FL.fmax
  585. ELSE $1
  586. END
  587. END as upstream,
  588. CASE
  589. WHEN FL.strand >= 0 THEN
  590. CASE
  591. WHEN FL.fmax + $2 > OF.seqlen THEN OF.seqlen - FL.fmax
  592. ELSE $2
  593. END
  594. ELSE
  595. CASE
  596. WHEN FL.fmin - $2 <= 0 THEN FL.fmin
  597. ELSE $2
  598. END
  599. END as downstream,
  600. OF.residues
  601. FROM {featureloc} FL
  602. INNER JOIN {feature} SF on FL.feature_id = SF.feature_id
  603. INNER JOIN {cvterm} SCVT on SF.type_id = SCVT.cvterm_id
  604. INNER JOIN {feature} OF on FL.srcfeature_id = OF.feature_id
  605. INNER JOIN {cvterm} OCVT on OF.type_id = OCVT.cvterm_id
  606. INNER JOIN {organism} OO on OF.organism_id = OO.organism_id
  607. WHERE SF.feature_id = $3 and NOT (OF.residues = \'\' or OF.residues IS NULL)) as tbl1
  608. ';
  609. $status = tripal_core_chado_prepare('sequence_by_parent', $psql, array('int', 'int', 'int'));
  610. if (!$status) {
  611. watchdog('tripal_feature',
  612. "init: not able to prepare SQL statement '%name'",
  613. array('%name' => 'sequence_by_parent'), 'WATCHDOG ERROR');
  614. }
  615. // this query is meant to get all of the sub features of any given
  616. // feature (arg #1) and order them as they appear on the reference
  617. // feature (arg #2).
  618. $psql ='PREPARE sub_features (int, int) AS
  619. SELECT SF.feature_id, CVT.name as type_name, SF.type_id
  620. FROM {feature_relationship} FR
  621. INNER JOIN {feature} SF on SF.feature_id = FR.subject_id
  622. INNER JOIN {cvterm} CVT on CVT.cvterm_id = SF.type_id
  623. INNER JOIN {featureloc} FL on FL.feature_id = FR.subject_id
  624. INNER JOIN {feature} PF on PF.feature_id = FL.srcfeature_id
  625. WHERE FR.object_id = $1 and PF.feature_id = $2
  626. ORDER BY FL.fmin ASC';
  627. $status = tripal_core_chado_prepare('sub_features', $psql, array('int', 'int'));
  628. if (!$status) {
  629. watchdog('tripal_views_handler_field_sequence',
  630. "init: not able to prepare SQL statement '%name'",
  631. array('%name' => 'ssub_features'), 'WATCHDOG ERROR');
  632. }
  633. $psql ='PREPARE count_sub_features (int, int) AS
  634. SELECT count(*) as num_children
  635. FROM {feature_relationship} FR
  636. INNER JOIN {feature} SF on SF.feature_id = FR.subject_id
  637. INNER JOIN {cvterm} CVT on CVT.cvterm_id = SF.type_id
  638. INNER JOIN {featureloc} FL on FL.feature_id = FR.subject_id
  639. INNER JOIN {feature} PF on PF.feature_id = FL.srcfeature_id
  640. WHERE FR.object_id = $1 and PF.feature_id = $2';
  641. $status = tripal_core_chado_prepare('count_sub_features', $psql, array('int', 'int'));
  642. if (!$status) {
  643. watchdog('tripal_views_handler_field_sequence',
  644. "init: not able to prepare SQL statement '%name'",
  645. array('%name' => 'count_sub_features'), 'WATCHDOG ERROR');
  646. }
  647. }
  648. // if we need to get the sequence from the parent then do so now.
  649. if ($derive_from_parent) {
  650. // execute the query to get the sequence from the parent
  651. $sql = "EXECUTE sequence_by_parent (%d, %d, %d)";
  652. $parents = chado_query($sql, $upstream, $downstream, $feature_id);
  653. while ($parent = db_fetch_object($parents)) {
  654. $seq = ''; // initialize the sequence for each parent
  655. // if we are to aggregate then we will ignore the feature returned
  656. // by the query above and rebuild it using the sub features
  657. if ($aggregate) {
  658. // now get the sub features that are located on the parent.
  659. $sql = "EXECUTE sub_features (%d, %d)";
  660. $children = chado_query($sql, $feature_id, $parent->srcfeature_id);
  661. $sql = "EXECUTE count_sub_features (%d, %d)";
  662. $num_children = db_fetch_object(chado_query($sql, $feature_id, $parent->srcfeature_id));
  663. // iterate through the sub features and concat their sequences. They
  664. // should already be in order.
  665. $types = array();
  666. $i = 0;
  667. while ($child = db_fetch_object($children)) {
  668. // if the callee has specified that only certain sub features should be
  669. // included then continue if this child is not one of those allowed
  670. // subfeatures
  671. if (count($sub_features) > 0 and !in_array($child->type_name, $sub_features)) {
  672. continue;
  673. }
  674. // keep up with the types
  675. if (!in_array($child->type_name, $types)) {
  676. $types[] = $child->type_name;
  677. }
  678. $sql = "EXECUTE sequence_by_parent (%d, %d, %d)";
  679. // if the first sub feature we need to include the upstream bases. first check if
  680. // the feature is in the foward direction or the reverse.
  681. if ($i == 0 and $parent->strand >= 0) { // forward direction
  682. // -------------------------- ref
  683. // ....----> ---->
  684. // up 1 2
  685. $q = chado_query($sql, $upstream, 0, $child->feature_id);
  686. }
  687. elseif ($i == 0 and $parent->strand < 0) { // reverse direction
  688. // -------------------------- ref
  689. // ....<---- <----
  690. // down 1 2
  691. $q = chado_query($sql, 0, $downstream, $child->feature_id);
  692. }
  693. // Next, if the last sub feature we need to include the downstream bases. first check if
  694. // the feature is in teh forward direction or the reverse
  695. if ($i == $num_children->num_children - 1 and $parent->strand >= 0) { // forward direction
  696. // -------------------------- ref
  697. // ----> ---->....
  698. // 1 2 down
  699. $q = chado_query($sql, 0, $downstream, $child->feature_id);
  700. }
  701. elseif ($i == $num_children->num_children - 1 and $parent->strand < 0) { // reverse direction
  702. // -------------------------- ref
  703. // <---- <----....
  704. // 1 2 up
  705. $q = chado_query($sql, $upstream, 0, $child->feature_id);
  706. }
  707. // for internal sub features we don't want upstream or downstream bases
  708. else {
  709. $sql = "EXECUTE sequence_by_parent (%d, %d, %d)";
  710. $q = chado_query($sql, 0, 0, $child->feature_id);
  711. }
  712. while ($subseq = db_fetch_object($q)) {
  713. // concatenate the sequences of all the sub features
  714. if ($subseq->srcfeature_id == $parent->srcfeature_id) {
  715. $seq .= $subseq->residues;
  716. }
  717. }
  718. $i++;
  719. }
  720. }
  721. // if this isn't an aggregate then use the parent residues
  722. else {
  723. $seq = $parent->residues;
  724. }
  725. // get the reverse compliment if feature is on the reverse strand
  726. $dir = 'forward';
  727. if ($parent->strand < 0) {
  728. $seq = tripal_feature_reverse_complement($seq);
  729. $dir = 'reverse';
  730. }
  731. // now format for display
  732. if ($output_format == 'fasta_html') {
  733. $seq = wordwrap($seq, $num_bases_per_line, "<br>", TRUE);
  734. }
  735. elseif ($output_format == 'fasta_txt') {
  736. $seq = wordwrap($seq, $num_bases_per_line, "\r\n", TRUE);
  737. }
  738. $residues .= ">$feature_name. Sequence derived from feature of type, '$parent->srctypename', of $parent->genus $parent->species: $parent->srcname:" . ($parent->adjfmin + 1) . ".." . $parent->adjfmax ." ($dir). ";
  739. if (count($types) > 0) {
  740. $residues .= "Excludes all bases but those of type(s): " . implode(', ', $types) . ". " ;
  741. }
  742. if ($parent->upstream > 0) {
  743. $residues .= "Includes " . $parent->upstream . " bases upstream. ";
  744. }
  745. if ($parent->downstream > 0) {
  746. $residues .= "Includes " . $parent->downstream . " bases downstream. ";
  747. }
  748. if (!$seq) {
  749. if ($output_format == 'fasta_html') {
  750. $residues .= "No sequence available.</br>";
  751. }
  752. else {
  753. $residues .= "No sequence available.\r\n";
  754. }
  755. }
  756. else {
  757. if ($output_format == 'fasta_html') {
  758. $residues .= "<br>";
  759. }
  760. $residues .= "\r\n" . $seq . "\r\n";
  761. if ($output_format == 'fasta_html') {
  762. $residues .= "<br>";
  763. }
  764. }
  765. }
  766. }
  767. // if we are not getting the sequence from the parent sequence then
  768. // use what comes through from the feature record
  769. else {
  770. $sql = "SELECT * FROM {feature} F WHERE feature_id = %d";
  771. $values = db_fetch_object(chado_query($sql, $feature_id));
  772. $residues = $values->residues;
  773. if ($output_format == 'fasta_html') {
  774. $residues = wordwrap($residues, $num_bases_per_line, "<br>", TRUE);
  775. }
  776. elseif ($output_format == 'fasta_txt') {
  777. $residues = wordwrap($residues, $num_bases_per_line, "\r\n", TRUE);
  778. }
  779. $residues = ">$feature_name\r\n$residues\r\n";
  780. }
  781. // format the residues for display
  782. if ($residues and $num_bases_per_line) {
  783. if ($output_format == 'fasta_html') {
  784. $residues = '<span style="font-family: monospace;">' . $residues . '</span>';
  785. }
  786. }
  787. return $residues;
  788. }
  789. /**
  790. * This function defines the custom tables that will be created
  791. * in the chado schema.
  792. *
  793. * @ingroup tripal_feature
  794. */
  795. function tripal_feature_get_custom_tables($table = NULL) {
  796. if (!$table or strcmp($table, 'tripal_gff_temp')==0) {
  797. $schema['tripal_gff_temp'] = array(
  798. 'table' => 'tripal_gff_temp',
  799. 'fields' => array(
  800. 'feature_id' => array(
  801. 'type' => 'int',
  802. 'not null' => TRUE,
  803. ),
  804. 'organism_id' => array(
  805. 'type' => 'int',
  806. 'not null' => TRUE,
  807. ),
  808. 'uniquename' => array(
  809. 'type' => 'text',
  810. 'not null' => TRUE,
  811. ),
  812. 'type_name' => array(
  813. 'type' => 'varchar',
  814. 'length' => '1024',
  815. 'not null' => TRUE,
  816. ),
  817. ),
  818. 'indexes' => array(
  819. 'tripal_gff_temp_idx0' => array('feature_id'),
  820. 'tripal_gff_temp_idx0' => array('organism_id'),
  821. 'tripal_gff_temp_idx1' => array('uniquename'),
  822. ),
  823. 'unique keys' => array(
  824. 'tripal_gff_temp_uq0' => array('feature_id'),
  825. 'tripal_gff_temp_uq1' => array('uniquename', 'organism_id', 'type_name'),
  826. ),
  827. );
  828. }
  829. return $schema;
  830. }
  831. /**
  832. * Using the tripal_core_expand_chado_vars function to retrieve a set
  833. * of relationships can be very slow, especialy if there are many relationships
  834. * This function is intended to help speed up the retrieval of relationships
  835. * by only retrieving the base information for the relationship and returning
  836. * an array with
  837. *
  838. * @param $feature
  839. * The feature object
  840. * @return
  841. * An array with two objects
  842. *
  843. * @ingroup tripal_feature_api
  844. */
  845. function tripal_feature_get_feature_relationships($feature) {
  846. // expand the feature object to include the feature relationships.
  847. $options = array(
  848. 'return_array' => 1,
  849. 'order_by' => array('rank' => 'ASC'),
  850. );
  851. $feature = tripal_core_expand_chado_vars($feature, 'table',
  852. 'feature_relationship', $options);
  853. // get the subject relationships
  854. $srelationships = $feature->feature_relationship->subject_id;
  855. $orelationships = $feature->feature_relationship->object_id;
  856. // get alignment as child. The $feature->featureloc element
  857. // is already populated from the alignment preprocess function
  858. $feature = tripal_core_expand_chado_vars($feature, 'table', 'featureloc');
  859. $cfeaturelocs = $feature->featureloc->feature_id;
  860. if (!$cfeaturelocs) {
  861. $cfeaturelocs = array();
  862. }
  863. elseif (!is_array($cfeaturelocs)) {
  864. $cfeaturelocs = array($cfeaturelocs);
  865. }
  866. // prepare the SQL statement to get the featureloc for the
  867. // feature in the relationships.
  868. $connection = tripal_db_persistent_chado();
  869. $psql = "
  870. PREPARE sel_featureloc_preprocess_relationships (int, int) AS
  871. SELECT
  872. FL.featureloc_id, F.name as srcfeature_name, FL.srcfeature_id,
  873. FL.feature_id, FL.fmin, FL.fmax, FL.strand, FL.phase
  874. FROM featureloc FL
  875. INNER JOIN feature F ON F.feature_id = FL.srcfeature_id
  876. WHERE FL.feature_id = $1 and FL.srcfeature_id = $2
  877. ";
  878. tripal_core_chado_prepare('sel_featureloc_preprocess_relationships', $psql, array('int', 'int'));
  879. // combine both object and subject relationshisp into a single array
  880. $relationships = array();
  881. $relationships['object'] = array();
  882. $relationships['subject'] = array();
  883. // iterate through the object relationships
  884. if ($orelationships) {
  885. foreach ($orelationships as $relationship) {
  886. $rel = new stdClass();
  887. // get locations where the child feature and this feature overlap with the
  888. // same landmark feature.
  889. $rel->child_featurelocs = array();
  890. foreach ($cfeaturelocs as $featureloc) {
  891. $res = chado_query("EXECUTE sel_featureloc_preprocess_relationships (%d, %d)",
  892. $relationship->subject_id->feature_id,
  893. $featureloc->srcfeature_id->feature_id);
  894. while ($loc = db_fetch_object($res)) {
  895. // add in the node id of the src feature if it exists and save this location
  896. $loc->nid = $featureloc->srcfeature_id->nid;
  897. $rel->child_featurelocs[] = $loc;
  898. }
  899. }
  900. $rel->record = $relationship;
  901. // get the relationship and child types
  902. $rel_type = t(preg_replace('/_/', " ", $relationship->type_id->name));
  903. $child_type = $relationship->subject_id->type_id->name;
  904. // get the node id of the subject
  905. $sql = "SELECT nid FROM {chado_feature} WHERE feature_id = %d";
  906. $n = db_fetch_object(db_query($sql, $relationship->subject_id->feature_id));
  907. if ($n) {
  908. $rel->record->nid = $n->nid;
  909. }
  910. if (!array_key_exists($rel_type, $relationships['object'])) {
  911. $relationships['object'][$rel_type] = array();
  912. }
  913. if (!array_key_exists($child_type, $relationships['object'][$rel_type])) {
  914. $relationships['object'][$rel_type][$child_type] = array();
  915. }
  916. $relationships['object'][$rel_type][$child_type][] = $rel;
  917. }
  918. }
  919. // now add in the subject relationships
  920. if ($srelationships) {
  921. foreach ($srelationships as $relationship) {
  922. $rel = new stdClass();
  923. // get locations where this feature overlaps with the parent
  924. $rel->parent_featurelocs = array();
  925. foreach ($cfeaturelocs as $featureloc) {
  926. $res = chado_query("EXECUTE sel_featureloc_preprocess_relationships (%d, %d)",
  927. $relationship->object_id->feature_id,
  928. $featureloc->srcfeature_id->feature_id);
  929. while ($loc = db_fetch_object($res)) {
  930. // add in the node id of the src feature if it exists and save this location
  931. $loc->nid = $featureloc->srcfeature_id->nid;
  932. $rel->parent_featurelocs[] = $loc;
  933. }
  934. }
  935. $rel->record = $relationship;
  936. $rel_type = t(preg_replace('/_/', " ", $relationship->type_id->name));
  937. $parent_type = $relationship->object_id->type_id->name;
  938. // get the node id of the subject
  939. $sql = "SELECT nid FROM {chado_feature} WHERE feature_id = %d";
  940. $n = db_fetch_object(db_query($sql, $relationship->object_id->feature_id));
  941. if ($n) {
  942. $rel->record->nid = $n->nid;
  943. }
  944. if (!array_key_exists($rel_type, $relationships['subject'])) {
  945. $relationships['subject'][$rel_type] = array();
  946. }
  947. if (!array_key_exists($child_type, $relationships['subject'][$rel_type])) {
  948. $relationships['subject'][$rel_type][$parent_type] = array();
  949. }
  950. $relationships['subject'][$rel_type][$parent_type][] = $rel;
  951. }
  952. }
  953. return $relationships;
  954. }
  955. /*
  956. * This function adds an entry to the feature_dbxref table.
  957. *
  958. * @param $feature_id
  959. * The numeric feature_if of the feature
  960. * @param $dbname
  961. * The name of the database to which the term belongs
  962. * @param accession
  963. * The accession of the term
  964. *
  965. * @return
  966. * TRUE on success. FALSE on failure.
  967. *
  968. * @ingroup tripal_feature_api
  969. */
  970. function tripal_feature_add_dbxref($feature_id, $dbname, $accession) {
  971. // make sure the db exists. If it doesn't, then add it
  972. $values = array('name' => $dbname);
  973. $options = array('statement_name' => 'sel_db_na');
  974. $db = tripal_core_chado_select('db', array('db_id'), $values, $options);
  975. if (!$db or count($db) == 0) {
  976. $options = array('statement_name' => 'ins_db_na');
  977. $success = tripal_core_chado_insert('db', $values, $options);
  978. if (!$success) {
  979. watchdog('tripal_feature', 'tripal_feature_add_dbxref: The feature dbxref entry for feature, %feature_id, ".
  980. "could not be added because the database, %dbname, does not exist and cannot be added.',
  981. array('%feature_id' => $feature_id, '%dbname' => $dbname), WATCHDOG_WARNING);
  982. return FALSE;
  983. }
  984. }
  985. // first make sure that the record doesn't already exist
  986. $values = array(
  987. 'dbxref_id' => array(
  988. 'accession' => $accession,
  989. 'db_id' => array(
  990. 'name' => $dbname
  991. ),
  992. ),
  993. 'feature_id' => $feature_id,
  994. );
  995. $options = array('statement_name' => 'sel_featuredbxref_dbfe');
  996. $xref = tripal_core_chado_select('feature_dbxref', array('feature_dbxref_id'), $values, $options);
  997. if (count($xref) == 0) {
  998. // if the record doesn't exist then add it.
  999. $options = array('statement_name' => 'ins_featuredbxref_dbfe');
  1000. $success = tripal_core_chado_insert('feature_dbxref', $values, $options);
  1001. if (!$success) {
  1002. watchdog('tripal_feature', 'tripal_feature_add_dbxref: The feature dbxref entry for feature, %feature_id, '.
  1003. 'could not be added: %db:%accession.', array('%feature_id' => $feature_id, '%db' => $dbname,
  1004. '%accession' => $accession), WATCHDOG_WARNING);
  1005. return FALSE;
  1006. }
  1007. }
  1008. return TRUE;
  1009. }
  1010. /*
  1011. * This function adds an entry to the feature_cvterm table.
  1012. *
  1013. * @param $feature_id
  1014. * The numeric feature_if of the feature
  1015. * @param $cvname
  1016. * The name of the controlled vocabulary to which the term belongs
  1017. * @param cvterm
  1018. * The name of the cvterm
  1019. *
  1020. * @return
  1021. * TRUE on success. FALSE on failure.
  1022. *
  1023. * @ingroup tripal_feature_api
  1024. */
  1025. function tripal_feature_add_cvterm($feature_id, $cvname, $cvterm) {
  1026. // make sure the cv exists. If it doesn't, then add it
  1027. $values = array('name' => $cvname);
  1028. $options = array('statement_name' => 'sel_cv_na');
  1029. $cv = tripal_core_chado_select('cv', array('cv_id'), $values, $options);
  1030. if (!$cv or count($cv) == 0) {
  1031. $options = array('statement_name' => 'ins_cv_na');
  1032. $success = tripal_core_chado_insert('cv', $values, $options);
  1033. if (!$success) {
  1034. watchdog('tripal_feature', 'tripal_feature_add_cvterm: The feature cvterm entry for feature, %feature_id, ".
  1035. "could not be added because the CV, %cvname, does not exist and cannot be added.',
  1036. array('%feature_id' => $feature_id, '%cvname' => $cvname), WATCHDOG_WARNING);
  1037. return FALSE;
  1038. }
  1039. }
  1040. // first make sure that the record doesn't already exist
  1041. $values = array(
  1042. 'cvterm_id' => array(
  1043. 'name' => $cvterm,
  1044. 'cv_id' => array(
  1045. 'name' => $cvname
  1046. ),
  1047. ),
  1048. 'feature_id' => $feature_id,
  1049. 'pub_id' => 1,
  1050. );
  1051. $options = array('statement_name' => 'sel_featuredcvterm_cvfepu');
  1052. $xref = tripal_core_chado_select('feature_cvterm', array('feature_cvterm_id'), $values, $options);
  1053. if (count($xref) == 0) {
  1054. // if the record doesn't exist then add it.
  1055. $options = array('statement_name' => 'ins_featurecvterm_cvfepu');
  1056. $success = tripal_core_chado_insert('feature_cvterm', $values, $options);
  1057. if (!$success) {
  1058. watchdog('tripal_feature', 'tripal_feature_add_cvterm: The feature cvterm entry for feature, %feature_id, '.
  1059. 'could not be added: %cvterm.', array('%feature_id' => $feature_id, '%cvterm' => $cvterm), WATCHDOG_WARNING);
  1060. return FALSE;
  1061. }
  1062. }
  1063. return TRUE;
  1064. }

Related topics