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