From b0cdff77b561b38b840d430c55a4d3a0ec4cde4b Mon Sep 17 00:00:00 2001 From: sunkaixuan <610262374@qq.com> Date: Thu, 22 Jun 2017 14:22:37 +0800 Subject: [PATCH] Update .net Core --- .../SqlServerTest/src/SqlServerTest/Config.cs | 13 + .../src/SqlServerTest/DataBase/script.sql | Bin 0 -> 11986 bytes .../src/SqlServerTest/Demos/1_Query.cs | 326 ++++++++++ .../src/SqlServerTest/Demos/2_Update.cs | 63 ++ .../src/SqlServerTest/Demos/3_Insert.cs | 58 ++ .../src/SqlServerTest/Demos/4_Delete.cs | 33 + .../src/SqlServerTest/Demos/5_CodeFirst.cs | 52 ++ .../src/SqlServerTest/Demos/5_DbFirst.cs | 72 +++ .../src/SqlServerTest/Demos/6_ComplexModel.cs | 78 +++ .../src/SqlServerTest/Demos/7_Filter.cs | 72 +++ .../src/SqlServerTest/Demos/8_JoinSql.cs | 51 ++ .../src/SqlServerTest/Demos/DemoBase.cs | 23 + .../src/SqlServerTest/Models/DataTestInfo.cs | 135 ++++ .../src/SqlServerTest/Models/DataTestInfo2.cs | 44 ++ .../src/SqlServerTest/Models/Enum.cs | 22 + .../src/SqlServerTest/Models/School.cs | 17 + .../src/SqlServerTest/Models/Student.cs | 22 + .../SqlServerTest/Models/ViewModelStudent.cs | 18 + .../PerformanceTesting/PerformanceBase.cs | 31 + .../PerformanceTesting/SqlSugarPerformance.cs | 34 + .../src/SqlServerTest/Program.cs | 31 +- .../src/SqlServerTest/UnitTest/DataTest.cs | 77 +++ .../src/SqlServerTest/UnitTest/Delete.cs | 62 ++ .../UnitTest/ExpressionTest/Field.cs | 51 ++ .../UnitTest/ExpressionTest/Method.cs | 612 ++++++++++++++++++ .../UnitTest/ExpressionTest/Select.cs | 99 +++ .../UnitTest/ExpressionTest/Where.cs | 258 ++++++++ .../src/SqlServerTest/UnitTest/Insert.cs | 127 ++++ .../src/SqlServerTest/UnitTest/Mapping .cs | 46 ++ .../SqlServerTest/UnitTest/PerformanceTest.cs | 115 ++++ .../SqlServerTest/UnitTest/Query/JoinQuery.cs | 83 +++ .../UnitTest/Query/SelectQuery.cs | 94 +++ .../UnitTest/Query/SingleQuery.cs | 131 ++++ .../UnitTest/Setting/Attribute.cs | 20 + .../UnitTest/Setting/AutoClose.cs | 32 + .../UnitTest/Setting/MapColumn.cs | 18 + .../UnitTest/Setting/MapTable.cs | 28 + .../SqlServerTest/UnitTest/UnitTestBase.cs | 49 ++ .../src/SqlServerTest/UnitTest/Update.cs | 135 ++++ .../Abstract/AdoProvider/AdoAccessory.cs | 2 +- .../CodeFirstProvider/CodeFirstProvider.cs | 3 +- .../Abstract/DbBindProvider/DbBindProvider.cs | 2 +- .../IDataReaderEntityBuilder.cs | 2 +- .../Abstract/EntityProvider/EntityProvider.cs | 2 +- .../InsertableProvider/InsertableProvider.cs | 2 +- .../QueryableProvider/QueryableProvider.cs | 3 +- .../UpdateProvider/UpdateableProvider.cs | 2 +- .../SqlServerTest/src/SqlSugar/Class1.cs | 14 - .../src/SqlSugar/Common/IsWhatExtensions.cs | 2 +- .../src/SqlSugar/Common/RewritableMethods.cs | 3 + .../ExpressionsToSql/Common/ExpressionTool.cs | 8 +- .../MethodCallExpressionResolve.cs | 2 +- .../src/SqlSugar/InstanceFactory.cs | 3 +- .../src/SqlSugar/OnlyCore/CoreMethod.cs | 19 + .../src/SqlSugar/OnlyCore/DataExtension.cs | 19 +- .../SqlSugar/{ => OnlyCore}/IDataAdapter.cs | 1 + .../src/SqlSugar/OnlyCore/TypeExtensions.cs | 73 +++ .../SqlServer/SqlServerProvider.cs | 1 - .../src/SqlSugar/SqlSugarClient.cs | 1 - .../SqlServerTest/src/SqlSugar/project.json | 4 +- 60 files changed, 3365 insertions(+), 35 deletions(-) create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Config.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/DataBase/script.sql create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/1_Query.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/2_Update.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/3_Insert.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/4_Delete.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_CodeFirst.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_DbFirst.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/6_ComplexModel.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/7_Filter.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/8_JoinSql.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/DemoBase.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo2.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Enum.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/School.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Student.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/ViewModelStudent.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/PerformanceBase.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/SqlSugarPerformance.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/DataTest.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Delete.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Field.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Method.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Select.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Where.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Insert.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Mapping .cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/PerformanceTest.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/JoinQuery.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SelectQuery.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SingleQuery.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/Attribute.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/AutoClose.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapColumn.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapTable.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/UnitTestBase.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Update.cs delete mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Class1.cs create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/CoreMethod.cs rename Src/Asp.NetCore/SqlServerTest/src/SqlSugar/{ => OnlyCore}/IDataAdapter.cs (69%) create mode 100644 Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/TypeExtensions.cs diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Config.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Config.cs new file mode 100644 index 000000000..540bf35ba --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Config.cs @@ -0,0 +1,13 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Config + { + public static string ConnectionString = "server=.;uid=sa;pwd=sasa;database=SqlSugar4XTest"; + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/DataBase/script.sql b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/DataBase/script.sql new file mode 100644 index 0000000000000000000000000000000000000000..cd68e4e1f44bdb58e753c4d69a34a0cf75b5b288 GIT binary patch literal 11986 zcmeI2Yfl?T6o%((EA>D48>C8;m^NvH6bUewTERB8P0|!a79=Jm1w#!)$)9igK65;t z*~K?5OHqp~+w0k#IcLu0J(uy{e{H*#TXQA1-z4k`^J6kHeADhKX%_H zuaZXh+($k4PERjtZpp1`?wQ_uevPhQujT%9hg$vIeb8v%{osCeZOwwlTR)4LEv?db z2ku0pVV$mDb-_JxW%r|d?4Ihq;GXL~V~c)#QTNIkNjZD$xvjXScC;*7>}%CuExQ$c zhn-I2EZuw6t!tHePwR!Q*4?(-)Qi>G4{J8vD_3CUNUol6#n z8tb~x+G*AGyc~A@XxF{ha}V@_@}8dgAc^$+FQ}|(Z8S8Q??-y#y=EUvx?G=1rX9CG zpp0Ij+|e^xU7?F5jiJp0&F<+pJDt;vp2qjYV^_c6jgj~MD%i&IKo(8SxQeWiUt4pR zU0wUDiog0m!X2%*Cdn=P-#pXMFSL>Br#SkpTcfz8J+A6i)!sL5jp}PrZHl5%Eq=F6 zQEI!NMRi4*#6ODG=(cDyWKk8_Xk+00#oADy*wQ}PZ{5ATwOwutcgzFVwC9%g4hB~J z73gFdu8W@{{HG!>ZHfk(O(ovZNZpS#Tum=*pjf?UImu&4NgjqZ5DzvBlLdROc=@Mz z_C~v36V+A8DUKH_4bZeEs#s%1REba9;tor>9Y6d<^cvFonrL>!1sbV)%Ut*JAaWGx zm1G0KCaQ|mct_jIV?(xpWQxWAa~I{$My|I6?LVYJn8LC3lMD3wt0FZoAi>FXGgjf@J~zfJColk1ff5Svx0g z;4AnESenYFSP77WH1!56@Kx|4D}S=Hns~&5i?LbD+d&DeBSedU9C;ZPD-ZNg*PCdT zdTU1#KsMYVmKAL!hF%SiTTM?bR3OFZpd`6d;oyTE?-STUF|@Eb5V$kg9kmwntjG(% z?3eNZq8D{y5jo4MG>ff~lai}V%D-bBcIv*Uwt6(Euc){>?vv`IzA7VX;sakvA8M3J z_gLe*s^_};z3+cfXP;?Db=6dpD!MuMaPSnCX!Td9x?5SA!vYP3<5&JzIuR&)86y8|%)CRakaLwy!{TZP9$PtmZw{ zuO!c^B#P{Id~I(%kTe^zenDAUFRK%PeGm!wwvNNY;YxMs=|~o3tC{VgA8hcgdJa$3 zA+Z(GnTA_6@ohLl_F>+(>HXYLpDfM1?IP!72^G)914S*X=ID)>2rvB&=Nbo|Qfu zk!aM@$Pyn!cUdW#hfTXb%4R3o9bJxe&h-A933cv$7yFvzyIE;n^nvSp zZ;GX(FyZ?CP6WkX@j7xk{1PPDk@u|2BU-YAXcPEh#1m?jY}bt*Cib(hr|4o5yXXso zKy)o5E>(m-UEQJA*!FQSV3hS7yShVkw9&B7%W^x8$|%l>yJzCwc$yctf#2~|w}dTu z8R0is&o2!Ti0+cr4rEIA_<0d+r{UwY`zaRA61VgC8Rq1ptwk*ES~oJE^Q2ya1y~G# z8{T-;>~rUb836H+UVhA|3lu$`KNGo>wkA4~UKpZhT^FU{-ijOaA6#s5Zzz?ou*L?xYrnH*-> zJ)XU!8JsP026raQ31ieOHdc~c&voy_e{!F*Q@&4q#NkBkMBep6>)=h{4ku}xvr+q$ z6j9;pNLO|a8Y(QF&Q`p!`ka0Wn5|EDrEj7)XMc8jhc%c)PBhZj_!m)I8piY&9vQMZ zf?>y!uX7Kz=dN~U^=pceC1GOESGgbsy9o7ancj&uKCfaEHG9NhKO{w@Od(ftiRl4 z-%2GLJ8I+q2SdJPT@o@NPA%vGkr7cGMGUv?C{D-1>Y6%EAtG-Je1~tQM%x zwpyO2n$W)|YF~z29Suh&??28A9OP%_X}yx9`#Pn-j=737&6?9Y*dvFhV#XMYobd;kCd literal 0 HcmV?d00001 diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/1_Query.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/1_Query.cs new file mode 100644 index 000000000..9041108f1 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/1_Query.cs @@ -0,0 +1,326 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Demo +{ + public class Query : DemoBase + { + + public static void Init() + { + Easy(); + Page(); + Where(); + Join(); + Funs(); + Select(); + Ado(); + Group(); + Sqlable(); + Tran(); + StoredProcedure(); + Enum(); + } + + private static void StoredProcedure() + { + var db = GetInstance(); + //1. no result + db.Ado.UseStoredProcedure(() => + { + string spName = "sp_help"; + var getSpReslut = db.Ado.SqlQueryDynamic(spName, new { objname = "student" }); + }); + + //2. has result + var result = db.Ado.UseStoredProcedure(() => + { + string spName = "sp_help"; + return db.Ado.SqlQueryDynamic(spName, new { objname = "student" }); + }); + + //2. has output + object outPutValue; + var outputResult = db.Ado.UseStoredProcedure(() => + { + string spName = "sp_school"; + var p1 = new SugarParameter("@p1", "1"); + var p2 = new SugarParameter("@p2", null, true);//isOutput=true + var dbResult = db.Ado.SqlQueryDynamic(spName, new SugarParameter[] { p1, p2 }); + outPutValue = p2.Value; + return dbResult; + }); + } + private static void Tran() + { + var db = GetInstance(); + var x=db.Insertable(new Student() { CreateTime = DateTime.Now, Name = "tran" }).ExecuteCommand(); + //1. no result + var result = db.Ado.UseTran(() => + { + + var beginCount = db.Queryable().ToList(); + db.Ado.ExecuteCommand("delete student"); + var endCount = db.Queryable().Count(); + throw new Exception("error haha"); + }); + var count = db.Queryable().Count(); + + //2 has result + var result2 = db.Ado.UseTran>(() => + { + return db.Queryable().ToList(); + }); + + //3 use try + try + { + db.Ado.BeginTran(); + + db.Ado.CommitTran(); + } + catch (Exception) + { + db.Ado.RollbackTran(); + throw; + } + } + private static void Group() + { + var db = GetInstance(); + var list = db.Queryable() + .GroupBy(it => it.Name) + .GroupBy(it => it.Id).Having(it => SqlFunc.AggregateAvg(it.Id) > 0) + .Select(it => new { idAvg = SqlFunc.AggregateAvg(it.Id), name = it.Name }).ToList(); + + + var list2 = db.Queryable() + .GroupBy(it => new { it.Id, it.Name }).Having(it => SqlFunc.AggregateAvg(it.Id) > 0) + .Select(it => new { idAvg = SqlFunc.AggregateAvg(it.Id), name = it.Name }).ToList(); + + // group id,name take first + var list3 = db.Queryable() + .PartitionBy(it => new { it.Id, it.Name }).Take(1).ToList(); + + + //SQL: + //SELECT AVG([Id]) AS[idAvg], [Name] AS[name] FROM[Student] GROUP BY[Name],[Id] HAVING(AVG([Id]) > 0 ) + + //SqlFunc.AggregateSum(object thisValue) + //SqlFunc.AggregateAvg(TResult thisValue) + //SqlFunc.AggregateMin(object thisValue) + //SqlFunc.AggregateMax(object thisValue) + //SqlFunc.AggregateCount(object thisValue) + } + private static void Ado() + { + var db = GetInstance(); + db.Ado.BeginTran(); + var t1 = db.Ado.SqlQuery("select 'a'"); + var t2 = db.Ado.GetInt("select 1"); + var t3 = db.Ado.GetDataTable("select 1 as id"); + db.Ado.CommitTran(); + //more + //db.Ado.GetXXX... + } + public static void Easy() + { + var db = GetInstance(); + var getAll = db.Queryable().ToList(); + var getAllOrder = db.Queryable().OrderBy(it => it.Id).OrderBy(it => it.Name, OrderByType.Desc).ToList(); + var getId = db.Queryable().Select(it => it.Id).ToList(); + var getNew = db.Queryable().Where(it => it.Id == 1).Select(it => new { id = SqlFunc.IIF(it.Id == 0, 1, it.Id), it.Name, it.SchoolId }).ToList(); + var getAllNoLock = db.Queryable().With(SqlWith.NoLock).ToList(); + var getByPrimaryKey = db.Queryable().InSingle(2); + var getSingleOrDefault = db.Queryable().Single(); + var getFirstOrDefault = db.Queryable().First(); + var getByWhere = db.Queryable().Where(it => it.Id == 1 || it.Name == "a").ToList(); + var getByFuns = db.Queryable().Where(it => SqlFunc.IsNullOrEmpty(it.Name)).ToList(); + var sum = db.Queryable().Sum(it => it.Id); + var isAny = db.Queryable().Where(it => it.Id == -1).Any(); + var isAny2 = db.Queryable().Any(it => it.Id == -1); + var getListByRename = db.Queryable().AS("Student").ToList(); + var in1 = db.Queryable().In(it => it.Id, new int[] { 1, 2, 3 }).ToList(); + var in2 = db.Queryable().In(new int[] { 1, 2, 3 }).ToList(); + int[] array = new int[] { 1, 2 }; + var in3 = db.Queryable().Where(it => SqlFunc.ContainsArray(array, it.Id)).ToList(); + var group = db.Queryable().GroupBy(it => it.Id) + .Having(it => SqlFunc.AggregateCount(it.Id) > 10) + .Select(it => new { id = SqlFunc.AggregateCount(it.Id) }).ToList(); + + var between = db.Queryable().Where(it => SqlFunc.Between(it.Id, 1, 20)).ToList(); + + var getTodayList = db.Queryable().Where(it => SqlFunc.DateIsSame(it.CreateTime, DateTime.Now)).ToList(); + } + public static void Page() + { + var db = GetInstance(); + var pageIndex = 1; + var pageSize = 2; + var totalCount = 0; + //page + var page = db.Queryable().OrderBy(it => it.Id).ToPageList(pageIndex, pageSize, ref totalCount); + + //page join + var pageJoin = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }).ToPageList(pageIndex, pageSize, ref totalCount); + + //top 5 + var top5 = db.Queryable().Take(5).ToList(); + + //skip5 + var skip5 = db.Queryable().Skip(5).ToList(); + } + public static void Where() + { + var db = GetInstance(); + //join + var list = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }) + .Where((st, sc) => sc.Id == 1) + .Where((st, sc) => st.Id == 1) + .Where((st, sc) => st.Id == 1 && sc.Id == 2).ToList(); + + //SELECT [st].[Id],[st].[SchoolId],[st].[Name],[st].[CreateTime] FROM [Student] st + //Left JOIN School sc ON ( [st].[SchoolId] = [sc].[Id] ) + //WHERE ( [sc].[Id] = @Id0 ) AND ( [st].[Id] = @Id1 ) AND (( [st].[Id] = @Id2 ) AND ( [sc].[Id] = @Id3 )) + + + //Where If + string name = null; + string name2 = "sunkaixuan"; + var list2 = db.Queryable() + .WhereIF(!string.IsNullOrEmpty(name), it => it.Name == name) + .WhereIF(!string.IsNullOrEmpty(name2), it => it.Name == name2).ToList(); + } + public static void Join() + { + var db = GetInstance(); + //join 2 + var list = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }) + .Where(st => st.Name == "jack").ToList(); + + //join 3 + var list2 = db.Queryable((st, sc, st2) => new object[] { + JoinType.Left,st.SchoolId==sc.Id, + JoinType.Left,st.SchoolId==st2.Id + }) + .Where((st, sc, st2) => st2.Id == 1 || sc.Id == 1 || st.Id == 1).ToList(); + + //join return List + var list3 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }).Select((st, sc) => new ViewModelStudent { Name = st.Name, SchoolId = sc.Id }).ToList(); + + //join Order By (order by st.id desc,sc.id desc) + var list4 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }) + .OrderBy(st => st.Id, OrderByType.Desc) + .OrderBy((st, sc) => sc.Id, OrderByType.Desc) + .Select((st, sc) => new ViewModelStudent { Name = st.Name, SchoolId = sc.Id }).ToList(); + + + //join 2 + var list4_1 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id&& st.Name == "jack" + }).ToList(); + + + //The simple use of Join 2 table + var list5 = db.Queryable((st, sc) => st.SchoolId == sc.Id).Select((st,sc)=>new {st.Name,st.Id,schoolName=sc.Name}).ToList(); + + //join 3 table + var list6 = db.Queryable((st, sc,sc2) => st.SchoolId == sc.Id&&sc.Id==sc2.Id) + .Select((st, sc,sc2) => new { st.Name, st.Id, schoolName = sc.Name,schoolName2=sc2.Name }).ToList(); + + //join 3 table page + var list7= db.Queryable((st, sc, sc2) => st.SchoolId == sc.Id && sc.Id == sc2.Id) + .Select((st, sc, sc2) => new { st.Name, st.Id, schoolName = sc.Name, schoolName2 = sc2.Name }).ToPageList(1,2); + + //join 3 table page + var list8 = db.Queryable((st, sc, sc2) => st.SchoolId == sc.Id && sc.Id == sc2.Id) + .OrderBy(st=>st.Id) + .Select((st, sc, sc2) => new { st.Name, st.Id, schoolName = sc.Name, schoolName2 = sc2.Name }).ToPageList(1, 2); + } + public static void Funs() + { + var db = GetInstance(); + var t1 = db.Queryable().Where(it => SqlFunc.ToLower(it.Name) == SqlFunc.ToLower("JACK")).ToList(); + //SELECT [Id],[SchoolId],[Name],[CreateTime] FROM [Student] WHERE ((LOWER([Name])) = (LOWER(@MethodConst0)) ) + + /***More Functions***/ + //SqlFunc.IsNullOrEmpty(object thisValue) + //SqlFunc.ToLower(object thisValue) + //SqlFunc.string ToUpper(object thisValue) + //SqlFunc.string Trim(object thisValue) + //SqlFunc.bool Contains(string thisValue, string parameterValue) + //SqlFunc.ContainsArray(object[] thisValue, string parameterValue) + //SqlFunc.StartsWith(object thisValue, string parameterValue) + //SqlFunc.EndsWith(object thisValue, string parameterValue) + //SqlFunc.Equals(object thisValue, object parameterValue) + //SqlFunc.DateIsSame(DateTime date1, DateTime date2) + //SqlFunc.DateIsSame(DateTime date1, DateTime date2, DateType dataType) + //SqlFunc.DateAdd(DateTime date, int addValue, DateType millisecond) + //SqlFunc.DateAdd(DateTime date, int addValue) + //SqlFunc.DateValue(DateTime date, DateType dataType) + //SqlFunc.Between(object value, object start, object end) + //SqlFunc.ToInt32(object value) + //SqlFunc.ToInt64(object value) + //SqlFunc.ToDate(object value) + //SqlFunc.ToString(object value) + //SqlFunc.ToDecimal(object value) + //SqlFunc.ToGuid(object value) + //SqlFunc.ToDouble(object value) + //SqlFunc.ToBool(object value) + //SqlFunc.Substring(object value, int index, int length) + //SqlFunc.Replace(object value, string oldChar, string newChar) + //SqlFunc.Length(object value) { throw new NotImplementedException(); } + //SqlFunc.AggregateSum(object thisValue) + //SqlFunc.AggregateAvg(TResult thisValue) + //SqlFunc.AggregateMin(object thisValue) + //SqlFunc.AggregateMax(object thisValue) + //SqlFunc.AggregateCount(object thisValue) + } + public static void Select() + { + var db = GetInstance(); + db.IgnoreColumns.Add("TestId", "Student"); + var s1 = db.Queryable().Select(it => new ViewModelStudent2 { Name = it.Name, Student = it }).ToList(); + var s2 = db.Queryable().Select(it => new { id = it.Id, w = new { x = it } }).ToList(); + var s3 = db.Queryable().Select(it => new { newid = it.Id }).ToList(); + var s4 = db.Queryable().Select(it => new { newid = it.Id, obj = it }).ToList(); + var s5 = db.Queryable().Select(it => new ViewModelStudent2 { Student = it, Name = it.Name }).ToList(); + var s6 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }) + .OrderBy(st => st.Id, OrderByType.Desc) + .OrderBy((st, sc) => sc.Id, OrderByType.Desc) + .Select((st, sc) => new { Name = st.Name, SchoolId = sc.Id }).ToList(); + } + private static void Sqlable() + { + var db = GetInstance(); + var join3 = db.Queryable("Student", "st") + .AddJoinInfo("School", "sh", "sh.id=st.schoolid") + .Where("st.id>@id") + .AddParameters(new { id = 1 }) + .Select("st.*").ToList(); + //SELECT st.* FROM [Student] st Left JOIN School sh ON sh.id=st.schoolid WHERE st.id>@id + } + private static void Enum() + { + var db = GetInstance(); + var list = db.Queryable().AS("Student").Where(it => it.SchoolId == SchoolEnum.HarvardUniversity).ToList(); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/2_Update.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/2_Update.cs new file mode 100644 index 000000000..2f9a678a2 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/2_Update.cs @@ -0,0 +1,63 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Demo +{ + public class Update : DemoBase + { + public static void Init() + { + var db = GetInstance(); + var updateObj = new Student() { Id = 1, Name = "jack", SchoolId = 0, CreateTime = Convert.ToDateTime("2017-05-21 09:56:12.610") }; + var updateObjs = new List() { updateObj, new Student() { Id = 2, Name = "sun", SchoolId = 0 } }.ToArray(); + db.IgnoreColumns.Add("TestId", "Student"); + //db.MappingColumns.Add("id","dbid", "Student"); + + + //update reutrn Update Count + var t1 = db.Updateable(updateObj).ExecuteCommand(); + + //Only update Name + var t3 = db.Updateable(updateObj).UpdateColumns(it => new { it.Name }).ExecuteCommand(); + var t3_1 = db.Updateable(updateObj).UpdateColumns(it => it=="Name").ExecuteCommand(); + + + //Ignore Name and TestId + var t4 = db.Updateable(updateObj).IgnoreColumns(it => new { it.Name, it.TestId }).ExecuteCommand(); + + //Ignore Name and TestId + var t5 = db.Updateable(updateObj).IgnoreColumns(it => it == "Name" || it == "TestId").With(SqlWith.UpdLock).ExecuteCommand(); + + + //Use Lock + var t6 = db.Updateable(updateObj).With(SqlWith.UpdLock).ExecuteCommand(); + + //update List + var t7 = db.Updateable(updateObjs).ExecuteCommand(); + + //Re Set Value + var t8 = db.Updateable(updateObj) + .ReSetValue(it => it.Name == (it.Name + 1)).ExecuteCommand(); + + //Where By Expression + var t9 = db.Updateable(updateObj).Where(it => it.Id == 1).ExecuteCommand(); + + //Update By Expression Where By Expression + var t10 = db.Updateable() + .UpdateColumns(it => new Student() { Name = "a", CreateTime = DateTime.Now }) + .Where(it => it.Id == 11).ExecuteCommand(); + + //Rename + db.Updateable().AS("Student").UpdateColumns(it => new School() { Name = "jack" }).Where(it => it.Id == 1).ExecuteCommand(); + //Update Student set Name='jack' Where Id=1 + + //Column is null no update + db.Updateable(updateObj).Where(true).ExecuteCommand(); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/3_Insert.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/3_Insert.cs new file mode 100644 index 000000000..c9e52329a --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/3_Insert.cs @@ -0,0 +1,58 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Demo +{ + public class Insert:DemoBase + { + public static void Init() + { + var db = GetInstance(); + db.IgnoreColumns.Add("TestId", "Student"); + + var insertObj = new Student() { Name = "jack", CreateTime = Convert.ToDateTime("2010-1-1"), SchoolId = 1 }; + + //Insert reutrn Insert Count + var t2 = db.Insertable(insertObj).ExecuteCommand(); + + //Insert reutrn Identity Value + var t3 = db.Insertable(insertObj).ExecuteReutrnIdentity(); + + + //Only insert Name and SchoolId + var t4 = db.Insertable(insertObj).InsertColumns(it => new { it.Name, it.SchoolId }).ExecuteReutrnIdentity(); + var t4_1 = db.Insertable(insertObj).InsertColumns(it => it=="Name"||it== "SchoolId").ExecuteReutrnIdentity(); + + + //Ignore TestId + var t5 = db.Insertable(insertObj).IgnoreColumns(it => new { it.Name, it.TestId }).ExecuteReutrnIdentity(); + + + //Ignore TestId + var t6 = db.Insertable(insertObj).IgnoreColumns(it => it == "Name" || it == "TestId").ExecuteReutrnIdentity(); + + + //Use Lock + var t8 = db.Insertable(insertObj).With(SqlWith.UpdLock).ExecuteCommand(); + + + var insertObj2 = new Student() { Name = null, CreateTime = Convert.ToDateTime("2010-1-1") }; + var t9 = db.Insertable(insertObj2).Where(true/* Is insert null */, false/*off identity*/).ExecuteCommand(); + + //Insert List + var insertObjs = new List(); + for (int i = 0; i < 1000; i++) + { + insertObjs.Add(new Student() { Name = "name" + i }); + } + var t10 = db.Insertable(insertObjs.ToArray()).InsertColumns(it => new { it.Name }).ExecuteCommand(); + + var t11 = db.Insertable(insertObjs.ToArray()).ExecuteCommand(); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/4_Delete.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/4_Delete.cs new file mode 100644 index 000000000..960434203 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/4_Delete.cs @@ -0,0 +1,33 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Demo +{ + public class Delete:DemoBase + { + public static void Init() + { + var db = GetInstance(); + //by entity + var t1 = db.Deleteable().Where(new Student() { Id = 1 }).ExecuteCommand(); + + //use lock + var t2 = db.Deleteable().With(SqlWith.RowLock).ExecuteCommand(); + + + //by primary key + var t3 = db.Deleteable().In(1).ExecuteCommand(); + + //by primary key array + var t4 = db.Deleteable().In(new int[] { 1, 2 }).ExecuteCommand(); + + //by expression + var t5 = db.Deleteable().Where(it => it.Id == 1).ExecuteCommand(); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_CodeFirst.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_CodeFirst.cs new file mode 100644 index 000000000..3c5cb24f0 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_CodeFirst.cs @@ -0,0 +1,52 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Demo +{ + public class CodeTable + { + + [SugarColumn(IsNullable =false ,IsPrimaryKey =true,IsIdentity =true)] + public int Id { get; set; } + [SugarColumn(Length = 21,OldColumnName = "Name2")] + public string Name{ get; set; } + [SugarColumn(IsNullable = true,Length =10)] + public string IsOk { get; set; } + public Guid Guid { get; set; } + public decimal Decimal { get; set; } + [SugarColumn(IsNullable = true)] + public DateTime? DateTime { get; set; } + [SugarColumn(IsNullable = true,OldColumnName = "Dob")] + public double? Dob2 { get; set; } + [SugarColumn(Length =10)] + public string A { get; set; } + } + public class CodeTable2 { + public int Id { get; set; } + public string Name { get; set; } + [SugarColumn(IsIgnore =true)] + public string TestId { get; set; } + } + public class CodeFirst : DemoBase + { + public static void Init() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString, + DbType = DbType.SqlServer, + IsAutoCloseConnection = true, + InitKeyType = InitKeyType.Attribute + }); + + //Backup table + //db.CodeFirst.BackupTable().InitTables(typeof(CodeTable),typeof(CodeTable2)); + + //No backup table + db.CodeFirst.InitTables(typeof(CodeTable),typeof(CodeTable2)); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_DbFirst.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_DbFirst.cs new file mode 100644 index 000000000..7e79a7734 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/5_DbFirst.cs @@ -0,0 +1,72 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Demo +{ + public class DbFirst : DemoBase + { + public static void Init() + { + var db = GetInstance(); + //Create all class + db.DbFirst.CreateClassFile("c:\\Demo\\1"); + + //Create student calsss + db.DbFirst.Where("Student").CreateClassFile("c:\\Demo\\2"); + //Where(array) + + //Mapping name + db.MappingTables.Add("ClassStudent", "Student"); + db.MappingColumns.Add("NewId", "Id", "ClassStudent"); + db.DbFirst.Where("Student").CreateClassFile("c:\\Demo\\3"); + + //Remove mapping + db.MappingTables.Clear(); + + //Create class with default value + db.DbFirst.IsCreateDefaultValue().CreateClassFile("c:\\Demo\\4", "Demo.Models"); + + + //Mapping and Attribute + db.MappingTables.Add("ClassStudent", "Student"); + db.MappingColumns.Add("NewId", "Id", "ClassStudent"); + db.DbFirst.IsCreateAttribute().Where("Student").CreateClassFile("c:\\Demo\\5"); + + + //Remove mapping + db.MappingTables.Clear(); + db.MappingColumns.Clear(); + + //Custom format,Change old to new + db.DbFirst. + SettingClassTemplate(old => + { + return old; + }) + .SettingNamespaceTemplate(old => + { + return old; + }) + .SettingPropertyDescriptionTemplate(old => + { + return @" /// + /// Desc_New:{PropertyDescription} + /// Default_New:{DefaultValue} + /// Nullable_New:{IsNullable} + /// "; + }) + .SettingPropertyTemplate(old => + { + return old; + }) + .SettingConstructorTemplate(old => + { + return old; + }) + .CreateClassFile("c:\\Demo\\6"); + } + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/6_ComplexModel.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/6_ComplexModel.cs new file mode 100644 index 000000000..5ca494f05 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/6_ComplexModel.cs @@ -0,0 +1,78 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using SqlSugar; +using OrmTest.Demo; + +namespace OrmTest.Demo +{ + public class ComplexModel : DemoBase + { + public static void Init() + { + var db = GetInstance(); + var students = db.Queryable().ToList(); + if (students != null) + { + foreach (var item in students) + { + Console.WriteLine(item.SchoolName); + if (item.SchoolSingle != null) + { + Console.WriteLine(item.SchoolSingle.Name); + } + if (item.SchoolList != null) + { + Console.WriteLine(item.SchoolList.Count); + } + } + } + } + } + + [SugarTable("Student")] + public class CMStudent : ModelContext + { + public int Id { get; set; } + public string Name { get; set; } + public int SchoolId { get; set; } + + [SugarColumn(IsIgnore = true)] + public string SchoolName + { + get + { + if (this.SchoolSingle != null) + return this.SchoolSingle.Name; + else + return null; + } + } + + [SugarColumn(IsIgnore = true)] + public CMSchool SchoolSingle + { + get + { + return base.CreateMapping().Single(it => it.Id == this.SchoolId); + } + } + + [SugarColumn(IsIgnore = true)] + public List SchoolList + { + get + { + return base.CreateMapping().Where(it => it.Id == this.SchoolId).ToList(); + } + } + } + + [SugarTable("School")] + public class CMSchool + { + public int Id { get; set; } + public string Name { get; set; } + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/7_Filter.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/7_Filter.cs new file mode 100644 index 000000000..273f6f814 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/7_Filter.cs @@ -0,0 +1,72 @@ +using OrmTest.Demo; +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Demo +{ + public class Filter : DemoBase + { + public static void Init() + { + + + //gobal filter + var db = GetInstance1(); + + var sql = db.Queryable().ToSql(); + //SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WHERE isDelete=0 + + var sql2 = db.Queryable((f, s) => new object[] { JoinType.Left, f.SchoolId == s.Id }).ToSql(); + //SELECT[f].[ID],[f].[SchoolId],[f].[Name],[f].[CreateTime] + //FROM[STudent] f Left JOIN School s ON([f].[SchoolId] = [s].[Id]) WHERE f.isDelete=0 + + + //Specify name filter + var sql3 = db.Queryable().Filter("query1").ToSql(); + //SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WHERE WHERE id>@id AND isDelete=0 + + + //Specify key filter and disabled global filter + string key = "query1"; + var sql4 = db.Queryable().Filter(key,true).ToSql(); + //SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WHERE WHERE id>@id + + } + + public static SqlSugarClient GetInstance1() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + db.QueryFilter + .Add(new SqlFilterItem() + { + FilterValue = filterDb => + { + return new SqlFilterResult() { Sql = " isDelete=0" }; + }, + IsJoinQuery = false + }).Add(new SqlFilterItem() + { + FilterValue = filterDb => + { + return new SqlFilterResult() { Sql = " f.isDelete=0" }; + }, + IsJoinQuery = true + }) + .Add(new SqlFilterItem() + { + FilterName = "query1", + FilterValue = filterDb => + { + return new SqlFilterResult() { Sql = " id>@id", Parameters = new { id = 1 } }; + }, + IsJoinQuery = false + }); + return db; + } + } + +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/8_JoinSql.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/8_JoinSql.cs new file mode 100644 index 000000000..78adb85b8 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/8_JoinSql.cs @@ -0,0 +1,51 @@ +using OrmTest.Demo; +using OrmTest.Models; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Demo +{ + /// + /// Secure string operations + /// + public class JoinSql : DemoBase + { + public static void Init() + { + Where(); + OrderBy(); + } + + private static void Where() + { + var db = GetInstance(); + //Parameterized processing + string value = "'jack';drop table Student"; + var list = db.Queryable().Where("name=@name", new { name = value }).ToList(); + //Nothing happened + } + + private static void OrderBy() + { + var db = GetInstance(); + //propertyName is valid + string propertyName = "Id"; + string dbColumnName = db.EntityProvider.GetDbColumnName(propertyName); + var list = db.Queryable().OrderBy(dbColumnName).ToList(); + + //propertyName is invalid + try + { + propertyName = "Id'"; + dbColumnName = db.EntityProvider.GetDbColumnName(propertyName); + var list2 = db.Queryable().OrderBy(dbColumnName).ToList(); + } + catch (Exception ex) + { + Console.WriteLine(ex.Message); + } + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/DemoBase.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/DemoBase.cs new file mode 100644 index 000000000..9cbda2855 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Demos/DemoBase.cs @@ -0,0 +1,23 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Demo +{ + public class DemoBase + { + public static SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + db.Ado.IsEnableLogEvent = true; + db.Ado.LogEventStarting = (sql, pars) => + { + Console.WriteLine(sql + "\r\n" + db.RewritableMethods.SerializeObject(pars)); + Console.WriteLine(); + }; + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo.cs new file mode 100644 index 000000000..935aefaff --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo.cs @@ -0,0 +1,135 @@ +using System; +using System.Linq; +using System.Text; + +namespace OrmTest.Models +{ + /// + /// + /// + public class DataTestInfo + { + public DataTestInfo(){ + + } + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public int Int1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public int? Int2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public string String {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public decimal Decimal1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public decimal? Decimal2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public DateTime Datetime1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public DateTime? Datetime2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public byte[] Image1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public byte[] Image2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public Guid Guid1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public Guid? Guid2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public decimal Money1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public decimal? Money2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public byte[] Varbinary1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public byte[] Varbinary2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public double Float1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public double? Float2 {get;set;} + + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo2.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo2.cs new file mode 100644 index 000000000..8f425a4c1 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/DataTestInfo2.cs @@ -0,0 +1,44 @@ +using System; +using System.Linq; +using System.Text; + +namespace OrmTest.Models +{ + /// + /// + /// + public class DataTestInfo2 + { + public DataTestInfo2(){ + + } + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public Guid PK {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:False + /// + public bool Bool1 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public bool? Bool2 {get;set;} + + /// + /// Desc: + /// Default: + /// Nullable:True + /// + public string Text1 {get;set;} + + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Enum.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Enum.cs new file mode 100644 index 000000000..09102a410 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Enum.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.Models +{ + public enum SchoolEnum + { + HarvardUniversity = 0, + UniversityOfOxford = 1 + } + public class StudentEnum + { + public int Id { get; set; } + public SchoolEnum SchoolId { get; set; } + public string Name { get; set; } + public DateTime? CreateTime { get; set; } + [SqlSugar.SugarColumn(IsIgnore =true)] + public int TestId { get; set; } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/School.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/School.cs new file mode 100644 index 000000000..4373f3feb --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/School.cs @@ -0,0 +1,17 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Models +{ + public class School + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int Id { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Student.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Student.cs new file mode 100644 index 000000000..421b87bcf --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/Student.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using System.Linq.Expressions; + +namespace OrmTest.Models +{ + [SugarTable("STudent")] + public class Student + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true, ColumnName = "ID")] + public int Id { get; set; } + public int? SchoolId { get; set; } + public string Name { get; set; } + public DateTime? CreateTime { get; set; } + [SugarColumn(IsIgnore=true)] + public int TestId { get; set; } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/ViewModelStudent.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/ViewModelStudent.cs new file mode 100644 index 000000000..6705f3dcb --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Models/ViewModelStudent.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.Models +{ + public class ViewModelStudent:Student + { + + } + public class ViewModelStudent2 + { + public string Name { get; set; } + public Student Student { get; set; } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/PerformanceBase.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/PerformanceBase.cs new file mode 100644 index 000000000..f26f1557e --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/PerformanceBase.cs @@ -0,0 +1,31 @@ + +using SyntacticSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.PerformanceTesting +{ + public class PerformanceBase + { + public int count = 100; + public void Execute(string title, Action fun) + { + PerformanceTest ptef = new PerformanceTest(); + ptef.SetCount(count);//执行count次 + ptef.Execute( + i => + { + fun(); + + }, + res => + { + Console.WriteLine(string.Format("Execute {0} time，{1}{2}", count, title, res)); + }); + + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/SqlSugarPerformance.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/SqlSugarPerformance.cs new file mode 100644 index 000000000..5299a8813 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/PerformanceTesting/SqlSugarPerformance.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using OrmTest.Models; + +namespace OrmTest.PerformanceTesting +{ + public class SqlSugarPerformance : PerformanceBase + { + public SqlSugarPerformance(int eachCount) + { + this.count = eachCount; + } + public void Select() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString, + DbType = DbType.SqlServer, + IsAutoCloseConnection = false + }); + db.IgnoreColumns.Add("TestId", "Student"); + db.Queryable().Select(it => new ViewModelStudent2 { Name = it.Name, Student = it }).ToList(); + base.Execute("sqlsuagr", () => + { + var test = db.Queryable().Select(it => new ViewModelStudent2 { Name = it.Name, Student = it }).ToList(); + }); + db.Close(); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Program.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Program.cs index 5ff2eb417..8ae6958c5 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Program.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/Program.cs @@ -1,4 +1,6 @@ -using System; +using OrmTest.PerformanceTesting; +using OrmTest.UnitTest; +using System; using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; @@ -9,6 +11,33 @@ namespace SqlServerTest { public static void Main(string[] args) { + /***Unit Test***/ + new Field(1).Init(); + new Where(1).Init(); + new Method(1).Init(); + new JoinQuery(1).Init(); + new SingleQuery(1).Init(); + new SelectQuery(1).Init(); + new AutoClose(1).Init(); + new Insert(1).Init(); + new Delete(1).Init(); + new Update(1).Init(); + new Mapping(1).Init(); + new DataTest(1).Init(); + + /***Performance Test***/ + new SqlSugarPerformance(100).Select(); + + /***Demo***/ + OrmTest.Demo.Query.Init(); + OrmTest.Demo.Insert.Init(); + OrmTest.Demo.Delete.Init(); + OrmTest.Demo.Update.Init(); + OrmTest.Demo.DbFirst.Init(); + OrmTest.Demo.JoinSql.Init(); + OrmTest.Demo.Filter.Init(); + OrmTest.Demo.ComplexModel.Init(); + OrmTest.Demo.CodeFirst.Init(); } } } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/DataTest.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/DataTest.cs new file mode 100644 index 000000000..c0d28941e --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/DataTest.cs @@ -0,0 +1,77 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest.UnitTest +{ + public class DataTest : UnitTestBase + { + private DataTest() { } + public DataTest(int eachCount) + { + this.Count = eachCount; + } + + public void Init() + { + var db = GetInstance(); + db.DbMaintenance.TruncateTable("DataTestInfo"); + var insertObject = new DataTestInfo() + { + Datetime1 = DateTime.Now, + Datetime2 = DateTime.Now, + Decimal1 = 1, + Decimal2 = 2, + Float1 = 3, + Float2 = 4, + Guid1 = Guid.Empty, + Guid2 = null, + Image1 = new byte[] { 1, 2 }, + Image2 = new byte[] { 2, 3 }, + Int2 = 6, + Money1 = 7, + Money2 = 8, + Varbinary1 = new byte[] { 4, 5 }, + Varbinary2 = null, + String = "string" + }; + var id = db.Insertable(insertObject).ExecuteReutrnIdentity(); + var data = db.Queryable().InSingle(id); + if ( + insertObject.Datetime1.ToString("yyyy-MM-dd HH:mm:ss") != data.Datetime1.ToString("yyyy-MM-dd HH:mm:ss") || + insertObject.Decimal1 != data.Decimal1 || + insertObject.Float1 != data.Float1 || + insertObject.Float2 != data.Float2 || + insertObject.Int2 != data.Int2 || + insertObject.Money1 != data.Money1 || + string.Join(",", insertObject.Varbinary1) != string.Join(",", data.Varbinary1) || + insertObject.String != data.String) + { + throw new Exception("DataTest Error"); + } + data.Float1= data.Float1+1; + db.Updateable(data).ExecuteCommand(); + data = db.Queryable().InSingle(id); + if ( + insertObject.Datetime1.ToString("yyyy-MM-dd HH:mm:ss") != data.Datetime1.ToString("yyyy-MM-dd HH:mm:ss") || + insertObject.Decimal1 != data.Decimal1 || + (insertObject.Float1+1) != data.Float1 || + insertObject.Float2 != data.Float2 || + insertObject.Int2 != data.Int2 || + insertObject.Money1 != data.Money1 || + string.Join(",", insertObject.Varbinary1) != string.Join(",", data.Varbinary1) || + insertObject.String != data.String) + { + throw new Exception("DataTest Error"); + } + } + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Delete.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Delete.cs new file mode 100644 index 000000000..3575648f3 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Delete.cs @@ -0,0 +1,62 @@ +using OrmTest.Models; +using OrmTest.UnitTest; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Delete : UnitTestBase + { + private Delete() { } + public Delete(int eachCount) + { + this.Count = eachCount; + } + + public void Init() + { + var db = GetInstance(); + //by entity + var t1= db.Deleteable().Where(new Student() { Id = 1 }).ToSql(); + base.Check(@"DELETE FROM [STudent] WHERE [Id] IN ('1') ", + null, + t1.Key, + null, "Delte t1 error" + ); + //use lock + var t2 = db.Deleteable().With(SqlWith.RowLock).ToSql(); + base.Check(@"DELETE FROM [STudent] WITH(ROWLOCK) ", + null, + t2.Key, + null, "Delte t2 error" + ); + + //by primary key + var t3 = db.Deleteable().In(1).ToSql(); + base.Check(@"DELETE FROM [STudent] WHERE [Id] IN ('1') ", + null, + t3.Key, + null, "Delte tt error" + ); + //by primary key array + var t4 = db.Deleteable().In(new int[] { 1,2}).ToSql(); + base.Check(@"DELETE FROM [STudent] WHERE [Id] IN ('1','2') ", null, t4.Key, null, "Update t4 error"); + + //by expression + var t5 = db.Deleteable().Where(it=>it.Id==1).ToSql(); + base.Check(@"DELETE FROM [STudent] WHERE ( [ID] = @Id0 ) ", new List() { + new SugarParameter("@Id0",1) + }, t5.Key, t5.Value, "Delte t5 error"); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Field.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Field.cs new file mode 100644 index 000000000..9f7384f0e --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Field.cs @@ -0,0 +1,51 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Field : UnitTestBase + { + private Field() { } + public Field(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + FieldSingle(); + FieldMultiple(); + } + base.End("Filed Test"); + } + private void FieldSingle() + { + Expression> exp = it => it.Name; + ExpressionContext expContext = GetContext(); + expContext.Resolve(exp, ResolveExpressType.FieldSingle); + var selectorValue = expContext.Result.GetString(); + Check(selectorValue, null, expContext.GetTranslationColumnName("Name"), null, "FieldSingle error"); + } + private void FieldMultiple() + { + Expression> exp = it => it.Name; + ExpressionContext expContext = GetContext(); + expContext.Resolve(exp, ResolveExpressType.FieldMultiple); + var selectorValue = expContext.Result.GetString(); + Check(selectorValue, null, expContext.GetTranslationColumnName("it.Name"), null, "FieldMultiple error"); + } + + public ExpressionContext GetContext() + { + return new SqlServerExpressionContext();//可以更换 + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Method.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Method.cs new file mode 100644 index 000000000..cf40bc647 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Method.cs @@ -0,0 +1,612 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Method : UnitTestBase + { + private Method() { } + public Method(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + + //Native methods + ExtendContainsArray(); + ConvetToString(); + ExtendToString(); + ExtendSubstring(); + ExtendDate(); + + //SqlFun methods + IIF(); + IIF2(); + #region StringIsNullOrEmpty + HasValue(); + HasNumber(); + StringIsNullOrEmpty(); + StringIsNullOrEmpty2(); + StringIsNullOrEmpty3(); + StringIsNullOrEmpty4(); + StringIsNullOrEmpty5(); + #endregion + ToUpper(); + ToLower(); + Trim(); + Contains(); + Contains2(); + ContainsArray(); + StartsWith(); + EndsWith(); + Between(); + Equals(); + Equals_2(); + DateIsSameByDay(); + DateIsSameByType(); + DateAddDay(); + DateAddByType(); + DateValue(); + ToInt32(); + ToInt64(); + ToDate(); + Tostring(); + ToDecimal(); + ToGuid(); + ToDouble(); + ToBool(); + Substring(); + Replace(); + Length(); + } + base.End("Method Test"); + } + + private void ExtendToString() + { + Expression> exp = it => it.Id.ToString() == "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST([Id] AS NVARCHAR(MAX)) = @Const0 )", new List() { + new SugarParameter("@Const0","a") + }, "ExtendToString error"); + } + + private void ConvetToString() + { + Expression> exp = it => Convert.ToString(it.Id) == "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST([Id] AS NVARCHAR(MAX)) = @Const0 )", new List() { + new SugarParameter("@Const0","a") + }, "ConvetToString error"); + } + + + private void Length() + { + Expression> exp = it => SqlFunc.Length("aaaa") > 1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(LEN(@MethodConst0) > @Const1 )", new List() { + new SugarParameter("@MethodConst0","aaaa"),new SugarParameter("@Const1",1) + }, "Length error"); + } + + private void Replace() + { + var x2 = Guid.NewGuid(); + Expression> exp = it => SqlFunc.Replace("aaaa", "a", "1") == "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(REPLACE(@MethodConst0,@MethodConst1,@MethodConst2) = @Const3 )", new List() { + new SugarParameter("@MethodConst0","aaaa"), new SugarParameter("@MethodConst1","a") , new SugarParameter("@MethodConst2","1"),new SugarParameter("@Const3","a") + }, "Replace error"); + } + + private void Substring() + { + var x2 = Guid.NewGuid(); + Expression> exp = it => SqlFunc.Substring("aaaa", 0, 2) == "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(SUBSTRING(@MethodConst0,1 + @MethodConst1,@MethodConst2) = @Const3 )", new List() { + new SugarParameter("@MethodConst0","aaaa"), new SugarParameter("@MethodConst1",0) , new SugarParameter("@MethodConst2",2),new SugarParameter("@Const3","a") + }, "Substring error"); + } + private void ExtendSubstring() + { + var x2 = Guid.NewGuid(); + Expression> exp = it =>"aaaa".Substring(0, 2)== "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(SUBSTRING(@MethodConst0,1 + @MethodConst1,@MethodConst2) = @Const3 )", new List() { + new SugarParameter("@MethodConst0","aaaa"), new SugarParameter("@MethodConst1",0) , new SugarParameter("@MethodConst2",2),new SugarParameter("@Const3","a") + }, "Substring error"); + } + + + private void ToBool() + { + var x2 = Guid.NewGuid(); + Expression> exp = it => SqlFunc.ToBool("true") == true; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS BIT) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","true"),new SugarParameter("@Const1",(bool)true) + }, "ToBool error"); + } + + private void ToDouble() + { + var x2 = Guid.NewGuid(); + Expression> exp = it => SqlFunc.ToDouble("2") == 2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS FLOAT) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","2"),new SugarParameter("@Const1",(Double)2) + }, "ToDouble error"); + } + + private void ToGuid() + { + var x2 = Guid.NewGuid(); + Expression> exp = it => SqlFunc.ToGuid("A94027A3-476E-478D-8228-F4054394B874") == x2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS UNIQUEIDENTIFIER) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","A94027A3-476E-478D-8228-F4054394B874"),new SugarParameter("@Const1",x2) + }, "ToGuid error"); + } + + private void ToDecimal() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.ToDecimal("22") == 1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS MONEY) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","22"),new SugarParameter("@Const1",(decimal)1) + }, "ToDecimal error"); + } + + private void Tostring() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.ToString("2015-1-1") == "a"; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS NVARCHAR(MAX)) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","2015-1-1"),new SugarParameter("@Const1","a") + }, "Tostring error"); + } + + private void ToDate() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.ToDate("2015-1-1") == x2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS DATETIME) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","2015-1-1"),new SugarParameter("@Const1",x2) + }, "ToDate error"); + } + private void ExtendDate() + { + var x2 = DateTime.Now; + Expression> exp = it => Convert.ToDateTime("2015-1-1") == x2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS DATETIME) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","2015-1-1"),new SugarParameter("@Const1",x2) + }, "ExtendDate error"); + } + + private void ToInt64() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.ToInt64("3") == 1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS BIGINT) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","3"),new SugarParameter("@Const1",(Int64)1) + }, "ToInt64 error"); + } + + private void ToInt32() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.ToInt32("3") == 1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS INT) = @Const1 )", new List() { + new SugarParameter("@MethodConst0","3"),new SugarParameter("@Const1",1) + }, "ToInt32 error"); + } + + private void DateValue() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateValue(x2, DateType.Year) == 1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ((@MethodConst1(@MethodConst0)) = @Const2 ) ", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",DateType.Year),new SugarParameter("@Const2",1) + }, "DateValue error"); + } + + private void StartsWith() + { + Expression> exp = it => SqlFunc.StartsWith(it.Name, "a"); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] like @MethodConst0+'%') ", new List() { + new SugarParameter("@MethodConst0","a") + }, "StartsWith error"); + } + private void EndsWith() + { + Expression> exp = it => SqlFunc.EndsWith(it.Name, "a"); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] like '%'+@MethodConst0) ", new List() { + new SugarParameter("@MethodConst0","a") + }, "EndsWith"); + } + private void Between() + { + Expression> exp = it => SqlFunc.Between(it.Name, 1, 2); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] BETWEEN @MethodConst0 AND @MethodConst1) ", new List() { + new SugarParameter("@MethodConst0",1),new SugarParameter("@MethodConst1",2), + }, "Between error"); + } + + private void DateAddByType() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateAdd(x2, 11, DateType.Millisecond) == x2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "((DATEADD(@MethodConst2,@MethodConst1,@MethodConst0)) = @Const3 )", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",11),new SugarParameter("@Const3",x2), + new SugarParameter("@MethodConst2",DateType.Millisecond) + }, "DateAddByType error"); + } + private void DateAddDay() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateAdd(x2, 1) == x2; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "((DATEADD(day,@MethodConst1,@MethodConst0)) = @Const2 )", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",1),new SugarParameter("@Const2",x2) + }, "DateIsSameByType error"); + } + + private void DateIsSameByType() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateIsSame(x2, x2, DateType.Millisecond); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " (DATEDIFF(@MethodConst2,@MethodConst0,@MethodConst1)=0) ", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2), + new SugarParameter("@MethodConst2",DateType.Millisecond) + }, "DateIsSameByType error"); + } + private void DateIsSameByDay() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateIsSame(x2, x2); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(DATEDIFF(day,@MethodConst0,@MethodConst1)=0) ", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2) + }, "DateIsSameDay error"); + } + + private void Equals() + { + Expression> exp = it => SqlFunc.Equals(it.Name, "a"); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] = @MethodConst0) ", new List() { + new SugarParameter("@MethodConst0","a") + }, "Equals1 error"); + + + Expression> exp2 = it => SqlFunc.Equals("a", it.Name); + SqlServerExpressionContext expContext2 = new SqlServerExpressionContext(); + expContext2.Resolve(exp2, ResolveExpressType.WhereSingle); + var value2 = expContext2.Result.GetString(); + var pars2 = expContext2.Parameters; + base.Check(value2, pars2, " (@MethodConst0 = [Name]) ", new List() { + new SugarParameter("@MethodConst0","a") + }, "Equals2 error"); + } + private void Equals_2() + { + Expression> exp = it => SqlFunc.Equals(it.Name, it.Name); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] = [Name]) ", new List() { + new SugarParameter("@MethodConst0","a") + }, "Equals1 error"); + + + Expression> exp2 = it => SqlFunc.Equals("a", "a2"); + SqlServerExpressionContext expContext2 = new SqlServerExpressionContext(); + expContext2.Resolve(exp2, ResolveExpressType.WhereSingle); + var value2 = expContext2.Result.GetString(); + var pars2 = expContext2.Parameters; + base.Check(value2, pars2, " (@MethodConst0 = @MethodConst1) ", new List() { + new SugarParameter("@MethodConst0","a"),new SugarParameter("@MethodConst1","a2") + }, "Equals2 error"); + } + + private void Contains() + { + Expression> exp = it => SqlFunc.Contains(it.Name, "a"); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] like '%'+@MethodConst0+'%') ", new List() { + new SugarParameter("@MethodConst0","a") + }, "Contains error"); + } + private void Contains2(string name="a") + { + Expression> exp = it => SqlFunc.Contains(it.Name, name); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ([Name] like '%'+@MethodConst0+'%') ", new List() { + new SugarParameter("@MethodConst0","a") + }, "Contains2 error"); + } + + private void ExtendContainsArray() { + var array = new string[] { "1", "2" }.ToList(); + Expression> exp = it => array.Contains(it.Name); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, null, " ([Name] IN ('1','2')) ", null, "Contains2 error"); + } + + private void ContainsArray() + { + string[] array = new string[] { "1", "2" }; + Expression> exp = it => SqlFunc.ContainsArray(array, it.Name); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, null, " ([Name] IN ('1','2')) ", null, "Contains2 error"); + } + + private void Trim() + { + Expression> exp = it => SqlFunc.Trim(" a") == it.Name; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "((rtrim(ltrim(@MethodConst0))) = [Name] )", new List() { + new SugarParameter("@MethodConst0"," a") + }, "Trim error"); + } + + private void ToUpper() + { + Expression> exp = it => "a" == SqlFunc.ToUpper(it.Id); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( @Const0 = (UPPER([Id])) )", new List() { + new SugarParameter("@Const0","a") + }, "ToUpper error"); + } + private void ToLower() + { + Expression> exp = it => "a" == SqlFunc.ToLower(it.Id); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( @Const0 = (LOWER([Id])) )", new List() { + new SugarParameter("@Const0","a") + }, "ToLower error"); + } + + #region StringIsNullOrEmpty + private void StringIsNullOrEmpty() + { + Expression> exp = it => it.Id > 2 || SqlFunc.IsNullOrEmpty(it.Id); ; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( [Id] > @Id0 ) OR ( [Id]='' OR [Id] IS NULL ))", new List() { + new SugarParameter("@Id0",2) + }, "StringIsNullOrEmpty error"); + } + private void StringIsNullOrEmpty2() + { + Expression> exp = it => 2 == it.Id || SqlFunc.IsNullOrEmpty(true); ; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( @Id0 = [Id] ) OR ( @MethodConst1='' OR @MethodConst1 IS NULL ))", new List() { + new SugarParameter("@MethodConst1",true), + new SugarParameter("@Id0",2) + }, "StringIsNullOrEmpty2 error"); + } + private void StringIsNullOrEmpty3() + { + int a = 1; + Expression> exp = it => 2 == it.Id || SqlFunc.IsNullOrEmpty(a); ; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( @Id0 = [Id] ) OR ( @MethodConst1='' OR @MethodConst1 IS NULL ))", new List() { + new SugarParameter("@MethodConst1",1), + new SugarParameter("@Id0",2) + }, "StringIsNullOrEmpty3 error"); + } + private void StringIsNullOrEmpty4() + { + WhereConst.name = "xx"; + Expression> exp = it => 2 == it.Id || SqlFunc.IsNullOrEmpty(WhereConst.name); ; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( @Id0 = [Id] ) OR ( @MethodConst1='' OR @MethodConst1 IS NULL ))", new List() { + new SugarParameter("@MethodConst1","xx"), + new SugarParameter("@Id0",2) + }, "StringIsNullOrEmpty4 error"); + } + private void StringIsNullOrEmpty5() + { + WhereConst.name = "xx"; + Expression> exp = it => !SqlFunc.IsNullOrEmpty(WhereConst.name); ; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "NOT( @MethodConst0='' OR @MethodConst0 IS NULL )", new List() { + new SugarParameter("@MethodConst0","xx") + }, "StringIsNullOrEmpty5 error"); + } + #endregion + + private void HasValue() + { + Expression> exp = it => SqlFunc.HasValue(it.Name); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Name]<>'' AND [Name] IS NOT NULL )", new List() + { + + }, "HasValue error"); + } + + private void HasNumber() + { + Expression> exp = it => SqlFunc.HasNumber(it.Id); + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Id]>0 AND [Id] IS NOT NULL )", new List() + { + + + }, "HasNumber error"); + } + + private void IIF() + { + Expression> exp = it => SqlFunc.IIF(it.Id == 1, 1, 2)==1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( CASE WHEN ( [Id] = @Id0 ) THEN @MethodConst1 ELSE @MethodConst2 END ) = @Const3 )", new List() + { + new SugarParameter("@Id0",1), + new SugarParameter("@MethodConst1",1), + new SugarParameter("@MethodConst2",2), + new SugarParameter("@Const3",1) + }, "IIF error"); + } + + private void IIF2() + { + Expression> exp = it => SqlFunc.IIF(SqlFunc.Contains(it.Name,"a"), 1, 2)==1; + SqlServerExpressionContext expContext = new SqlServerExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( CASE WHEN ([Name] like '%'+@MethodConst0+'%') THEN @MethodConst1 ELSE @MethodConst2 END ) = @Const3 )", new List() + { + new SugarParameter("@MethodConst0","a"), + new SugarParameter("@MethodConst1",1), + new SugarParameter("@MethodConst2",2), + new SugarParameter("@Const3",1) + }, "IIF2 error"); + } + } +} + diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Select.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Select.cs new file mode 100644 index 000000000..4686721ce --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Select.cs @@ -0,0 +1,99 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Select : UnitTestBase + { + private Select() { } + public Select(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + single(); + Multiple(); + singleDynamic(); + MultipleDynamic(); + } + base.End("Select Test"); + } + + private void Multiple() + { + Expression> exp = (it, school) => new Student() { Name = "a", Id = it.Id, SchoolId = school.Id, TestId = it.Id + 1 }; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.SelectMultiple); + var selectorValue = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check( + selectorValue, + pars, + @" @constant1 AS Name , it.Id AS Id , school.Id AS SchoolId , ( it.Id + 1 ) AS TestId ", + new List(){ + new SugarParameter("@constant1","a")}, + "Select.Multiple Error"); + } + + private void MultipleDynamic() + { + Expression> exp = (it, school) => new { Name = "a", Id = it.Id / 2, SchoolId = school.Id }; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.SelectMultiple); + var selectorValue = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check( + selectorValue, + pars, + @" @constant1 AS Name , ( it.Id / 2 ) AS Id , school.Id AS SchoolId ", + new List(){ + new SugarParameter("@constant1","a")}, + "Select.MultipleDynamic Error"); + } + private void single() + { + int p = 1; + Expression> exp = it => new Student() { Name = "a", Id = it.Id, SchoolId = p,TestId=it.Id+1 }; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.SelectSingle); + var selectorValue = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check( + selectorValue, + pars, + @" @constant1 AS Name , Id AS Id , @constant3 AS SchoolId , ( Id + 1 ) AS TestId ", + new List(){ + new SugarParameter("@constant1","a"), + new SugarParameter("@constant3",1)}, + "Select.single Error"); + } + + private void singleDynamic() + { + string a = "a"; + Expression> exp = it => new { x = it.Id, shoolid = 1, name = a,p=it.Id*1 }; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.SelectSingle); + var selectorValue = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check( + selectorValue, + pars, + @" Id AS x , @constant2 AS shoolid , @constant3 AS name , ( Id * 1 ) AS p ", + new List(){ + new SugarParameter("@constant2",1), + new SugarParameter("@constant3","a")}, + "Select.single Error"); + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Where.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Where.cs new file mode 100644 index 000000000..fc6f74d56 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/ExpressionTest/Where.cs @@ -0,0 +1,258 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Where : UnitTestBase + { + private Where() { } + public Where(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + whereSingle1(); + whereSingle2(); + whereSingle3(); + whereSingle4(); + whereSingle5(); + whereSingle6(); + whereSingle7(new Student() { Id = 1 }); + whereSingle8(new Student() { Id = 1 }); + whereSingle9(new Student() { Id = 1 }); + whereSingle10(); + whereSingle11(); + whereSingle12(); + whereSingle13(); + whereSingle14(); + WhereMultiple1(); + WhereMultiple2(); + + } + base.End("Where Test"); + } + private void WhereMultiple1() + { + Expression> exp = it => it.Id > 1; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereMultiple); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [it].[Id] > @Id0 )", new List() { + new SugarParameter("@Id0",1) + }, "WhereMultiple1"); + } + private void WhereMultiple2() + { + string name = "a"; + WhereConst.name = "a1"; + Expression> exp = it => (it.Id > 1 && it.Name != name || it.Id == 1) || it.Name == WhereConst.name; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereMultiple); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " (((( [it].[Id] > @Id0 ) AND ( [it].[Name] <> @Name1 )) OR ( [it].[Id] = @Id2 )) OR ( [it].[Name] = @Name3 ))", new List() { + new SugarParameter("@Id0",1), + new SugarParameter("@Name1","a"), + new SugarParameter("@Id2",1), + new SugarParameter("@Name3","a1") + }, "WhereMultiple2"); + } + private void whereSingle1() + { + Expression> exp = it => it.Id > 1; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Id] > @Id0 )", new List() { + new SugarParameter("@Id0",1) + }, "whereSingle1"); + } + private void whereSingle2() + { + Expression> exp = it => 1 > it.Id; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( @Id0 > [Id] )", new List() { + new SugarParameter("@Id0",1) + }, "whereSingle2"); + } + private void whereSingle3() + { + Expression> exp = it => it.Id > 1 || it.Name == "a"; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " (( [Id] > @Id0 ) OR ( [Name] = @Name1 ))", new List() { + new SugarParameter("@Id0",1), + new SugarParameter("@Name1","a") + }, "whereSingle3"); + } + private void whereSingle4() + { + Expression> exp = it => (it.Id > 1 && it.Name != "a") || it.Name == "a1"; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ((( [Id] > @Id0 ) AND ( [Name] <> @Name1 )) OR ( [Name] = @Name2 )) ", new List() { + new SugarParameter("@Id0",1), + new SugarParameter("@Name1","a"), + new SugarParameter("@Name2","a1") + }, "whereSingle4"); + } + private void whereSingle5() + { + string name = "a"; + WhereConst.name = "a1"; + Expression> exp = it => (it.Id > 1 && it.Name != name) || it.Name == WhereConst.name; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " ((( [Id] > @Id0 ) AND ( [Name] <> @Name1 )) OR ( [Name] = @Name2 )) ", new List() { + new SugarParameter("@Id0",1), + new SugarParameter("@Name1","a"), + new SugarParameter("@Name2","a1") + }, "whereSingle5"); + } + private void whereSingle6() + { + string name = "a"; + WhereConst.name = "a1"; + Expression> exp = it => (it.Id > 1 && it.Name != name||it.Id==1) || it.Name == WhereConst.name; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " (((( [Id] > @Id0 ) AND ( [Name] <> @Name1 )) OR ( [Id] = @Id2 )) OR ( [Name] = @Name3 ))", new List() { + new SugarParameter("@Id0",1), + new SugarParameter("@Name1","a"), + new SugarParameter("@Id2",1), + new SugarParameter("@Name3","a1") + }, "whereSingle6"); + } + private void whereSingle7(Student st) + { + Expression> exp = it => it.Id > st.Id; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Id] > @Id0 )", new List() { + new SugarParameter("@Id0",1) + }, "whereSingle7"); + } + + private void whereSingle8(Student st) + { + Expression> exp = it => it.Name == null; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Name] IS NULL )", new List() { + + }, "whereSingle8"); + } + + private void whereSingle9(Student st) + { + Expression> exp = it => it.Name == st.Name; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Name] = @Name0 )", new List() + { + new SugarParameter("@Name0",null) + }, "whereSingle9"); + } + + + private void whereSingle10() + { + Expression> exp = it => true; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( 1 = 1 )", new List() + { + + }, "whereSingle10"); + } + + + private void whereSingle11() + { + Expression> exp = it => !true; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( 1 = 2 )", new List() + { + + }, "whereSingle11"); + } + + private void whereSingle12() + { + Expression> exp = it => it.Bool1==true; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Bool1] = @Bool10 )", new List() + { + new SugarParameter("@Bool10",true) + }, "whereSingle12"); + } + + private void whereSingle13() + { + Expression> exp = it => it.Name!=null; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "( [Name] IS NOT NULL )", new List() + { + + }, "whereSingle13"); + } + + private void whereSingle14() + { + Expression> exp = it =>true&& it.Name != null; + ExpressionContext expContext = new ExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(( 1 = 1 ) AND( [Name] IS NOT NULL ))", new List() + { + + }, "whereSingle14"); + } + } + + public class WhereConst + { + public static string name { get; set; } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Insert.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Insert.cs new file mode 100644 index 000000000..e5fb874e1 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Insert.cs @@ -0,0 +1,127 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Insert : UnitTestBase + { + private Insert() { } + public Insert(int eachCount) + { + this.Count = eachCount; + } + + public void Init() + { + var db = GetInstance(); + var insertObj = new Student() { Name = "jack", CreateTime = Convert.ToDateTime("2010-1-1"), SchoolId=0 }; + db.IgnoreColumns.Add("TestId", "Student"); + //db.MappingColumns.Add("id","dbid", "Student"); + + var t1 = db.Insertable(insertObj).ToSql(); + base.Check(@"INSERT INTO [STudent] + ([SchoolId],[Name],[CreateTime]) + VALUES + (@SchoolId,@Name,@CreateTime) ;SELECT SCOPE_IDENTITY();", + new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@CreateTime",Convert.ToDateTime("2010-1-1")), + new SugarParameter("@Name","jack") + }, t1.Key, t1.Value, "Insert t1 error" + ); + + + //Insert reutrn Command Count + var t2 = db.Insertable(insertObj).ExecuteCommand(); + + db.IgnoreColumns = null; + //Only insert Name + var t3 = db.Insertable(insertObj).InsertColumns(it => new { it.Name }).ToSql(); + base.Check(@"INSERT INTO [STudent] + ([Name]) + VALUES + (@Name) ;SELECT SCOPE_IDENTITY();", new List() { + new SugarParameter("@Name","jack") + }, t3.Key, t3.Value, "Insert t3 error"); + + + //Ignore Name and TestId + var t4 = db.Insertable(insertObj).IgnoreColumns(it => new { it.Name, it.TestId }).ToSql(); + base.Check(@"INSERT INTO [STudent] + ([SchoolId],[CreateTime]) + VALUES + (@SchoolId,@CreateTime) ;SELECT SCOPE_IDENTITY();", + new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@CreateTime",Convert.ToDateTime("2010-1-1")), + }, t4.Key, t4.Value, "Insert t4 error" + ); + + //Ignore Name and TestId + var t5 = db.Insertable(insertObj).IgnoreColumns(it => it == "Name" || it == "TestId").With(SqlWith.UpdLock).ToSql(); + base.Check(@"INSERT INTO [STudent] WITH(UPDLOCK) + ([SchoolId],[CreateTime]) + VALUES + (@SchoolId,@CreateTime) ;SELECT SCOPE_IDENTITY();", +new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@CreateTime",Convert.ToDateTime("2010-1-1")), +}, t5.Key, t5.Value, "Insert t5 error" +); + //Use Lock + var t6 = db.Insertable(insertObj).With(SqlWith.UpdLock).ToSql(); + base.Check(@"INSERT INTO [STudent] WITH(UPDLOCK) + ([SchoolId],[Name],[CreateTime]) + VALUES + (@SchoolId,@Name,@CreateTime) ;SELECT SCOPE_IDENTITY();", +new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@CreateTime",Convert.ToDateTime("2010-1-1")), + new SugarParameter("@Name","jack") +}, t6.Key, t6.Value, "Insert t6 error" +); + + var insertObj2 = new Student() { Name = null,SchoolId=0, CreateTime = Convert.ToDateTime("2010-1-1") }; + var t8 = db.Insertable(insertObj2).Where(true/* Is insert null */, true/*off identity*/).ToSql(); + base.Check(@"INSERT INTO [STudent] + ([ID],[SchoolId],[CreateTime]) + VALUES + (@ID,@SchoolId,@CreateTime) ;SELECT SCOPE_IDENTITY();", + new List() { + new SugarParameter("@SchoolId", 0), + new SugarParameter("@ID", 0), + new SugarParameter("@CreateTime", Convert.ToDateTime("2010-1-1")) + }, + t8.Key, + t8.Value, + "Insert t8 error" + ); + + + db.IgnoreColumns = new IgnoreComumnList(); + db.IgnoreColumns.Add("TestId", "Student"); + + //Insert List + var insertObjs = new List(); + for (int i = 0; i < 1000; i++) + { + insertObjs.Add(new Student() { Name = "name" + i }); + } + var s9 = db.Insertable(insertObjs.ToArray()).InsertColumns(it => new { it.Name }).With(SqlWith.UpdLock).ToSql(); + + insertObj.Name = null; + var t10 = db.Insertable(insertObj).ExecuteCommand(); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Mapping .cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Mapping .cs new file mode 100644 index 000000000..9112e94f4 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Mapping .cs @@ -0,0 +1,46 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Mapping:UnitTestBase + { + private Mapping() { } + public Mapping(int eachCount) + { + this.Count = eachCount; + } + + public void Init() { + + var db = GetInstance(); + var t1= db.Queryable().Where(it=>it.Id==1).ToSql(); + base.Check("SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WHERE ( [ID] = @Id0 ) ", null, t1.Key, null,"Mapping t1 error"); + + db.MappingColumns.Add("Id", "id", "School"); + var t2 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }) + .Where(st => st.Id == 1) + .Where((st,sc) => sc.Id == 1) + .Where((st,sc) => sc.Id == st.Id) + .GroupBy(st => st.Id) + .GroupBy((st,sc) => sc.Id).OrderBy(st => st.Id,OrderByType.Asc) + .Select((st,sc)=> new { stid=st.Id,scid=sc.Id}).ToSql(); + base.Check(@"SELECT [st].[ID] AS [stid] , [sc].[id] AS [scid] FROM [STudent] st Left JOIN School sc ON ( [st].[SchoolId] = [sc].[id] ) WHERE ( [st].[ID] = @Id0 ) AND ( [sc].[id] = @Id1 ) AND ( [sc].[id] = [st].[ID] )GROUP BY [st].[ID],[sc].[id]ORDER BY [st].[ID] ASC ", + null, t2.Key, null, " Mapping t2 error"); + var x2 = GetInstance(); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() {InitKeyType=InitKeyType.Attribute, ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/PerformanceTest.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/PerformanceTest.cs new file mode 100644 index 000000000..3ac2b9286 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/PerformanceTest.cs @@ -0,0 +1,115 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Linq; +using System.Text; +using System.Threading; +namespace SyntacticSugar +{ + + public class PerformanceTest + { + private DateTime _beginTime; + private DateTime _endTime; + private ParamsModel _params; + private List _CharSource = new List(); + /// + ///设置执行次数(默认:1) + /// + public void SetCount(int count) + { + _params.RunCount = count; + } + /// + /// 设置线程模式(默认:false) + /// + /// true为多线程 + public void SetIsMultithread(bool isMul) + { + _params.IsMultithread = isMul; + } + + /// + /// 构造函数 + /// + public PerformanceTest() + { + _params = new ParamsModel() + { + RunCount = 1 + }; + } + + /// + /// 执行函数 + /// + /// + public void Execute(Action action, Action rollBack, string name = null) + { + List arr = new List(); + _beginTime = DateTime.Now; + for (int i = 0; i < _params.RunCount; i++) + { + if (_params.IsMultithread) + { + var thread = new Thread(new System.Threading.ThreadStart(() => + { + action(i); + })); + thread.Start(); + arr.Add(thread); + } + else + { + action(i); + } + } + if (_params.IsMultithread) + { + foreach (Thread t in arr) + { + while (t.IsAlive) + { + Thread.Sleep(10); + } + } + + } + + _CharSource.Add(new PerformanceTestChartModel() { Name = name, Time = GetTime(), CPU = GetCurrentProcessSize() }); + rollBack(string.Format("总共执行时间：{0}秒", GetTime())); + } + + private double GetTime() + { + _endTime = DateTime.Now; + double totalTime = ((_endTime - _beginTime).TotalMilliseconds / 1000.0); + return totalTime; + } + + public List GetChartSource() + { + return _CharSource; + } + private Double GetCurrentProcessSize() + { + Process processes = Process.GetCurrentProcess(); + var processesSize = (Double)(processes.WorkingSet64); + return processesSize / (1024 * 1024); + } + + private class ParamsModel + { + public int RunCount { get; set; } + public bool IsMultithread { get; set; } + } + public class PerformanceTestChartModel + { + public string Name { get; set; } + public double Time { get; set; } + public double CPU { get; set; } + } + } + + +} \ No newline at end of file diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/JoinQuery.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/JoinQuery.cs new file mode 100644 index 000000000..0cc74061f --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/JoinQuery.cs @@ -0,0 +1,83 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using System.Linq.Expressions; +using OrmTest.Models; +namespace OrmTest.UnitTest +{ + public class JoinQuery : UnitTestBase + { + private JoinQuery() { } + public JoinQuery(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + Q1(); + Q2(); + Q3(); + } + base.End("Method Test"); + } + + private void Q3() + { + using (var db = GetInstance()) + { + var join3 = db.Queryable("Student", "st") + .AddJoinInfo("School", "sh", "sh.id=st.schoolid") + .Where("st.id>@id") + .AddParameters(new { id = 1 }) + .Select("st.*").ToSql(); + string sql = @"SELECT st.* FROM [Student] st Left JOIN School sh ON sh.id=st.schoolid WHERE st.id>@id "; + base.Check(sql,new List() {new SugarParameter("@id",1)}, join3.Key, join3.Value, "join 3 Error"); + } + } + + public void Q1() + { + using (var db = GetInstance()) + { + var join1 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }).Where(st => st.Id > 0).Select("*").ToSql(); + base.Check(@"SELECT * FROM [STudent] st Left JOIN School sc ON ( [st].[SchoolId] = [sc].[Id] ) WHERE ( [st].[ID] > @Id0 ) ", + new List() { + new SugarParameter("@Id0",0) + }, join1.Key, join1.Value, "join 1 Error"); + } + } + public void Q2() + { + using (var db = GetInstance()) + { + var join2 = db.Queryable((st, sc) => new object[] { + JoinType.Left,st.SchoolId==sc.Id + }).Where(st => st.Id > 2).Select("*").ToSql(); + base.Check(@"SELECT * FROM [STudent] st Left JOIN School sc ON ( [st].[SchoolId] = [sc].[Id] ) WHERE ( [st].[ID] > @Id0 ) ", + new List() { + new SugarParameter("@Id0",2) + }, join2.Key, join2.Value, "join 2 Error"); + } + } + + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer }); + db.Ado.IsEnableLogEvent = true; + db.Ado.LogEventStarting = (sql, pars) => + { + Console.WriteLine(sql + " " + pars); + }; + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SelectQuery.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SelectQuery.cs new file mode 100644 index 000000000..be6907b56 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SelectQuery.cs @@ -0,0 +1,94 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using System.Linq.Expressions; +using OrmTest.Models; +namespace OrmTest.UnitTest +{ + public class SelectQuery : UnitTestBase + { + private SelectQuery() { } + public SelectQuery(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + Q2(); + } + base.End("Method Test"); + } + + public void Q2() + { + using (var db = GetInstance()) + { + //db.Database.IsEnableLogEvent = true; + db.Ado.LogEventStarting = (sql, pars) => + { + Console.WriteLine(sql + " " + pars); + }; + + + #region dr ot entity + db.IgnoreColumns.Add("TestId", "Student"); + var s1 = db.Queryable().Select(it => new ViewModelStudent2 { Name = it.Name, Student = it }).ToList(); + var s2 = db.Queryable().Select(it => new { id = it.Id, w = new { x = it } }).ToList(); + var s3 = db.Queryable().Select(it => new { newid = it.Id }).ToList(); + var s4 = db.Queryable().Select(it => new { newid = it.Id, obj = it }).ToList(); + var s5 = db.Queryable().Select(it => new ViewModelStudent2 { Student = it, Name = it.Name }).ToList(); + #endregion + + + #region sql and parameters validate + var t1 = db.Queryable((st, sc) => new object[] { + JoinType.Inner,st.Id==sc.Id + }).GroupBy(st => st.Id).Having(st => SqlFunc.AggregateAvg(st.Id) == 1).Select(st => new { avgId = SqlFunc.AggregateAvg(st.Id) }).ToSql(); + base.Check("SELECT AVG([st].[ID]) AS [avgId] FROM [STudent] st Inner JOIN School sc ON ( [st].[ID] = [sc].[Id] ) GROUP BY [st].[ID] HAVING (AVG([st].[ID]) = @Const0 ) ", + new List() { + new SugarParameter("@Const0",1) + } + , + t1.Key, t1.Value, " select t1 Error"); + + + var t2 = db.Queryable((st, st2) => new object[] { + JoinType.Left,st.Id==st2.Id + }) + .Where(st => st.Id > 0) + .Select((st, st2) => new { stid = st.Id, scId = st2.Id, xx = st }).ToSql(); + + base.Check("SELECT [st].[Id] AS [stid] , [st2].[Id] AS [scId] , [st].[Id] AS [School.Id] , [st].[Name] AS [School.Name] FROM [School] st Left JOIN School st2 ON ( [st].[Id] = [st2].[Id] ) WHERE ( [st].[Id] > @Id0 ) " + , new List() { + new SugarParameter("@Id0",0) + }, t2.Key, t2.Value, "select t2 Error"); + + + var t3 = db.Queryable((st, sc, sc2) => new object[] { + JoinType.Left,st.SchoolId==sc.Id, + JoinType.Left,sc2.Id==sc.Id + }).Where(st => st.Id > 0) + .Select((st) => new School() { Id = st.Id }).ToSql(); + base.Check("SELECT [st].[ID] AS [Id] FROM [STudent] st Left JOIN School sc ON ( [st].[SchoolId] = [sc].[Id] ) Left JOIN School sc2 ON ( [sc2].[Id] = [sc].[Id] ) WHERE ( [st].[ID] > @Id0 ) ", + new List() { + new SugarParameter("@Id0",0) + }, t3.Key, t3.Value, "select t3 Error"); + #endregion + + + } + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SingleQuery.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SingleQuery.cs new file mode 100644 index 000000000..d8a92bd6d --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Query/SingleQuery.cs @@ -0,0 +1,131 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +using System.Linq.Expressions; +using OrmTest.Models; +namespace OrmTest.UnitTest +{ + public class SingleQuery : UnitTestBase + { + private SingleQuery() { } + public SingleQuery(int eachCount) + { + this.Count = eachCount; + } + internal void Init() + { + base.Begin(); + for (int i = 0; i < base.Count; i++) + { + Q2(); + } + base.End("Method Test"); + } + + public void Q2() + { + using (var db = GetInstance()) + { + var t1 = db.Queryable().ToSql(); + base.Check("SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent]", null, t1.Key, null, "single t1 Error"); + + var t2 = db.Queryable().With(SqlWith.NoLock).ToSql(); + base.Check("SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WITH(NOLOCK)", null, t2.Key, null, "single t2 Error"); + + var t3 = db.Queryable().OrderBy(it=>it.Id).ToSql(); + base.Check("SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] ORDER BY [ID] ASC", null, t3.Key, null, "single t3 Error"); + + var t4 = db.Queryable().OrderBy(it => it.Id).Take(3).ToSql(); + base.Check(@"WITH PageTable AS( + SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] + ) + SELECT * FROM (SELECT *,ROW_NUMBER() OVER(ORDER BY [ID] ASC) AS RowIndex FROM PageTable ) T WHERE RowIndex BETWEEN 1 AND 3", null, t4.Key, null, "single t4 Error"); + + var t5 = db.Queryable().OrderBy(it => it.Id).Skip(3).ToSql(); + base.Check(@"WITH PageTable AS( + SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] + ) + SELECT * FROM (SELECT *,ROW_NUMBER() OVER(ORDER BY [ID] ASC) AS RowIndex FROM PageTable ) T WHERE RowIndex BETWEEN 4 AND 9223372036854775807", null, t5.Key,null, "single t5 Error"); + + int pageIndex = 2; + int pageSize = 10; + var t6 = db.Queryable().OrderBy(it => it.Id,OrderByType.Desc).Skip((pageIndex-1)*pageSize).Take(pageSize).ToSql(); + base.Check(@"WITH PageTable AS( + SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] + ) + SELECT * FROM (SELECT *,ROW_NUMBER() OVER(ORDER BY [ID] DESC) AS RowIndex FROM PageTable ) T WHERE RowIndex BETWEEN 11 AND 20", null, t6.Key, null, "single t6 Error"); + + + int studentCount=db.Ado.GetInt("select count(1) from Student"); + var countIsSuccess=db.Queryable().Count()== studentCount; + if (!countIsSuccess) { + throw new Exception(" single countIsSuccess Error"); + } + + var t7 = db.Queryable().OrderBy(it => it.Id, OrderByType.Desc).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToPageList(pageIndex,pageSize,ref studentCount); + countIsSuccess = studentCount == db.Queryable().OrderBy(it => it.Id, OrderByType.Desc).Skip((pageIndex - 1) * pageSize).Take(pageSize * pageIndex).Count(); + if (!countIsSuccess) + { + throw new Exception("single t7 Error"); + } + + int studentMin = db.Ado.GetInt("select min(id) from Student"); + var minIsSuccess = db.Queryable().Min(it=>it.Id) == studentMin; + if (!minIsSuccess) + { + throw new Exception("single minIsSuccess Error"); + } + + int studentMax = db.Ado.GetInt("select max(id) from Student"); + var maxIsSuccess = db.Queryable().Max(it => it.Id) == studentMax; + if (!maxIsSuccess) + { + throw new Exception("single maxIsSuccess Error"); + } + + int studentAvg = db.Ado.GetInt("select avg(id) from Student"); + var avgIsSuccess = db.Queryable().Avg(it => it.Id) == studentAvg; + if (!maxIsSuccess) + { + throw new Exception(" single avgIsSuccess Error"); + } + + int studentSum = db.Ado.GetInt("select sum(id) from Student"); + var sumIsSuccess = db.Queryable().Sum(it => it.Id) == studentSum; + if (!sumIsSuccess) + { + throw new Exception("single sumIsSuccess Error"); + } + + var t8 = db.Queryable() + .Where(it=>it.Id==1) + .WhereIF(true,it=> SqlFunc.Contains(it.Name,"a")) + .OrderBy(it => it.Id, OrderByType.Desc).Skip((pageIndex - 1) * pageSize).Take(pageSize ).With(SqlWith.NoLock).ToSql(); + base.Check(@"WITH PageTable AS( + SELECT [ID],[SchoolId],[Name],[CreateTime] FROM [STudent] WITH(NOLOCK) WHERE ( [ID] = @Id0 ) AND ([Name] like '%'+@MethodConst1+'%') + ) + SELECT * FROM (SELECT *,ROW_NUMBER() OVER(ORDER BY [ID] DESC) AS RowIndex FROM PageTable ) T WHERE RowIndex BETWEEN 11 AND 20", new List() { + new SugarParameter("@Id0",1),new SugarParameter("@MethodConst1","a") + }, t8.Key, t8.Value,"single t8 Error"); + + + + var t9 = db.Queryable() + .In(1) + .Select(it => new { it.Id, it.Name,x=it.Id }).ToSql(); + base.Check("SELECT [ID] AS [Id] , [Name] AS [Name] , [ID] AS [x] FROM [STudent] WHERE [Id] IN (@InPara0) ", new List() { + new SugarParameter("@InPara0",1) },t9.Key,t9.Value, "single t9 error"); + } + } + + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/Attribute.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/Attribute.cs new file mode 100644 index 000000000..e0e8da931 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/Attribute.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Attribute : UnitTestBase + { + public Attribute(int eachCount) + { + this.Count = eachCount; + } + public void Init() + { + + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/AutoClose.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/AutoClose.cs new file mode 100644 index 000000000..49d43a396 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/AutoClose.cs @@ -0,0 +1,32 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class AutoClose : UnitTestBase + { + public AutoClose(int eachCount) + { + this.Count = eachCount; + } + public void Init() + { + //IsAutoCloseConnection + for (int i = 0; i < this.Count; i++) + { + var db = GetInstance(); + var x = db.Queryable().ToList(); + } + } + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapColumn.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapColumn.cs new file mode 100644 index 000000000..5b3301226 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapColumn.cs @@ -0,0 +1,18 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class MapColumn : UnitTestBase + { + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapTable.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapTable.cs new file mode 100644 index 000000000..f5b2b11e7 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Setting/MapTable.cs @@ -0,0 +1,28 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class MapTable : UnitTestBase + { + public void Init() + { + //IsAutoCloseConnection + for (int i = 0; i < 200; i++) + { + var db = GetInstance(); + var x = db.Queryable().ToList(); + } + } + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/UnitTestBase.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/UnitTestBase.cs new file mode 100644 index 000000000..286075238 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/UnitTestBase.cs @@ -0,0 +1,49 @@ +using System; +using System.Collections.Generic; +using SqlSugar; +using System.Linq; +namespace OrmTest.UnitTest +{ + public class UnitTestBase + { + public int Count { get; set; } + private DateTime BeginTime { get; set; } + private DateTime EndTime { get; set; } + + public void Begin() + { + this.BeginTime = DateTime.Now; + } + + public void End(string title) + { + this.EndTime = DateTime.Now; + Console.WriteLine(title + " \r\nCount: " + this.Count + "\r\nTime: " + (this.EndTime - this.BeginTime).TotalSeconds + " Seconds \r\n"); + } + + internal void Check(string value, List pars, string validValue, List validPars, string errorMessage) + { + if (value.Trim() != validValue.Trim()) + { + throw new Exception(errorMessage); + } + if (pars != null && pars.Count > 0) + { + if (pars.Count != validPars.Count) + { + throw new Exception(errorMessage); + } + else + { + foreach (var item in pars) + { + if (!validPars.Any(it => it.ParameterName.Equals(item.ParameterName) && it.Value.ObjToString().Equals(item.Value.ObjToString()))) + { + throw new Exception(errorMessage); + } + } + } + } + } + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Update.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Update.cs new file mode 100644 index 000000000..366938bf6 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlServerTest/UnitTest/Update.cs @@ -0,0 +1,135 @@ +using OrmTest.Models; +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest.UnitTest +{ + public class Update : UnitTestBase + { + private Update() { } + public Update(int eachCount) + { + this.Count = eachCount; + } + + public void Init() + { + var db = GetInstance(); + var updateObj = new Student() { Id = 1, Name = "jack",SchoolId=0, CreateTime = Convert.ToDateTime("2017-05-21 09:56:12.610") }; + var updateObjs = new List() { updateObj,new Student() { Id=2,Name="sun",SchoolId=0 } }.ToArray(); + db.IgnoreColumns.Add("TestId", "Student"); + //db.MappingColumns.Add("id","dbid", "Student"); + + var t1 = db.Updateable(updateObj).ToSql(); + base.Check(@"UPDATE [STudent] SET + [SchoolId]=@SchoolId,[Name]=@Name,[CreateTime]=@CreateTime WHERE [Id]=@Id", new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@ID",1), + new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@Name", "jack") + }, t1.Key, t1.Value,"Update t1 error"); + + //update reutrn Command Count + var t2 = db.Updateable(updateObj).ExecuteCommand(); + + db.IgnoreColumns = null; + //Only update Name + var t3 = db.Updateable(updateObj).UpdateColumns(it => new { it.Name }).ToSql(); + base.Check(@"UPDATE [STudent] SET + [Name]=@Name WHERE [Id]=@Id", new List() { + new SugarParameter("@ID",1), + new SugarParameter("@Name", "jack") + }, t3.Key, t3.Value, "Update t3 error"); + + //Ignore Name and TestId + var t4 = db.Updateable(updateObj).IgnoreColumns(it => new { it.Name, it.TestId }).ToSql(); + base.Check(@"UPDATE [STudent] SET + [SchoolId]=@SchoolId,[CreateTime]=@CreateTime WHERE [Id]=@Id", new List() { + new SugarParameter("@CreateTime",Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@SchoolId", 0), + new SugarParameter("@ID",1), + }, t4.Key, t4.Value, "Update t4 error"); + + //Ignore Name and TestId + var t5 = db.Updateable(updateObj).IgnoreColumns(it => it == "Name" || it == "TestId").With(SqlWith.UpdLock).ToSql(); + base.Check(@"UPDATE [STudent] WITH(UPDLOCK) SET + [SchoolId]=@SchoolId,[CreateTime]=@CreateTime WHERE [Id]=@Id", new List() { + new SugarParameter("@CreateTime",Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@SchoolId", 0), + new SugarParameter("@ID",1), + }, t5.Key, t5.Value, "Update t5 error"); + + + //Use Lock + var t6 = db.Updateable(updateObj).With(SqlWith.UpdLock).ToSql(); + base.Check(@"UPDATE [STudent] WITH(UPDLOCK) SET + [SchoolId]=@SchoolId,[Name]=@Name,[CreateTime]=@CreateTime WHERE [Id]=@Id", new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@ID",1), + new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@Name", "jack") + }, t6.Key, t6.Value, "Update t6 error"); + + +// //update List +// var t7 = db.Updateable(updateObjs).With(SqlWith.UpdLock).ToSql(); +// base.Check(@"UPDATE S SET S.[SchoolId]=T.[SchoolId],S.[Name]=T.[Name],S.[CreateTime]=T.[CreateTime] FROM [STudent] S WITH(UPDLOCK) INNER JOIN ( + +// SELECT N'1' AS ID,N'0' AS SchoolId,N'jack' AS Name,'2017-05-21 09:56:12.610' AS CreateTime +//UNION ALL +// SELECT N'2' AS ID,N'0' AS SchoolId,N'sun' AS Name,NULL AS CreateTime + + +// ) T ON S.[Id]=T.[Id] +// ; ", null, t7.Key, null,"Update t7 error"); + + //Re Set Value + var t8 = db.Updateable(updateObj) + .ReSetValue(it=>it.Name==(it.Name+1)).ToSql(); + base.Check(@"UPDATE [STudent] SET + [SchoolId]=@SchoolId, [Name] =( [Name] + @Const0 ),[CreateTime]=@CreateTime WHERE [Id]=@Id", + new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@ID",1), + new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@Const0", 1) + }, t8.Key, t8.Value, "Update t8 error" + ); + + //Where By Expression + var t9 = db.Updateable(updateObj) + .Where(it => it.Id==1).ToSql(); + base.Check(@"UPDATE [STudent] SET + [SchoolId]=@SchoolId,[Name]=@Name,[CreateTime]=@CreateTime WHERE ( [ID] = @Id0 )", + new List() { + new SugarParameter("@SchoolId",0), + new SugarParameter("@ID",1), + new SugarParameter("@Id0",1), + new SugarParameter("@CreateTime", Convert.ToDateTime("2017-05-21 09:56:12.610")), + new SugarParameter("@Name", "jack") },t9.Key,t9.Value,"Upate t9 error" + ); + updateObj.SchoolId = 18; + string name = "x"; + var t10 = db.Updateable().UpdateColumns(it => new Student() { Name =name, SchoolId=updateObj.SchoolId }).Where(it=>it.Id==11).ToSql(); + base.Check(@"UPDATE [STudent] SET + [SchoolId] = @Const0 , [Name] = @const3 WHERE ( [ID] = @Id1 )", new List() { + new SugarParameter("@const3","x"), + new SugarParameter("@Const0",18), + new SugarParameter("@Id1",11)}, + t10.Key, + t10.Value, + "Update 10 error" + ); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.SqlServer, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoAccessory.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoAccessory.cs index 68bc7a3b6..729bcb577 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoAccessory.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/AdoProvider/AdoAccessory.cs @@ -48,7 +48,7 @@ namespace SqlSugar foreach (PropertyInfo properyty in properties) { var value = properyty.GetValue(parameters, null); - if (properyty.PropertyType.IsEnum) + if (properyty.PropertyType.IsEnum()) { value = Convert.ToInt64(value); } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs index 786c64e6f..105d7d0a4 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; +using System.Runtime.Loader; using System.Text; namespace SqlSugar { @@ -45,7 +46,7 @@ namespace SqlSugar } public void InitTables(string entitiesNamespace) { - var types = Assembly.Load(entitiesNamespace).GetTypes(); + var types = AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(entitiesNamespace)).GetTypes(); InitTables(types); } public void InitTables(params string[] entitiesNamespaces) diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs index 229ac4b7b..4dc1576ba 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs @@ -167,7 +167,7 @@ namespace SqlSugar { return GetKeyValueList(type, dataReader); } - else if (type.IsValueType || type == PubConst.StringType) + else if (type.IsValueType() || type == PubConst.StringType) { return GetValueTypeList(type, dataReader); } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs index 6b7e6143a..e1bb7a8cf 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs @@ -162,7 +162,7 @@ namespace SqlSugar validPropertyName = validPropertyName == "byte[]" ? "byteArray" : validPropertyName; CSharpDataType validPropertyType = (CSharpDataType)Enum.Parse(typeof(CSharpDataType), validPropertyName); string bindProperyTypeName = bindPropertyType.Name.ToLower(); - bool isEnum = bindPropertyType.IsEnum; + bool isEnum = bindPropertyType.IsEnum(); if (isEnum) { validPropertyType = CSharpDataType.@enum; } switch (validPropertyType) { diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/EntityProvider/EntityProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/EntityProvider/EntityProvider.cs index 0a7f3ec44..8fa2e839d 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/EntityProvider/EntityProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/EntityProvider/EntityProvider.cs @@ -26,7 +26,7 @@ namespace SqlSugar }, (cm, key) => { EntityInfo result = new EntityInfo(); - var sugarAttributeInfo = type.GetCustomAttributes(typeof(SugarTable), true).Where(it => it is SugarTable).SingleOrDefault(); + var sugarAttributeInfo = type.GetTypeInfo().GetCustomAttributes(typeof(SugarTable), true).Where(it => it is SugarTable).SingleOrDefault(); if (sugarAttributeInfo.IsValuable()) { var sugarTable = (SugarTable)sugarAttributeInfo; diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs index 37b474300..b580db0be 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs @@ -165,7 +165,7 @@ namespace SqlSugar PropertyType = PubMethod.GetUnderType(column.PropertyInfo), TableId = i }; - if (columnInfo.PropertyType.IsEnum) { + if (columnInfo.PropertyType.IsEnum()) { columnInfo.Value = Convert.ToInt64(columnInfo.Value); } insertItem.Add(columnInfo); 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 c19fdef3c..456225574 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs @@ -5,6 +5,7 @@ using System.Data; using System.Data.SqlClient; using System.Linq; using System.Linq.Expressions; +using System.Reflection; using System.Text; using System.Text.RegularExpressions; @@ -629,7 +630,7 @@ namespace SqlSugar { if (result.IsValuable()) { - if (entityType.BaseType.IsValuable() && entityType.BaseType == PubConst.ModelType) + if (entityType.GetTypeInfo().BaseType.IsValuable() && entityType.GetTypeInfo().BaseType == PubConst.ModelType) { foreach (var item in result) { diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs index 1c3c004bb..1c60263ce 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs @@ -165,7 +165,7 @@ namespace SqlSugar PropertyType=PubMethod.GetUnderType(column.PropertyInfo), TableId = i }; - if (columnInfo.PropertyType.IsEnum) + if (columnInfo.PropertyType.IsEnum()) { columnInfo.Value = Convert.ToInt64(columnInfo.Value); } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Class1.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Class1.cs deleted file mode 100644 index ade8d36de..000000000 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Class1.cs +++ /dev/null @@ -1,14 +0,0 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Threading.Tasks; - -namespace SqlSugar -{ - public class Class1 - { - public Class1() - { - } - } -} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/IsWhatExtensions.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/IsWhatExtensions.cs index 5e3a1b3b0..bdf493ab3 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/IsWhatExtensions.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/IsWhatExtensions.cs @@ -167,7 +167,7 @@ namespace SqlSugar public static bool IsClass(this Type thisValue) { - return thisValue != StringType && thisValue.IsClass; + return thisValue != StringType && thisValue.IsEntity(); } } } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/RewritableMethods.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/RewritableMethods.cs index 0a359ac3d..0c11c1952 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/RewritableMethods.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Common/RewritableMethods.cs @@ -107,6 +107,9 @@ namespace SqlSugar } } var stringValue = SerializeObject(result); + if (stringValue.IsValuable()) { + stringValue = stringValue.Replace(":{}", ":null"); + } reval.Add((T)DeserializeObject(stringValue)); } reader.Close(); diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs index af9761d70..71d0ed5c8 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs @@ -111,7 +111,7 @@ namespace SqlSugar object reval = null; FieldInfo field = (FieldInfo)memberExpr.Member; reval = field.GetValue(memberExpr.Member); - if (reval != null && reval.GetType().IsClass && reval.GetType() != ExpressionConst.StringType) + if (reval != null && reval.GetType().IsClass() && reval.GetType() != ExpressionConst.StringType) { var fieldName = memberExpr.Member.Name; var proInfo = reval.GetType().GetProperty(fieldName); @@ -137,7 +137,7 @@ namespace SqlSugar object reval = null; PropertyInfo pro = (PropertyInfo)memberExpr.Member; reval = pro.GetValue(memberExpr.Member, null); - if (reval != null && reval.GetType().IsClass && reval.GetType() != ExpressionConst.StringType) + if (reval != null && reval.GetType().IsClass() && reval.GetType() != ExpressionConst.StringType) { var fieldName = memberExpr.Member.Name; var proInfo = reval.GetType().GetProperty(fieldName); @@ -161,7 +161,7 @@ namespace SqlSugar public static object DynamicInvoke(MemberExpression expression) { object value = Expression.Lambda(expression).Compile().DynamicInvoke(); - if (value != null && value.GetType().IsClass && value.GetType() != ExpressionConst.StringType) + if (value != null && value.GetType().IsClass()& value.GetType() != ExpressionConst.StringType) { value = Expression.Lambda(expression).Compile().DynamicInvoke(); } @@ -180,7 +180,7 @@ namespace SqlSugar public static bool IsEntity(Type type) { - return type.IsClass && type!=ExpressionConst.StringType; + return type.IsClass() && type!=ExpressionConst.StringType; } public static bool IsValueType(Type type) diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs index ab4c67507..09b0ca459 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs @@ -258,7 +258,7 @@ namespace SqlSugar private void CheckMethod(MethodCallExpression expression) { - Check.Exception(expression.Method.ReflectedType.FullName != ExpressionConst.SqlFuncFullName,string.Format(ExpressionErrorMessage.MethodError, expression.Method.Name)); + Check.Exception(expression.Method.DeclaringType.FullName != ExpressionConst.SqlFuncFullName,string.Format(ExpressionErrorMessage.MethodError, expression.Method.Name)); } } } diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs index f812b48fd..267c13142 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/InstanceFactory.cs @@ -2,13 +2,14 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; +using System.Runtime.Loader; using System.Text; using System.Threading.Tasks; namespace SqlSugar { public class InstanceFactory { - static Assembly assembly = Assembly.Load(PubConst.AssemblyName); + static Assembly assembly = CoreMethod.LoadAssembly(PubConst.AssemblyName); static Dictionary typeCache = new Dictionary(); #region Queryable diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/CoreMethod.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/CoreMethod.cs new file mode 100644 index 000000000..e32f93ce1 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/CoreMethod.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; +using Microsoft.Extensions.DependencyModel; + +namespace SqlSugar +{ + public class CoreMethod + { + public static Assembly LoadAssembly(string name) + { + var deps = DependencyContext.Default; + var assemblyies = deps.CompileLibraries.Where(it => it.Name == name).ToList(); + return assemblyies.Any() ? Assembly.Load(new AssemblyName(assemblyies.First().Name)) : null; + } + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/DataExtension.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/DataExtension.cs index f27aee497..3fb9fce67 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/DataExtension.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/DataExtension.cs @@ -218,7 +218,6 @@ namespace SqlSugar return Rows[thisIndex]; } } - private int index = -1; private List Rows = null; /// @@ -354,6 +353,14 @@ namespace SqlSugar } } + public object this[DataColumn column] + { + get + { + return obj[column.ColumnName]; + } + } + /// /// Get Item By Index /// @@ -392,7 +399,7 @@ namespace SqlSugar /// /// 数据填充器 /// - public class SqlDataAdapter + public class SqlDataAdapter: IDataAdapter { private SqlCommand command; private string sql; @@ -407,6 +414,11 @@ namespace SqlSugar this.command = command; } + public SqlDataAdapter() + { + + } + /// /// SqlDataAdapter /// @@ -431,6 +443,9 @@ namespace SqlSugar } return this.command; } + set { + this.command = value; + } } /// diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/IDataAdapter.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/IDataAdapter.cs similarity index 69% rename from Src/Asp.NetCore/SqlServerTest/src/SqlSugar/IDataAdapter.cs rename to Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/IDataAdapter.cs index 78750decb..adf37aa7d 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/IDataAdapter.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/IDataAdapter.cs @@ -2,5 +2,6 @@ { public interface IDataAdapter { + void Fill(DataSet ds); } } \ No newline at end of file diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/TypeExtensions.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/TypeExtensions.cs new file mode 100644 index 000000000..d628f6655 --- /dev/null +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/OnlyCore/TypeExtensions.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Threading.Tasks; + +namespace SqlSugar +{ + internal static class TypeExtensions + { + + public static Type[] GetGenericArguments(this Type type) + { + var reval = type.GetTypeInfo().GetGenericArguments(); + return reval; + } + public static bool IsGenericType(this Type type) + { + var reval = type.GetTypeInfo().IsGenericType; + return reval; + } + public static PropertyInfo[] GetProperties(this Type type) + { + var reval = type.GetTypeInfo().GetProperties(); + return reval; + } + public static PropertyInfo GetProperty(this Type type, string name) + { + var reval = type.GetTypeInfo().GetProperty(name); + return reval; + } + + public static FieldInfo GetField(this Type type, string name) + { + var reval = type.GetTypeInfo().GetField(name); + return reval; + } + + public static bool IsEnum(this Type type) + { + var reval = type.GetTypeInfo().IsEnum; + return reval; + } + + public static MethodInfo GetMethod(this Type type, string name) + { + var reval = type.GetTypeInfo().GetMethod(name); + return reval; + } + public static MethodInfo GetMethod(this Type type, string name, Type[] types) + { + var reval = type.GetTypeInfo().GetMethod(name, types); + return reval; + } + public static ConstructorInfo GetConstructor(this Type type, Type[] types) + { + var reval = type.GetTypeInfo().GetConstructor(types); + return reval; + } + + public static bool IsValueType(this Type type) + { + return type.GetTypeInfo().IsValueType; + } + + + public static bool IsEntity(this Type type) + { + return type.GetTypeInfo().IsClass; + } + + } +} diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/SqlServer/SqlServerProvider.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/SqlServer/SqlServerProvider.cs index 7bf9832f1..0b2972fc8 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/SqlServer/SqlServerProvider.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/Realization/SqlServer/SqlServerProvider.cs @@ -83,7 +83,6 @@ namespace SqlSugar if (parameter.Value == null) parameter.Value = DBNull.Value; var sqlParameter = new SqlParameter(); sqlParameter.ParameterName = parameter.ParameterName; - sqlParameter.UdtTypeName = parameter.UdtTypeName; sqlParameter.Size = parameter.Size; sqlParameter.Value = parameter.Value; sqlParameter.DbType = parameter.DbType; diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs index 4a2f3d8e1..cbbcecdff 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/SqlSugarClient.cs @@ -3,7 +3,6 @@ using System.Collections.Generic; using System.Data; using System.Linq; using System.Linq.Expressions; -using System.Runtime.Remoting.Contexts; using System.Text; using System.Threading.Tasks; namespace SqlSugar diff --git a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/project.json b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/project.json index ad46b6d25..6a1500396 100644 --- a/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/project.json +++ b/Src/Asp.NetCore/SqlServerTest/src/SqlSugar/project.json @@ -2,13 +2,15 @@ "version": "1.0.0-*", "dependencies": { + "Microsoft.Extensions.DependencyModel": "1.0.1-beta-003206", "NETStandard.Library": "1.6.0", "Newtonsoft.Json": "9.0.1", "System.Collections.NonGeneric": "4.0.1", "System.Data.Common": "4.1.0", "System.Data.SqlClient": "4.1.0", "System.Dynamic.Runtime": "4.0.11", - "System.Reflection.Emit.Lightweight": "4.0.1" + "System.Reflection.Emit.Lightweight": "4.0.1", + "System.Runtime.Loader": "4.0.0" }, "frameworks": {