public ISparqlQueryResult ExecuteQuery(ISparqlQuery query, ITransaction transaction = null)
{
string q = query.ToString();
Log?.Invoke(q);
SparqlQueryParser p = new SparqlQueryParser();
var x = p.ParseFromString(q);
x.ClearNamedGraphs();
x.ClearDefaultGraphs();
SparqlEndpointQueryResult result = null;
if (query.QueryType == SparqlQueryType.Describe || query.QueryType == SparqlQueryType.Construct)
{
var r = _endpoint.QueryWithResultGraph(x.ToString());
result = new SparqlEndpointQueryResult(r, query);
}
else
{
var r = _endpoint.QueryWithResultSet(x.ToString());
result = new SparqlEndpointQueryResult(r, query);
}
return(result);
}
/// <summary>
/// Internal constructor which parses the results returned from a given query.
/// </summary>
/// <param name="query">The executed query.</param>
/// <param name="store"></param>
/// <param name="transaction"></param>
/// <param name="model"></param>
internal VirtuosoSparqlQueryResult(IModel model, ISparqlQuery query, VirtuosoStore store, ITransaction transaction = null)
{
_store = store;
_transaction = transaction;
_query = query;
_model = model;
}
public IEnumerable <T> GetResources <T>(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null) where T : Resource
{
IEnumerable <T> result = ExecuteQuery(query, inferenceEnabled, transaction).GetResources <T>();
// TODO: Could be done in the SparqlQueryResult for increased performance.
if (result != null)
{
foreach (object r in result)
{
T t = r as T;
// NOTE: This safeguard is required because of a bug in ExecuteQuery where
// it returns null objects when a rdf:type triple is missing..
if (t == null)
{
continue;
}
t.SetModel(this);
t.IsNew = false;
t.IsSynchronized = true;
t.IsReadOnly = true;
yield return(t);
}
}
}
public ISparqlQueryResult ExecuteQuery(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null)
{
query.Model = this;
query.IsInferenceEnabled = inferenceEnabled;
return(_store.ExecuteQuery(query, transaction));
}
public dotNetRDFQueryResult(dotNetRDFStore store, ISparqlQuery query, IGraph graph)
{
_query = query;
_tripleProvider = new GraphTripleProvider(graph);
_model = query.Model;
_store = store;
}
public string CreateQuery(ISparqlQuery query)
{
StringBuilder queryBuilder = new StringBuilder();
// Add Virtuoso specific describe mode for Describe queries.
if (query.QueryType == SparqlQueryType.Describe)
{
// http://docs.openlinksw.com/virtuoso/rdfsparql.html: sql:describe-mode "SPO".
// This pair of procedures searches for all triples where the input IRIs are used
// as subjects; they are faster than the default routine which searches for all
// triples where the input IRIs are used as subjects or objects.
queryBuilder.Append("DEFINE sql:describe-mode \"SPO\" \n");
}
// Add Virtuoso specific inferencing DEFINEs.
// The models which can be used for inferencing is Virtuoso specific and
// are therefore added here in the store.
if (query.IsInferenceEnabled)
{
if (string.IsNullOrEmpty(_defaultInferenceRule))
{
throw new Exception("You tried to query with inferencing but the inference rule is empty or not set.");
}
queryBuilder.Append("DEFINE input:inference '" + _defaultInferenceRule + "' \n");
}
queryBuilder.Append(query.ToString());
return(string.Format("SPARQL {0}", queryBuilder));
}
/// <summary>
/// Add an offset or limit solution modifier to a given SPARQL query.
/// </summary>
/// <param name="model">The model to be queried.</param>
/// <param name="query">The SPARQL query to be executed.</param>
/// <param name="offset">Offset solution modifier.</param>
/// <param name="limit">Limit solution modifier.</param>
/// <returns></returns>
public static string SerializeOffsetLimit(IModel model, ISparqlQuery query, int offset = -1, int limit = -1)
{
string variable = "?" + query.GetGlobalScopeVariableNames()[0];
string from = GenerateDatasetClause(model);
string where = query.GetRootGraphPattern();
StringBuilder resultBuilder = new StringBuilder();
resultBuilder.AppendFormat("SELECT {0} ?p ?o {1} WHERE {{ {0} ?p ?o {{", variable, from);
resultBuilder.AppendFormat("SELECT DISTINCT {0} WHERE {{ {1} }}", variable, where);
if (offset != -1)
{
resultBuilder.Append(" OFFSET ");
resultBuilder.Append(offset);
}
if (limit != -1)
{
resultBuilder.Append(" LIMIT ");
resultBuilder.Append(limit);
}
resultBuilder.Append(" } }");
return(resultBuilder.ToString());
}
public StardogQueryResult(StardogStore store, ISparqlQuery query, StardogResultHandler resultHandler)
{
_resultHandler = resultHandler;
string s = null;
string p = null;
string o = null;
if (query.ProvidesStatements())
{
// A list of global scope variables without the ?. Used to access the
// subject, predicate and object variable in statement providing queries.
string[] vars = query.GetGlobalScopeVariableNames();
s = vars[0];
p = vars[1];
o = vars[2];
}
_query = query;
if (_resultHandler.SparqlResultSet != null)
{
_tripleProvider = new SparqlResultSetTripleProvider(_resultHandler.SparqlResultSet, s, p, o);
}
_model = query.Model;
_resultHandler = resultHandler;
_store = store;
}
/// <summary>
/// Executes a SparqlQuery on the store.
/// </summary>
/// <param name="query"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public override ISparqlQueryResult ExecuteQuery(ISparqlQuery query, ITransaction transaction = null)
{
if (query.IsInferenceEnabled && _reasoner != null)
{
_store.AddInferenceEngine(_reasoner);
}
else
{
_store.ClearInferenceEngines();
}
string q = query.ToString();
object results = ExecuteQuery(q);
if (results is IGraph)
{
return(new dotNetRDFQueryResult(this, query, results as IGraph));
}
else if (results is SparqlResultSet)
{
return(new dotNetRDFQueryResult(this, query, results as SparqlResultSet));
}
return(null);
}
/// <summary>
/// Execute a SPARQL Query.
/// </summary>
/// <param name="query">A SparqlQuery object.</param>
/// <param name="inferenceEnabled">Indicate that this query should work with enabled inferencing.</param>
/// <param name="transaction">Transaction associated with this action.</param>
/// <returns>A SparqlQueryResults object in any case.</returns>
public ISparqlQueryResult ExecuteQuery(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null)
{
if (query.Model == null || !query.GetDefaultModels().Any())
{
query.Model = this;
}
query.IsInferenceEnabled = inferenceEnabled;
return(_store.ExecuteQuery(query, transaction));
}
/// <summary>
/// Executes a <c>SparqlQuery</c> on the store.
/// </summary>
/// <param name="query">SPARQL query to be executed.</param>
/// <param name="transaction">An optional transaction.</param>
/// <returns></returns>
public override ISparqlQueryResult ExecuteQuery(ISparqlQuery query, ITransaction transaction = null)
{
string q = query.ToString();
Log?.Invoke(q);
StardogResultHandler resultHandler = new StardogResultHandler();
_connector.Query(_rdfHandler, resultHandler, q, query.IsInferenceEnabled);
return(new StardogQueryResult(this, query, resultHandler));
}
/// <summary>
/// Executes a SPARQL query and provides an enumeration of matching resources.
/// </summary>
/// <param name="query">The SparqlQuery object that should be executed.</param>
/// <param name="inferenceEnabled">Indicate that this query should work with enabled inferencing.</param>
/// <param name="transaction">transaction associated with this action.</param>
/// <returns>An enumeration of resources that match the given query.</returns>
public IEnumerable <Resource> GetResources(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null)
{
IEnumerable <Resource> result = ExecuteQuery(query, inferenceEnabled, transaction).GetResources <Resource>();
if (result != null)
{
// TODO: Should be done in the SparqlQueryResult for increased performance.
foreach (Resource r in result)
{
r.SetModel(this);
r.IsNew = false;
r.IsSynchronized = true;
}
}
return(result);
}
public IEnumerable <Resource> GetResources(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null)
{
IEnumerable <Resource> result = ExecuteQuery(query, inferenceEnabled, transaction).GetResources <Resource>();
if (result != null)
{
foreach (Resource r in result)
{
r.SetModel(this);
r.IsNew = false;
r.IsReadOnly = true;
r.IsSynchronized = true;
}
}
return(result);
}
/// <summary>
/// Serialize a count query for the given SPARQL query.
/// </summary>
/// <param name="model">The model to be queried.</param>
/// <param name="query">The query which results should be counted.</param>
/// <returns></returns>
public static string SerializeCount(IModel model, ISparqlQuery query)
{
string variable = "?" + query.GetGlobalScopeVariableNames()[0];
string from = GenerateDatasetClause(model);
string where = query.GetRootGraphPattern();
StringBuilder queryBuilder = new StringBuilder();
queryBuilder.Append("SELECT COUNT(DISTINCT ");
queryBuilder.Append(variable);
queryBuilder.Append(") AS ?count ");
queryBuilder.Append(from);
queryBuilder.Append(" WHERE { ");
queryBuilder.Append(where);
queryBuilder.Append(" }");
return(queryBuilder.ToString());
}
public T ExecuteScalar <T>(QueryModel queryModel)
{
Type t = typeof(T);
if (t == typeof(bool))
{
// Generate and execute ASK query.
SparqlQueryModelVisitor <T> visitor = new SparqlQueryModelVisitor <T>(new AskQueryGenerator());
visitor.VisitQueryModel(queryModel);
ISparqlQuery query = visitor.GetQuery();
ISparqlQueryResult result = Model.ExecuteQuery(query, _inferenceEnabled);
return(new object[] { result.GetAnwser() }.OfType <T>().First());
}
else if (queryModel.ResultOperators.Any(o => o is CountResultOperator))
{
SparqlQueryModelVisitor <T> visitor = new SparqlQueryModelVisitor <T>(new SelectBindingsQueryGenerator());
visitor.VisitQueryModel(queryModel);
ISparqlQuery query = visitor.GetQuery();
ISparqlQueryResult result = Model.ExecuteQuery(query, _inferenceEnabled);
BindingSet b = result.GetBindings().FirstOrDefault();
if (b != null && b.Any())
{
return(new object[] { b.First().Value }.OfType <T>().First());
}
else
{
return(new object[] { 0 }.OfType <T>().First());
}
}
else
{
// Unknown scalar type.
throw new NotImplementedException();
}
}
public dotNetRDFQueryResult(dotNetRDFStore store, ISparqlQuery query, SparqlResultSet resultSet)
{
string s = null;
string p = null;
string o = null;
if (query.ProvidesStatements())
{
// A list of global scope variables without the ?. Used to access the
// subject, predicate and object variable in statement providing queries.
string[] vars = query.GetGlobalScopeVariableNames();
s = vars[0];
p = vars[1];
o = vars[2];
}
_query = query;
_tripleProvider = new SparqlResultSetTripleProvider(resultSet, s, p, o);
_model = query.Model;
_queryResults = resultSet;
_store = store;
}
/// <summary>
/// Generate a query which returns the URIs of all resources selected in a given query.
/// </summary>
/// <param name="model">The model to be queried.</param>
/// <param name="query">The SPARQL query which provides resources.</param>
/// <param name="offset">Offset solution modifier.</param>
/// <param name="limit">Limit solution modifier.</param>
/// <returns></returns>
public static string SerializeFetchUris(IModel model, ISparqlQuery query, int offset = -1, int limit = -1)
{
string variable = "?" + query.GetGlobalScopeVariableNames()[0];
string from = GenerateDatasetClause(model);
string where = query.GetRootGraphPattern();
string orderby = query.GetRootOrderByClause();
StringBuilder queryBuilder = new StringBuilder();
foreach (string prefix in query.GetDeclaredPrefixes())
{
queryBuilder.Append($"PREFIX <{prefix}> ");
}
queryBuilder.Append("SELECT DISTINCT ");
queryBuilder.Append(variable);
queryBuilder.Append(from);
queryBuilder.Append(" WHERE { ");
queryBuilder.Append(where);
queryBuilder.Append(" } ");
queryBuilder.Append(orderby);
if (offset != -1)
{
queryBuilder.Append(" OFFSET ");
queryBuilder.Append(offset);
}
if (limit != -1)
{
queryBuilder.Append(" LIMIT ");
queryBuilder.Append(limit);
}
return(queryBuilder.ToString());
}
public IEnumerable <T> ExecuteCollection <T>(QueryModel queryModel)
{
Type t = queryModel.SelectClause.Selector.Type;
if (typeof(Resource).IsAssignableFrom(t))
{
// Handle queries which return instances of resources.
SparqlQueryModelVisitor <T> visitor = new SparqlQueryModelVisitor <T>(new SelectTriplesQueryGenerator());
visitor.VisitQueryModel(queryModel);
MethodInfo getResources = _getResourceMethod.MakeGenericMethod(typeof(T));
object[] args = new object[] { visitor.GetQuery(), _inferenceEnabled, null };
foreach (T value in getResources.Invoke(Model, args) as IEnumerable <T> )
{
yield return(value);
}
}
else
{
// Handle queries which return value type objects.
SparqlQueryModelVisitor <T> visitor = new SparqlQueryModelVisitor <T>(new SelectBindingsQueryGenerator());
visitor.VisitQueryModel(queryModel);
ISparqlQuery query = visitor.GetQuery();
ISparqlQueryResult result = Model.ExecuteQuery(query, _inferenceEnabled);
// TODO: This works correctly for single bindings, check with multiple bindings.
foreach (BindingSet bindings in result.GetBindings())
{
foreach (var value in bindings.Values.OfType <T>())
{
yield return(value);
}
}
}
}
internal static string SerializeFetchUris(IModel model, ISparqlQuery query, int offset = -1, int limit = -1)
{
string variable = "?" + query.GetGlobalScopeVariableNames()[0];
string from = GenerateDatasetClause(model);
string where = query.GetRootGraphPattern();
string orderby = query.GetRootOrderByClause();
StringBuilder queryBuilder = new StringBuilder();
foreach (string prefix in query.GetDeclaredPrefixes())
{
queryBuilder.AppendFormat("prefix <{0}> ", prefix);
}
queryBuilder.Append("select distinct ");
queryBuilder.Append(variable);
queryBuilder.Append(from);
queryBuilder.Append(" where { ");
queryBuilder.Append(where);
queryBuilder.Append(" } ");
queryBuilder.Append(orderby);
if (offset != -1)
{
queryBuilder.Append(" offset ");
queryBuilder.Append(offset);
}
if (limit != -1)
{
queryBuilder.Append(" limit ");
queryBuilder.Append(limit);
}
return(queryBuilder.ToString());
}
public SparqlEndpointQueryResult(IGraph r1, ISparqlQuery query) : base(null, query, r1)
{
}
public SparqlEndpointQueryResult(SparqlResultSet r, ISparqlQuery query) : base(null, query, r)
{
}
/// <summary> /// Executes a <c>SparqlQuery</c> on the store. /// </summary> /// <param name="query">SPARQL query to be executed.</param> /// <param name="transaction">An optional transaction.</param> /// <returns></returns> public abstract ISparqlQueryResult ExecuteQuery(ISparqlQuery query, ITransaction transaction = null);
public override ISparqlQueryResult ExecuteQuery(ISparqlQuery query, ITransaction transaction = null)
{
return(new VirtuosoSparqlQueryResult(query.Model, query, this, transaction));
}
public IEnumerable <BindingSet> GetBindings(ISparqlQuery query, bool inferenceEnabled = false, ITransaction transaction = null)
{
return(ExecuteQuery(query, inferenceEnabled, transaction).GetBindings());
}
