public void SparqlResultSetToDataTable()
{
String query = "SELECT * WHERE {?s ?p ?o}";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
DataTable table = new DataTable();
foreach (String var in rset.Variables)
{
table.Columns.Add(new DataColumn(var, typeof(INode)));
}
foreach (SparqlResult r in rset)
{
DataRow row = table.NewRow();
foreach (String var in rset.Variables)
{
if (r.HasValue(var))
{
row[var] = r[var];
}
else
{
row[var] = null;
}
}
table.Rows.Add(row);
}
Assert.AreEqual(rset.Variables.Count(), table.Columns.Count, "Number of Columns should be equal");
Assert.AreEqual(rset.Count, table.Rows.Count, "Number of Rows should be equal");
foreach (DataRow row in table.Rows)
{
foreach (DataColumn col in table.Columns)
{
Object temp = row[col];
Console.Write(col.ColumnName + " = " + ((temp != null) ? temp.ToString() : String.Empty) + " , ");
}
Console.WriteLine();
}
}
else
{
Assert.Fail("Query should have returned a Result Set");
}
}
private List <AopNetwork> GetAopNetworks(string id = null)
{
var queryString = new SparqlParameterizedString();
queryString.Namespaces.AddNamespace("dc", new Uri("http://purl.org/dc/elements/1.1/"));
queryString.Namespaces.AddNamespace("aopo", new Uri("http://aopkb.org/aop_ontology#"));
queryString.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
if (!string.IsNullOrEmpty(id))
{
queryString.SetUri("id", new Uri($@"http://identifiers.org/aop/{id}"));
queryString.CommandText = (@"
SELECT *
WHERE {
?Aop a aopo:AdverseOutcomePathway ;
dc:title ?AopName ;
rdfs:label ?AopId .
FILTER (?Aop = @id)
}
");
}
else
{
queryString.CommandText = (@"
SELECT *
WHERE {
?Aop a aopo:AdverseOutcomePathway ;
dc:title ?AopName ;
rdfs:label ?AopId .
}
");
}
queryString.SetUri("value", new Uri("http://aopwiki-rdf.prod.openrisknet.org/sparql/"));
var parser = new SparqlQueryParser();
var processor = new RemoteQueryProcessor(new SparqlRemoteEndpoint(Endpoint));
var query = parser.ParseFromString(queryString);
var resultSet = processor.ProcessQuery(query);
if (resultSet is SparqlResultSet)
{
var result = new List <AopNetwork>();
foreach (var resultRow in (resultSet as SparqlResultSet))
{
var recordId = ((ILiteralNode)resultRow["AopId"]).Value;
var record = new AopNetwork()
{
Id = recordId.Replace("AOP ", ""),
Name = recordId,
Description = ((ILiteralNode)resultRow["AopName"]).Value,
};
result.Add(record);
}
return(result);
}
else
{
return(null);
}
}
public void SparqlResultSetToDataTable2()
{
String query = "PREFIX ex: <http://example.org/vehicles/> SELECT * WHERE {?s a ex:Car . OPTIONAL { ?s ex:Speed ?speed }}";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
Object results = g.ExecuteQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
DataTable table = new DataTable();
foreach (String var in rset.Variables)
{
table.Columns.Add(new DataColumn(var, typeof(INode)));
}
foreach (SparqlResult r in rset)
{
DataRow row = table.NewRow();
foreach (String var in rset.Variables)
{
if (r.HasValue(var))
{
row[var] = r[var];
}
else
{
row[var] = null;
}
}
table.Rows.Add(row);
}
Assert.Equal(rset.Variables.Count(), table.Columns.Count);
Assert.Equal(rset.Count, table.Rows.Count);
foreach (DataRow row in table.Rows)
{
foreach (DataColumn col in table.Columns)
{
Object temp = row[col];
Console.Write(col.ColumnName + " = " + ((temp != null) ? temp.ToString() : String.Empty) + " , ");
}
Console.WriteLine();
}
}
else
{
Assert.True(false, "Query should have returned a Result Set");
}
}
public FoursquareDataController()
{
_foursquareGraph = new Graph();
FileLoader.Load(_foursquareGraph, @"Ontologies/Foursquare.owl");
//First we need an instance of the SparqlQueryParser
_parser = new SparqlQueryParser();
}
public void SparqlParsingReplaceExpression()
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString("SELECT (REPLACE(?term, 'find', 'replace') AS ?test) { }");
ISparqlExpression expr = q.Variables.First().Projection;
Assert.IsInstanceOf <ReplaceFunction>(expr);
}
public static SparqlResultSet Select(TripleStore store, string sparql)
{
InMemoryDataset ds = new InMemoryDataset(store);
ISparqlQueryProcessor processor = new LeviathanQueryProcessor(ds);
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery query = sparqlparser.ParseFromString(sparql);
return((SparqlResultSet)processor.ProcessQuery(query));
}
public void SparqlParsingNestedGraphPatternFirstItem2()
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromFile("resources\\childgraphpattern2.rq");
Console.WriteLine(q.ToString());
Console.WriteLine();
Console.WriteLine(q.ToAlgebra().ToString());
}
private object Query(string query)
{
var sqp = new SparqlQueryParser();
var sparqlQuery = sqp.ParseFromString(query);
sparqlQuery.AddDefaultGraph(_graphUri);
return(_store.Query(sparqlQuery.ToString()));
}
/// <summary>
/// Executes a SPARQL Query on the Triple Store
/// </summary>
/// <param name="query">SPARQL Query as unparsed String</param>
/// <returns></returns>
public virtual Object ExecuteQuery(String query)
{
//Parse the Query
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery q = sparqlparser.ParseFromString(query);
//Invoke other execute method
return(this.ExecuteQuery(q));
}
public FoodController()
{
_graph = new Graph();
var file = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "food.owl");
FileLoader.Load(_graph, file);
_parser = new SparqlQueryParser();
}
static object Execute(TripleStore store, string sparql)
{
InMemoryDataset ds = new InMemoryDataset(store);
ISparqlQueryProcessor processor = new LeviathanQueryProcessor(ds);
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery query = sparqlparser.ParseFromString(sparql);
return(processor.ProcessQuery(query));
}
/// <summary>
/// Executes a SPARQL Query on the Triple Store processing the results with an appropriate handler from those provided
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query as unparsed String</param>
public virtual void ExecuteQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, String query)
{
//Parse the Query
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery q = sparqlparser.ParseFromString(query);
//Invoke other execute method
this.ExecuteQuery(rdfHandler, resultsHandler, q);
}
protected void Page_Load(object sender, EventArgs e)
{
var sublayout = Parent as Sitecore.Web.UI.WebControls.Sublayout;
var dataSourceItem = Sitecore.Context.Database.GetItem(sublayout.DataSource);
var factory = DependencyResolver.Instance.Resolve <SitecoreManagerFactory>();
var manager = factory.GetContextWebDatabaseDataManager();
//string rawParameters = Attributes["sc_parameters"];
//var parameters = Sitecore.Web.WebUtil.ParseUrlParameters(rawParameters);
var title = dataSourceItem.Fields["Title"].Value;
var sparqlQuery = dataSourceItem.Fields["SparqlQuery"].Value;
litTitle.Text = title;
SitecoreTriples = new List <SitecoreTriple>();
if (!string.IsNullOrEmpty(sparqlQuery))
{
//Format the query
var formattedQuery = String.Format(sparqlQuery,
SitecoreTripleHelper.ItemToUri(Sitecore.Context.Item));
var sqp = new SparqlQueryParser();
var query = sqp.ParseFromString(formattedQuery);
if (query.QueryType == SparqlQueryType.Construct)
{
var triples = manager.TripleQuery(query);
SitecoreTriples = triples.ToSitecoreTriples();
}
else if (query.QueryType == SparqlQueryType.Select || query.QueryType == SparqlQueryType.SelectAll)
{
var resultSet = manager.ResultSetQuery(query);
foreach (SparqlResult result in resultSet)
{
foreach (var variable in result.ToList())
{
var sitecoreNode = variable.Value.ToSitecoreNode();
if (sitecoreNode != null)
{
litSparqlQueryResult.Text += string.Format("Key: {0} Value: <a href=\"{1}\">{2}</a><br/>",
variable.Key, LinkManager.GetItemUrl(sitecoreNode.Item), sitecoreNode.Item.Name);
}
else
{
litSparqlQueryResult.Text += string.Format("Key: {0} Value: {1}<br/>",
variable.Key, variable.Value.ToString());
}
}
}
}
}
}
public void SparqlQuery()
{
TripleStore store = new TripleStore();
var g = new Graph();
var parser = new NTriplesParser();
parser.Load(g, new StringReader(
@"<http://example.org/a> <http://example.org/b> <http://example.org/c>.
<http://example.org/a> <http://example.org/b> <http://example.org/d>.
<http://example.org/a> <http://example.org/b> <http://example.org/e>.
<http://example.org/d> <http://example.org/f> <http://example.org/g>."));
store.Add(g);
// Normal SPARQL results ARE NOT rdf data. But a rows of bindings.
Object results = store.ExecuteQuery("SELECT * WHERE {?s ?p ?o}");
if (results is SparqlResultSet)
{
var rset = (SparqlResultSet)results;
Assert.AreEqual(4, rset.Count);
foreach (SparqlResult result in rset)
{
Console.WriteLine(result.ToString());
}
}
// SPARQL can be used to construct RDF as a result of the query. This can be loaded into a graph
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery query = sparqlparser.ParseFromString("CONSTRUCT { ?s ?p ?o } WHERE {?s ?p ?o}");
results = store.ExecuteQuery(query);
if (results is IGraph)
{
IGraph gr = (IGraph)results;
foreach (Triple t in gr.Triples)
{
Console.WriteLine(t.ToString());
}
}
// SPARQL works by matching patterns
results = store.ExecuteQuery("SELECT * WHERE {<http://example.org/a> ?p ?o}");
if (results is SparqlResultSet)
{
var rset = (SparqlResultSet)results;
Assert.AreEqual(3, rset.Count);
foreach (SparqlResult result in rset)
{
Console.WriteLine(result.ToString());
}
}
}
public RedditDataController()
{
_redditGraph = new Graph();
// DataUriLoader.Load(_redditGraph, new Uri("https://www.tratics.com/semanticweb/Reddit.owl"));
FileLoader.Load(_redditGraph, @"Ontologies/Reddit.owl");
//First we need an instance of the SparqlQueryParser
_parser = new SparqlQueryParser();
}
/// <summary>
/// Loads data from ontology file and initialize some intances for querying
/// </summary>
public static void Start()
{
store = new TripleStore();
store.LoadFromFile("PhoneOntology.owl");
InMemoryDataset ds = new InMemoryDataset(store);
processor = new LeviathanQueryProcessor(ds);
sparqlparser = new SparqlQueryParser();
}
public void SparqlSimpleQuery1()
{
TripleStore store = new TripleStore();
store.AddFromUri(new Uri("http://dbpedia.org/resource/Barack_Obama"));
string sparqlQuery = "SELECT * WHERE {?s ?p ?o}";
SparqlQueryParser sparqlParser = new SparqlQueryParser();
SparqlQuery query = sparqlParser.ParseFromString(sparqlQuery);
Object results = store.ExecuteQuery(query);
}
/// <summary>
/// Creates a new SPARQL View
/// </summary>
/// <param name="sparqlQuery">SPARQL Query</param>
/// <param name="store">Triple Store to query</param>
protected BaseSparqlView(String sparqlQuery, ITripleStore store)
{
SparqlQueryParser parser = new SparqlQueryParser();
this._q = parser.ParseFromString(sparqlQuery);
this._store = store;
this._async = new UpdateViewDelegate(this.UpdateViewInternal);
this.Initialise();
}
/// <summary>
/// This method queries the dotNetRdf store directly.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public object ExecuteQuery(string query)
{
Log?.Invoke(query);
SparqlQueryParser parser = new SparqlQueryParser();
var q = parser.ParseFromString(query);
return(_queryProcessor.ProcessQuery(q));
}
private void ExecuteSparqlQuery()
{
fixture.StartWatch();
ISparqlQueryProcessor processor = new LeviathanQueryProcessor(_smallStore);
SparqlQueryParser sparqlparser = new SparqlQueryParser();
SparqlQuery query = sparqlparser.ParseFromString(File.ReadAllText(@"data\rdf\queries\query1.sparql"));
_sparqlResults = processor.ProcessQuery(query) as SparqlResultSet;
fixture.Log("Executed sparql query on {0} named graphs yielding {1} results. Elapsed time: {2} miliseconds.", "ExecuteSparqlQuery", _smallStore.Graphs.Count(p => p.BaseUri != null), _sparqlResults.Results.Count, fixture.StopWatch());
}
public void SparqlLazyWithAndWithoutOffset()
{
String query = "SELECT * WHERE { ?s a ?vehicle . FILTER (SAMETERM(?vehicle, <http://example.org/vehicles/Car>)) } LIMIT 3";
String query2 = "SELECT * WHERE { ?s a ?vehicle . FILTER (SAMETERM(?vehicle, <http://example.org/vehicles/Car>)) } LIMIT 3 OFFSET 3";
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "InferenceTest.ttl");
store.Add(g);
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
SparqlQuery q2 = parser.ParseFromString(query2);
Console.WriteLine(q.ToAlgebra().ToString());
Assert.IsTrue(q.ToAlgebra().ToString().Contains("LazyBgp"), "Should have been optimised to use a Lazy BGP");
Console.WriteLine();
Console.WriteLine(q2.ToAlgebra().ToString());
Assert.IsTrue(q2.ToAlgebra().ToString().Contains("LazyBgp"), "Should have been optimised to use a Lazy BGP");
Console.WriteLine();
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store));
Object results = processor.ProcessQuery(q);
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
foreach (SparqlResult r in rset)
{
Console.WriteLine(r.ToString());
}
Assert.IsTrue(rset.Count == 3, "Expected exactly 3 results");
Object results2 = processor.ProcessQuery(q2);
if (results2 is SparqlResultSet)
{
SparqlResultSet rset2 = (SparqlResultSet)results2;
foreach (SparqlResult r in rset2)
{
Console.WriteLine(r.ToString());
}
Assert.IsTrue(rset2.Count == 1, "Expected exactly 1 results");
}
else
{
Assert.Fail("Expected a SPARQL Result Set");
}
}
else
{
Assert.Fail("Expected a SPARQL Result Set");
}
}
public DescribeAlgorithms()
{
this._parser = new SparqlQueryParser();
TripleStore store = new TripleStore();
Graph g = new Graph();
g.LoadFromFile("resources\\describe-algos.ttl");
store.Add(g);
this._data = new InMemoryDataset(store);
this._processor = new LeviathanQueryProcessor(this._data);
}
static void CustomQuery()
{
Uri prefixRDF = new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
Uri prefixFilm = new Uri("http://www.semprog.com/film#");
//IGraph g = new Graph(); //Load triples from file OWL
//g.LoadFromFile("film-ontology.owl");
//g.BaseUri = null; //!
IGraph g = new VDS.RDF.Graph(); //Load triples from server (OWL)
RdfsReasoner reasoner = new RdfsReasoner(); //Apply reasoner
reasoner.Initialise(g);
reasoner.Apply(g);
g.BaseUri = null; //!!!!!!!!
TripleStore store = new TripleStore();
store.Add(g);
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.Namespaces.AddNamespace("rdf", prefixRDF);
queryString.Namespaces.AddNamespace("film", prefixFilm);
queryString.CommandText = "SELECT ?who WHERE { ?who rdf:type film:Person }";
string sparql = "";
sparql = File.ReadAllText("sparql1.txt");
SparqlQueryParser parser = new SparqlQueryParser();
//SparqlQuery query = parser.ParseFromString(queryString.ToString());
SparqlQuery query = parser.ParseFromString(sparql);
Console.WriteLine(query.ToAlgebra());
Console.WriteLine(query.ToString());
//ISparqlQueryProcessor processor = new LeviathanQueryProcessor(store); //process query
//SparqlResultSet results = processor.ProcessQuery(query) as SparqlResultSet;
ISparqlQueryProcessor processor = new MirageQueryProcessor(mapping);//new LeviathanQueryProcessor(store); //process query
string results = processor.ProcessQuery(query) as string;
Console.WriteLine(results);
//if (results is SparqlResultSet)
//{
// SparqlResultSet rset = (SparqlResultSet)results;
// foreach (SparqlResult result in rset)
// {
// Console.WriteLine(result);
// }
//}
}
public string MakeSparqlQueryAndReturnGraphAsJsonLdString(string sparqlQuery)
{
var parser = new SparqlQueryParser();
SparqlQuery tupleQuery = parser.ParseFromString(sparqlQuery);
var processor = new LeviathanQueryProcessor(_repository);
var result = processor.ProcessQuery(tupleQuery) as IGraph;
var ts = new TripleStore();
ts.Add(result);
return(StringWriter.Write(ts, new JsonLdWriter()));
}
private static SparqlQuery ParseSparql(string exp)
{
var parser = new SparqlQueryParser(SparqlQuerySyntax.Extended);
var expressionFactories = parser.ExpressionFactories.ToList();
expressionFactories.Add(new BrightstarFunctionFactory());
parser.ExpressionFactories = expressionFactories;
var query = parser.ParseFromString(exp);
return(query);
}
public void Setup()
{
this._parser = new SparqlQueryParser();
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "describe-algos.ttl");
store.Add(g);
this._data = new InMemoryDataset(store);
this._processor = new LeviathanQueryProcessor(this._data);
}
/// <summary>
/// Executes this command as a query
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
public void ExecuteQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler)
{
if (this._queryProcessor == null)
{
throw new RdfQueryException("Cannot call ExecuteQuery() when the QueryProcessor property has not been set");
}
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(this.ToString());
this._queryProcessor.ProcessQuery(rdfHandler, resultsHandler, q);
}
public RDFExplorerGraph ConvertToGraph(string query)
{
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.Namespaces.AddNamespace("wd", new Uri("http://www.wikidata.org/entity/"));
queryString.Namespaces.AddNamespace("wdt", new Uri("http://www.wikidata.org/prop/direct/"));
queryString.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
queryString.CommandText = query;
var parser = new SparqlQueryParser();
//Then we can parse a SPARQL string into a query
var sparqlQuery = parser.ParseFromString(queryString);
var triples = sparqlQuery.RootGraphPattern.TriplePatterns.Select(x => (TriplePattern)x).ToArray();
var variables = sparqlQuery.RootGraphPattern.Variables.ToArray();
var nodesDict = new Dictionary <string, Node>();
var edgesDict = new Dictionary <string, Edge>();
foreach (var triple in triples)
{
var s = triple.Subject.ToString();
var p = triple.Predicate.ToString();
var o = triple.Object.ToString();
if (!nodesDict.ContainsKey(s))
{
nodesDict.Add(s, ToNode(s));
}
if (!nodesDict.ContainsKey(o))
{
nodesDict.Add(o, ToNode(o));
}
var subjectNode = nodesDict[s];
var objectNode = nodesDict[o];
if (!edgesDict.ContainsKey(p))
{
edgesDict.Add(p, ToEdge(p, subjectNode.id, objectNode.id));
}
}
var nodes = nodesDict.Select(x => x.Value).ToArray();
var edges = edgesDict.Select(x => x.Value).ToArray();
return(new RDFExplorerGraph {
nodes = nodes.ToArray(), edges = edges.ToArray()
});
}
static void Main(string[] args)
{
// For simple queries:
//First we need an instance of the SparqlQueryParser
SparqlQueryParser parser = new SparqlQueryParser();
//For complex queries
//Create a Parameterized String
SparqlParameterizedString queryString = new SparqlParameterizedString();
//Add a namespace declaration
queryString.Namespaces.AddNamespace("ex", new Uri("http://www.w3.org/ns/dcat#"));
//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 }";
//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 p = new SparqlQueryParser();
SparqlQuery query = p.ParseFromString(queryString);
IGraph g = new Graph();
g.LoadFromFile("dcat-ap_2.0.1.rdf");
foreach (Triple t in g.Triples)
{
Console.WriteLine(string.Concat("PREDICATE: ", t.Predicate));
Console.WriteLine(string.Concat("SUBJECT: ", t.Subject));
Console.WriteLine(string.Concat("OBJECT: ", t.Object));
}
TurtleParser turtleParser = new TurtleParser();
Graph graph = new Graph();
graph.LoadFromFile("dcat-ap_2.0.1.rdf");
var ds = graph.GetUriNode("dct:title");
}
public void SparqlParsingSubqueries2()
{
String query = "SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o } } }";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Console.WriteLine("Parsed original input OK");
String query2 = q.ToString();
SparqlQuery q2 = parser.ParseFromString(query2);
Console.WriteLine("Parsed reserialized input OK");
}
/// <summary>
/// Creates a new SPARQL Query Validator using the given Query Parser
/// </summary>
/// <param name="parser">Query Parser</param>
public SparqlQueryValidator(SparqlQueryParser parser)
{
this._parser = parser;
}
/// <summary>
/// Creates a new SPARQL Query Validator
/// </summary>
public SparqlQueryValidator()
{
this._parser = new SparqlQueryParser();
}
/// <summary>
/// Creates a new SPARQL Query Validator using the given Syntax
/// </summary>
/// <param name="syntax">Query Syntax</param>
public SparqlQueryValidator(SparqlQuerySyntax syntax)
{
this._parser = new SparqlQueryParser(syntax);
}
