/// <summary>
/// Writes the SPARQL Result Set to a String and returns the Output in your chosen format
/// </summary>
/// <param name="results">SPARQL Result Set</param>
/// <param name="writer">Writer to use to generate the SPARQL Results output</param>
/// <returns></returns>
public static String Write(SparqlResultSet results, ISparqlResultsWriter writer)
{
System.IO.StringWriter sw = new System.IO.StringWriter();
writer.Save(results, sw);
return(sw.ToString());
}
public static void Save(this ISparqlResultsWriter resultsWriter, SparqlResultSet resultSet, string filename)
{
using (var output = new StreamWriter(filename))
{
resultsWriter.Save(resultSet, output);
}
}
/// <summary>
/// Creates a new GZipped Results writer
/// </summary>
/// <param name="writer">Underlying writer</param>
public BaseGZipResultsWriter(ISparqlResultsWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
this._writer = writer;
this._writer.Warning += this.RaiseWarning;
}
private void EnsureTestData(String file, ISparqlResultsWriter writer)
{
if (!File.Exists(file))
{
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
SparqlResultSet results = g.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }") as SparqlResultSet;
if (results == null) Assert.Fail("Failed to generate sample SPARQL Results");
writer.Save(results, file);
}
}
private bool SetResultsFormat(String format)
{
switch (format)
{
case "xml":
this._resultsWriter = new SparqlXmlWriter();
this._graphWriter = new RdfXmlWriter();
break;
case "json":
this._resultsWriter = new SparqlJsonWriter();
this._graphWriter = new RdfJsonWriter();
break;
case "ntriples":
this._graphWriter = new NTriplesWriter();
break;
case "rdfxml":
this._graphWriter = new RdfXmlWriter();
break;
case "turtle":
this._graphWriter = new CompressingTurtleWriter(WriterCompressionLevel.High);
break;
case "n3":
this._graphWriter = new Notation3Writer(WriterCompressionLevel.High);
break;
case "html":
case "rdfa":
this._resultsWriter = new SparqlHtmlWriter();
this._graphWriter = new HtmlWriter();
break;
case "csv":
this._resultsWriter = new SparqlCsvWriter();
this._graphWriter = new CsvWriter();
break;
case "tsv":
this._resultsWriter = new SparqlTsvWriter();
this._graphWriter = new TsvWriter();
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + format + "' is not a valid Results Format");
return(false);
}
return(true);
}
private void TestSparqlWriterConneg(String header, Type expected, String contentType)
{
String ctype;
ISparqlResultsWriter writer = MimeTypesHelper.GetSparqlWriter(header, out ctype);
Console.WriteLine("Accept Header: " + header);
Console.WriteLine("Expected Writer: " + expected.Name);
Console.WriteLine("Actual Writer: " + writer.GetType().Name);
Console.WriteLine("Expected Content Type: " + contentType);
Console.WriteLine("Actual Content Type: " + ctype);
Assert.AreEqual(expected, writer.GetType());
Assert.AreEqual(contentType, ctype);
}
private void EnsureTestData(String file, ISparqlResultsWriter writer)
{
if (!File.Exists(file))
{
Graph g = new Graph();
g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
g.Retract(g.Triples.Where(t => !t.IsGroundTriple).ToList());
SparqlResultSet results = g.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }") as SparqlResultSet;
if (results == null)
{
Assert.True(false, "Failed to generate sample SPARQL Results");
}
writer.Save(results, file);
}
}
private void btnExport_Click(object sender, EventArgs e)
{
ExportResultSetOptionsForm exporter = new ExportResultSetOptionsForm();
if (exporter.ShowDialog() == DialogResult.OK)
{
ISparqlResultsWriter writer = exporter.Writer;
String file = exporter.File;
try
{
writer.Save(this._results, file);
MessageBox.Show("Successfully exported the SPARQL Results to the file '" + file + "'", "SPARQL Results Export Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("An error occurred attempting to export the SPARQL Results:\n" + ex.Message, "SPARQL Results Export Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// Creates a new Export SPARQL Results Options Form
/// </summary>
public ExportResultSetOptionsForm()
{
InitializeComponent();
//Load Writers
Type targetType = typeof(ISparqlResultsWriter);
List <ISparqlResultsWriter> writers = new List <ISparqlResultsWriter>();
foreach (Type t in Assembly.GetAssembly(targetType).GetTypes())
{
if (t.Namespace == null)
{
continue;
}
if (t.Namespace.Equals("VDS.RDF.Writing"))
{
if (t.GetInterfaces().Contains(targetType))
{
try
{
ISparqlResultsWriter writer = (ISparqlResultsWriter)Activator.CreateInstance(t);
writers.Add(writer);
}
catch
{
//Ignore this Writer
}
}
}
}
writers.Sort(new ToStringComparer <ISparqlResultsWriter>());
this.cboWriter.DataSource = writers;
if (this.cboWriter.Items.Count > 0)
{
this.cboWriter.SelectedIndex = 0;
}
this.cboWriter.SelectedIndex = 0;
}
private void cboResultsFormat_SelectedIndexChanged(object sender, EventArgs e)
{
fclsStylesheetPicker stylesheetPicker;
switch (this.cboResultsFormat.SelectedIndex)
{
case 0:
this._resultswriter = new SparqlCsvWriter();
this._resultsext = ".csv";
break;
case 1:
this._resultswriter = new SparqlRdfWriter(this._rdfwriter);
this._resultsext = this._rdfext;
break;
case 2:
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
break;
case 3:
stylesheetPicker = new fclsStylesheetPicker("CSS");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
SparqlHtmlWriter temp = new SparqlHtmlWriter();
temp.Stylesheet = stylesheetPicker.StylesheetUri;
this._resultswriter = temp;
}
else
{
this._resultswriter = new SparqlHtmlWriter();
}
this._resultsext = ".html";
break;
case 4:
this._resultswriter = new SparqlJsonWriter();
this._resultsext = ".json";
break;
case 5:
this._resultswriter = new SparqlTsvWriter();
this._resultsext = ".tsv";
break;
case 6:
this._resultswriter = new SparqlXmlWriter();
this._resultsext = ".srx";
break;
case 7:
stylesheetPicker = new fclsStylesheetPicker("XSLT");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
try
{
this._resultswriter = new SparqlXsltWriter(stylesheetPicker.StylesheetUri);
this._resultsext = ".xml";
}
catch (Exception ex)
{
MessageBox.Show("Unable to use the selected XSLT Stylesheet due to the following error:\n" + ex.Message, "Invalid Stylesheet", MessageBoxButtons.OK, MessageBoxIcon.Warning);
this.cboResultsFormat.SelectedIndex = 2;
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
}
}
else
{
this.cboResultsFormat.SelectedIndex = 2;
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
}
break;
}
}
/// <summary>
/// Creates a new GZipped Results writer
/// </summary>
/// <param name="writer">Underlying writer</param>
public BaseGZipResultsWriter(ISparqlResultsWriter writer)
{
if (writer == null) throw new ArgumentNullException("writer");
this._writer = writer;
this._writer.Warning += this.RaiseWarning;
}
/// <summary>
/// Registers a writer as the default SPARQL Results Writer for all the given MIME types and updates relevant definitions to include the MIME types and file extensions
/// </summary>
/// <param name="writer">SPARQL Results Writer</param>
/// <param name="mimeTypes">MIME Types</param>
/// <param name="fileExtensions">File Extensions</param>
public static void RegisterWriter(ISparqlResultsWriter writer, IEnumerable<String> mimeTypes, IEnumerable<String> fileExtensions)
{
if (!_init) Init();
if (!mimeTypes.Any()) throw new RdfException("Cannot register a writer without specifying at least 1 MIME Type");
//Get any existing defintions that are to be altered
IEnumerable<MimeTypeDefinition> existing = GetDefinitions(mimeTypes);
foreach (MimeTypeDefinition def in existing)
{
foreach (String type in mimeTypes)
{
def.AddMimeType(type);
}
foreach (String ext in fileExtensions)
{
def.AddFileExtension(ext);
}
def.SparqlResultsWriterType = writer.GetType();
}
//Create any new defintions
IEnumerable<String> newTypes = mimeTypes.Where(t => !GetDefinitions(t).Any());
if (newTypes.Any())
{
MimeTypeDefinition newDef = new MimeTypeDefinition(String.Empty, newTypes, fileExtensions);
newDef.SparqlResultsWriterType = writer.GetType();
AddDefinition(newDef);
}
}
private void cboResultsFormat_SelectedIndexChanged(object sender, EventArgs e)
{
fclsStylesheetPicker stylesheetPicker;
switch (this.cboResultsFormat.SelectedIndex)
{
case 0:
this._resultswriter = new SparqlCsvWriter();
this._resultsext = ".csv";
break;
case 1:
this._resultswriter = new SparqlRdfWriter(this._rdfwriter);
this._resultsext = this._rdfext;
break;
case 2:
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
break;
case 3:
stylesheetPicker = new fclsStylesheetPicker("CSS");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
SparqlHtmlWriter temp = new SparqlHtmlWriter();
temp.Stylesheet = stylesheetPicker.StylesheetUri;
this._resultswriter = temp;
}
else
{
this._resultswriter = new SparqlHtmlWriter();
}
this._resultsext = ".html";
break;
case 4:
this._resultswriter = new SparqlJsonWriter();
this._resultsext = ".json";
break;
case 5:
this._resultswriter = new SparqlTsvWriter();
this._resultsext = ".tsv";
break;
case 6:
this._resultswriter = new SparqlXmlWriter();
this._resultsext = ".srx";
break;
case 7:
stylesheetPicker = new fclsStylesheetPicker("XSLT");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
try
{
this._resultswriter = new SparqlXsltWriter(stylesheetPicker.StylesheetUri);
this._resultsext = ".xml";
}
catch (Exception ex)
{
MessageBox.Show("Unable to use the selected XSLT Stylesheet due to the following error:\n" + ex.Message, "Invalid Stylesheet", MessageBoxButtons.OK, MessageBoxIcon.Warning);
this.cboResultsFormat.SelectedIndex = 2;
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
}
}
else
{
this.cboResultsFormat.SelectedIndex = 2;
this._resultswriter = new SparqlHtmlWriter();
this._resultsext = ".html";
}
break;
}
}
private void cboGraphFormat_SelectedIndexChanged(object sender, EventArgs e)
{
switch (this.cboGraphFormat.SelectedIndex)
{
case 0:
this._rdfwriter = new CsvWriter();
this._rdfext = ".csv";
break;
case 1:
fclsStylesheetPicker stylesheetPicker = new fclsStylesheetPicker("CSS (Optional)");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
HtmlWriter temp = new HtmlWriter();
temp.Stylesheet = stylesheetPicker.StylesheetUri;
this._rdfwriter = temp;
}
else
{
this._rdfwriter = new HtmlWriter();
}
this._rdfext = ".html";
break;
case 2:
this._rdfwriter = new Notation3Writer();
this._rdfext = ".n3";
break;
case 3:
this._rdfwriter = new NTriplesWriter();
this._rdfext = ".nt";
break;
case 4:
this._rdfwriter = new RdfJsonWriter();
this._rdfext = ".json";
break;
case 5:
this._rdfwriter = new RdfXmlWriter();
this._rdfext = ".rdf";
break;
case 6:
this._rdfwriter = new CompressingTurtleWriter();
this._rdfext = ".ttl";
break;
case 7:
this._rdfwriter = new TsvWriter();
this._rdfext = ".tsv";
break;
}
if (this._rdfwriter is ICompressingWriter)
{
((ICompressingWriter)this._rdfwriter).CompressionLevel = WriterCompressionLevel.High;
}
if (this.cboResultsFormat.SelectedIndex == 1)
{
this._resultswriter = new SparqlRdfWriter(this._rdfwriter);
this._resultsext = this._rdfext;
}
}
// See https://github.com/dotnetrdf/dotnetrdf/blob/5b7fc480346c90eb9b164fb4f8ee09f378442d52/Libraries/dotNetRDF.Web/HandlerHelper.cs#L157
/// <summary>
/// Helper function which returns the Results (Graph/Triple Store/SPARQL Results) back to the Client in one of their accepted formats
/// </summary>
/// <param name="context">Context of the HTTP Request</param>
/// <param name="result">Results of the Sparql Query</param>
/// <param name="config">Handler Configuration</param>
public static void SendToClient(HttpContext context, SparqlQueryResult result)
{
MimeTypeDefinition definition = null;
const string TEXT_PLAIN = "text/plain";
var acceptTypes = context.Request.Headers[HeaderNames.Accept];
// Return the Results
if (result.SparqlResultSet != null)
{
ISparqlResultsWriter sparqlWriter = null;
// Try and get a MIME Type Definition using the HTTP Requests Accept Header
if (acceptTypes.Count > 0)
{
definition = MimeTypesHelper.GetDefinitions((IEnumerable <string>)acceptTypes).FirstOrDefault(d => d.CanWriteSparqlResults);
}
// Try and get the registered Definition for SPARQL Results XML
if (definition == null)
{
definition = MimeTypesHelper.GetDefinitions(MimeTypesHelper.SparqlResultsXml[0]).FirstOrDefault();
}
// If Definition is still null create a temporary definition
if (definition == null)
{
definition = new MimeTypeDefinition("SPARQL Results XML", MimeTypesHelper.SparqlResultsXml, Enumerable.Empty <String>());
definition.SparqlResultsWriterType = typeof(VDS.RDF.Writing.SparqlXmlWriter);
}
// Set up the Writer appropriately
sparqlWriter = definition.GetSparqlResultsWriter();
context.Response.ContentType = definition.CanonicalMimeType;
// HandlerHelper.ApplyWriterOptions(sparqlWriter, config);
// Send Result Set to Client
context.Response.Headers[HeaderNames.ContentEncoding] = definition.Encoding.WebName;
sparqlWriter.Save(result.SparqlResultSet, new StreamWriter(context.Response.Body, definition.Encoding));
}
else if (result.Graph != null)
{
IRdfWriter rdfWriter = null;
var ctype = TEXT_PLAIN;
// Try and get a MIME Type Definition using the HTTP Requests Accept Header
if (acceptTypes.Count > 0)
{
definition = MimeTypesHelper.GetDefinitions((IEnumerable <string>)acceptTypes).FirstOrDefault(d => d.CanWriteRdf);
}
if (definition == null)
{
// If no appropriate definition then use the GetWriter method instead
rdfWriter = MimeTypesHelper.GetWriter((IEnumerable <string>)acceptTypes, out ctype);
}
else
{
rdfWriter = definition.GetRdfWriter();
}
// Setup the writer
if (definition != null)
{
ctype = definition.CanonicalMimeType;
}
context.Response.ContentType = ctype;
//HandlerHelper.ApplyWriterOptions(rdfWriter, config);
// Clear any existing Response
//context.Response.Clear();
// Send Graph to Client
if (definition != null)
{
context.Response.Headers[HeaderNames.ContentEncoding] = definition.Encoding.WebName;
rdfWriter.Save(result.Graph, new StreamWriter(context.Response.Body, definition.Encoding));
}
else
{
rdfWriter.Save(result.Graph, new StreamWriter(context.Response.Body));
}
}
else
{
Debug.Assert(result == SparqlQueryResult.Null);
}
}
private void EnsureTestData(String file)
{
ISparqlResultsWriter writer = MimeTypesHelper.GetSparqlWriter(MimeTypesHelper.GetMimeTypes(Path.GetExtension(file)));
this.EnsureTestData(file, writer);
}
/// <summary>
/// Helper function which returns the Results (Graph/Triple Store/SPARQL Results) back to the Client in one of their accepted formats
/// </summary>
/// <param name="context">Context of the HTTP Request</param>
/// <param name="result">Results of the Sparql Query</param>
/// <param name="config">Handler Configuration</param>
public static void SendToClient(HttpContext context, Object result, BaseHandlerConfiguration config)
{
MimeTypeDefinition definition = null;
String ctype = "text/plain";
String[] acceptTypes = HandlerHelper.GetAcceptTypes(context);
//Return the Results
if (result is SparqlResultSet)
{
ISparqlResultsWriter sparqlWriter = null;
//Try and get a MIME Type Definition using the HTTP Requests Accept Header
if (acceptTypes != null)
{
definition = MimeTypesHelper.GetDefinitions(acceptTypes).FirstOrDefault(d => d.CanWriteSparqlResults);
}
//Try and get the registered Definition for SPARQL Results XML
if (definition == null)
{
definition = MimeTypesHelper.GetDefinitions(MimeTypesHelper.SparqlXml[0]).FirstOrDefault();
}
//If Definition is still null create a temporary definition
if (definition == null)
{
definition = new MimeTypeDefinition("SPARQL Results XML", MimeTypesHelper.SparqlXml, Enumerable.Empty <String>());
definition.SparqlResultsWriterType = typeof(VDS.RDF.Writing.SparqlXmlWriter);
}
//Set up the Writer appropriately
sparqlWriter = definition.GetSparqlResultsWriter();
context.Response.ContentType = definition.CanonicalMimeType;
HandlerHelper.ApplyWriterOptions(sparqlWriter, config);
//Clear any existing Response
context.Response.Clear();
//Send Result Set to Client
context.Response.ContentEncoding = definition.Encoding;
sparqlWriter.Save((SparqlResultSet)result, new StreamWriter(context.Response.OutputStream, definition.Encoding));
}
else if (result is IGraph)
{
IRdfWriter rdfWriter = null;
//Try and get a MIME Type Definition using the HTTP Requests Accept Header
if (acceptTypes != null)
{
definition = MimeTypesHelper.GetDefinitions(acceptTypes).FirstOrDefault(d => d.CanWriteRdf);
}
if (definition == null)
{
//If no appropriate definition then use the GetWriter method instead
rdfWriter = MimeTypesHelper.GetWriter(acceptTypes, out ctype);
}
else
{
rdfWriter = definition.GetRdfWriter();
}
//Setup the writer
if (definition != null)
{
ctype = definition.CanonicalMimeType;
}
context.Response.ContentType = ctype;
HandlerHelper.ApplyWriterOptions(rdfWriter, config);
//Clear any existing Response
context.Response.Clear();
//Send Graph to Client
if (definition != null)
{
context.Response.ContentEncoding = definition.Encoding;
rdfWriter.Save((IGraph)result, new StreamWriter(context.Response.OutputStream, definition.Encoding));
}
else
{
rdfWriter.Save((IGraph)result, new StreamWriter(context.Response.OutputStream));
}
}
else if (result is ITripleStore)
{
IStoreWriter storeWriter = null;
//Try and get a MIME Type Definition using the HTTP Requests Accept Header
if (acceptTypes != null)
{
definition = MimeTypesHelper.GetDefinitions(acceptTypes).FirstOrDefault(d => d.CanWriteRdfDatasets);
}
if (definition == null)
{
//If no appropriate definition then use the GetStoreWriter method instead
storeWriter = MimeTypesHelper.GetStoreWriter(acceptTypes, out ctype);
}
else
{
storeWriter = definition.GetRdfDatasetWriter();
}
//Setup the writer
if (definition != null)
{
ctype = definition.CanonicalMimeType;
}
context.Response.ContentType = ctype;
HandlerHelper.ApplyWriterOptions(storeWriter, config);
//Clear any existing Response
context.Response.Clear();
//Send Triple Store to Client
if (definition != null)
{
context.Response.ContentEncoding = definition.Encoding;
storeWriter.Save((ITripleStore)result, new VDS.RDF.Storage.Params.StreamParams(context.Response.OutputStream, definition.Encoding));
}
else
{
storeWriter.Save((ITripleStore)result, new VDS.RDF.Storage.Params.StreamParams(context.Response.OutputStream));
}
}
else if (result is ISparqlDataset)
{
//Wrap in a Triple Store and then call self so the Triple Store writing branch of this if gets called instead
TripleStore store = new TripleStore(new DatasetGraphCollection((ISparqlDataset)result));
HandlerHelper.SendToClient(context, store, config);
}
else
{
throw new RdfOutputException("Unexpected Result Object of Type '" + result.GetType().ToString() + "' returned - unable to write Objects of this Type to the HTTP Response");
}
}
static void DoQuery(Dictionary <String, String> arguments)
{
SparqlRemoteEndpoint endpoint;
bool verbose = arguments.ContainsKey("verbose") || arguments.ContainsKey("v");
if (verbose)
{
Options.HttpDebugging = true;
}
//First get the Server to which we are going to connect
try
{
if (arguments.ContainsKey("server") && !arguments["server"].Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(new Uri(arguments["server"]));
}
else if (arguments.ContainsKey("service") && !arguments["service"].Equals(String.Empty))
{
endpoint = new SparqlRemoteEndpoint(new Uri(arguments["service"]));
}
else
{
Console.Error.WriteLine("soh: Error: Required --server/--service argument not present");
Environment.Exit(-1);
return;
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("soh: Error: Malformed SPARQL Endpoint URI");
Console.Error.WriteLine(uriEx.Message);
Environment.Exit(-1);
return;
}
if (verbose)
{
Console.Error.WriteLine("soh: SPARQL Endpoint for URI " + endpoint.Uri + " created OK");
}
//Then decide where to get the query to execute from
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery query;
try
{
if (arguments.ContainsKey("query") && !arguments["query"].Equals(String.Empty))
{
query = parser.ParseFromFile(arguments["query"]);
}
else if (arguments.ContainsKey("file") && !arguments["file"].Equals(String.Empty))
{
query = parser.ParseFromFile(arguments["file"]);
}
else if (arguments.ContainsKey("$1") && !arguments["$1"].Equals(String.Empty))
{
query = parser.ParseFromString(arguments["$1"]);
}
else
{
Console.Error.WriteLine("soh: Error: Required SPARQL Query not found - may be specified as --file/--query FILE or as final argument");
Environment.Exit(-1);
return;
}
}
catch (Exception ex)
{
Console.Error.WriteLine("soh: Error: Error Parsing SPARQL Query");
Console.Error.WriteLine(ex.Message);
Environment.Exit(-1);
return;
}
if (verbose)
{
Console.Error.WriteLine("soh: Parsed Query OK");
Console.Error.WriteLine("soh: dotNetRDF's interpretation of the Query:");
SparqlFormatter formatter = new SparqlFormatter();
Console.Error.WriteLine(formatter.Format(query));
Console.Error.WriteLine("soh: Submitting Query");
}
try
{
using (HttpWebResponse response = endpoint.QueryRaw(query.ToString()))
{
MimeTypeDefinition definition = MimeTypesHelper.GetDefinitions(response.ContentType).FirstOrDefault();
Encoding enc;
if (definition != null)
{
enc = definition.Encoding;
}
else if (!response.ContentEncoding.Equals(String.Empty))
{
enc = Encoding.GetEncoding(response.ContentEncoding);
}
else if (response.ContentType.Contains("charset="))
{
enc = Encoding.GetEncoding(response.ContentType.Substring(response.ContentType.IndexOf('=') + 1));
}
else
{
enc = Console.OutputEncoding;
}
if (verbose)
{
Console.Error.WriteLine("soh: Got Response from SPARQL Endpoint OK");
Console.Error.WriteLine("soh: Content-Type: " + response.ContentType);
Console.Error.WriteLine("soh: Content-Encoding: " + enc.WebName);
}
String requestedType = arguments.ContainsKey("accept") ? arguments["accept"] : null;
if (requestedType == null || response.ContentType.StartsWith(requestedType, StringComparison.OrdinalIgnoreCase))
{
//If no --accept (OR matches servers content type) then just return whatever the server has given us
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
using (StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(), enc))
{
while (!reader.EndOfStream)
{
writer.WriteLine(reader.ReadLine());
}
writer.Close();
}
reader.Close();
}
}
else
{
if (verbose)
{
Console.Error.WriteLine("soh: Warning: Retrieved Content Type '" + response.ContentType + "' does not match your desired Content Type '" + requestedType + "' so dotNetRDF will not attempt to transcode the response into your desired format");
}
//Requested Type Doesn't match servers returned type so parse then serialize
MimeTypeDefinition outputDefinition;
try
{
ISparqlResultsReader sparqlParser = MimeTypesHelper.GetSparqlParser(response.ContentType);
SparqlResultSet results = new SparqlResultSet();
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
sparqlParser.Load(results, reader);
reader.Close();
}
outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteSparqlResults || d.CanWriteRdf);
if (outputDefinition == null)
{
throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write SPARQL Results/RDF");
}
ISparqlResultsWriter writer = outputDefinition.GetSparqlResultsWriter();
Console.OutputEncoding = outputDefinition.Encoding;
writer.Save(results, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding));
}
catch (RdfParserSelectionException)
{
try
{
IRdfReader rdfParser = MimeTypesHelper.GetParser(response.ContentType);
Graph g = new Graph();
using (StreamReader reader = new StreamReader(response.GetResponseStream()))
{
rdfParser.Load(g, reader);
reader.Close();
}
outputDefinition = MimeTypesHelper.GetDefinitions(requestedType).FirstOrDefault(d => d.CanWriteRdf);
if (outputDefinition == null)
{
throw new RdfWriterSelectionException("No MIME Type Definition for the MIME Type '" + requestedType + "' was found that can write RDF");
}
IRdfWriter writer = outputDefinition.GetRdfWriter();
Console.OutputEncoding = outputDefinition.Encoding;
writer.Save(g, new StreamWriter(Console.OpenStandardOutput(), outputDefinition.Encoding));
}
catch (Exception ex)
{
//For any other exception show a warning
Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format.");
Console.Error.WriteLine(ex.Message);
}
}
catch (Exception ex)
{
//For any other exception show a warning
Console.Error.WriteLine("soh: Warning: You wanted results in the format '" + requestedType + "' but the server returned '" + response.ContentType + "' and dotNetRDF was unable to translate the response into your desired format.");
Console.Error.WriteLine(ex.Message);
}
}
response.Close();
}
if (verbose)
{
Console.Error.WriteLine("soh: Query Completed OK");
}
}
catch (Exception ex)
{
Console.Error.WriteLine("soh: Error: Error while making the SPARQL Query");
Console.Error.WriteLine(ex.Message);
Environment.Exit(-1);
return;
}
}
public BrightstarSparqlResultsType ExecuteSparql(SparqlQuery query, IStore store, TextWriter resultsWriter)
{
try
{
EnsureValidResultFormat(query);
var dataset = MakeDataset(store);
if (_defaultGraphUris != null)
{
dataset.SetDefaultGraph(_defaultGraphUris);
}
var queryProcessor = new BrightstarQueryProcessor(store, dataset);
var queryResult = queryProcessor.ProcessQuery(query);
if (queryResult is SparqlResultSet)
{
var sparqlResultSet = (SparqlResultSet)queryResult;
ISparqlResultsWriter sparqlResultsWriter = null;
if (_sparqlResultsFormat != null)
{
sparqlResultsWriter =
MimeTypesHelper.GetSparqlWriter(new string[] { _sparqlResultsFormat.ToString() });
}
if (sparqlResultsWriter == null)
{
throw new NoAcceptableFormatException(typeof(SparqlResultsFormat),
"No acceptable format provided for writing a SPARQL result set.");
}
sparqlResultsWriter.Save(sparqlResultSet, resultsWriter);
switch (sparqlResultSet.ResultsType)
{
case SparqlResultsType.Boolean:
return(BrightstarSparqlResultsType.Boolean);
case SparqlResultsType.VariableBindings:
return(BrightstarSparqlResultsType.VariableBindings);
default:
throw new BrightstarInternalException("Unrecognized SPARQL result type");
}
}
if (queryResult is IGraph)
{
var g = (IGraph)queryResult;
var rdfWriter = _rdfFormat == null
? null
: MimeTypesHelper.GetWriter(new string[] { _rdfFormat.ToString() });
if (rdfWriter == null)
{
throw new NoAcceptableFormatException(typeof(RdfFormat),
"No acceptable format provided for writing an RDF graph result.");
}
rdfWriter.Save(g, resultsWriter);
try
{
resultsWriter.Flush();
}
catch (ObjectDisposedException)
{
// resultWriter is already closed
}
return(BrightstarSparqlResultsType.Graph);
}
throw new BrightstarInternalException(
String.Format("Unexpected return type from QueryProcessor.ProcessQuery: {0}",
queryResult.GetType()));
}
catch (Exception ex)
{
Logging.LogError(BrightstarEventId.SparqlExecutionError,
"Error Executing query {0}. Cause: {1}",
query.ToString(), ex);
throw;
}
}
private bool SetOptions(String[] args)
{
if (args.Length == 0 || args.Length == 1 && args[0].Equals("-help"))
{
this.ShowUsage();
return(false);
}
String arg;
int i = 0;
while (i < args.Length)
{
arg = args[i];
if (arg.StartsWith("-uri:"))
{
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify input URIs as well as specifying a remote endpoint to query");
return(false);
}
String uri = arg.Substring(5);
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given URI
if (!this._print)
{
Uri u = new Uri(uri);
Graph g = new Graph();
UriLoader.Load(g, u);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since this is not a valid URI");
if (this._debug)
{
this.DebugErrors(uriEx);
}
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
}
}
else if (arg.StartsWith("-endpoint:"))
{
if (this._mode == RdfQueryMode.Local)
{
Console.Error.WriteLine("rdfQuery: Cannot specify a remote endpoint to query as well as specifying local files and/or input URIs");
return(false);
}
else if (this._mode == RdfQueryMode.Remote)
{
if (!(this._endpoint is FederatedSparqlRemoteEndpoint))
{
this._endpoint = new FederatedSparqlRemoteEndpoint(this._endpoint);
}
}
try
{
this._mode = RdfQueryMode.Remote;
if (this._endpoint is FederatedSparqlRemoteEndpoint)
{
((FederatedSparqlRemoteEndpoint)this._endpoint).AddEndpoint(new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1))));
}
else
{
this._endpoint = new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1)));
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Unable to use remote endpoint with URI '" + arg.Substring(arg.IndexOf(':') + 1) + "' since this is not a valid URI");
if (this._debug)
{
this.DebugErrors(uriEx);
}
return(false);
}
}
else if (arg.StartsWith("-output:") || arg.StartsWith("-out:"))
{
this._output = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("-outformat:"))
{
String format = arg.Substring(arg.IndexOf(':') + 1);
try
{
if (format.Contains("/"))
{
//MIME Type
this._graphWriter = MimeTypesHelper.GetWriter(format);
this._resultsWriter = MimeTypesHelper.GetSparqlWriter(format);
}
else
{
//File Extension
this._graphWriter = MimeTypesHelper.GetWriterByFileExtension(format);
this._resultsWriter = MimeTypesHelper.GetSparqlWriterByFileExtension(format);
}
}
catch (RdfException)
{
Console.Error.WriteLine("rdfQuery: The file extension '" + format + "' could not be used to determine a MIME Type and select a writer - default writers will be used");
}
}
else if (arg.StartsWith("-syntax"))
{
if (arg.Contains(':'))
{
String syntax = arg.Substring(arg.IndexOf(':') + 1);
switch (syntax)
{
case "1":
case "1.0":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_0;
break;
case "1.1":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_1;
break;
case "E":
case "e":
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + syntax + "' is not a valid query syntax specifier - assuming SPARQL 1.1 with Extensions");
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
}
}
else
{
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
}
}
else if (arg.StartsWith("-timeout:"))
{
long timeout;
if (Int64.TryParse(arg.Substring(arg.IndexOf(':') + 1), out timeout))
{
this._timeout = timeout;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid timeout in milliseconds - default timeouts will be used");
}
}
else if (arg.StartsWith("-r:"))
{
arg = arg.Substring(arg.IndexOf(':') + 1);
switch (arg)
{
case "rdfs":
((IInferencingTripleStore)this._store).AddInferenceEngine(new RdfsReasoner());
break;
case "skos":
((IInferencingTripleStore)this._store).AddInferenceEngine(new SkosReasoner());
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + arg + "' is not a valid Reasoner - ignoring this option");
break;
}
}
else if (arg.StartsWith("-partialResults"))
{
if (arg.Contains(':'))
{
bool partial;
if (Boolean.TryParse(arg.Substring(arg.IndexOf(':') + 1), out partial))
{
this._partialResults = partial;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid boolean - partial results mode is disabled");
}
}
else
{
this._partialResults = true;
}
}
else if (arg.StartsWith("-noopt"))
{
if (arg.Equals("-noopt"))
{
Options.QueryOptimisation = false;
Options.AlgebraOptimisation = false;
}
else if (arg.Length >= 7)
{
String opts = arg.Substring(7);
foreach (char c in opts.ToCharArray())
{
if (c == 'a' || c == 'A')
{
Options.AlgebraOptimisation = false;
}
else if (c == 'q' || c == 'Q')
{
Options.QueryOptimisation = false;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + c + "' as part of the -noopt argument is not supported - it has been ignored");
}
}
}
}
else if (arg.Equals("-nocache"))
{
Options.UriLoaderCaching = false;
}
else if (arg.Equals("-nobom"))
{
Options.UseBomForUtf8 = false;
}
else if (arg.Equals("-print"))
{
this._print = true;
}
else if (arg.Equals("-debug"))
{
this._debug = true;
}
else if (arg.StartsWith("-explain"))
{
this._explain = true;
if (arg.Length > 9)
{
try
{
this._level = (ExplanationLevel)Enum.Parse(typeof(ExplanationLevel), arg.Substring(9));
this._level = (this._level | ExplanationLevel.OutputToConsoleStdErr | ExplanationLevel.Simulate) ^ ExplanationLevel.OutputToConsoleStdOut;
}
catch
{
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' does not specify a valid Explanation Level");
return(false);
}
}
}
else if (arg.Equals("-help"))
{
//Ignore Help Argument if other arguments present
}
else if (arg.StartsWith("-"))
{
//Report Invalid Argument
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' is not a supported argument - it has been ignored");
}
else if (i == args.Length - 1)
{
//Last Argument must be the Query
this._query = arg;
}
else
{
//Treat as an input file
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify local files as well as specifying a remote endpoint to query");
return(false);
}
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given file
if (!this._print)
{
Graph g = new Graph();
FileLoader.Load(g, arg);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
}
}
i++;
}
return(true);
}
private void cboGraphFormat_SelectedIndexChanged(object sender, EventArgs e)
{
switch (this.cboGraphFormat.SelectedIndex)
{
case 0:
this._rdfwriter = new CsvWriter();
this._rdfext = ".csv";
break;
case 1:
fclsStylesheetPicker stylesheetPicker = new fclsStylesheetPicker("CSS (Optional)");
if (stylesheetPicker.ShowDialog() == DialogResult.OK)
{
HtmlWriter temp = new HtmlWriter();
temp.Stylesheet = stylesheetPicker.StylesheetUri;
this._rdfwriter = temp;
}
else
{
this._rdfwriter = new HtmlWriter();
}
this._rdfext = ".html";
break;
case 2:
this._rdfwriter = new Notation3Writer();
this._rdfext = ".n3";
break;
case 3:
this._rdfwriter = new NTriplesWriter();
this._rdfext = ".nt";
break;
case 4:
this._rdfwriter = new RdfJsonWriter();
this._rdfext = ".json";
break;
case 5:
this._rdfwriter = new RdfXmlWriter();
this._rdfext = ".rdf";
break;
case 6:
this._rdfwriter = new CompressingTurtleWriter();
this._rdfext = ".ttl";
break;
case 7:
this._rdfwriter = new TsvWriter();
this._rdfext = ".tsv";
break;
}
if (this._rdfwriter is ICompressingWriter)
{
((ICompressingWriter)this._rdfwriter).CompressionLevel = WriterCompressionLevel.High;
}
if (this.cboResultsFormat.SelectedIndex == 1)
{
this._resultswriter = new SparqlRdfWriter(this._rdfwriter);
this._resultsext = this._rdfext;
}
}
public void Setup()
{
this._g = new Graph();
this._g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl");
this._results = this._g.ExecuteQuery("SELECT * WHERE { ?s ?p ?o }") as SparqlResultSet;
foreach (MimeTypeDefinition def in MimeTypesHelper.Definitions)
{
// Omit CSV since that is a lossy format that does not round trip
if (def.CanonicalMimeType.Equals("text/csv"))
{
continue;
}
if (def.CanWriteRdf && def.CanParseRdf)
{
IRdfWriter writer = def.GetRdfWriter();
bool isManual = !def.CanonicalFileExtension.EndsWith(".gz");
String filename = "gzip-tests" + (isManual ? String.Empty : "-auto") + "." + def.CanonicalFileExtension + (isManual ? ".gz" : String.Empty);
if (isManual)
{
using (StreamWriter output = new StreamWriter(new GZipStream(new FileStream(filename, FileMode.Create, FileAccess.Write), CompressionMode.Compress)))
{
writer.Save(this._g, output);
output.Close();
}
this._manualTestFiles.Add(filename);
}
else
{
writer.Save(this._g, filename);
this._autoTestFiles.Add(filename);
}
}
else if (def.CanParseRdfDatasets && def.CanWriteRdfDatasets)
{
IStoreWriter writer = def.GetRdfDatasetWriter();
bool isManual = !def.CanonicalFileExtension.EndsWith(".gz");
String filename = "gzip-tests-datasets" + (isManual ? String.Empty : "-auto") + "." + def.CanonicalFileExtension + (isManual ? ".gz" : String.Empty);
TripleStore store = new TripleStore();
store.Add(this._g);
if (isManual)
{
using (Stream output = new GZipStream(new FileStream(filename, FileMode.Create, FileAccess.Write), CompressionMode.Compress))
{
writer.Save(store, new StreamWriter(output));
output.Close();
}
this._manualDatasetTestFiles.Add(filename);
}
else
{
writer.Save(store, new StreamWriter(new FileStream(filename, FileMode.Create, FileAccess.Write)));
this._autoDatasetTestFiles.Add(filename);
}
}
else if (def.CanParseSparqlResults && def.CanWriteSparqlResults)
{
ISparqlResultsWriter writer = def.GetSparqlResultsWriter();
bool isManual = !def.CanonicalFileExtension.EndsWith(".gz");
String filename = "gzip-tests-results" + (isManual ? String.Empty : "-auto") + "." + def.CanonicalFileExtension + (isManual ? ".gz" : String.Empty);
if (isManual)
{
using (StreamWriter output = new StreamWriter(new GZipStream(new FileStream(filename, FileMode.Create, FileAccess.Write), CompressionMode.Compress)))
{
writer.Save(this._results, output);
output.Close();
}
this._manualResultsTestFiles.Add(filename);
}
else
{
writer.Save(this._results, new StreamWriter(filename));
this._autoResultsTestFiles.Add(filename);
}
}
}
}
private bool SetOptions(String[] args)
{
if (args.Length == 0 || args.Length == 1 && args[0].Equals("-help"))
{
this.ShowUsage();
return false;
}
String arg;
int i = 0;
while (i < args.Length)
{
arg = args[i];
if (arg.StartsWith("-uri:"))
{
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify input URIs as well as specifying a remote endpoint to query");
return false;
}
String uri = arg.Substring(5);
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given URI
if (!this._print)
{
Uri u = new Uri(uri);
Graph g = new Graph();
UriLoader.Load(g, u);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since this is not a valid URI");
if (this._debug) this.DebugErrors(uriEx);
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug) this.DebugErrors(parseEx);
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug) this.DebugErrors(ex);
}
}
else if (arg.StartsWith("-endpoint:"))
{
if (this._mode == RdfQueryMode.Local)
{
Console.Error.WriteLine("rdfQuery: Cannot specify a remote endpoint to query as well as specifying local files and/or input URIs");
return false;
}
else if (this._mode == RdfQueryMode.Remote)
{
if (!(this._endpoint is FederatedSparqlRemoteEndpoint))
{
this._endpoint = new FederatedSparqlRemoteEndpoint(this._endpoint);
}
}
try
{
this._mode = RdfQueryMode.Remote;
if (this._endpoint is FederatedSparqlRemoteEndpoint)
{
((FederatedSparqlRemoteEndpoint)this._endpoint).AddEndpoint(new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1))));
}
else
{
this._endpoint = new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1)));
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Unable to use remote endpoint with URI '" + arg.Substring(arg.IndexOf(':') + 1) + "' since this is not a valid URI");
if (this._debug) this.DebugErrors(uriEx);
return false;
}
}
else if (arg.StartsWith("-output:") || arg.StartsWith("-out:"))
{
this._output = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("-outformat:"))
{
String format = arg.Substring(arg.IndexOf(':') + 1);
try
{
if (format.Contains("/"))
{
//MIME Type
this._graphWriter = MimeTypesHelper.GetWriter(format);
this._resultsWriter = MimeTypesHelper.GetSparqlWriter(format);
}
else
{
//File Extension
this._graphWriter = MimeTypesHelper.GetWriter(MimeTypesHelper.GetMimeType(format));
this._resultsWriter = MimeTypesHelper.GetSparqlWriter(MimeTypesHelper.GetMimeType(format));
}
}
catch (RdfException)
{
Console.Error.WriteLine("rdfQuery: The file extension '" + format + "' could not be used to determine a MIME Type and select a writer - default writers will be used");
}
}
else if (arg.StartsWith("-syntax"))
{
if (arg.Contains(':'))
{
String syntax = arg.Substring(arg.IndexOf(':') + 1);
switch (syntax)
{
case "1":
case "1.0":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_0;
break;
case "1.1":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_1;
break;
case "E":
case "e":
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + syntax + "' is not a valid query syntax specifier - assuming SPARQL 1.1 with Extensions");
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
}
}
else
{
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
}
}
else if (arg.StartsWith("-timeout:"))
{
long timeout;
if (Int64.TryParse(arg.Substring(arg.IndexOf(':') + 1), out timeout))
{
this._timeout = timeout;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid timeout in milliseconds - default timeouts will be used");
}
}
else if (arg.StartsWith("-r:"))
{
arg = arg.Substring(arg.IndexOf(':') + 1);
switch (arg)
{
case "rdfs":
((IInferencingTripleStore)this._store).AddInferenceEngine(new RdfsReasoner());
break;
case "skos":
((IInferencingTripleStore)this._store).AddInferenceEngine(new SkosReasoner());
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + arg + "' is not a valid Reasoner - ignoring this option");
break;
}
}
else if (arg.StartsWith("-partialResults"))
{
if (arg.Contains(':'))
{
bool partial;
if (Boolean.TryParse(arg.Substring(arg.IndexOf(':') + 1), out partial))
{
this._partialResults = partial;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid boolean - partial results mode is disabled");
}
}
else
{
this._partialResults = true;
}
}
else if (arg.StartsWith("-noopt"))
{
if (arg.Equals("-noopt"))
{
Options.QueryOptimisation = false;
Options.AlgebraOptimisation = false;
}
else if (arg.Length >= 7)
{
String opts = arg.Substring(7);
foreach (char c in opts.ToCharArray())
{
if (c == 'a' || c == 'A')
{
Options.AlgebraOptimisation = false;
}
else if (c == 'q' || c == 'Q')
{
Options.QueryOptimisation = false;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + c + "' as part of the -noopt argument is not supported - it has been ignored");
}
}
}
}
else if (arg.Equals("-nocache"))
{
Options.UriLoaderCaching = false;
}
else if (arg.Equals("-nobom"))
{
Options.UseBomForUtf8 = false;
}
else if (arg.Equals("-print"))
{
this._print = true;
}
else if (arg.Equals("-debug"))
{
this._debug = true;
}
else if (arg.StartsWith("-explain"))
{
this._explain = true;
if (arg.Length > 9)
{
try
{
this._level = (ExplanationLevel)Enum.Parse(typeof(ExplanationLevel), arg.Substring(9));
this._level = (this._level | ExplanationLevel.OutputToConsoleStdErr | ExplanationLevel.Simulate) ^ ExplanationLevel.OutputToConsoleStdOut;
}
catch
{
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' does not specify a valid Explanation Level");
return false;
}
}
}
else if (arg.Equals("-help"))
{
//Ignore Help Argument if other arguments present
}
else if (arg.StartsWith("-"))
{
//Report Invalid Argument
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' is not a supported argument - it has been ignored");
}
else if (i == args.Length - 1)
{
//Last Argument must be the Query
this._query = arg;
}
else
{
//Treat as an input file
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify local files as well as specifying a remote endpoint to query");
return false;
}
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given file
if (!this._print)
{
Graph g = new Graph();
FileLoader.Load(g, arg);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug) this.DebugErrors(parseEx);
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug) this.DebugErrors(ex);
}
}
i++;
}
return true;
}
/// <summary>
/// Writes the SPARQL Result Set to a String and returns the Output in your chosen format
/// </summary>
/// <param name="results">SPARQL Result Set</param>
/// <param name="writer">Writer to use to generate the SPARQL Results output</param>
/// <returns></returns>
public static String Write(SparqlResultSet results, ISparqlResultsWriter writer)
{
System.IO.StringWriter sw = new System.IO.StringWriter();
writer.Save(results, sw);
return sw.ToString();
}
private bool SetResultsFormat(String format)
{
switch (format)
{
case "xml":
this._resultsWriter = new SparqlXmlWriter();
this._graphWriter = new FastRdfXmlWriter();
break;
case "json":
this._resultsWriter = new SparqlJsonWriter();
this._graphWriter = new RdfJsonWriter();
break;
case "ntriples":
this._graphWriter = new NTriplesWriter();
break;
case "rdfxml":
this._graphWriter = new FastRdfXmlWriter();
break;
case "turtle":
this._graphWriter = new CompressingTurtleWriter(WriterCompressionLevel.High);
break;
case "n3":
this._graphWriter = new Notation3Writer(WriterCompressionLevel.High);
break;
case "html":
case "rdfa":
this._resultsWriter = new SparqlHtmlWriter();
this._graphWriter = new HtmlWriter();
break;
case "csv":
this._resultsWriter = new SparqlCsvWriter();
this._graphWriter = new CsvWriter();
break;
case "tsv":
this._resultsWriter = new SparqlTsvWriter();
this._graphWriter = new TsvWriter();
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + format + "' is not a valid Results Format");
return false;
}
return true;
}