/// <summary> /// インスタンスを生成します。 /// </summary> /// <param name="@operator">演算子</param> /// <param name="type">左辺のインスタンスの型</param> /// <param name="propertyName">プロパティ名</param> /// <param name="value">値</param> internal PredicateElement(PredicateOperator @operator, Type type = null, string propertyName = null, object value = null) { this.Operator = @operator; this.Type = type; this.PropertyName = propertyName; this.Value = value; }
/// <summary> /// Extends the specified source Predicate with another Predicate and the specified PredicateOperator. /// </summary> /// <typeparam name="T">The type</typeparam> /// <param name="first">The source Predicate.</param> /// <param name="second">The second Predicate.</param> /// <param name="operator">The Operator (can be "And" or "Or").</param> /// <returns>Expression{Func{T, bool}}</returns> public static Expression <Func <T, bool> > Extend <T>( [NotNull] this Expression <Func <T, bool> > first, [NotNull] Expression <Func <T, bool> > second, PredicateOperator @operator = PredicateOperator.Or) { return(@operator == PredicateOperator.Or ? first.Or(second) : first.And(second)); }
/// <summary> /// Sets the condition. /// </summary> /// <typeparam name="T">Type of predicate values.</typeparam> /// <param name="operator">The predicate operator.</param> /// <param name="values">The values.</param> /// <returns>The parent query builder for call chaining.</returns> private TParent SetCondition <T>(PredicateOperator @operator, T[] values) { predicate.@operator = @operator; if (typeof(T) == typeof(string)) { predicate.values = Array.ConvertAll(values, delegate(T value) { // backslash, singlequote and doublequotes should be escaped. See // https://developers.google.com/adwords/api/docs/guides/awql#notes_1 return("'" + value.ToString() // Replace backslashes first, so double-escaping won't happen. .Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("'", "\\'") + "'"); }); } else if (typeof(T) == typeof(bool)) { // When using a Boolean condition in a predicate, it should be sent as TRUE or FALSE. predicate.values = Array.ConvertAll(values, value => value.ToString().ToUpper()); } else { predicate.values = Array.ConvertAll(values, value => value.ToString()); } return(queryBuilder); }
public void OutputPredicateOperator(PredicateOperator valueSet) { OutputStatusMessage(string.Format("Values in {0}", valueSet.GetType())); foreach (var value in Enum.GetValues(typeof(PredicateOperator))) { OutputStatusMessage(value.ToString()); } }
/// <summary> /// Adds a filter to select only items where the value of /// <paramref name="field"/> satisfies a particular condition. /// </summary> /// <param name="field">The field to filter on.</param> /// <param name="operator">The predicate operator.</param> /// <param name="values">The predicate values.</param> /// <returns>The current object, for call chaining.</returns> private static Predicate WithCondition(string field, PredicateOperator @operator, string[] values) { return new Predicate() { field = field, @operator = @operator, values = values }; }
public BinaryOpPredicate(Expr left, PredicateOperator op, Expr right) { this.Comments = new Comments(1); this.Left = left; this.Operator = op; this.Right = right; this.Left.Parent = this; this.Right.Parent = this; }
internal BinaryOpPredicate(Expr left, PredicateOperator op, Expr right, Comments comments) { this.Comments = comments; this.Left = left; this.Operator = op; this.Right = right; this.Left.Parent = this; this.Right.Parent = this; }
/// <summary> /// Adds a filter to select only items where the value of /// <paramref name="field"/> satisfies a particular condition. /// </summary> /// <param name="field">The field to filter on.</param> /// <param name="operator">The predicate operator.</param> /// <param name="values">The predicate values.</param> /// <returns>The current object, for call chaining.</returns> private static Predicate WithCondition(string field, PredicateOperator @operator, string[] values) { return(new Predicate() { field = field, @operator = @operator, values = values }); }
public SubQueryPredicate(Expr operand , PredicateOperator operater , QueryQuantifier quantifier , IQuery query) { this.Comments = new Comments(4); this.Operand = operand; this.Operator = operater; this.Quantifier = quantifier; this.Query = query; }
internal SubQueryPredicate(Expr operand , PredicateOperator operater , QueryQuantifier quantifier , IQuery query , Comments comments) { this.Comments = comments; this.Operand = operand; this.Operator = operater; this.Quantifier = quantifier; this.Query = query; }
/// <summary> /// Adds a filter to select only items where the value of /// <paramref name="field"/> satisfies a particular condition. /// </summary> /// <param name="field">The field to filter on.</param> /// <param name="operator">The predicate operator.</param> /// <param name="values">The predicate values.</param> /// <returns>A new <see cref="Predicate"/> object that filters by specified /// conditions.</returns> private static Predicate WithCondition(string field, PredicateOperator @operator, string[] values) { // Mark the usage. featureUsageRegistry.MarkUsage(FEATURE_ID);; return(new Predicate() { field = field, @operator = @operator, values = values }); }
private bool FindPredicate(char use) { var regex = new Regex(@"[A-EG-SU-Z]"); var match = regex.Match(use.ToString()); if (match.Success) { var predicate = new PredicateOperator(_argumentManager); predicate.SetName(use); _operator = predicate; return(true); } return(false); }
/// <summary> /// 指定された条件式演算子を反転します。 /// </summary> /// <param name="@operator">演算子</param> /// <returns>反転された演算子</returns> public static PredicateOperator Flip(this PredicateOperator @operator) { switch (@operator) { case PredicateOperator.LessThan: return(PredicateOperator.GreaterThan); case PredicateOperator.LessThanOrEqual: return(PredicateOperator.GreaterThanOrEqual); case PredicateOperator.GreaterThan: return(PredicateOperator.LessThan); case PredicateOperator.GreaterThanOrEqual: return(PredicateOperator.LessThanOrEqual); } return(@operator); }
/// <summary> /// Creates the <see cref="PropertyFilter{T}"/>. /// </summary> /// <param name="propertyPath">The property path</param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> /// <param name="culture">The culture</param> /// <param name="isCaseSensitive"></param> public PropertyFilter(string propertyPath, PredicateOperator @operator, object value, CultureInfo culture, bool isCaseSensitive) { if (propertyPath == null) { throw new ArgumentNullException(nameof(propertyPath)); } this.builder = new PredicateBuilder(); this.propertyPath = propertyPath; this.@operator = @operator; this.value = value; this.culture = culture; this.isCaseSensitive = isCaseSensitive; this.Refresh(); }
/// <summary> /// Extends the specified source Predicate with another Predicate and the specified PredicateOperator. /// </summary> /// <typeparam name="T">The type</typeparam> /// <param name="first">The source Predicate.</param> /// <param name="second">The second Predicate.</param> /// <param name="operator">The Operator (can be "And" or "Or").</param> /// <returns>Expression{Func{T, bool}}</returns> public static Expression <Func <T, bool> > Extend <T>( this ExpressionStarter <T> first, Expression <Func <T, bool> > second, PredicateOperator @operator = PredicateOperator.Or) { if (first is null) { throw new ArgumentNullException(nameof(first)); } if (second is null) { throw new ArgumentNullException(nameof(second)); } return(@operator == PredicateOperator.Or ? first.Or(second) : first.And(second)); }
public Selector <TField> AddPredicate(TField field, PredicateOperator @operator, params object[] values) { var predicate = new Predicate(); predicate.Field = field.ToString(); predicate.Operator = @operator; predicate.Values = new List <string>(); foreach (var value in values) { predicate.Values.Add(value.ToString()); } if (Predicates == null) { Predicates = new List <Predicate>(); } Predicates.Add(predicate); return(this); }
// 演算子を反転させる、 <= と >= の違いを吸収するため public static PredicateOperator Flip(this PredicateOperator predicateOperator) { switch (predicateOperator) { case PredicateOperator.LessThan: return(PredicateOperator.GreaterThan); case PredicateOperator.LessThanOrEqual: return(PredicateOperator.GreaterThanOrEqual); case PredicateOperator.GreaterThan: return(PredicateOperator.LessThan); case PredicateOperator.GreaterThanOrEqual: return(PredicateOperator.LessThanOrEqual); default: return(predicateOperator); } }
// 左右ノードから抽出 PredicatePair ExtractBinary(BinaryExpression node, PredicateOperator predicateOperator) { // x.hoge == xx形式なら左がメンバ名 var memberName = ExtractMemberName(node.Left); if (memberName != null) { var value = GetValue(node.Right); return(new PredicatePair(memberName, value, predicateOperator)); } // xx == x.hoge形式なら右がメンバ名 memberName = ExtractMemberName(node.Right); if (memberName != null) { var value = GetValue(node.Left); return(new PredicatePair(memberName, value, predicateOperator.Flip())); // >, >= と <, <= を統一して扱うため演算子は左右反転 } throw new InvalidOperationException(); }
/// <summary> /// Adds a filter to select only items where the value of /// <paramref name="field"/> satisfies a particular condition. /// </summary> /// <param name="field">The field to filter on.</param> /// <param name="operator">The predicate operator.</param> /// <param name="values">The predicate values.</param> /// <returns>A new <see cref="Predicate"/> object that filters by specified /// conditions.</returns> private static Predicate WithCondition(string field, PredicateOperator @operator, string[] values) { // Mark the usage. featureUsageRegistry.MarkUsage(FEATURE_ID); return new Predicate() { field = field, @operator = @operator, values = values }; }
/// <summary> /// Creates the <see cref="PropertyFilter{T}"/>. /// </summary> /// <param name="propertyPath">The property path</param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> /// <param name="isCaseSensitive"></param> public PropertyFilter(string propertyPath, PredicateOperator @operator, object value, bool isCaseSensitive) : this(propertyPath, @operator, value, null, isCaseSensitive) { }
/// <summary> /// Creates the <see cref="PropertyFilter{T}"/>. /// </summary> /// <param name="propertyPath">The property path</param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> public PropertyFilter(string propertyPath, PredicateOperator @operator, object value) : this(propertyPath, @operator, value, null, false) { }
private IAsciiBasePropositionalOperator Process(IAsciiBasePropositionalOperator work) { var logic = work as IAsciiSinglePropositionalOperator; if (logic != null) { switch (logic.GetAsciiSymbol()) { case '>': var or = new OrPropositionalOperator(_manager); or.Instantiate(new [] { SurroundWithNot(logic.GetChilds()[0]), logic.GetChilds()[1] }); return(HandleOr(or)); case '=': var implication1 = new IfThenPropositionalOperator(_manager); implication1.Instantiate(new [] { logic.GetChilds()[0], logic.GetChilds()[1] }); var implication2 = new IfThenPropositionalOperator(_manager); implication2.Instantiate(new IAsciiBasePropositionalOperator[] { logic.GetChilds()[1], logic.GetChilds()[0] }); var and = new AndPropositionalOperator(_manager); and.Instantiate(new IAsciiBasePropositionalOperator[] { implication1, implication2 }); return(HandleAnd(and)); case '&': return(HandleAnd((AndPropositionalOperator)logic)); case '|': return(HandleOr((OrPropositionalOperator)logic)); case '~': return(logic); case '%': var nAnd = new AndPropositionalOperator(_manager); nAnd.Instantiate(logic.GetChilds()); return(SurroundWithNot(HandleAnd(nAnd))); case 'F': return(new TruePropositionalOperator(_manager)); case 'T': return(new FalsePropositionalOperator(_manager)); case '@': if (work is UniversalQuantifierOperator workUnversal) { var ext = new ExtensionalQuantifierOperator(_manager); ext.SetVariable(workUnversal.GetVariable()); ext.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) }); return(SurroundWithNot(ext)); } break; case '!': if (work is ExtensionalQuantifierOperator workExtensional) { var universal = new UniversalQuantifierOperator(_manager); universal.SetVariable(workExtensional.GetVariable()); universal.Instantiate(new[] { SurroundWithNot(logic.GetChilds()[0]) }); return(SurroundWithNot(universal)); } break; } } if (work is PredicateOperator predicate) { var result = new PredicateOperator(_manager); result.SetName(predicate.GetName()); foreach (var child in work.GetChilds()) { result.AddChild(Process(child)); } return(result); } if (work is ScalarPropositionalOperator scalar) { return(_manager.RequestOperator(scalar.GetName())); } throw new System.Exception("Operator not found"); }
public PredicatePair(string name, object value, PredicateOperator predicateOperator) { this.MemberName = name; this.Value = value; this.Operator = predicateOperator; }
public Predicate(string fieldName, PredicateOperator op, Element value) { this.FieldName = fieldName; this.Operator = op; this.Value = value; }
/// <summary> /// Creates the predicate expression. /// </summary> /// <typeparam name="T">The type</typeparam> /// <param name="propertyPath">The property path</param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> /// <returns>The predicate expresion</returns> public Expression <Predicate <T> > CreatePredicateExpression <T>(string propertyPath, PredicateOperator @operator, object value) { return(CreatePredicateExpression <T>(propertyPath, @operator, value, CultureInfo.InvariantCulture, false)); }
/// <summary> /// Creates a Predicate with can be "And" (true) or "Or" (false). /// </summary> /// <typeparam name="T">The generic Type</typeparam> /// <param name="startOperator">The start PredicateOperator (can be "And" or "Or").</param> /// <returns>Expression{Func{T, bool}}</returns> public static Expression <Func <T, bool> > Create <T>(PredicateOperator startOperator = PredicateOperator.Or) { return(f => startOperator == PredicateOperator.And); }
public override void ExitBinaryOpPredicate(MiniSqlParserParser.BinaryOpPredicateContext context) { var right = (Expr)_stack.Pop(); var comments = this.GetComments(context.op); var left = (Expr)_stack.Pop(); var opType = context.op.Type; PredicateOperator op = PredicateOperator.Equal; if (opType == MiniSqlParserLexer.ASSIGN) { op = PredicateOperator.Equal; } else if (opType == MiniSqlParserLexer.NOT_EQ2) { op = PredicateOperator.NotEqual; } else if (opType == MiniSqlParserLexer.LT) { op = PredicateOperator.Less; } else if (opType == MiniSqlParserLexer.LT_EQ) { op = PredicateOperator.LessOrEqual; } else if (opType == MiniSqlParserLexer.GT) { op = PredicateOperator.Greater; } else if (opType == MiniSqlParserLexer.GT_EQ) { op = PredicateOperator.GreaterOrEqual; } else if (opType == MiniSqlParserLexer.EQ) { op = PredicateOperator.Equal2; } else if (opType == MiniSqlParserLexer.NOT_EQ1) { op = PredicateOperator.NotEqual2; } else if (opType == MiniSqlParserLexer.AT_LT) { op = PredicateOperator.ContainsJsonValueL; } else if (opType == MiniSqlParserLexer.AT_GT) { op = PredicateOperator.ContainsJsonValueR; } else if (opType == MiniSqlParserLexer.QRY_PIPE) { op = PredicateOperator.ExistsJsonValue2; } else if (opType == MiniSqlParserLexer.QRY_AMP) { op = PredicateOperator.ExistsJsonValue3; } else { throw new CannotBuildASTException("Undifined PredicateOperator is used"); } var node = new BinaryOpPredicate(left, op, right, comments); _stack.Push(node); }
public override void ExitSubQueryPredicate(MiniSqlParserParser.SubQueryPredicateContext context) { var comments = this.GetComments(context); var query = (IQuery)_stack.Pop(); var opType2 = context.op2.Type; QueryQuantifier quantifier = QueryQuantifier.Any; if (opType2 == MiniSqlParserLexer.K_ANY) { quantifier = QueryQuantifier.Any; } else if (opType2 == MiniSqlParserLexer.K_SOME) { quantifier = QueryQuantifier.Some; } else if (opType2 == MiniSqlParserLexer.K_ALL) { quantifier = QueryQuantifier.All; } else { throw new CannotBuildASTException("Undifined QueryQuantifier is used"); } var opType1 = context.op1.Type; PredicateOperator operater = PredicateOperator.Equal; if (opType1 == MiniSqlParserLexer.ASSIGN) { operater = PredicateOperator.Equal; } else if (opType1 == MiniSqlParserLexer.NOT_EQ2) { operater = PredicateOperator.NotEqual; } else if (opType1 == MiniSqlParserLexer.LT) { operater = PredicateOperator.Less; } else if (opType1 == MiniSqlParserLexer.LT_EQ) { operater = PredicateOperator.LessOrEqual; } else if (opType1 == MiniSqlParserLexer.GT) { operater = PredicateOperator.Greater; } else if (opType1 == MiniSqlParserLexer.GT_EQ) { operater = PredicateOperator.GreaterOrEqual; } else if (opType1 == MiniSqlParserLexer.EQ) { operater = PredicateOperator.Equal2; } else if (opType1 == MiniSqlParserLexer.NOT_EQ1) { operater = PredicateOperator.NotEqual2; } else { throw new CannotBuildASTException("Undifined PredicateOperator is used"); } var operand = (Expr)_stack.Pop(); var node = new SubQueryPredicate(operand, operater, quantifier, query, comments); _stack.Push(node); }
/// <summary> /// Creates the predicate expression. /// </summary> /// <typeparam name="T">The type</typeparam> /// <param name="propertyPath">The property </param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> /// <param name="culture">The culture</param> /// <param name="isCaseSensitive">Checks if is case sensitive</param> /// <returns>The predicate expresion</returns> public Expression <Predicate <T> > CreatePredicateExpression <T>(string propertyPath, PredicateOperator @operator, object value, CultureInfo culture, bool isCaseSensitive) { if (propertyPath == null) { throw new ArgumentNullException(nameof(propertyPath)); } // p => p.FirstName == "Marie" var parameterExpression = CreateParameter(typeof(T)); // Type var memberExpression = CreateMember(parameterExpression, propertyPath); // property name value = TryConvert(memberExpression, value, culture); // convert value ? var constantExpression = CreateConstant(value); // value var bodyExpression = CreateBody(@operator, memberExpression, constantExpression, isCaseSensitive); // operator var lambdaExpression = Expression.Lambda <Predicate <T> >(bodyExpression, parameterExpression); return(lambdaExpression); }
/// <summary> /// Creates the <see cref="PropertyFilter{T}"/>. /// </summary> /// <param name="propertyPath">The property path</param> /// <param name="operator">The operator</param> /// <param name="value">The value</param> /// <param name="culture">The culture</param> public PropertyFilter(string propertyPath, PredicateOperator @operator, object value, CultureInfo culture) : this(propertyPath, @operator, value, culture, false) { }
/// <summary> /// Extends the specified source Predicate with another Predicate and the specified PredicateOperator. /// </summary> /// <typeparam name="T">The type</typeparam> /// <param name="first">The source Predicate.</param> /// <param name="second">The second Predicate.</param> /// <param name="op">The Operator (can be "And" or "Or").</param> /// <returns>Expression{Func{T, bool}}</returns> public static Expression <Func <T, bool> > Extend <T>(this Expression <Func <T, bool> > first, Expression <Func <T, bool> > second, PredicateOperator op = PredicateOperator.Or) { Guard.NotNull(first, nameof(first)); Guard.NotNull(second, nameof(second)); return(op == PredicateOperator.Or ? first.Or(second) : first.And(second)); }
public override string ToString() { return(PredicateOperator.GetAttributeDescription() + " " + PredicateOperand); }
/// <summary> /// Creates the body <see cref="Expression"/>. /// </summary> /// <param name="operator">The operator</param> /// <param name="left">The left expression</param> /// <param name="right">The right expression</param> /// <param name="isCaseSensitive">Checks if is case sensitive</param> /// <returns>The expression created</returns> public Expression CreateBody(PredicateOperator @operator, Expression left, Expression right, bool isCaseSensitive) { // p.FirstName == "Marie" Expression expression = null; switch (@operator) { case PredicateOperator.IsEqual: expression = Expression.Equal(left, right); break; case PredicateOperator.IsLessThan: expression = Expression.LessThan(left, right); break; case PredicateOperator.IsGreaterThan: expression = Expression.GreaterThan(left, right); break; case PredicateOperator.IsGreaterThanOrEqualTo: expression = Expression.GreaterThanOrEqual(left, right); break; case PredicateOperator.IsLessThanOrEqualTo: expression = Expression.LessThanOrEqual(left, right); break; case PredicateOperator.IsNotEqual: expression = Expression.NotEqual(left, right); break; case PredicateOperator.StartsWith: if (isCaseSensitive) { expression = Expression.Call(left, typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) }), right); } else { expression = Expression.Call(left, typeof(string).GetMethod("StartsWith", new Type[] { typeof(string), typeof(StringComparison) }), right, Expression.Constant(StringComparison.InvariantCultureIgnoreCase)); } break; case PredicateOperator.EndsWith: if (isCaseSensitive) { expression = Expression.Call(left, typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) }), right); } else { expression = Expression.Call(left, typeof(string).GetMethod("EndsWith", new Type[] { typeof(string), typeof(StringComparison) }), right, Expression.Constant(StringComparison.InvariantCultureIgnoreCase)); } break; case PredicateOperator.Contains: if (isCaseSensitive) { expression = Expression.Call(left, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), right); } else { expression = Expression.GreaterThanOrEqual(Expression.Call(left, typeof(string).GetMethod("IndexOf", new Type[] { typeof(string), typeof(StringComparison) }), right, Expression.Constant(StringComparison.InvariantCultureIgnoreCase)), Expression.Constant(0)); } break; case PredicateOperator.DoesNotContain: if (isCaseSensitive) { expression = Expression.Not(Expression.Call(left, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), right)); } else { expression = Expression.Equal(Expression.Call(left, typeof(string).GetMethod("IndexOf", new Type[] { typeof(string), typeof(StringComparison) }), right, Expression.Constant(StringComparison.InvariantCultureIgnoreCase)), Expression.Constant(-1)); } break; } return(expression); }