Cleanup

src/lib.rs

@@ -15,6 +15,13 @@ pub fn get_connection(db_path: &str) -> Connection {
     conn
 }
 
+pub fn run_query(conn: &Connection, query: &str) {
+    let mut stmt = conn.prepare(query).unwrap();
+    for entry in stmt.query_map([], |row| Ok(println!("{row:?}"))).unwrap() {
+        println!("{entry:?}");
+    }
+}
+
 pub fn calculate_hash(t: &str) -> String {
     let mut hasher = Sha256::new();
     hasher.update(t);

src/models.rs

@@ -202,22 +202,19 @@ impl BlockGroup {
 
             row = it.next().unwrap();
         }
-        println!("new edges {edge_map:?}");
 
         let existing_paths = Path::get_paths(
             conn,
             "SELECT * from path where block_group_id = ?1",
             vec![Value::from(source_block_group_id)],
         );
-        println!("eps {existing_paths:?}");
 
         for path in existing_paths {
             let mut new_edges = vec![];
             for edge in path.edges {
                 new_edges.push(*edge_map.get(&edge).unwrap());
             }
-            let new_p = Path::create(conn, &path.name, target_block_group_id, new_edges);
-            println!("made {new_p:?}");
+            Path::create(conn, &path.name, target_block_group_id, new_edges);
         }
     }
 
@@ -359,7 +356,6 @@ impl BlockGroup {
         // that means we have an edge with the chromosome index, that connects our start/end coordinates with the new block id
 
         let path = Path::get(conn, path_id);
-        let block_group_id = path.block_group_id;
         let graph = PathEdge::edges_to_graph(conn, path.id);
         println!("{path:?} {graph:?}");
         let query = format!("SELECT id, sequence_hash, block_group_id, start, end, strand from block where id in ({block_ids})", block_ids = graph.nodes().map(|k| format!("{k}")).collect::<Vec<_>>().join(","));
@@ -396,18 +392,12 @@ impl BlockGroup {
         let mut path_end = 0;
         let mut new_edges = vec![];
         let mut previous_block: Option<&Block> = None;
-        let mut next_node = dfs.next(&graph);
         println!("{blocks:?}");
-        while next_node.is_some() {
-            let nx = next_node.unwrap();
-            println!("nx is {nx}");
+        while let Some(nx) = dfs.next(&graph) {
             let block = blocks.get(&(nx as i32)).unwrap();
             let block_length = (block.end - block.start);
             path_end += block_length;
 
-            // do stuff here
-            println!("{nx} {block:?} {start} {end} {path_start} {path_end}");
-
             let contains_start = path_start <= start && start < path_end;
             let contains_end = path_start <= end && end < path_end;
             let overlap = path_start <= end && start <= path_end;
@@ -501,7 +491,6 @@ impl BlockGroup {
                 break;
             }
             previous_block = Some(block);
-            next_node = dfs.next(&graph);
         }
 
         println!("change is {path:?} {graph:?} {blocks:?} {new_edges:?}");
@@ -510,52 +499,6 @@ impl BlockGroup {
             Edge::create(conn, new_edge.0, new_edge.1, chromosome_index, phased);
         }
     }
-
-    // TODO: move this to path, doesn't belong in block group
-    pub fn sequence(
-        conn: &mut Connection,
-        collection_name: &str,
-        sample_name: Option<&String>,
-        block_group_name: &str,
-    ) -> String {
-        struct SequenceBlock {
-            sequence: String,
-            strand: String,
-        }
-        let mut query;
-        let mut placeholders: Vec<rusqlite::types::Value> =
-            vec![collection_name.to_string().into()];
-
-        if sample_name.is_some() {
-            query = "WITH RECURSIVE traverse(block_id, block_sequence, block_start, block_end, block_strand, depth) AS (
-          SELECT edges.source_id, substr(seq.sequence, block.start + 1, block.end - block.start), block.start, block.end, block.strand, 0 as depth FROM block_group left join block on (block_group.id = block.block_group_id) left join sequence seq on (seq.hash = block.sequence_hash) left join edges on (block.id = edges.source_id or block.id = edges.target_id) WHERE block_group.collection_name = ?1 AND block_group.sample_name = ?2 AND block_group.name = ?3 and edges.target_id is null
-          UNION
-          SELECT e2.source_id, substr(seq2.sequence, b2.start + 1, b2.end - b2.start), b2.start, b2.end, b2.strand, depth + 1 FROM edges e2 left join block b2 on (b2.id = e2.source_id) left join sequence seq2 on (seq2.hash = b2.sequence_hash) JOIN traverse t2 ON e2.target_id = t2.block_id order by depth desc
-        ) SELECT block_sequence as sequence, block_strand as strand FROM traverse;";
-            placeholders.push(sample_name.unwrap().clone().into());
-        } else {
-            query = "WITH RECURSIVE traverse(block_id, block_sequence, block_start, block_end, block_strand, depth) AS (
-          SELECT edges.source_id, substr(seq.sequence, block.start + 1, block.end - block.start), block.start, block.end, block.strand, 0 as depth FROM block_group left join block on (block_group.id = block.block_group_id) left join sequence seq on (seq.hash = block.sequence_hash) left join edges on (block.id = edges.source_id or block.id = edges.target_id) WHERE block_group.collection_name = ?1 AND block_group.sample_name is null AND block_group.name = ?2 and edges.target_id is null
-          UNION
-          SELECT e2.source_id, substr(seq2.sequence, b2.start + 1, b2.end - b2.start), b2.start, b2.end, b2.strand, depth + 1 FROM edges e2 left join block b2 on (b2.id = e2.source_id) left join sequence seq2 on (seq2.hash = b2.sequence_hash) JOIN traverse t2 ON e2.target_id = t2.block_id  order by depth desc
-        ) SELECT block_sequence as sequence, block_strand as strand FROM traverse;"
-        }
-        placeholders.push(block_group_name.to_string().into());
-        let mut stmt = conn.prepare(query).unwrap();
-        let mut blocks = stmt
-            .query_map(params_from_iter(placeholders), |row| {
-                Ok(SequenceBlock {
-                    sequence: row.get(0)?,
-                    strand: row.get(1)?,
-                })
-            })
-            .unwrap();
-        let mut sequence = "".to_string();
-        for block in blocks {
-            sequence.push_str(&block.unwrap().sequence);
-        }
-        sequence
-    }
 }
 
 #[cfg(test)]

src/models/path.rs

@@ -176,7 +176,6 @@ impl PathEdge {
         let mut graph = DiGraphMap::new();
         for edge in rows {
             let (source, target) = edge.unwrap();
-            println!("edg eis {source:?} {target:?}");
             if let Some(source_value) = source {
                 graph.add_node(source_value);
                 if let Some(target_value) = target {