Merge pull request #9 from ginkgobioworks/refactor-block-splitting

Refactor some models

src/main.rs

@@ -7,7 +7,7 @@ use std::path::PathBuf;
 use bio::io::fasta;
 use gen::get_connection;
 use gen::migrations::run_migrations;
-use gen::models::{self, Block, BlockGroup, Sequence};
+use gen::models::{self, block::Block, edge::Edge, sequence::Sequence, BlockGroup};
 use noodles::vcf;
 use noodles::vcf::variant::record::samples::series::value::genotype::Phasing;
 use noodles::vcf::variant::record::samples::series::Value;
@@ -69,7 +69,7 @@ fn import_fasta(fasta: &String, name: &String, shallow: bool, conn: &mut Connect
         for result in reader.records() {
             let record = result.expect("Error during fasta record parsing");
             let sequence = String::from_utf8(record.seq().to_vec()).unwrap();
-            let seq_hash = models::Sequence::create(conn, "DNA".to_string(), &sequence, !shallow);
+            let seq_hash = Sequence::create(conn, "DNA".to_string(), &sequence, !shallow);
             let block_group =
                 BlockGroup::create(conn, &collection.name, None, &record.id().to_string());
             let block = Block::create(
@@ -80,7 +80,7 @@ fn import_fasta(fasta: &String, name: &String, shallow: bool, conn: &mut Connect
                 (sequence.len() as i32),
                 &"1".to_string(),
             );
-            let edge = models::Edge::create(conn, block.id, None, 0, 0);
+            let edge = Edge::create(conn, block.id, None, 0, 0);
         }
         println!("Created it");
     } else {

src/models.rs

@@ -3,9 +3,13 @@ use std::collections::HashMap;
 use std::fmt::*;
 
 use rusqlite::{params_from_iter, Connection};
-use sha2::{Digest, Sha256};
 
+pub mod block;
+pub mod edge;
+pub mod sequence;
 use crate::models;
+use crate::models::block::Block;
+use crate::models::edge::Edge;
 
 #[derive(Debug)]
 pub struct Collection {
@@ -62,184 +66,6 @@ impl Sample {
     }
 }
 
-#[derive(Debug)]
-pub struct Sequence {
-    pub hash: String,
-    pub sequence_type: String,
-    pub sequence: String,
-    pub length: i32,
-}
-
-impl Sequence {
-    pub fn create(
-        conn: &mut Connection,
-        sequence_type: String,
-        sequence: &String,
-        store: bool,
-    ) -> String {
-        let mut hasher = Sha256::new();
-        hasher.update(&sequence_type);
-        hasher.update(sequence);
-        let hash = format!("{:x}", hasher.finalize());
-        let mut obj_hash: String = match conn.query_row(
-            "SELECT hash from sequence where hash = ?1;",
-            [hash.clone()],
-            |row| row.get(0),
-        ) {
-            Ok(res) => res,
-            Err(rusqlite::Error::QueryReturnedNoRows) => "".to_string(),
-            Err(_e) => {
-                panic!("something bad happened querying the database")
-            }
-        };
-        if obj_hash.is_empty() {
-            let mut stmt = conn.prepare("INSERT INTO sequence (hash, sequence_type, sequence, length) VALUES (?1, ?2, ?3, ?4) RETURNING (hash);").unwrap();
-            let mut rows = stmt
-                .query_map(
-                    (
-                        hash,
-                        sequence_type,
-                        if store { sequence } else { "" },
-                        sequence.len(),
-                    ),
-                    |row| row.get(0),
-                )
-                .unwrap();
-            obj_hash = rows.next().unwrap().unwrap();
-        }
-        obj_hash
-    }
-}
-
-#[derive(Debug)]
-pub struct Block {
-    pub id: i32,
-    pub sequence_hash: String,
-    pub block_group_id: i32,
-    pub start: i32,
-    pub end: i32,
-    pub strand: String,
-}
-
-impl Block {
-    pub fn create(
-        conn: &Connection,
-        hash: &String,
-        block_group_id: i32,
-        start: i32,
-        end: i32,
-        strand: &String,
-    ) -> Block {
-        let mut stmt = conn
-            .prepare_cached("INSERT INTO block (sequence_hash, block_group_id, start, end, strand) VALUES (?1, ?2, ?3, ?4, ?5) RETURNING *")
-            .unwrap();
-        match stmt.query_row((hash, block_group_id, start, end, strand), |row| {
-            Ok(Block {
-                id: row.get(0)?,
-                sequence_hash: row.get(1)?,
-                block_group_id: row.get(2)?,
-                start: row.get(3)?,
-                end: row.get(4)?,
-                strand: row.get(5)?,
-            })
-        }) {
-            Ok(res) => res,
-            Err(rusqlite::Error::SqliteFailure(err, details)) => {
-                if err.code == rusqlite::ErrorCode::ConstraintViolation {
-                    // println!("{err:?} {details:?}");
-                    Block {
-                        id: conn
-                            .query_row(
-                                "select id from block where sequence_hash = ?1 AND block_group_id = ?2 AND start = ?3 AND end = ?4 AND strand = ?5;",
-                                (hash, block_group_id, start, end, strand),
-                                |row| row.get(0),
-                            )
-                            .unwrap(),
-                        sequence_hash: hash.clone(),
-                        block_group_id,
-                        start,
-                        end,
-                        strand: strand.clone(),
-                    }
-                } else {
-                    panic!("something bad happened querying the database")
-                }
-            }
-            Err(_e) => {
-                panic!("failure in making block {_e}")
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Edge {
-    pub id: i32,
-    pub source_id: i32,
-    pub target_id: Option<i32>,
-    pub chromosome_index: i32,
-    pub phased: i32,
-}
-
-impl Edge {
-    pub fn create(
-        conn: &Connection,
-        source_id: i32,
-        target_id: Option<i32>,
-        chromosome_index: i32,
-        phased: i32,
-    ) -> Edge {
-        let mut query;
-        let mut id_query;
-        let mut placeholders = vec![];
-        if target_id.is_some() {
-            query = "INSERT INTO edges (source_id, target_id, chromosome_index, phased) VALUES (?1, ?2, ?3, ?4) RETURNING *";
-            id_query = "select id from edges where source_id = ?1 and target_id = ?2";
-            placeholders.push(source_id);
-            placeholders.push(target_id.unwrap());
-            placeholders.push(chromosome_index);
-            placeholders.push(phased);
-        } else {
-            id_query = "select id from edges where source_id = ?1 and target_id is null and chromosome_index = ?2 and phased = ?3";
-            query = "INSERT INTO edges (source_id, chromosome_index, phased) VALUES (?1, ?2, ?3) RETURNING *";
-            placeholders.push(source_id);
-            placeholders.push(chromosome_index);
-            placeholders.push(phased);
-        }
-        let mut stmt = conn.prepare(query).unwrap();
-        match stmt.query_row(params_from_iter(&placeholders), |row| {
-            Ok(Edge {
-                id: row.get(0)?,
-                source_id: row.get(1)?,
-                target_id: row.get(2)?,
-                chromosome_index: row.get(3)?,
-                phased: row.get(4)?,
-            })
-        }) {
-            Ok(edge) => edge,
-            Err(rusqlite::Error::SqliteFailure(err, details)) => {
-                if err.code == rusqlite::ErrorCode::ConstraintViolation {
-                    println!("{err:?} {details:?}");
-                    Edge {
-                        id: conn
-                            .query_row(id_query, params_from_iter(&placeholders), |row| row.get(0))
-                            .unwrap(),
-                        source_id,
-                        target_id,
-                        chromosome_index,
-                        phased,
-                    }
-                } else {
-                    panic!("something bad happened querying the database")
-                }
-            }
-            Err(_) => {
-                panic!("something bad happened querying the database")
-            }
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct Path {
     pub id: i32,

src/models/block.rs

@@ -0,0 +1,61 @@
+use rusqlite::Connection;
+
+#[derive(Debug)]
+pub struct Block {
+    pub id: i32,
+    pub sequence_hash: String,
+    pub block_group_id: i32,
+    pub start: i32,
+    pub end: i32,
+    pub strand: String,
+}
+
+impl Block {
+    pub fn create(
+        conn: &Connection,
+        hash: &String,
+        block_group_id: i32,
+        start: i32,
+        end: i32,
+        strand: &String,
+    ) -> Block {
+        let mut stmt = conn
+            .prepare_cached("INSERT INTO block (sequence_hash, block_group_id, start, end, strand) VALUES (?1, ?2, ?3, ?4, ?5) RETURNING *")
+            .unwrap();
+        match stmt.query_row((hash, block_group_id, start, end, strand), |row| {
+            Ok(Block {
+                id: row.get(0)?,
+                sequence_hash: row.get(1)?,
+                block_group_id: row.get(2)?,
+                start: row.get(3)?,
+                end: row.get(4)?,
+                strand: row.get(5)?,
+            })
+        }) {
+            Ok(res) => res,
+            Err(rusqlite::Error::SqliteFailure(err, _details)) => {
+                if err.code == rusqlite::ErrorCode::ConstraintViolation {
+                    Block {
+                        id: conn
+                            .query_row(
+                                "select id from block where sequence_hash = ?1 AND block_group_id = ?2 AND start = ?3 AND end = ?4 AND strand = ?5;",
+                                (hash, block_group_id, start, end, strand),
+                                |row| row.get(0),
+                            )
+                            .unwrap(),
+                        sequence_hash: hash.clone(),
+                        block_group_id,
+                        start,
+                        end,
+                        strand: strand.clone(),
+                    }
+                } else {
+                    panic!("something bad happened querying the database")
+                }
+            }
+            Err(_e) => {
+                panic!("failure in making block {_e}")
+            }
+        }
+    }
+}

src/models/edge.rs

@@ -0,0 +1,69 @@
+use rusqlite::{params_from_iter, Connection};
+
+#[derive(Debug)]
+pub struct Edge {
+    pub id: i32,
+    pub source_id: i32,
+    pub target_id: Option<i32>,
+    pub chromosome_index: i32,
+    pub phased: i32,
+}
+
+impl Edge {
+    pub fn create(
+        conn: &Connection,
+        source_id: i32,
+        target_id: Option<i32>,
+        chromosome_index: i32,
+        phased: i32,
+    ) -> Edge {
+        let query;
+        let id_query;
+        let mut placeholders = vec![];
+        if target_id.is_some() {
+            query = "INSERT INTO edges (source_id, target_id, chromosome_index, phased) VALUES (?1, ?2, ?3, ?4) RETURNING *";
+            id_query = "select id from edges where source_id = ?1 and target_id = ?2";
+            placeholders.push(source_id);
+            placeholders.push(target_id.unwrap());
+            placeholders.push(chromosome_index);
+            placeholders.push(phased);
+        } else {
+            id_query = "select id from edges where source_id = ?1 and target_id is null and chromosome_index = ?2 and phased = ?3";
+            query = "INSERT INTO edges (source_id, chromosome_index, phased) VALUES (?1, ?2, ?3) RETURNING *";
+            placeholders.push(source_id);
+            placeholders.push(chromosome_index);
+            placeholders.push(phased);
+        }
+        let mut stmt = conn.prepare(query).unwrap();
+        match stmt.query_row(params_from_iter(&placeholders), |row| {
+            Ok(Edge {
+                id: row.get(0)?,
+                source_id: row.get(1)?,
+                target_id: row.get(2)?,
+                chromosome_index: row.get(3)?,
+                phased: row.get(4)?,
+            })
+        }) {
+            Ok(edge) => edge,
+            Err(rusqlite::Error::SqliteFailure(err, details)) => {
+                if err.code == rusqlite::ErrorCode::ConstraintViolation {
+                    println!("{err:?} {details:?}");
+                    Edge {
+                        id: conn
+                            .query_row(id_query, params_from_iter(&placeholders), |row| row.get(0))
+                            .unwrap(),
+                        source_id,
+                        target_id,
+                        chromosome_index,
+                        phased,
+                    }
+                } else {
+                    panic!("something bad happened querying the database")
+                }
+            }
+            Err(_) => {
+                panic!("something bad happened querying the database")
+            }
+        }
+    }
+}