6335 lines
262 KiB
C#
6335 lines
262 KiB
C#
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Data;
|
||
using System.Data.SqlClient;
|
||
using System.Linq;
|
||
using System.Linq.Expressions;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
using System.Reflection;
|
||
using System.Dynamic;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace SqlSugar
|
||
{
|
||
#region T1
|
||
public partial class QueryableProvider<T> : QueryableAccessory, ISugarQueryable<T>
|
||
{
|
||
public SqlSugarProvider Context { get; set; }
|
||
public IAdo Db { get { return Context.Ado; } }
|
||
public IDbBind Bind { get { return this.Db.DbBind; } }
|
||
public ISqlBuilder SqlBuilder { get; set; }
|
||
public MappingTableList OldMappingTableList { get; set; }
|
||
public MappingTableList QueryableMappingTableList { get; set; }
|
||
public Action<T> MapperAction { get; set; }
|
||
public Action<T, MapperCache<T>> MapperActionWithCache { get; set; }
|
||
public List<Action<List<T>>> Mappers { get; set; }
|
||
public bool IsCache { get; set; }
|
||
public int CacheTime { get; set; }
|
||
public bool IsAs { get; set; }
|
||
public QueryBuilder QueryBuilder
|
||
{
|
||
get
|
||
{
|
||
return this.SqlBuilder.QueryBuilder;
|
||
}
|
||
set
|
||
{
|
||
this.SqlBuilder.QueryBuilder = value;
|
||
}
|
||
}
|
||
public EntityInfo EntityInfo
|
||
{
|
||
get
|
||
{
|
||
return this.Context.EntityMaintenance.GetEntityInfo<T>();
|
||
}
|
||
}
|
||
public void Clear()
|
||
{
|
||
QueryBuilder.Clear();
|
||
}
|
||
public ISugarQueryable<T> IgnoreColumns(Expression<Func<T, object>> columns)
|
||
{
|
||
var ignoreColumns = QueryBuilder.GetExpressionValue(columns, ResolveExpressType.ArraySingle).GetResultArray().Select(it => this.SqlBuilder.GetNoTranslationColumnName(it).ToLower()).ToList();
|
||
return IgnoreColumns(ignoreColumns.ToArray());
|
||
}
|
||
public ISugarQueryable<T> IgnoreColumns(params string[] columns)
|
||
{
|
||
if (QueryBuilder.IgnoreColumns.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.IgnoreColumns = new List<string>();
|
||
}
|
||
QueryBuilder.IgnoreColumns.AddRange(columns);
|
||
return this;
|
||
}
|
||
public void AddQueue()
|
||
{
|
||
var sqlObj = this.ToSql();
|
||
this.Context.Queues.Add(sqlObj.Key, sqlObj.Value);
|
||
}
|
||
public ISugarQueryable<T> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T>().WithCacheIF(IsCache, CacheTime);
|
||
CopyQueryBuilder(queryable.QueryBuilder);
|
||
((QueryableProvider<T>)queryable).MapperAction = this.MapperAction;
|
||
((QueryableProvider<T>)queryable).MapperActionWithCache = this.MapperActionWithCache;
|
||
((QueryableProvider<T>)queryable).Mappers = this.Mappers;
|
||
return queryable;
|
||
}
|
||
public virtual ISugarQueryable<T> AS<T2>(string tableName)
|
||
{
|
||
var entityName = typeof(T2).Name;
|
||
return _As(tableName, entityName);
|
||
}
|
||
public ISugarQueryable<T> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
return _As(tableName, entityName);
|
||
}
|
||
public virtual ISugarQueryable<T> With(string withString)
|
||
{
|
||
QueryBuilder.TableWithString = withString;
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Mapper(Action<T> mapperAction)
|
||
{
|
||
this.MapperAction = mapperAction;
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> Mapper(Action<T, MapperCache<T>> mapperAction)
|
||
{
|
||
this.MapperActionWithCache = mapperAction;
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T> Mapper<TObject>(Expression<Func<T, TObject>> mapperObject, Expression<Func<T, object>> mainField, Expression<Func<T, object>> childField)
|
||
{
|
||
return _Mapper<TObject>(mapperObject, mainField, childField);
|
||
}
|
||
public ISugarQueryable<T> Mapper<TObject>(Expression<Func<T, List<TObject>>> mapperObject, Expression<Func<T, object>> mainField, Expression<Func<T, object>> childField)
|
||
{
|
||
return _Mapper<TObject>(mapperObject, mainField, childField);
|
||
}
|
||
public virtual ISugarQueryable<T> Mapper<TObject>(Expression<Func<T, List<TObject>>> mapperObject, Expression<Func<T, object>> mapperField)
|
||
{
|
||
return _Mapper<TObject>(mapperObject, mapperField);
|
||
}
|
||
public virtual ISugarQueryable<T> Mapper<TObject>(Expression<Func<T, TObject>> mapperObject, Expression<Func<T, object>> mapperField)
|
||
{
|
||
return _Mapper<TObject>(mapperObject, mapperField);
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> AddParameters(SugarParameter parameter)
|
||
{
|
||
if (parameter != null)
|
||
QueryBuilder.Parameters.Add(parameter);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public ISugarQueryable<T> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
return WhereClass(new List<ClassType>() { whereClass }, ignoreDefaultValue);
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public ISugarQueryable<T> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
if (whereClassTypes.HasValue())
|
||
{
|
||
var columns = this.Context.EntityMaintenance.GetEntityInfo<ClassType>().Columns.Where(it => it.IsIgnore == false).ToList();
|
||
List<IConditionalModel> whereModels = new List<IConditionalModel>();
|
||
foreach (var item in whereClassTypes)
|
||
{
|
||
var cons = new ConditionalCollections();
|
||
foreach (var column in columns)
|
||
{
|
||
|
||
var value = column.PropertyInfo.GetValue(item, null);
|
||
WhereType WhereType = WhereType.And;
|
||
var isNotNull = ignoreDefaultValue == false && value != null;
|
||
var isNotNullAndDefault = ignoreDefaultValue && value != null && value.ObjToString() != UtilMethods.DefaultForType(column.PropertyInfo.PropertyType).ObjToString();
|
||
if (isNotNull || isNotNullAndDefault)
|
||
{
|
||
if (cons.ConditionalList == null)
|
||
{
|
||
cons.ConditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>();
|
||
if (QueryBuilder.WhereInfos.IsNullOrEmpty() && whereModels.IsNullOrEmpty())
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
WhereType = WhereType.Or;
|
||
}
|
||
|
||
}
|
||
cons.ConditionalList.Add(new KeyValuePair<WhereType, ConditionalModel>(WhereType, new ConditionalModel()
|
||
{
|
||
ConditionalType = ConditionalType.Equal,
|
||
FieldName = column.DbColumnName,
|
||
FieldValue = value.ObjToString()
|
||
}));
|
||
}
|
||
}
|
||
if (cons.HasValue())
|
||
{
|
||
whereModels.Add(cons);
|
||
}
|
||
}
|
||
this.Where(whereModels);
|
||
}
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
this._Where(expression);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> Where(string whereString, object whereObj = null)
|
||
{
|
||
if (whereString.HasValue())
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
if (conditionalModels.IsNullOrEmpty()) return this;
|
||
var sqlObj = this.SqlBuilder.ConditionalModelToSql(conditionalModels);
|
||
return this.Where(sqlObj.Key, sqlObj.Value);
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Where<T2>(string whereString, object whereObj = null)
|
||
{
|
||
var whereValue = QueryBuilder.WhereInfos;
|
||
whereValue.Add(SqlBuilder.AppendWhereOrAnd(whereValue.Count == 0, whereString + UtilConstants.Space));
|
||
if (whereObj != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(whereObj));
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Having(Expression<Func<T, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> Having(string whereString, object parameters = null)
|
||
{
|
||
|
||
QueryBuilder.HavingInfos = SqlBuilder.AppendHaving(whereString);
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (!isWhere) return this;
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> WhereIF(bool isWhere, string whereString, object whereObj = null)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public virtual T InSingle(object pkValue)
|
||
{
|
||
Check.Exception(this.QueryBuilder.SelectValue.HasValue(), "'InSingle' and' Select' can't be used together,You can use .Select(it=>...).Single(it.id==1)");
|
||
var list = In(pkValue).ToList();
|
||
if (list == null) return default(T);
|
||
else return list.SingleOrDefault();
|
||
}
|
||
public virtual ISugarQueryable<T> In<TParamter>(params TParamter[] pkValues)
|
||
{
|
||
if (pkValues == null || pkValues.Length == 0)
|
||
{
|
||
Where(SqlBuilder.SqlFalse);
|
||
return this;
|
||
}
|
||
if (pkValues.Length == 1 && pkValues.First().GetType().FullName.IsCollectionsList() || (pkValues.First() is IEnumerable && pkValues.First().GetType() != UtilConstants.StringType))
|
||
{
|
||
var newValues = new List<object>();
|
||
foreach (var item in pkValues.First() as IEnumerable)
|
||
{
|
||
newValues.Add(item);
|
||
}
|
||
return In(newValues);
|
||
}
|
||
var pks = GetPrimaryKeys().Select(it => SqlBuilder.GetTranslationTableName(it)).ToList();
|
||
Check.Exception(pks == null || pks.Count != 1, "Queryable.In(params object[] pkValues): Only one primary key");
|
||
string filed = pks.FirstOrDefault();
|
||
string shortName = QueryBuilder.TableShortName == null ? null : (QueryBuilder.TableShortName + ".");
|
||
filed = shortName + filed;
|
||
return In(filed, pkValues);
|
||
}
|
||
public virtual ISugarQueryable<T> In<FieldType>(string filed, params FieldType[] inValues)
|
||
{
|
||
if (inValues.Length == 1)
|
||
{
|
||
if (inValues.GetType().IsArray)
|
||
{
|
||
var whereIndex = QueryBuilder.WhereIndex;
|
||
string parameterName = this.SqlBuilder.SqlParameterKeyWord + "InPara" + whereIndex;
|
||
this.AddParameters(new SugarParameter(parameterName, inValues[0]));
|
||
this.Where(string.Format(QueryBuilder.InTemplate, filed, parameterName));
|
||
QueryBuilder.WhereIndex++;
|
||
}
|
||
else
|
||
{
|
||
var values = new List<object>();
|
||
foreach (var item in ((IEnumerable)inValues[0]))
|
||
{
|
||
if (item != null)
|
||
{
|
||
values.Add(item.ToString().ToSqlValue());
|
||
}
|
||
}
|
||
this.Where(string.Format(QueryBuilder.InTemplate, filed, string.Join(",", values)));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var values = new List<object>();
|
||
foreach (var item in inValues)
|
||
{
|
||
if (item != null)
|
||
{
|
||
values.Add(item.ToString().ToSqlValue());
|
||
}
|
||
}
|
||
this.Where(string.Format(QueryBuilder.InTemplate, filed, string.Join(",", values)));
|
||
|
||
}
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
return In(fieldName, inValues);
|
||
}
|
||
public virtual ISugarQueryable<T> In<TParamter>(List<TParamter> pkValues)
|
||
{
|
||
if (pkValues == null || pkValues.Count == 0)
|
||
{
|
||
Where(SqlBuilder.SqlFalse);
|
||
return this;
|
||
}
|
||
return In(pkValues.ToArray());
|
||
}
|
||
public virtual ISugarQueryable<T> In<FieldType>(string InFieldName, List<FieldType> inValues)
|
||
{
|
||
if (inValues == null || inValues.Count == 0)
|
||
{
|
||
Where(SqlBuilder.SqlFalse);
|
||
return this;
|
||
}
|
||
return In(InFieldName, inValues.ToArray());
|
||
}
|
||
public virtual ISugarQueryable<T> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
if (inValues == null || inValues.Count == 0)
|
||
{
|
||
Where(SqlBuilder.SqlFalse);
|
||
return this;
|
||
}
|
||
return In(expression, inValues.ToArray());
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> OrderBy(string orderFileds)
|
||
{
|
||
var orderByValue = QueryBuilder.OrderByValue;
|
||
if (QueryBuilder.OrderByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.OrderByValue = QueryBuilder.OrderByTemplate;
|
||
}
|
||
QueryBuilder.OrderByValue += string.IsNullOrEmpty(orderByValue) ? orderFileds : ("," + orderFileds);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
this._OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
return this.OrderBy(orderFileds);
|
||
else
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
return this.OrderBy(expression, type);
|
||
else
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> GroupBy(string groupFileds)
|
||
{
|
||
var croupByValue = QueryBuilder.GroupByValue;
|
||
if (QueryBuilder.GroupByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.GroupByValue = QueryBuilder.GroupByTemplate;
|
||
}
|
||
QueryBuilder.GroupByValue += string.IsNullOrEmpty(croupByValue) ? groupFileds : ("," + groupFileds);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> PartitionBy(Expression<Func<T, object>> expression)
|
||
{
|
||
if (QueryBuilder.Take == null)
|
||
QueryBuilder.Take = 1;
|
||
_PartitionBy(expression);
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> PartitionBy(string groupFileds)
|
||
{
|
||
var partitionByValue = QueryBuilder.PartitionByValue;
|
||
if (QueryBuilder.PartitionByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.PartitionByValue = QueryBuilder.PartitionByTemplate;
|
||
}
|
||
QueryBuilder.PartitionByValue += string.IsNullOrEmpty(partitionByValue) ? groupFileds : ("," + groupFileds);
|
||
return this;
|
||
}
|
||
|
||
public virtual ISugarQueryable<T> Skip(int num)
|
||
{
|
||
QueryBuilder.Skip = num;
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> Take(int num)
|
||
{
|
||
QueryBuilder.Take = num;
|
||
return this;
|
||
}
|
||
|
||
public virtual T Single()
|
||
{
|
||
if (QueryBuilder.OrderByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate;
|
||
}
|
||
var oldSkip = QueryBuilder.Skip;
|
||
var oldTake = QueryBuilder.Take;
|
||
var oldOrderBy = QueryBuilder.OrderByValue;
|
||
QueryBuilder.Skip = null;
|
||
QueryBuilder.Take = null;
|
||
QueryBuilder.OrderByValue = null;
|
||
var result = this.ToList();
|
||
QueryBuilder.Skip = oldSkip;
|
||
QueryBuilder.Take = oldTake;
|
||
QueryBuilder.OrderByValue = oldOrderBy;
|
||
if (result == null || result.Count == 0)
|
||
{
|
||
return default(T);
|
||
}
|
||
else if (result.Count == 2)
|
||
{
|
||
Check.Exception(true, ".Single() result must not exceed one . You can use.First()");
|
||
return default(T);
|
||
}
|
||
else
|
||
{
|
||
return result.SingleOrDefault();
|
||
}
|
||
}
|
||
public virtual T Single(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Single();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public virtual T First()
|
||
{
|
||
if (QueryBuilder.OrderByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate;
|
||
}
|
||
if (QueryBuilder.Skip.HasValue)
|
||
{
|
||
QueryBuilder.Take = 1;
|
||
return this.ToList().FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
QueryBuilder.Skip = 0;
|
||
QueryBuilder.Take = 1;
|
||
var result = this.ToList();
|
||
if (result.HasValue())
|
||
return result.FirstOrDefault();
|
||
else
|
||
return default(T);
|
||
}
|
||
}
|
||
public virtual T First(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = First();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public virtual bool Any(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public virtual bool Any()
|
||
{
|
||
return this.Count() > 0;
|
||
}
|
||
|
||
public virtual ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
|
||
public virtual ISugarQueryable<TResult> Select<TResult>()
|
||
{
|
||
var isJoin = this.QueryBuilder.JoinExpression != null;
|
||
if (isJoin)
|
||
{
|
||
var selectValue = new SugarMapper(this.Context).GetSelectValue<TResult>(this.QueryBuilder);
|
||
return this.Select<TResult>(selectValue);
|
||
}
|
||
else
|
||
{
|
||
return this.Select<TResult>(this.SqlBuilder.SqlSelectAll);
|
||
}
|
||
}
|
||
|
||
public virtual ISugarQueryable<TResult> Select<TResult>(string selectValue)
|
||
{
|
||
var result = InstanceFactory.GetQueryable<TResult>(this.Context.CurrentConnectionConfig);
|
||
result.Context = this.Context;
|
||
result.SqlBuilder = this.SqlBuilder;
|
||
QueryBuilder.SelectValue = selectValue;
|
||
if (this.IsAs)
|
||
{
|
||
((QueryableProvider<TResult>)result).IsAs = true;
|
||
}
|
||
return result;
|
||
}
|
||
public virtual ISugarQueryable<T> Select(string selectValue)
|
||
{
|
||
QueryBuilder.SelectValue = selectValue;
|
||
return this;
|
||
}
|
||
public virtual ISugarQueryable<T> MergeTable()
|
||
{
|
||
Check.Exception(this.MapperAction != null || this.MapperActionWithCache != null, "'Mapper’ needs to be written after ‘MergeTable’ ");
|
||
Check.Exception(this.QueryBuilder.SelectValue.IsNullOrEmpty(), "MergeTable need to use Queryable.Select Method .");
|
||
Check.Exception(this.QueryBuilder.Skip > 0 || this.QueryBuilder.Take > 0 || this.QueryBuilder.OrderByValue.HasValue(), "MergeTable Queryable cannot Take Skip OrderBy PageToList ");
|
||
ToSqlBefore();
|
||
var sql = QueryBuilder.ToSqlString();
|
||
var tableName = this.SqlBuilder.GetPackTable(sql, "MergeTable");
|
||
var mergeQueryable = this.Context.Queryable<ExpandoObject>();
|
||
mergeQueryable.QueryBuilder.Parameters = QueryBuilder.Parameters;
|
||
mergeQueryable.QueryBuilder.WhereIndex = QueryBuilder.WhereIndex + 1;
|
||
mergeQueryable.QueryBuilder.JoinIndex = QueryBuilder.JoinIndex + 1;
|
||
mergeQueryable.QueryBuilder.LambdaExpressions.ParameterIndex = QueryBuilder.LambdaExpressions.ParameterIndex;
|
||
return mergeQueryable.AS(tableName).Select<T>("*");
|
||
}
|
||
|
||
public ISugarQueryable<T> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
public virtual int Count()
|
||
{
|
||
MappingTableList expMapping;
|
||
int result;
|
||
_CountBegin(out expMapping, out result);
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<int>(cacheService, this.QueryBuilder, () => { return GetCount(); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result = GetCount();
|
||
}
|
||
_CountEnd(expMapping);
|
||
return result;
|
||
}
|
||
|
||
public virtual int Count(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Count();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public virtual TResult Max<TResult>(string maxField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.MaxTemplate, maxField));
|
||
var result = this._ToList<TResult>().SingleOrDefault();
|
||
return result;
|
||
}
|
||
public virtual TResult Max<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
|
||
public virtual TResult Min<TResult>(string minField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.MinTemplate, minField));
|
||
var result = this._ToList<TResult>().SingleOrDefault();
|
||
return result;
|
||
}
|
||
public virtual TResult Min<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
|
||
public virtual TResult Sum<TResult>(string sumField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.SumTemplate, sumField));
|
||
var result = this._ToList<TResult>().SingleOrDefault();
|
||
return result;
|
||
}
|
||
public virtual TResult Sum<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
|
||
public virtual TResult Avg<TResult>(string avgField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.AvgTemplate, avgField));
|
||
var result = this._ToList<TResult>().SingleOrDefault();
|
||
return result;
|
||
}
|
||
public virtual TResult Avg<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
public virtual T[] ToArray()
|
||
{
|
||
|
||
var result = this.ToList();
|
||
if (result.HasValue())
|
||
return result.ToArray();
|
||
else
|
||
return null;
|
||
}
|
||
public virtual string ToJson()
|
||
{
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
var result = CacheSchemeMain.GetOrCreate<string>(cacheService, this.QueryBuilder, () =>
|
||
{
|
||
return this.Context.Utilities.SerializeObject(this.ToList(),typeof(T));
|
||
}, CacheTime, this.Context);
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
return this.Context.Utilities.SerializeObject(this.ToList(), typeof(T));
|
||
}
|
||
}
|
||
public virtual string ToJsonPage(int pageIndex, int pageSize)
|
||
{
|
||
return this.Context.Utilities.SerializeObject(this.ToPageList(pageIndex, pageSize), typeof(T));
|
||
}
|
||
public virtual string ToJsonPage(int pageIndex, int pageSize, ref int totalNumber)
|
||
{
|
||
return this.Context.Utilities.SerializeObject(this.ToPageList(pageIndex, pageSize, ref totalNumber), typeof(T));
|
||
}
|
||
|
||
public virtual DataTable ToDataTable()
|
||
{
|
||
InitMapping();
|
||
var sqlObj = this.ToSql();
|
||
RestoreMapping();
|
||
DataTable result = null;
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<DataTable>(cacheService, this.QueryBuilder, () => { return this.Db.GetDataTable(sqlObj.Key, sqlObj.Value.ToArray()); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result = this.Db.GetDataTable(sqlObj.Key, sqlObj.Value.ToArray());
|
||
}
|
||
return result;
|
||
}
|
||
public virtual DataTable ToDataTablePage(int pageIndex, int pageSize)
|
||
{
|
||
if (pageIndex == 0)
|
||
pageIndex = 1;
|
||
if (QueryBuilder.PartitionByValue.HasValue())
|
||
{
|
||
QueryBuilder.ExternalPageIndex = pageIndex;
|
||
QueryBuilder.ExternalPageSize = pageSize;
|
||
}
|
||
else
|
||
{
|
||
QueryBuilder.Skip = (pageIndex - 1) * pageSize;
|
||
QueryBuilder.Take = pageSize;
|
||
}
|
||
return ToDataTable();
|
||
}
|
||
public virtual DataTable ToDataTablePage(int pageIndex, int pageSize, ref int totalNumber)
|
||
{
|
||
_RestoreMapping = false;
|
||
totalNumber = this.Count();
|
||
_RestoreMapping = true;
|
||
var result = ToDataTablePage(pageIndex, pageSize);
|
||
return result;
|
||
}
|
||
public virtual DataTable ToDataTablePage(int pageIndex, int pageSize, ref int totalNumber, ref int totalPage)
|
||
{
|
||
var result = ToDataTablePage(pageIndex, pageSize, ref totalNumber);
|
||
totalPage = (totalNumber + pageSize - 1) / pageSize;
|
||
return result;
|
||
}
|
||
|
||
public virtual List<T> ToList()
|
||
{
|
||
InitMapping();
|
||
return _ToList<T>();
|
||
}
|
||
public virtual List<T> ToPageList(int pageIndex, int pageSize)
|
||
{
|
||
pageIndex = _PageList(pageIndex, pageSize);
|
||
return ToList();
|
||
}
|
||
public virtual List<T> ToPageList(int pageIndex, int pageSize, ref int totalNumber)
|
||
{
|
||
_RestoreMapping = false;
|
||
List<T> result = null;
|
||
int count = this.Count();
|
||
_RestoreMapping = true;
|
||
QueryBuilder.IsDisabledGobalFilter = UtilMethods.GetOldValue(QueryBuilder.IsDisabledGobalFilter, () =>
|
||
{
|
||
QueryBuilder.IsDisabledGobalFilter = true;
|
||
if (count == 0)
|
||
result = new List<T>();
|
||
else
|
||
result = ToPageList(pageIndex, pageSize);
|
||
|
||
});
|
||
totalNumber = count;
|
||
return result;
|
||
}
|
||
public virtual List<T> ToPageList(int pageIndex, int pageSize, ref int totalNumber, ref int totalPage)
|
||
{
|
||
var result = ToPageList(pageIndex, pageSize, ref totalNumber);
|
||
totalPage = (totalNumber + pageSize - 1) / pageSize;
|
||
return result;
|
||
}
|
||
|
||
public virtual KeyValuePair<string, List<SugarParameter>> ToSql()
|
||
{
|
||
InitMapping();
|
||
ToSqlBefore();
|
||
string sql = QueryBuilder.ToSqlString();
|
||
RestoreMapping();
|
||
return new KeyValuePair<string, List<SugarParameter>>(sql, QueryBuilder.Parameters);
|
||
}
|
||
public ISugarQueryable<T> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
Check.ArgumentNullException(this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService, "Use Cache ConnectionConfig.ConfigureExternalServices.DataInfoCacheService is required ");
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (isCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
public string ToClassString(string className)
|
||
{
|
||
List<DbColumnInfo> columns = new List<DbColumnInfo>();
|
||
var properties = typeof(T).GetProperties();
|
||
foreach (var item in properties)
|
||
{
|
||
columns.Add(new DbColumnInfo()
|
||
{
|
||
DbColumnName = item.Name,
|
||
PropertyName = UtilMethods.GetUnderType(item.PropertyType).Name,
|
||
PropertyType = UtilMethods.GetUnderType(item.PropertyType)
|
||
});
|
||
}
|
||
var result = ((this.Context.DbFirst) as DbFirstProvider).GetClassString(columns, ref className);
|
||
return result;
|
||
}
|
||
#region Async methods
|
||
public virtual async Task<T> InSingleAsync(object pkValue)
|
||
{
|
||
Check.Exception(this.QueryBuilder.SelectValue.HasValue(), "'InSingle' and' Select' can't be used together,You can use .Select(it=>...).Single(it.id==1)");
|
||
var list =await In(pkValue).ToListAsync();
|
||
if (list == null) return default(T);
|
||
else return list.SingleOrDefault();
|
||
}
|
||
public async Task<T> SingleAsync()
|
||
{
|
||
if (QueryBuilder.OrderByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate;
|
||
}
|
||
var oldSkip = QueryBuilder.Skip;
|
||
var oldTake = QueryBuilder.Take;
|
||
var oldOrderBy = QueryBuilder.OrderByValue;
|
||
QueryBuilder.Skip = null;
|
||
QueryBuilder.Take = null;
|
||
QueryBuilder.OrderByValue = null;
|
||
var result =await this.ToListAsync();
|
||
QueryBuilder.Skip = oldSkip;
|
||
QueryBuilder.Take = oldTake;
|
||
QueryBuilder.OrderByValue = oldOrderBy;
|
||
if (result == null || result.Count == 0)
|
||
{
|
||
return default(T);
|
||
}
|
||
else if (result.Count == 2)
|
||
{
|
||
Check.Exception(true, ".Single() result must not exceed one . You can use.First()");
|
||
return default(T);
|
||
}
|
||
else
|
||
{
|
||
return result.SingleOrDefault();
|
||
}
|
||
}
|
||
|
||
public async Task<T> SingleAsync(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result =await SingleAsync();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public async Task<T> FirstAsync()
|
||
{
|
||
if (QueryBuilder.OrderByValue.IsNullOrEmpty())
|
||
{
|
||
QueryBuilder.OrderByValue = QueryBuilder.DefaultOrderByTemplate;
|
||
}
|
||
if (QueryBuilder.Skip.HasValue)
|
||
{
|
||
QueryBuilder.Take = 1;
|
||
var list = await this.ToListAsync();
|
||
return list.FirstOrDefault();
|
||
}
|
||
else
|
||
{
|
||
QueryBuilder.Skip = 0;
|
||
QueryBuilder.Take = 1;
|
||
var result =await this.ToListAsync();
|
||
if (result.HasValue())
|
||
return result.FirstOrDefault();
|
||
else
|
||
return default(T);
|
||
}
|
||
}
|
||
|
||
public async Task<T> FirstAsync(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = await FirstAsync();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public async Task<bool> AnyAsync(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result =await AnyAsync();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
|
||
public async Task<bool> AnyAsync()
|
||
{
|
||
return await this.CountAsync() > 0;
|
||
}
|
||
|
||
public async Task<int> CountAsync()
|
||
{
|
||
MappingTableList expMapping;
|
||
int result;
|
||
_CountBegin(out expMapping, out result);
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<int>(cacheService, this.QueryBuilder, () => { return GetCount(); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result =await GetCountAsync();
|
||
}
|
||
_CountEnd(expMapping);
|
||
return result;
|
||
}
|
||
public async Task<int> CountAsync(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result =await CountAsync();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public async Task<TResult> MaxAsync<TResult>(string maxField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.MaxTemplate, maxField));
|
||
var list = await this._ToListAsync<TResult>();
|
||
var result =list.SingleOrDefault();
|
||
return result;
|
||
}
|
||
|
||
public Task<TResult> MaxAsync<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _MaxAsync<TResult>(expression);
|
||
}
|
||
|
||
public async Task<TResult> MinAsync<TResult>(string minField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.MinTemplate, minField));
|
||
var list = await this._ToListAsync<TResult>();
|
||
var result = list.SingleOrDefault();
|
||
return result;
|
||
}
|
||
|
||
public Task<TResult> MinAsync<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _MinAsync<TResult>(expression);
|
||
}
|
||
|
||
public async Task<TResult> SumAsync<TResult>(string sumField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.SumTemplate, sumField));
|
||
var list = await this._ToListAsync<TResult>();
|
||
var result = list.SingleOrDefault();
|
||
return result;
|
||
}
|
||
|
||
public Task<TResult> SumAsync<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _SumAsync<TResult>(expression);
|
||
}
|
||
|
||
public async Task<TResult> AvgAsync<TResult>(string avgField)
|
||
{
|
||
this.Select(string.Format(QueryBuilder.AvgTemplate, avgField));
|
||
var list = await this._ToListAsync<TResult>();
|
||
var result = list.SingleOrDefault();
|
||
return result;
|
||
}
|
||
|
||
public Task<TResult> AvgAsync<TResult>(Expression<Func<T, TResult>> expression)
|
||
{
|
||
return _AvgAsync<TResult>(expression);
|
||
}
|
||
|
||
public Task<List<T>> ToListAsync()
|
||
{
|
||
InitMapping();
|
||
return _ToListAsync<T>();
|
||
}
|
||
public Task<List<T>> ToPageListAsync(int pageIndex, int pageSize)
|
||
{
|
||
pageIndex = _PageList(pageIndex, pageSize);
|
||
return ToListAsync();
|
||
}
|
||
public async Task<List<T>> ToPageListAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber)
|
||
{
|
||
totalNumber.Value = await this.Clone().CountAsync();
|
||
return await this.Clone().ToPageListAsync(pageIndex, pageSize);
|
||
}
|
||
public async Task<string> ToJsonAsync()
|
||
{
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
var result = CacheSchemeMain.GetOrCreate<string>(cacheService, this.QueryBuilder, () =>
|
||
{
|
||
return this.Context.Utilities.SerializeObject(this.ToList(), typeof(T));
|
||
}, CacheTime, this.Context);
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
return this.Context.Utilities.SerializeObject(await this.ToListAsync(), typeof(T));
|
||
}
|
||
}
|
||
public async Task<string> ToJsonPageAsync(int pageIndex, int pageSize)
|
||
{
|
||
return this.Context.Utilities.SerializeObject(await this.ToPageListAsync(pageIndex, pageSize), typeof(T));
|
||
}
|
||
public async Task<string> ToJsonPageAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber)
|
||
{
|
||
totalNumber.Value = await this.Clone().CountAsync();
|
||
return await this.Clone().ToJsonPageAsync(pageIndex, pageSize);
|
||
}
|
||
public async Task<DataTable> ToDataTableAsync()
|
||
{
|
||
InitMapping();
|
||
var sqlObj = this.ToSql();
|
||
RestoreMapping();
|
||
DataTable result = null;
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<DataTable>(cacheService, this.QueryBuilder, () => { return this.Db.GetDataTable(sqlObj.Key, sqlObj.Value.ToArray()); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result = await this.Db.GetDataTableAsync(sqlObj.Key, sqlObj.Value.ToArray());
|
||
}
|
||
return result;
|
||
}
|
||
public Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize)
|
||
{
|
||
pageIndex = _PageList(pageIndex, pageSize);
|
||
return ToDataTableAsync();
|
||
}
|
||
public async Task<DataTable> ToDataTablePageAsync(int pageIndex, int pageSize, RefAsync<int> totalNumber)
|
||
{
|
||
totalNumber.Value = await this.Clone().CountAsync();
|
||
return await this.Clone().ToDataTablePageAsync(pageIndex, pageSize);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Private Methods
|
||
private void _CountEnd(MappingTableList expMapping)
|
||
{
|
||
RestoreMapping();
|
||
QueryBuilder.IsCount = false;
|
||
if (expMapping.Count > 0)
|
||
{
|
||
if (this.QueryableMappingTableList == null)
|
||
{
|
||
this.QueryableMappingTableList = new MappingTableList();
|
||
}
|
||
this.QueryableMappingTableList.Add(expMapping.First());
|
||
}
|
||
}
|
||
|
||
private void _CountBegin(out MappingTableList expMapping, out int result)
|
||
{
|
||
expMapping = new MappingTableList();
|
||
if (QueryBuilder.EntityName == "ExpandoObject" && this.Context.MappingTables.Any(it => it.EntityName == "ExpandoObject"))
|
||
{
|
||
expMapping.Add("ExpandoObject", this.Context.MappingTables.First(it => it.EntityName == "ExpandoObject").DbTableName);
|
||
}
|
||
InitMapping();
|
||
QueryBuilder.IsCount = true;
|
||
result = 0;
|
||
}
|
||
protected ISugarQueryable<TResult> _Select<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Select");
|
||
this.Context.InitMappingInfo(typeof(TResult));
|
||
var result = InstanceFactory.GetQueryable<TResult>(this.Context.CurrentConnectionConfig);
|
||
result.Context = this.Context;
|
||
result.SqlBuilder = this.SqlBuilder;
|
||
result.SqlBuilder.QueryBuilder.Parameters = QueryBuilder.Parameters;
|
||
result.SqlBuilder.QueryBuilder.SelectValue = expression;
|
||
return result;
|
||
}
|
||
protected void _Where(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Where");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var result = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple);
|
||
QueryBuilder.WhereInfos.Add(SqlBuilder.AppendWhereOrAnd(QueryBuilder.WhereInfos.IsNullOrEmpty(), result.GetResultString()));
|
||
}
|
||
protected ISugarQueryable<T> _OrderBy(Expression expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "OrderBy");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
if ((expression as LambdaExpression).Body is NewExpression)
|
||
{
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.ArraySingle : ResolveExpressType.ArrayMultiple);
|
||
var items = lamResult.GetResultString().Split(',').Where(it => it.HasValue()).Select(it => it + UtilConstants.Space + type.ToString().ToUpper()).ToList();
|
||
OrderBy(string.Join(",", items));
|
||
return this;
|
||
}
|
||
else
|
||
{
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
OrderBy(lamResult.GetResultString() + UtilConstants.Space + type.ToString().ToUpper());
|
||
return this;
|
||
}
|
||
}
|
||
private int _PageList(int pageIndex, int pageSize)
|
||
{
|
||
if (pageIndex == 0)
|
||
pageIndex = 1;
|
||
if (QueryBuilder.PartitionByValue.HasValue())
|
||
{
|
||
QueryBuilder.ExternalPageIndex = pageIndex;
|
||
QueryBuilder.ExternalPageSize = pageSize;
|
||
}
|
||
else
|
||
{
|
||
QueryBuilder.Skip = (pageIndex - 1) * pageSize;
|
||
QueryBuilder.Take = pageSize;
|
||
}
|
||
|
||
return pageIndex;
|
||
}
|
||
protected ISugarQueryable<T> _GroupBy(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "GroupBy");
|
||
LambdaExpression lambda = expression as LambdaExpression;
|
||
expression = lambda.Body;
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
ExpressionResult lamResult = null;
|
||
string result = null;
|
||
if (expression is NewExpression)
|
||
{
|
||
lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.ArraySingle : ResolveExpressType.ArrayMultiple);
|
||
result = string.Join(",", lamResult.GetResultArray().Select(it => it));
|
||
}
|
||
else
|
||
{
|
||
lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
result = lamResult.GetResultString();
|
||
}
|
||
GroupBy(result);
|
||
return this;
|
||
}
|
||
protected TResult _Min<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Main");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var result = Min<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return result;
|
||
}
|
||
protected async Task<TResult> _MinAsync<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Main");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var result = await MinAsync<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return result;
|
||
}
|
||
protected TResult _Avg<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Avg");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
return Avg<TResult>(lamResult.GetResultString());
|
||
}
|
||
protected async Task<TResult> _AvgAsync<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Avg");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
return await AvgAsync<TResult>(lamResult.GetResultString());
|
||
}
|
||
protected TResult _Max<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Max");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var reslut = Max<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return reslut;
|
||
}
|
||
protected async Task<TResult> _MaxAsync<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Max");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var reslut =await MaxAsync<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return reslut;
|
||
}
|
||
protected TResult _Sum<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Sum");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var reslut = Sum<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return reslut;
|
||
}
|
||
protected async Task<TResult> _SumAsync<TResult>(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Sum");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var reslut =await SumAsync<TResult>(lamResult.GetResultString());
|
||
QueryBuilder.SelectValue = null;
|
||
return reslut;
|
||
}
|
||
protected ISugarQueryable<T> _As(string tableName, string entityName)
|
||
{
|
||
IsAs = true;
|
||
OldMappingTableList = this.Context.MappingTables;
|
||
this.Context.MappingTables = this.Context.Utilities.TranslateCopy(this.Context.MappingTables);
|
||
if (this.Context.MappingTables.Any(it => it.EntityName == entityName))
|
||
{
|
||
this.Context.MappingTables.Add(this.Context.MappingTables.First(it => it.EntityName == entityName).DbTableName, tableName);
|
||
}
|
||
this.Context.MappingTables.Add(entityName, tableName);
|
||
this.QueryableMappingTableList = this.Context.MappingTables;
|
||
return this;
|
||
}
|
||
protected void _Filter(string FilterName, bool isDisabledGobalFilter)
|
||
{
|
||
QueryBuilder.IsDisabledGobalFilter = isDisabledGobalFilter;
|
||
if (this.Context.QueryFilter.GeFilterList.HasValue() && FilterName.HasValue())
|
||
{
|
||
var list = this.Context.QueryFilter.GeFilterList.Where(it => it.FilterName == FilterName && it.IsJoinQuery == !QueryBuilder.IsSingle());
|
||
foreach (var item in list)
|
||
{
|
||
var filterResult = item.FilterValue(this.Context);
|
||
Where(filterResult.Sql + UtilConstants.Space, filterResult.Parameters);
|
||
}
|
||
}
|
||
}
|
||
public ISugarQueryable<T> _PartitionBy(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "PartitionBy");
|
||
LambdaExpression lambda = expression as LambdaExpression;
|
||
expression = lambda.Body;
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
ExpressionResult lamResult = null;
|
||
string result = null;
|
||
if (expression is NewExpression)
|
||
{
|
||
lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.ArraySingle : ResolveExpressType.ArrayMultiple);
|
||
result = string.Join(",", lamResult.GetResultArray());
|
||
}
|
||
else
|
||
{
|
||
lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
result = lamResult.GetResultString();
|
||
}
|
||
PartitionBy(result);
|
||
return this;
|
||
}
|
||
protected ISugarQueryable<T> _Having(Expression expression)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "Having");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple);
|
||
Having(lamResult.GetResultString());
|
||
return this;
|
||
}
|
||
protected List<TResult> _ToList<TResult>()
|
||
{
|
||
List<TResult> result = null;
|
||
var sqlObj = this.ToSql();
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<List<TResult>>(cacheService, this.QueryBuilder, () => { return GetData<TResult>(sqlObj); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result = GetData<TResult>(sqlObj);
|
||
}
|
||
RestoreMapping();
|
||
_Mapper(result);
|
||
return result;
|
||
}
|
||
protected async Task<List<TResult>> _ToListAsync<TResult>()
|
||
{
|
||
List<TResult> result = null;
|
||
var sqlObj = this.ToSql();
|
||
if (IsCache)
|
||
{
|
||
var cacheService = this.Context.CurrentConnectionConfig.ConfigureExternalServices.DataInfoCacheService;
|
||
result = CacheSchemeMain.GetOrCreate<List<TResult>>(cacheService, this.QueryBuilder, () => { return GetData<TResult>(sqlObj); }, CacheTime, this.Context);
|
||
}
|
||
else
|
||
{
|
||
result =await GetDataAsync<TResult>(sqlObj);
|
||
}
|
||
RestoreMapping();
|
||
_Mapper(result);
|
||
return result;
|
||
}
|
||
|
||
protected void _Mapper<TResult>(List<TResult> result)
|
||
{
|
||
if (this.EntityInfo.Columns.Any(it => it.IsTranscoding))
|
||
{
|
||
foreach (var item in result)
|
||
{
|
||
foreach (var column in this.EntityInfo.Columns.Where(it => it.IsTranscoding))
|
||
{
|
||
var value = column.PropertyInfo.GetValue(item, null);
|
||
if (value != null)
|
||
{
|
||
column.PropertyInfo.SetValue(item, UtilMethods.DecodeBase64(value.ToString()), null);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (this.Mappers.HasValue())
|
||
{
|
||
foreach (var mapper in this.Mappers)
|
||
{
|
||
if (typeof(TResult) == typeof(T))
|
||
{
|
||
mapper(result.Select(it => (T)Convert.ChangeType(it, typeof(T))).ToList());
|
||
}
|
||
else
|
||
{
|
||
Check.Exception(true, "{0} and {1} are not a type, Try .select().mapper().ToList", typeof(TResult).FullName, typeof(T).FullName);
|
||
}
|
||
}
|
||
}
|
||
if (this.MapperAction != null)
|
||
{
|
||
foreach (TResult item in result)
|
||
{
|
||
if (typeof(TResult) == typeof(T))
|
||
{
|
||
this.MapperAction((T)(item as object));
|
||
}
|
||
else
|
||
{
|
||
Check.Exception(true, "{0} and {1} are not a type, Try .select().mapper().ToList", typeof(TResult).FullName, typeof(T).FullName);
|
||
}
|
||
}
|
||
}
|
||
if (this.MapperActionWithCache != null)
|
||
{
|
||
if (typeof(TResult) == typeof(T))
|
||
{
|
||
var list = (List<T>)Convert.ChangeType(result, typeof(List<T>));
|
||
var mapperCache = new MapperCache<T>(list, this.Context);
|
||
foreach (T item in list)
|
||
{
|
||
mapperCache.GetIndex = 0;
|
||
this.MapperActionWithCache(item, mapperCache);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Check.Exception(true, "{0} and {1} are not a type, Try .select().mapper().ToList", typeof(TResult).FullName, typeof(T).FullName);
|
||
}
|
||
}
|
||
}
|
||
|
||
private ISugarQueryable<T> _Mapper<TObject>(Expression mapperObject, Expression mapperField)
|
||
{
|
||
if ((mapperObject as LambdaExpression).Body is UnaryExpression)
|
||
{
|
||
mapperObject = ((mapperObject as LambdaExpression).Body as UnaryExpression).Operand;
|
||
}
|
||
else
|
||
{
|
||
mapperObject = (mapperObject as LambdaExpression).Body;
|
||
}
|
||
if ((mapperField as LambdaExpression).Body is UnaryExpression)
|
||
{
|
||
mapperField = ((mapperField as LambdaExpression).Body as UnaryExpression).Operand;
|
||
}
|
||
else
|
||
{
|
||
mapperField = (mapperField as LambdaExpression).Body;
|
||
}
|
||
Check.Exception(mapperObject is MemberExpression == false || mapperField is MemberExpression == false, ".Mapper() parameter error");
|
||
var mapperObjectExp = mapperObject as MemberExpression;
|
||
var mapperFieldExp = mapperField as MemberExpression;
|
||
Check.Exception(mapperFieldExp.Type.IsClass(), ".Mapper() parameter error");
|
||
var objType = mapperObjectExp.Type;
|
||
var filedType = mapperFieldExp.Expression.Type;
|
||
Check.Exception(objType != typeof(TObject) && objType != typeof(List<TObject>), ".Mapper() parameter error");
|
||
if (objType == typeof(List<TObject>))
|
||
{
|
||
objType = typeof(TObject);
|
||
}
|
||
var filedName = mapperFieldExp.Member.Name;
|
||
var objName = mapperObjectExp.Member.Name;
|
||
var filedEntity = this.Context.EntityMaintenance.GetEntityInfo(objType);
|
||
var objEntity = this.Context.EntityMaintenance.GetEntityInfo(filedType);
|
||
var isSelf = filedType == typeof(T);
|
||
if (Mappers == null)
|
||
Mappers = new List<Action<List<T>>>();
|
||
if (isSelf)
|
||
{
|
||
Action<List<T>> mapper = (entitys) =>
|
||
{
|
||
if (entitys.IsNullOrEmpty() || !entitys.Any()) return;
|
||
var entity = entitys.First();
|
||
var whereCol = filedEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals(filedName, StringComparison.CurrentCultureIgnoreCase));
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => it.IsPrimarykey == true);
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => GetPrimaryKeys().Any(pk => pk.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase)));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals("id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => (it.PropertyName).Equals(it.EntityName + "id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
Check.Exception(true, ".Mapper() parameter error");
|
||
}
|
||
List<string> inValues = entitys.Select(it => it.GetType().GetProperty(filedName).GetValue(it, null).ObjToString()).ToList();
|
||
List<IConditionalModel> wheres = new List<IConditionalModel>()
|
||
{
|
||
new ConditionalModel()
|
||
{
|
||
FieldName=whereCol.DbColumnName,
|
||
ConditionalType= ConditionalType.In,
|
||
FieldValue=string.Join(",",inValues.Distinct())
|
||
}
|
||
};
|
||
var list = this.Context.Queryable<TObject>().Where(wheres).ToList();
|
||
foreach (var item in entitys)
|
||
{
|
||
var whereValue = item.GetType().GetProperty(filedName).GetValue(item, null);
|
||
var setValue = list.Where(x => x.GetType().GetProperty(whereCol.PropertyName).GetValue(x, null).ObjToString() == whereValue.ObjToString()).ToList();
|
||
var setObject = item.GetType().GetProperty(objName);
|
||
if (setObject.PropertyType.FullName.IsCollectionsList())
|
||
{
|
||
setObject.SetValue(item, setValue.ToList(), null);
|
||
}
|
||
else
|
||
{
|
||
setObject.SetValue(item, setValue.FirstOrDefault(), null);
|
||
}
|
||
}
|
||
};
|
||
Mappers.Add(mapper);
|
||
}
|
||
else
|
||
{
|
||
Action<List<T>> mapper = (entitys) =>
|
||
{
|
||
if (entitys.IsNullOrEmpty() || !entitys.Any()) return;
|
||
var entity = entitys.First();
|
||
var tEntity = this.Context.EntityMaintenance.GetEntityInfo<T>();
|
||
var whereCol = tEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals(filedName, StringComparison.CurrentCultureIgnoreCase));
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => it.IsPrimarykey == true);
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => GetPrimaryKeys().Any(pk => pk.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase)));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals("id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => (it.PropertyName).Equals(it.EntityName + "id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
Check.Exception(true, ".Mapper() parameter error");
|
||
}
|
||
List<string> inValues = entitys.Select(it => it.GetType().GetProperty(whereCol.PropertyName).GetValue(it, null).ObjToString()).ToList();
|
||
var dbColumnName = filedEntity.Columns.FirstOrDefault(it => it.PropertyName == filedName).DbColumnName;
|
||
List<IConditionalModel> wheres = new List<IConditionalModel>()
|
||
{
|
||
new ConditionalModel()
|
||
{
|
||
FieldName=dbColumnName,
|
||
ConditionalType= ConditionalType.In,
|
||
FieldValue=string.Join(",",inValues)
|
||
}
|
||
};
|
||
var list = this.Context.Queryable<TObject>().Where(wheres).ToList();
|
||
foreach (var item in entitys)
|
||
{
|
||
var whereValue = item.GetType().GetProperty(whereCol.PropertyName).GetValue(item, null);
|
||
var setValue = list.Where(x => x.GetType().GetProperty(filedName).GetValue(x, null).ObjToString() == whereValue.ObjToString()).ToList();
|
||
var setObject = item.GetType().GetProperty(objName);
|
||
if (setObject.PropertyType.FullName.IsCollectionsList())
|
||
{
|
||
setObject.SetValue(item, setValue.ToList(), null);
|
||
}
|
||
else
|
||
{
|
||
setObject.SetValue(item, setValue.FirstOrDefault(), null);
|
||
}
|
||
}
|
||
};
|
||
Mappers.Add(mapper);
|
||
}
|
||
|
||
return this;
|
||
}
|
||
|
||
private ISugarQueryable<T> _Mapper<TObject>(Expression mapperObject, Expression mainField, Expression childField)
|
||
{
|
||
if ((mapperObject as LambdaExpression).Body is UnaryExpression)
|
||
{
|
||
mapperObject = ((mapperObject as LambdaExpression).Body as UnaryExpression).Operand;
|
||
}
|
||
else
|
||
{
|
||
mapperObject = (mapperObject as LambdaExpression).Body;
|
||
}
|
||
if ((mainField as LambdaExpression).Body is UnaryExpression)
|
||
{
|
||
mainField = ((mainField as LambdaExpression).Body as UnaryExpression).Operand;
|
||
}
|
||
else
|
||
{
|
||
mainField = (mainField as LambdaExpression).Body;
|
||
}
|
||
if ((childField as LambdaExpression).Body is UnaryExpression)
|
||
{
|
||
childField = ((childField as LambdaExpression).Body as UnaryExpression).Operand;
|
||
}
|
||
else
|
||
{
|
||
childField = (childField as LambdaExpression).Body;
|
||
}
|
||
Check.Exception(mapperObject is MemberExpression == false || mainField is MemberExpression == false, ".Mapper() parameter error");
|
||
var mapperObjectExp = mapperObject as MemberExpression;
|
||
var mainFieldExp = mainField as MemberExpression;
|
||
var childFieldExp = childField as MemberExpression;
|
||
Check.Exception(mainFieldExp.Type.IsClass(), ".Mapper() parameter error");
|
||
Check.Exception(childFieldExp.Type.IsClass(), ".Mapper() parameter error");
|
||
var objType = mapperObjectExp.Type;
|
||
var filedType = mainFieldExp.Expression.Type;
|
||
Check.Exception(objType != typeof(TObject) && objType != typeof(List<TObject>), ".Mapper() parameter error");
|
||
if (objType == typeof(List<TObject>))
|
||
{
|
||
objType = typeof(TObject);
|
||
}
|
||
var mainFiledName = mainFieldExp.Member.Name;
|
||
var childFiledName = childFieldExp.Member.Name;
|
||
var objName = mapperObjectExp.Member.Name;
|
||
var filedEntity = this.Context.EntityMaintenance.GetEntityInfo(objType);
|
||
var objEntity = this.Context.EntityMaintenance.GetEntityInfo(filedType);
|
||
var isSelf = filedType == typeof(T);
|
||
if (Mappers == null)
|
||
Mappers = new List<Action<List<T>>>();
|
||
if (isSelf)
|
||
{
|
||
Action<List<T>> mapper = (entitys) =>
|
||
{
|
||
if (entitys.IsNullOrEmpty() || !entitys.Any()) return;
|
||
var entity = entitys.First();
|
||
var whereCol = filedEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals(childFiledName, StringComparison.CurrentCultureIgnoreCase));
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => it.IsPrimarykey == true);
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => GetPrimaryKeys().Any(pk => pk.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase)));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals("id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = filedEntity.Columns.FirstOrDefault(it => (it.PropertyName).Equals(it.EntityName + "id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
Check.Exception(true, ".Mapper() parameter error");
|
||
}
|
||
List<string> inValues = entitys.Select(it => it.GetType().GetProperty(mainFiledName).GetValue(it, null).ObjToString()).ToList();
|
||
List<IConditionalModel> wheres = new List<IConditionalModel>()
|
||
{
|
||
new ConditionalModel()
|
||
{
|
||
FieldName=whereCol.DbColumnName,
|
||
ConditionalType= ConditionalType.In,
|
||
FieldValue=string.Join(",",inValues.Distinct())
|
||
}
|
||
};
|
||
var list = this.Context.Queryable<TObject>().Where(wheres).ToList();
|
||
foreach (var item in entitys)
|
||
{
|
||
var whereValue = item.GetType().GetProperty(mainFiledName).GetValue(item, null);
|
||
var setValue = list.Where(x => x.GetType().GetProperty(whereCol.PropertyName).GetValue(x, null).ObjToString() == whereValue.ObjToString()).ToList();
|
||
var setObject = item.GetType().GetProperty(objName);
|
||
if (setObject.PropertyType.FullName.IsCollectionsList())
|
||
{
|
||
setObject.SetValue(item, setValue.ToList(), null);
|
||
}
|
||
else
|
||
{
|
||
setObject.SetValue(item, setValue.FirstOrDefault(), null);
|
||
}
|
||
}
|
||
};
|
||
Mappers.Add(mapper);
|
||
}
|
||
else
|
||
{
|
||
Action<List<T>> mapper = (entitys) =>
|
||
{
|
||
if (entitys.IsNullOrEmpty() || !entitys.Any()) return;
|
||
var entity = entitys.First();
|
||
var tEntity = this.Context.EntityMaintenance.GetEntityInfo<T>();
|
||
var whereCol = tEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals(childFiledName, StringComparison.CurrentCultureIgnoreCase));
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => it.IsPrimarykey == true);
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => GetPrimaryKeys().Any(pk => pk.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase)));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => it.PropertyName.Equals("id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
whereCol = tEntity.Columns.FirstOrDefault(it => (it.PropertyName).Equals(it.EntityName + "id", StringComparison.CurrentCultureIgnoreCase));
|
||
}
|
||
if (whereCol == null)
|
||
{
|
||
Check.Exception(true, ".Mapper() parameter error");
|
||
}
|
||
List<string> inValues = entitys.Select(it => it.GetType().GetProperty(whereCol.PropertyName).GetValue(it, null).ObjToString()).ToList();
|
||
var dbColumnName = filedEntity.Columns.FirstOrDefault(it => it.PropertyName == mainFiledName).DbColumnName;
|
||
List<IConditionalModel> wheres = new List<IConditionalModel>()
|
||
{
|
||
new ConditionalModel()
|
||
{
|
||
FieldName=dbColumnName,
|
||
ConditionalType= ConditionalType.In,
|
||
FieldValue=string.Join(",",inValues)
|
||
}
|
||
};
|
||
var list = this.Context.Queryable<TObject>().Where(wheres).ToList();
|
||
foreach (var item in entitys)
|
||
{
|
||
var whereValue = item.GetType().GetProperty(whereCol.PropertyName).GetValue(item, null);
|
||
var setValue = list.Where(x => x.GetType().GetProperty(mainFiledName).GetValue(x, null).ObjToString() == whereValue.ObjToString()).ToList();
|
||
var setObject = item.GetType().GetProperty(objName);
|
||
if (setObject.PropertyType.FullName.IsCollectionsList())
|
||
{
|
||
setObject.SetValue(item, setValue.ToList(), null);
|
||
}
|
||
else
|
||
{
|
||
setObject.SetValue(item, setValue.FirstOrDefault(), null);
|
||
}
|
||
}
|
||
};
|
||
Mappers.Add(mapper);
|
||
}
|
||
|
||
return this;
|
||
}
|
||
protected int GetCount()
|
||
{
|
||
var sql = string.Empty;
|
||
ToSqlBefore();
|
||
sql = QueryBuilder.ToSqlString();
|
||
sql = QueryBuilder.ToCountSql(sql);
|
||
var result = Context.Ado.GetInt(sql, QueryBuilder.Parameters.ToArray());
|
||
return result;
|
||
}
|
||
protected async Task<int> GetCountAsync()
|
||
{
|
||
var sql = string.Empty;
|
||
ToSqlBefore();
|
||
sql = QueryBuilder.ToSqlString();
|
||
sql = QueryBuilder.ToCountSql(sql);
|
||
var result =Convert.ToInt32(await Context.Ado.GetScalarAsync(sql, QueryBuilder.Parameters.ToArray()));
|
||
return result;
|
||
}
|
||
|
||
private void ToSqlBefore()
|
||
{
|
||
var moreSetts = this.Context.CurrentConnectionConfig.MoreSettings;
|
||
if (moreSetts != null && moreSetts.IsWithNoLockQuery && string.IsNullOrEmpty(QueryBuilder.TableWithString))
|
||
{
|
||
this.With(SqlWith.NoLock);
|
||
}
|
||
}
|
||
|
||
protected List<TResult> GetData<TResult>(KeyValuePair<string, List<SugarParameter>> sqlObj)
|
||
{
|
||
List<TResult> result;
|
||
var isComplexModel = QueryBuilder.IsComplexModel(sqlObj.Key);
|
||
var entityType = typeof(TResult);
|
||
var dataReader = this.Db.GetDataReader(sqlObj.Key, sqlObj.Value.ToArray());
|
||
result = GetData<TResult>(isComplexModel, entityType, dataReader);
|
||
return result;
|
||
}
|
||
protected async Task<List<TResult>> GetDataAsync<TResult>(KeyValuePair<string, List<SugarParameter>> sqlObj)
|
||
{
|
||
List<TResult> result;
|
||
var isComplexModel = QueryBuilder.IsComplexModel(sqlObj.Key);
|
||
var entityType = typeof(TResult);
|
||
var dataReader = await this.Db.GetDataReaderAsync(sqlObj.Key, sqlObj.Value.ToArray());
|
||
result =await GetDataAsync<TResult>(isComplexModel, entityType, dataReader);
|
||
return result;
|
||
}
|
||
|
||
private List<TResult> GetData<TResult>(bool isComplexModel, Type entityType, IDataReader dataReader)
|
||
{
|
||
List<TResult> result;
|
||
if (entityType == UtilConstants.DynamicType)
|
||
{
|
||
result = this.Context.Utilities.DataReaderToExpandoObjectList(dataReader) as List<TResult>;
|
||
}
|
||
else if (entityType == UtilConstants.ObjType)
|
||
{
|
||
result = this.Context.Utilities.DataReaderToExpandoObjectList(dataReader).Select(it => ((TResult)(object)it)).ToList();
|
||
}
|
||
else if (entityType.IsAnonymousType() || isComplexModel)
|
||
{
|
||
result = this.Context.Utilities.DataReaderToList<TResult>(dataReader);
|
||
}
|
||
else
|
||
{
|
||
result = this.Bind.DataReaderToList<TResult>(entityType, dataReader);
|
||
}
|
||
SetContextModel(result, entityType);
|
||
return result;
|
||
}
|
||
private async Task<List<TResult>> GetDataAsync<TResult>(bool isComplexModel, Type entityType, IDataReader dataReader)
|
||
{
|
||
List<TResult> result;
|
||
if (entityType == UtilConstants.DynamicType)
|
||
{
|
||
result =await this.Context.Utilities.DataReaderToExpandoObjectListAsync(dataReader) as List<TResult>;
|
||
}
|
||
else if (entityType == UtilConstants.ObjType)
|
||
{
|
||
var expObj = await this.Context.Utilities.DataReaderToExpandoObjectListAsync(dataReader);
|
||
result = expObj.Select(it => ((TResult)(object)it)).ToList();
|
||
}
|
||
else if (entityType.IsAnonymousType() || isComplexModel)
|
||
{
|
||
result =await this.Context.Utilities.DataReaderToListAsync<TResult>(dataReader);
|
||
}
|
||
else
|
||
{
|
||
result =await this.Bind.DataReaderToListAsync<TResult>(entityType, dataReader);
|
||
}
|
||
SetContextModel(result, entityType);
|
||
return result;
|
||
}
|
||
|
||
protected void _InQueryable(Expression expression, KeyValuePair<string, List<SugarParameter>> sqlObj)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
string sql = sqlObj.Key;
|
||
if (sqlObj.Value.HasValue())
|
||
{
|
||
this.SqlBuilder.RepairReplicationParameters(ref sql, sqlObj.Value.ToArray(), 100);
|
||
this.QueryBuilder.Parameters.AddRange(sqlObj.Value);
|
||
}
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
var whereSql = string.Format(this.QueryBuilder.InTemplate, fieldName, sql);
|
||
this.QueryBuilder.WhereInfos.Add(SqlBuilder.AppendWhereOrAnd(this.QueryBuilder.WhereInfos.IsNullOrEmpty(), whereSql));
|
||
base._InQueryableIndex += 100;
|
||
}
|
||
|
||
protected List<string> GetPrimaryKeys()
|
||
{
|
||
if (this.Context.IsSystemTablesConfig)
|
||
{
|
||
return this.Context.DbMaintenance.GetPrimaries(this.Context.EntityMaintenance.GetTableName(this.EntityInfo.EntityName));
|
||
}
|
||
else
|
||
{
|
||
return this.EntityInfo.Columns.Where(it => it.IsPrimarykey).Select(it => it.DbColumnName).ToList();
|
||
}
|
||
}
|
||
protected virtual List<string> GetIdentityKeys()
|
||
{
|
||
if (this.Context.IsSystemTablesConfig)
|
||
{
|
||
return this.Context.DbMaintenance.GetIsIdentities(this.EntityInfo.DbTableName);
|
||
}
|
||
else
|
||
{
|
||
return this.EntityInfo.Columns.Where(it => it.IsIdentity).Select(it => it.DbColumnName).ToList();
|
||
}
|
||
}
|
||
|
||
protected void RestoreMapping()
|
||
{
|
||
if (IsAs && _RestoreMapping)
|
||
{
|
||
this.Context.MappingTables = OldMappingTableList == null ? new MappingTableList() : OldMappingTableList;
|
||
}
|
||
}
|
||
protected void InitMapping()
|
||
{
|
||
if (this.QueryableMappingTableList != null)
|
||
this.Context.MappingTables = this.QueryableMappingTableList;
|
||
}
|
||
|
||
private void SetContextModel<TResult>(List<TResult> result, Type entityType)
|
||
{
|
||
if (result.HasValue())
|
||
{
|
||
if (UtilMethods.GetRootBaseType(entityType).HasValue() && UtilMethods.GetRootBaseType(entityType) == UtilConstants.ModelType)
|
||
{
|
||
foreach (var item in result)
|
||
{
|
||
var contextProperty = item.GetType().GetProperty("Context");
|
||
SqlSugarProvider newClient = this.Context.Utilities.CopyContext();
|
||
newClient.Ado.IsDisableMasterSlaveSeparation = true;
|
||
if (newClient.CurrentConnectionConfig.AopEvents == null)
|
||
newClient.CurrentConnectionConfig.AopEvents = new AopEvents();
|
||
contextProperty.SetValue(item, newClient, null);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
protected void CopyQueryBuilder(QueryBuilder asyncQueryableBuilder)
|
||
{
|
||
var pars = new List<SugarParameter>();
|
||
pars.AddRange(this.QueryBuilder.Parameters);
|
||
asyncQueryableBuilder.Take = this.QueryBuilder.Take;
|
||
asyncQueryableBuilder.Skip = this.QueryBuilder.Skip;
|
||
asyncQueryableBuilder.SelectValue = this.QueryBuilder.SelectValue;
|
||
asyncQueryableBuilder.WhereInfos = this.Context.Utilities.TranslateCopy(this.QueryBuilder.WhereInfos);
|
||
asyncQueryableBuilder.EasyJoinInfos = this.QueryBuilder.EasyJoinInfos;
|
||
asyncQueryableBuilder.JoinQueryInfos = this.QueryBuilder.JoinQueryInfos;
|
||
asyncQueryableBuilder.WhereIndex = this.QueryBuilder.WhereIndex;
|
||
asyncQueryableBuilder.EntityType = this.QueryBuilder.EntityType;
|
||
asyncQueryableBuilder.EntityName = this.QueryBuilder.EntityName;
|
||
asyncQueryableBuilder.Parameters = pars;
|
||
asyncQueryableBuilder.TableShortName = this.QueryBuilder.TableShortName;
|
||
asyncQueryableBuilder.TableWithString = this.QueryBuilder.TableWithString;
|
||
asyncQueryableBuilder.GroupByValue = this.QueryBuilder.GroupByValue;
|
||
asyncQueryableBuilder.IsDistinct = this.QueryBuilder.IsDistinct;
|
||
asyncQueryableBuilder.OrderByValue = this.QueryBuilder.OrderByValue;
|
||
asyncQueryableBuilder.IsDisabledGobalFilter = this.QueryBuilder.IsDisabledGobalFilter;
|
||
asyncQueryableBuilder.PartitionByValue = this.QueryBuilder.PartitionByValue;
|
||
asyncQueryableBuilder.JoinExpression = this.QueryBuilder.JoinExpression;
|
||
asyncQueryableBuilder.WhereIndex = this.QueryBuilder.WhereIndex;
|
||
asyncQueryableBuilder.HavingInfos = this.QueryBuilder.HavingInfos;
|
||
asyncQueryableBuilder.LambdaExpressions.ParameterIndex = this.QueryBuilder.LambdaExpressions.ParameterIndex;
|
||
asyncQueryableBuilder.IgnoreColumns = this.QueryBuilder.IgnoreColumns;
|
||
}
|
||
protected int SetCacheTime(int cacheDurationInSeconds)
|
||
{
|
||
if (cacheDurationInSeconds == int.MaxValue && this.Context.CurrentConnectionConfig.MoreSettings != null && this.Context.CurrentConnectionConfig.MoreSettings.DefaultCacheDurationInSeconds > 0)
|
||
{
|
||
cacheDurationInSeconds = this.Context.CurrentConnectionConfig.MoreSettings.DefaultCacheDurationInSeconds;
|
||
}
|
||
|
||
return cacheDurationInSeconds;
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T2
|
||
public partial class QueryableProvider<T, T2> : QueryableProvider<T>, ISugarQueryable<T, T2>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Order
|
||
public new ISugarQueryable<T, T2> OrderBy(string orderFileds)
|
||
{
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2> OrderBy(Expression<Func<T, object>> expression, OrderByType type)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2> Having(Expression<Func<T, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2> Having(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2> Having(string whereString, object whereObj)
|
||
{
|
||
base.Having(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, T2, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, T2, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2> In<FieldType>(Expression<Func<T, T2, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2>((t, t2) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (isCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T3
|
||
public partial class QueryableProvider<T, T2, T3> : QueryableProvider<T>, ISugarQueryable<T, T2, T3>
|
||
{
|
||
#region Group
|
||
public ISugarQueryable<T, T2, T3> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> Having(Expression<Func<T, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> Having(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> Having(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> Having(string whereString, object whereObj)
|
||
{
|
||
base.Having(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Order
|
||
public ISugarQueryable<T, T2, T3> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> OrderBy(Expression<Func<T, object>> expression, OrderByType type)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Where
|
||
public ISugarQueryable<T, T2, T3> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3>((t, t2, t3) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T4
|
||
public partial class QueryableProvider<T, T2, T3, T4> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> Having(Expression<Func<T, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> Having(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> Having(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> Having(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
this._Having(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4> Having(string whereString, object whereObj)
|
||
{
|
||
base.Having(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, T4, object>> expression, params FieldType[] inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, T4, object>> expression, List<FieldType> inValues)
|
||
{
|
||
QueryBuilder.CheckExpression(expression, "In");
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4> In<FieldType>(Expression<Func<T, T2, T3, T4, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4>((t, t2, t3, t4) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T5
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5>((t, t2, t3, t4, t5) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T6
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6>((t, t2, t3, t4, t5, T6) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T7
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7>((t, t2, t3, t4, t5, T6, t7) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T8
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClass"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereClass<ClassType>(ClassType whereClass, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
base.WhereClass(whereClass, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
/// <summary>
|
||
/// if a property that is not empty is a condition
|
||
/// </summary>
|
||
/// <param name="whereClassTypes"></param>
|
||
/// <returns></returns>
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WhereClass<ClassType>(List<ClassType> whereClassTypes, bool ignoreDefaultValue = false) where ClassType : class, new()
|
||
{
|
||
|
||
base.WhereClass(whereClassTypes, ignoreDefaultValue);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, string orderFileds)
|
||
{
|
||
if (isOrderBy)
|
||
base.OrderBy(orderFileds);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> OrderByIF(bool isOrderBy, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
if (isOrderBy)
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7, T8>((t, t2, t3, t4, t5, T6, t7, t8) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
|
||
public bool Any(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
var result = Any();
|
||
this.QueryBuilder.WhereInfos.Remove(this.QueryBuilder.WhereInfos.Last());
|
||
return result;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8> Distinct()
|
||
{
|
||
QueryBuilder.IsDistinct = true;
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T9
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7, T8, T9>((t, t2, t3, t4, t5, T6, t7, t8, t9) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T10
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10>((t, t2, t3, t4, t5, T6, t7, t8, t9, t10) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T11
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>((t, t2, t3, t4, t5, T6, t7, t8, t9, t10, t11) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
#region T12
|
||
public partial class QueryableProvider<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> : QueryableProvider<T>, ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
|
||
{
|
||
#region Where
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>> expression)
|
||
{
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(List<IConditionalModel> conditionalModels)
|
||
{
|
||
base.Where(conditionalModels);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, bool>> expression)
|
||
{
|
||
if (isWhere)
|
||
_Where(expression);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Where(string whereString, object whereObj)
|
||
{
|
||
Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WhereIF(bool isWhere, string whereString, object whereObj)
|
||
{
|
||
if (!isWhere) return this;
|
||
this.Where<T>(whereString, whereObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Select
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
public ISugarQueryable<TResult> Select<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>> expression)
|
||
{
|
||
return _Select<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region OrderBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> OrderBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, object>> expression, OrderByType type = OrderByType.Asc)
|
||
{
|
||
_OrderBy(expression, type);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region GroupBy
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
public ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> GroupBy(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, object>> expression)
|
||
{
|
||
_GroupBy(expression);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Aggr
|
||
public TResult Max<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>> expression)
|
||
{
|
||
return _Max<TResult>(expression);
|
||
}
|
||
public TResult Min<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>> expression)
|
||
{
|
||
return _Min<TResult>(expression);
|
||
}
|
||
public TResult Sum<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>> expression)
|
||
{
|
||
return _Sum<TResult>(expression);
|
||
}
|
||
public TResult Avg<TResult>(Expression<Func<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>> expression)
|
||
{
|
||
return _Avg<TResult>(expression);
|
||
}
|
||
#endregion
|
||
|
||
#region In
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> In<FieldType>(Expression<Func<T, object>> expression, params FieldType[] inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> In<FieldType>(Expression<Func<T, object>> expression, List<FieldType> inValues)
|
||
{
|
||
var isSingle = QueryBuilder.IsSingle();
|
||
var lamResult = QueryBuilder.GetExpressionValue(expression, isSingle ? ResolveExpressType.FieldSingle : ResolveExpressType.FieldMultiple);
|
||
var fieldName = lamResult.GetResultString();
|
||
In(fieldName, inValues);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> In<FieldType>(Expression<Func<T, object>> expression, ISugarQueryable<FieldType> childQueryExpression)
|
||
{
|
||
var sqlObj = childQueryExpression.ToSql();
|
||
_InQueryable(expression, sqlObj);
|
||
return this;
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Clone()
|
||
{
|
||
var queryable = this.Context.Queryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>((t, t2, t3, t4, t5, T6, t7, t8, t9, t10, t11, t12) => new object[] { }).WithCacheIF(IsCache, CacheTime);
|
||
base.CopyQueryBuilder(queryable.QueryBuilder);
|
||
return queryable;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AS<AsT>(string tableName)
|
||
{
|
||
var entityName = typeof(AsT).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AS(string tableName)
|
||
{
|
||
var entityName = typeof(T).Name;
|
||
_As(tableName, entityName);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Filter(string FilterName, bool isDisabledGobalFilter = false)
|
||
{
|
||
_Filter(FilterName, isDisabledGobalFilter);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AddParameters(object parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(Context.Ado.GetParameters(parameters));
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AddParameters(SugarParameter[] parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AddParameters(List<SugarParameter> parameters)
|
||
{
|
||
if (parameters != null)
|
||
QueryBuilder.Parameters.AddRange(parameters);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> AddJoinInfo(string tableName, string shortName, string joinWhere, JoinType type = JoinType.Left)
|
||
{
|
||
QueryBuilder.JoinIndex = +1;
|
||
QueryBuilder.JoinQueryInfos
|
||
.Add(new JoinQueryInfo()
|
||
{
|
||
JoinIndex = QueryBuilder.JoinIndex,
|
||
TableName = tableName,
|
||
ShortName = shortName,
|
||
JoinType = type,
|
||
JoinWhere = joinWhere
|
||
});
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> With(string withString)
|
||
{
|
||
base.With(withString);
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WithCache(int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
return this;
|
||
}
|
||
public new ISugarQueryable<T, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> WithCacheIF(bool isCache, int cacheDurationInSeconds = int.MaxValue)
|
||
{
|
||
cacheDurationInSeconds = SetCacheTime(cacheDurationInSeconds);
|
||
if (IsCache)
|
||
{
|
||
this.IsCache = true;
|
||
this.CacheTime = cacheDurationInSeconds;
|
||
}
|
||
return this;
|
||
}
|
||
#endregion
|
||
}
|
||
#endregion
|
||
}
|