public void SparqlGroupByAssignmentSimple2()
{
String query = "SELECT ?x (COUNT(?p) AS ?predicates) WHERE { ?s ?p ?o } GROUP BY ?s AS ?x";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
QueryableGraph g = new QueryableGraph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
TestTools.ShowResults(rset);
Assert.True(rset.All(r => r.HasValue("x") && !r.HasValue("s") && r.HasValue("predicates")), "All Results should have a ?x and ?predicates variables and no ?s variable");
}
else
{
Assert.True(false, "Didn't get a Result Set as expected");
}
}
public void SparqlGroupByAssignmentExpression()
{
String query = "SELECT ?s ?sum WHERE { ?s ?p ?o } GROUP BY ?s (1 + 2 AS ?sum)";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
QueryableGraph g = new QueryableGraph();
FileLoader.Load(g, "InferenceTest.ttl");
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
TestTools.ShowResults(rset);
Assert.IsTrue(rset.All(r => r.HasValue("s") && r.HasValue("sum")), "All Results should have a ?s and a ?sum variable");
}
else
{
Assert.Fail("Didn't get a Result Set as expected");
}
}
public void SparqlGroupByAssignmentExpression3()
{
String query = "SELECT ?lang (SAMPLE(?o) AS ?example) WHERE { ?s ?p ?o . FILTER(ISLITERAL(?o)) } GROUP BY (LANG(?o) AS ?lang) HAVING LANGMATCHES(?lang, \"*\")";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
QueryableGraph g = new QueryableGraph();
UriLoader.Load(g, new Uri("http://dbpedia.org/resource/Southampton"));
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
TestTools.ShowResults(rset);
Assert.IsTrue(rset.All(r => r.HasValue("lang") && r.HasValue("example")), "All Results should have a ?lang and a ?example variable");
}
else
{
Assert.Fail("Didn't get a Result Set as expected");
}
}
public void SparqlFunctionsNow()
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromFile("resources\\now01.rq");
Console.WriteLine("ToString Output:");
Console.WriteLine(q.ToString());
Console.WriteLine();
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine("SparqlFormatter Output:");
Console.WriteLine(formatter.Format(q));
TripleStore store = new TripleStore();
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(store);
SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet;
if (results != null)
{
Assert.IsTrue(results.Result, "Result should be true");
}
else
{
Assert.Fail("Expected a non-null result");
}
}
public void SparqlFormattingOptionalAtRoot()
{
SparqlQuery q = new SparqlQuery {
QueryType = SparqlQueryType.Select
};
q.AddVariable(new SparqlVariable("s", true));
GraphPattern gp = new GraphPattern();
gp.IsOptional = true;
gp.AddTriplePattern(new TriplePattern(new VariablePattern("s"), new VariablePattern("p"), new VariablePattern("o")));
q.RootGraphPattern = gp;
String toStr = q.ToString();
Console.WriteLine("ToString() Form:");
Console.WriteLine(toStr);
Assert.AreEqual(2, toStr.ToCharArray().Where(c => c == '{').Count());
Assert.AreEqual(2, toStr.ToCharArray().Where(c => c == '}').Count());
Console.WriteLine();
SparqlFormatter formatter = new SparqlFormatter();
String fmtStr = formatter.Format(q);
Console.WriteLine("SparqlFormatter Form:");
Console.WriteLine(fmtStr);
Assert.AreEqual(2, fmtStr.ToCharArray().Where(c => c == '{').Count());
Assert.AreEqual(2, fmtStr.ToCharArray().Where(c => c == '}').Count());
}
public void SparqlGroupByAssignmentExpression3()
{
if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing))
{
throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run");
}
String query = "SELECT ?lang (SAMPLE(?o) AS ?example) WHERE { ?s ?p ?o . FILTER(ISLITERAL(?o)) } GROUP BY (LANG(?o) AS ?lang) HAVING LANGMATCHES(?lang, \"*\")";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
QueryableGraph g = new QueryableGraph();
UriLoader.Load(g, new Uri("http://dbpedia.org/resource/Southampton"));
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
TestTools.ShowResults(rset);
Assert.True(rset.All(r => r.HasValue("lang") && r.HasValue("example")), "All Results should have a ?lang and a ?example variable");
}
else
{
Assert.True(false, "Didn't get a Result Set as expected");
}
}
private static void SetUris(SparqlParameterizedString sparqlParameterizedString, string parameter, IEnumerable <Uri> values)
{
// Enclose Uris in <>
var formatter = new SparqlFormatter();
var factory = new NodeFactory();
sparqlParameterizedString.CommandText = sparqlParameterizedString.CommandText.Replace($"@{parameter}", string.Join(" ", values.Select(uri => formatter.Format(factory.CreateUriNode(uri)))));
}
private static void SetLiterals(SparqlParameterizedString sparqlParameterizedString, string parameter, IEnumerable <string> values)
{
// Create literal nodes
var formatter = new SparqlFormatter();
var factory = new NodeFactory();
sparqlParameterizedString.CommandText = sparqlParameterizedString.CommandText.Replace($"@{parameter}", string.Join(" ", values.Select(value => formatter.Format(factory.CreateLiteralNode(value)))));
}
private void RunTest(IFullTextIndexer indexer, String query, IEnumerable <INode> expected)
{
this.EnsureTestData();
indexer.Index(this._dataset);
indexer.Dispose();
//Build the SPARQL Query and parse it
SparqlParameterizedString queryString = new SparqlParameterizedString(query);
queryString.Namespaces = this.GetQueryNamespaces();
SparqlQuery q = this._parser.ParseFromString(queryString);
SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap);
Console.WriteLine("Parsed Query:");
Console.WriteLine(formatter.Format(q));
Console.WriteLine("Expected Results:");
foreach (INode n in expected)
{
Console.WriteLine(n.ToString(formatter));
}
Console.WriteLine();
LuceneSearchProvider provider = new LuceneSearchProvider(LuceneTestHarness.LuceneVersion, LuceneTestHarness.Index);
try
{
q.AlgebraOptimisers = new IAlgebraOptimiser[] { new FullTextOptimiser(provider) };
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(this._dataset);
SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet;
if (results != null)
{
TestTools.ShowResults(results);
foreach (INode n in expected)
{
Assert.IsTrue(results.Any(r => r.HasValue("match") && r["match"] != null && r["match"].Equals(n)), "Did not get expected ?match => " + formatter.Format(n));
}
foreach (SparqlResult r in results)
{
Assert.IsTrue(r.HasValue("match") && r["match"] != null && expected.Contains(r["match"]), "Unexpected Match " + formatter.Format(r["match"]));
}
}
else
{
Assert.Fail("Did not get a SPARQL Result Set as expected");
}
}
finally
{
provider.Dispose();
LuceneTestHarness.Index.Dispose();
}
}
private void RunTest(IFullTextIndexer indexer, String query, int expectedResults, bool exact)
{
this.EnsureTestData();
indexer.Index(this._dataset);
indexer.Dispose();
//Build the SPARQL Query and parse it
SparqlParameterizedString queryString = new SparqlParameterizedString(query);
queryString.Namespaces = this.GetQueryNamespaces();
SparqlQuery q = this._parser.ParseFromString(queryString);
SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap);
Console.WriteLine("Parsed Query:");
Console.WriteLine(formatter.Format(q));
LuceneSearchProvider provider = new LuceneSearchProvider(LuceneTestHarness.LuceneVersion, LuceneTestHarness.Index);
FullTextPropertyFunctionFactory factory = new FullTextPropertyFunctionFactory();
try
{
PropertyFunctionFactory.AddFactory(factory);
q.AlgebraOptimisers = new IAlgebraOptimiser[] { new FullTextOptimiser(provider) };
Options.AlgebraOptimisation = true;
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(this._dataset);
SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet;
if (results != null)
{
TestTools.ShowResults(results);
if (exact)
{
Assert.Equal(expectedResults, results.Count);
}
else
{
Assert.True(expectedResults >= results.Count, "Got more results that the expected maximum");
}
}
else
{
Assert.True(false, "Did not get a SPARQL Result Set as expected");
}
}
finally
{
PropertyFunctionFactory.RemoveFactory(factory);
provider.Dispose();
LuceneTestHarness.Index.Dispose();
}
}
private void ShowQueryInformation(QueryTask task)
{
if (task.Query != null)
{
SparqlFormatter formatter = new SparqlFormatter(task.Query.NamespaceMap);
StringWriter writer = new StringWriter();
writer.WriteLine("Parsed Query:");
writer.WriteLine(formatter.Format(task.Query));
writer.WriteLine("SPARQL Algebra:");
writer.WriteLine(task.Query.ToAlgebra().ToString());
CrossThreadSetText(this.txtAdvInfo, writer.ToString());
}
}
public void SparqlParsingCore427_2()
{
const string query = "SELECT (StrUUID() AS ?test) { }";
var q = this._parser.ParseFromString(query);
var toString = q.ToString();
Assert.Contains("(STRUUID", toString);
var formattedString = new SparqlFormatter().Format(q);
Assert.Contains("(STRUUID", formattedString);
}
public void SparqlParsingCore427_2()
{
const String query = "SELECT (StrUUID() AS ?test) { }";
SparqlQuery q = this._parser.ParseFromString(query);
String toString = q.ToString();
Assert.IsTrue(toString.Contains("(STRUUID"));
String formattedString = new SparqlFormatter().Format(q);
Assert.IsTrue(formattedString.Contains("(STRUUID"));
}
public void SparqlParsingCore427_1()
{
const String query = "SELECT (UUID() AS ?test) { }";
SparqlQuery q = this._parser.ParseFromString(query);
String toString = q.ToString();
Assert.Contains("(UUID", toString);
String formattedString = new SparqlFormatter().Format(q);
Assert.Contains("(UUID", formattedString);
}
public void SparqlParsingSubqueries4()
{
String query = "SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o } } }";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Console.WriteLine("Parsed original input OK");
SparqlFormatter formatter = new SparqlFormatter();
String query2 = formatter.Format(q);
SparqlQuery q2 = parser.ParseFromString(query2);
Console.WriteLine("Parsed reserialized input OK");
}
private static string SetUris(string sparql, IEnumerable <string> ids)
{
var formatter = new SparqlFormatter();
var factory = new NodeFactory();
string format(string id)
{
var uri = new Uri(Program.BaseUri, id);
var node = factory.CreateUriNode(uri);
return(formatter.Format(node));
}
return(sparql.Replace("@concepts", string.Join(" ", ids.Select(format))));
}
public void SparqlParsingConstructShortForm()
{
List <String> valid = new List <string>()
{
"CONSTRUCT WHERE {?s ?p ?o }",
"CONSTRUCT WHERE {?s a ?type }",
};
List <String> invalid = new List <string>()
{
"CONSTRUCT {?s ?p ?o}",
"CONSTRUCT WHERE { ?s ?p ?o . FILTER(ISLITERAL(?o)) }",
"CONSTRUCT WHERE { GRAPH ?g { ?s ?p ?o } }",
"CONSTRUCT WHERE { ?s ?p ?o . OPTIONAL {?s a ?type}}",
"CONSTRUCT WHERE { ?s a ?type . BIND (<http://example.org> AS ?thing) }",
"CONSTRUCT WHERE { {SELECT * WHERE { ?s ?p ?o } } }"
};
SparqlQueryParser parser = new SparqlQueryParser();
SparqlFormatter formatter = new SparqlFormatter();
foreach (String v in valid)
{
Console.WriteLine("Valid Input: " + v);
SparqlQuery q = parser.ParseFromString(v);
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
}
foreach (String iv in invalid)
{
Console.WriteLine("Invalid Input: " + iv);
try
{
SparqlQuery q = parser.ParseFromString(iv);
Assert.Fail("Should have thrown a Parsing Error");
}
catch (RdfParseException parseEx)
{
Console.WriteLine("Errored as expected");
TestTools.ReportError("Parsing Error", parseEx);
}
Console.WriteLine();
}
}
private void TestExtractPatterns(String query, int expectedPatterns, int expectedSubjArgs, int expectedObjArgs)
{
FullTextPropertyFunctionFactory factory = new FullTextPropertyFunctionFactory();
try
{
PropertyFunctionFactory.AddFactory(factory);
SparqlParameterizedString queryString = new SparqlParameterizedString(query);
queryString.Namespaces.AddNamespace("pf", new Uri(FullTextHelper.FullTextMatchNamespace));
SparqlQuery q = this._parser.ParseFromString(queryString);
SparqlFormatter formatter = new SparqlFormatter(queryString.Namespaces);
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
List <IPropertyFunctionPattern> ps = PropertyFunctionHelper.ExtractPatterns(q.RootGraphPattern.TriplePatterns);
Console.WriteLine(ps.Count + " Pattern(s) extracted");
foreach (IPropertyFunctionPattern propFunc in ps.Where(p => p.PropertyFunction is FullTextMatchPropertyFunction))
{
Console.WriteLine("Match Variable: " + propFunc.SubjectArgs.First().ToString());
Console.WriteLine("Score Variable: " + (propFunc.SubjectArgs.Count() > 1 ? propFunc.SubjectArgs.Skip(1).First().ToString() : "N/A"));
Console.WriteLine("Search Term: " + propFunc.ObjectArgs.First().ToString());
Console.WriteLine("Threshold/Limit: " + (propFunc.ObjectArgs.Count() > 1 ? propFunc.ObjectArgs.Skip(1).First().ToString() : "N/A"));
Console.WriteLine("Limit: " + (propFunc.ObjectArgs.Count() > 2 ? propFunc.ObjectArgs.Skip(2).First().ToString() : "N/A"));
Console.WriteLine();
if (expectedSubjArgs > 0)
{
Assert.Equal(expectedSubjArgs, propFunc.SubjectArgs.Count());
}
if (expectedObjArgs > 0)
{
Assert.Equal(expectedObjArgs, propFunc.ObjectArgs.Count());
}
}
Assert.Equal(expectedPatterns, ps.Count);
}
finally
{
PropertyFunctionFactory.RemoveFactory(factory);
}
}
public XsdtTypeConverter()
{
this._formatter = new SparqlFormatter(this._g);
typeLookup.Add(XsdtPrimitiveDataType.XsdtString, typeof(string));
typeLookup.Add(XsdtPrimitiveDataType.XsdtBoolean, typeof(Boolean));
typeLookup.Add(XsdtPrimitiveDataType.XsdtFloat, typeof(Single));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDouble, typeof(Double));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDecimal, typeof(Decimal));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDuration, typeof(TimeSpan));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDayTimeDuration, typeof(TimeSpan));
typeLookup.Add(XsdtPrimitiveDataType.XsdtShort, typeof(Int16));
typeLookup.Add(XsdtPrimitiveDataType.XsdtInt, typeof(Int32));
typeLookup.Add(XsdtPrimitiveDataType.XsdtLong, typeof(Int64));
typeLookup.Add(XsdtPrimitiveDataType.XsdtHexBinary, typeof(Byte[]));
typeLookup.Add(XsdtPrimitiveDataType.XsdtAnyUri, typeof(Uri));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDateTime, typeof(DateTime));
typeLookup.Add(XsdtPrimitiveDataType.XsdtDate, typeof(DateTime));
}
private static string addProvenance(IEnumerable <Triple> additions, IEnumerable <Triple> removals)
{
Graph graph = new Graph();
StringBuilder sb = new StringBuilder();
SparqlFormatter sparqlFormatter = new SparqlFormatter();
DateTimeOffset dt = DateTimeOffset.UtcNow;
sb.AppendLine(";INSERT DATA {");
foreach (Triple removed in removals)
{
sb.Append($@"[] <http://example.com/subject> {sparqlFormatter.Format(removed.Subject)};
<http://example.com/predicate> {sparqlFormatter.Format(removed.Predicate)};
<http://example.com/dateTime> {sparqlFormatter.Format(dt.ToLiteral(graph))};
<http://example.com/oldObject> {sparqlFormatter.Format(removed.Object)}");
IEnumerable <Triple> foundAdded = additions.Where(a => a.HasSubject(removed.Subject) && a.HasPredicate(removed.Predicate));
if (foundAdded.Any())
{
sb.AppendLine(";");
foreach (Triple added in foundAdded)
{
sb.AppendLine($@"<http://example.com/newObject> {sparqlFormatter.Format(added.Object)}.");
}
}
else
{
sb.AppendLine($@".");
}
}
foreach (Triple added in additions)
{
if (removals.Any(a => a.HasSubject(added.Subject) && a.HasPredicate(added.Predicate)) == false)
{
sb.Append($@"[] <http://example.com/subject> {sparqlFormatter.Format(added.Subject)};
<http://example.com/predicate> {sparqlFormatter.Format(added.Predicate)};
<http://example.com/dateTime> {sparqlFormatter.Format(dt.ToLiteral(graph))};
<http://example.com/newObject> {sparqlFormatter.Format(added.Object)}.");
}
}
sb.AppendLine("}");
return(sb.ToString());
}
public void SparqlGroupByRefactor7()
{
String query = "SELECT ?s WHERE { ?s ?p ?o } GROUP BY (?s)";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
String queryStr = q.ToString();
Console.WriteLine("Raw ToString()");
Console.WriteLine(queryStr);
Console.WriteLine();
Assert.Contains("GROUP BY ?s", queryStr);
String queryStrFmt = new SparqlFormatter().Format(q);
Console.WriteLine("Formatted String");
Console.WriteLine(queryStrFmt);
Assert.Contains("GROUP BY ?s", queryStrFmt);
}
private void ShowQueryInformation(QueryTask task)
{
CrossThreadSetEnabled(this.btnViewResults, task.State == TaskState.Completed && task.Result != null);
if (task.Query != null)
{
StringWriter writer = new StringWriter();
writer.WriteLine("Parsed Query:");
if (task.Query != null)
{
SparqlFormatter formatter = new SparqlFormatter(task.Query.NamespaceMap);
writer.WriteLine(formatter.Format(task.Query));
writer.WriteLine("SPARQL Algebra:");
writer.WriteLine(task.Query.ToAlgebra().ToString());
}
else
{
writer.WriteLine("Unavailable - Not standard SPARQL 1.0/1.1");
}
CrossThreadSetText(this.txtAdvInfo, writer.ToString());
}
}
private static void SetUris(SparqlParameterizedString query, string name, string value, Uri baseUri)
{
var formatter = new SparqlFormatter();
var factory = new NodeFactory();
Func <string, string> format = instanceId =>
{
var uri = new Uri(baseUri, instanceId);
var node = factory.CreateUriNode(uri);
return(formatter.Format(node));
};
var formattedUris = value.Split(',').Select(format);
value = string.Join(" ", formattedUris);
var parameter = $"@{name}";
query.CommandText = query.CommandText.Replace(parameter, value);
}
public void SparqlBlankNodeVariables1()
{
this.EnsureTestData();
SparqlQuery q = this._parser.ParseFromString("SELECT ?o WHERE { _:s ?p1 ?o1 FILTER(ISURI(?o1)) ?o1 ?p2 ?o . FILTER(ISLITERAL(?o)) }");
q.AlgebraOptimisers = new IAlgebraOptimiser[] { new StrictAlgebraOptimiser() };
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine(formatter.Format(q));
Console.WriteLine(q.ToAlgebra().ToString());
SparqlResultSet results = this._processor.ProcessQuery(q) as SparqlResultSet;
if (results == null)
{
Assert.True(false, "Did not get a SPARQL Result Set as expected");
}
Assert.False(results.Count == 0, "Result Set should not be empty");
Assert.True(results.All(r => r.HasValue("o") && r["o"] != null && r["o"].NodeType == NodeType.Literal), "All results should be literals");
}
public void SparqlParsingDescribeHangingWhere()
{
List <String> valid = new List <string>()
{
"DESCRIBE ?s WHERE { ?s a ?type }",
"DESCRIBE <http://example.org/>",
"PREFIX ex: <http://example.org/> DESCRIBE ex:"
};
List <String> invalid = new List <string>()
{
"DESCRIBE ?s WHERE"
};
SparqlQueryParser parser = new SparqlQueryParser();
SparqlFormatter formatter = new SparqlFormatter();
foreach (String v in valid)
{
SparqlQuery q = parser.ParseFromString(v);
Console.WriteLine(formatter.Format(q));
Console.WriteLine();
}
foreach (String iv in invalid)
{
try
{
SparqlQuery q = parser.ParseFromString(iv);
Assert.Fail("Should have thrown a Parsing Error");
}
catch (RdfParseException parseEx)
{
Console.WriteLine("Errored as expected");
TestTools.ReportError("Parsing Error", parseEx);
}
}
}
static void loadOwl(string ruta)
{
//string path = Application.StartupPath.ToString() + "\\JudoOntology.owl";
// string path = Application.StartupPath.ToString() + "\\JudoOntology.owl";
string path = Application.StartupPath.ToString() + "\\FoodOntologyRecomender.owl";
IGraph g = new Graph();
g.LoadFromFile(path, new RdfXmlParser());
try
{
/*foreach (IUriNode u in g.Nodes.UriNodes())
* {
* //Write the URI to the Console
* Console.WriteLine(u.Uri.ToString());
* }
*
*
* Console.WriteLine(g.BaseUri);foreach (Triple u in g.Triples)
* {
* //Write the URI to the Console
* Console.WriteLine(u.ToString());
* }*/
//Fill in the code shown on this page here to build your hello world application
/*
* IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
* IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
* ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
* ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
*
* g.Assert(new Triple(dotNetRDF, says, helloWorld));
* g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
*
* Console.WriteLine();
* Console.WriteLine("Raw Output");
* Console.WriteLine();*/
/*
* foreach (Triple t in g.Triples)
* {
*
* Console.WriteLine(t.ToString());
* }
* foreach (IUriNode u in g.Nodes.UriNodes())
* {
* //Write the URI to the Console
* Console.WriteLine(u.Uri.ToString());
* }*/
//Create a Parameterized String
SparqlParameterizedString queryString = new SparqlParameterizedString();
//Add a namespace declaration
queryString.Namespaces.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
queryString.Namespaces.AddNamespace("owl", new Uri("http://www.w3.org/2002/07/owl#"));
queryString.Namespaces.AddNamespace("xsd", new Uri("http://www.w3.org/2001/XMLSchema#"));
queryString.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
//Set the SPARQL command
//For more complex queries we can do this in multiple lines by using += on the
//CommandText property
//Note we can use @name style parameters here
// queryString.CommandText = "SELECT * WHERE { ?s ex:property @value }";
/*
* queryString.CommandText = "SELECT ?individual ?class WHERE {?individual"+
* " rdf:type owl:NamedIndividual. "+
* "?class rdf:type owl:Class.}";*/
/*
* // get all class in the model
* queryString.CommandText = "SELECT ?s WHERE { ?s rdf:type owl:Class } "; */
//Inject a Value for the parameter
// queryString.SetUri("value", new Uri("http://example.org/value"));
//When we call ToString() we get the full command text with namespaces appended as PREFIX
//declarations and any parameters replaced with their declared values
Console.WriteLine(queryString.ToString());
//We can turn this into a query by parsing it as in our previous example
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery query = parser.ParseFromString(queryString);
InMemoryDataset ds = new InMemoryDataset(g);
//Get the Query processor
ISparqlQueryProcessor processor = new LeviathanQueryProcessor(ds);
Object results = processor.ProcessQuery(query);
if (results is SparqlResultSet)
{
SparqlResultSet r = results as SparqlResultSet;
foreach (SparqlResult res in r)
{
SparqlFormatter format = new SparqlFormatter();
Console.WriteLine(res.ToString(format));
}
}
}
catch (RdfParseException ex)
{
Console.WriteLine("Parser Error");
Console.WriteLine(ex.Message);
}
}
public void RunQuery(String[] args)
{
//If we can't set options then we abort
if (!this.SetOptions(args))
{
return;
}
if (this._query == null)
{
//Try to read query from Standard In instead
this._query = Console.In.ReadToEnd();
if (this._query.Equals(String.Empty))
{
Console.Error.WriteLine("rdfQuery: No Query was specified");
return;
}
}
//Parse the Query
try
{
SparqlQuery q = this._parser.ParseFromString(this._query);
//Set Timeout if necessary
q.Timeout = this._timeout;
q.PartialResultsOnTimeout = this._partialResults;
//Execute the Query unless print was specified
Object results = null;
if (!this._print)
{
switch (this._mode)
{
case RdfQueryMode.Local:
if (this._explain)
{
var processor = new ExplainQueryProcessor(this._store, this._level);
results = processor.ProcessQuery(q);
}
else
{
var processor = new LeviathanQueryProcessor(_store);
results = processor.ProcessQuery(q);
}
break;
case RdfQueryMode.Remote:
if (this._explain)
{
Console.Error.WriteLine("rdfQuery: Warning: Cannot explain queries when the query is being sent to a remote endpoint");
}
this._endpoint.Timeout = Convert.ToInt32(this._timeout);
switch (q.QueryType)
{
case SparqlQueryType.Construct:
case SparqlQueryType.Describe:
case SparqlQueryType.DescribeAll:
results = this._endpoint.QueryWithResultGraph(this._query);
break;
default:
results = this._endpoint.QueryWithResultSet(this._query);
break;
}
break;
case RdfQueryMode.Unknown:
default:
if (this._explain)
{
ExplainQueryProcessor processor = new ExplainQueryProcessor(new TripleStore(), this._level);
processor.ProcessQuery(q);
}
else
{
Console.Error.WriteLine("rdfQuery: There were no inputs or a remote endpoint specified in the arguments so no query can be executed");
}
return;
}
}
//Select the Output Stream
StreamWriter output;
if (this._output == null)
{
output = new StreamWriter(Console.OpenStandardOutput());
}
else
{
output = new StreamWriter(this._output);
}
if (!this._print)
{
//Output the Results
if (results is SparqlResultSet)
{
this._resultsWriter.Save((SparqlResultSet)results, output);
}
else if (results is IGraph)
{
this._graphWriter.Save((IGraph)results, output);
}
else
{
Console.Error.WriteLine("rdfQuery: The Query resulted in an unknown result");
}
}
else
{
//If Printing Print the Query then the Algebra
SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap);
output.WriteLine("Query");
output.WriteLine(formatter.Format(q));
output.WriteLine();
output.WriteLine("Algebra");
output.WriteLine(q.ToAlgebra().ToString());
output.Flush();
output.Close();
}
}
catch (RdfQueryTimeoutException timeout)
{
Console.Error.WriteLine("rdfQuery: Query Timeout: " + timeout.Message);
if (this._debug)
{
this.DebugErrors(timeout);
}
return;
}
catch (RdfQueryException queryEx)
{
Console.Error.WriteLine("rdfQuery: Query Error: " + queryEx.Message);
if (this._debug)
{
this.DebugErrors(queryEx);
}
return;
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
return;
}
catch (RdfException rdfEx)
{
Console.Error.WriteLine("rdfQuery: RDF Error: " + rdfEx.Message);
if (this._debug)
{
this.DebugErrors(rdfEx);
}
return;
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
return;
}
}
private void LogStartQuery(SparqlQuery q)
{
SparqlFormatter formatter = new SparqlFormatter(q.NamespaceMap);
this.Log("QUERY START", formatter.Format(q));
}
/// <summary>
/// Creates a new empty parameterized String
/// </summary>
public SparqlParameterizedString()
{
_formatter = new SparqlFormatter(_nsmap);
}
public AsyncFusekiConnector(string updateUri)
{
this.updateUri = updateUri;
this.formatter = new SparqlFormatter();
this.httpClient = new HttpClient();
}
