From b3396ec168c7be7778f4e8c6eb7c2a3018a3c156 Mon Sep 17 00:00:00 2001 From: sunkaixuan <610262374@qq.com> Date: Fri, 11 Aug 2017 15:01:03 +0800 Subject: [PATCH] Update Core --- .../SqliteTest/DataBase/SqlSugar4xTest.sqlite | Bin 303104 -> 311296 bytes .../Abstract/AdoProvider/AdoProvider.cs | 21 +- .../QueryableProvider/QueryableProvider.cs | 1251 +++++++++++++++++ .../SqlBuilderProvider/QueryBuilder.cs | 56 +- .../src/SqlSugar/InstanceFactory.cs | 52 + .../src/SqlSugar/Interface/IAdo.cs | 1 + .../src/SqlSugar/Interface/IQueryable.cs | 308 ++++ .../src/SqlSugar/Properties/AssemblyInfo.cs | 4 +- .../MySql/SqlBuilder/MySqlQueryBuilder.cs | 1 + .../Sqlite/SqlBuilder/SqliteQueryBuilder.cs | 1 + .../src/SqlSugar/SqlSugarAccessory.cs | 24 + .../src/SqlSugar/SqlSugarClient.cs | 40 + .../src/SqlSugar/SqlSugarForCore.nuspec | 2 +- .../SqliteTest/DataBase/SqlSugar4xTest.sqlite | Bin 208896 -> 208896 bytes 14 files changed, 1730 insertions(+), 31 deletions(-) diff --git a/Src/Asp.Net/SqliteTest/DataBase/SqlSugar4xTest.sqlite b/Src/Asp.Net/SqliteTest/DataBase/SqlSugar4xTest.sqlite index c8ab10fe0870e4e014ec576e4daf603c67bd1f97..6339700c8952c38a6e4dd72b26c4122bba4d8edc 100644 GIT binary patch literal 311296 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 DlWLTY literal 303104 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 diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoProvider.cs index f8071fcfd..6b6896682 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoProvider.cs @@ -50,6 +50,7 @@ namespace SqlSugar public virtual bool IsClearParameters { get; set; } public virtual Action LogEventStarting { get; set; } public virtual Action LogEventCompleted { get; set; } + public virtual Func> ProcessingEventStartingSQL { get; set; } #endregion #region Connection @@ -208,6 +209,8 @@ namespace SqlSugar #region Core public virtual int ExecuteCommand(string sql, params SugarParameter[] parameters) { + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); ExecuteBefore(sql, parameters); IDbCommand sqlCommand = GetCommand(sql, parameters); int count = sqlCommand.ExecuteNonQuery(); @@ -219,10 +222,12 @@ namespace SqlSugar } public virtual IDataReader GetDataReader(string sql, params SugarParameter[] parameters) { + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); ExecuteBefore(sql, parameters); IDbCommand sqlCommand = GetCommand(sql, parameters); var isAutoClose = this.Context.CurrentConnectionConfig.IsAutoCloseConnection && this.Transaction == null; - IDataReader sqlDataReader = sqlCommand.ExecuteReader(isAutoClose?CommandBehavior.CloseConnection:CommandBehavior.Default); + IDataReader sqlDataReader = sqlCommand.ExecuteReader(isAutoClose ? CommandBehavior.CloseConnection : CommandBehavior.Default); if (this.IsClearParameters) sqlCommand.Parameters.Clear(); ExecuteAfter(sql, parameters); @@ -230,6 +235,8 @@ namespace SqlSugar } public virtual DataSet GetDataSetAll(string sql, params SugarParameter[] parameters) { + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); ExecuteBefore(sql, parameters); IDataAdapter dataAdapter = this.GetAdapter(); IDbCommand sqlCommand = GetCommand(sql, parameters); @@ -244,6 +251,8 @@ namespace SqlSugar } public virtual object GetScalar(string sql, params SugarParameter[] parameters) { + if (this.ProcessingEventStartingSQL != null) + ExecuteProcessingSQL(ref sql, parameters); ExecuteBefore(sql, parameters); IDbCommand sqlCommand = GetCommand(sql, parameters); object scalar = sqlCommand.ExecuteScalar(); @@ -321,7 +330,7 @@ namespace SqlSugar } public virtual decimal GetDecimal(string sql, params SugarParameter[] parameters) { - return GetScalar(sql, parameters).ObjToDecimal(); + return GetScalar(sql, parameters).ObjToDecimal(); } public virtual decimal GetDecimal(string sql, List parameters) { @@ -340,7 +349,7 @@ namespace SqlSugar } public virtual DateTime GetDateTime(string sql, params SugarParameter[] parameters) { - return GetScalar(sql, parameters).ObjToDate(); + return GetScalar(sql, parameters).ObjToDate(); } public virtual DateTime GetDateTime(string sql, List parameters) { @@ -496,6 +505,12 @@ namespace SqlSugar #endregion #region Helper + private void ExecuteProcessingSQL(ref string sql, SugarParameter[] parameters) + { + var result = this.ProcessingEventStartingSQL(sql, parameters); + sql = result.Key; + parameters = result.Value; + } public virtual void ExecuteBefore(string sql, SugarParameter[] parameters) { if (this.IsEnableLogEvent) diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs index 68e855a5a..fc51baf48 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs @@ -1944,4 +1944,1255 @@ namespace SqlSugar #endregion } #endregion + #region T9 + public partial class QueryableProvider : QueryableProvider, ISugarQueryable + { + #region Where + public new ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public new ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public new ISugarQueryable Where(string whereString, object whereObj) + { + Where(whereString, whereObj); + return this; + } + + public new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj) + { + if (!isWhere) return this; + this.Where(whereString, whereObj); + return this; + } + #endregion + + #region Select + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + #endregion + + #region OrderBy + public new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + #endregion + + #region GroupBy + public new ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + #endregion + + #region Aggr + public TResult Max(Expression> expression) + { + return _Max(expression); + } + public TResult Min(Expression> expression) + { + return _Min(expression); + } + public TResult Sum(Expression> expression) + { + return _Sum(expression); + } + public TResult Avg(Expression> expression) + { + return _Avg(expression); + } + #endregion + } + #endregion + #region T10 + public partial class QueryableProvider : QueryableProvider, ISugarQueryable + { + #region Where + public new ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public new ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public new ISugarQueryable Where(string whereString, object whereObj) + { + Where(whereString, whereObj); + return this; + } + + public new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj) + { + if (!isWhere) return this; + this.Where(whereString, whereObj); + return this; + } + #endregion + + #region Select + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + #endregion + + #region OrderBy + public new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + #endregion + + #region GroupBy + public new ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + #endregion + + #region Aggr + public TResult Max(Expression> expression) + { + return _Max(expression); + } + public TResult Min(Expression> expression) + { + return _Min(expression); + } + public TResult Sum(Expression> expression) + { + return _Sum(expression); + } + public TResult Avg(Expression> expression) + { + return _Avg(expression); + } + #endregion + } + #endregion + #region T11 + public partial class QueryableProvider : QueryableProvider, ISugarQueryable + { + #region Where + public new ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public new ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public new ISugarQueryable Where(string whereString, object whereObj) + { + Where(whereString, whereObj); + return this; + } + + public new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj) + { + if (!isWhere) return this; + this.Where(whereString, whereObj); + return this; + } + #endregion + + #region Select + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + #endregion + + #region OrderBy + public new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + #endregion + + #region GroupBy + public new ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + #endregion + + #region Aggr + public TResult Max(Expression> expression) + { + return _Max(expression); + } + public TResult Min(Expression> expression) + { + return _Min(expression); + } + public TResult Sum(Expression> expression) + { + return _Sum(expression); + } + public TResult Avg(Expression> expression) + { + return _Avg(expression); + } + #endregion + } + #endregion + #region T12 + public partial class QueryableProvider : QueryableProvider, ISugarQueryable + { + #region Where + public new ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public ISugarQueryable Where(Expression> expression) + { + _Where(expression); + return this; + } + public new ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public ISugarQueryable WhereIF(bool isWhere, Expression> expression) + { + if (isWhere) + _Where(expression); + return this; + } + public new ISugarQueryable Where(string whereString, object whereObj) + { + Where(whereString, whereObj); + return this; + } + + public new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj) + { + if (!isWhere) return this; + this.Where(whereString, whereObj); + return this; + } + #endregion + + #region Select + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + public ISugarQueryable Select(Expression> expression) + { + return _Select(expression); + } + #endregion + + #region OrderBy + public new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + public ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc) + { + _OrderBy(expression, type); + return this; + } + #endregion + + #region GroupBy + public new ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + public ISugarQueryable GroupBy(Expression> expression) + { + _GroupBy(expression); + return this; + } + #endregion + + #region Aggr + public TResult Max(Expression> expression) + { + return _Max(expression); + } + public TResult Min(Expression> expression) + { + return _Min(expression); + } + public TResult Sum(Expression> expression) + { + return _Sum(expression); + } + public TResult Avg(Expression> expression) + { + return _Avg(expression); + } + #endregion + } + #endregion } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs index 10f0606f7..70a905e76 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs @@ -225,6 +225,37 @@ namespace SqlSugar { string oldOrderBy = this.OrderByValue; string externalOrderBy = oldOrderBy; + AppendFilter(); + sql = new StringBuilder(); + if (this.OrderByValue == null && (Skip != null || Take != null)) this.OrderByValue = " ORDER BY GetDate() "; + if (this.PartitionByValue.IsValuable()) + { + this.OrderByValue = this.PartitionByValue + this.OrderByValue; + } + var isRowNumber = Skip != null || Take != null; + var rowNumberString = string.Format(",ROW_NUMBER() OVER({0}) AS RowIndex ", GetOrderByString); + string groupByValue = GetGroupByString + HavingInfos; + string orderByValue = (!isRowNumber && this.OrderByValue.IsValuable()) ? GetOrderByString : null; + if (this.IsCount) { orderByValue = null; } + sql.AppendFormat(SqlTemplate, GetSelectValue, GetTableNameString, GetWhereValueString, groupByValue, orderByValue); + sql.Replace("{$:OrderByString:$}", isRowNumber ? (this.IsCount ? null : rowNumberString) : null); + if (this.IsCount) { return sql.ToString(); } + var result = ToPageSql(sql.ToString(), this.Take, this.Skip); + if (ExternalPageIndex > 0) + { + if (externalOrderBy.IsNullOrEmpty()) + { + externalOrderBy = " ORDER BY GetDate() "; + } + result = string.Format("SELECT *,ROW_NUMBER() OVER({0}) AS RowIndex2 FROM ({1}) ExternalTable ", GetExternalOrderBy(externalOrderBy), result); + result = ToPageSql2(result, ExternalPageIndex, ExternalPageSize, true); + } + this.OrderByValue = oldOrderBy; + return result; + } + + public virtual void AppendFilter() + { if (!IsDisabledGobalFilter && this.Context.QueryFilter.GeFilterList.IsValuable()) { var gobalFilterList = this.Context.QueryFilter.GeFilterList.Where(it => it.FilterName.IsNullOrEmpty()).ToList(); @@ -239,31 +270,6 @@ namespace SqlSugar } } } - sql = new StringBuilder(); - if (this.OrderByValue == null && (Skip != null || Take != null)) this.OrderByValue = " ORDER BY GetDate() "; - if (this.PartitionByValue.IsValuable()) - { - this.OrderByValue = this.PartitionByValue + this.OrderByValue; - } - var isRowNumber = Skip != null || Take != null; - var rowNumberString = string.Format(",ROW_NUMBER() OVER({0}) AS RowIndex ", GetOrderByString); - string groupByValue = GetGroupByString + HavingInfos; - string orderByValue = (!isRowNumber && this.OrderByValue.IsValuable()) ? GetOrderByString : null; - if (this.IsCount) { orderByValue = null; } - sql.AppendFormat(SqlTemplate, GetSelectValue, GetTableNameString, GetWhereValueString, groupByValue, orderByValue); - sql.Replace("{$:OrderByString:$}", isRowNumber ? (this.IsCount ? null : rowNumberString) : null); - if (this.IsCount) { return sql.ToString(); } - var result = ToPageSql(sql.ToString(), this.Take, this.Skip); - if (ExternalPageIndex > 0) - { - if (externalOrderBy.IsNullOrEmpty()) { - externalOrderBy = " ORDER BY GetDate() "; - } - result = string.Format("SELECT *,ROW_NUMBER() OVER({0}) AS RowIndex2 FROM ({1}) ExternalTable ", GetExternalOrderBy(externalOrderBy),result); - result = ToPageSql2(result,ExternalPageIndex, ExternalPageSize, true); - } - this.OrderByValue = oldOrderBy; - return result; } public virtual string GetExternalOrderBy(string externalOrderBy) diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs index 4f848ab2d..51a4506b2 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs @@ -89,6 +89,38 @@ namespace SqlSugar ISugarQueryable result = CreateInstance>(className); return result; } + + #region 9-12 + public static ISugarQueryable GetQueryable(ConnectionConfig currentConnectionConfig) + { + string className = "Queryable"; + className = GetClassName(currentConnectionConfig.DbType, className); + ISugarQueryable result = CreateInstance>(className); + return result; + } + public static ISugarQueryable GetQueryable(ConnectionConfig currentConnectionConfig) + { + string className = "Queryable"; + className = GetClassName(currentConnectionConfig.DbType, className); + ISugarQueryable result = CreateInstance>(className); + return result; + } + public static ISugarQueryable GetQueryable(ConnectionConfig currentConnectionConfig) + { + string className = "Queryable"; + className = GetClassName(currentConnectionConfig.DbType, className); + ISugarQueryable result = CreateInstance>(className); + return result; + } + public static ISugarQueryable GetQueryable(ConnectionConfig currentConnectionConfig) + { + string className = "Queryable"; + className = GetClassName(currentConnectionConfig.DbType, className); + ISugarQueryable result = CreateInstance>(className); + return result; + } + #endregion + #endregion public static QueryBuilder GetQueryBuilder(ConnectionConfig currentConnectionConfig) @@ -206,6 +238,26 @@ namespace SqlSugar { return CreateInstance(className, typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8)); } + + #region 9-12 + private static Restult CreateInstance(string className) + { + return CreateInstance(className, typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8),typeof(T9)); + } + private static Restult CreateInstance(string className) + { + return CreateInstance(className, typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9),typeof(T10)); + } + private static Restult CreateInstance(string className) + { + return CreateInstance(className, typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10),typeof(T11)); + } + private static Restult CreateInstance(string className) + { + return CreateInstance(className, typeof(T), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10), typeof(T11),typeof(T12)); + } + #endregion + private static Restult CreateInstance(string className, params Type[] types) { var cacheKey = className + string.Join(",", types.Select(it => it.FullName)); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IAdo.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IAdo.cs index 982b76121..44ea41fce 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IAdo.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IAdo.cs @@ -24,6 +24,7 @@ namespace SqlSugar bool IsEnableLogEvent { get; set; } Action LogEventStarting { get; set; } Action LogEventCompleted { get; set; } + Func> ProcessingEventStartingSQL { get; set; } bool IsClearParameters { get; set; } int CommandTimeOut { get; set; } IDbBind DbBind { get; } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IQueryable.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IQueryable.cs index 4a408069a..72e2f73ab 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IQueryable.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Interface/IQueryable.cs @@ -436,4 +436,312 @@ namespace SqlSugar #endregion } + #region 9-12 + public partial interface ISugarQueryable : ISugarQueryable + { + #region Where + new ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + + new ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + + new ISugarQueryable Where(string whereString, object whereObj = null); + new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj = null); + #endregion + + #region Select + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + #endregion + + #region OrderBy + new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + #endregion + + #region GroupBy + new ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + #endregion + + #region Aggr + TResult Max(Expression> expression); + TResult Min(Expression> expression); + TResult Sum(Expression> expression); + TResult Avg(Expression> expression); + #endregion + } + public partial interface ISugarQueryable : ISugarQueryable + { + #region Where + new ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + + new ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + + new ISugarQueryable Where(string whereString, object whereObj = null); + new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj = null); + #endregion + + #region Select + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + #endregion + + #region OrderBy + new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + #endregion + + #region GroupBy + new ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + #endregion + + #region Aggr + TResult Max(Expression> expression); + TResult Min(Expression> expression); + TResult Sum(Expression> expression); + TResult Avg(Expression> expression); + #endregion + } + public partial interface ISugarQueryable : ISugarQueryable + { + #region Where + new ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + + new ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + + new ISugarQueryable Where(string whereString, object whereObj = null); + new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj = null); + #endregion + + #region Select + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + #endregion + + #region OrderBy + new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + #endregion + + #region GroupBy + new ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + #endregion + + #region Aggr + TResult Max(Expression> expression); + TResult Min(Expression> expression); + TResult Sum(Expression> expression); + TResult Avg(Expression> expression); + #endregion + } + public partial interface ISugarQueryable : ISugarQueryable + { + #region Where + new ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + ISugarQueryable Where(Expression> expression); + + new ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + ISugarQueryable WhereIF(bool isWhere, Expression> expression); + + new ISugarQueryable Where(string whereString, object whereObj = null); + new ISugarQueryable WhereIF(bool isWhere, string whereString, object whereObj = null); + #endregion + + #region Select + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + ISugarQueryable Select(Expression> expression); + #endregion + + #region OrderBy + new ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + ISugarQueryable OrderBy(Expression> expression, OrderByType type = OrderByType.Asc); + #endregion + + #region GroupBy + new ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + ISugarQueryable GroupBy(Expression> expression); + #endregion + + #region Aggr + TResult Max(Expression> expression); + TResult Min(Expression> expression); + TResult Sum(Expression> expression); + TResult Avg(Expression> expression); + #endregion + } + #endregion } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Properties/AssemblyInfo.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Properties/AssemblyInfo.cs index 574d6211f..7b686d8f1 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Properties/AssemblyInfo.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Properties/AssemblyInfo.cs @@ -19,5 +19,5 @@ using System.Runtime.InteropServices; // The following GUID is for the ID of the typelib if this project is exposed to COM [assembly: Guid("1c022a5c-4e4d-4026-a8a3-f659b9740a1a")] -[assembly: AssemblyVersion("4.3.2.3")] -[assembly: AssemblyFileVersion("4.3.2.3")] +[assembly: AssemblyVersion("4.3.2.4")] +[assembly: AssemblyFileVersion("4.3.2.4")] diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs index c5f51f386..662fd9311 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/MySql/SqlBuilder/MySqlQueryBuilder.cs @@ -35,6 +35,7 @@ namespace SqlSugar } public override string ToSqlString() { + base.AppendFilter(); string oldOrderValue = this.OrderByValue; string result = null; sql = new StringBuilder(); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs index 7cdccdfad..d616ca009 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteQueryBuilder.cs @@ -35,6 +35,7 @@ namespace SqlSugar } public override string ToSqlString() { + base.AppendFilter(); string result = null; string oldOrderBy = this.OrderByValue; sql = new StringBuilder(); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarAccessory.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarAccessory.cs index 43bd56900..d684c4b75 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarAccessory.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarAccessory.cs @@ -66,6 +66,30 @@ namespace SqlSugar InitMppingInfo(); InitMppingInfo(); } + + #region 9-12 + protected void InitMppingInfo() + { + InitMppingInfo(); + InitMppingInfo(); + } + protected void InitMppingInfo() + { + InitMppingInfo(); + InitMppingInfo(); + } + protected void InitMppingInfo() + { + InitMppingInfo(); + InitMppingInfo(); + } + protected void InitMppingInfo() + { + InitMppingInfo(); + InitMppingInfo(); + } + #endregion + protected void InitMppingInfo() { InitMppingInfo(typeof(T)); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs index e1c429c38..591f8e24e 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs @@ -225,6 +225,46 @@ namespace SqlSugar queryable.Where(joinExpression); return queryable; } + + #region 9-12 + public virtual ISugarQueryable Queryable(Expression> joinExpression) where T : class, new() + { + InitMppingInfo(); + var types = new Type[] { typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8),typeof(T9) }; + var queryable = InstanceFactory.GetQueryable(base.CurrentConnectionConfig); + base.CreateEasyQueryJoin(joinExpression, types, queryable); + queryable.Where(joinExpression); + return queryable; + } + public virtual ISugarQueryable Queryable(Expression> joinExpression) where T : class, new() + { + InitMppingInfo(); + var types = new Type[] { typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9) ,typeof(T10)}; + var queryable = InstanceFactory.GetQueryable(base.CurrentConnectionConfig); + base.CreateEasyQueryJoin(joinExpression, types, queryable); + queryable.Where(joinExpression); + return queryable; + } + public virtual ISugarQueryable Queryable(Expression> joinExpression) where T : class, new() + { + InitMppingInfo(); + var types = new Type[] { typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10),typeof(T11) }; + var queryable = InstanceFactory.GetQueryable(base.CurrentConnectionConfig); + base.CreateEasyQueryJoin(joinExpression, types, queryable); + queryable.Where(joinExpression); + return queryable; + } + public virtual ISugarQueryable Queryable(Expression> joinExpression) where T : class, new() + { + InitMppingInfo(); + var types = new Type[] { typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7), typeof(T8), typeof(T9), typeof(T10), typeof(T11),typeof(T12) }; + var queryable = InstanceFactory.GetQueryable(base.CurrentConnectionConfig); + base.CreateEasyQueryJoin(joinExpression, types, queryable); + queryable.Where(joinExpression); + return queryable; + } + #endregion + public virtual List UnionAll(params ISugarQueryable[] queryables) where T : class, new() { if (queryables.IsNullOrEmpty()) return new List(); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarForCore.nuspec b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarForCore.nuspec index 07f0e4d31..09967591f 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarForCore.nuspec +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarForCore.nuspec @@ -2,7 +2,7 @@ sqlSugarCore - 4.2.3.3 + 4.3.2.4 sunkaixuan Landa http://www.apache.org/licenses/LICENSE-2.0.html diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqliteTest/DataBase/SqlSugar4xTest.sqlite b/Src/Asp.NetCore/SqlServerTest/src/SqliteTest/DataBase/SqlSugar4xTest.sqlite index df6b446b1b9b5c77ce01b982bf54fd2b9f56cf73..7a2fbf9ce99fb42d8a8d64846898f5b08a5cd58b 100644 GIT binary patch literal 208896 zcmeIb36NaXp59rNduCNuiB$-JNQq4XB=YVzS%icTAQmA&Y>x-1gbL6@ly-Im^+vWk zybwHS+tap(;I-R5nY>(;3so}?8r%~z_DmRqC&tq~5vF0rvp8mqMaQ_u6FrURd?#<# z_b*9Ryr%#R#37!Z^vk94%P%wU@0@e<-n#ehJ9ZzMEIhIIz%vtv3eM1yq2b}74TZwc zQ1X+Zp&>{8S*HHvhK7c>s=pKJ&)~n|!9N!MTm6i+|L%8_>ITE(e~z1-KmO;VSB$)n ztLIi`@6Y^`^jGQqsozg6OKwek7=L8=KTX^=^iN}#CT?8#CoX!;^sSGlmtK4A@Xs$l zG_iBf$t@QERh3)WmjR# z*6mlRe{G$3X0ot-^Me|;9K7r4Ik@HU?pxZXLd@6(IQgkfO@)&de<>xH$Wai&$k!Q1g^57x$ zMDgTuYkuzSN-w?WqT!>Z`Mu6PdVJo)t(v=h)#`k1)s|hW3cIHcO+Gn!ps@9>?doaY zaYtd>JzMVFc+W$H+c!T{*m&ReyS8jqKjO~Ks#kRn^t!6>?8Je`pPD$Z+P2p4eg#~Q zs(HPI>+v)7b!eW~*~Js@8@(8-3cCic${>=y`{2b<*Q=N5Q2%8b{Op_5E48X{U{b%9 zg9|tE(X4roR#-EA>tl<)A5VM@qqk}Q;xp!TI#=nh{R)1w???5yTeWoM%Hiqf=D!8( zO{vM0{!kv?nbtS(PQ1a~r!X<^8S!0WFZ?#qugUzk!@PHc>Nxkvq8}91mv^cUN_6>I z^D?pJsOIQazwQTR`qqaRd%;i2(tp9Di*pM^nRlZ_l6b7i^ms;GVexAR$y>HQ8i$&KixzS=8Miz)N??#Ix`KEil^J{wzJTa&ejj78s3p|8lT(MHzhd*Eu8J;QRTvDX=EhSC4x{Eq zOc*cS`}k9P_wKv6}0uD^5d)Z_~bJ!5_4LeKa9i32-#PfZ-q_dY4t+_i($ z2y^qEy%YK+?GKDaH~Jdfblx@Uy)^CKkY0NE<%5Zue3RJoAiMCpsXuDmcDopUpE%aP zQN8O`3p;lon(MtkNx&5<*U49GpL`xqWzeg5D-{ZbHLp79rOTELPe0WE$m&m3|Fe~v zpR<4A!o%7HKep)egyF9GSVq&E!kTTDr>yG{B zW4|-@*T!BM+dDQfcJJ8cv0!ZV*s`%){?GIOSN>n-Kg$0>zM21J{>}VEKjQ)S4|7P^l(SJ7j!DwsrcSqkEJvw@L^oh|2MsFQ0jb1Ujd~|f=FGju? z`IC{4M?M@mHuCpJetYCEjXXQ@`$_{XRphy z&92CfXNNLhW@r%TCVt-;H zad%>4!b+@6oRJuge;NNg{z?49cq{(P_%Gtq@%{0M_}%f1aVx$uenxya_GRqz*e9_M zW3AXPW50+^$M(l2Vt2AUmjru?Uli;renGIx_p9dxt9-wDPO!@N zt7iox-{Cp7O2~IeF!CJ~jC=rg??-s$xce7yR+bkIQZW4@qo5(Km-6$CO zHVQ_*4T6#H2EoX;UNG`qFBti*6O4S<3P!$b1S4OG>>yt#82JLh$ma`2K2I?6xq^|; z5sZAcVC1s|BVSQ4@?A}~k#C(~pS>(N>rxS_(5nq)N|Wh*T*eQYDEkqUGl6+|8(Qo-X9A{8_qAyUEO5h4{N9wAb} z;eB+F3JQ-9sbKI3kqQEj5UJqr2$2fK3hIs!sbKCt+DHX) zM~GDLc7#X;ZAXYyuy%w<1!+f!RB(2LNCjm_h*U6kgh&NpM~GDLbssIHg03S(D%d(g zq=Kv?L@KyCLZpJKBSb2gIzps^s3SxwcsfF)f~F%Z=8nD#OE2wjMHRu(eF_!9(0vLN z!Owm26~WGZ@)W_%eR37S%zbhc!OMNJ6~W4VvJ}C|eJY-J^j#Qv$Wd#G#kECC{jX3g zUZeka!O?e>owMgSKbv^`=~G;`AXb;{hQzAk(8U1jm?IYaol3Y5YlP>-nm zz3?Nd>y^(JzCL~QUHJWsq355!>; z1-)23|J6rl)~mmYM|%&ezt$e@JdaY2w$D+2*+*MfslTkFjVnKz%=kca;0OtS0;|~w1|C#?x1EvAffN8)qU>YzDm!l9r(^bSy{yKlS&h@Qg$#xgHYB&~)?+R@{ zoCqe@PT0GwwXS2A)|N`8;@Z;AU18C()eo?|U*|UIOd^>`nEn61`3r0AVHz+EmnK zz%*bQ_+B(Hz3TF>+y5V|wTgw}i&ye?S6y|g?+FBJZM$H(*Lb!%^B+$8SF&uY|2=^d zuL?_!f*7 zG+^fc--lPhWH1ew222B{0n>nKz%*bQFb$XnOarC?)4;defSLb)yZxGYzD ze7g;p`Tw`uulebw0n>nKz%*bQFb$XnOarC?(|~EfG+-L|J~UwF|KEpK!DKKEmf4lvfpKcm34VVT@1EvAffN8)qU>YzDmnKz%*bQ_&zj%`G0);4~EA7VEj+UzxX~RG8s$*rUBD{X}~mK z8ZZr*222B{0n>nKz%*bQ7&I`Nj4zMfduT->zH#`mnl{9GynhbzP9F>nFdS)rUBD{X}~mK8ZZr*222B{0n>nKV9{|}ll zf13tO1EvAffN8)qU>YzDmnKz%*bQFb$Xn zOarC?(|~EfG%#qu%>M^Xn7>T}rUBD{X}~mK8ZZr*222B{0n>nKz%=mVZ6F{2v!OHM zyNAZ><7>yB&BjMwNG*%+PX1ovj}yBxuc!Yoy*2g6`CsMz(GQ3IY3$OW2NSm?Zv1uH zI5?SFdj0joFCCiLxo2|I-d&U1@ejLyVnWNcY}av%3thf+(>eJ7b>78iFYuuAZnQdA zC`1pd{x$c=SK;D=cRj6R0B$+Fd)FM?H2L`MXD0R(w%&Iqu2bhUw+O4PiFqT7kM`Nbdvq2kX!R}Z&!Nh zMHdYpEzR$B?$P7(9&Xj#<*QcbbE~%OT2`fOGEw5N~PkK8=m#f1of(0IQ-i;P{nZDt7`ZHhKpJko8Kg+ssfu|C^ z<@6J_tdsjYdT?WU>Bf!2zqMc6ZQ-*iFMLgU-b1fi_=c+r+K5w!tW||MDK6;3Iqhlb zO&wD5nY+`#q`2zdLkD(GJ*lo7C{q{{*GJC7W1eU|aW#JWDX)%1sP8@}#mJia{?Uc{ z2b}5#Tb`MCauRpnxo7Xr`A-Vh;C?4v1CQe_gQp}-jt9l{xZ^_C-??{c@`Z(-vA%Ml z=X?Left|ajCJyL(pOkCv+CgfBxp~jt3H_4x#|EMseGP6p@0z?C;H|qcy>$8V;h#JD zT^F6BJNhd&|NRtQ8ohbc@Mi8^@aw&G?tT2Jy?ggy95%QkLia~ma|K$(;u>7MNhR$M zP}R)`gCG@HZGZpvZ@3NqE^dDCl|?ogwq@B)v1p&T$rxOI>Aap7y4A^>jDs&M@}O2= zIYq}Vo%rJhmtVZ-gAQ(W@`Fy_`rKmM`I8>CzX^{nE-dh%^KSH=ZRe-m8`4WJzkD!J zQ-kig^Vi$+AUiMis(IJx$;GzY#qj&YvHp$fU9UC)J9i(N+vxNs3AjRiC{Mm(`{eWZ z91k`sVmn$W6xO`zq?ayRHaz`M|0AnERsGLaYJSfCh2O~R2OrC5dQ(`l?ef&pE3X{x zKmNh}dv+h1eC*)l{=<_~k58U}XU!j-G1)C}t?bx(Y%@n2T`S*`x8Q-7{ff38-4 zEcM4$e=zb|tNs+#pM?4oAN)Obc2gYt4D~(+-wtQ?f{}=f$@_&;5IR9b(SpM(l ze>?w|^3Ud<%s-gllD{T@W&VPEe)Ox+e>?iw=qIE9XtX{0d!v7I^e>M-H~Q4*L!-Bi zUORf#=!K(WBmZIK_{irY|9s>RM>-?_VB~L&{FRaCM|O|=WaRdd>qgd&tQZ*|8OnW` z`=4|FeeS=?b#uR;``fwS%Ds^LS?=N79l7gs>vAh{W7)5=Ut~Ycew2MbThG3oeLZ_5 zJC%JjyEVH$yDqyTJC^w>^F`*<%tx8`Gxf~dnb$K%GEr?AeD^g?0uaaLRKTUp=d_P%FzMXtMc_cZNd^EW=xjwlrxgt51_$u*5;?u-OiT4xr z#M_D26GswLiANJ#6YCS}5-Sp8@vq`v#6OLH6n{TnkG~y%J$@uU6@N6oHNHN+F1{i@ z7W*ppMeNhqN3r)~_1N37*JDRwQ?W;5TVv~E>tZWnW5Zt!e=+>2dX-yqmiyk4-Y_-?f5~ z?;63#S0Y=;7YatcKrr(8f|1V?jC`(OaeM!x0b5c$p*jC{)kBj0&~k#DJBudR8#<9TtpyhXf;j8@z!?1$ak+`M`L+p0zPkh?-&VoMcc)W|P> z2=hniD1`VUv=zep5n2kN{Roi?*6(A8RFHmzNCoFdh*VI1gh&PBM~GAqeuPK`-$#g4 z(0znR1=~l6RFHjyNCnsTF+eJ)K0>5|=_5och(1E3g6AVdDri1Jq=MxmL@G!=LZpJ@ zBSb1FK0>5|;rr+#6$Bq4Qo-*LA{F!=AyUEa5h4}j9wAb}?GYjs)E*&H!R!$t6~rDP zQo-we^pFZ#j}WO~^$3v)QjZX+;PeQQ3QCUPRB(BONClNgh*U6ngh&OEM~GDLc!Wp=jYo)7uy}+>1&K$9RB(779i)Q7BSb0~ zJVK;`z#~K|_&Y+Rg1#eEsosRWBUGv0guEkEsosRUBUGv0gt{YCsosRS`)I3FZ$jJ= zs#I^n+Yzc%Z$jGIjhvrj8J)AnFK_3Z9M-si5fyi@Bq3!qQ9oTTw-Dbe}>+ zFm#^+MeuWik}=*4k&?EUGKy^M6+GBgT}Q_+F3HVd~DwG#)(U9gIk?y5pDXsMOM)UcjOP$3uJ?f^9wxc zyc>OIt7r$O&t0rRTkW6=ypz5nU`LmaF7RCXyGsVQI%R`rFV^5m58E#%x_D%PN1b=0 z@36r$zqY~RNncaxcT+6p7I-eQ!D8{04KDfG2Ia$wa*D;w0*^ZHM&DV3N4HFmrF{serx!)#3a$Kia$f3r3%O>W*y-*QbH(>fPPI?$#OuHB`@{}UUzuLIa^>)}r{7E5 z2=iZw`R^lMvG8KM{$9`guN0lIuK#mydX4#lliK(9n|{G*`qt@@#kXXR8#+SbgN>BF z_=mIdO4Ec&g&!WFKHN5=mA64D^ zdvN-Sg&PPhOMgA+MDx#Ge%WFT%-!nb2Gr+e^}?T*xjV80d=%y`zGQ(%op+<}@bhxn zA`KSRerG2vp7>>*aB%sm1)ht3r_J5!lnq|8NP~kPe?o(Ui&rf0sJg+yjlRPMS1sIN zV0)@T&pqjjk%P+@`o41XS&i;}$_5JyH+YJN?Qf2wpLfp*EOiND||DE zZq(&xEbv_B-|CbNUhs7d&U;uks4gB~;8Ew@=sRoB9RGhhix}oUrUBD{X}~mK8ZZr* z222B{0n>nKz%*bQ_+d3*=Knve*UO|e4VVT@1EvAffN8)qU>YzDm*G z|EJTMxsPeUG+-Jq4VVT@1EvAffN8)qU>YzDmnKz%*bQ zFb$XnOarC?(|~EfG;lf%nEC(dv}W#O8ZZr*222B{0n>nKz%*bQFb$XnOarEYA65fq z{{O>zy-ZrufN8)qU>YzDm$z1`YzDmnKz%*bQFb$XnOarC?(|~EfG+-L|VKrdp|39qP%cM08mX(U>YzDm-92eO#`L@(|~EfG+-Jq4VVT@1EvAffN8)qa5@c``Tyy(X6|DeFb$XnOarC? z(|~EfG+-Jq4VVT@1Ezr=Rs)#-|1ZNI4~-um|7`r@@ejtE`9?@sZC)J|6jCq&f1=$QvWCjqDrQF|uuB!$@(YFtTK1D0e*fS?=T92f1eMo!lF_ z*K+%EJ967{8*;^5A-5zqls%sPEcYh-k{>5ONH&x2 zB;QEBmfV-zk=&NtkSrz($tB65#PP&uiH{Q>B$|nL5^p44OYBSRNNh`NNE8!=#FE5N z{CNDc_{Z@N;?4Lw@i*eH#rMT`#J9ya#EbDld`WyLc0Bf3?Bm!6v1aU@*c-9eV*6q{ zV%uUHV#Qb?wj?$*e0=yb^)e2P9-UdA92#0aG&S+eWLOLpUoSXNe4Sul@wI|I#n%XS z6_*4%ibKJ+;y|#a*cV(>?9FjdDk*jaBcCG}`E0?+X9-5WqG05^S}^jh6O4Ro1tZ^8 zf|2h^a)^9a2u8j&f{|~vVC1`8F!Eg{82K(0jC_{}M!t&$Bi|~)$hVRlAYVZ+@?9ht z`Bn%rDPxZ&J~P&=Lkl=vjrpHS%Q)8Ou@)^ zhG67dA{hC`1tZ^>VC2h_J>(k|jC>=4kuN70`LcqMFC!TF(t?pMB^ddVf{`yF82RF4 z7x`j>k#ATq@(l@A`QCd~u*&z|5y2|od#?yq`QCe3u*&z|OM+Ft_g)mN^1b&0*-`o4 zdtR{0_ug}YRlfJ06^wj`1tZ@f!N_+|F!CJ`jC}hABi}y3$hVhlBj1!@`AsG1{6O4S1 z3P!$11S8*11tZ_XZ%R2u8je1S22)?}x}o|NHRAd-T5_ARqnj2gpbN`vLON|9*gc z^uHe-RzaJnU{qMsc@6rFhk9_pM?;{`m@B7F{|NB1j(f_`W zeDuHXBOm?m`^ZQC`#$o~|GtlW^uG^(yhs209`e!uzK4ADzwaR*{qK9oNB{dC^3ngk zhkW$E?;#)k?|aBc|N9>D(f>aD@gDu}yU0iX`!4d)|GtZS^uO;SAN}vU$VdPCF7na; zzKeYHzwaU+{qMWTNB{fUAN0TPARqnjJIF`>`wsHa|GtBK^uO;QAN}t;$VdPC4)W3e zzJq-9zwaO){qJjk(Eq-TeDuF>BOm?m+sH@%`!@2?|GtfU^uKQ-AN}v!$VdPCHuBN` zzKwkJzpwp4|NEB8*Q5V^OXcg)|GuU2_2_@!Qu%uHzi+90J^J6bRK6bl?^`NgkN)>9 zm9Izt`f4_))^uJ$3KKkD;A|L(l7m<(t_lw9!|NBMcqyPOP z^3nf(5&7tU5B})U|6U3C=zp(-eDuFpLO%N6DnKz%*bQFb$XnOarC?(|~EfG;lf%nEC(dv}W#O8ZZr*222B{0n>nKz%*bQFb$Xn zOarEYA65fq{{O>zy-ZrufN8)qU>YzDmJX8vpim`gyW@VdAwK&$4kxfc(D?Wmzw4AVxJYN zvpim`gyU^zdAwK&$J@^Gc(D?Wx1HtjVkI1JJImw6N;uwjmdA^gaJ=m-j~6T9c-vVX zFIK|wwzE85tc2rjXL-C>3CG*c@_4Zlj<=oV@nR($Z#&E5#Y#Bdc9zGBm2kZ6?89@% z8<%jr?d(qkBi}=Uk?%pl$oGI?5R8251tZ_}f|2h!!N_;5VC1_-F!GfIBVQ;O`2sSIx1IF`BcCT2 z`CP%s=LkkVTQKrjf|0K%82PRijC|_^Bi~vwj<=n?N-*+WDH!>#5R80l1S8*S!N_;H zVC1_@F!Eh082K&{jC>c9alGy9D#6INQZVur1S8)?f{|~9VC1_{F!Eg>82Oe9M!xd} zBj2()4z)kd6O4RI1tZ_Nf|2hW!N_;EVB|YXF!G%#82Qc+jC@N3Bi}e#`(sQn^5q31 z->6{Z8xf3rIl;)66^wit!N`{ujC?7<$d@E*eiv_<(r}ZL-=Ec{tw}g8Tvoe=lh}mL-=Ec{tw}g8TvnjKW6Cv5dN5<|3jRwVTS$> zalVEb`ai_^8fNJK5a(-{q5ngiuVIG%5B2$e=>HJsYnY+`L!7T+hW-z6zJ?k4Kg9VO zX6XMA=WCdu|3jRwVTS$>alVEb`ai_^8fNJK5a(-{q5ngDz90HO#Q7R#=>HJsYnY+` zL!7T+hW-z6zJ?k4Kg9VOX6XMA=WCdu|3jRwVTS$>alVEb`ai_^8fNJK5dN5<|3jRw zVTS$>alVEb`ai_^8fNJK5a(-{q5ngiuVIG%4{^SR8TvoO`5I>E{}AVEn4$keoUdVq z{tw}g8TvoO`5I>E{}AVEn4$keoUdVq{tt1!h8g-l#Q7R#=>HJsYnY+`L!7T+hW-z6 zzJ?k4Kg9VOX6XMA{+OZvL!7T+hW-z6zJ?k4Kg9VOX6XMA=WCdu|3jRwVTS$>alVEb z`ai_^8fNJK5a(-{q5ngiuVIG%4~r$t|IPXTeoW{8>u`JPV0+c!_SV7ns>AKAgY8v^ z+gk_Qs}8rf4z^bvZf_lIuR7e`I@n%yxV?3-z3Om#>tK7;;r7F|9c-^U+}=9aUUj&=b+EnaaC_@ud)49g*1`6w!|knu?Nx`{TL;^#4!5@s zwpSf)Zyju}I^5nm*j{zGy>+m?>TrAOV0+c!_SV7ns>AKAgY8v^+gk_Qs}8rf4z^bv zZf_lIuR7e`I@n%yxV?3-z3Om#>tK7;;r78zg{Z`oKc>0B=u`K}X;eAfy_zH0;{ zUr8|Xg@TbUAY;7S@dYEFCm8u$!N}(bMm}3G@>znBuP7M#t`>}Z>jWd;S~AAFovQ>R z-<5)q?+U@lw?;7Xtrm=YmkUO|%LF6erGk;~62ZuKF&X3C&MLvkw^A_j6$B&SMS_uU zg<#~nP%!dcAQ<_U3r4>41tZ@wGRC`|^8_Q`Qo+b~u3+RlM=eC;EGRlfEsf>plu%Ys$D_Df{=qy3^_m9PDRV3n^;|J(3K zoBp@qk2d{p!yj$>--bWh^uG;%wCR5v{%F(xHvG}1|84lAP5;~QN1Oh);g2@`Z^IvL z`rn2>+VsB-f3)d;8~$k1|2F*5rvGjDqfP(Y@JE~ex8aXA{cpn`ZTjDaKic%a4S%%h ze;fX2)BiU7(Wd`x_@hn#+we!5{If3<9UXw&}|{L!ZW zEv&b<>3<9B?QQzs!g_m~{3<9B?QQzs!g_m~{DJ^uLAmk~aNsVZEeH|6A}! zoBp@3Uec!jEv%Qc>3<9BC2jiO!g@)Y{3<9Jk2d{pVgAvk|1Hcv+VsDL`A3`nw=n-`)BhIcA8q>I z!u+F6|6A}!oBp>j|7g?y7Umyq`rpF*qfP%?n18hCe+%=EHvMm5{?VrYEzCdK^uLAq zN1Oh)F#l-N|CaU#{cqW!ng9RT&i`MbUrYFWROr_dJ|7kOwS><{g?=sJ^HHH+OZa?L z=+_cH9~JtwgwIEXel6kiQK4T;_YZ;qy_UUrYFWROr_dJ|7kOwS><{g?=sJ^HHH+OPHTm=+_eF=N0<3gz;5{ zel1~qRiR%?7++QB*Am8875cS=@l}O>En$3BpnVSH7g zUrQKYRp{3e##a^kwS@6ig?=qzd{v=eOBi2O=+_d)R~7oTgz;5{el1~qRiR%?7++QB z*Am8875cS=@l}O>En$3BpnVSH7gUrQKYRp?i}KdM5% zh8SN}=+_YAs|x)ZVtiGhUqg(qD)eiJ@l}O>4Kco|(61rJR~7m-#Q3U0zlIoJRp{3c zUsdSW5aX)~{TgC? zRiR%)jIS#6Yl!hxg?ld{v=e_5P>| z{i^pzRp?i}KdM5%>itm_`c?0bs?e``e^iBj)%&9=^sC+SAIdT%2$3~u*z3{jtqa4pB0RJhXo_wA;HLZP%!cx z5R82L1tZ@+!N|8)F!Is=dVf@z{@44X%Jje9A62IR_5P?b{jc{&mFa)IKdMas>-|w> z`d{ylD%1aZe^i~W%@sa zKg#rf2!E96{}BEt)Bhp-QKtVx_@hk!>)&5grvC%@qfGw?@JE^c58#h7{U5*|W%@sW zKg#rf0DqL}{{a3d)BgedQKtU`_@hk!2k=Lk{tw`fGW{RGA7%PKfIrIge*k}!>Hh%! zDAWG|{86U=1Nfs%{|E3#nf?#pk23uqz#nD$KY%~V^nU<{{#4= zO#cV)N16T);Eyu>A7Fl7rvC%X&&%|Gfcbfu{tqxeFVp`4=I3SlKfwIFO#cU%pO@+X z0Q2)Q{U2a{UZ(#8%+Jg8e}MUUnf?zjKQGh&0p{mr`ai(@yiETGn4g#F{{ZvzGW{Q5 zeqN^k1I*9M^nZZ)d71tXFh4KT{{iObW%@tB{Jc#62k=Lk{tqz!DAWG|<{xGHKfwH> zO#cU%f0XI}0P~MB{U2cdQKtU`%s{{zfF%JhGL`A3=l z4>12I)BgeHA7%PK!2F|3{|A_VlHh%p zk23uqVE$32{{zfF%JhGL`A3=l4>12I)Bl03&;M`s|Nofw|JUeW7w`WX{p;fWU!#9r zy#H(TuZ#D8jsA7<{;$!$F5dq&`q#z#zefMMc>mYvUl;HH8vX0y{a>ShUA+Hm^skHe ze~tci@&2#Tzb@YYHTu`Z`@cs2x_JNB=wBD_{~G=4;{9Kve_hPKYxJ*+`FD-}bus_0 z(Z4R{-!=Nz#r(TQ|GJoe*XUmt^Y0q{>tg<0qkmn@ziafbi}`nr{&g|`uF=0P=HE5? z*Tww1M*q4PKh@}87xV8L{p(`tOs;qkkQY zpKA24gYi?1{&g^Zs?om=#!of+*TMLyM*lh(Kh@}82jiz2{p(=-RHJ_#jGt=suY>VZ zjsA5oeyY*G4#rP4`q#nusYd@g7(dnMUkBr-8vW~F{8XcV9gLr9^sj^QQ;q(0Fn+4h zzYfMvHTu`V_^C$!Iv79I=wAopryBk1VEk00e;tgUYV@yz@l%cdbufOa(Z3GHPc{12 z!T700|2h~y)#zUbtOs;qkkQYpKA24gYi?1{&g^Zs?om=#!of+*TMLyM*lh( zKh@}8{r##M{j0xURil6P_p563ul{~jjsDf&ud0pA&ENF*t7O&WmllkC zDZ%J3DH#1F1f##WVDuLgjQ)nn+8;xLRle%0f>pli5y2{7^%cP?U-f0dDqr;_!75+% zMZqdx^##EyU-fyxDqrk{;1ObHvCbg z|84lAO8?vNN0t7!;g2f)Z^Iu|`rn2>s`S4Ne^lvz8~&)$|2F(lrT=aCqe}nV@JE&Y zx8aW}{cpn`Rr=qCKdSV<4S!VWe;fX&(*HL6QKkQF_@hey+wez~{>3k z{;1ObHvCbg|84lAO8?vNN0t7!;g2f)Z)5&lrT=ZrzpM1Wjrn(#{$8}sif{cmIbU8VnR%)hJjzm55KmHxLe|E|*iHs;?|`rpRk^N%Y1Z)5&ZrT=ZrKdSV9(>TFPd)gcN1uA|L61K5;Da80>cIy+`qYCDdi1FW zAN1%`4?gJ8ryhLJqfb5fphus2@IjA0_27dZed@snJ^Ivx4|?>e2Osq4Qx87q(Wf4K z(4$X1_@GChdhkJyKK0;(9)0S;2R-`KgAaQ2sRtkQ=u;0q=+UPhe9)s$J@}wUpL*~? zk3RL_gC2eA!3RD1)PoOt^r;6Q^ypI$KIqY>9(>TFPd)gcN1uA|L61K5;Da80>cIy+ z`qYCDdi1FWAN1%`4?gJ8ryhLJqfb4oNA>7a59?7q`qaaERF6LOupZT;Pd%(h_2^R% z>rp-W)WdpIk3RJd~hj)}wm#sfYEb9)0Rz zJ*r2adRUL@(Wf5Pqk8nIhxMo)ed=L7sz;xCSdZ$_ryka$di1G>^{5_w>R~;qN1u9F zkLuB<9@e9J^r?sSs2+XlVLhrxpSoC&>d~hz)}wm#sf+cf9)0R!J*r2ax|mP&=u;Q- ziC%neKIURR(TfR2zG1=0HzZi)>%L0He4=|qu*%ncMX<`(eOa)|*L_K_%GZ5Su*%nc zL9oi#eO|E2*L_Z~%GZ5XF!CKH!yny4f|2i_VB|X>82R=KM!tQ5k#DbH{&(SzF8%MqA6@$2g+IFVzYBkK>3-`yB`d{zQ=+ggse@2)7*ZVWN^uOMp(WU?O{){gDulHwk>3_XH zqf7tm{TW^QU+>T8(*JsYMwkBA`!l-qzuuqGrT_K*j4u7J_h)qJf4x7WOaJTr8D08c z@6YJc|9XE$m;TrLGrIJ@-k;H>|MmWiF8#0fXLRX*y+5N%|Lgr3UHV_|&*;+sdVfZj z{@436y7a%^pV6iN_5O@5{jc|Dbm@P+Kch?k>-`yB`d{zQ=+ggse@2)7*ZVWN^uOMp z(WU?O{){gDulHwk>3_XHqf7tm{TW^QU+>T8(*JsYMwkBA`!l-qzuuqGrT_K*j4u7J z_h)qJf4x7WOaJTr8D08c@6YJc|9XE$m;TrLGrIJ@-k;H>|MmWiF8#0fXLRX*y+5N% z|Lgr3UHV_|&*;+sdVfZj{@436y7a%^pV6iN_5O@5{jc|Dbm@P+Kch?k>-`yB`d{zQ z=+ggse@2)7*ZVWN^uOMp(WU?O{){gDulHwk>3_XHqf7tm{TUtlU+>T8(EoaWMu+~_ z`!hQ9zuuqGq5t*%j1K*;_h)qIf3-iu%>RFE^Zy3@=3{=`px=DVj~n!xkNI(fe)BOu zZqRQ&=En{C&By$>LBIK!A2;YXAM@h|{pMqQ)1cpc%#R!Nn~(W%gMRZdKW@-(KIX>_ z`pw7uxIw@97~eGLHy`7h2L0w^eAA%ce2i}z^qY_IO@n^(F}`WgZ$8F14f@T;_@+U> z`550c=r$~-+YX38uXiw@lAt%^D#ee&~HBG#|`?;$NacKzxkLSH|RGX z^Wz5n=3{=`px=DVj~n!xkNI(fe)BOuZqRQ&=En{C&By$>LBIK!A2;YXAM@h|{pMqS z+@Rll%#R!Nn~(W%gMRZdKW@-(KIX>_`pw7uxIw@9m>)OjHy`uk2L0w^e%zqne9Vs< z^qY_Qaf5#IF+Xn5Z$9S74f@T;{J25C`IsL!=r!U99_Gh&`pv`swmSXhVSiiw`MLR#hy88!=LD;K^=Abm-(kVXcStbu9Tbdw2LvPE zelq6A^?iboZ?9nFn-YwC&j?1oJ%W+%X~D?%Gr`EWTQKrHB^ddhBx8PDe?lB4uh&=W^uJzTt<(Q{eYH;i>-E(-{jb+o>-4`~U#-*sdVRG{|LgVDI{mNL zSL^h@USF-#|9XA3PXFum)jIvJ*H`QGzg}Oh)Bk#XwNC%*_0>B4uh&=W^uJzTt<(Q{ zeYH;i>-E(-{jb+o>-4`~U#-*sdVRG{|LgVDI{mNLSL^h@USF-#|9XA3PXFum)jIvJ z*H`QGzg}Oh)Bk#XwNC%*_0>B4uh&=W^uJzTt<(Q{eYH;i>-E(-{jb+o>-4`~U#-*s zdVRG{|LgVDI{mNLSL^h@USF-#|9XA3PXFum)jIvJ*H`QGzg}Oh)Bmpa2mSAAf6)J~ z_6Pm%YJbrGuJ#B0?`nV0|E~52{qN%Y8g=^L#rHMp^uLSmYt-p~7vI;Y)Bi5^&(-OF z7yIYx^uMe9LI1nhKUb&!UF@H$)Bi5^&(-OF7yIYx^uLS!b9MUP#s0ZE{qJJ`T%G=R zv45^k|GU^fSEv77?GO6j#s0ZE{qJJ_QK$c1{e3_B-__suqyJs~eLwo&)!+A{|6Tok zKl#H^TU$3v$=zqPwTBHB<`f82-*Xye_`d_cF*64q|zFMRI z_4;a!{#Wa(X8!+UoBy}y3w?ZYi@wmuC%5PeeSC6@zR<@fx9AIfd~%Dv(8njY=nH*( za*Mvu$0xVw3w?ZYi@wmuC%5PeeSC6@zR<@fx9AIfd~%Dv(8njY=nH*(a*Mvu$0xVw z3w?ZYi@wmuC%5PeeSC6@zR<@fx9AIfd~%Dv(8njY=nH*(a*Mvu$0xVw3w?ZYi@wmu zC%5PeeSC6@zR<@fx9AIfd~%Dv(8njY=nH*(a*Mvu$0xVw3w?ZYi@wmuC%5PeeSC6@ zzR<@fx9AIfzT6glq0g7wqA&FMa$EF;K3{H&zR>5(ZP6F{e7P<9LZ2_UMPKOi<+kVx zeZJf#eWA~n+oUh_`Er}|g+5u zJ}emdej*t89ukav4+=)U2gq2jY2Ggw`R)^peA@*h-@Ss7?;gR(ceh~V+a?(K?h=fA zTLmNEopY>@Pj22J82N4&jC{8VM!qeAk?&T)$ajli3@BEa+Cho$0s-Ge|>y%lm6GoCpYPTeSC70{@2GRH|c+Ud~%ci*T*L}>3@BE za+Cho$0s-Ge|>y%lm6GoCpYPTeSC70{@2GRH|c+Ud~%ci*T*L}>3@BEa+Cho$0s-G ze|>y%lm6GoCpYPTeSC70{@2GRH|c+Ud~%ci*T*L}>3@BEa+Cho$0s-Ge|>y%lm6Go zCpYPTeSC70{@2GRH|c+Ud~%ci*T*L}>3@BEa+Cho$0s-Ge|>y%lm6GoCpYPTeSC70 z{@2GRH|c+Ud~%ciSH~x-^<(-!(Chv5f1ua<>Hk2l_tXD@Uhk*>1HIl){|9=#pZ*W@ zdO!Ui==Fa3KhW#_^nak&`|1BculLjcfnM*Y{{y|=PyYvcy`TOM^m;%2AL#Xd`ajU? z{q%pJ*Zb-JK(F`H|AAibr~d=J-cSDrdcB|i_w{-|{qO7be)`|n>;3eCWSAL}&@`rpTTO@sdTv0l@l z|9!02H0XaH>opDf-^Y4QgZ}riUeloeeXQ3s=zkyUH4XaThd&zhzmN5r2L112y{19` z`&h4O(EmQxYZ~;wkM)`c{qJMFra}MvSg&c&|321h8uY)9^_m9#@53Jr`rr5U`Tzd) z@TWh<-~YEWyFGhzHq2g;y&yZ59m@P^=3iz0hs=MSc`sAW{7&YtW?std$vl$TnzGslT3jB{h|LEVV7QF=eMNPMw`fCjTt?zbF4F`A?GnMe`P1}?n!J)xQR;>=O)te ze;@zX@&76Q-^Kr7ycT~u{(AgKd@BBEd~1Atd|iA+d@S}=?2Fi^v5#W!$Lg`SW3R`K z#HM18#HP8PP#ZQ9Ag*11hPS=c(aX(tO?=QizRVe8zcoh)pf+q9E~t#g}pvaoe-(@qw) z&TZPs!q&M>J6YH|w`nH}Tjw_IWMS*vrkyNoo!hjNg{^a&cCxT_ZqrT{w$8_BCktEW zW3-cnt@AP3$->t880}wJuMvaoeNMmt%>;>gisu+y@ksflMMOC^PnQ-q;HxGBOw zA=DJ1uMlR6&{GI8Md&Jomm+i&LQ4_a3Sp%PErpO$gh&M^^)W;$C@Dguf{`LbDhMe; zq=JtkL@MYgLZpI?B19_4C_Ho5 zR9lEhbt@66ZkaB2ryUM5))?>j7HYKU-cM`tbf1iF&bI_e$`_%vi|+5$7p2z`&Ez8$oluI9;1=Mf(#{rgpq(a8Gus~)3~_3u|bMkDLr zuX>C|*1uo%7>%rdzv?j>S^s|3V>Gh<{i-b*S^s|37LBZbziNv{*1uo1MI-CquiB!K z_3u}0(a8GutF~a|<^A^(#@j6@dBE!RZNbSAW4zshln1Ov6fIbJz-mO%f|duYMiec0 zdBAE!(Sn!H|hTSbf0A2dxhn o`QY^dBOk;*VB~|@`>fAr-GbT&jC^qWfRPV!A29O4?gRGze>nB#Qvd(} literal 208896 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