/// <summary>
/// Applies the query to the given store
/// </summary>
public RDFAskQueryResult ApplyToStore(RDFStore store)
{
if (store != null)
{
this.PatternGroupResultTables.Clear();
this.PatternResultTables.Clear();
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (!this.IsEmpty)
{
//Iterate the pattern groups of the query
foreach (RDFPatternGroup patternGroup in this.PatternGroups)
{
//Step 1: Get the intermediate result tables of the current pattern group
RDFAskQueryEngine.EvaluatePatterns(this, patternGroup, store);
//Step 2: Get the result table of the current pattern group
RDFAskQueryEngine.CombinePatterns(this, patternGroup);
//Step 3: Apply the filters of the current pattern group to its result table
RDFAskQueryEngine.ApplyFilters(this, patternGroup);
}
//Step 4: Get the result table of the query
DataTable queryResultTable = RDFQueryEngine.CombineTables(this.PatternGroupResultTables.Values.ToList <DataTable>(), false);
//Step 5: Transform the result into a boolean response
askResult.AskResult = (queryResultTable.Rows.Count > 0);
}
return(askResult);
}
throw new RDFQueryException("Cannot execute ASK query because given \"store\" parameter is null.");
}
/// <summary>
/// Applies the query to the given SPARQL endpoint
/// </summary>
public RDFAskQueryResult ApplyToSPARQLEndpoint(RDFSPARQLEndpoint sparqlEndpoint)
{
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (sparqlEndpoint != null)
{
//Establish a connection to the given SPARQL endpoint
using (WebClient webClient = new WebClient())
{
//Insert reserved "query" parameter
webClient.QueryString.Add("query", HttpUtility.UrlEncode(this.ToString()));
//Insert user-provided parameters
webClient.QueryString.Add(sparqlEndpoint.QueryParams);
//Insert request headers
webClient.Headers.Add(HttpRequestHeader.Accept, "application/sparql-results+xml");
//Send querystring to SPARQL endpoint
byte[] sparqlResponse = webClient.DownloadData(sparqlEndpoint.BaseAddress);
//Parse response from SPARQL endpoint
if (sparqlResponse != null)
{
using (var sStream = new MemoryStream(sparqlResponse))
{
askResult = RDFAskQueryResult.FromSparqlXmlResult(sStream);
}
}
}
}
return(askResult);
}
/// <summary>
/// Applies the query to the given datasource
/// </summary>
internal RDFAskQueryResult ApplyToDataSource(RDFDataSource datasource)
{
this.PatternGroupResultTables.Clear();
this.PatternResultTables.Clear();
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (this.PatternGroups.Any())
{
//Iterate the pattern groups of the query
var fedPatternResultTables = new Dictionary <RDFPatternGroup, List <DataTable> >();
foreach (var patternGroup in this.PatternGroups)
{
//Step 1: Get the intermediate result tables of the current pattern group
if (datasource.IsFederation())
{
#region TrueFederations
foreach (var store in (RDFFederation)datasource)
{
//Step FED.1: Evaluate the patterns of the current pattern group on the current store
RDFQueryEngine.EvaluatePatterns(this, patternGroup, store);
//Step FED.2: Federate the patterns of the current pattern group on the current store
if (!fedPatternResultTables.ContainsKey(patternGroup))
{
fedPatternResultTables.Add(patternGroup, this.PatternResultTables[patternGroup]);
}
else
{
fedPatternResultTables[patternGroup].ForEach(fprt =>
fprt.Merge(this.PatternResultTables[patternGroup].Single(prt => prt.TableName.Equals(fprt.TableName, StringComparison.Ordinal)), true, MissingSchemaAction.Add));
}
}
this.PatternResultTables[patternGroup] = fedPatternResultTables[patternGroup];
#endregion
}
else
{
RDFQueryEngine.EvaluatePatterns(this, patternGroup, datasource);
}
//Step 2: Get the result table of the current pattern group
RDFQueryEngine.CombinePatterns(this, patternGroup);
//Step 3: Apply the filters of the current pattern group to its result table
RDFQueryEngine.ApplyFilters(this, patternGroup);
}
//Step 4: Get the result table of the query
var queryResultTable = RDFQueryEngine.CombineTables(this.PatternGroupResultTables.Values.ToList(), false);
//Step 5: Transform the result into a boolean response
askResult.AskResult = (queryResultTable.Rows.Count > 0);
}
return(askResult);
}
/// <summary>
/// Applies the query to the given federation
/// </summary>
public RDFAskQueryResult ApplyToFederation(RDFFederation federation)
{
if (federation != null)
{
this.PatternGroupResultTables.Clear();
this.PatternResultTables.Clear();
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (!this.IsEmpty)
{
//Iterate the pattern groups of the query
var fedPatternResultTables = new Dictionary <RDFPatternGroup, List <DataTable> >();
foreach (RDFPatternGroup patternGroup in this.PatternGroups)
{
#region TrueFederations
foreach (RDFStore store in federation.Stores.Values)
{
//Step 1: Evaluate the patterns of the current pattern group on the current store
RDFAskQueryEngine.EvaluatePatterns(this, patternGroup, store);
//Step 2: Federate the patterns of the current pattern group on the current store
if (!fedPatternResultTables.ContainsKey(patternGroup))
{
fedPatternResultTables.Add(patternGroup, this.PatternResultTables[patternGroup]);
}
else
{
fedPatternResultTables[patternGroup].ForEach(fprt =>
fprt.Merge(this.PatternResultTables[patternGroup].Single(prt => prt.TableName.Equals(fprt.TableName, StringComparison.Ordinal)), true, MissingSchemaAction.Add));
}
}
this.PatternResultTables[patternGroup] = fedPatternResultTables[patternGroup];
#endregion
//Step 3: Get the result table of the current pattern group
RDFAskQueryEngine.CombinePatterns(this, patternGroup);
//Step 4: Apply the filters of the current pattern group to its result table
RDFAskQueryEngine.ApplyFilters(this, patternGroup);
}
//Step 5: Get the result table of the query
DataTable queryResultTable = RDFQueryEngine.CombineTables(this.PatternGroupResultTables.Values.ToList <DataTable>(), false);
//Step 6: Transform the result into a boolean response
askResult.AskResult = (queryResultTable.Rows.Count > 0);
}
return(askResult);
}
throw new RDFQueryException("Cannot execute ASK query because given \"federation\" parameter is null.");
}
/// <summary>
/// Applies the query to the given federation
/// </summary>
public RDFAskQueryResult ApplyToFederation(RDFFederation federation)
{
if (federation != null) {
this.PatternGroupResultTables.Clear();
this.PatternResultTables.Clear();
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (this.PatternGroups.Any()) {
//Iterate the pattern groups of the query
var fedPatternResultTables = new Dictionary<RDFPatternGroup, List<DataTable>>();
foreach (RDFPatternGroup patternGroup in this.PatternGroups) {
#region TrueFederations
foreach (RDFStore store in federation) {
//Step 1: Evaluate the patterns of the current pattern group on the current store
RDFQueryEngine.EvaluatePatterns(this, patternGroup, store);
//Step 2: Federate the patterns of the current pattern group on the current store
if (!fedPatternResultTables.ContainsKey(patternGroup)) {
fedPatternResultTables.Add(patternGroup, this.PatternResultTables[patternGroup]);
}
else {
fedPatternResultTables[patternGroup].ForEach(fprt =>
fprt.Merge(this.PatternResultTables[patternGroup].Single(prt => prt.TableName.Equals(fprt.TableName, StringComparison.Ordinal)), true, MissingSchemaAction.Add));
}
}
this.PatternResultTables[patternGroup] = fedPatternResultTables[patternGroup];
#endregion
//Step 3: Get the result table of the current pattern group
RDFQueryEngine.CombinePatterns(this, patternGroup);
//Step 4: Apply the filters of the current pattern group to its result table
RDFQueryEngine.ApplyFilters(this, patternGroup);
}
//Step 5: Get the result table of the query
DataTable queryResultTable = RDFQueryEngine.CombineTables(this.PatternGroupResultTables.Values.ToList(), false);
//Step 6: Transform the result into a boolean response
askResult.AskResult = (queryResultTable.Rows.Count > 0);
}
return askResult;
}
throw new RDFQueryException("Cannot execute ASK query because given \"federation\" parameter is null.");
}
/// <summary>
/// Reads the given "SPARQL Query Results XML Format" stream into an ASK query result
/// </summary>
public static RDFAskQueryResult FromSparqlXmlResult(Stream inputStream)
{
try {
#region deserialize
RDFAskQueryResult result = new RDFAskQueryResult();
using (StreamReader streamReader = new StreamReader(inputStream, Encoding.UTF8)) {
using (XmlTextReader xmlReader = new XmlTextReader(streamReader)) {
xmlReader.DtdProcessing = DtdProcessing.Parse;
xmlReader.Normalization = false;
#region load
XmlDocument srxDoc = new XmlDocument();
srxDoc.Load(xmlReader);
#endregion
#region parse
Boolean foundHead = false;
Boolean foundBoolean = false;
var nodesEnum = srxDoc.DocumentElement.ChildNodes.GetEnumerator();
while (nodesEnum != null && nodesEnum.MoveNext())
{
XmlNode node = (XmlNode)nodesEnum.Current;
#region HEAD
if (node.Name.ToUpperInvariant().Equals("HEAD", StringComparison.Ordinal))
{
foundHead = true;
}
#endregion
#region BOOLEAN
else if (node.Name.ToUpperInvariant().Equals("BOOLEAN", StringComparison.Ordinal))
{
foundBoolean = true;
if (foundHead)
{
Boolean bRes = false;
if (Boolean.TryParse(node.InnerText, out bRes))
{
result.AskResult = bRes;
}
else
{
throw new Exception("\"boolean\" node contained data not corresponding to a valid Boolean.");
}
}
else
{
throw new Exception("\"head\" node was not found, or was after \"boolean\" node.");
}
}
#endregion
}
if (!foundHead)
{
throw new Exception("mandatory \"head\" node was not found");
}
if (!foundBoolean)
{
throw new Exception("mandatory \"boolean\" node was not found");
}
#endregion
}
}
return(result);
#endregion
}
catch (Exception ex) {
throw new RDFQueryException("Cannot read given \"SPARQL Query Results XML Format\" source because: " + ex.Message, ex);
}
}
/// <summary>
/// Reads the given "SPARQL Query Results XML Format" stream into an ASK query result
/// </summary>
public static RDFAskQueryResult FromSparqlXmlResult(Stream inputStream)
{
try {
#region deserialize
RDFAskQueryResult result = new RDFAskQueryResult();
using(StreamReader streamReader = new StreamReader(inputStream, Encoding.UTF8)) {
using(XmlTextReader xmlReader = new XmlTextReader(streamReader)) {
xmlReader.DtdProcessing = DtdProcessing.Ignore;
xmlReader.Normalization = false;
#region load
XmlDocument srxDoc = new XmlDocument();
srxDoc.Load(xmlReader);
#endregion
#region parse
Boolean foundHead = false;
Boolean foundBoolean = false;
var nodesEnum = srxDoc.DocumentElement.ChildNodes.GetEnumerator();
while (nodesEnum != null && nodesEnum.MoveNext()) {
XmlNode node = (XmlNode)nodesEnum.Current;
#region HEAD
if (node.Name.ToUpperInvariant().Equals("HEAD", StringComparison.Ordinal)) {
foundHead = true;
}
#endregion
#region BOOLEAN
else if (node.Name.ToUpperInvariant().Equals("BOOLEAN", StringComparison.Ordinal)) {
foundBoolean = true;
if (foundHead) {
Boolean bRes = false;
if (Boolean.TryParse(node.InnerText, out bRes)) {
result.AskResult = bRes;
}
else {
throw new Exception("\"boolean\" node contained data not corresponding to a valid Boolean.");
}
}
else {
throw new Exception("\"head\" node was not found, or was after \"boolean\" node.");
}
}
#endregion
}
if (!foundHead) {
throw new Exception("mandatory \"head\" node was not found");
}
if (!foundBoolean) {
throw new Exception("mandatory \"boolean\" node was not found");
}
#endregion
}
}
return result;
#endregion
}
catch(Exception ex) {
throw new RDFQueryException("Cannot read given \"SPARQL Query Results XML Format\" source because: " + ex.Message, ex);
}
}
/// <summary>
/// Applies the query to the given store
/// </summary>
public RDFAskQueryResult ApplyToStore(RDFStore store) {
if (store != null) {
this.PatternGroupResultTables.Clear();
this.PatternResultTables.Clear();
RDFAskQueryResult askResult = new RDFAskQueryResult();
if (!this.IsEmpty) {
//Iterate the pattern groups of the query
foreach (RDFPatternGroup patternGroup in this.PatternGroups) {
//Step 1: Get the intermediate result tables of the current pattern group
RDFAskQueryEngine.EvaluatePatterns(this, patternGroup, store);
//Step 2: Get the result table of the current pattern group
RDFAskQueryEngine.CombinePatterns(this, patternGroup);
//Step 3: Apply the filters of the current pattern group to its result table
RDFAskQueryEngine.ApplyFilters(this, patternGroup);
}
//Step 4: Get the result table of the query
DataTable queryResultTable = RDFQueryEngine.CombineTables(this.PatternGroupResultTables.Values.ToList<DataTable>(), false);
//Step 5: Transform the result into a boolean response
askResult.AskResult = (queryResultTable.Rows.Count > 0);
}
return askResult;
}
throw new RDFQueryException("Cannot execute ASK query because given \"store\" parameter is null.");
}