Merge pull request #12 from ginkgobioworks/convert-path-edge-to-block

Convert path edges to path block

migrations/01-initial/up.sql

@@ -56,13 +56,13 @@ CREATE TABLE path (
 );
 CREATE UNIQUE INDEX path_uidx ON path(block_group_id, name);
 
-CREATE TABLE path_edges (
+CREATE TABLE path_blocks (
   id INTEGER PRIMARY KEY NOT NULL,
   path_id INTEGER NOT NULL,
-  source_edge_id INTEGER,
-  target_edge_id INTEGER,
-  FOREIGN KEY(source_edge_id) REFERENCES edges(id),
-  FOREIGN KEY(target_edge_id) REFERENCES edges(id),
+  source_block_id INTEGER,
+  target_block_id INTEGER,
+  FOREIGN KEY(source_block_id) REFERENCES block(id),
+  FOREIGN KEY(target_block_id) REFERENCES block(id),
   FOREIGN KEY(path_id) REFERENCES path(id)
 );
-CREATE UNIQUE INDEX path_edge_uidx ON path_edges(path_id, source_edge_id, target_edge_id);
+CREATE UNIQUE INDEX path_blocks_uidx ON path_blocks(path_id, source_block_id, target_block_id);

src/main.rs

@@ -80,14 +80,9 @@ fn import_fasta(fasta: &String, name: &String, shallow: bool, conn: &mut Connect
                 (sequence.len() as i32),
                 &"1".to_string(),
             );
-            let edge_1 = Edge::create(conn, None, Some(block.id), 0, 0);
-            let edge_2 = Edge::create(conn, Some(block.id), None, 0, 0);
-            Path::create(
-                conn,
-                record.id(),
-                block_group.id,
-                vec![edge_1.id, edge_2.id],
-            );
+            Edge::create(conn, None, Some(block.id), 0, 0);
+            Edge::create(conn, Some(block.id), None, 0, 0);
+            Path::create(conn, record.id(), block_group.id, vec![block.id]);
         }
         println!("Created it");
     } else {

src/models.rs

@@ -17,7 +17,7 @@ pub mod sequence;
 use crate::models;
 use crate::models::block::Block;
 use crate::models::edge::Edge;
-use crate::models::path::{all_simple_paths, Path, PathEdge};
+use crate::models::path::{all_simple_paths, Path, PathBlock};
 use crate::models::sequence::Sequence;
 
 #[derive(Debug)]
@@ -158,10 +158,8 @@ impl BlockGroup {
             .join(", ");
         let mut it = stmt.query([block_keys]).unwrap();
         let mut row = it.next().unwrap();
-        let mut edge_map = HashMap::new();
         while row.is_some() {
             let edge = row.unwrap();
-            let edge_id: i32 = edge.get(0).unwrap();
             let source_id: Option<i32> = edge.get(1).unwrap();
             let target_id: Option<i32> = edge.get(2).unwrap();
             let chrom_index = edge.get(3).unwrap();
@@ -198,7 +196,6 @@ impl BlockGroup {
             } else {
                 panic!("no source and target specified.");
             }
-            edge_map.insert(edge_id, new_edge.id);
 
             row = it.next().unwrap();
         }
@@ -210,11 +207,11 @@ impl BlockGroup {
         );
 
         for path in existing_paths {
-            let mut new_edges = vec![];
-            for edge in path.edges {
-                new_edges.push(*edge_map.get(&edge).unwrap());
+            let mut new_blocks = vec![];
+            for block in path.blocks {
+                new_blocks.push(*block_map.get(&block).unwrap());
             }
-            Path::create(conn, &path.name, target_block_group_id, new_edges);
+            Path::create(conn, &path.name, target_block_group_id, new_blocks);
         }
     }
 
@@ -356,7 +353,7 @@ 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 graph = PathEdge::edges_to_graph(conn, path.id);
+        let graph = PathBlock::blocks_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(","));
         let mut stmt = conn.prepare(&query).unwrap();
@@ -380,21 +377,12 @@ impl BlockGroup {
             row = it.next().unwrap();
         }
         // TODO: probably don't need the graph, just get vector of source_ids.
-        let mut start_node = -1;
-        let start_edge = Edge::get(conn, path.edges[0]);
-        if let Some(value) = start_edge.source_id {
-            start_node = value
-        } else if let Some(value) = start_edge.target_id {
-            start_node = value
-        }
-        let mut dfs = Dfs::new(&graph, start_node as u32);
         let mut path_start = 0;
         let mut path_end = 0;
         let mut new_edges = vec![];
         let mut previous_block: Option<&Block> = None;
-        println!("{blocks:?}");
-        while let Some(nx) = dfs.next(&graph) {
-            let block = blocks.get(&(nx as i32)).unwrap();
+        for block_id in &path.blocks {
+            let block = blocks.get(block_id).unwrap();
             let block_length = (block.end - block.start);
             path_end += block_length;
 
@@ -406,9 +394,14 @@ impl BlockGroup {
                 // our range is fully contained w/in the block
                 //      |----block------|
                 //        |----range---|
-                let (left_block, right_block) =
-                    Block::split(conn, block, start - path_start, chromosome_index, phased)
-                        .unwrap();
+                let (left_block, right_block) = Block::split(
+                    conn,
+                    block,
+                    block.start + start - path_start,
+                    chromosome_index,
+                    phased,
+                )
+                .unwrap();
                 Block::delete(conn, block.id);
                 // let left_block = Block::create(
                 //     conn,
@@ -435,9 +428,14 @@ impl BlockGroup {
                 // our range is overlapping the end of the block
                 // |----block---|
                 //        |----range---|
-                let (left_block, right_block) =
-                    Block::split(conn, block, start - path_start, chromosome_index, phased)
-                        .unwrap();
+                let (left_block, right_block) = Block::split(
+                    conn,
+                    block,
+                    block.start + start - path_start,
+                    chromosome_index,
+                    phased,
+                )
+                .unwrap();
                 Block::delete(conn, block.id);
                 // let left_block = Block::create(
                 //     conn,
@@ -457,8 +455,14 @@ impl BlockGroup {
                 // our range is overlapping the beginning of the block
                 //              |----block---|
                 //        |----range---|
-                let (left_block, right_block) =
-                    Block::split(conn, block, end - path_start, chromosome_index, phased).unwrap();
+                let (left_block, right_block) = Block::split(
+                    conn,
+                    block,
+                    block.start + end - path_start,
+                    chromosome_index,
+                    phased,
+                )
+                .unwrap();
                 Block::delete(conn, block.id);
                 // let right_block = Block::create(
                 //     conn,
@@ -493,8 +497,6 @@ impl BlockGroup {
             previous_block = Some(block);
         }
 
-        println!("change is {path:?} {graph:?} {blocks:?} {new_edges:?}");
-
         for new_edge in new_edges {
             Edge::create(conn, new_edge.0, new_edge.1, chromosome_index, phased);
         }
@@ -536,7 +538,7 @@ mod tests {
             conn,
             "chr1",
             block_group.id,
-            vec![edge_0.id, edge_1.id, edge_2.id, edge_3.id, edge_4.id],
+            vec![a_block.id, t_block.id, c_block.id, g_block.id],
         );
         (block_group.id, path.id)
     }
@@ -587,7 +589,8 @@ mod tests {
             HashSet::from_iter(vec![
                 "AAAAAAAAAATTTTTTTTTTCCCCCCCCCCGGGGGGGGGG".to_string(),
                 "AAAAAAANNNNTTTTTCCCCCCCCCCGGGGGGGGGG".to_string(),
-                "AAAAAAAAAATTTTTTTTTGGGGGGGGG".to_string()
+                "AAAAAAAAAATTTTTTTTTGGGGGGGGG".to_string(),
+                "AAAAAAANNNNTTTTGGGGGGGGG".to_string(),
             ])
         )
     }

src/models/block.rs

@@ -2,6 +2,7 @@ use crate::models::Path;
 use rusqlite::{params_from_iter, types::Value, Connection};
 
 use crate::models::edge::{Edge, UpdatedEdge};
+use crate::models::path::PathBlock;
 
 #[derive(Debug)]
 pub struct Block {
@@ -131,7 +132,12 @@ impl Block {
         phased: i32,
     ) -> Option<(Block, Block)> {
         if coordinate < block.start || coordinate >= block.end {
-            println!("Coordinate is out of block bounds");
+            println!(
+                "Coordinate {coordinate} is out of block {block_id} bounds ({start}, {end})",
+                start = block.start,
+                end = block.end,
+                block_id = block.id
+            );
             return None;
         }
         let new_left_block = Block::create(
@@ -183,6 +189,41 @@ impl Block {
 
         Edge::bulk_update(conn, replacement_edges);
 
+        // replace paths using this block
+        let impacted_path_blocks = PathBlock::query(
+            conn,
+            "select * from path_blocks where source_block_id = ?1 OR target_block_id = ?1",
+            vec![Value::from(block.id)],
+        );
+
+        for path_block in impacted_path_blocks {
+            let path_id = path_block.path_id;
+            PathBlock::create(
+                conn,
+                path_id,
+                Some(new_left_block.id),
+                Some(new_right_block.id),
+            );
+            if let Some(source_block_id) = path_block.source_block_id {
+                if source_block_id == block.id {
+                    PathBlock::update(
+                        conn,
+                        "update path_blocks set source_block_id = ?2 where id = ?1",
+                        vec![Value::from(path_block.id), Value::from(new_right_block.id)],
+                    );
+                }
+            }
+            if let Some(target_block_id) = path_block.target_block_id {
+                if target_block_id == block.id {
+                    PathBlock::update(
+                        conn,
+                        "update path_blocks set target_block_id = ?2 where id = ?1",
+                        vec![Value::from(path_block.id), Value::from(new_left_block.id)],
+                    );
+                }
+            }
+        }
+
         // TODO: Delete existing block? -- leave to caller atm
 
         Some((new_left_block, new_right_block))