This is an automated email from the ASF dual-hosted git repository. andy pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/jena.git
commit 4157f9a87fe337371794cf3a44174c6a835280b4 Author: Andy Seaborne <[email protected]> AuthorDate: Wed Nov 12 10:45:00 2025 +0000 GH-3586: Rewrite ResultsFormat --- .../org/apache/jena/query/ResultSetFactory.java | 120 +------- .../org/apache/jena/query/ResultSetFormatter.java | 20 +- .../java/org/apache/jena/riot/RDFLanguages.java | 4 +- .../jena/riot/rowset/RowSetReaderRegistry.java | 1 - .../apache/jena/sparql/resultset/PlainFormat.java | 104 +++---- .../org/apache/jena/sparql/resultset/RDFInput.java | 11 +- .../jena/sparql/resultset/ResultsFormat.java | 334 ++++++++------------- .../jena/sparql/sse/builders/BuilderExec.java | 2 +- .../apache/jena/sparql/util/QueryExecUtils.java | 261 +++++++--------- .../jena/arq/junit/sparql/tests/QueryTestItem.java | 149 +++++---- .../jena/arq/junit/sparql/tests/SparqlTestLib.java | 2 +- .../jena/sparql/resultset/TestResultSet.java | 6 +- .../src/main/java/arq/cmdline/ModResultsIn.java | 2 +- .../src/main/java/arq/cmdline/ModResultsOut.java | 5 +- jena-cmds/src/main/java/arq/query.java | 5 +- .../examples/RDFConnectionExampleDBpedia01.java | 2 +- 16 files changed, 382 insertions(+), 646 deletions(-) diff --git a/jena-arq/src/main/java/org/apache/jena/query/ResultSetFactory.java b/jena-arq/src/main/java/org/apache/jena/query/ResultSetFactory.java index ae94e2e212..460575da83 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/ResultSetFactory.java +++ b/jena-arq/src/main/java/org/apache/jena/query/ResultSetFactory.java @@ -26,9 +26,7 @@ import org.apache.jena.atlas.io.IO ; import org.apache.jena.atlas.io.IOX; import org.apache.jena.atlas.logging.Log ; import org.apache.jena.rdf.model.Model ; -import org.apache.jena.rdf.model.ModelFactory ; import org.apache.jena.riot.Lang ; -import org.apache.jena.riot.RDFDataMgr; import org.apache.jena.riot.ReadAnything; import org.apache.jena.riot.ResultSetMgr ; import org.apache.jena.riot.resultset.ResultSetLang; @@ -37,7 +35,6 @@ import org.apache.jena.sparql.core.Var; import org.apache.jena.sparql.engine.QueryIterator ; import org.apache.jena.sparql.engine.ResultSetStream ; import org.apache.jena.sparql.exec.RowSet; -import org.apache.jena.sparql.graph.GraphFactory ; import org.apache.jena.sparql.resultset.* ; /** ResultSetFactory - make result sets from places other than a query. */ @@ -91,130 +88,23 @@ public class ResultSetFactory { public static ResultSet load(InputStream input, ResultsFormat format) { if (format == null) { Log.warn(ResultSet.class, "Null format - defaulting to XML"); - format = ResultsFormat.FMT_RS_XML; + format = ResultsFormat.XML; } - // Old World - new world - Lang lang = ResultsFormat.convert(format) ; - if ( lang != null ) - return ResultSetMgr.read(input, lang) ; - - if (format.equals(ResultsFormat.FMT_TEXT)) { + if ( format == ResultsFormat.TEXT ) { Log.warn(ResultSet.class, "Can't read a text result set"); throw new ResultSetException("Can't read a text result set"); } - if (format.equals(ResultsFormat.FMT_RDF_XML)) { - Model m = ModelFactory.createDefaultModel(); - m.read(input, null); - return RDFInput.fromRDF(m); - } - - if (format.equals(ResultsFormat.FMT_RDF_TTL)) { - Model m = ModelFactory.createDefaultModel(); - m.read(input, null, "TURTLE"); - return RDFInput.fromRDF(m); - } - - if (format.equals(ResultsFormat.FMT_RDF_N3)) { - Model m = ModelFactory.createDefaultModel(); - m.read(input, null, "N3"); - return RDFInput.fromRDF(m); - } + Lang lang = format.resultSetLang(); - if (format.equals(ResultsFormat.FMT_RDF_NT)) { - Model m = ModelFactory.createDefaultModel(); - m.read(input, null, "N-TRIPLES"); - return RDFInput.fromRDF(m); - } + if ( lang != null ) + return ResultSetMgr.read(input, lang) ; Log.warn(ResultSet.class, "Unknown result set syntax: " + format); return null; } - /** - * Load a result set (or any other model) from file or URL - * - * @param filenameOrURI - * @return Model - */ - public static Model loadAsModel(String filenameOrURI) { - return loadAsModel(null, filenameOrURI, null); - } - - /** - * Load a result set (or any other model) from file or URL - * - * @param model - * Load into this model (returned) - * @param filenameOrURI - * @return Model - */ - public static Model loadAsModel(Model model, String filenameOrURI) { - return loadAsModel(model, filenameOrURI, null); - } - - /** - * Load a result set (or any other model) from file or URL - * - * @param filenameOrURI - * @param format - * @return Model - */ - public static Model loadAsModel(String filenameOrURI, ResultsFormat format) { - return loadAsModel(null, filenameOrURI, format); - } - - /** - * Load a result set (or any other model) from file or URL. Does not have to - * be a result set (e.g. CONSTRUCt results) but it does interpret the - * ResultSetFormat possibilities. - * - * @param model - * Load into this model (returned) - * @param filenameOrURI - * @param format - * @return Model - * @deprecated This function will become be internal. - */ - @Deprecated - public static Model loadAsModel(Model model, String filenameOrURI, ResultsFormat format) { - if (model == null) - model = GraphFactory.makeDefaultModel(); - - if (format == null) - format = ResultsFormat.guessSyntax(filenameOrURI); - - if (format == null) { - Log.warn(ResultSet.class, "Null format - defaulting to XML"); - format = ResultsFormat.FMT_RS_XML; - } - - if (format.equals(ResultsFormat.FMT_TEXT)) { - Log.error(ResultSet.class, "Can't read a text result set"); - throw new ResultSetException("Can't read a text result set"); - } - - if (format.equals(ResultsFormat.FMT_RS_XML) || format.equals(ResultsFormat.FMT_RS_JSON)) { - SPARQLResult x = ReadAnything.read(filenameOrURI); - if (x.isResultSet()) - RDFOutput.encodeAsRDF(model, x.getResultSet()); - else if ( x.isBoolean() ) - RDFOutput.encodeAsRDF(model, x.getBooleanResult()); - else - throw new ResultSetException("Not a result set"); - return model; - } - - if (ResultsFormat.isRDFGraphSyntax(format)) { - RDFDataMgr.read(model, filenameOrURI); - return model; - } - - Log.error(ResultSet.class, "Unknown result set syntax: " + format); - return null; - } - /** * Read in any kind of result kind (result set, boolean, graph) Guess the * syntax based on filename/URL extension. diff --git a/jena-arq/src/main/java/org/apache/jena/query/ResultSetFormatter.java b/jena-arq/src/main/java/org/apache/jena/query/ResultSetFormatter.java index 0e90fcc933..ea568044e2 100644 --- a/jena-arq/src/main/java/org/apache/jena/query/ResultSetFormatter.java +++ b/jena-arq/src/main/java/org/apache/jena/query/ResultSetFormatter.java @@ -29,6 +29,7 @@ import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Iterator; import java.util.List; +import java.util.Objects; import org.apache.jena.atlas.io.IndentedWriter; import org.apache.jena.atlas.json.JsonObject; @@ -279,19 +280,16 @@ public class ResultSetFormatter { */ static public void output(OutputStream outStream, ResultSet resultSet, ResultsFormat rFmt) { - Lang lang = ResultsFormat.convert(rFmt); - if ( lang != null ) { - output(outStream, resultSet, lang); - return; - } + Objects.requireNonNull(resultSet); + Objects.requireNonNull(outStream); + Objects.requireNonNull(rFmt); - boolean b = ResultsFormat.oldWrite(outStream, rFmt, null, resultSet); - if ( b ) - return; - throw new ARQException("Unknown ResultSet format: " + rFmt); - } + Lang lang = rFmt.resultSetLang(); + if ( lang == null ) + throw new ARQException("Unknown ResultSet output format: " + rFmt); - // ---- General Output + output(outStream, resultSet, lang); + } public static void output(ResultSet resultSet, Lang resultFormat) { output(System.out, resultSet, resultFormat); diff --git a/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java b/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java index 8d7f24202d..d149533085 100644 --- a/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java +++ b/jena-arq/src/main/java/org/apache/jena/riot/RDFLanguages.java @@ -419,8 +419,8 @@ public class RDFLanguages public static Lang filenameToLang(String uriOrFilename) { return pathnameToLang(uriOrFilename); } /** - * Try to map a URI or URI path name to a {@link Lang}; return null on no - * registered mapping. + * Try to map a URI or URI path name to a {@link Lang}; This included filenames. + * Return null on no registered mapping. */ public static Lang pathnameToLang(String pathname) { if ( pathname == null ) diff --git a/jena-arq/src/main/java/org/apache/jena/riot/rowset/RowSetReaderRegistry.java b/jena-arq/src/main/java/org/apache/jena/riot/rowset/RowSetReaderRegistry.java index 6ed3fe8eca..b19014b529 100644 --- a/jena-arq/src/main/java/org/apache/jena/riot/rowset/RowSetReaderRegistry.java +++ b/jena-arq/src/main/java/org/apache/jena/riot/rowset/RowSetReaderRegistry.java @@ -66,7 +66,6 @@ public class RowSetReaderRegistry { initialized = true; register(RS_XML, RowSetReaderXML.factory); - // register(RS_JSON, RowSetReaderJSON.factory); register(RS_JSON, RowSetReaderJSONStreaming.factory); register(RS_CSV, RowSetReaderCSV.factory); diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/PlainFormat.java b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/PlainFormat.java index c4d8d473ab..0d5a759ba6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/PlainFormat.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/PlainFormat.java @@ -18,72 +18,72 @@ package org.apache.jena.sparql.resultset; -import java.io.OutputStream ; -import java.io.PrintWriter ; +import java.io.OutputStream; +import java.io.PrintWriter; -import org.apache.jena.query.QuerySolution ; -import org.apache.jena.query.ResultSet ; -import org.apache.jena.rdf.model.RDFNode ; -import org.apache.jena.sparql.core.Prologue ; -import org.apache.jena.sparql.serializer.SerializationContext ; -import org.apache.jena.sparql.util.FmtUtils ; -import org.apache.jena.util.FileUtils ; +import org.apache.jena.query.QuerySolution; +import org.apache.jena.query.ResultSet; +import org.apache.jena.rdf.model.RDFNode; +import org.apache.jena.sparql.core.Prologue; +import org.apache.jena.sparql.serializer.SerializationContext; +import org.apache.jena.sparql.util.FmtUtils; +import org.apache.jena.util.FileUtils; -public class PlainFormat implements ResultSetProcessor -{ - PrintWriter out ; - int count = 0 ; - boolean lineNumbers = true ; - boolean first = true ; - SerializationContext context ; +public class PlainFormat implements ResultSetProcessor { + private PrintWriter out; + private int count = 0; + private boolean lineNumbers = true; + private boolean first = true; + private SerializationContext context; - public PlainFormat(OutputStream outStream, SerializationContext context) - { - this.out = FileUtils.asPrintWriterUTF8(outStream) ; - this.context = context ; + public PlainFormat(OutputStream outStream, SerializationContext context) { + this.out = FileUtils.asPrintWriterUTF8(outStream); + this.context = context; } - - public PlainFormat(OutputStream outStream, Prologue prologue) - { - this(outStream, new SerializationContext(prologue)) ; + + public PlainFormat(OutputStream outStream, Prologue prologue) { + this(outStream, new SerializationContext(prologue)); } - + @Override public void start(ResultSet rs) {} + @Override - public void finish(ResultSet rs) { out.flush() ; } + public void finish(ResultSet rs) { + out.flush(); + } + @Override - public void start(QuerySolution qs) - { - count++ ; - //insertLineNumber() ; - first = true ; + public void start(QuerySolution qs) { + count++; + // insertLineNumber() ; + first = true; } - + @Override - public void finish(QuerySolution qs) { out.println() ; } + public void finish(QuerySolution qs) { + out.println(); + } + @Override - public void binding(String varName, RDFNode value) - { + public void binding(String varName, RDFNode value) { if ( value == null ) - return ; // Unbound - if ( ! first ) - out.print(" ") ; + return; // Unbound + if ( !first ) + out.print(" "); // Would like to share code Binding here. - String s = FmtUtils.stringForRDFNode(value, context) ; - out.print("( ?"+varName+" = "+s+" )") ; - first = false ; - } - - void insertLineNumber() - { - if ( ! lineNumbers ) - return ; - String s = Integer.toString(count) ; - for ( int i = 0 ; i < 3-s.length() ; i++ ) - out.print(' ') ; - out.print(s) ; - out.print(' ') ; + String s = FmtUtils.stringForRDFNode(value, context); + out.print("( ?" + varName + " = " + s + " )"); + first = false; } + void insertLineNumber() { + if ( !lineNumbers ) + return; + String s = Integer.toString(count); + for ( int i = 0 ; i < 3 - s.length() ; i++ ) + out.print(' '); + out.print(s); + out.print(' '); + } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/RDFInput.java b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/RDFInput.java index 495be93278..4079f36ee6 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/RDFInput.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/RDFInput.java @@ -32,13 +32,12 @@ import org.apache.jena.sparql.engine.binding.BindingBuilder; import org.apache.jena.sparql.vocabulary.ResultSetGraphVocab; import org.apache.jena.vocabulary.RDF; +/** + * Process a result set encoded in RDF according to + * <a href="http://www.w3.org/2001/sw/DataAccess/tests/result-set";>http://www.w3.org/2001/sw/DataAccess/tests/result-set</a> + */ public class RDFInput extends ResultSetMem { - /** - * Process a result set encoded in RDF according to - * <code>@link{http://www.w3.org/2001/sw/DataAccess/tests/result-set}#</code> - * - * @param model - */ + public RDFInput(Model model) { buildFromDumpFormat(model); } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/ResultsFormat.java b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/ResultsFormat.java index 6376fc4d29..25926ea03c 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/resultset/ResultsFormat.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/resultset/ResultsFormat.java @@ -18,247 +18,151 @@ package org.apache.jena.sparql.resultset; -import static org.apache.jena.riot.WebContent.* ; - -import java.io.OutputStream; -import java.io.PrintStream; -import java.util.HashMap ; -import java.util.Map ; - -import org.apache.jena.query.ResultSet; -import org.apache.jena.query.ResultSetFormatter; -import org.apache.jena.riot.Lang ; -import org.apache.jena.riot.resultset.ResultSetLang ; -import org.apache.jena.sparql.core.Prologue; -import org.apache.jena.sparql.util.QueryExecUtils; -import org.apache.jena.sparql.util.Symbol ; -import org.apache.jena.sparql.util.TranslationTable ; - -// Better .... -//public enum ResultFormat -//{ -// // Merge with our system wide naming (WebContent?) -// FMT_RS_XML , FMT_RS_JSON , FMT_RS_CSV , FMT_RS_TSV , FMT_RS_SSE , FMT_RS_BIO , -// FMT_NONE , FMT_TEXT , FMT_TUPLES , FMT_COUNT , -// FMT_RS_RDF , FMT_RDF_XML , FMT_RDF_N3 , FMT_RDF_TTL , FMT_RDF_TURTLE , FMT_RDF_NT , -// FMT_UNKNOWN ; - - -// Old world. -public class ResultsFormat extends Symbol -{ - private ResultsFormat(String symbol) { - super(symbol); - } +import org.apache.jena.riot.Lang; +import org.apache.jena.riot.RDFFormat; +import org.apache.jena.riot.RDFLanguages; +import org.apache.jena.riot.resultset.ResultSetLang; +import org.apache.jena.sparql.util.TranslationTable; + +/** + * The output formats for all query types. + * Result sets, boolean graphs. + * <p> + * This does not include results sets as RDF is elsewhere which is provided for tests with {@link RDFInput} and {@link RDFOutput}. + */ - static public ResultsFormat FMT_RS_XML = new ResultsFormat(contentTypeResultsXML) ; - static public ResultsFormat FMT_RS_JSON = new ResultsFormat(contentTypeResultsJSON) ; +public enum ResultsFormat { + // Results formats, by surface syntax. + // Used by commands. - static public ResultsFormat FMT_RS_THRIFT = new ResultsFormat(contentTypeResultsThrift) ; - static public ResultsFormat FMT_RS_PROTOBUF = new ResultsFormat(contentTypeResultsProtobuf) ; + XML(ResultSetLang.RS_XML, RDFFormat.RDFXML_ABBREV), + JSON(ResultSetLang.RS_JSON, RDFFormat.JSONLD11), + TEXT(ResultSetLang.RS_Text, RDFFormat.TURTLE), - static public ResultsFormat FMT_RS_CSV = new ResultsFormat(contentTypeTextCSV) ; - static public ResultsFormat FMT_RS_TSV = new ResultsFormat(contentTypeTextTSV) ; - static public ResultsFormat FMT_RS_SSE = new ResultsFormat(contentTypeSSE) ; - static public ResultsFormat FMT_NONE = new ResultsFormat("none") ; - static public ResultsFormat FMT_TEXT = new ResultsFormat("text") ; - static public ResultsFormat FMT_TUPLES = new ResultsFormat("tuples") ; - static public ResultsFormat FMT_COUNT = new ResultsFormat("count") ; - // Also used for output of result sets as RDF. - static public ResultsFormat FMT_RDF_XML = new ResultsFormat(contentTypeRDFXML) ; - static public ResultsFormat FMT_RDF_N3 = new ResultsFormat(contentTypeN3) ; - static public ResultsFormat FMT_RDF_TTL = new ResultsFormat(contentTypeTurtle) ; - static public ResultsFormat FMT_RDF_TURTLE = new ResultsFormat(contentTypeTurtle) ; - static public ResultsFormat FMT_RDF_NT = new ResultsFormat(contentTypeNTriples) ; - static public ResultsFormat FMT_RDF_TRIG = new ResultsFormat(contentTypeTriG) ; - static public ResultsFormat FMT_RDF_NQ = new ResultsFormat(contentTypeNQuads) ; - static public ResultsFormat FMT_RDF_JSONLD = new ResultsFormat(contentTypeJSONLD) ; - static public ResultsFormat FMT_UNKNOWN = new ResultsFormat("unknown") ; + CSV(ResultSetLang.RS_CSV, null), + TSV(ResultSetLang.RS_TSV, null), - // ---- Compatibility + THRIFT(ResultSetLang.RS_Thrift, RDFFormat.RDF_THRIFT), + PROTOBUF(ResultSetLang.RS_Protobuf, RDFFormat.RDF_PROTO), - // Common names to symbol (used by arq.rset) - private static TranslationTable<ResultsFormat> names = new TranslationTable<>(true) ; - static { - names.put("srx", FMT_RS_XML) ; - names.put("xml", FMT_RS_XML) ; + // result set as RDF is handled specially + TTL(null, RDFFormat.TURTLE), + NT(null, RDFFormat.NTRIPLES), + RDFXML(null, RDFFormat.RDFXML), + RDF_JSONLD(null, RDFFormat.JSONLD), - names.put("json", FMT_RS_JSON) ; - names.put("srj", FMT_RS_JSON) ; + // Special name. + COUNT(null, null), - names.put("srt", FMT_RS_THRIFT) ; - names.put("srp", FMT_RS_PROTOBUF) ; + NONE(ResultSetLang.RS_None, RDFFormat.RDFNULL), - names.put("sse", FMT_RS_SSE) ; - names.put("csv", FMT_RS_CSV) ; - names.put("tsv", FMT_RS_TSV) ; - names.put("text", FMT_TEXT) ; - names.put("count", FMT_COUNT) ; - names.put("tuples", FMT_TUPLES) ; - names.put("none", FMT_NONE) ; + SSE(null, null), + TUPLES(null, null) + ; - names.put("rdf", FMT_RDF_XML) ; - names.put("rdf/n3", FMT_RDF_N3) ; - names.put("rdf/xml", FMT_RDF_XML) ; - names.put("n3", FMT_RDF_N3) ; - names.put("ttl", FMT_RDF_TTL) ; - names.put("turtle", FMT_RDF_TTL) ; - names.put("graph", FMT_RDF_TTL) ; - names.put("nt", FMT_RDF_NT) ; - names.put("n-triples", FMT_RDF_NT) ; - names.put("ntriples", FMT_RDF_NT) ; - names.put("jsonld", FMT_RDF_JSONLD) ; - names.put("json-ld", FMT_RDF_JSONLD) ; + private final Lang resultSetLang; + private final RDFFormat rdfFormat; + //private final boolean supportsBoolean; - names.put("nq", FMT_RDF_NQ) ; - names.put("nquads", FMT_RDF_NQ) ; - names.put("n-quads", FMT_RDF_NQ) ; - names.put("trig", FMT_RDF_TRIG) ; - } + ResultsFormat(Lang resultSetLang, RDFFormat rdfFormat) { + this.resultSetLang = resultSetLang; + this.rdfFormat = rdfFormat; - public static ResultsFormat guessSyntax(String url) { - return guessSyntax(url, FMT_RS_XML); + //this.supportsBoolean = supportsBoolean; } - public static boolean isRDFGraphSyntax(ResultsFormat fmt) { - if ( FMT_RDF_N3.equals(fmt) ) - return true; - if ( FMT_RDF_TURTLE.equals(fmt) ) - return true; - if ( FMT_RDF_XML.equals(fmt) ) - return true; - if ( FMT_RDF_NT.equals(fmt) ) - return true; - return false; + public Lang resultSetLang() { + return resultSetLang; } - public static boolean isDatasetSyntax(ResultsFormat fmt) { - if ( FMT_RDF_TRIG.equals(fmt) ) - return true; - if ( FMT_RDF_NQ.equals(fmt) ) - return true; - return false; + public RDFFormat rdfFormat() { + return rdfFormat; } - public static ResultsFormat guessSyntax(String url, ResultsFormat defaultFormat) { - // -- XML - if ( url.endsWith(".srx") ) - return FMT_RS_XML; - if ( url.endsWith(".xml") ) - return FMT_RS_XML; - - // -- Some kind of RDF - if ( url.endsWith(".rdf") ) - return FMT_RDF_XML; - if ( url.endsWith(".n3") ) - return FMT_RDF_N3; - if ( url.endsWith(".ttl") ) - return FMT_RDF_TURTLE; - - // -- JSON - if ( url.endsWith(".srj") ) - return FMT_RS_JSON; - if ( url.endsWith(".json") ) - return FMT_RS_JSON; - if ( url.endsWith(".yml") ) - return FMT_RS_JSON; - - // -- Thrift - if ( url.endsWith(".srt") ) - return FMT_RS_THRIFT; - // -- Thrift - if ( url.endsWith(".srp") ) - return FMT_RS_PROTOBUF; - - // -- SSE : http://jena.apache.org/documentation/notes/sse.html - if ( url.endsWith(".sse") ) - return FMT_RS_SSE; - - // Likely to be something completely different! - if ( url.endsWith(".csv") ) - return FMT_RS_CSV; - if ( url.endsWith(".tsv") ) - return FMT_RS_TSV; - - // -- Dataset - if ( url.endsWith(".trig") ) - return FMT_RDF_TRIG; - if ( url.endsWith(".nq") ) - return FMT_RDF_NQ; - - return defaultFormat; +// +// public boolean supportsBoolean() { +// return supportsBoolean; +// } +// +// public boolean isResultSet() { +// return ResultSetLang.isRegistered(lang()); +// } + + /** Guess the syntax of a result set URL */ + public static ResultsFormat guessSyntax(String resultsFilename) { + Lang rsLang = RDFLanguages.pathnameToLang(resultsFilename); + if ( rsLang == null ) + return null; +// if ( ! ResultSetLang.isRegistered(rsLang) ) +// return null; + ResultsFormat[] enums = ResultsFormat.values(); + for ( ResultsFormat rsFmt : enums ) { + if ( rsFmt.resultSetLang().equals(rsLang) ) + return rsFmt; + } + return null; } /** * Look up a short name for a result set FMT_ * - * @param s - * Short name + * @param shortname Short name * @return ResultSetFormat */ - public static ResultsFormat lookup(String s) { - return names.lookup(s); + public static ResultsFormat lookup(String shortname) { + return names.lookup(shortname); } - /** - * Mapping from old-style {@link ResultsFormat} to {@link ResultSetLang} or other - * {@link Lang}. See also {@link QueryExecUtils#outputResultSet} for dispatch of some old, - * specialized types such as results encoded in RDF. - */ - static Map<ResultsFormat, Lang> mapResultsFormatToLang = new HashMap<>() ; + // Common names to symbol (used by arq.rset) + private static TranslationTable<ResultsFormat> names = new TranslationTable<>(true) ; static { - mapResultsFormatToLang.put(ResultsFormat.FMT_NONE, ResultSetLang.RS_None) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_CSV, ResultSetLang.RS_CSV) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_TSV, ResultSetLang.RS_TSV) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_XML, ResultSetLang.RS_XML) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_JSON, ResultSetLang.RS_JSON) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_THRIFT, ResultSetLang.RS_Thrift) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_RS_PROTOBUF, ResultSetLang.RS_Protobuf) ; - mapResultsFormatToLang.put(ResultsFormat.FMT_TEXT, ResultSetLang.RS_Text); - } - - public static Lang convert(ResultsFormat fmt) { - return mapResultsFormatToLang.get(fmt) ; - } - - /** Write a {@link ResultSet} in various old style formats no longer recommended. - * Return true if the format was handled else false. - */ - public static boolean oldWrite(OutputStream out, ResultsFormat outputFormat, Prologue prologue, ResultSet resultSet) { - if ( outputFormat.equals(ResultsFormat.FMT_COUNT) ) { - int count = ResultSetFormatter.consume(resultSet) ; - PrintStream pOut = new PrintStream(out); - pOut.println("Count = " + count) ; - return true ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_XML) ) { - RDFOutput.outputAsRDF(out, "RDF/XML-ABBREV", resultSet) ; - return true; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_TTL) ) { - RDFOutput.outputAsRDF(out, "TTL", resultSet) ; - return true; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_NT) ) { - RDFOutput.outputAsRDF(out, "N-TRIPLES", resultSet) ; - return true; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_JSONLD) ) { - RDFOutput.outputAsRDF(out, "JSONLD", resultSet) ; - return true; - } - - if ( outputFormat.equals(ResultsFormat.FMT_TUPLES) ) { - PlainFormat pFmt = new PlainFormat(out, prologue) ; - ResultSetApply a = new ResultSetApply(resultSet, pFmt) ; - a.apply() ; - return true; - } - - return false; + names.put("srx", XML) ; + names.put("xml", XML) ; + + names.put("json", JSON) ; + names.put("srj", JSON) ; + + names.put("srt", THRIFT) ; + names.put("srp", PROTOBUF) ; + + names.put("rdfxml", RDFXML) ; + names.put("rdf", TTL) ; + names.put("ttl", TTL); + names.put("turtle", TTL); + + names.put("n-triples", NT); + names.put("ntriples", NT); + names.put("nt", NT); + + names.put("jsonld", RDF_JSONLD) ; + names.put("json-ld", RDF_JSONLD) ; + + names.put("sse", SSE) ; + names.put("csv", CSV) ; + names.put("tsv", TSV) ; + names.put("text", TEXT) ; + names.put("count", COUNT) ; + names.put("tuples", TUPLES) ; + names.put("none", NONE) ; + + //names.put("rdf", ???) ; + +// names.put("rdf", RDF_XML) ; +// names.put("rdf/n3", RDF_N3) ; +// names.put("rdf/xml", RDF_XML) ; +// names.put("n3", RDF_N3) ; +// names.put("ttl", RDF_TTL) ; +// names.put("turtle", RDF_TTL) ; +// names.put("graph", RDF_TTL) ; +// names.put("nt", RDF_NT) ; +// names.put("n-triples", RDF_NT) ; +// names.put("ntriples", RDF_NT) ; +// names.put("jsonld", RDF_JSONLD) ; +// names.put("json-ld", RDF_JSONLD) ; +// +// names.put("nq", RDF_NQ) ; +// names.put("nquads", RDF_NQ) ; +// names.put("n-quads", RDF_NQ) ; +// names.put("trig", RDF_TRIG) ; } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/sse/builders/BuilderExec.java b/jena-arq/src/main/java/org/apache/jena/sparql/sse/builders/BuilderExec.java index 690425c28b..3301464ffe 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/sse/builders/BuilderExec.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/sse/builders/BuilderExec.java @@ -43,6 +43,6 @@ public class BuilderExec { DatasetGraph dsg = BuilderGraph.buildDataset(list.get(1)); Op op = BuilderOp.build(list.get(2)); - QueryExecUtils.execute(op, dsg, ResultsFormat.FMT_TEXT); + QueryExecUtils.execute(op, dsg, ResultsFormat.TEXT); } } diff --git a/jena-arq/src/main/java/org/apache/jena/sparql/util/QueryExecUtils.java b/jena-arq/src/main/java/org/apache/jena/sparql/util/QueryExecUtils.java index bfef9dbd41..657b618343 100644 --- a/jena-arq/src/main/java/org/apache/jena/sparql/util/QueryExecUtils.java +++ b/jena-arq/src/main/java/org/apache/jena/sparql/util/QueryExecUtils.java @@ -18,6 +18,7 @@ package org.apache.jena.sparql.util ; +import java.io.OutputStream; import java.io.PrintStream; import java.util.ArrayList; import java.util.List ; @@ -28,7 +29,9 @@ import org.apache.jena.query.* ; import org.apache.jena.rdf.model.Model ; import org.apache.jena.rdf.model.RDFNode ; import org.apache.jena.riot.Lang ; -import org.apache.jena.riot.RDFDataMgr ; +import org.apache.jena.riot.RDFFormat; +import org.apache.jena.riot.RDFWriter; +import org.apache.jena.riot.resultset.ResultSetLang; import org.apache.jena.shared.PrefixMapping ; import org.apache.jena.shared.impl.PrefixMappingImpl ; import org.apache.jena.sparql.ARQConstants ; @@ -44,9 +47,10 @@ import org.apache.jena.sparql.engine.QueryIterator ; import org.apache.jena.sparql.engine.ResultSetStream; import org.apache.jena.sparql.exec.QueryExec; import org.apache.jena.sparql.exec.QueryExecutionAdapter; -import org.apache.jena.sparql.resultset.RDFOutput ; +import org.apache.jena.sparql.resultset.RDFOutput; import org.apache.jena.sparql.resultset.ResultsFormat ; import org.apache.jena.sparql.resultset.ResultsWriter; +import org.apache.jena.sparql.resultset.SPARQLResult; /** Some utilities for query processing. */ public class QueryExecUtils { @@ -72,14 +76,14 @@ public class QueryExecUtils { } public static void exec(Prologue prologue, QueryExec queryExec) { - exec(prologue, queryExec, ResultsFormat.FMT_TEXT) ; + exec(prologue, queryExec, ResultsFormat.TEXT) ; } public static void exec(Prologue prologue, QueryExec queryExec, ResultsFormat outputFormat) { exec(prologue, queryExec, outputFormat, System.out); } - public static void exec(Prologue prologue, QueryExec queryExec, ResultsFormat outputFormat, PrintStream output) { + public static void exec(Prologue prologue, QueryExec queryExec, ResultsFormat outputFormat, OutputStream output) { QueryExecution queryExecution = QueryExecutionAdapter.adapt(queryExec); executeQuery(prologue, queryExecution, outputFormat, output); } @@ -89,14 +93,14 @@ public class QueryExecUtils { } public static void executeQuery(Prologue prologue, QueryExecution queryExecution) { - executeQuery(prologue, queryExecution, ResultsFormat.FMT_TEXT) ; + executeQuery(prologue, queryExecution, ResultsFormat.TEXT) ; } public static void executeQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat) { executeQuery(prologue, queryExecution, outputFormat, System.out); } - public static void executeQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat, PrintStream output) { + public static void executeQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat, OutputStream output) { Query query = queryExecution.getQuery() ; if ( prologue == null && query != null ) prologue = query.getPrologue() ; @@ -117,18 +121,17 @@ public class QueryExecUtils { doJsonQuery(prologue, queryExecution, outputFormat, output) ; else throw new QueryException("Unrecognized query form"); - output.flush(); } public static void execute(Op op, DatasetGraph dsg) { - execute(op, dsg, ResultsFormat.FMT_TEXT) ; + execute(op, dsg, ResultsFormat.TEXT) ; } public static void execute(Op op, DatasetGraph dsg, ResultsFormat outputFormat) { execute(op, dsg, outputFormat, System.out); } - public static void execute(Op op, DatasetGraph dsg, ResultsFormat outputFormat, PrintStream output) { + public static void execute(Op op, DatasetGraph dsg, ResultsFormat outputFormat, OutputStream output) { QueryIterator qIter = Algebra.exec(op, dsg) ; List<Var> vars = null ; @@ -141,196 +144,140 @@ public class QueryExecUtils { ResultSet results = ResultSetStream.create(vars, qIter) ; outputResultSet(results, null, outputFormat, output) ; - output.flush(); } - public static void outputResultSet(ResultSet results, Prologue prologue, ResultsFormat outputFormat, PrintStream output) { - if ( outputFormat.equals(ResultsFormat.FMT_UNKNOWN) ) - outputFormat = ResultsFormat.FMT_TEXT ; - // Proper ResultSet formats. + + public static void output(SPARQLResult result, ResultsFormat outputFormat, OutputStream output) { + if ( result.isResultSet() ) { + ResultSet rs = result.getResultSet(); + outputResultSet(rs, null, outputFormat, output); + return; + } + + if ( result.isModel() ) { + Model m = result.getModel(); + writeModel(m, outputFormat, output); + return; + } + + if ( result.isGraph() ) {} + + if ( result.isDataset() ) { + writeDataset(result.getDataset(), outputFormat, output); + return; + } + if ( result.isJson() ) { + result.getJsonItems(); + return; + } + } + + public static void outputResultSet(ResultSet resultSet, Prologue prologue, ResultsFormat outputFormat, OutputStream output) { if ( prologue == null ) prologue = new Prologue(globalPrefixMap) ; - Lang lang = ResultsFormat.convert(outputFormat) ; - if ( lang != null ) { - Context context = ARQ.getContext().copy(); - if ( prologue != null ) - context.set(ARQConstants.symPrologue, prologue); - ResultsWriter.create().context(context).lang(lang).build().write(output, results); - output.flush() ; - return ; + + if ( outputFormat == ResultsFormat.TEXT ) { + ResultSetFormatter.out(output, resultSet); + return; } - boolean done = ResultsFormat.oldWrite(output, outputFormat, prologue, results); - if ( !done ) - System.err.println("Unknown format request: " + outputFormat) ; - output.flush() ; + if ( outputFormat == ResultsFormat.COUNT ) { + long count = ResultSetFormatter.consume(resultSet); + String text = String.format("%d\n", count); + try ( PrintStream ps = new PrintStream(output) ) { + ps.print(text); + } + return; + } + + Lang rsLang = outputFormat.resultSetLang(); + + if ( rsLang == null ) { + RDFFormat asRDF = outputFormat.rdfFormat(); + Model model = RDFOutput.encodeAsModel(resultSet); + RDFWriter.source(model).format(asRDF).output(output); + return; + } + + if ( ! ResultSetLang.isRegistered(rsLang) ) + throw noFormatException("Not a result set output lang: "+rsLang.getName()); + + Context context = ARQ.getContext().copy(); + if ( prologue != null ) + context.set(ARQConstants.symPrologue, prologue); + ResultsWriter.create().context(context).lang(rsLang).build().write(output, resultSet); + return ; } - private static void doSelectQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, PrintStream output) { + private static void doSelectQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, OutputStream output) { if ( prologue == null ) prologue = qe.getQuery().getPrologue() ; - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_TEXT ; + if ( outputFormat == null ) + outputFormat = ResultsFormat.TEXT; ResultSet results = qe.execSelect() ; outputResultSet(results, prologue, outputFormat, output) ; } - private static void doJsonQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat, PrintStream output) { + private static void doJsonQuery(Prologue prologue, QueryExecution queryExecution, ResultsFormat outputFormat, OutputStream output) { JsonArray results = queryExecution.execJson(); JSON.write(output, results); } - private static void doDescribeQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, PrintStream output) { - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_RDF_TTL ; + private static void doDescribeQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, OutputStream output) { Model r = qe.execDescribe() ; - writeModel(prologue, r, outputFormat, output) ; + writeModel(r, outputFormat, output) ; } - private static void doConstructQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, PrintStream output) { + private static void doConstructQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, OutputStream output) { if ( qe.getQuery().isConstructQuad() ) { doConstructQuadsQuery(prologue, qe, outputFormat, output); return; } - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_RDF_TTL ; Model r = qe.execConstruct() ; - writeModel(prologue, r, outputFormat, output) ; + writeModel(r, outputFormat, output) ; } - private static void doConstructQuadsQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, PrintStream output) { - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_RDF_TRIG; + private static void doConstructQuadsQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, OutputStream output) { Dataset ds = qe.execConstructDataset(); - writeDataset(prologue, ds, outputFormat, output) ; - output.flush(); + writeDataset(ds, outputFormat, output) ; } - private static void writeModel(Prologue prologue, Model model, ResultsFormat outputFormat, PrintStream output) { - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_TEXT ; + private static void doAskQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, OutputStream output) { + boolean resultBoolean = qe.execAsk() ; - if ( outputFormat.equals(ResultsFormat.FMT_NONE) ) - return ; - - if ( outputFormat.equals(ResultsFormat.FMT_TEXT) ) { - output.println("# ======== ") ; - RDFDataMgr.write(output, model, Lang.TURTLE) ; - output.println("# ======== ") ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_XML) ) { - model.write(output, "RDF/XML-ABBREV", null) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_TTL) ) { - model.write(output, "N3", null) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_N3) ) { - model.write(output, "N3", null) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_NT) ) { - model.write(output, "N-TRIPLES", null) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_NQ) ) { - model.write(output, "N-QUADS", null) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_TRIG) ) { - model.write(output, "TriG", null) ; - return ; + if ( outputFormat == ResultsFormat.TEXT ) { + ResultSetFormatter.out(output, resultBoolean); + return; } - if ( outputFormat.equals(ResultsFormat.FMT_RDF_JSONLD) ) { - RDFDataMgr.write(output, model, Lang.JSONLD) ; - return ; + Lang rsLang = outputFormat.resultSetLang(); + if ( rsLang == null ) { + RDFFormat asRDF = outputFormat.rdfFormat(); + Model model = RDFOutput.encodeAsModel(resultBoolean); + RDFWriter.source(model).format(asRDF).output(output); + return; } - System.err.println("Unknown format: " + outputFormat) ; + ResultsWriter.create().lang(rsLang).build().write(output, resultBoolean); } - private static void writeDataset(Prologue prologue, Dataset dataset, ResultsFormat outputFormat, PrintStream output) { - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_TEXT ; - - if ( outputFormat.equals(ResultsFormat.FMT_NONE) ) - return ; - - if ( outputFormat.equals(ResultsFormat.FMT_TEXT) ) { - output.println("# ======== ") ; - RDFDataMgr.write(output, dataset, Lang.TURTLE) ; - output.println("# ======== ") ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_NQ) ) { - RDFDataMgr.write(output, dataset, Lang.NQUADS); - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_TRIG) ) { - RDFDataMgr.write(output, dataset, Lang.TRIG); - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_JSONLD) ) { - RDFDataMgr.write(output, dataset, Lang.JSONLD); - return ; - } - - System.err.println("Unknown format: " + outputFormat) ; + private static void writeModel(Model model, ResultsFormat outputFormat, OutputStream output) { + RDFFormat rdfFormat = RDFFormat.TURTLE_PRETTY; + RDFWriter.source(model).format(rdfFormat).output(output); + return; } + private static void writeDataset(Dataset dataset, ResultsFormat outputFormat, OutputStream output) { + RDFFormat rdfFormat = outputFormat.rdfFormat(); + if ( rdfFormat == null ) + throw noFormatException("No dataset output format for : "+outputFormat.name()); + RDFWriter.source(dataset).format(rdfFormat).output(output); + return; + } - private static void doAskQuery(Prologue prologue, QueryExecution qe, ResultsFormat outputFormat, PrintStream output) { - boolean b = qe.execAsk() ; - - if ( outputFormat == null || outputFormat == ResultsFormat.FMT_UNKNOWN ) - outputFormat = ResultsFormat.FMT_TEXT ; - - if ( outputFormat.equals(ResultsFormat.FMT_NONE) ) - return ; - - if ( outputFormat.equals(ResultsFormat.FMT_RS_XML) ) { - ResultSetFormatter.outputAsXML(output, b) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RDF_N3) || outputFormat.equals(ResultsFormat.FMT_RDF_TTL) ) { - RDFOutput.outputAsRDF(output, "TURTLE", b) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RS_JSON) ) { - ResultSetFormatter.outputAsJSON(output, b) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_TEXT) ) { - // ResultSetFormatter.out(System.out, b) ; - System.out.println("Ask => " + (b ? "Yes" : "No")) ; - return ; - } - - if ( outputFormat.equals(ResultsFormat.FMT_RS_CSV) ) { - ResultSetFormatter.outputAsCSV(System.out, b) ; - return ; - } - if ( outputFormat.equals(ResultsFormat.FMT_RS_TSV) ) { - ResultSetFormatter.outputAsTSV(System.out, b) ; - return ; - } - System.err.println("Unknown format: " + outputFormat) ; + private static RuntimeException noFormatException(String msg) { + return new ARQException(msg); } /** diff --git a/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/QueryTestItem.java b/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/QueryTestItem.java index 4f50a83ac1..b2bebb8640 100644 --- a/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/QueryTestItem.java +++ b/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/QueryTestItem.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.jena.arq.junit.sparql.tests ; +package org.apache.jena.arq.junit.sparql.tests; import java.util.ArrayList; import java.util.List; @@ -29,10 +29,9 @@ import org.apache.jena.graph.Node; import org.apache.jena.query.Dataset; import org.apache.jena.query.ResultSetFactory; import org.apache.jena.rdf.model.Model; -import org.apache.jena.rdf.model.ModelFactory; -import org.apache.jena.riot.RDFDataMgr; -import org.apache.jena.sparql.graph.GraphFactory; -import org.apache.jena.sparql.resultset.ResultsFormat; +import org.apache.jena.riot.Lang; +import org.apache.jena.riot.RDFLanguages; +import org.apache.jena.riot.resultset.ResultSetLang; import org.apache.jena.sparql.resultset.SPARQLResult; import org.apache.jena.sparql.vocabulary.TestManifestX; import org.apache.jena.sparql.vocabulary.VocabTestQuery; @@ -49,10 +48,10 @@ import org.apache.jena.vocabulary.TestManifest; */ public class QueryTestItem { - static int counter = 0 ; + static int counter = 0; public static String fakeURI() { - return "test:" + (++counter) ; + return "test:" + (++counter); } private final ManifestEntry manifestEntry; @@ -60,18 +59,18 @@ public class QueryTestItem private final Node testResource; private final Node actionResource; - private final String name ; + private final String name; - private boolean buildLuceneIndex = false ; - private final String resultFile ; - private final String comment ; - private List<String> defaultGraphURIs ; - private List<String> namedGraphURIs ; + private boolean buildLuceneIndex = false; + private final String resultFile; + private final String comment; + private List<String> defaultGraphURIs; + private List<String> namedGraphURIs; private final Node testType; private final String queryFile; public static QueryTestItem create(ManifestEntry entry, Node defaultTestType) { - return new QueryTestItem(entry, defaultTestType) ; + return new QueryTestItem(entry, defaultTestType); } private QueryTestItem(ManifestEntry entry, Node defaultTestType) { @@ -83,30 +82,30 @@ public class QueryTestItem actionResource = G.getOneSP(graph, testResource, TestManifest.action.asNode()); if ( ! G.hasProperty(graph, testResource, TestManifest.name.asNode()) ) - throw new TestSetupException("TestItem with no name (" + entry + ")") ; - name = _getName() ; + throw new TestSetupException("TestItem with no name (" + entry + ")"); + name = _getName(); if ( ! G.hasProperty(graph, testResource, TestManifest.action.asNode()) ) - throw new TestSetupException("TestItem '" + name + "' with no action") ; + throw new TestSetupException("TestItem '" + name + "' with no action"); // Assumes one type per test only. - Node _testType = G.getZeroOrOneSP(graph, testResource, RDF.Nodes.type) ; + Node _testType = G.getZeroOrOneSP(graph, testResource, RDF.Nodes.type); if ( _testType == null ) - _testType = defaultTestType ; + _testType = defaultTestType; testType = _testType; - resultFile = _getResultFile() ; - comment = _getComment() ; + resultFile = _getResultFile(); + comment = _getComment(); - defaultGraphURIs = _getDefaultGraphURIs() ; - namedGraphURIs = _getNamedGraphsURIs() ; + defaultGraphURIs = _getDefaultGraphURIs(); + namedGraphURIs = _getNamedGraphsURIs(); queryFile = SparqlTestLib.queryFile(entry); - buildLuceneIndex = _getTextIndex() ; + buildLuceneIndex = _getTextIndex(); } public Node getResource() { - return testResource ; + return testResource; } public Node getAction() { @@ -115,56 +114,56 @@ public class QueryTestItem /** @return Returns the testType. */ public Node getTestType() { - return testType ; + return testType; } public String getQueryFile() { - return queryFile ; + return queryFile; } public String getResultFile() { - return resultFile ; + return resultFile; } /** - * Load results as a SPARQLResult. If the results are a model, no conversion - * to a result set is attempted here. + * Load tests results as a SPARQLResult. + * <p> + * If the results are an RDF graph, no + * conversion to a result set is attempted here. */ public SPARQLResult getResults() { if ( resultFile == null ) - return null ; - ResultsFormat format = ResultsFormat.guessSyntax(resultFile) ; - - if ( ResultsFormat.isRDFGraphSyntax(format) ) { - // Load plain. - Graph g = GraphFactory.createDefaultGraph(); - SparqlTestLib.parser(resultFile).parse(g); - Model m = ModelFactory.createModelForGraph(g); - return new SPARQLResult(m) ; - } + return null; + Lang lang = RDFLanguages.pathnameToLang(resultFile); - if ( ResultsFormat.isDatasetSyntax(format) ) { - Dataset d = RDFDataMgr.loadDataset(resultFile) ; - return new SPARQLResult(d) ; + if ( ResultSetLang.isRegistered(lang) ) { + // Attempt to handle as a resultset or boolean result.s + SPARQLResult x = ResultSetFactory.result(resultFile); + return x; } - // Attempt to handle as a resultset or boolean result.s - SPARQLResult x = ResultSetFactory.result(resultFile) ; - return x ; + if ( RDFLanguages.isTriples(lang) ) { + // Load plain. No warnings. + Model m = SparqlTestLib.parser(resultFile).toModel(); + return new SPARQLResult(m); + } else { + Dataset d = SparqlTestLib.parser(resultFile).toDataset(); + return new SPARQLResult(d); + } } public String getName() { - return name ; + return name; } public String getURI() { if ( testResource != null && testResource.isURI() ) - return testResource.getURI() ; - return fakeURI() ; + return testResource.getURI(); + return fakeURI(); } public String getComment() { - return comment ; + return comment; } public ManifestEntry getManifestEntry() { @@ -172,19 +171,19 @@ public class QueryTestItem } public List<String> getDefaultGraphURIs() { - return defaultGraphURIs ; + return defaultGraphURIs; } public List<String> getNamedGraphURIs() { - return namedGraphURIs ; + return namedGraphURIs; } public boolean requiresTextIndex() { - return buildLuceneIndex ; + return buildLuceneIndex; } private String _getName() { - Node x = G.getOneSP(graph, testResource, TestManifest.name.asNode()) ; + Node x = G.getOneSP(graph, testResource, TestManifest.name.asNode()); if ( ! testResource.isURI() ) return G.asString(x); String ln = SplitIRI.localname(testResource.getURI()); @@ -193,8 +192,8 @@ public class QueryTestItem // private Resource _getAction() { // if ( actionResource == null ) -// actionResource = testResource.getProperty(TestManifest.action).getResource() ; -// return actionResource ; +// actionResource = testResource.getProperty(TestManifest.action).getResource(); +// return actionResource; // } // private String _getResultFile() { @@ -205,9 +204,9 @@ public class QueryTestItem } private String _getComment() { - Node c = G.getZeroOrOneSP(graph, testResource, RDFS.Nodes.comment) ; + Node c = G.getZeroOrOneSP(graph, testResource, RDFS.Nodes.comment); if ( c == null ) - return null ; + return null; return c.getLiteralLexicalForm(); } @@ -224,15 +223,15 @@ public class QueryTestItem private List<String> _getDefaultGraphURIs() { if ( ! actionResource.isBlank() ) // Action is not a blank node - the data had better be in the query itself. - return null ; + return null; - List<String> l = new ArrayList<>() ; + List<String> l = new ArrayList<>(); G.listSP(graph, actionResource, VocabTestQuery.data.asNode()).forEach(x->{ if ( ! x.isURI() ) throw new TestSetupException("Deafult Graph URI is not a URI: "+x); - l.add(x.getURI()) ; + l.add(x.getURI()); }); - return l ; + return l; } /** @@ -244,22 +243,22 @@ public class QueryTestItem private List<String> _getNamedGraphsURIs() { if ( ! actionResource.isBlank() ) // Action is not a blank node - the data had better be in the query itself. - return null ; + return null; - List<String> l = new ArrayList<>() ; + List<String> l = new ArrayList<>(); G.listSP(graph, actionResource, VocabTestQuery.graphData.asNode()).forEach(x->{ if ( ! x.isURI() ) throw new TestSetupException("Deafult Graph URI is not a URI: "+x); - l.add(x.getURI()) ; + l.add(x.getURI()); }); - return l ; + return l; } private boolean _getTextIndex() { - Node x = G.getZeroOrOneSP(graph, testResource, TestManifestX.textIndex.asNode()) ; + Node x = G.getZeroOrOneSP(graph, testResource, TestManifestX.textIndex.asNode()); if ( x == null ) - return false ; - return G.asString(x).equalsIgnoreCase("true") ; + return false; + return G.asString(x).equalsIgnoreCase("true"); } // ---------------------------------------------------- @@ -267,14 +266,14 @@ public class QueryTestItem @Override public String toString() { - StringBuilder sbuff = new StringBuilder() ; - String name = getName() ; - // String actionStr = FmtUtils.stringForRDFNode(_getAction()) ; + StringBuilder sbuff = new StringBuilder(); + String name = getName(); + // String actionStr = FmtUtils.stringForRDFNode(_getAction()); - sbuff.append("Name: " + name) ; + sbuff.append("Name: " + name); if ( getComment() != null ) - sbuff.append(" Comment: " + getComment()) ; - return sbuff.toString() ; + sbuff.append(" Comment: " + getComment()); + return sbuff.toString(); } } diff --git a/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/SparqlTestLib.java b/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/SparqlTestLib.java index 640aeb2f31..c6c80d4ecd 100644 --- a/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/SparqlTestLib.java +++ b/jena-arq/src/test/java/org/apache/jena/arq/junit/sparql/tests/SparqlTestLib.java @@ -37,7 +37,7 @@ import org.apache.jena.update.UpdateRequest; /** Misc code to make the tests clearer */ class SparqlTestLib { - // Data Parser - no warnings. + // Test data or results - no warnings. static RDFParserBuilder parser(String sourceURI) { return RDFParser.create().source(sourceURI).errorHandler(ErrorHandlerFactory.errorHandlerNoWarnings); } diff --git a/jena-arq/src/test/java/org/apache/jena/sparql/resultset/TestResultSet.java b/jena-arq/src/test/java/org/apache/jena/sparql/resultset/TestResultSet.java index 9c89a00948..676c934c29 100644 --- a/jena-arq/src/test/java/org/apache/jena/sparql/resultset/TestResultSet.java +++ b/jena-arq/src/test/java/org/apache/jena/sparql/resultset/TestResultSet.java @@ -176,19 +176,19 @@ public class TestResultSet { @Test public void test_RS_7() { ResultSet rs = ResultSetFactory.load(DIR + "output.srx"); - test_RS_fmt(rs, ResultsFormat.FMT_RS_XML, true); + test_RS_fmt(rs, ResultsFormat.XML, true); } @Test public void test_RS_8() { ResultSet rs = ResultSetFactory.load(DIR + "output.srx"); - test_RS_fmt(rs, ResultsFormat.FMT_RS_JSON, true); + test_RS_fmt(rs, ResultsFormat.JSON, true); } @Test public void test_RS_9() { ResultSet rs = ResultSetFactory.load(DIR + "output.srx"); - test_RS_fmt(rs, ResultsFormat.FMT_RDF_XML, false); + test_RS_fmt(rs, ResultsFormat.XML, false); } @Test diff --git a/jena-cmds/src/main/java/arq/cmdline/ModResultsIn.java b/jena-cmds/src/main/java/arq/cmdline/ModResultsIn.java index 5d097c7d05..af70cfbb2e 100644 --- a/jena-cmds/src/main/java/arq/cmdline/ModResultsIn.java +++ b/jena-cmds/src/main/java/arq/cmdline/ModResultsIn.java @@ -30,7 +30,7 @@ public class ModResultsIn extends ModBase protected final ArgDecl resultsInputFmtDecl = new ArgDecl(ArgDecl.HasValue, "in") ; protected final ArgDecl fileDecl = new ArgDecl(ArgDecl.HasValue, "file") ; - private ResultsFormat inputFormat = ResultsFormat.FMT_TEXT ; + private ResultsFormat inputFormat = ResultsFormat.TEXT; private String resultsFilename = null ; private ResultSet resultSet = null ; diff --git a/jena-cmds/src/main/java/arq/cmdline/ModResultsOut.java b/jena-cmds/src/main/java/arq/cmdline/ModResultsOut.java index 786d6721e5..a0f61bf7b1 100644 --- a/jena-cmds/src/main/java/arq/cmdline/ModResultsOut.java +++ b/jena-cmds/src/main/java/arq/cmdline/ModResultsOut.java @@ -31,7 +31,7 @@ import org.apache.jena.sparql.util.QueryExecUtils ; public class ModResultsOut extends ModBase { protected final ArgDecl resultsFmtDecl = new ArgDecl(ArgDecl.HasValue, "results", "out", "rfmt"); - private ResultsFormat resultsFormat = ResultsFormat.FMT_UNKNOWN; + private ResultsFormat resultsFormat = ResultsFormat.TEXT; @Override public void processArgs(CmdArgModule cmdline) throws IllegalArgumentException { @@ -48,7 +48,7 @@ public class ModResultsOut extends ModBase { cmdLine.getUsage().startCategory("Results"); cmdLine.add(resultsFmtDecl, "--results=", - "Results format (Result set: text, XML, JSON, CSV, TSV; Graph: RDF serialization)") ; + "Results format (Result set: text, XML, JSON, CSV, TSV; Graph: RDF serialization)") ; } public void checkCommandLine(CmdArgModule cmdLine) {} @@ -60,5 +60,4 @@ public class ModResultsOut extends ModBase { public ResultsFormat getResultsFormat() { return resultsFormat; } - } diff --git a/jena-cmds/src/main/java/arq/query.java b/jena-cmds/src/main/java/arq/query.java index f08f250f52..7ca0c85d7e 100644 --- a/jena-cmds/src/main/java/arq/query.java +++ b/jena-cmds/src/main/java/arq/query.java @@ -235,8 +235,9 @@ public class query extends CmdARQ Txn.executeRead(transactional, ()->{ modTime.startTimer() ; try ( QueryExecution qe = QueryExecutionFactory.create(query, dataset) ) { - try { QueryExecUtils.executeQuery(query, qe, fmt, resultsDest); } - catch (QueryCancelledException ex) { + try { + QueryExecUtils.executeQuery(query, qe, fmt, resultsDest); + } catch (QueryCancelledException ex) { IO.flush(resultsDest); System.err.println("Query timed out"); } diff --git a/jena-examples/src/main/java/rdfconnection/examples/RDFConnectionExampleDBpedia01.java b/jena-examples/src/main/java/rdfconnection/examples/RDFConnectionExampleDBpedia01.java index d587fec47c..47c8014350 100644 --- a/jena-examples/src/main/java/rdfconnection/examples/RDFConnectionExampleDBpedia01.java +++ b/jena-examples/src/main/java/rdfconnection/examples/RDFConnectionExampleDBpedia01.java @@ -42,7 +42,7 @@ public class RDFConnectionExampleDBpedia01 { .acceptHeaderSelectQuery(acceptHeader).parseCheckSPARQL(false).build()) { try (QueryExecution qe = conn.query(queryString)) { ResultSet rs = qe.execSelect(); - ResultSetFormatter.output(System.out, rs, ResultsFormat.FMT_TEXT); + ResultSetFormatter.output(System.out, rs, ResultsFormat.TEXT); } catch (Exception e) { System.out.println("Request failed: " + e.getMessage()); }
