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; }