How to use

UpdateDataDelete

in

org.apache.jena.sparql.modify.request

  @Override
  public QuadDataAccSink createDeleteDataSink()
  {
    QuadDataAcc quads = new QuadDataAcc();
    send(new UpdateDataDelete(quads));
    
    return quads;
  }
}

public static UpdateDataDelete clone(UpdateDataDelete update) {
  UpdateDataDelete result = new UpdateDataDelete(new QuadDataAcc(update.getQuads()));
  return result;
}

@Override
public void visit(UpdateDataDelete update) {
  for ( Quad quad : update.getQuads() )
    deleteFromDatasetGraph(datasetGraph, quad);
}

@SuppressWarnings("unused")
private void _update(UpdateDataDelete update)
{
  delete(update.getQuads());
}

public static UpdateRequest createUpdateRequest(Iterator<? extends Quad> added, Iterator<? extends Quad> removed) {
  UpdateRequest result = new UpdateRequest();
  if(added != null && added.hasNext()) {
    QuadDataAcc insertQuads = new QuadDataAcc(Lists.newArrayList(added));
    UpdateData insertData = new UpdateDataInsert(insertQuads);
    result.add(insertData);
  }
  if(removed != null && removed.hasNext()) {
    QuadDataAcc deleteQuads = new QuadDataAcc(Lists.newArrayList(removed));
    UpdateData deleteData = new UpdateDataDelete(deleteQuads);
    result.add(deleteData);
  }
  return result;
}

public static Iterator<Diff<Set<Quad>>> createIteratorDiff(QueryExecutionFactory qef, UpdateDataDelete update)
{
  Diff<Set<Quad>> diff = new Diff<Set<Quad>>(Sets.<Quad>newHashSet(), Sets.newHashSet(update.getQuads()), null);
  Iterator<Diff<Set<Quad>>> result = Collections.singleton(diff).iterator();
  return result;
}

private Update buildNoWhere() {
  if (inserts.isEmpty()) {
    QuadDataAcc quadData = new QuadDataAcc(getQuads(deletes).mapWith(new Function<Quad, Quad>() {
      @Override
      public Quad apply(Quad arg0) {
        return check(arg0);
      }
    }).toList());
    return new UpdateDataDelete(quadData);
  }
  if (deletes.isEmpty()) {
    QuadDataAcc quadData = new QuadDataAcc(getQuads(inserts).mapWith(new Function<Quad, Quad>() {
      @Override
      public Quad apply(Quad t) {
        return check(t);
      }
    }).toList());
    return new UpdateDataInsert(quadData);
  }
  throw new IllegalStateException("Can not have both insert and delete without a where clause");
}

@Override
public void visit(UpdateDataDelete update)
{
  Iter.sendToSink(update.getQuads(), createDeleteDataSink()); // Iter.sendToSink() will call close() on the sink
}

private Update buildNoWhere() {
  if (inserts.isEmpty()) {
    QuadDataAcc quadData = new QuadDataAcc(getQuads(deletes).mapWith(new Function<Quad, Quad>() {
      @Override
      public Quad apply(Quad arg0) {
        return check(arg0);
      }
    }).toList());
    return new UpdateDataDelete(quadData);
  }
  if (deletes.isEmpty()) {
    QuadDataAcc quadData = new QuadDataAcc(getQuads(inserts).mapWith(new Function<Quad, Quad>() {
      @Override
      public Quad apply(Quad t) {
        return check(t);
      }
    }).toList());
    return new UpdateDataInsert(quadData);
  }
  throw new IllegalStateException("Can not have both insert and delete without a where clause");
}

@Test public void testDelete3()
{
  DatasetGraph gStore = getEmptyDatasetGraph() ;
  defaultGraphData(gStore, graph1) ;
  QuadDataAcc acc = new QuadDataAcc() ;
  UpdateDataDelete delete = new UpdateDataDelete(acc) ;
  acc.addTriple(triple1) ;
  UpdateAction.execute(delete, gStore) ;
  assertTrue(graphEmpty(gStore.getDefaultGraph())) ;
}

@Test public void testDeleteData2()
{
  DatasetGraph gStore = getEmptyDatasetGraph() ;
  defaultGraphData(gStore, graph1) ;
  QuadDataAcc acc = new QuadDataAcc() ;
  acc.addTriple(triple1) ;
  UpdateDataDelete delete = new UpdateDataDelete(acc) ;
  UpdateProcessor uProc = UpdateExecutionFactory.create(delete, gStore) ;
  uProc.execute(); 
  assertTrue(graphEmpty(gStore.getDefaultGraph())) ;
  assertFalse(graphContains(gStore.getDefaultGraph(), triple1)) ;
}

@Test public void testDelete4()
{
  DatasetGraph gStore = getEmptyDatasetGraph() ;
  namedGraphData(gStore, graphIRI, data1()) ;
  
  QuadDataAcc acc = new QuadDataAcc() ;
  UpdateDataDelete delete = new UpdateDataDelete(acc) ;
  acc.setGraph(graphIRI) ;
  acc.addTriple(triple1) ;
  UpdateAction.execute(delete, gStore) ;
  assertTrue(graphEmpty(gStore.getGraph(graphIRI))) ;
  assertTrue(graphEmpty(gStore.getDefaultGraph())) ;
}

@Test public void testDeleteData1()
{
  DatasetGraph gStore = getEmptyDatasetGraph() ;
  defaultGraphData(gStore, graph1) ;
  QuadDataAcc acc = new QuadDataAcc() ;
  acc.addTriple(triple2) ;
  UpdateDataDelete delete = new UpdateDataDelete(acc) ;
  UpdateProcessor uProc = UpdateExecutionFactory.create(delete, gStore) ;
  uProc.execute(); 
  assertFalse(graphEmpty(gStore.getDefaultGraph())) ;
  assertTrue(graphContains(gStore.getDefaultGraph(), triple1)) ;
  assertFalse(graphContains(gStore.getDefaultGraph(), triple2)) ;
}