public static string ToString(StringTree tree)
{
switch (tree.Type)
{
// text node
case StringPatternLexer.TEXT:
return(tree.Text);
// Pattern nodes
case StringPatternLexer.IS:
return(String.Format("{0} LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.CONTAINS:
return(String.Format("{0} LIKE '%{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.BEGINS:
return(String.Format("{0} LIKE '{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.ENDS:
return(String.Format("{0} LIKE '%{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.COMPLEX:
return(String.Format("{0} LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
}
return(String.Empty);
}
private static SQLTree createDefaultStringExpression(string property)
{
SQLTree root = new SQLTree(SQLFilterLexer.STRING_EXPR);
StringTree op = new StringTree(StringPatternLexer.IS);
SQLTree id = new SQLTree(new CommonToken(SQLFilterLexer.ID, property));
StringTree constant = new StringTree(new CommonToken(StringPatternLexer.TEXT, ""));
op.AddChild(id);
op.AddChild(constant);
root.AddChild(op);
constant.MarkAsDirty();
id.IsDirty = true;
root.IsLeaf = true;
return(root);
}
private static string ToStringNegate(StringTree tree)
{
switch (tree.Type)
{
case StringPatternLexer.IS:
return(String.Format("{0} NOT LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.CONTAINS:
return(String.Format("{0} NOT LIKE '%{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.BEGINS:
return(String.Format("{0} NOT LIKE '{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.ENDS:
return(String.Format("{0} NOT LIKE '%{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
case StringPatternLexer.COMPLEX:
return(String.Format("{0} NOT LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString()));
}
return(String.Empty);
}
public static Expression Compile(StringTree node, ParameterExpression param)
{
switch (node.Type)
{
// text node
case StringPatternLexer.TEXT:
return(Expression.Constant(node.Text));
// Pattern nodes
case StringPatternLexer.IS:
return(Expression.Call(
typeof(StringExtension).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) }));
case StringPatternLexer.CONTAINS:
return(Expression.Call(
typeof(StringExtension).GetMethod("Contains", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) }));
case StringPatternLexer.BEGINS:
return(Expression.Call(
typeof(StringExtension).GetMethod("StartsWith", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) }));
case StringPatternLexer.ENDS:
return(Expression.Call(
typeof(StringExtension).GetMethod("EndsWith", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) }));
case StringPatternLexer.COMPLEX:
{
Func <string, bool> validator = Filter.CompilePattern(node.Children[1].Text);
Expression <Func <string, bool> > lambda = (s) => (s == null) ? false : validator(s);
return(Expression.Invoke(
lambda,
new Expression[] { ((FilterTree)node.Children[0]).Compile(param) }));
}
}
return(null);
}
private static string ToStringNegate(StringTree tree)
{
switch (tree.Type)
{
case StringPatternLexer.IS:
return String.Format("{0} NOT LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.CONTAINS:
return String.Format("{0} NOT LIKE '%{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.BEGINS:
return String.Format("{0} NOT LIKE '{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.ENDS:
return String.Format("{0} NOT LIKE '%{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.COMPLEX:
return String.Format("{0} NOT LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
}
return String.Empty;
}
public static string ToString(StringTree tree)
{
switch (tree.Type)
{
// text node
case StringPatternLexer.TEXT:
return tree.Text;
// Pattern nodes
case StringPatternLexer.IS:
return String.Format("{0} LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.CONTAINS:
return String.Format("{0} LIKE '%{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.BEGINS:
return String.Format("{0} LIKE '{1}%'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.ENDS:
return String.Format("{0} LIKE '%{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
case StringPatternLexer.COMPLEX:
return String.Format("{0} LIKE '{1}'", tree.Children[0].ToString(), tree.Children[1].ToString());
}
return String.Empty;
}
public static Expression Compile(StringTree node, ParameterExpression param)
{
switch (node.Type)
{
// text node
case StringPatternLexer.TEXT:
return Expression.Constant(node.Text);
// Pattern nodes
case StringPatternLexer.IS:
return Expression.Call(
typeof(StringExtension).GetMethod("Equals", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
case StringPatternLexer.CONTAINS:
return Expression.Call(
typeof(StringExtension).GetMethod("Contains", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
case StringPatternLexer.BEGINS:
return Expression.Call(
typeof(StringExtension).GetMethod("StartsWith", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
case StringPatternLexer.ENDS:
return Expression.Call(
typeof(StringExtension).GetMethod("EndsWith", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(string), typeof(StringComparison) }, null),
new Expression[] { ((FilterTree)node.Children[0]).Compile(param), ((FilterTree)node.Children[1]).Compile(param), Expression.Constant(StringComparison.OrdinalIgnoreCase) });
case StringPatternLexer.COMPLEX:
{
Func<string, bool> validator = Filter.CompilePattern(node.Children[1].Text);
Expression<Func<string, bool>> lambda = (s) => (s == null) ? false : validator(s);
return Expression.Invoke(
lambda,
new Expression[] { ((FilterTree)node.Children[0]).Compile(param) });
}
}
return null;
}
