public object Search(queryrequest xml)
{
SemWeb.Query.Query query = null;
string q = string.Empty;
try
{
query = new SparqlEngine(new StringReader(xml.query));
}
catch (QueryFormatException ex)
{
var malformed = new malformedquery();
malformed.faultdetails = ex.Message;
return(malformed);
}
// Load the data from sql server
SemWeb.Stores.SQLStore store;
string connstr = ConfigurationManager.ConnectionStrings["SemWebDB"].ConnectionString;
DebugLogging.Log(connstr);
store = (SemWeb.Stores.SQLStore)SemWeb.Store.CreateForInput(connstr);
//Create a Sink for the results to be writen once the query is run.
MemoryStream ms = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(ms, System.Text.Encoding.UTF8);
QueryResultSink sink = new SparqlXmlQuerySink(writer);
try
{
// Run the query.
query.Run(store, sink);
}
catch (Exception ex)
{
// Run the query.
query.Run(store, sink);
DebugLogging.Log("Run the query a second time");
DebugLogging.Log(ex.Message);
}
//flush the writer then load the memory stream
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
//Write the memory stream out to the response.
ASCIIEncoding ascii = new ASCIIEncoding();
DebugLogging.Log(ascii.GetString(ms.ToArray()).Replace("???", ""));
writer.Close();
DebugLogging.Log("End of Processing");
return(SerializeXML.DeserializeObject(ascii.GetString(ms.ToArray()).Replace("???", ""), typeof(sparql)) as sparql);
}
public bool SPARQLConstruct(Store store, IEntity inputRoot, string inputInstanceQuery)
{
int incomingStatementCount = store.StatementCount;
SparqlEngine sparql = new SparqlEngine(inputInstanceQuery);
sparql.Construct(this, store);
return(store.StatementCount != incomingStatementCount);
}
protected virtual Query CreateQuery(string query)
{
Query sparql = new SparqlEngine(query);
if (MaximumLimit != -1 && (sparql.ReturnLimit == -1 || sparql.ReturnLimit > MaximumLimit))
{
sparql.ReturnLimit = MaximumLimit;
}
return(sparql);
}
public static void Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: euler.exe axioms.n3 axioms... {questions.n3 | -sparql query.sparql}");
return;
}
// Load Axioms
bool sparql = false;
MemoryStore axioms = new MemoryStore();
for (int i = 0; i < args.Length - 1; i++)
{
if (i > 0 && i == args.Length - 2 && args[i] == "-sparql")
{
sparql = true;
break;
}
N3Reader axiomsreader = new N3Reader(args[i]);
axiomsreader.BaseUri = "http://www.example.org/arbitrary/base#";
axioms.Import(axiomsreader);
}
Euler engine = new Euler(axioms);
// Load question
if (!sparql)
{
MemoryStore question = new MemoryStore();
question.Import(new N3Reader(args[args.Length - 1]));
Proof[] proofs = engine.Prove(null, question.ToArray());
foreach (Proof p in proofs)
{
Console.WriteLine(p.ToString());
}
}
else
{
using (StreamReader fs = new StreamReader(args[args.Length - 1])) {
string q = fs.ReadToEnd();
Store store = new Store();
store.AddReasoner(engine);
SparqlEngine s = new SparqlEngine(q);
s.Run(store, Console.Out);
}
}
}
public static void Main(string[] argv)
{
if (argv.Length < 3)
{
Console.WriteLine("Usage: query.exe format queryfile datafile");
return;
}
string format = argv[0];
string queryfile = argv[1];
string datafile = argv[2];
Query query;
if (format == "rsquary")
{
// Create a simple-entailment "RSquary" query
// from the N3 file.
query = new GraphMatch(new N3Reader(queryfile));
}
else
{
// Create a SPARQL query by reading the file's
// contents.
query = new SparqlEngine(new StreamReader(queryfile));
}
// Load the data file from disk
MemoryStore data = new MemoryStore();
data.Import(new N3Reader(datafile));
// First, print results in SPARQL XML Results format...
// Create a result sink where results are written to.
QueryResultSink sink = new SparqlXmlQuerySink(Console.Out);
// Run the query.
query.Run(data, sink);
// Second, print the results via our own custom QueryResultSink...
query.Run(data, new PrintQuerySink());
}
public static void Main(string[] args)
{
System.Net.ServicePointManager.Expect100Continue = false;
Opts opts = new Opts();
opts.ProcessArgs(args);
if (opts.RemainingArguments.Length != 1)
{
opts.DoHelp();
return;
}
string baseuri = "query://query/#";
QueryResultSink qs;
if (opts.format == "simple")
{
qs = new PrintQuerySink();
}
else if (opts.format == "html")
{
qs = new HTMLQuerySink(Console.Out);
}
else if (opts.format == "xml")
{
qs = new SparqlXmlQuerySink(Console.Out);
}
else if (opts.format == "lubm")
{
qs = new LUBMReferenceAnswerOutputQuerySink();
}
else if (opts.format == "csv")
{
qs = new CSVQuerySink();
}
else
{
Console.Error.WriteLine("Invalid output format.");
return;
}
Query query;
MemoryStore queryModel = null;
#if !DOTNET2
System.Collections.ICollection queryModelVars = null;
#else
System.Collections.Generic.ICollection <Variable> queryModelVars = null;
#endif
Store model = Store.Create(opts.RemainingArguments[0]);
if (opts.type == "rsquary")
{
RdfReader queryparser = RdfReader.Create("n3", "-");
queryparser.BaseUri = baseuri;
queryModel = new MemoryStore(queryparser);
queryModelVars = queryparser.Variables;
query = new GraphMatch(queryModel);
}
else if (opts.type == "sparql" && model.DataSources.Count == 1 && model.DataSources[0] is SemWeb.Remote.SparqlSource)
{
string querystring = Console.In.ReadToEnd();
((SemWeb.Remote.SparqlSource)model.DataSources[0]).RunSparqlQuery(querystring, Console.Out);
return;
}
else if (opts.type == "sparql")
{
string querystring = Console.In.ReadToEnd();
query = new SparqlEngine(querystring);
}
else
{
throw new Exception("Invalid query format: " + opts.type);
}
if (opts.limit > 0)
{
query.ReturnLimit = opts.limit;
}
//Console.Error.WriteLine(query.GetExplanation());
if (query is SparqlEngine && ((SparqlEngine)query).Type != SparqlEngine.QueryType.Select)
{
SparqlEngine sparql = (SparqlEngine)query;
sparql.Run(model, Console.Out);
}
else if (model is QueryableSource && queryModel != null)
{
SemWeb.Query.QueryOptions qopts = new SemWeb.Query.QueryOptions();
qopts.DistinguishedVariables = queryModelVars;
// Replace bnodes in the query with Variables
int bnodectr = 0;
foreach (Entity e in queryModel.GetEntities())
{
if (e is BNode && !(e is Variable))
{
BNode b = (BNode)e;
queryModel.Replace(e, new Variable(b.LocalName != null ? b.LocalName : "bnodevar" + (++bnodectr)));
}
}
model.Query(queryModel.ToArray(), qopts, qs);
}
else
{
query.Run(model, qs);
}
if (qs is IDisposable)
{
((IDisposable)qs).Dispose();
}
}
static void RunTest(Entity test, Store manifest)
{
Entity rdf_type = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
Entity mf_PositiveSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#PositiveSyntaxTest";
Entity mf_NegativeSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#NegativeSyntaxTest";
Entity mf_QueryTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#QueryEvaluationTest";
Entity mf_action = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#action";
Entity mf_result = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#result";
Entity qt_data = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#data";
Entity qt_query = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#query";
Entity test_type = (Entity)manifest.SelectObjects(test, rdf_type)[0];
Entity action = (Entity)manifest.SelectObjects(test, mf_action)[0];
if (test_type == mf_PositiveSyntaxTest || test_type == mf_NegativeSyntaxTest)
{
// The action is a query.
// Load the action as a string.
string q = ReadFile(action.Uri);
// Run the action.
try {
new SparqlEngine(q);
} catch (SemWeb.Query.QueryFormatException qfe) {
// On a negative test: Good!
if (test_type == mf_NegativeSyntaxTest)
{
pass++;
return;
}
Console.WriteLine("Test Failed: " + action);
Console.WriteLine(qfe.Message);
Console.WriteLine(q);
Console.WriteLine();
fail++;
return;
}
// On a positive test: Good!
if (test_type == mf_PositiveSyntaxTest)
{
pass++;
return;
}
Console.WriteLine("Test Failed: " + action);
Console.WriteLine("Query is syntactically incorrect.");
Console.WriteLine(q);
Console.WriteLine();
fail++;
}
else if (test_type == mf_QueryTest)
{
Entity data = (Entity)manifest.SelectObjects(action, qt_data)[0];
Entity query = (Entity)manifest.SelectObjects(action, qt_query)[0];
Entity result = (Entity)manifest.SelectObjects(test, mf_result)[0];
MemoryStore data_store = new MemoryStore(new N3Reader(data.Uri));
string q = ReadFile(query.Uri);
if (q.IndexOf("ASK") >= 0)
{
Console.WriteLine("ASK Test Skipped: " + test);
skip++;
return;
}
string run_individual_test = "mono ../../bin/rdfquery.exe -type sparql n3:" + data.Uri + " < " + query.Uri;
SparqlEngine sp;
try {
sp = new SparqlEngine(q);
} catch (SemWeb.Query.QueryFormatException qfe) {
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(qfe.Message);
Console.WriteLine();
fail++;
return;
}
QueryResultBuffer results = new QueryResultBuffer();
bool results_bool = false;
try {
if (sp.Type != SparqlEngine.QueryType.Ask)
{
sp.Run(data_store, results);
}
else
{
results_bool = sp.Ask(data_store);
}
} catch (Exception e) {
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(e);
Console.WriteLine();
fail++;
return;
}
bool failed = false;
StringBuilder info = new StringBuilder();
if (result.Uri.EndsWith(".ttl") || result.Uri.EndsWith(".srx") || result.Uri.EndsWith(".rdf"))
{
bool sorted = false;
QueryResultBuffer results2 = new QueryResultBuffer();
if (result.Uri.EndsWith(".srx"))
{
using (FileStream fs = new FileStream(result.Uri, FileMode.Open))
SemWeb.Remote.SparqlHttpSource.ParseSparqlResponse(fs, results2);
}
else if (result.Uri.EndsWith(".rdf") || result.Uri.EndsWith(".ttl"))
{
RdfReader reader = null;
if (result.Uri.EndsWith(".rdf"))
{
reader = new RdfXmlReader(result.Uri);
}
else if (result.Uri.EndsWith(".ttl"))
{
reader = new N3Reader(result.Uri);
}
MemoryStore result_store = new MemoryStore(reader);
string rs = "http://www.w3.org/2001/sw/DataAccess/tests/result-set#";
Entity rsResultSet = rs + "ResultSet";
Entity rsresultVariable = rs + "resultVariable";
Entity rssolution = rs + "solution";
Entity rsindex = rs + "index";
Entity rsbinding = rs + "binding";
Entity rsvariable = rs + "variable";
Entity rsvalue = rs + "value";
// get a list of variables in the query output
Entity resultset = result_store.GetEntitiesOfType(rsResultSet)[0];
ArrayList vars = new ArrayList();
foreach (Literal var in result_store.SelectObjects(resultset, rsresultVariable))
{
vars.Add(new Variable(var.Value));
}
Variable[] varsarray = (Variable[])vars.ToArray(typeof(Variable));
// try to order as best we can to our own output, so we sort the results the same way
for (int i = 0; i < results.Variables.Length; i++)
{
if (i >= varsarray.Length)
{
break;
}
for (int j = i; j < varsarray.Length; j++)
{
if (varsarray[j].LocalName == results.Variables[i].LocalName)
{
Variable temp = varsarray[i];
varsarray[i] = varsarray[j];
varsarray[j] = temp;
break;
}
}
}
Hashtable varmap = new Hashtable();
foreach (Variable v in varsarray)
{
varmap[v.LocalName] = varmap.Count;
}
results2.Init(varsarray);
Resource[] resultbindings = result_store.SelectObjects(resultset, rssolution);
// Try sorting by index
int[] indexes = new int[resultbindings.Length];
for (int i = 0; i < resultbindings.Length; i++)
{
Entity binding = (Entity)resultbindings[i];
Literal index = (Literal)result_store.SelectObjects(binding, rsindex)[0];
indexes[i] = (int)(Decimal)index.ParseValue();
sorted = true;
}
Array.Sort(indexes, resultbindings);
// Add bindings into results2.
for (int i = 0; i < resultbindings.Length; i++)
{
Resource[] row = new Resource[vars.Count];
Entity binding = (Entity)resultbindings[i];
foreach (Entity var in result_store.SelectObjects(binding, rsbinding))
{
string name = ((Literal)result_store.SelectObjects(var, rsvariable)[0]).Value;
Resource val = result_store.SelectObjects(var, rsvalue)[0];
row[(int)varmap[name]] = val;
}
results2.Add(new VariableBindings(varsarray, row));
}
}
// Check variable list
ArrayList vars1 = new ArrayList();
foreach (Variable v in results.Variables)
{
vars1.Add(v.LocalName);
}
ArrayList vars2 = new ArrayList();
foreach (Variable v in results2.Variables)
{
vars2.Add(v.LocalName);
}
failed |= !SetsSame(vars1, vars2, "Result Set Variables", info);
// Checking bindings
if (results.Bindings.Count != results2.Bindings.Count)
{
info.Append("Solutions have different number of bindings.\n");
failed = true;
}
else
{
// Now actually run comparison.
if (!sorted)
{
((ArrayList)results.Bindings).Sort();
((ArrayList)results2.Bindings).Sort();
}
for (int i = 0; i < results.Bindings.Count; i++)
{
VariableBindings b1 = (VariableBindings)results.Bindings[i];
VariableBindings b2 = (VariableBindings)results2.Bindings[i];
foreach (Variable var in results.Variables)
{
Resource val1 = b1[var.LocalName];
Resource val2 = b2[var.LocalName];
if (val1 != val2 && !(val1 is BNode) && !(val2 is BNode)) // TODO: Test bnodes are returned correctly
{
info.Append("Binding row " + i + " differ in value of " + var.LocalName + " variable: " + val2 + ", should be: " + val1 + "\n");
failed = true;
}
}
}
}
}
else
{
skip++;
Console.WriteLine(test + ": Unknown result type " + result.Uri);
}
if (failed)
{
Console.WriteLine("Test Failed: " + test);
Console.WriteLine(run_individual_test);
Console.WriteLine(q);
Console.WriteLine(info.ToString());
Console.WriteLine();
fail++;
}
else
{
pass++;
}
}
else
{
skip++;
Console.WriteLine(test + ": Unknown test type " + test_type);
Console.WriteLine();
}
}
