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);
}
/// <summary>
/// Internal Helper function which returns the 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>
protected void ProcessQueryResults(HttpServerContext context, Object result)
{
//Return the Results
String ctype;
if (result is SparqlResultSet)
{
//Get the appropriate Writer and set the Content Type
ISparqlResultsWriter sparqlwriter;
if (context.Request.AcceptTypes != null)
{
sparqlwriter = MimeTypesHelper.GetSparqlWriter(context.Request.AcceptTypes, out ctype);
}
else
{
//Default to SPARQL XML Results Format if no accept header
sparqlwriter = new SparqlXmlWriter();
ctype = "application/sparql-results+xml";
}
context.Response.ContentType = ctype;
if (sparqlwriter is IHtmlWriter)
{
((IHtmlWriter)sparqlwriter).Stylesheet = this._config.Stylesheet;
}
//Send Result Set to Client
sparqlwriter.Save((SparqlResultSet)result, new StreamWriter(context.Response.OutputStream));
}
else if (result is Graph)
{
//Get the appropriate Writer and set the Content Type
IRdfWriter rdfwriter = MimeTypesHelper.GetWriter(context.Request.AcceptTypes, out ctype);
context.Response.ContentType = ctype;
if (rdfwriter is IHtmlWriter)
{
((IHtmlWriter)rdfwriter).Stylesheet = this._config.Stylesheet;
}
//Send Graph to Client
rdfwriter.Save((Graph)result, new StreamWriter(context.Response.OutputStream));
}
else
{
throw new RdfQueryException("Unexpected Query Result Object of Type '" + result.GetType().ToString() + "' returned");
}
}
private void EnsureTestData(String file)
{
ISparqlResultsWriter writer = MimeTypesHelper.GetSparqlWriter(MimeTypesHelper.GetMimeTypes(Path.GetExtension(file)));
this.EnsureTestData(file, writer);
}
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);
}
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;
}
}
