public override void Select(StatementSink storage)
{
foreach (string infile in files)
{
if (!quiet)
{
Console.Error.Write(infile + " ");
}
try {
DateTime start = DateTime.Now;
StatementFilterSink filter = new StatementFilterSink(storage);
if (format == null || format != "spec")
{
string fmt = format;
if (fmt == null)
{
// Use file extension to override default parser type.
if (infile.StartsWith("http:"))
{
fmt = "url";
}
else if (infile.EndsWith(".nt") || infile.EndsWith(".n3") || infile.EndsWith(".ttl"))
{
fmt = "n3";
}
else if (infile.EndsWith(".xml") || infile.EndsWith(".rdf"))
{
fmt = "xml";
}
else
{
Console.Error.WriteLine("Unrecognized file extension in " + infile + ": Trying RDF/XML.");
fmt = "xml";
}
}
using (RdfReader parser = RdfReader.Create(fmt, infile)) {
if (baseuri != null)
{
parser.BaseUri = baseuri;
}
if (meta != null)
{
parser.Meta = meta;
}
if (storage is RdfWriter)
{
((RdfWriter)storage).Namespaces.AddFrom(parser.Namespaces);
}
try {
parser.Select(filter);
} finally {
if (parser.Warnings.Count > 0)
{
Console.Error.WriteLine("\nThere were warnings parsing this file:");
}
foreach (string warning in parser.Warnings)
{
Console.Error.WriteLine("> " + warning);
}
}
}
}
else
{
StatementSource src = Store.Create(infile);
src.Select(filter);
if (src is IDisposable)
{
((IDisposable)src).Dispose();
}
}
totalStatementsRead += filter.StatementCount;
TimeSpan time = DateTime.Now - start;
if (!quiet)
{
Console.Error.WriteLine(" {0}m{1}s, {2} statements, {3} st/sec", (int)time.TotalMinutes, (int)time.Seconds, filter.StatementCount, time.TotalSeconds == 0 ? "?" : ((int)(filter.StatementCount / time.TotalSeconds)).ToString());
}
} catch (ParserException e) {
Console.Error.WriteLine(" " + e.Message);
} catch (Exception e) {
Console.Error.WriteLine("\n" + e + "\n");
}
}
}
private static void ProcessResponse(string mimetype, Stream stream, object outputObj)
{
// If the user wants the output sent to a TextWriter, copy the response from
// the response stream to the TextWriter. TODO: Get encoding from HTTP header.
if (outputObj is TextWriter)
{
TextWriter tw = (TextWriter)outputObj;
using (StreamReader reader = new StreamReader(stream, System.Text.Encoding.UTF8)) {
char[] buffer = new char[512];
while (true)
{
int len = reader.Read(buffer, 0, buffer.Length);
if (len <= 0)
{
break;
}
tw.Write(buffer, 0, len);
if (Debug)
{
Console.Error.WriteLine(">> " + new String(buffer, 0, len));
}
}
}
tw.Flush();
return;
}
// If the user wants a boolean out of this, then we're expecting a
// SPARQL XML Results document with a boolean response element.
if (outputObj is BooleanWrap)
{
BooleanWrap bw = (BooleanWrap)outputObj;
if (mimetype != null && mimetype != "application/sparql-results+xml" && mimetype != "text/xml" && mimetype != "application/xml")
{
throw new ApplicationException("The result of the query was not a SPARQL Results document.");
}
XmlReader xmldoc = new XmlTextReader(stream);
{
// Move to the document element
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
// Just check that it has the right local name.
if (xmldoc.LocalName != "sparql" || xmldoc.IsEmptyElement)
{
throw new ApplicationException("Invalid server response: Not a SPARQL results document.");
}
// Move to the next node.
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
// If it's a head node, skip it.
if (xmldoc.LocalName == "head")
{
xmldoc.Skip();
// Move to the 'boolean' element, it better be next
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
}
if (xmldoc.LocalName != "boolean")
{
throw new ApplicationException("Invalid server response: Missing 'boolean' element.");
}
string value = xmldoc.ReadElementString();
bw.value = (value == "true");
}
if (Debug)
{
Console.Error.WriteLine(">> " + bw.value);
}
return;
}
// If the user wants statements out of the response, read it with an RDFReader.
if (outputObj is StatementSink)
{
// If the mime type is application/sparql-results+xml, just try to
// read it as if it were an RDF/XML MIME type.
if (mimetype != null && mimetype == "application/sparql-results+xml")
{
mimetype = "text/xml";
}
using (RdfReader reader = RdfReader.Create(mimetype, stream))
reader.Select((StatementSink)outputObj);
if (Debug)
{
Console.Error.WriteLine(">> (read as statements)");
}
return;
}
// If the user wants query result bindings, read the response XML.
if (outputObj is QueryResultSink)
{
QueryResultSink sink = (QueryResultSink)outputObj;
if (mimetype != null && mimetype != "application/sparql-results+xml" && mimetype != "text/xml")
{
throw new ApplicationException("The result of the query was not a SPARQL Results document.");
}
ArrayList variableNames = new ArrayList();
ArrayList variables = new ArrayList();
Variable[] variablesArray = null;
Hashtable bnodes = new Hashtable();
XmlReader xmldoc = new XmlTextReader(stream);
{
// Move to the document element
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
// Just check that it has the right local name.
if (xmldoc.LocalName != "sparql" || xmldoc.IsEmptyElement)
{
throw new ApplicationException("Invalid server response: Not a SPARQL results document.");
}
// Move to the 'head' node, it better be the first element
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
if (xmldoc.LocalName != "head" || xmldoc.IsEmptyElement)
{
throw new ApplicationException("Invalid server response: Missing head full element.");
}
// Read the head element
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "variable")
{
if (xmldoc.GetAttribute("name") == null)
{
throw new ApplicationException("Invalid server response: Head/variable node missing name attribute.");
}
variableNames.Add(xmldoc.GetAttribute("name"));
variables.Add(new Variable(xmldoc.GetAttribute("name")));
if (!xmldoc.IsEmptyElement)
{
xmldoc.Skip();
}
}
else if (xmldoc.NodeType == XmlNodeType.EndElement)
{
break;
}
}
// Move to the 'results' element, it better be next
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element)
{
break;
}
}
if (xmldoc.LocalName != "results")
{
throw new ApplicationException("Invalid server response: Missing results element.");
}
variablesArray = (Variable[])variables.ToArray(typeof(Variable));
sink.Init(variablesArray);
// Read the results
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "result")
{
// Read the bindings in this result
Resource[] valuesArray = new Resource[variablesArray.Length];
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "binding")
{
if (xmldoc.IsEmptyElement)
{
throw new ApplicationException("Invalid server response: Binding element empty.");
}
if (xmldoc.GetAttribute("name") == null)
{
throw new ApplicationException("Invalid server response: Result binding node missing name attribute.");
}
int vIndex = variableNames.IndexOf(xmldoc.GetAttribute("name"));
if (vIndex == -1)
{
throw new ApplicationException("Invalid server response: Result binding name does not match a variable in the head.");
}
Resource value = null;
while (xmldoc.Read())
{
if (xmldoc.NodeType == XmlNodeType.Whitespace || xmldoc.NodeType == XmlNodeType.SignificantWhitespace)
{
continue;
}
if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "uri")
{
value = new Entity(xmldoc.ReadElementString());
if (!xmldoc.IsEmptyElement)
{
xmldoc.Skip();
}
}
else if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "literal")
{
string lang = xmldoc.XmlLang;
if (lang == "")
{
lang = null;
}
string dt = xmldoc.GetAttribute("datatype");
value = new Literal(xmldoc.ReadElementString(), lang, dt);
if (!xmldoc.IsEmptyElement)
{
xmldoc.Skip();
}
}
else if (xmldoc.NodeType == XmlNodeType.Element && xmldoc.LocalName == "bnode")
{
string id = xmldoc.ReadElementString();
if (bnodes.ContainsKey(id))
{
value = (BNode)bnodes[id];
}
else
{
value = new BNode(id);
bnodes[id] = value;
}
if (!xmldoc.IsEmptyElement)
{
xmldoc.Skip();
}
}
else
{
throw new ApplicationException("Invalid server response: Invalid content in binding node.");
}
break;
}
if (value == null)
{
throw new ApplicationException("Invalid server response: Result binding value is invalid.");
}
valuesArray[vIndex] = value;
}
else if (xmldoc.NodeType == XmlNodeType.EndElement)
{
break;
}
}
sink.Add(new VariableBindings(variablesArray, valuesArray));
if (Debug)
{
Console.Error.WriteLine(">> " + new VariableBindings(variablesArray, valuesArray));
}
}
else if (xmldoc.NodeType == XmlNodeType.EndElement)
{
break;
}
}
sink.Finished();
}
}
}
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(Store testlist, Entity test, bool shouldSucceed, int mode)
{
string inputpath = null, outputpath = null,
inputformat = null, outputformat = null,
inputbase = null, outputbase = null;
if (mode == 0)
{
inputformat = "xml";
outputformat = "n3";
string uribase = "http://www.w3.org/2000/10/rdf-tests/rdfcore/";
Resource input = testlist.SelectObjects(test, "http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#inputDocument")[0];
inputbase = input.Uri;
inputpath = input.Uri.Substring(uribase.Length);
if (testlist.SelectObjects(test, "http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#outputDocument").Length > 0)
{
Resource output = testlist.SelectObjects(test, "http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#outputDocument")[0];
outputpath = output.Uri.Substring(uribase.Length);
outputbase = output.Uri;
}
}
else if (mode == 1)
{
inputformat = "n3";
outputformat = "n3";
inputbase = "file:/home/syosi/cvs-trunk/WWW/2000/10/swap/test/n3parser.tests";
string uribase = "http://www.example.org/";
if (testlist.SelectObjects(test, "http://www.w3.org/2004/11/n3test#inputDocument").Length == 0)
{
return;
}
Resource input = testlist.SelectObjects(test, "http://www.w3.org/2004/11/n3test#inputDocument")[0];
inputpath = input.Uri.Substring(uribase.Length);
if (testlist.SelectObjects(test, "http://www.w3.org/2004/11/n3test#outputDocument").Length > 0)
{
Resource output = testlist.SelectObjects(test, "http://www.w3.org/2004/11/n3test#outputDocument")[0];
outputpath = output.Uri.Substring(uribase.Length);
}
}
string desc = test.ToString();
try {
desc += " " + ((Literal)testlist.SelectObjects(test, "http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#description")[0]).Value;
} catch (Exception e) {
}
try {
total++;
RdfReader reader = RdfReader.Create(inputformat, Path.Combine(basepath, inputpath));
reader.BaseUri = inputbase;
MemoryStore inputmodel = new MemoryStore(reader);
if (reader.Warnings.Count > 0)
{
string warnings = String.Join("; ", (string[])((ArrayList)reader.Warnings).ToArray(typeof(string)));
throw new ParserException(warnings);
}
if (!shouldSucceed)
{
Console.WriteLine(desc + ": Should Not Have Passed **\n");
badpass++;
return;
}
if (shouldSucceed && outputpath != null)
{
RdfReader reader2 = RdfReader.Create(outputformat, Path.Combine(basepath, outputpath));
reader2.BaseUri = outputbase;
MemoryStore outputmodel = new MemoryStore(reader2);
CompareModels(inputmodel, outputmodel);
}
} catch (System.IO.FileNotFoundException ex) {
Console.WriteLine(inputpath + " Not Found");
error++;
} catch (System.IO.DirectoryNotFoundException ex) {
Console.WriteLine(inputpath + " Not Found");
error++;
} catch (ParserException ex) {
if (shouldSucceed)
{
Console.WriteLine(desc + ": " + ex.Message + " **");
Console.WriteLine();
badfail++;
}
}
}
