Package org.openrdf.rio

Examples of org.openrdf.rio.RDFParser


    public static RDFFormat parse(final InputStream is,
                                  final RDFSink sink,
                                  final String baseUri,
                                  final RDFFormat format) throws RippleException {
        RDFParser parser = Rio.createParser(format);
        parser.setRDFHandler(new SesameInputAdapter(sink));

        try {
            parser.parse(is, baseUri);
        } catch (IOException e) {
            throw new RippleException(e);
        } catch (RDFParseException e) {
            throw new RippleException(e);
        } catch (RDFHandlerException e) {
View Full Code Here


    }

    private void add(final Sail sail, final InputStream is, final String baseUri, final RDFFormat format)
            throws Exception {

        RDFParser parser = Rio.createParser(format);
        SailConnection sc = sail.getConnection();
        try {
            sc.begin();

            SailInserter inserter = new SailInserter(sc);
            parser.setRDFHandler(inserter);

            inserter.startRDF();

            try {
                parser.parse(is, baseUri);
            } catch (Exception e) {
                inserter.endRDF();
                sc.close();
                throw e;
            }
View Full Code Here

                     final InputStream is,
                     final String baseUri,
                     final RDFFormat format,
                     final URI context) throws Exception {

        RDFParser parser = Rio.createParser(format);
        SailConnection sc = sail.getConnection();
        try {
            sc.begin();
            SailInserter inserter = new SailInserter(sc);
            SesameOutputAdapter outAdapter = new SesameOutputAdapter(inserter);
            RDFSink scp = new SingleContextPipe(outAdapter, context, sail.getValueFactory());
            SesameInputAdapter inAdapter = new SesameInputAdapter(scp);
            parser.setRDFHandler(inAdapter);

            inserter.startRDF();

            try {
                parser.parse(is, baseUri);
            } catch (Exception e) {
                inserter.endRDF();
                sc.close();
                throw e;
            }
View Full Code Here

                    try {
                        aConn = aRepository.getConnection();
                        aConn.begin();

                        for (String aFile : Splitter.on(',').omitEmptyStrings().trimResults().split(aFiles.toString())) {
                            RDFParser aParser = Rio.createParser(Rio.getParserFormatForFileName(aFile));

                            aParser.setRDFHandler(new RDFInserter(aConn));

                            if (NetUtils.isURL(aFile)) {
                                aParser.parse(new java.net.URL(aFile).openStream(), "");
                            }
                            else {
                                aParser.parse(new FileInputStream(aFile), "");
                            }
                        }

                        aConn.commit();
                    }
View Full Code Here

        rdfWriter.startRDF();
        rdfWriter.handleStatement(st1);
        rdfWriter.endRDF();

        ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        RDFParser rdfParser = rdfParserFactory.getParser();
        ParserConfig config = new ParserConfig();
        config.set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, true);
        config.set(BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES, true);
        rdfParser.setParserConfig(config);
        rdfParser.setValueFactory(vf);
        Model model = new LinkedHashModel();
        rdfParser.setRDFHandler(new StatementCollector(model));

        rdfParser.parse(in, "foo:bar");

        assertEquals("Unexpected number of statements, found " + model.size(), 1, model.size());

        assertTrue("missing namespaced statement", model.contains(st1));

        if (rdfParser.getRDFFormat().supportsNamespaces()) {
            assertTrue("Expected at least one namespace, found " + model.getNamespaces().size(),
                    model.getNamespaces().size() >= 1);
            assertEquals(exNs, model.getNamespace("ex").getName());
        }
    }
View Full Code Here

    sendDelayAdd();

    final boolean useStatementContext = (contexts != null && contexts.length == 0); // If no context are specified, each statement is added to statement context

    try {
      RDFParser parser = Rio.createParser(format, getValueFactory());
            parser.setParserConfig(getParserConfig());
            parser.setParseErrorListener(new ParseErrorLogger());

      // set up a handler for parsing the data from reader

      parser.setRDFHandler(new RDFHandlerBase() {
       
              Resource[] _contexts = checkDMLContext(contexts);

        public void startRDF() throws RDFHandlerException {
        }

        public void endRDF() throws RDFHandlerException {
          try {
            flushDelayAdd();
          }
          catch (RepositoryException e) {
            throw new RDFHandlerException("Problem executing query: ", e);
          }
        }

        public void handleNamespace(String prefix, String name) throws RDFHandlerException {
          String query = "DB.DBA.XML_SET_NS_DECL(?, ?, 1)";
          try {
            PreparedStatement psn = prepareStatement(query);
            psn.setString(1, prefix);
            psn.setString(2, name);
            psn.execute();
            psn.close();
          }
          catch (SQLException e) {
            throw new RDFHandlerException("Problem executing query: " + query, e);
          }
        }

        public void handleStatement(Statement st) throws RDFHandlerException {
           try {
          Resource[] hcontexts;
          if (st.getContext() != null && useStatementContext) {
            hcontexts = new Resource[] {st.getContext()};
          } else {
            hcontexts = _contexts;
          }
                addToQuadStore(st.getSubject(), st.getPredicate(), st.getObject(), hcontexts);
          
           catch(Exception e) {
             throw new RDFHandlerException(e);
           }
        }
      });
      parser.parse(reader, baseURI); // parse out each tripled to be handled by the handler above
    }
    catch (Exception e) {
      throw new RepositoryException("Problem parsing triples", e);
    }
  }
View Full Code Here

      // Add the stream in a single transaction
      begin();
                }

    try {
      RDFParser parser = Rio.createParser(format, getValueFactory());

      // set up a handler for parsing the data from reader
      parser.setVerifyData(true);
      parser.setStopAtFirstError(true);
      parser.setDatatypeHandling(RDFParser.DatatypeHandling.IGNORE);

                        RDFHandlerBase rdfInserter = new RDFHandlerBase() {
       
        int count = 0;
        PreparedStatement ps = null;
        Resource[] _contexts = checkDMLContext(contexts);

        public void startRDF() throws RDFHandlerException {
          if (ps == null)
            try {
                    ps = prepareStatement(VirtuosoRepositoryConnection.S_INSERT);
                  } catch (java.sql.SQLException e) {
              throw new RDFHandlerException("Problem PrepareStatement: ", e);
                  }
        }


        public void endRDF() throws RDFHandlerException {
          try {
            if (count > 0) {
              ps.executeBatch();
              ps.clearBatch();
              count = 0;
            }
            if (ps != null) {
              ps.close();
              ps = null;
            }
          }
          catch (SQLException e) {
            throw new RDFHandlerException("Problem executing query: ", e);
          }
        }

        public void handleNamespace(String prefix, String name) throws RDFHandlerException {
          String query = "DB.DBA.XML_SET_NS_DECL(?, ?, 1)";
          try {
            PreparedStatement psn = prepareStatement(query);
            psn.setString(1, prefix);
            psn.setString(2, name);
            psn.execute();
            psn.close();
          }
          catch (SQLException e) {
            throw new RDFHandlerException("Problem executing query: " + query, e);
          }
        }

        public void handleStatement(Statement st) throws RDFHandlerException {
           try {
          Resource[] hcontexts;
          if (st.getContext() != null && useStatementContext) {
            hcontexts = new Resource[] {st.getContext()};
          } else {
            hcontexts = _contexts;
          }
          for (int i = 0; i < hcontexts.length; i++) {
            ps.setString(1, hcontexts[i].stringValue());
            bindResource(ps, 2, st.getSubject());
            bindURI(ps, 3, st.getPredicate());
            bindValue(ps, 4, st.getObject());
            ps.addBatch();
            count++;
          }
          if (count > BATCH_SIZE) {
            ps.executeBatch();
            ps.clearBatch();
            count = 0;
          }
           } 
           catch(Exception e) {
             throw new RDFHandlerException(e);
           }
        }
      };

      parser.setRDFHandler(rdfInserter);
      parser.parse(reader, baseURI); // parse out each tripled to be handled by the handler above

      if (autoCommit)
        commit();

    }
View Full Code Here

    public Model createModelFromFile(String filename, String baseUri) throws IOException {
        Model model = new LinkedHashModel();
        if (filename != null) {
            try {
                RDFParser parser = Rio.createParser(SesameTestHelper.detectFileFormat(filename));
                parser.setRDFHandler(new ContextStatementCollector(model, ValueFactoryImpl.getInstance()));

                ParserConfig config = parser.getParserConfig();
                config.set(BasicParserSettings.PRESERVE_BNODE_IDS, true);
                config.addNonFatalError(BasicParserSettings.VERIFY_DATATYPE_VALUES);
                config.addNonFatalError(BasicParserSettings.VERIFY_LANGUAGE_TAGS);
                // Attempt to normalize known datatypes, including XML Schema
                config.set(BasicParserSettings.NORMALIZE_DATATYPE_VALUES, true);
                // Try not to fail when normalization fails
                config.addNonFatalError(BasicParserSettings.NORMALIZE_DATATYPE_VALUES);

                ParseErrorCollector errors = new ParseErrorCollector();
                parser.setParseErrorListener(errors);

                parser.parse(openStreamForResource(filename), baseUri);

                for(String nextFatalError : errors.getFatalErrors()) {
                    System.err.println("Fatal parse error was ignored : " + filename + " : "+ nextFatalError);
                }
                for(String nextError : errors.getErrors()) {
View Full Code Here

        rdfWriter.handleStatement(st5);
        rdfWriter.handleStatement(st6);
        rdfWriter.endRDF();

        final ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
        final RDFParser rdfParser = rdfParserFactory.getParser();
        final ParserConfig config = new ParserConfig();
        config.set(BasicParserSettings.FAIL_ON_UNKNOWN_DATATYPES, true);
        config.set(BasicParserSettings.FAIL_ON_UNKNOWN_LANGUAGES, true);
        rdfParser.setParserConfig(config);
        rdfParser.setValueFactory(vf);
        final Model model = new LinkedHashModel();
        rdfParser.setRDFHandler(new StatementCollector(model));

        rdfParser.parse(in, "foo:bar");

        assertEquals("Unexpected number of statements", 6, model.size());
        final Model bnodeModel = model.filter(null, uri1,
                vf.createLiteral(plainLit.getLabel(), XMLSchema.STRING));
        assertEquals("Blank node was not round-tripped", 1, bnodeModel.size());
        assertTrue("Blank node was not round-tripped as a blank node", bnodeModel.subjects()
                .iterator().next() instanceof BNode);
        if (rdfParser.getRDFFormat().supportsContexts()) {
            assertTrue(model.contains(st2));
        } else {
            assertTrue(model.contains(vf.createStatement(uri1, uri2, langLit)));
        }
        assertTrue(model.contains(st3));
View Full Code Here

TOP

Related Classes of org.openrdf.rio.RDFParser

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.