/// <summary>
/// 将表达式操作符转换为数据库可理解的字符串
/// </summary>
/// <param name="eo">表达式操作符</param>
/// <returns>字符串</returns>
public static string ToString(ExpressionOperation eo)
{
switch (eo)
{
case ExpressionOperation.大于:
return(">");
case ExpressionOperation.小于:
return("<");
case ExpressionOperation.等于:
return("=");
case ExpressionOperation.等于:
return("!=");
case ExpressionOperation.大于等于:
return(">=");
case ExpressionOperation.小于等于:
return("<=");
case ExpressionOperation.包含:
return("like");
case ExpressionOperation.是:
return("is");
case ExpressionOperation.是:
return("is not");
default:
throw new Exception("未知表达式操作符");
}
}
public SqlQueryConditionOperationBuilder(SqlQueryConditionBuilder parent, ExpressionOperation operation,
DocDef docDef, AttrDef attrDef)
{
Parent = parent;
Operation = operation;
DocDef = docDef;
AttrDef = attrDef;
}
public virtual IQueryCondition CreateCondition(Guid attributeId, ExpressionOperation operation, string source)
{
var condition = CreateConditionDef(attributeId, operation, source); //new QueryConditionDef {AttributeId = attributeId, Operation = operation, Exp = source};
AddCondition(condition);
return(new QueryConditionBuilder(this, condition));
}
internal virtual QueryConditionDef CreateConditionDef(Guid attrId, ExpressionOperation operation, string source)
{
if (Parent != null)
{
return(Parent.CreateConditionDef(attrId, operation, source));
}
throw new ApplicationException("Не могу создать Query ConditionDef");
}
public override IQueryCondition CreateCondition(string attribute, ExpressionOperation operation, string source)
{
var condition = CreateConditionDef(attribute, ExpressionOperation.And, source); // new QueryConditionDef {AttributeName = attribute, Operation = operation, Exp = source};
Parent.AddCondition(condition);
//Condition.WhereConditions.Add(condition);
return(new QueryConditionBuilder(this /*Parent*/, condition));
}
public static ExpressionBase GetOperation(char operationSymbol)
{
ExpressionBase expr;
if (!Expressions.TryGetValue(operationSymbol, out expr))
{
expr = Expressions[operationSymbol] = new ExpressionOperation(operationSymbol);
}
return(expr);
}
public IQueryCondition AddExpCondition(ExpressionOperation operation, string attribute)
{
var exp = new QueryConditionDef {
Operation = operation, Condition = ConditionOperation.Exp
};
AddCondition(exp);
var condition = CreateConditionDef(attribute, ExpressionOperation.And, ""); // new QueryConditionDef { AttributeName = attribute, Operation = ExpressionOperation.And };
exp.Conditions.Add(condition);
var expBuilder = new ExpressionBuilder(this, exp);
return(new QueryConditionBuilder(expBuilder, condition));
}
public SqlQueryCondition AddCondition(ExpressionOperation operation, SqlQuerySource source1, string attrDefName1, ConditionOperation condition, SqlQuerySource source2, string attrDefName2, SqlQueryCondition parentCondition = null)
{
var item = new SqlQueryCondition(operation, source1, attrDefName1, condition, source2, attrDefName2);
if (parentCondition == null)
{
Conditions.Add(item);
}
else
{
parentCondition.Conditions.Add(item);
}
return(item);
}
public SqlQueryCondition AddCondition(ExpressionOperation operation, SqlQuerySource source, string attrDefName, ConditionOperation condition, object value, SqlQueryCondition parentCondition = null)
{
var item = new SqlQueryCondition(source, operation, attrDefName, condition, value);
if (parentCondition == null)
{
Conditions.Add(item);
}
else
{
parentCondition.Conditions.Add(item);
}
return(item);
}
public SqlCondition AddCondition(ExpressionOperation operation, string exp)
{
var condition = new SqlCondition(operation, exp);
if (_currentWhereExp != null)
{
_currentWhereExp.AddCondition(condition);
}
else
{
if (WhereConditions == null)
{
WhereConditions = new List <SqlConditionItem>();
}
WhereConditions.Add(condition);
}
return(condition);
}
public SqlCondition AddHaving(ExpressionOperation operation, string exp)
{
var condition = new SqlCondition(operation, exp);
if (_currentHavingExp != null)
{
_currentHavingExp.AddCondition(condition);
}
else
{
if (HavingConditions == null)
{
HavingConditions = new List <SqlConditionItem>();
}
HavingConditions.Add(condition);
}
return(condition);
}
/// <summary>
/// Kolon Kolon Arama İşlemi
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
private Expression <Func <T, bool> > SearchSingleColumnQuery(List <Column> columns)
{
var filter = new Filter <T>();
foreach (Column col in columns)
{
if (col.search.value != null)
{
ExpressionOperationHelper operation = ExpressionOperation.GetExpressionOperation(
TypeofReferences <T> .GetType(col.name), col.search.value, null);
filter.By(
col.name,
operation.VOperation,
operation.Value,
Connector.And
);
}
}
return(filter);
}
public void SetConditionExpression(Guid id, string value)
{
ExpressionOperation exp;
if (ExpressionOperation.TryParse(value, out exp))
{
if (Context == null || Context.Def == null || Context.Def.Conditions == null)
{
return;
}
var condition = FindConditionDef(Context.Def, id);
if (condition == null)
{
return;
}
condition.Operation = exp;
}
}
internal override QueryConditionDef CreateConditionDef(Guid attrId, ExpressionOperation operation, string source)
{
var def = GetDef();
if (def != null)
{
var helper = new QueryDefHelper(def);
var sourceDef = String.IsNullOrEmpty(source) ? null /*def.Source*/ : helper.FindSource(source);
return(new QueryConditionDef
{
Operation = operation,
Left = new QueryConditionPartDef {
Attribute = helper.AddAttribute(attrId, sourceDef)
}
});
}
return(base.CreateConditionDef(attrId, operation, source));
}
public SqlExpression AddHavingExp(ExpressionOperation operation)
{
if (HavingConditions == null)
{
HavingConditions = new List <SqlConditionItem>();
}
var condition = new SqlExpression(operation);
if (_currentHavingExp != null)
{
_currentHavingExp.AddCondition(condition);
}
else
{
HavingConditions.Add(condition);
}
_currentHavingExp = condition;
return(condition);
}
private static ExpressionContainer CalculateContainer(ExpressionContainer container, System.Type operationType)
{
List <ExpressionElement> expression = container.GetExpression();
bool isComplited = false;
while (isComplited == false)
{
// Идея просчёт в том, что мы последовательно обходим всё выражение.
// Если нам попадаются простые операции(+, -), мы их пропускаем,
// если попались приоритетные операции, то мы их считаем и сразу удаляем
// из выражения записывая на их место результат.
isComplited = true;
for (int i = 0; i < expression.Count; i++)
{
ExpressionElement element = expression[i];
if (element is ExpressionNumber || element.GetType().IsSubclassOf(operationType) == false)
{
continue;
}
ExpressionOperation operation = (ExpressionOperation)element;
ExpressionNumber number1 = (ExpressionNumber)expression[i - 1];
ExpressionNumber number2 = (ExpressionNumber)expression[i + 1];
expression[i - 1] = new ExpressionNumber(operation.Calculate(number1, number2).ToString());
expression.Remove(expression[i + 1]);
expression.Remove(expression[i]);
isComplited = false;
break;
}
}
return(new ExpressionContainer(expression));
}
public QuerySystemCondition(SystemIdent ident, ExpressionOperation operation) :
base(operation)
{
Ident = ident;
}
public QueryAttributeCondition(string attributeName, ExpressionOperation operation) :
base(operation)
{
AttributeName = attributeName;
Conditions = new List <QueryCondition>();
}
public SqlConditionItem(ExpressionOperation operation)
{
Operation = operation;
}
public SqlExpression(ExpressionOperation operation) : base(operation)
{
}
public SqlCondition(ExpressionOperation operation, string expression)
: base(operation)
{
Expression = expression;
}
public SqlCondition AddHaving(ExpressionOperation operation, string exp, params object[] args)
{
return(AddHaving(operation, String.Format(exp, args)));
}
