public void Evaluate_grouped()
{
var variables = new Dictionary <string, IVariableValueResolver>();
var expression = new GroupExpression(new IBooleanExpression[]
{
new ComparisonExpression(
new ConstantExpression("a"),
new ConstantExpression("b"),
ComparisonOperator.Equal,
BooleanOperator.And),
new GroupExpression(new[]
{
new ComparisonExpression(
new ConstantExpression("1"),
new ConstantExpression("2"),
ComparisonOperator.Equal,
BooleanOperator.And),
new ComparisonExpression(
new ConstantExpression("c"),
new ConstantExpression("c"),
ComparisonOperator.Equal,
BooleanOperator.Or),
},
BooleanOperator.And)
}, BooleanOperator.And);
var actual = ExpressionEvaluator.Evaluate(expression, variables);
actual.Should().Be.False();
}
public void GroupTest()
{
var expr = new GroupExpression(new[] {
new StructureExpression("foo"),
new StructureExpression("bar")
});
var result = expr.Run();
Assert.Collection(result,
item =>
{
Assert.IsType <StructureResultTree>(item);
Assert.Equal("foo", (item as StructureResultTree).Name);
Assert.Collection((item as StructureResultTree).FirstChild,
item => Assert.Null(item)
);
Assert.Collection((item as StructureResultTree).NextSibling,
item =>
{
Assert.IsType <StructureResultTree>(item);
Assert.Equal("bar", (item as StructureResultTree).Name);
Assert.Collection((item as StructureResultTree).FirstChild,
item => Assert.Null(item)
);
Assert.Collection((item as StructureResultTree).NextSibling,
item => Assert.Null(item)
);
}
);
}
);
}
/// <summary>
/// GroupExpression を作成する.
/// </summary>
/// <returns></returns>
public static GeneratedExpression CreateGroup()
{
GroupExpression exp = new GroupExpression();
exp.Type = ExpressionType.Group;
return(exp);
}
public void OnExportGroupBegin(GroupExpression expression)
{
XmlNode groupNode = m_root.AppendChild(m_xml.CreateElement("Group"));
XmlNode exp = groupNode.Attributes.Append(m_xml.CreateAttribute("Expression"));
exp.Value = expression.Expression;
}
public object Visit(GroupExpression groupExpression)
{
PrintStart("Group", ConsoleColor.Magenta);
Next(groupExpression.Expression);
_indentationLevel--;
return(null !);
}
private bool TryFindGroupExpression(Tree tree, out GroupExpression groupExpr)
{
groupExpr = new GroupExpression();
if (tree == null)
{
return(false);
}
bool found = false;
Tree vp = null;
Traverse(tree, x =>
{
if (x.label().value().Equals("VP"))
{
vp = x;
return(false);
}
return(true);
});
if (vp != null)
{
var allWords = WordsListToStringList(vp.yieldWords());
if (allWords.Contains("add", StringComparer.InvariantCultureIgnoreCase))
{
IEnumerable <string> resKeywords = null;
if (TryFindSubjectKeywords(vp, out resKeywords))
{
Tree pp = null;
Traverse(vp, x =>
{
if (x.label().value().Equals("PP"))
{
pp = x;
return(false);
}
return(true);
});
if (pp != null)
{
IEnumerable <string> groupKeywords = null;
if (TryFindSubjectKeywords(pp, out groupKeywords))
{
if (groupKeywords.Count() > 0)
{
found = true;
groupExpr.GroupKeywords = groupKeywords;
groupExpr.ResourceKeywords = resKeywords;
}
}
}
}
}
}
return(found);
}
public void OnExportGroupBegin(GroupExpression expression)
{
XmlNode groupNode = m_root.AppendChild(m_xml.CreateElement("Group"));
XmlNode name = groupNode.Attributes.Append(m_xml.CreateAttribute("Name"));
name.Value = expression.Name;
foreach (KeyValuePair <string, string> item in expression.Data)
{
XmlNode attr = groupNode.Attributes.Append(m_xml.CreateAttribute(item.Key));
attr.Value = item.Value;
}
}
private IEnumerable <UserResponsePackage> ExecuteSentenceRequest(Annotation sentence)
{
var responses = new List <UserResponsePackage>();
var parseTree = sentence.get(typeof(TreeCoreAnnotations.TreeAnnotation)) as Tree;
IEnumerable <string> subjectKeywords = null;
ConditionalExpression condExpr = null;
GroupExpression groupExpr = null;
if (TryFindGroupExpression(parseTree, out groupExpr))
{
responses.AddRange(ResourceGroupManager.Instance.ExecuteExpressions(groupExpr.Yield()));
}
else if (TryFindConditionalExpression(parseTree, out condExpr))
{
// Process conditional
var response = new UserResponsePackage()
{
Data = "Success."
};
try
{
ConditionalRequestManager.Instance.AddExpression(condExpr);
}
catch (Exception e)
{
response.Data = e;
}
responses.Add(response);
}
else if (TryFindSubjectKeywords(parseTree, out subjectKeywords))
{
Predicate predicate = null;
if (TryFindPredicate(parseTree, out predicate))
{
using (var context = new ApplicationDbContext())
{
var se = new ResourceSearchEngine(context);
var resources = se.FindResources(subjectKeywords);
var groups = se.FindGroups(subjectKeywords);
predicate.ResetActionType();
responses.AddRange(ResourceGroupManager.Instance.ExecuteOnGroups(groups, predicate));
responses.AddRange(predicate.ExecuteAction(resources));
}
}
}
return(responses);
}
private void okButton_Click(object sender, EventArgs e)
{
try
{
GroupExpression exp = new GroupExpression(expressionTextBox.Text);
}
catch (SystemException exc)
{
MessageBox.Show(exc.Message, m_strErrorCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
m_editGroup.Header = expressionTextBox.Text.Split(':').First();
m_editGroup.Tag = expressionTextBox.Text;
Close();
}
public void CompileShouldMultiplyGroupExpressionWithFollowingIntegerExpression()
{
var groupExpression = new GroupExpression();
groupExpression.AddChild(new IntegerExpression("2"));
groupExpression.Children.First().Operator = Operator.Plus;
groupExpression.AddChild(new IntegerExpression("3"));
groupExpression.Operator = Operator.Multiply;
_graph.Add(groupExpression);
_graph.Add(new IntegerExpression("2"));
var result = _expressionCompiler.Compile(_graph.Expressions);
Assert.AreEqual(10d, result.Result);
}
/// <summary>
/// 解析分组
/// </summary>
/// <returns></returns>
public virtual string ResolveGroupBy()
{
StringBuilder builder = new StringBuilder();
var groupExpression = abstractSet.GroupExpressionList;
if (groupExpression != null && groupExpression.Any())
{
for (int i = 0; i < groupExpression.Count; i++)
{
var groupParam = new GroupExpression(groupExpression[i], $"Group_{i}", provider);
if (builder.Length != 0)
{
builder.Append(",");
}
builder.Append(groupParam.SqlCmd);
}
builder.Insert(0, " GROUP BY ");
}
return(builder.ToString());
}
public void Evaluate_multiple(BooleanOperator booleanOperator, bool expected)
{
var variables = new Dictionary <string, IVariableValueResolver>();
var expression = new GroupExpression(new[]
{
new ComparisonExpression(
new ConstantExpression("a"),
new ConstantExpression("b"),
ComparisonOperator.Equal,
BooleanOperator.And),
new ComparisonExpression(
new ConstantExpression("c"),
new ConstantExpression("c"),
ComparisonOperator.Equal,
booleanOperator)
}, BooleanOperator.And);
var actual = ExpressionEvaluator.Evaluate(expression, variables);
actual.Should().Be.EqualTo(expected);
}
protected virtual void VisitGroupExpression(GroupExpression groupExpression)
{
Visit(groupExpression.Expression);
}
public void Compile(GroupExpression query)
{
}
public void OnExportGroupBegin(GroupExpression expression)
{
m_sw.WriteLine("\"" + expression.Name + "\"");
}
protected abstract T CompileGroupExpression(GroupExpression expression);
public ResolvedGroupExpression(GroupExpression other) : base()
{
this.GroupKeywords = other.GroupKeywords;
this.ResourceKeywords = other.ResourceKeywords;
this.Resolve();
}
public Expression Parse(string expr, CompileContext ctx = null, Dictionary <Expression, ExpressionSegment> segments = null)
{
if (expr == null)
{
throw new Exception("expr null");
}
expr = expr.Trim();
if (string.IsNullOrEmpty(expr))
{
throw new Exception("expr empty");
}
Expression result;
if (cachedExprs.TryGetValue(expr, out result))
{
return(result);
}
Stack <Expression> s1 = new Stack <Expression>();
Stack <PartInfo> s2 = new Stack <PartInfo>();
Stack <string> variables = new Stack <string>();
Stack <CompileContext> ctxs = new Stack <CompileContext>();
ctxs.Push(ctx);
PushScope(ctxs);
foreach (var segment in ToParts(expr))
{
if (segment.IsString)
{
s1.Push(Expression.Constant <string>(segment.Expr));
//s1.Push((Expression)part1);
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
}
string exprPart = segment.Expr;
Console.WriteLine("part:" + exprPart);
if (kws.ContainsKey(exprPart))
// if(segment.IsKeyword)
{
var part = new PartInfo()
{
segment = segment,
keywordInfo = kws[exprPart]
};
var kw = part.keywordInfo;
if (kw.Keyword == ")")
{
while (s2.Count > 0 && s2.Peek().keywordInfo.Keyword != "(")
{
var tmp = s2.Pop();
s1.Push(GetExpr(tmp, s1, s2));
if (s2.Peek().keywordInfo.Keyword == ",")
{
}
}
Expression contentNode;
if (s1.Peek().ExpressionType != ExpressionType.Group)
{
contentNode = PopData(s1);
}
else
{
contentNode = null;
}
if (s1.Peek() is JoinExpression)
{
var join = s1.Pop() as JoinExpression;
//join.List.Insert(0, contentNode);
join.List.Add(contentNode);
contentNode = join;
}
//pop group
s1.Pop();
bool isGroup = true;
if (s1.Count > 0 && (s1.Peek().ExpressionType == ExpressionType.Member || s1.Peek().ExpressionType == ExpressionType.Variable))
{
Expression[] args = null;
if (contentNode == null)
{
args = null;
}
else if (contentNode is JoinExpression)
{
args = ((JoinExpression)contentNode).List.ToArray();
}
else
{
args = new Expression[] { contentNode };
}
var d = s1.Peek() as MemberExpression;
if (d != null)
{
if (d.Member.MemberType == MemberTypes.Method)
{
s1.Pop();
s1.Push(Expression.Call(d.Instance, d.Member.Name, args));
if (segments != null)
{
var seg = segments[d];
segments.Remove(d);
segments[s1.Peek()] = seg;
}
}
}
else
{
var p = s1.Peek() as ParameterExpression;
if (p.ValueType == typeof(MethodInfo))
{
MethodInfo mInfo = ctx.Context.GetVariable(p.Name) as MethodInfo;
s1.Pop();
s1.Push(Expression.Call(mInfo, args));
if (segments != null)
{
var seg = segments[p];
segments.Remove(p);
segments[s1.Peek()] = seg;
}
}
else if (p.ValueType.IsSubclassOf(typeof(Delegate)))
{
Type delType = p.ValueType;
var mInfo = delType.GetMethod("Invoke");
s1.Push(Expression.Call(s1.Pop(), mInfo.ReturnType, args));
if (segments != null)
{
var seg = segments[p];
segments.Remove(p);
segments[s1.Peek()] = seg;
}
}
}
isGroup = false;
}
if (isGroup)
{
GroupExpression g = new GroupExpression(contentNode);
s1.Push(g);
}
s2.Pop();
}
else if (kw.Keyword == ",")
{
while (s2.Count > 0 && s2.Peek().keywordInfo.Keyword != "(")
{
s1.Push(GetExpr(s2.Pop(), s1, s2));
}
var left = PopData(s1);
JoinExpression join;
if (s1.Count > 0 && s1.Peek() is JoinExpression)
{
join = s1.Peek() as JoinExpression;
}
else
{
join = new JoinExpression();
s1.Push(join);
}
//join.List.Insert(0, left);
join.List.Add(left);
}
else
{
if (kw.Keyword == "(")
{
s1.Push(Expression.Group(Expression.Null));
}
while (s2.Count > 0 && kw.Priority != 0 && /* s2.Peek().Priority != 0 &&*/ s2.Peek().keywordInfo.Priority > kw.Priority)
{
var tmp = s2.Pop();
s1.Push(GetExpr(tmp, s1, s2));
}
s2.Push(part);
}
}
else
{
switch (exprPart.ToLower())
{
case "true":
s1.Push(Expression.True);
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
case "false":
s1.Push(Expression.False);
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
case "null":
s1.Push(Expression.Null);
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
//case "undefined":
// s1.Push(Expression.Undefined);
// continue;
}
if (segment.IsDigit)
{
if (segment.Expr.IndexOf('.') >= 0)
{
double f;
if (double.TryParse(exprPart, out f))
{
s1.Push(Expression.Constant(f));
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
}
}
else
{
long l;
if (long.TryParse(exprPart, out l))
{
s1.Push(Expression.Constant(l));
if (segments != null)
{
segments[s1.Peek()] = segment;
}
continue;
}
}
}
if (s2.Count > 0 && s2.Peek().keywordInfo.Keyword == ".")
{
var variable = s1.Pop();
var member = GetMember(variable, null, exprPart, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.GetField | BindingFlags.GetProperty);
if (member == null)
{
throw new Exception("not found Member :" + exprPart);
}
if (member.MemberType == MemberTypes.Method)
{
s1.Push(Expression.Member(variable, null, exprPart));
if (segments != null)
{
segments[s1.Peek()] = segment;
}
}
else
{
s1.Push(Expression.PropertyOrField(variable, member.Name));
if (segments != null)
{
segments[s1.Peek()] = segment;
}
}
s2.Pop();
}
else
{
//variable
s1.Push(Expression.Variable(GetVariableType(ctxs, exprPart), exprPart));
if (segments != null)
{
segments[s1.Peek()] = segment;
}
}
// variables.Push(part);
}
}
while (s2.Count > 0)
{
var tmp = s2.Pop();
s1.Push(GetExpr(tmp, s1, s2));
}
result = PopData(s1);
if (s1.Count > 1)
{
throw new Exception("expr stack error, count>1 count:" + s1.Count + ", expr:" + expr + " ,type:" + s1.Peek().ToString());
}
PopScope(ctxs);
//cachedExprs[expr] = result;
return(result);
}
private System.Linq.Expressions.Expression EvaluateGroupExpression(GroupExpression groupExpression)
{
return(Evaluate(groupExpression.Expression));
}
private string GenerateGroupExpression(Expression expression)
{
GroupExpression group = expression as GroupExpression;
return("( " + this.GenerateExpression(group.Expression) + " )");
}
protected override object CompileGroupExpression(GroupExpression expression)
{
object value = CompileExpression(expression.Expression);
return(value);
}
