execute::insert(deps, info, format.unwrap_or_default(), data)

ExecuteMsg::DeleteData {

prefixes,

delete,

r#where,

} => execute::delete(deps, info, prefixes, delete, r#where),

use crate::msg::{DataFormat, Prefix, SelectItem, TriplePattern, WhereClause};

use crate::querier::{PlanBuilder, QueryEngine};

use crate::rdf::{Atom, TripleReader};

use crate::storer::StoreEngine;

use std::collections::HashSet;

let mut storer = StoreEngine::new(deps.storage)?;

pub fn delete(

deps: DepsMut,

info: MessageInfo,

prefixes: Vec<Prefix>,

delete: Vec<TriplePattern>,

r#where: Option<WhereClause>,

) -> Result<Response, ContractError> {

verify_owner(&deps, &info)?;

let plan =

PlanBuilder::new(deps.storage, &prefixes).build_plan(&r#where.unwrap_or_default())?;

let variables = delete

.iter()

.fold(HashSet::new(), |mut acc, tp| {

acc.extend(tp.variables());

acc

})

.into_iter()

.map(SelectItem::Variable)

.collect();

let response = QueryEngine::new(deps.storage).select(plan, variables)?;

let atoms: Vec<Atom> = response

.results

.bindings

.iter()

.flat_map(|row| delete.iter().map(|pattern| pattern.resolve(row, &prefixes)))

.collect::<Result<Vec<_>, _>>()?;

let mut storer = StoreEngine::new(deps.storage)?;

let count = storer.delete_all(&atoms)?;

Ok(Response::new()

.add_attribute("action", "delete")

.add_attribute("triple_count", count))

}

QueryMsg::Describe { query, format } => {

to_binary(&query::describe(deps, query, format.unwrap_or_default())?)

}

use crate::storer::StoreEngine;

let mut storer = StoreEngine::new(storage).unwrap();