internal static XQueryInvoker WithQuery(string query, IXQueryProcessor processor, Assembly callingAssembly, out int hashCode)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
if (processor == null)
{
processor = Processors.XQuery.DefaultProcessor;
}
hashCode = query.GetHashCode();
ConcurrentDictionary <int, XQueryExecutable> cache =
inlineCache.GetOrAdd(processor, p => new ConcurrentDictionary <int, XQueryExecutable>());
XQueryExecutable exec = cache.GetOrAdd(hashCode, i => {
var resolver = new XmlDynamicResolver(callingAssembly);
return(processor.Compile(new StringReader(query), new XQueryCompileOptions {
XmlResolver = resolver
}));
});
return(new XQueryInvoker(exec, callingAssembly));
}
static XQueryInvoker With(Uri queryUri, IXQueryProcessor processor, Assembly callingAssembly)
{
if (queryUri == null)
{
throw new ArgumentNullException("queryUri");
}
var resolver = new XmlDynamicResolver(callingAssembly);
if (!queryUri.IsAbsoluteUri)
{
queryUri = resolver.ResolveUri(null, queryUri.OriginalString);
}
if (processor == null)
{
processor = Processors.XQuery.DefaultProcessor;
}
ConcurrentDictionary <Uri, XQueryExecutable> cache =
uriCache.GetOrAdd(processor, p => new ConcurrentDictionary <Uri, XQueryExecutable>());
XQueryExecutable executable = cache.GetOrAdd(queryUri, u => {
using (var stylesheetSource = (Stream)resolver.GetEntity(queryUri, null, typeof(Stream))) {
return(processor.Compile(stylesheetSource, new XQueryCompileOptions {
BaseUri = queryUri,
XmlResolver = resolver
}));
}
});
return(new XQueryInvoker(executable, callingAssembly));
}
/**
* Show a query reading an input document using an XmlReader (the .NET XML parser)
*/
public static void ExampleFromXmlReader(String inputFileName)
{
Processor processor = new Processor();
XmlTextReader reader = new XmlTextReader(inputFileName,
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
reader.Normalization = true;
// add a validating reader - not to perform validation, but to expand entity references
XmlValidatingReader validator = new XmlValidatingReader(reader);
validator.ValidationType = ValidationType.None;
XdmNode doc = processor.NewDocumentBuilder().Build(validator);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("/");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = doc;
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputStream(new FileStream("testoutput2.xml", FileMode.Create, FileAccess.Write));
eval.Run(qout);
}
private void writeModuleReportXQuery(string paperName, string className, StreamWriter sw)
{
Processor pr = new Processor();
XQueryCompiler xqc = pr.NewXQueryCompiler();
string errPath = "Papers\\" + paperName + "\\" + className + "_err.xml";
XmlDocument errdoc = new XmlDocument();
errdoc.Load(errPath);
XmlElement root = errdoc.DocumentElement;
XmlNodeList ruleNodes = root.GetElementsByTagName("err-rule");
foreach (XmlNode xrule in ruleNodes)
{
string rule = xrule.InnerText;
//Console.WriteLine(rule);
XQueryExecutable xqe = xqc.Compile(rule);
XQueryEvaluator xqev = xqe.Load();
XdmValue result = xqev.Evaluate(); //对比结果
foreach (XdmItem rs in result)
{
sw.WriteLine(count + ". " + rs.ToString().Trim());
count++;
}
}
}
/**
* Show a query producing a sequence as its result and returning the sequence
* to the Java application in the form of an iterator. The sequence is then
* output by serializing each item individually, with each item on a new line.
*/
public static void ExampleToSerializedSequence(String inputFileName)
{
Processor processor = new Processor();
XmlTextReader reader = new XmlTextReader(inputFileName,
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
reader.Normalization = true;
// add a validating reader - not to perform validation, but to expand entity references
XmlValidatingReader validator = new XmlValidatingReader(reader);
validator.ValidationType = ValidationType.None;
XdmNode doc = processor.NewDocumentBuilder().Build(reader);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("//ISBN");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = doc;
foreach (XdmNode node in eval)
{
Console.WriteLine(node.OuterXml);
}
}
// https://www.nuget.org/packages/Saxon-HE/
public string XQuery(string xml, string query)
{
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.LoadXml(xml);
XdmNode indoc = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
DomDestination qout = new DomDestination();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
eval.Run(qout);
XmlDocument outdoc = qout.XmlDocument;
using (var stringWriter = new StringWriter())
using (var xmlTextWriter = XmlWriter.Create(stringWriter))
{
outdoc.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
return(stringWriter.GetStringBuilder().ToString());
}
}
public void GenXML()
{
String sourceUri = Server.MapPath("5648.xml");
String xqUri = Server.MapPath("graph.xq");
using (FileStream sXml = File.OpenRead(sourceUri))
{
using (FileStream sXq = File.OpenRead(xqUri))
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = sourceUri;
XQueryExecutable exp = compiler.Compile(sXq);
XQueryEvaluator eval = exp.Load();
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(sourceUri);
XdmNode indoc = loader.Build(new FileStream(sourceUri, FileMode.Open, FileAccess.Read));
eval.ContextItem = indoc;
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
qout.SetOutputWriter(Response.Output);
eval.Run(qout);
}
}
}
/**
* Show a query producing a single atomic value as its result and returning the value
* to the Java application
*/
public static void ExampleToSingleton()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("avg(for $i in 1 to 10 return $i * $i)");
XQueryEvaluator eval = exp.Load();
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (decimal)result.Value);
}
/**
* Show how to run two queries in tandem. The second query is applied to the
* results of the first.
*/
public static void ExampleExtra()
{
// place-holder to add user-defined examples for testing
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(@"<out>{matches('ABC', '\p{IsBasicLatin}*')}</out>");
XQueryEvaluator eval = exp.Load();
DomDestination dest = new DomDestination();
eval.Run(dest);
Console.WriteLine(dest.XmlDocument.OuterXml);
}
private XQueryExecutable CreateXQueryExecutable(string currentNamespaceURI = "", Processor processor = null)
{
XQueryExecutable xQueryExecutable = null;
if (processor != null && !string.IsNullOrEmpty(XQuery))
{
XQueryCompiler xQueryCompiler = processor.NewXQueryCompiler();
xQueryCompiler.DeclareNamespace(_evaluator.RuleNamespace, currentNamespaceURI);
xQueryExecutable = xQueryCompiler.Compile(XQuery);
}
return(xQueryExecutable);
}
/// <summary>
/// Perform XQuery <paramref name="query"/> on XML document at <paramref name="input"/> using Saxon API.
/// </summary>
/// <param name="input">A valid XML document.</param>
/// <param name="query">An XQuery query.</param>
/// <returns>Returns the results of the <paramref name="query"/> as an XmlDocument.</returns>
public static XmlDocument PerformQuery(XmlDocument input, string query)
{
var processor = new Processor();
XdmNode inputXml = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable executable = compiler.Compile(query);
XQueryEvaluator evaluator = executable.Load();
evaluator.ContextItem = inputXml;
var domOut = new DomDestination();
evaluator.Run(domOut);
return(domOut.XmlDocument);
}
/**
* Show a query producing a sequence as its result and returning the sequence
* to the Java application in the form of an iterator. For each item in the
* result, its string value is output.
*/
public static void ExampleToSequence()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("for $i in 1 to 10 return $i * $i");
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
XdmItem item = (XdmItem)e.Current;
Console.WriteLine(item.ToString());
}
}
public void ExecuteQuery(string query, string destination, string dimension, string granularity)
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
if (dimension.Equals("Geo", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Country");
int id1 = GetMetaID("Region");
int id2 = GetMetaID("City");
int id3 = GetMetaID("Street");
eval.SetExternalVariable(new QName("Country"), new XdmAtomicValue(id));
eval.SetExternalVariable(new QName("Region"), new XdmAtomicValue(id1));
eval.SetExternalVariable(new QName("City"), new XdmAtomicValue(id2));
eval.SetExternalVariable(new QName("Street"), new XdmAtomicValue(id3));
//expr.bindInt(new QName("Country"), id, null);
//expr.bindInt(new QName("Region"), id1, null);
//expr.bindInt(new QName("City"), id2, null);
//expr.bindInt(new QName("Street"), id3, null);
}
else if (dimension.Equals("Time", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Date/Time Original");
eval.SetExternalVariable(new QName("id"), new XdmAtomicValue(id));
}
else if (dimension.Equals("Social", StringComparison.InvariantCultureIgnoreCase))
{
int id = GetMetaID("Artist");
eval.SetExternalVariable(new QName("id"), new XdmAtomicValue(id));
}
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
FileStream outStream = new FileStream(BaseUri + destination, FileMode.Create, FileAccess.Write);
qout.SetOutputStream(outStream);
Console.WriteLine("Output written to " + destination);
eval.Run(qout);
outStream.Dispose();
outStream.Close();
qout.Close();
}
/**
* Show a query that takes a parameter (external variable) as input.
* The query produces a single atomic value as its result and returns the value
* to the Java application. For the types of value that may be returned, and
* their mapping to XPath data types, see {@link XPathEvaluator#Evaluate}
*/
public static void ExampleWithParam()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.DeclareNamespace("p", "http://saxon.sf.net/ns/p");
XQueryExecutable exp = compiler.Compile(
"declare variable $p:in as xs:integer external; $p:in * $p:in");
XQueryEvaluator eval = exp.Load();
eval.SetExternalVariable(new QName("http://saxon.sf.net/ns/p", "p:in"), new XdmAtomicValue(12));
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (long)result.Value);
}
public List <MetadataAttributes> GetGeo(string granularity, bool distinct = true)
{
string query = "";
if (granularity.Equals("Country", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Country");
}
else if (granularity.Equals("Region", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Region");
}
else if (granularity.Equals("City", StringComparison.InvariantCultureIgnoreCase))
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "City");
}
else
{
query = String.Format(distinct ? XQueries.ExtractGeoArray : XQueries.ExtractGeoArray2, "Street");
};
List <MetadataAttributes> ts = new List <MetadataAttributes>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
Interval interval = new Interval();
var current = e.Current.ToString();
if (!current.Equals("")) // a revoir avec elio
{
MetadataAttributes geo = new MetadataAttributes("Geo", "Nominal", current, interval);
ts.Add(geo);
}
}
//ts.Reverse();
return(ts);
}
/**
* Show a query producing a document as its result and serializing this
* to a FileStream
*/
public static void ExampleToStreamResult()
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = "http://www.saxonica.com/";
compiler.DeclareNamespace("saxon", "http://saxon.sf.net/");
XQueryExecutable exp = compiler.Compile("<saxon:example>{static-base-uri()}</saxon:example>");
XQueryEvaluator eval = exp.Load();
Serializer qout = new Serializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.INDENT, "yes");
qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "1");
qout.SetOutputStream(new FileStream("testoutput.xml", FileMode.Create, FileAccess.Write));
eval.Run(qout);
}
/**
* Saxon: Safe when Whitelisting on XQuery Expression Example
* Proves that Saxon is safe from injection when whitelisting the XQuery expression
*/
protected void Page_Load(object sender, EventArgs e)
{
bool expectedSafe = false;
try
{
// parse the XML
Processor processor = new Processor(false);
DocumentBuilder doc = processor.newDocumentBuilder();
XdmNode node = doc.build(new StreamSource(appPath + "/resources/students.xml"));
// query the XML
string query;
if (Request.QueryString["payload"].Contains("\"") || Request.QueryString["payload"].Contains(";"))
{
PrintResults(expectedSafe, new List <string>());
throw new InvalidParameterException("First Name parameter must not contain quotes or semicolons");
}
else
{
query = "for $s in //Students/Student " +
"where $s/FirstName = \"" + Request.QueryString["payload"] + "\" " +
"return $s"; // safe in here!
}
XQueryCompiler xqComp = processor.newXQueryCompiler();
XQueryExecutable xqExec = xqComp.compile(query);
XQueryEvaluator xqEval = xqExec.load();
xqEval.setContextItem(node);
xqEval.evaluate();
// interpret the result of the query
List <string> resultList = new List <string>();
foreach (XdmValue value in xqEval)
{
resultList.Add(value.ToString());
}
// print the results on the query
PrintResults(expectedSafe, resultList);
}
catch (Exception ex)
{
Response.Write(ex.ToString());
}
}
///<summary>
/// Demonstrate extensibility using user-written extension functions
///</summary>
public static void ExampleExtensibility()
{
String query =
"declare namespace ext = \"clitype:SampleExtensions.SampleExtensions?asm=SampleExtensions\";" +
"<out>" +
" <addition>{ext:add(2,2)}</addition>" +
" <average>{ext:average((1,2,3,4,5,6))}</average>" +
" <language>{ext:hostLanguage()}</language>" +
"</out>";
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
Serializer qout = new Serializer();
eval.Run(qout);
}
public List <string> GetObjects(string query)
{
List <string> objects = new List <string>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
objects.Add(e.Current.ToString());
}
return(objects);
}
/**
* Show a query taking a DOM as its input and producing a DOM as its output.
*/
public static void ExampleToDOM(String inputFileName)
{
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.Load(inputFileName);
XdmNode indoc = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("<doc>{reverse(/*/*)}</doc>");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
DomDestination qout = new DomDestination();
eval.Run(qout);
XmlDocument outdoc = qout.XmlDocument;
Console.WriteLine(outdoc.OuterXml);
}
/// <summary>
/// This application uses the xslt file created from the
/// original Word 2007 template document to transform xml data
/// into a valid Open XML 2.0 Wordprocessing format.
/// The application then updates the output document with the
/// new content using the Open XML SDK version 2.0.
/// </summary>
static void Main(string[] args)
{
//Declare variables for file locations.
string xmlDocxFile = @".\mydoc.xml";
string xmlResult = @".\mydoc1.xml";
FileStream fs = new FileStream(xmlDocxFile, FileMode.OpenOrCreate);
XQueryCompiler compiler = new Processor().NewXQueryCompiler();
//bug on saxon's end... sounds stupid but force add base URI for the current location
string directory = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName + '\\';
string uri = new Uri(directory).AbsoluteUri;
compiler.BaseUri = uri;
XQueryExecutable executable = compiler.Compile(fs);
XQueryEvaluator evaluator = executable.Load();
XdmValue result = evaluator.Evaluate();
FileStream fStream = System.IO.File.Open(xmlResult, FileMode.OpenOrCreate, FileAccess.ReadWrite);
XmlWriterSettings settings = new XmlWriterSettings
{
ConformanceLevel = ConformanceLevel.Fragment,
Indent = true
};
XmlWriter writer = XmlWriter.Create(fStream, settings);
try
{
writer.WriteRaw(result.ToString());
} catch (Exception e)
{
writer.Close();
throw e;
} finally
{
writer.Close();
}
}
///<summary>
/// ExampleExtra is where you can place your own code for testing
///</summary>
public static void ExampleExtra()
{
// place-holder to add user-defined examples for testing
string xhtml = "<html><head><title>Hello World</title></head></html>";
string query = "data(/html/head/title)";
Processor processor = new Processor();
XmlDocument input = new XmlDocument();
input.LoadXml(xhtml);
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
eval.ContextItem = processor.NewDocumentBuilder().Build(new XmlNodeReader(input));
Serializer qout = new Serializer();
StringWriter sw = new StringWriter();
qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes"); qout.SetOutputWriter(sw); eval.Run(qout);
Console.WriteLine(sw);
}
public List <MetadataAttributes> GetSocial(string query)
{
List <MetadataAttributes> ts = new List <MetadataAttributes>();
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(query);
XQueryEvaluator eval = exp.Load();
XdmValue value = eval.Evaluate();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
Interval interval = new Interval();
MetadataAttributes social = new MetadataAttributes("Social", "Nominal", e.Current.ToString(), interval);
ts.Add(social);
}
return(ts);
}
/**
* Show a query taking a Saxon tree as its input and producing a Saxon tree as its output.
*/
public static void ExampleToXDM(String inputFileName)
{
Processor processor = new Processor();
DocumentBuilder loader = processor.NewDocumentBuilder();
loader.BaseUri = new Uri(inputFileName);
XdmNode indoc = loader.Build(
new FileStream(inputFileName, FileMode.Open, FileAccess.Read));
XQueryCompiler compiler = processor.NewXQueryCompiler();
XQueryExecutable exp = compiler.Compile("<doc>{reverse(/*/*)}</doc>");
XQueryEvaluator eval = exp.Load();
eval.ContextItem = indoc;
XdmDestination qout = new XdmDestination();
eval.Run(qout);
XdmNode outdoc = qout.XdmNode;
Console.WriteLine(outdoc.OuterXml);
}
/**
* Saxon: Safe when Using Bind Variables on XQuery Expression Example
* Proves that Saxon is safe from injection when using bind variables on the XQuery expression
*/
protected void Page_Load(object sender, EventArgs e)
{
bool expectedSafe = true;
try
{
// parse the XML
Processor processor = new Processor(false);
DocumentBuilder doc = processor.newDocumentBuilder();
XdmNode node = doc.build(new StreamSource(appPath + "/resources/students.xml"));
// query the XML
string query = "declare variable $name as xs:string external; " +
"for $s in //Students/Student " +
"where $s/FirstName = $name " +
"return $s"; // safe!
XQueryCompiler xqComp = processor.newXQueryCompiler();
XQueryExecutable xqExec = xqComp.compile(query);
XQueryEvaluator xqEval = xqExec.load();
xqEval.setContextItem(node);
xqEval.setExternalVariable(new QName("name"), new XdmAtomicValue(Request.QueryString["payload"]));
xqEval.evaluate();
// interpret the result of the query
List <string> resultList = new List <string>();
foreach (XdmValue value in xqEval)
{
resultList.Add(value.ToString());
}
// print the results on the query
PrintResults(expectedSafe, resultList);
}
catch (Exception ex)
{
Response.Write(ex.ToString());
}
}
/**
* Show a query consisting of two modules, using a QueryResolver to resolve
* the "import module" declaration
*/
public static void ExampleMultiModule()
{
String mod1 = "import module namespace m2 = 'http://www.example.com/module2';" +
"m2:square(3)";
String mod2 = "module namespace m2 = 'http://www.example.com/module2';" +
"declare function m2:square($p) { $p * $p };";
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
InlineModuleResolver resolver = new InlineModuleResolver();
resolver.AddModule(new Uri("http://www.example.com/module2"), mod2);
compiler.QueryResolver = resolver;
XQueryExecutable exp = compiler.Compile(mod1);
XQueryEvaluator eval = exp.Load();
XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
Console.WriteLine("Result type: " + result.Value.GetType());
Console.WriteLine("Result value: " + (long)result.Value);
}
public EFileCERuleExecutionElement(string codeEffectsRuleXML, Func <FieldService> fieldServiceFactory, Func <RuleService> ruleServiceFactory, Guid ruleId, int precision, Func <IValuesDictionary> valuesDictionaryProvider, ICache <int, Field> fieldsCache, string xQuery, string currentNamespaceURI = "", Processor processor = null)
{
if (!string.IsNullOrEmpty(codeEffectsRuleXML))
{
MidpointRounding midpointRounding = MidpointRounding.ToEven;
if (precision > -1)
{
midpointRounding = MidpointRounding.AwayFromZero;
}
Evaluator = new Evaluator <EFileDocument>(codeEffectsRuleXML, new EvaluationParameters {
MidpointRounding = midpointRounding, Precision = precision
});
_evaluator = new EFileCERuleEvaluator(codeEffectsRuleXML, fieldServiceFactory, ruleServiceFactory, valuesDictionaryProvider, ruleId, fieldsCache: fieldsCache);
_evaluator.Evaluator = Evaluator;
XQuery = xQuery;
CompiledXQueryExecutable = CreateXQueryExecutable(currentNamespaceURI, processor);
}
else
{
throw new InvalidOperationException("Error in EFileCERuleExecutionElement constructor");
}
}
public int GetMetaID(String meta)
{
Processor processor = new Processor();
XQueryCompiler compiler = processor.NewXQueryCompiler();
//compiler.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
compiler.BaseUri = BaseUri;
XQueryExecutable exp = compiler.Compile(XQueries.GetMetaID);
XQueryEvaluator eval = exp.Load();
eval.SetExternalVariable(new QName("meta"), new XdmAtomicValue(meta));
//XdmAtomicValue result = (XdmAtomicValue)eval.EvaluateSingle();
XdmItem value = eval.EvaluateSingle();
IEnumerator e = value.GetEnumerator();
while (e.MoveNext())
{
//XdmItem item = (XdmItem)e.Current;
//Console.WriteLine(item.ToString());
return(Convert.ToInt32(e.Current.ToString()));
}
return(-1);
}
public ViewModel(MainWindow v, Model model)
{
this.view = v;
this.model = model;
// Register the types for hightlighting. C#, VB.NET and TSQL are defined
// internally by the editor, so they do not need to be registered.
HighlightingManager.Instance.RegisterHighlighting("Go", new[] { ".go" }, LoadHighlightDefinition("Go.xshd"));
Properties.Settings.Default.PropertyChanged += (object sender, PropertyChangedEventArgs e) =>
{
// Save all the user's settings
Properties.Settings.Default.Save();
};
ExitCommand = new RelayCommand(
p => { Application.Current.Shutdown(); });
OpenSourceCommand = new RelayCommand(
p =>
{
var(extension, l) = this.Language;
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = extension; // Default file extension
dlg.Filter = l + " Files |*" + extension; // Filter files by extension
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.SourceEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveSourceCommand = new RelayCommand(
p =>
{
var(e, l) = this.Language;
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = e, // Default file extension
Filter = l + " Files |*" + e // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.SourceEditor.Text);
}
}
);
OpenAstCommand = new RelayCommand(
p =>
{
OpenFileDialog dlg = new OpenFileDialog
{
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.ResultsEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveAstCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.ResultsEditor.Text);
}
}
);
OpenQueryCommand = new RelayCommand(
p =>
{
OpenFileDialog dlg = new OpenFileDialog
{
DefaultExt = ".xq", // Default file extension
Filter = "xq Files |*.xq" // Filter files by extension
};
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
view.QueryEditor.Text = File.ReadAllText(dlg.FileName);
}
}
);
SaveQueryCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = "document"; // Default file name
dlg.DefaultExt = ".xq"; // Default file extension
dlg.Filter = "xq Files |*.xq"; // Filter files by extension
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.QueryEditor.Text);
}
}
);
SaveQueryResultsCommand = new RelayCommand(
p =>
{
SaveFileDialog dlg = new SaveFileDialog
{
FileName = "document", // Default file name
DefaultExt = ".xml", // Default file extension
Filter = "XML Files |*.xml" // Filter files by extension
};
// Show save file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process save file dialog box results
if (result.Value)
{
// Save document
File.WriteAllText(dlg.FileName, view.QueryEditor.Text);
}
}
);
ExecuteExtractionCommand = new RelayCommand(
p =>
{
this.Status = "";
this.Result = "";
// Get the current language extractor from the model
ILanguageExtractor extractor = this.Languages
.Where(l => l.Metadata.Name == Properties.Settings.Default.CurrentLanguage)
.Select(l => l.Value).FirstOrDefault();
XDocument doc = null;;
IEnumerable <IDiagnosticItem> diagnostics = null;
try
{
(doc, diagnostics) = extractor.Extract(this.view.SourceEditor.Text);
}
catch (Exception e)
{
// Nothing.
}
this.Result = doc != null ? doc.ToString() : "";
// Remove all the entries in the error list and the squigglies
this.DiagnosticItems.Clear();
this.view.SourceEditorTextMarkerService.RemoveAll(m => true);
if (diagnostics != null)
{
foreach (var d in diagnostics)
{
this.DiagnosticItems.Add(d);
int startOffset = this.view.SourceEditor.Document.GetOffset(d.Line, d.Column);
int endOffset = this.view.SourceEditor.Document.GetOffset(d.EndLine, d.EndColumn);
int length = endOffset - startOffset;
ITextMarker marker = this.view.SourceEditorTextMarkerService.Create(startOffset, length);
marker.MarkerTypes = TextMarkerTypes.SquigglyUnderline;
marker.MarkerColor = d.Severity == "Error" ? Colors.Red : Colors.Green;
}
}
}
);
view.InputBindings.Add(new InputBinding(OpenSourceCommand, new KeyGesture(Key.O, ModifierKeys.Control)));
view.InputBindings.Add(new InputBinding(SaveSourceCommand, new KeyGesture(Key.S, ModifierKeys.Control)));
view.InputBindings.Add(new InputBinding(ExecuteExtractionCommand, new KeyGesture(Key.E, ModifierKeys.Control)));
this.executeQueryCommand = new RelayCommand(
p =>
{
Processor processor = new Processor();
StringReader sr = new StringReader(this.view.ResultsEditor.Text);
XmlReader reader = XmlReader.Create(sr, new XmlReaderSettings()
{
ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None
});
XdmNode doc = null;
try
{
doc = processor.NewDocumentBuilder().Build(reader);
}
catch (Exception)
{
}
XQueryCompiler compiler = processor.NewXQueryCompiler();
// Add any namespaces needed...
// compiler.DeclareNamespace("saxon", "http://saxon.sf.net/");
try
{
XQueryExecutable exp = compiler.Compile(this.view.QueryEditor.Text);
XQueryEvaluator eval = exp.Load();
// The context node is always the root document.
if (doc != null)
{
eval.ContextItem = doc;
}
Serializer qout = processor.NewSerializer();
qout.SetOutputProperty(Serializer.METHOD, "xml");
qout.SetOutputProperty(Serializer.OMIT_XML_DECLARATION, "yes");
// Not available: qout.SetOutputProperty(Serializer.SAXON_INDENT_SPACES, "2");
// Do not put attributes on separate lines:
qout.SetOutputProperty(Serializer.INDENT, "no");
// Put the result of the XQuery query into a memory stream:
var output = new MemoryStream();
qout.SetOutputStream(output);
// Run the query:
eval.Run(qout);
// Harvest the result
output.Position = 0;
StreamReader resultReader = new StreamReader(output);
string result = resultReader.ReadToEnd();
// Normalize the strange looking output generated by the serializer
// if it is XML
try
{
var d = XDocument.Parse(result);
this.view.QueryResultsEditor.Text = d.ToString(SaveOptions.None);
}
catch
{
this.view.QueryResultsEditor.Text = result;
}
}
catch (Exception e)
{
this.view.QueryResultsEditor.Text = e.Message;
}
},
p => { return(true); });
}
/**
* Run a test case
*
*
* @param testCase the test case element in the catalog
* @param xpc the XPath compiler to be used for compiling XPath expressions against the catalog
* @
*/
protected override void runTestCase(XdmNode testCase, XPathCompiler xpc)
{
bool run = true;
bool xpDependency = false;
string hostLang;
string langVersion;
Spec specOpt = Spec.NULL;
XPathCompiler xpath = driverProc.NewXPathCompiler();
string testCaseName = testCase.GetAttributeValue(new QName("name"));
string testSetName = testCase.Parent.GetAttributeValue(new QName("name"));
bool needSerializedResult = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//assert-serialization-error) or exists(./result//serialization-matches)", testCase)).GetBooleanValue();
bool needResultValue = true;
if (needSerializedResult)
{
needResultValue = ((XdmAtomicValue)xpc.EvaluateSingle(
"exists(./result//*[not(self::serialization-matches or self::assert-serialization-error or self::any-of or self::all-of)])", testCase)).GetBooleanValue();
}
XdmNode alternativeResult = null;
XdmNode optimization = null;
hostLang = ((SpecAttr)spec.GetAttr()).sname;
langVersion = ((SpecAttr)spec.GetAttr()).version;
Environment env = getEnvironment(testCase, xpc);
if (env == null)
{
notrun++;
return;
}
env.xpathCompiler.BackwardsCompatible = false;
env.processor.XmlVersion = (decimal)1.0;
//test
bool icuColCheck = net.sf.saxon.Version.platform.hasICUCollator();
bool icuNumCheck = net.sf.saxon.Version.platform.hasICUNumberer();
Console.WriteLine("ICUCol: " + (icuColCheck ? "true" : "false"));
Console.WriteLine("ICUNum: " + (icuNumCheck ? "true" : "false"));
//end of test
foreach (XdmItem dependency in xpc.Evaluate("/*/dependency, ./dependency", testCase))
{
string type = ((XdmNode)dependency).GetAttributeValue(new QName("type"));
if (type == null)
{
// throw new IllegalStateException("dependency/@type is missing"); //TODO
}
string value = ((XdmNode)dependency).GetAttributeValue(new QName("value"));
if (value == null)
{
//throw new IllegalStateException("dependency/@value is missing"); //TODO
}
if (type.Equals("spec"))
{
bool applicable = false;
if (!value.Contains(((SpecAttr)spec.GetAttr()).sname))
{
applicable = false;
}
else if (value.Contains(((SpecAttr)spec.GetAttr()).svname))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XQ30") && value.Contains("XQ10+"))
{
applicable = true;
}
else if (((SpecAttr)spec.GetAttr()).svname.Equals("XP30") && value.Contains("XP20+"))
{
applicable = true;
}
if (!applicable)
{
writeTestcaseElement(testCaseName, "n/a", "not" + ((SpecAttr)spec.GetAttr()).svname, spec);
notrun++;
return;
}
}
if (langVersion.Equals("3.0"))
{
/* EnvironmentVariableResolver resolver = new EnvironmentVariableResolver() {
* public Set<string> getAvailableEnvironmentVariables() {
* Set<string> strings = new HashSet<string>();
* strings.add("QTTEST");
* strings.add("QTTEST2");
* strings.add("QTTESTEMPTY");
* return strings;
* }
*
* public string getEnvironmentVariable(string name) {
* if (name.Equals("QTTEST")) {
* return "42";
* } else if (name.Equals("QTTEST2")) {
* return "other";
* } else if (name.Equals("QTTESTEMPTY")) {
* return "";
* } else {
* return null;
* }
* }
* }; */
//TODO
//env.processor.SetProperty(JFeatureKeys.ENVIRONMENT_VARIABLE_RESOLVER, resolver);
}
if (type.Equals("feature") && value.Equals("xpath-1.0-compatibility"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (type.Equals("feature") && value.Equals("namespace-axis"))
{
hostLang = "XP";
langVersion = "3.0";
xpDependency = true;
specOpt = Spec.XP30;
}
if (!dependencyIsSatisfied((XdmNode)dependency, env))
{
println("*** Dependency not satisfied: " + ((XdmNode)dependency).GetAttributeValue(new QName("type")));
writeTestcaseElement(testCaseName, "n/a", "Dependency not satisfied", spec);
run = false;
notrun++;
return;
}
}
XdmNode exceptionElement;
try{
exceptionElement = exceptionsMap[testCaseName];
} catch (Exception) {
exceptionElement = null;
}
if (exceptionElement != null)
{
XdmItem config = xpath.EvaluateSingle("configuration", exceptionElement);
string runAtt = exceptionElement.GetAttributeValue(new QName("run"));
string reasonMsg = xpath.EvaluateSingle("reason", exceptionElement).ToString();
string reportAtt = exceptionElement.GetAttributeValue(new QName("report"));
if (config != null)
{
XdmItem paramValue = xpath.EvaluateSingle("param[@name='not-unfolded' and @value='yes']/@name", config);
if (unfolded && paramValue != null)
{
writeTestcaseElement(testCaseName, "notRun", reasonMsg, spec);
notrun++;
return;
}
}
if ("false".Equals(runAtt))
{
writeTestcaseElement(testCaseName, reportAtt, reasonMsg, spec);
notrun++;
return;
}
alternativeResult = (XdmNode)xpc.EvaluateSingle("result", exceptionElement);
optimization = (XdmNode)xpc.EvaluateSingle("optimization", exceptionElement);
}
if (run && (specOpt == Spec.NULL || specOpt == spec))
{
TestOutcome outcome = new TestOutcome(this);
string exp = null;
try
{
exp = xpc.Evaluate("if (test/@file) then unparsed-text(resolve-uri(test/@file, base-uri(.))) else string(test)", testCase).ToString();
}
catch (Exception err)
{
println("*** Failed to read query: " + err.Message);
outcome.SetException((DynamicError)err);
}
//noinspection ThrowableResultOfMethodCallIgnored
if (outcome.GetException() == null)
{
if (hostLang.Equals("XP") || hostLang.Equals("XT"))
{
XPathCompiler testXpc = env.xpathCompiler;
testXpc.XPathLanguageVersion = langVersion;
testXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
testXpc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
//testXpc.DeclareNamespace("math", NamespaceConstant.MATH);
//testXpc.DeclareNamespace("Dictionary", NamespaceConstant.Dictionary_FUNCTIONS);
try
{
XPathSelector selector = testXpc.Compile(exp).Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = new TestUriResolver(env);
if (env.unparsedTextResolver != null)
{
//selector.getUnderlyingXPathContext().setUnparsedTextURIResolver(env.unparsedTextResolver); //TODO
}
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
catch (Exception err)
{
println(err.Message);
outcome.SetException(err);
}
}
else if (hostLang.Equals("XQ"))
{
XQueryCompiler testXqc = env.xqueryCompiler;
testXqc.XQueryLanguageVersion = langVersion;
testXqc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
testXqc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
//testXqc.DeclareNamespace("math", NamespaceConstant.MATH);
testXqc.DeclareNamespace("map", "http://www.w3.org/2005/xpath-functions/map");
// ErrorCollector errorCollector = new ErrorCollector();
testXqc.ErrorList = new ArrayList();
string decVars = env.paramDecimalDeclarations.ToString();
if (decVars.Length != 0)
{
int x = (exp.IndexOf("(:%DECL%:)"));
if (x < 0)
{
exp = decVars + exp;
}
else
{
exp = exp.Substring(0, x) + decVars + exp.Substring(x + 13);
}
}
string vars = env.paramDeclarations.ToString();
if (vars.Length != 0)
{
int x = (exp.IndexOf("(:%VARDECL%:)"));
if (x < 0)
{
exp = vars + exp;
}
else
{
exp = exp.Substring(0, x) + vars + exp.Substring(x + 13);
}
}
ModuleResolver mr = new ModuleResolver(xpc);
mr.setTestCase(testCase);
// testXqc.QueryResolver = mr;// .setModuleURIResolver(mr); //TODO
testXqc.QueryResolver = mr;
try
{
XQueryExecutable q = testXqc.Compile(exp);
if (optimization != null)
{
// Test whether required optimizations have been performed
XdmDestination expDest = new XdmDestination();
JConfiguration config = driverProc.Implementation;
//ExpressionPresenter presenter = new ExpressionPresenter(config, expDest.getReceiver(config));
//q.getUnderlyingCompiledQuery().explain(presenter);
//presenter.close();
XdmNode explanation = expDest.XdmNode;
XdmItem optResult = xpc.EvaluateSingle(optimization.GetAttributeValue(new QName("assert")), explanation);
if (((XdmAtomicValue)optResult).GetBooleanValue())
{
println("Optimization result OK");
}
else
{
println("Failed optimization test");
Serializer ser = new Serializer();
ser.SetOutputStream((Stream)System.Console.OpenStandardError());
driverProc.WriteXdmValue(explanation, ser);
writeTestcaseElement(testCaseName, "fail", "Failed optimization assertions", spec);
failures++;
return;
}
}
XQueryEvaluator selector = q.Load();
foreach (QName varName in env.params1.Keys)
{
selector.SetExternalVariable(varName, env.params1[varName]);
}
if (env.contextItem != null)
{
selector.ContextItem = env.contextItem;
}
selector.InputXmlResolver = env;
//selector.InputXmlResolver = .SetURIResolver(new TestURIResolver(env)); //TODO
if (env.unparsedTextResolver != null)
{
selector.Implementation.setUnparsedTextURIResolver(env.unparsedTextResolver);// TODO
}
if (needSerializedResult)
{
StringWriter sw = new StringWriter();
Serializer serializer = new Serializer(); //env.processor.NewSerializer(sw); //TODO
serializer.SetOutputWriter(sw);
selector.Run(serializer);
outcome.SetPrincipalSerializedResult(sw.ToString());
}
if (needResultValue)
{
XdmValue result = selector.Evaluate();
outcome.SetPrincipalResult(result);
}
}
catch (Exception err)
{
println("in TestSet " + testSetName + err.StackTrace);
println(err.Message);
outcome.SetException(err);
outcome.SetErrorsReported((IList)testXqc.ErrorList);
}
}
else
{
writeTestcaseElement(testCaseName, "notRun", "No processor found", spec);
notrun++;
return;
}
}
if (env.resetAction != null)
{
env.resetAction.reset(env);
}
XdmNode assertion;
if (alternativeResult != null)
{
assertion = (XdmNode)xpc.EvaluateSingle("*[1]", alternativeResult);
}
else
{
assertion = (XdmNode)xpc.EvaluateSingle("result/*[1]", testCase);
}
if (assertion == null)
{
println("*** No assertions found for test case " + testCaseName);
writeTestcaseElement(testCaseName, "disputed", "No assertions in test case", spec);
feedback.Feedback(successes, failures++, total);
return;
}
XPathCompiler assertXpc = env.processor.NewXPathCompiler();
assertXpc.XPathLanguageVersion = "3.1";
assertXpc.DeclareNamespace("fn", "http://www.w3.org/2005/xpath-functions");
assertXpc.DeclareNamespace("xs", "http://www.w3.org/2001/XMLSchema");
assertXpc.DeclareNamespace("math", "http://www.w3.org/2005/xpath-functions/math");
assertXpc.DeclareNamespace("MAP_FUNCTIONS", "http://www.w3.org/2005/xpath-functions/map");
assertXpc.DeclareVariable(new QName("result"));
bool b = outcome.TestAssertion(assertion, outcome.GetPrincipalResultDoc(), assertXpc, xpc, debug);
if (b)
{
//println("OK");
writeTestcaseElement(testCaseName, "pass", null, spec);
feedback.Feedback(successes++, failures, total);
}
else
{
if (outcome.IsException())
{
XdmItem expectedError = xpc.EvaluateSingle("result//error/@code", testCase);
if (expectedError == null)
{
// if (debug) {
// outcome.getException().printStackTrace(System.out);
// }
writeTestcaseElement(testCaseName, "fail", "Expected success, got ", spec);
println("*** fail, result " + outcome.GetException() +
" Expected success.");
feedback.Feedback(successes, failures++, total);
}
else
{
writeTestcaseElement(testCaseName, "wrongError",
"Expected error:" + expectedError.ToString() + ", got " + outcome.GetErrorCode().LocalName, spec);
println("*** fail, result " + outcome.GetErrorCode().LocalName +
" Expected error:" + expectedError.ToString());
wrongErrorResults++;
feedback.Feedback(successes++, failures, total);
}
}
else
{
writeTestcaseElement(testCaseName, "fail", "Wrong results, got " +
truncate(outcome.Serialize(assertXpc.Processor, outcome.GetPrincipalResultDoc())), spec);
feedback.Feedback(successes, failures++, total);
if (debug)
{
try
{
println("Result:");
driverProc.WriteXdmValue(outcome.GetPrincipalResult(), driverSerializer);
println("<=======");
}
catch (Exception err)
{
}
//println(outcome.getResult());
}
else
{
println("*** fail (use -debug to show actual result)");
//failures++;
}
}
}
}
}