/// <summary>
/// Executes a Graph Pattern style query against the Source
/// </summary>
/// <param name="graph">Graph Pattern</param>
/// <param name="options">Query Options</param>
/// <param name="sink">Results Sink</param>
/// <remarks>
/// <para>
/// This is implemented by transforming the Graph Pattern which is a set of SemWeb Statement templates into a SPARQL Algebra BGP. The resulting algebra is then executed using the Leviathan engine and the results converted into VariableBindings for SemWeb
/// </para>
/// <para>
/// The only Query Option that is supported is the Limit option
/// </para>
/// </remarks>
public void Query(Statement[] graph, SW.Query.QueryOptions options, SW.Query.QueryResultSink sink)
{
ISparqlAlgebra algebra = this.ToAlgebra(graph);
if (this._store == null)
{
this._store = new TripleStore();
this._store.Add(this._g);
}
SparqlEvaluationContext context = new SparqlEvaluationContext(null, new InMemoryDataset(this._store));
BaseMultiset results = context.Evaluate(algebra);//algebra.Evaluate(context);
sink.Init(results.Variables.Select(v => new Variable(v)).ToArray());
if (results.Count > 0)
{
int c = 0;
foreach (ISet s in results.Sets)
{
//Apply Limit if applicable
if (options.Limit > 0 && c >= options.Limit)
{
sink.Finished();
return;
}
//Convert the Set to VariableBindings for SemWeb
Variable[] vars = s.Variables.Select(v => new Variable(v)).ToArray();
Resource[] resources = s.Variables.Select(v => SemWebConverter.ToSemWeb(s[v], this._mapping)).ToArray();
SW.Query.VariableBindings bindings = new SW.Query.VariableBindings(vars, resources);
//Keep adding results until the sink tells us to stop
if (!sink.Add(bindings))
{
sink.Finished();
return;
}
c++;
}
sink.Finished();
}
else
{
sink.Finished();
}
}
/// <summary>
/// Queries the Store using the Graph Pattern specified by the set of Statement Patterns
/// </summary>
/// <param name="graph">Graph Pattern</param>
/// <param name="options">Query Options</param>
/// <param name="sink">Results Sink</param>
/// <remarks>
/// <para>
/// Implemented by converting the Statement Patterns into a SPARQL SELECT query and executing that against the underlying Store's SPARQL engine
/// </para>
/// <para>
/// The only Query Option that is supported is the Limit option
/// </para>
/// </remarks>
public void Query(Statement[] graph, SW.Query.QueryOptions options, SW.Query.QueryResultSink sink)
{
//Implement as a SPARQL SELECT
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.CommandText = "SELECT * WHERE {";
int p = 0;
foreach (Statement stmt in graph)
{
//Add Subject
queryString.CommandText += "\n";
if (stmt.Subject is Variable)
{
queryString.CommandText += stmt.Subject.ToString();
}
else
{
queryString.CommandText += "@param" + p;
queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Subject, this._mapping));
p++;
}
queryString.CommandText += " ";
//Add Predicate
if (stmt.Predicate is Variable)
{
queryString.CommandText += stmt.Predicate.ToString();
}
else
{
queryString.CommandText += "@param" + p;
queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Predicate, this._mapping));
p++;
}
queryString.CommandText += " ";
//Add Object
if (stmt.Object is Variable)
{
queryString.CommandText += stmt.Object.ToString();
}
else
{
queryString.CommandText += "@param" + p;
queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Object, this._mapping));
p++;
}
queryString.CommandText += " .";
}
queryString.CommandText += "}";
//Execute the Query and convert the Results
Object results = this._store.ExecuteQuery(queryString.ToString());
if (results is SparqlResultSet)
{
SparqlResultSet rset = (SparqlResultSet)results;
sink.Init(rset.Variables.Select(v => new Variable(v)).ToArray());
if (rset.Count > 0)
{
int c = 0;
foreach (SparqlResult r in rset)
{
//Apply Limit if applicable
if (options.Limit > 0 && c >= options.Limit)
{
sink.Finished();
return;
}
//Convert the Set to VariableBindings for SemWeb
Variable[] vars = r.Variables.Select(v => new Variable(v)).ToArray();
Resource[] resources = r.Variables.Select(v => SemWebConverter.ToSemWeb(r[v], this._mapping)).ToArray();
SW.Query.VariableBindings bindings = new SW.Query.VariableBindings(vars, resources);
//Keep adding results until the sink tells us to stop
if (!sink.Add(bindings))
{
sink.Finished();
return;
}
c++;
}
sink.Finished();
}
else
{
sink.Finished();
}
}
else
{
throw new RdfQueryException("Query returned an unexpected result where a SPARQL Result Set was expected");
}
}
void RewriteGraph(Statement[] graph, SemWeb.Query.QueryOptions options, out Statement[] graph2, out SemWeb.Query.QueryOptions options2, SemWeb.Query.QueryResultSink sink)
{
graph2 = new Statement[graph.Length];
options2 = new SemWeb.Query.QueryOptions();
options2.DistinguishedVariables = options.DistinguishedVariables;
options2.Limit = options.Limit;
options2.VariableKnownValues = (options.VariableKnownValues == null ? new VarKnownValuesType() : new VarKnownValuesType(options.VariableKnownValues));
options2.VariableLiteralFilters = options.VariableLiteralFilters;
for (int i = 0; i < graph.Length; i++)
{
graph2[i] = graph[i];
//ResSet subj = GetQueryRes(graph[i], 0, options);
ResSet pred = GetQueryRes(graph[i], 1, options);
ResSet obj = GetQueryRes(graph[i], 2, options);
if (pred.Count == 1 && pred.Contains(type))
{
// in an ?x rdf:type ___ query, replace ___ with the subclass closure of ___.
if (obj.Count > 0)
{
Entity[] sc = GetClosure(obj, subclasses, true);
if (sc.Length != obj.Count && sink != null)
{
sink.AddComments("Expanding object of " + graph[i] + " with subclass closure to [" + ToString(sc) + "]");
}
SetQueryRes(ref graph2[i], 2, options2, sc);
}
}
// expand properties into subproperties after the above tests,
// because we want to be sure the property was originally
// just one of the recognized properties
if (pred.Count > 0)
{
Entity[] pc = GetClosure(pred, subprops, true);
SetQueryRes(ref graph2[i], 1, options2, pc);
if (pc.Length != pred.Count && sink != null)
{
sink.AddComments("Expanding predicate of " + graph[i] + " with subproperty closure to [" + ToString(pc) + "]");
}
}
}
}
public override void Query(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource targetModel, SemWeb.Query.QueryResultSink sink)
{
QueryCheckArg(graph);
// Try to do the inferencing.
ArrayList evidence = prove(rules, targetModel, graph, -1);
if (evidence == null)
{
return; // not provable (in max number of steps, if that were given)
}
// Then send the possible bindings to the QueryResultSink.
// Map variables to indexes.
Hashtable vars = new Hashtable();
foreach (Statement s in graph)
{
if (s.Subject is Variable && !vars.ContainsKey(s.Subject))
{
vars[s.Subject] = vars.Count;
}
if (s.Predicate is Variable && !vars.ContainsKey(s.Predicate))
{
vars[s.Predicate] = vars.Count;
}
if (s.Object is Variable && !vars.ContainsKey(s.Object))
{
vars[s.Object] = vars.Count;
}
}
// Prepare the bindings array.
Variable[] varOrder = new Variable[vars.Count];
foreach (Variable v in vars.Keys)
{
varOrder[(int)vars[v]] = v;
}
// Initialize the sink.
sink.Init(varOrder);
// Send a binding set for each piece of evidence.
foreach (EvidenceItem ei in evidence)
{
// Write a comment to the results with the actual proof. (nifty actually)
sink.AddComments(ei.ToProof().ToString());
// Create the binding array and send it on
Resource[] variableBindings = new Resource[varOrder.Length];
foreach (Variable v in vars.Keys)
{
if (ei.env.ContainsKey(v))
{
variableBindings[(int)vars[v]] = (Resource)ei.env[v];
}
}
sink.Add(new SemWeb.Query.VariableBindings(varOrder, variableBindings));
}
// Close the sink.
sink.Finished();
}
public override void Query(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource data, SemWeb.Query.QueryResultSink sink)
{
Statement[] graph2;
SemWeb.Query.QueryOptions options2;
RewriteGraph(graph, options, out graph2, out options2, sink);
// TODO: Because we add variables to the query when we replace things with closures,
// we should filter the query results so we don't pass back the bindings for those
// variables to the caller.
if (!(data is QueryableSource))
{
new SimpleEntailment().Query(graph2, options2, data, sink);
}
else
{
((QueryableSource)data).Query(graph2, options2, sink);
}
}
