public WhereItem(WhereType whereType, string name, object value)
{
WhereType = whereType;
Name = name;
Value = value;
UniqueKey = Guid.NewGuid().ToString().Replace("-", "");
}
public void AddAction(string playerA, string playerB, ActionType actionType, ModifierType modifyer, Weapon weapon, WhereType where, ArmyType teamA, ArmyType teamB)
{
Player playerGet = getPlayer(playerA, teamA);
Player playerDo = null;
//damage from the world (harrier, falling) will not be considered in this version
if (playerB == string.Empty)
{
playerDo = playerGet;
} else
{
playerDo = getPlayer(playerB, teamB);
}
switch (actionType)
{
case ActionType.Kill:
playerGet.AddAction(playerDo, ActionType.Die, modifyer, weapon, where);
playerDo.AddAction(playerGet, ActionType.Kill, modifyer, weapon, where);
break;
case ActionType.Damage:
playerGet.AddAction(playerDo, ActionType.Damage, modifyer, weapon, where);
playerDo.AddAction(playerGet, ActionType.Damage, modifyer, weapon, where);
break;
}
}
private void CreateExpression(WhereType type, string column, string value, string prefix = "", string postfix = "")
{
IWhere exp = new Where(type, LogicOperator)
{
Column = column,
IsColumn = true,
IsRaw = false,
Value = value,
Prefix = prefix,
Postfix = postfix,
TableAlias = TableAlias
};
Append(exp);
}
public DWhere(WhereType type, string fieldName, params object[] values)
{
WhereType = type;
FieldName = fieldName;
if (type == WhereType.Field)
{
CompareTo = Convert.ToString(GetParamVal(values, 0));
return;
}
var firstValue = new FieldVariant(GetParamVal(values, 0));
if (type == WhereType.Equal)
{
CompareTo = firstValue.Value();
}
}
private JoinSqlBuilder <TNewPoco, TBasePoco> WhereInternal <T>(WhereType whereType, Expression <Func <T, bool> > where)
{
Type associatedType = this.PreviousAssociatedType(typeof(T), typeof(T));
if (associatedType == null)
{
throw new Exception("Either the source or destination table should be associated ");
}
var ev = OrmLiteConfig.DialectProvider.ExpressionVisitor <T>();
ev.WhereStatementWithoutWhereString = true;
ev.PrefixFieldWithTableName = true;
ev.Where(where);
var str = ev.WhereExpression;
if (String.IsNullOrEmpty(str) == false)
{
this.whereList.Add(new KeyValuePair <string, WhereType>(str, whereType));
}
return(this);
}
internal static string WhereTypeToString(WhereType type, bool isFirst)
{
if (isFirst && (type == WhereType.Or || type == WhereType.OrNot ||
type == WhereType.OrHaving || type == WhereType.OrNotHaving))
{
throw new InvalidOperationException("No 'Where' (or 'And') is added just yet, why are you adding an 'Or'?");
}
return(type switch
{
WhereType.And => isFirst ? "where" : "and",
WhereType.Or => "or",
WhereType.AndNot => isFirst ? "where not" : "and not",
WhereType.OrNot => "or not",
WhereType.AndHaving => isFirst ? "having" : "and",
WhereType.OrHaving => "or",
WhereType.AndNotHaving => isFirst ? "having not" : "and not",
WhereType.OrNotHaving => "or not",
_ => throw new NotImplementedException(),
});
public string GetExpression(WhereType whereType, string paramName)
{
switch (whereType)
{
case WhereType.IsNull:
case WhereType.IsNotNull:
return(GetSelector(whereType));
case WhereType.Eq:
case WhereType.NotEq:
case WhereType.Gt:
case WhereType.Lt:
case WhereType.GtEq:
case WhereType.LtEq:
case WhereType.In:
case WhereType.Like:
case WhereType.NotIn:
return($"{GetSelector(whereType)} {paramName}");
default:
throw new ArgumentOutOfRangeException(nameof(whereType));
}
}
public string GetExpression(WhereType whereType, string paramName)
{
switch (whereType)
{
case WhereType.IsNull:
case WhereType.IsNotNull:
return(GetSelector(whereType));
case WhereType.Eq:
case WhereType.NotEq:
case WhereType.Gt:
case WhereType.Lt:
case WhereType.GtEq:
case WhereType.LtEq:
case WhereType.In:
case WhereType.Like:
case WhereType.NotIn:
return(string.Format("{0} {1}", GetSelector(whereType), paramName));
default:
throw new ArgumentOutOfRangeException("whereType");
}
}
public bool IsWithoutValue(WhereType whereType)
{
switch (whereType)
{
case WhereType.Eq:
case WhereType.NotEq:
case WhereType.Gt:
case WhereType.Lt:
case WhereType.GtEq:
case WhereType.LtEq:
case WhereType.Like:
case WhereType.In:
case WhereType.NotIn:
return(false);
case WhereType.IsNull:
case WhereType.IsNotNull:
return(true);
default:
throw new ArgumentOutOfRangeException("whereType");
}
}
public Where(WhereType type, object s)
{
this.Type = type;
this.SingleObject = s;
}
public void AddAction(Player playerTo, ActionType actionType, ModifierType modifier, Weapon weapon, WhereType where)
{
listAction.Add(new Action() { PlayerTo = playerTo, ActionType = actionType, Modifier = modifier, Weapon = weapon, Where = where});
}
public QWhereCondition()
{
whereType = WhereType.None;
}
/// <summary>
///
/// </summary>
internal QWhereCondition()
{
whereType = WhereType.None;
}
private static WhereClip ToWhereClipChild(System.Linq.Expressions.Expression e, WhereType wt = WhereType.Where)
{
if (e is BinaryExpression)
{
return(ConvertBinary((BinaryExpression)e, wt));
}
if (e is MethodCallExpression)
{
return(ConvertMethodCall((MethodCallExpression)e));
}
if (e is UnaryExpression)
{
return(ConvertUnary((UnaryExpression)e));
}
if (IsBoolFieldOrProperty(e))
{
var key = ((MemberExpression)e).Member.Name;
return(new WhereClip());
}
if (e is ConstantExpression)
{
var key = ((ConstantExpression)e).Value;
if (DataUtils.ConvertValue <bool>(key))
{
return(new WhereClip(" 1=1 "));
}
return(new WhereClip(" 1=2 "));
}
throw new Exception("暂时不支持的Where条件Lambda表达式写法！请使用经典写法！");
}
private static ExpEnity <T> Where <T>(this ExpEnity <T> expr1, Expression <Func <T, bool> > expr2, WhereType type)
{
var expr1Body = expr1.WhereExprBody;
var name = $"{expr2.Parameters[0].Name}.";
var bodyContent = Resolve(expr2).Replace(name, "");
foreach (var item in _whereFilter)
{
bodyContent = bodyContent.Replace(item.Key, item.Value);
}
var right = Expression.Constant(
$"( {bodyContent} )"
);
if (string.IsNullOrEmpty(expr1Body))
{
expr1.WhereExpr = Expression.Lambda <Func <string> >(Expression.Constant($"{right}"));
}
else
{
expr1.WhereExpr = Expression.Lambda <Func <string> >(Expression.Constant($"{expr1Body} {type.ToString()} {right}"));
}
return(expr1);
}
/// <summary>
///
/// </summary>
/// <param name="c1"></param>
/// <param name="whereType"></param>
/// <param name="c2"></param>
internal QWhereCondition(QCondition c1, WhereType whereType, QCondition c2)
{
leftCondition = c1;
this.whereType = whereType;
rightCondition = c2;
}
/// <summary>
/// 分页查询
/// </summary>
/// <param name="pageInfo"></param>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="sQL"></param>
/// <returns></returns>
public virtual PageInfo <T> SelectPage <T>(PageInfo <T> pageInfo, string cols, string whereCol, WhereType whereType)
{
return(baseDAL.SelectPage(pageInfo, cols, whereCol, whereType));
}
/// <summary>
/// 创建修改语句
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <param name="cols"></param>
/// <param name="strWhere">修改语句的条件/列【逗号隔开】</param>
/// <returns></returns>
public static SqlModel UpdateSql <T>(T t, string cols, string strWhere, WhereType whereType)
{
Type type = typeof(T);
PrimaryKeyAttribute primaryKeyAttribute = type.GetPrimaryKey();
string primaryKeyName = primaryKeyAttribute.ColumnName;
PropertyInfo[] propertyInfos = PropertyHelper.GetProperties <T>(cols);
//生成要插入的列 $的出现｛｝就是占位符 里面就可以放变量
string colums = string.Join(",", propertyInfos.Where(p => !p.IsPrimaryKey() && p.IsExist()).Select(p => string.Format("[{0}]=@{0}", p.GetColumnName())));
bool isSql = WhereType.Columns.Equals(whereType);
if (isSql && !string.IsNullOrEmpty(strWhere))
{
PropertyInfo[] whereProp = PropertyHelper.GetProperties <T>(strWhere);
strWhere = string.Join(" and ", whereProp.Where(p => !p.IsPrimaryKey()).Select(p => string.Format("[{0}]=@{0}", p.GetColumnName())));
//合并两个数组 [去掉交集]
List <PropertyInfo> newsProps = new List <PropertyInfo>(propertyInfos);
bool flag = true;
for (int w = 0; w < whereProp.Length; w++)
{
for (int i = 0; i < newsProps.Count; i++)
{
if (newsProps[i].Name == whereProp[w].Name)
{
flag = false;
}
}
if (flag)
{
newsProps.Add(whereProp[w]);
}
}
propertyInfos = newsProps.ToArray();
}
//生成插入的参数
string paramColums = string.Join(",", propertyInfos.Where(p => !p.IsPrimaryKey()).Select(p => $"@{p.GetColumnName()}"));
//生成参数数组
SQLiteParameter[] arrParams = CreateParameters(propertyInfos, t);
//默认更加主键修改
if (string.IsNullOrEmpty(strWhere))
{
strWhere = $"{primaryKeyName} =@{primaryKeyName}";
}
string sql = $" UPDATE [{type.GetTableName()}] SET {colums} WHERE {strWhere} ";
SqlModel sqlModel = new SqlModel()
{
Sql = sql,
SqlParameters = arrParams
};
return(sqlModel);
}
/// <summary>
/// 查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public virtual List <T> SelectList <T>(T t, string cols, string whereCol, WhereType whereType)
{
return(baseDAL.SelectList(t, cols, whereCol, whereType));
}
/// <summary>
/// 分页查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="pageInfo"></param>
/// <param name="cols"></param>
/// <param name="whereCols">column1='column1' and column2 ='column2'</param>
/// <param name="whereType"></param>
/// <returns></returns>
public static SqlModel SelectSqlByPage <T>(PageInfo <T> pageInfo, string cols, string whereCols, WhereType whereType)
{
Type type = typeof(T);
PropertyInfo[] propertyInfos = PropertyHelper.GetProperties <T>(cols);
string colums = string.Join(",", propertyInfos.Where(p => p.IsExist()).Select(p => $"[{p.GetColumnName()}]"));
bool isSql = WhereType.Columns.Equals(whereType);
int start = pageInfo.CurrentPage > 1 ? pageInfo.CurrentPage - 1 : 0;
int offlimit = start * pageInfo.PageSize;//
if (isSql && !string.IsNullOrEmpty(whereCols))
{
PropertyInfo[] whereProp = PropertyHelper.GetProperties <T>(whereCols);
whereCols = string.Join(",", whereProp.Where(p => !p.IsPrimaryKey()).Select(p => string.Format("[{0}]=@{0}", p.GetColumnName())));
//合并两个数组 [去掉交集]
List <PropertyInfo> newsProps = new List <PropertyInfo>(propertyInfos);
bool flag = true;
for (int w = 0; w < whereProp.Length; w++)
{
for (int i = 0; i < newsProps.Count; i++)
{
if (newsProps[i].Name == whereProp[w].Name)
{
flag = false;
}
}
if (flag)
{
newsProps.Add(whereProp[w]);
}
}
propertyInfos = newsProps.ToArray();
}
//生成参数数组
SQLiteParameter[] arrParams = CreateParameters(propertyInfos, pageInfo.ParamsSearch);
if (string.IsNullOrEmpty(whereCols))
{
whereCols = " 1=1 ";
}
string sql = $"SELECT {colums} FROM [{type.GetTableName()}] WHERE {whereCols} limit {offlimit},{pageInfo.PageSize}";
SqlModel sqlModel = new SqlModel()
{
Sql = sql,
SqlParameters = arrParams
};
return(sqlModel);
}
public Where(WhereType type, object s, IEnumerable<Order> orders)
{
this.Type = type;
this.SingleObject = s;
this.Orders = new List<Order>(orders);
}
/// <summary>
/// 分页查询
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="whereCols">查询条件</typeparam>
/// <param name="t"></param>
/// <returns></returns>
public PageInfo <T> SelectPage <T>(PageInfo <T> pageInfo, string cols, string whereCols, WhereType whereType)
{
SqlModel selectModel = CreateSqlHelper.SelectSqlByPage(pageInfo, cols, whereCols, whereType);
DataTable dataTable = SQLiteHelper.ExecuteDataTable(selectModel.Sql, false, selectModel.SqlParameters);
List <T> lists = DbConvert.TableToList <T>(dataTable);
SqlModel selectCountModel = CreateSqlHelper.SelectCount(pageInfo.ParamsSearch, whereCols, whereType);
object result = SQLiteHelper.ExecuteScalar(selectCountModel.Sql, false, selectCountModel.SqlParameters);
int total = Convert.ToInt32(result);
int totalPage = 0;
if (total % pageInfo.PageSize == 0)
{
totalPage = total / pageInfo.PageSize;
}
else
{
totalPage = total / pageInfo.PageSize + 1;
}
pageInfo.TotalPage = totalPage;
pageInfo.Records = lists;
pageInfo.CurrentCount = total;
//lists.Count;
return(pageInfo);
}
public Where(WhereType type, object s)
{
this.Type = type;
this.SingleObject = s;
}
private IComparisonQueryBuilder PrepareHavingLeaf(WhereType type, string column)
{
_preparedLeaf = (type, column, _query.HavingForest);
return(this);
}
public Where(WhereType type, object s, IEnumerable <Order> orders)
{
this.Type = type;
this.SingleObject = s;
this.Orders = new List <Order>(orders);
}
/// <summary>
///
/// </summary>
/// <param name="ue"></param>
/// <param name="wtype"></param>
/// <returns></returns>
private static WhereOperation ConvertUnary(string tableName, UnaryExpression ue, WhereType wtype = WhereType.Where)
{
switch (ue.NodeType)
{
case ExpressionType.Not:
return(!ToWhereOperationChild(tableName, ue.Operand, wtype));
}
throw new Exception("暂时不支持的NodeType(" + ue.NodeType + ") lambda写法！请使用经典写法！");
}
private static WhereOperation ConvertBinary(string tableName, BinaryExpression be, WhereType wt = WhereType.Where)
{
switch (be.NodeType)
{
case ExpressionType.Equal:
return(LeftAndRight(tableName, be, QueryOperator.Equal, wt));
case ExpressionType.GreaterThan:
return(LeftAndRight(tableName, be, QueryOperator.Greater, wt));
case ExpressionType.GreaterThanOrEqual:
return(LeftAndRight(tableName, be, QueryOperator.GreaterOrEqual, wt));
case ExpressionType.LessThan:
return(LeftAndRight(tableName, be, QueryOperator.Less, wt));
case ExpressionType.LessThanOrEqual:
return(LeftAndRight(tableName, be, QueryOperator.LessOrEqual, wt));
case ExpressionType.NotEqual:
return(LeftAndRight(tableName, be, QueryOperator.NotEqual, wt));
case ExpressionType.AndAlso:
return(ToWhereOperationChild(tableName, be.Left, wt) && ToWhereOperationChild(tableName, be.Right, wt));
case ExpressionType.OrElse:
return(ToWhereOperationChild(tableName, be.Left, wt) || ToWhereOperationChild(tableName, be.Right, wt));
default:
throw new Exception("暂时不支持的Where条件(" + be.NodeType + ")Lambda表达式写法！请使用经典写法！");
}
}
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, left.Expression.Type), GetValue(expRight), co));
}
else
{
return(new WhereClip(new Field(keyRightName, rightMe.Expression.Type), new Field(keyLeft, 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, rightMe.Expression.Type), value, co));
}
switch (co)
{
case QueryOperator.Equal:
return(new Field(keyRightName, rightMe.Expression.Type).IsNull());
case QueryOperator.NotEqual:
return(new Field(keyRightName, 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, leftMe.Expression.Type),
new Field(keyRight, right.Expression.Type)
, co));
}
}
object value = GetValue(expRight);
if (value == null)
{
if (co == QueryOperator.Equal)
{
return(new Field(key, leftMe.Expression.Type).IsNull());
}
if (co == QueryOperator.NotEqual)
{
return(new Field(key, leftMe.Expression.Type).IsNotNull());
}
throw new Exception("null值只支持等于或不等于！");
}
return(new WhereClip(new Field(key, leftMe.Expression.Type), value, co));
}
}
private static WhereOperation ToWhereOperationChild(string tableName, System.Linq.Expressions.Expression e, WhereType wt = WhereType.Where)
{
if (e is BinaryExpression)
{
return(ConvertBinary(tableName, (BinaryExpression)e, wt));
}
if (e is MethodCallExpression)
{
return(ConvertMethodCall(tableName, (MethodCallExpression)e));
}
if (e is UnaryExpression)
{
return(ConvertUnary(tableName, (UnaryExpression)e));
}
if (IsBoolFieldOrProperty(e))
{
var d = (MemberExpression)e;
return(new WhereOperation(new Field(d.Member.Name), true, QueryOperator.Equal));
}
if (e is ConstantExpression)
{
var key = ((ConstantExpression)e).Value;
if (DataUtils.ConvertValue <bool>(key))
{
return(new WhereOperation(" 1=1 "));
}
return(new WhereOperation(" 1=2 "));
}
throw new Exception("暂时不支持的Where条件Lambda表达式写法！请使用经典写法！");
}
public static IQueryable <T> Where <T, K>(IQueryable <T> entity, string field, K query, WhereType whereType)
{
// Get the method information for the EnumType method
MethodInfo mi = typeof(K).GetMethod(Enum.GetName(typeof(WhereType), whereType), new Type[] { typeof(K) });
// Build the parameter for the expression
ParameterExpression X = Expression.Parameter(typeof(T), "x");
// Build the member that was specified for the expression
MemberExpression meField = Expression.PropertyOrField(X, field);
// Call the Type Method method on the member
MethodCallExpression filter = Expression.Call(meField, mi, Expression.Constant(query));
// Build the expression
Expression <Func <T, bool> > expression = Expression.Lambda <Func <T, bool> >(filter, X);
// Perform the search logic and return the results
return(entity.Where(expression));
}
public static WhereItem IsEqualTo(this string inner, WhereType whereType, object value)
{
return new WhereItem(whereType, inner, value);
}
/// <summary>
/// Initializes a new instance of the <see cref="WhereModel"/> with the specified <see cref="WhereType"/>
/// </summary>
/// <param name="whereType">Current <see cref="WhereType"/> type.</param>
protected WhereModel(WhereType whereType)
{
Type = whereType;
}
public Where(WhereType type, List <IWhere> whereForest)
{
Type = type;
WhereForest = whereForest;
}
