graphfusion 0.2.0

GraphFusion graph database.
Documentation
#![cfg(feature = "visualization")]
use graphfusion::{Database, OpenOptions, QueryResult, Session, StatementOutput};

async fn run(session: &mut Session, input: &str) -> QueryResult {
    match session.run(input).await.unwrap().pop().unwrap() {
        StatementOutput::Query(result) => result,
        _ => panic!("expected query"),
    }
}
fn setup(session: &mut Session) {
    session
        .execute("CREATE GRAPH g ANY; SESSION SET GRAPH g")
        .unwrap();
}

#[tokio::test]
async fn projects_returned_paths_and_edge_endpoints_from_the_result_snapshot() {
    let mut session = Database::new().session();
    setup(&mut session);
    run(&mut session, "INSERT (a:Person {name:'A'})-[e:Link {weight:3}]->(b:Person {name:'B'}), (b)-[:Link]->(c:Person {name:'C'})").await;
    let edge = run(&mut session, "MATCH (a {name:'A'})-[e]->(b) RETURN e").await;
    assert_eq!(edge.graph.nodes.len(), 2);
    assert_eq!(edge.graph.edges.len(), 1);
    assert_eq!(edge.graph.edges[0].properties["weight"], 3);
    assert!(edge
        .graph
        .nodes
        .iter()
        .any(|n| n.id == edge.graph.edges[0].source));
    let old = run(
        &mut session,
        "MATCH p = (a {name:'A'})-[:Link]->{2}(b) RETURN p",
    )
    .await;
    assert_eq!((old.graph.nodes.len(), old.graph.edges.len()), (3, 2));
    let updated = run(
        &mut session,
        "MATCH (a {name:'A'}) SET a.name='New' RETURN a",
    )
    .await;
    assert_eq!(updated.graph.nodes[0].properties["name"], "New");
    assert!(old.graph.nodes.iter().any(|n| n.properties["name"] == "A"));
    let deleted = run(&mut session, "MATCH (a {name:'New'}) DETACH DELETE a").await;
    assert!(deleted.graph.nodes.is_empty());
    let remaining = run(&mut session, "MATCH (a) RETURN a").await;
    assert_eq!(remaining.graph.nodes.len(), 2);
    assert!(!remaining
        .graph
        .nodes
        .iter()
        .any(|n| n.properties["name"] == "New"));
    let scalar = run(&mut session, "MATCH (a) RETURN a.name AS name").await;
    assert!(scalar.graph.nodes.is_empty());
}

#[tokio::test]
async fn same_element_ids_in_different_graphs_remain_distinct() {
    let mut session = Database::new().session();
    setup(&mut session);
    run(&mut session, "INSERT (:Person {name:'A'})").await;
    session
        .execute("CREATE GRAPH h ANY; SESSION SET GRAPH h")
        .unwrap();
    run(&mut session, "INSERT (:Person {name:'B'})").await;
    let result = run(
        &mut session,
        "USE g MATCH (n) RETURN n UNION ALL USE h MATCH (n) RETURN n",
    )
    .await;
    assert_eq!(result.graph.nodes.len(), 2);
    assert_ne!(result.graph.nodes[0].id, result.graph.nodes[1].id);
}

#[tokio::test]
async fn parquet_projection_uses_visible_selected_rows_and_exact_integer_ids() {
    use graphfusion::arrow::{
        array::{Int64Array, UInt64Array},
        datatypes::{DataType, Field, Schema},
        record_batch::RecordBatch,
    };
    use graphfusion::{
        graph::{GraphData, NodeTable, ID},
        visualization::cell,
    };
    use std::sync::Arc;
    let directory =
        std::env::temp_dir().join(format!("graphfusion-visualization-{}", std::process::id()));
    let db = Database::open(
        &directory,
        OpenOptions {
            create_if_missing: true,
        },
    )
    .unwrap();
    let mut session = db.session();
    setup(&mut session);
    let schema = Arc::new(Schema::new(vec![
        Field::new(ID, DataType::UInt64, false),
        Field::new("value", DataType::Int64, false),
    ]));
    let batch = RecordBatch::try_new(
        schema.clone(),
        vec![
            Arc::new(UInt64Array::from(vec![u64::MAX - 1, u64::MAX])),
            Arc::new(Int64Array::from(vec![i64::MAX, i64::MIN])),
        ],
    )
    .unwrap();
    session
        .replace_graph_data(
            GraphData::try_new(
                vec![NodeTable::try_new(vec!["Large".into()], schema, vec![batch]).unwrap()],
                vec![],
            )
            .unwrap(),
        )
        .unwrap();
    db.checkpoint().unwrap();
    let result = run(&mut session, "MATCH (n) RETURN n").await;
    assert_eq!(result.graph.nodes.len(), 2);
    assert!(result
        .graph
        .nodes
        .iter()
        .any(|n| n.id.ends_with(&u64::MAX.to_string())));
    let maximum = i64::MAX.to_string();
    assert!(result
        .graph
        .nodes
        .iter()
        .any(|n| n.properties["value"].as_str() == Some(maximum.as_str())));
    let array: graphfusion::arrow::array::ArrayRef = Arc::new(Int64Array::from(vec![42, i64::MIN]));
    assert_eq!(cell(&array, 0).unwrap(), 42);
    assert_eq!(cell(&array, 1).unwrap(), i64::MIN.to_string());
    drop(session);
    drop(db);
    std::fs::remove_dir_all(directory).unwrap();
}