/// <summary> /// Query condition /// </summary> public Q(object ColumnEnum, QueryOperator OpEnum, object Data) { SetColumnProperties(ColumnEnum, null); this.OpEnum = OpEnum; this.Data = Data; }
internal void AddOperator(QueryOperator queryOperator) { lock(_operatorsLock) { _operators.Add(queryOperator.Name, queryOperator); } }
private static String GetQueryOperator(QueryOperator queryOperator) { switch (queryOperator) { case QueryOperator.And: return " and "; case QueryOperator.Or: return " or "; } return ""; }
public override IFilter GetFilter(QueryOperator queryOperator) { return new InFilter { QueryOperator = queryOperator, FieldInternalName = Field.InternalName, FieldType = Field.Type.ToString(), FieldValues = Controls.Cast<TextBox>().Select( tb => tb.Text) }; }
/// <summary> /// Appends a single <see cref="QueryConstraint"/> instances linked /// by the associated <see cref="QueryOperator"/>. /// </summary> /// <param name="op">The op.</param> /// <param name="constraint">The constraint.</param> public void AppendConstraint(QueryOperator op, QueryConstraint constraint) { if (op == QueryOperator.None) { constraintBuilder.AppendLine(constraint.ToString()); } else { constraintBuilder.AppendLine(string.Format(" {0} {1}", GetOperatorChar(op), constraint.ToString())); } }
/// <summary> /// Initializes a new instance of the <see cref="QueryConstraint"/> class. /// </summary> /// <param name="columnName">Name of the column the constraint applies to.</param> /// <param name="constraintValue">The constraint value.</param> /// <param name="op">The <see cref="QueryOperator"/> used by the constraint.</param> public QueryConstraint(string columnName, object constraintValue, QueryOperator op) { constraintBuilder = new StringBuilder(); this.columnName = columnName; this.constraintValue = constraintValue; this.op = op; if (!string.IsNullOrEmpty(ToString())) { AppendConstraint(this); } }
public virtual IFilter GetFilter(QueryOperator queryOperator) { var filter = new Filter { QueryFilter = FilterOperator, QueryOperator = queryOperator, FieldInternalName = Field.InternalName, FieldType = Field.Type.ToString(), FieldValue = GetValue() }; UpdateFilter(filter); return filter; }
public CompositeExpression(QueryOperator @operator) : base(@operator) { Expressions = new List <QueryExpression>(); }
public GetAllMarketsResultsFilter(string Field, QueryOperator Operator, string Value, GetAllMarketsResultsFilter And) { this.Field = Field; this.Operator = Operator; this.Value = Value; this.And = And; }
/// <summary> /// Constructs an instance of QueryFilter with a single condition. /// More conditions can be added after initialization. /// </summary> /// <param name="attributeName">Target attribute name</param> /// <param name="op">Comparison operator</param> /// <param name="values">Attributes to compare</param> public QueryFilter(string attributeName, QueryOperator op, params DynamoDBEntry[] values) { AddCondition(attributeName, op, values); }
/// <summary> /// Adds a condition for a specified attribute that consists /// of an operator and any number of values /// </summary> /// <param name="attributeName">Target attribute name</param> /// <param name="op">Comparison operator</param> /// <param name="values">Values to compare to</param> public void AddCondition(string attributeName, QueryOperator op, params DynamoDBEntry[] values) { AddCondition(attributeName, new Condition { ComparisonOperator = EnumToStringMapper.Convert(op), AttributeValueList = ConvertToAttributeValues(values) }); }
public WhereClip Or(ExpressionClip left, QueryOperator op, ExpressionClip right) { bool toWrapBrackets = false; string sqlStr = left.Sql; while (sqlStr.IndexOf("] [") > 0) sqlStr = sqlStr.Substring(sqlStr.IndexOf("] [") + 2); left.Sql = sqlStr; if (sql.Length > 0) { sql.Append(" OR "); toWrapBrackets = true; } this.sql.Append(SqlQueryUtils.ToString(left)); this.sql.Append(SqlQueryUtils.ToString(op)); this.sql.Append(SqlQueryUtils.ToString(right)); SqlQueryUtils.AddParameters(this.parameters, left); SqlQueryUtils.AddParameters(this.parameters, right); if (toWrapBrackets) this.sql = new StringBuilder("(" + this.sql.ToString() + ")"); return this; }
private static bool TryConvertScanOperatorToQueryOperator(ScanOperator scanOperator, out QueryOperator result) { switch (scanOperator) { case ScanOperator.Equal: result = QueryOperator.Equal; break; case ScanOperator.GreaterThan: result = QueryOperator.GreaterThan; break; case ScanOperator.GreaterThanOrEqual: result = QueryOperator.GreaterThanOrEqual; break; case ScanOperator.LessThan: result = QueryOperator.LessThan; break; case ScanOperator.LessThanOrEqual: result = QueryOperator.LessThanOrEqual; break; case ScanOperator.BeginsWith: result = QueryOperator.BeginsWith; break; default: { result = QueryOperator.Equal; return false; } } return true; }
public void Where_Invalid(QueryOperator op, object value) { var query = GetEmptyQuery(); Assert.Throws <ArgumentException>(() => query.Where("x", op, value)); }
/// <summary> /// Constructs RangeFilter with the specified comparison /// operator and comparison values /// </summary> /// <param name="op">Comparison operator</param> /// <param name="values">Values to compare against</param> public RangeFilter(QueryOperator op, params Primitive[] values) : this(op, ConvertToAttributeValues(values)) { }
/// <summary> /// 组合 子查询 /// </summary> /// <param name="field"></param> /// <param name="from"></param> /// <param name="oper"></param> /// <returns></returns> private WhereClip subQuery(Field field, LambdaQueryHelper from, QueryOperator oper) { return(subQuery(field, from, DataUtils.ToString(oper))); }
IGraphQuery <T> IQueryBase <T, IGraphQuery <T> > .UsingDefaultOperator(QueryOperator queryOperator) { UsingDefaultOperator(queryOperator); return(this); }
IDocumentQuery <T> IDocumentQueryBase <T, IDocumentQuery <T> > .UsingDefaultOperator(QueryOperator queryOperator) { UsingDefaultOperator(queryOperator); return(this); }
public INetSqlQueryable <TEntity, TEntity2> Where <TKey>(Expression <Func <TEntity, TEntity2, TKey> > key, QueryOperator queryOperator, INetSqlQueryable queryable) { QueryBody.SetWhere(key, queryOperator, queryable); return(this); }
public BooleanQueryExpression(QueryOperator @operator, object left, object?right) : base(@operator) { Left = left; Right = right; }
/// <summary> /// Constructs RangeFilter with the specified comparison /// operator and comparison values /// </summary> /// <param name="op">Comparison operator</param> /// <param name="values">Values to compare against</param> public RangeFilter(QueryOperator op, List<AttributeValue> values) { Condition = new Condition() .WithComparisonOperator(EnumToStringMapper.Convert(op)) .WithAttributeValueList(values); }
public BooleanQuery(QueryOperator op, params Query[] clasues) { _clasues = clasues; Op = op; }
public ExpressionClip Append(QueryOperator op, ExpressionClip right) { this.sql.Append(SqlQueryUtils.ToString(op)); this.sql.Append(SqlQueryUtils.ToString(right)); SqlQueryUtils.AddParameters(this.parameters, right); return this; }
public static string Convert(QueryOperator value) { switch(value) { case QueryOperator.Equal: return "EQ"; case QueryOperator.LessThanOrEqual: return "LE"; case QueryOperator.LessThan: return "LT"; case QueryOperator.GreaterThanOrEqual: return "GE"; case QueryOperator.GreaterThan: return "GT"; case QueryOperator.BeginsWith: return "BEGINS_WITH"; case QueryOperator.Between: return "BETWEEN"; default: throw new ArgumentOutOfRangeException("Invalid QueryOperator value"); } }
/// <summary> /// Constructs RangeFilter with the specified comparison /// operator and comparison values /// </summary> /// <param name="op">Comparison operator</param> /// <param name="values">Values to compare against</param> public RangeFilter(QueryOperator op, List<AttributeValue> values) { Condition = new Condition { ComparisonOperator = EnumToStringMapper.Convert(op), AttributeValueList = values }; }
/// <summary> /// /// </summary> /// <param name="field"></param> /// <param name="value"></param> /// <param name="oper"></param> public WhereClip(Field field, object value, QueryOperator oper) : base(field, value, oper) { }
public static string ToString(QueryOperator op) { switch (op) { case QueryOperator.Add: return " + "; case QueryOperator.BitwiseAND: return " & "; case QueryOperator.BitwiseNOT: return " ~ "; case QueryOperator.BitwiseOR: return " | "; case QueryOperator.BitwiseXOR: return " ^ "; case QueryOperator.Divide: return " / "; case QueryOperator.Equal: return " = "; case QueryOperator.Greater: return " > "; case QueryOperator.GreaterOrEqual: return " >= "; case QueryOperator.IsNULL: return " IS NULL "; case QueryOperator.Less: return " < "; case QueryOperator.LessOrEqual: return " <= "; case QueryOperator.Like: return " LIKE "; case QueryOperator.Modulo: return " % "; case QueryOperator.Multiply: return " * "; case QueryOperator.NotEqual: return " <> "; case QueryOperator.Subtract: return " - "; } throw new NotSupportedException("Unknown QueryOperator: " + op.ToString() + "!"); }
/// <summary> ///Comments字段值 /// </summary> /// <param name="field">Comments字段</param> /// <param name="fieldValue">字段值</param> /// <param name="queryOperator">条件操作类型</param> /// <param name="queryCondition">条件关系</param> public CommentsWhereFields(CommentsFields field,object fieldValue, QueryCondition queryCondition,QueryOperator queryOperator) { this.field = field; this.fieldValue = fieldValue; this.queryOperator = queryOperator; this.queryCondition = queryCondition; }
/// <summary> /// Constructs an instance of QueryFilter with a single condition. /// More conditions can be added after initialization. /// </summary> /// <param name="attributeName">Target attribute name</param> /// <param name="op">Comparison operator</param> /// <param name="values">Attributes to compare</param> public QueryFilter(string attributeName, QueryOperator op, List<AttributeValue> values) { AddCondition(attributeName, op, values); }
/// <summary> ///JQResource字段值 /// </summary> /// <param name="field">JQResource字段</param> /// <param name="fieldValue">字段值</param> public JQResourceWhereFields(JQResourceFields field,object fieldValue) { this.field = field; this.fieldValue = fieldValue; this.queryOperator = QueryOperator.And; this.queryCondition = QueryCondition.Equal; }
/// <summary> /// Adds a condition for a specified attribute that consists /// of an operator and any number of AttributeValues. /// </summary> /// <param name="attributeName">Target attribute name</param> /// <param name="op">Comparison operator</param> /// <param name="values">AttributeValues to compare to</param> public void AddCondition(string attributeName, QueryOperator op, List<AttributeValue> values) { AddCondition(attributeName, new Condition { ComparisonOperator = EnumToStringMapper.Convert(op), AttributeValueList = values }); }
internal EntityQueryBuilder Or(IProperty property, PropertyValue value, QueryOperator oper = QueryOperator.Equals) { return(Or(property, value.GetStorageValue(), oper)); }
public MetaQueryItem(string fieldName, object fieldValue, QueryOperator fieldOperator) { MetaField = fieldName; MetaValue = fieldValue; MetaOperator = fieldOperator; }
public QueryExpression(QueryOperator @operator) { Operator = @operator; }
/// <summary> ///Comments字段值 /// </summary> /// <param name="field">Comments字段</param> /// <param name="fieldValue">字段值</param> public CommentsWhereFields(CommentsFields field,object fieldValue) { this.field = field; this.fieldValue = fieldValue; this.queryOperator = QueryOperator.And; this.queryCondition = QueryCondition.Equal; }
/// <summary> /// 构造函数 /// </summary> /// <param name="field"></param> /// <param name="value"></param> /// <param name="oper"></param> public Expression(Field field, object value, QueryOperator oper) : this(field, value, oper, true) { }
/// <summary> /// Initializes a ScanCondition with the target property, the /// comparison operator and values being tested against. /// </summary> /// <param name="propertyName">Name of the property</param> /// <param name="op">Comparison operator</param> /// <param name="values"> /// Value(s) being tested against. /// /// The values should be of the same type as the property. /// In the cases where the property is a collection, the values /// should be of the same type as the items in the collection. /// </param> public QueryCondition(string propertyName, QueryOperator op, params object[] values) { PropertyName = propertyName; Operator = op; Values = values; }
/// <summary> /// 构造函数 /// </summary> /// <param name="field"></param> /// <param name="value"></param> /// <param name="oper"></param> /// <param name="isFieldBefore"></param> public Expression(Field field, object value, QueryOperator oper, bool isFieldBefore) { if (!Field.IsNullOrEmpty(field)) { string valuestring = null; if (value is Expression) { Expression expression = (Expression)value; valuestring = expression.ToString(); parameters.AddRange(expression.Parameters); } else if (value is Field) { Field fieldValue = (Field)value; valuestring = fieldValue.TableFieldName; } else { valuestring = DataUtils.MakeUniqueKey(field); //valuestring = field.tableName + field.Name; Parameter p = new Parameter(valuestring, value, field.ParameterDbType, field.ParameterSize); parameters.Add(p); } if (isFieldBefore) { this.expressionString = string.Concat(field.TableFieldName, DataUtils.ToString(oper), valuestring); } else { this.expressionString = string.Concat(valuestring, DataUtils.ToString(oper), field.TableFieldName); } } }
/// <summary> ///JQResource字段值 /// </summary> /// <param name="field">JQResource字段</param> /// <param name="fieldValue">字段值</param> /// <param name="queryOperator">条件操作类型</param> /// <param name="queryCondition">条件关系</param> public JQResourceWhereFields(JQResourceFields field,object fieldValue, QueryCondition queryCondition,QueryOperator queryOperator) { this.field = field; this.fieldValue = fieldValue; this.queryOperator = queryOperator; this.queryCondition = queryCondition; }
private static WhereClip LeftAndRight(BinaryExpression be, QueryOperator co, WhereType wtype = WhereType.Where) { ColumnFunction leftFunction; ColumnFunction rightFunction; MemberExpression leftMe = null; MemberExpression rightMe; System.Linq.Expressions.Expression expLeft = be.Left; System.Linq.Expressions.Expression expRight = be.Right; if (be.Left.NodeType == ExpressionType.Convert) { expLeft = ((UnaryExpression)be.Left).Operand; } if (be.Right.NodeType == ExpressionType.Convert) { expRight = ((UnaryExpression)be.Right).Operand; } var isAgain = false; Again: if (expLeft.NodeType == ExpressionType.Constant || (expLeft.NodeType == ExpressionType.MemberAccess && ((MemberExpression)expLeft).Expression == null) || isAgain) { if (expRight.NodeType == ExpressionType.Constant || (expRight.NodeType == ExpressionType.MemberAccess && ((MemberExpression)expRight).Expression == null)) { return(DataUtils.ConvertValue <bool>(fastEvaluator.Eval(be)) ? new WhereClip(" 1=2 ") : new WhereClip(" 1=1 ")); } else { var keyRightName = GetMemberName(expRight, out rightFunction, out rightMe); if (expLeft.NodeType == ExpressionType.MemberAccess) { var left = (MemberExpression)expLeft; if (left.Expression != null && (wtype == WhereType.JoinWhere || left.Expression.ToString() == rightMe.Expression.ToString())) { ColumnFunction functionLeft; var keyLeft = GetMemberName(expLeft, out functionLeft, out left); if (keyRightName.Contains("$")) { return(new WhereClip(new Field(keyLeft, GetTableName(left.Expression.Type)), GetValue(expRight), co)); } else { return(new WhereClip(new Field(keyRightName, GetTableName(rightMe.Expression.Type)), new Field(keyLeft, GetTableName(left.Expression.Type)), co)); } } } object value = GetValue(expLeft); if (keyRightName.Contains("$")) { if (DataUtils.ConvertValue <bool>(fastEvaluator.Eval(be))) { return(new WhereClip(" 1=2 ")); } return(new WhereClip(" 1=1 ")); } if (value != null) { return(new WhereClip(new Field(keyRightName, GetTableName(rightMe.Expression.Type)), value, co)); } switch (co) { case QueryOperator.Equal: return(new Field(keyRightName, GetTableName(rightMe.Expression.Type)).IsNull()); case QueryOperator.NotEqual: return(new Field(keyRightName, GetTableName(rightMe.Expression.Type)).IsNotNull()); } throw new Exception("null值只支持等于或不等于!出错比较符:" + co.ToString()); } } else { var key = ""; try { key = GetMemberName(expLeft, out leftFunction, out leftMe); if (key.Contains("$")) { isAgain = true; goto Again; } } catch (Exception) { isAgain = true; goto Again; } if (expRight.NodeType == ExpressionType.MemberAccess) { var right = (MemberExpression)expRight; if (right.Expression != null && (wtype == WhereType.JoinWhere || right.Expression == leftMe.Expression)) { ColumnFunction functionRight; var keyRight = GetMemberName(expRight, out functionRight, out right); return(new WhereClip( new Field(key, GetTableName(leftMe.Expression.Type)), new Field(keyRight, GetTableName(right.Expression.Type)) , co)); } } object value = GetValue(expRight); if (value == null) { if (co == QueryOperator.Equal) { return(new Field(key, GetTableName(leftMe.Expression.Type)).IsNull()); } if (co == QueryOperator.NotEqual) { return(new Field(key, GetTableName(leftMe.Expression.Type)).IsNotNull()); } throw new Exception("null值只支持等于或不等于!"); } return(new WhereClip(new Field(key, GetTableName(leftMe.Expression.Type)), value, co)); } }