Java RDFHandlerException类代码示例

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Test
public final void exportEmptyStore()
        throws RDF4JException
{
    IRI dirgraph = conn.getValueFactory().createIRI("http://marklogic.com/dirgraph");

    Assert.assertEquals(0L, conn.size());
    conn.exportStatements(null, null, null, false, new RDFHandlerBase() {

        @Override
        public void handleStatement(Statement st1)
                throws RDFHandlerException {
            Assert.assertNull(st1);
        }

    }, dirgraph);
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Test
public void testAddDelete() throws org.eclipse.rdf4j.RDF4JException {
	final Statement st1 = vf.createStatement(john, fname, johnfname);
	try {
		testWriterCon.begin();
		testWriterCon.add(st1);
		testWriterCon.prepareUpdate(QueryLanguage.SPARQL, "DELETE DATA {<" + john.stringValue() + "> <"
				+ fname.stringValue() + "> \"" + johnfname.stringValue() + "\"}").execute();
		testWriterCon.commit();
	} catch (Exception e) {
		logger.debug(e.getMessage());
	} finally {
		if (testWriterCon.isActive())
			testWriterCon.rollback();
	}
	testWriterCon.exportStatements(null, null, null, false, new AbstractRDFHandler() {

		@Override
		public void handleStatement(Statement st) throws RDFHandlerException {
			assertThat(st, is(not(equalTo(st1))));
		}
	});
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Override
public void writeGraphQueryResult(GraphQueryResult queryResult) throws ExportException {
    try {
        writer.startRDF();
        for (Map.Entry<String, String> me : queryResult.getNamespaces().entrySet()) {
            writer.handleNamespace(me.getKey(), me.getValue());
        }
        while (queryResult.hasNext()) {
            writer.handleStatement(queryResult.next());
            tick();
        }
        writer.endRDF();
    } catch (QueryEvaluationException | RDFHandlerException e) {
        throw new ExportException(e);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
private static int getTriplesCount(String uri, String compression, RDFFormat format) throws Exception {
    InputStream in = FileSystem.get(URI.create(uri), HBaseServerTestInstance.getInstanceConfig()).open(new Path(uri));
    try {
        if (compression != null) {
            in = new CompressorStreamFactory().createCompressorInputStream(compression, in);
        }
        RDFParser parser = Rio.createParser(format);
        final AtomicInteger i = new AtomicInteger();
        parser.setRDFHandler(new AbstractRDFHandler(){
            @Override
            public void handleStatement(Statement st) throws RDFHandlerException {
                i.incrementAndGet();
            }
        });
        parser.parse(in, uri);
        return i.get();
    } finally {
        in.close();
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
/**
 * Convert Metadata object to RDF string
 *
 * @param <T>
 * @param metadata Subclass of metadata object
 * @param format RDF format
 * @return RDF string
 * @throws MetadataException
 */
public static <T extends Metadata> String getString(@Nonnull T metadata,
        @Nonnull RDFFormat format)
        throws MetadataException {
    Preconditions.checkNotNull(metadata,
            "Metadata object must not be null.");
    Preconditions.checkNotNull(format, "RDF format must not be null.");
    
    StringWriter sw = new StringWriter();
    RDFWriter writer = Rio.createWriter(format, sw);
    List<Statement> statement = getStatements(metadata);
    try {
        propagateToHandler(statement, writer);
    } catch (RepositoryException | RDFHandlerException ex) {
        LOGGER.error("Error reading RDF statements");
        throw (new MetadataException(ex.getMessage()));
    }
    return sw.toString();
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
private static void propagateToHandler(List<Statement> statements,
        RDFHandler handler)
        throws RDFHandlerException, RepositoryException {
    handler.startRDF();
    handler.handleNamespace(RDF.PREFIX, RDF.NAMESPACE);
    handler.handleNamespace(RDFS.PREFIX, RDFS.NAMESPACE);
    handler.handleNamespace(DCAT.PREFIX, DCAT.NAMESPACE);
    handler.handleNamespace(XMLSchema.PREFIX, XMLSchema.NAMESPACE);
    handler.handleNamespace(OWL.PREFIX, OWL.NAMESPACE);
    handler.handleNamespace(DCTERMS.PREFIX, DCTERMS.NAMESPACE);
    handler.handleNamespace(FDP.PREFIX, FDP.NAMESPACE);
    handler.handleNamespace(R3D.PREFIX, R3D.NAMESPACE);
    handler.handleNamespace("lang",
            "http://id.loc.gov/vocabulary/iso639-1/");
    for (Statement st : statements) {
        handler.handleStatement(st);
    }
    handler.endRDF();
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
private void triple(String s, String p, String o, String graph) {
    if (s == null || p == null || o == null) {
        // TODO: i don't know what to do here!!!!
        return;
    }

    Statement result;
    // This method is always called with three Resources as subject
    // predicate and object
    if (graph == null) {
        result = vf.createStatement(createResource(s), vf.createIRI(p), createResource(o));
    } else {
        result = vf.createStatement(createResource(s), vf.createIRI(p), createResource(o),
                createResource(graph));
    }

    if (handler != null) {
        try {
            handler.handleStatement(result);
        } catch (final RDFHandlerException e) {
            throw new RuntimeException(e);
        }
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Override
public void handleStatement(final org.eclipse.rdf4j.model.Statement st)
        throws org.eclipse.rdf4j.rio.RDFHandlerException {
    // TODO: if getRdfTermFactory() is a non-rdf4j factory, should
    // we use factory.createQuad() instead?
    // Unsure what is the promise of setting getRdfTermFactory() --
    // does it go all the way down to creating BlankNode, IRI and
    // Literal?
    quadTarget.accept(rdf4jTermFactory.asQuad(st));
    // Performance note:
    // Graph/Quad.add should pick up again our
    // RDF4JGraphLike.asStatement()
    // and avoid double conversion.
    // Additionally the RDF4JQuad and RDF4JTriple implementations
    // are lazily converting subj/obj/pred/graph.s
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@PostConstruct
public void startUp() throws IOException, RDFParseException, RDFHandlerException  {
    if(this.sparqlSamplesFile!=null){
        HashMapHandler handler = new HashMapHandler();
        RDFParser parser = Rio.createParser(RDFFormat.TURTLE);
        parser.setRDFHandler(handler);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(this.sparqlSamplesFile);
            parser.parse(fis, "");
            this.samplesData = handler.getSamplesData();
        } finally {
            if(fis!=null){
                fis.close();
            }
        }            
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Override
public void endRDF() throws RDFHandlerException {
    if (transactionOpen) {
        try {
            con.commit();
        } catch (RepositoryException e) {
            try {
                con.rollback();
            } catch (RepositoryException e1) {
                throw new RDFHandlerException(e1);
            }
            throw new RDFHandlerException(e);
        }
    }
    super.endRDF();
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Override
public void handleStatement(Statement st) throws RDFHandlerException {
  try {
    if (Thread.currentThread().isInterrupted()) {
      rdfProcessor.commit();
      throw new RDFHandlerException("Interrupted");
    }
    String graph = st.getContext() == null ? defaultGraph : st.getContext().stringValue();
    rdfProcessor.onQuad(
      isAssertion(),
      handleNode(st.getSubject()),
      st.getPredicate().stringValue(),
      handleNode(st.getObject()),
      (st.getObject() instanceof Literal) ? ((Literal) st.getObject()).getDatatype().toString() : null,
      (st.getObject() instanceof Literal) ? ((Literal) st.getObject()).getLanguage().orElse(null) : null,
      graph
    );
  } catch (RdfProcessingFailedException e) {
    throw new RDFHandlerException(e);
  }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
public void handleNamespace(final String prefix,
                            final String uri) throws RDFHandlerException {
    try {
        c.setNamespace(prefix, uri);
    } catch (SailException e) {
        throw new RDFHandlerException(e);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
public void handleStatement(final Statement s) throws RDFHandlerException {
    try {
        if (1 <= contexts.length) {
            for (Resource x : contexts) {
                c.addStatement(s.getSubject(), s.getPredicate(), s.getObject(), x);
            }
        } else {
            c.addStatement(s.getSubject(), s.getPredicate(), s.getObject(), s.getContext());
        }
    } catch (SailException e) {
        throw new RDFHandlerException(e);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
/**
 * evaluate graph query with RDFHandler
 *
 * @param resultHandler
 * @throws QueryEvaluationException
 * @throws RDFHandlerException
 */
@Override
public void evaluate(RDFHandler resultHandler) throws QueryEvaluationException, RDFHandlerException {
    GraphQueryResult queryResult = evaluate();
    if(queryResult.hasNext())
    {
        QueryResults.report(queryResult, resultHandler);
    }
}
 

import org.eclipse.rdf4j.rio.RDFHandlerException; //导入依赖的package包/类
@Test
public void testExportStatementsWithMultipleContexts() throws Exception
{
    ValueFactory f = conn.getValueFactory();

    Resource context9 = conn.getValueFactory().createIRI("http://marklogic.com/test/context9");
    final IRI alice = f.createIRI("http://example.org/people/alice");
    IRI name = f.createIRI("http://example.org/ontology/name");
    Literal alicesName = f.createLiteral("Alice");

    Statement st1 = f.createStatement(alice, name, alicesName);
    conn.add(st1, context9);

    Resource context10 = conn.getValueFactory().createIRI("http://marklogic.com/test/context10");
    final IRI mark = f.createIRI("http://example.org/people/mark");
    Literal marksName = f.createLiteral("Mark");

    Statement st2 = f.createStatement(mark, name, marksName);
    conn.add(st2, context10);

    List<String> expected = new ArrayList<>(Arrays.asList(alice.stringValue(), name.stringValue(), alicesName.stringValue(), context9.stringValue(),
            mark.stringValue(), name.stringValue(), marksName.stringValue(), context10.stringValue()));

    List<String> out = new ArrayList<>();
    conn.exportStatements(null, null, null, true, new AbstractRDFHandler() {
        @Override
        public void handleStatement(Statement st) throws RDFHandlerException {
            out.add(st.getSubject().stringValue());
            out.add(st.getPredicate().stringValue());
            out.add(st.getObject().stringValue());
            out.add(st.getContext().stringValue());
        }
    }, context9, context10);

    Assert.assertEquals(expected.size(), out.size());
    conn.clear(context9);
    conn.clear(context10);
}