diff --git a/Src/Asp.Net/SqlSugar/Common/RewritableMethods.cs b/Src/Asp.Net/SqlSugar/Common/RewritableMethods.cs index 26ef0bab5..b0d4b3907 100644 --- a/Src/Asp.Net/SqlSugar/Common/RewritableMethods.cs +++ b/Src/Asp.Net/SqlSugar/Common/RewritableMethods.cs @@ -120,6 +120,14 @@ namespace SqlSugar { addValue = DateTime.MinValue; } + else if (item.PropertyType == PubConst.StringType) + { + addValue = null; + } + else + { + addValue = null; + } } else { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln index abfcebdd7..7363ec40d 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln @@ -9,6 +9,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SqlSugar", "SqlSugar\SqlSug EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MySqlTest", "MySqlTest\MySqlTest.csproj", "{DEB62FB9-C743-4C2B-BC78-50FB0E8B44FE}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SqliteTest", "SqliteTest\SqliteTest.csproj", "{AE73F090-22EC-49E4-AFEE-879FFFA292EC}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -27,6 +29,10 @@ Global {DEB62FB9-C743-4C2B-BC78-50FB0E8B44FE}.Debug|Any CPU.Build.0 = Debug|Any CPU {DEB62FB9-C743-4C2B-BC78-50FB0E8B44FE}.Release|Any CPU.ActiveCfg = Release|Any CPU {DEB62FB9-C743-4C2B-BC78-50FB0E8B44FE}.Release|Any CPU.Build.0 = Release|Any CPU + {AE73F090-22EC-49E4-AFEE-879FFFA292EC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AE73F090-22EC-49E4-AFEE-879FFFA292EC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AE73F090-22EC-49E4-AFEE-879FFFA292EC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AE73F090-22EC-49E4-AFEE-879FFFA292EC}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Common/RewritableMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Common/RewritableMethods.cs index 2806e9c27..e57148407 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Common/RewritableMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Common/RewritableMethods.cs @@ -120,7 +120,11 @@ namespace SqlSugar { addValue = DateTime.MinValue; } - else if (item.PropertyType == PubConst.StringType) { + else if (item.PropertyType == PubConst.StringType) + { + addValue = null; + } + else { addValue = null; } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs index c9acda4a7..e92d69103 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs @@ -4,7 +4,7 @@ using System; using System.Collections; using System.Collections.Generic; using System.Data.SqlClient; -using System.Data.SQLite; +using System.Data.Sqlite; using System.Linq; using System.Threading.Tasks; namespace SqlSugar @@ -656,7 +656,7 @@ namespace SqlSugar /// /// 数据填充器 /// - public class SQLiteDataAdapter : IDataAdapter + public class SqliteDataAdapter : IDataAdapter { private SqliteCommand command; private string sql; @@ -666,12 +666,12 @@ namespace SqlSugar /// SqlDataAdapter /// /// - public SQLiteDataAdapter(SqliteCommand command) + public SqliteDataAdapter(SqliteCommand command) { this.command = command; } - public SQLiteDataAdapter() + public SqliteDataAdapter() { } @@ -681,7 +681,7 @@ namespace SqlSugar /// /// /// - public SQLiteDataAdapter(string sql, SqliteConnection _sqlConnection) + public SqliteDataAdapter(string sql, SqliteConnection _sqlConnection) { this.sql = sql; this._sqlConnection = _sqlConnection; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/SqliteExtensions.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/SqliteExtensions.cs index ebc23d296..08ee24c4b 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/SqliteExtensions.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/SqliteExtensions.cs @@ -2,11 +2,11 @@ using System; using System.Collections.Generic; using System.Data.Common; -using System.Data.SQLite; +using System.Data.Sqlite; using System.Linq; using System.Threading.Tasks; -namespace System.Data.SQLite +namespace System.Data.Sqlite { public static class AdoCore { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/DbMaintenance/SqliteDbMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/DbMaintenance/SqliteDbMaintenance.cs index c832a86b3..e1e4eea52 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/DbMaintenance/SqliteDbMaintenance.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/DbMaintenance/SqliteDbMaintenance.cs @@ -1,8 +1,9 @@ -using System; +using Microsoft.Data.Sqlite; +using System; using System.Collections.Generic; using System.Data; using System.Data.Common; -using System.Data.SQLite; +using System.Data.Sqlite; using System.Linq; using System.Text; @@ -178,7 +179,7 @@ namespace SqlSugar string sql = "select * from " + tableName + " limit 0,1"; var oldIsEnableLog = this.Context.Ado.IsEnableLogEvent; this.Context.Ado.IsEnableLogEvent = false; - using (DbDataReader reader = (SQLiteDataReader)this.Context.Ado.GetDataReader(sql)) + using (DbDataReader reader = (SqliteDataReader)this.Context.Ado.GetDataReader(sql)) { this.Context.Ado.IsEnableLogEvent = oldIsEnableLog; return AdoCore.GetColumnInfosByTableName(tableName, reader); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqliteProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqliteProvider.cs index 73334e739..cd18df849 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqliteProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqliteProvider.cs @@ -1,8 +1,9 @@ -using System; +using Microsoft.Data.Sqlite; +using System; using System.Collections.Generic; using System.Data; using System.Data.SqlClient; -using System.Data.SQLite; +using System.Data.Sqlite; using System.Linq; using System.Text; using System.Threading.Tasks; @@ -17,8 +18,8 @@ namespace SqlSugar { if (base._DbConnection == null) { - var SQLiteConnectionString = base.Context.CurrentConnectionConfig.ConnectionString; - base._DbConnection = new SQLiteConnection(SQLiteConnectionString); + var SqliteConnectionString = base.Context.CurrentConnectionConfig.ConnectionString; + base._DbConnection = new SqliteConnection(SqliteConnectionString); } return base._DbConnection; } @@ -43,31 +44,31 @@ namespace SqlSugar } public override IDataAdapter GetAdapter() { - return new SQLiteDataAdapter(); + return new SqliteDataAdapter(); } public override IDbCommand GetCommand(string sql, SugarParameter[] parameters) { - SQLiteCommand sqlCommand = new SQLiteCommand(sql, (SQLiteConnection)this.Connection); + SqliteCommand sqlCommand = new SqliteCommand(sql, (SqliteConnection)this.Connection); sqlCommand.CommandType = this.CommandType; sqlCommand.CommandTimeout = this.CommandTimeOut; if (this.Transaction != null) { - sqlCommand.Transaction = (SQLiteTransaction)this.Transaction; + sqlCommand.Transaction = (SqliteTransaction)this.Transaction; } if (parameters.IsValuable()) { IDataParameter[] ipars = ToIDbDataParameter(parameters); - sqlCommand.Parameters.AddRange((SQLiteParameter[])ipars); + sqlCommand.Parameters.AddRange((SqliteParameter[])ipars); } CheckConnection(); return sqlCommand; } public override void SetCommandToAdapter(IDataAdapter dataAdapter, IDbCommand command) { - ((SQLiteDataAdapter)dataAdapter).SelectCommand = (SQLiteCommand)command; + ((SqliteDataAdapter)dataAdapter).SelectCommand = (SqliteCommand)command; } /// - /// if SQLite return SQLiteParameter[] pars + /// if Sqlite return SqliteParameter[] pars /// if sqlerver return SqlParameter[] pars ... /// /// @@ -75,12 +76,12 @@ namespace SqlSugar public override IDataParameter[] ToIDbDataParameter(params SugarParameter[] parameters) { if (parameters == null || parameters.Length == 0) return null; - SQLiteParameter[] result = new SQLiteParameter[parameters.Length]; + SqliteParameter[] result = new SqliteParameter[parameters.Length]; int index = 0; foreach (var parameter in parameters) { if (parameter.Value == null) parameter.Value = DBNull.Value; - var sqlParameter = new SQLiteParameter(); + var sqlParameter = new SqliteParameter(); sqlParameter.ParameterName = parameter.ParameterName; sqlParameter.Size = parameter.Size; sqlParameter.Value = parameter.Value; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj index 54d3cfbc8..09c7e141b 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj @@ -4,12 +4,6 @@ netstandard2.0 - - - - - - diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Config.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Config.cs new file mode 100644 index 000000000..e6ad3c5a3 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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 = @"DataSource=D:\MyGit\SqlSugar\Src\Asp.NetCore2\SqlSeverTest\SqliteTest\DataBase\SqlSugar4xTest.sqlite"; + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite new file mode 100644 index 000000000..00dccbf75 Binary files /dev/null and b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite differ diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/1_Query.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/1_Query.cs new file mode 100644 index 000000000..96532db26 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/1_Query.cs @@ -0,0 +1,348 @@ +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(); + Simple(); + } + + private static void Simple() + { + //SqlSugarClient + var db = GetInstance(); + var student1 = db.Queryable().InSingle(1); + + //get SimpleClient + var sdb = db.SimpleClient; + var student2 = sdb.GetById(1); + sdb.DeleteById(1); + sdb.Insert(new Student() { Name = "xx" }); + sdb.Update(it => new Student { Name = "newvalue" }, it => it.Id == 1);//only update name where id=1 + sdb.Update(new Student() { Name="newavalue" ,Id=1});//update all where id=1 + + //SimpleClient Get SqlSugarClient + var student3=sdb.FullClient.Queryable().InSingle(1); + + } + + 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(); + var count1 = db.Queryable().Count(); + //1. no result + var result = db.Ado.UseTran(() => + { + + var beginCount = db.Queryable().ToList(); + db.Ado.ExecuteCommand("delete from student"); + var endCount = db.Queryable().Count(); + throw new Exception("error haha"); + }); + var count2 = 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 getLike = db.Queryable().Where(it => it.Name.Contains("a")).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 = 2; + 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.NetCore2/SqlSeverTest/SqliteTest/Demos/2_Update.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/2_Update.cs new file mode 100644 index 000000000..12407ae12 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Demos/3_Insert.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/3_Insert.cs new file mode 100644 index 000000000..7ec172b12 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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).ExecuteReturnIdentity(); + + + //Only insert Name and SchoolId + var t4 = db.Insertable(insertObj).InsertColumns(it => new { it.Name, it.SchoolId }).ExecuteReturnIdentity(); + var t4_1 = db.Insertable(insertObj).InsertColumns(it => it=="Name"||it== "SchoolId").ExecuteReturnIdentity(); + + + //Ignore TestId + var t5 = db.Insertable(insertObj).IgnoreColumns(it => new { it.Name, it.TestId }).ExecuteReturnIdentity(); + + + //Ignore TestId + var t6 = db.Insertable(insertObj).IgnoreColumns(it => it == "Name" || it == "TestId").ExecuteReturnIdentity(); + + + //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.NetCore2/SqlSeverTest/SqliteTest/Demos/4_Delete.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/4_Delete.cs new file mode 100644 index 000000000..960434203 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Demos/5_CodeFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/5_CodeFirst.cs new file mode 100644 index 000000000..b76568f6e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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 =11)] + 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.Sqlite, + 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.NetCore2/SqlSeverTest/SqliteTest/Demos/5_DbFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/5_DbFirst.cs new file mode 100644 index 000000000..eea77d03b --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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:\\DemoSqlite\\1"); + + //Create student calsss + db.DbFirst.Where("Student").CreateClassFile("c:\\DemoSqlite\\2"); + //Where(array) + + //Mapping name + db.MappingTables.Add("ClassStudent", "Student"); + db.MappingColumns.Add("NewId", "Id", "ClassStudent"); + db.DbFirst.Where("Student").CreateClassFile("c:\\DemoSqlite\\3"); + + //Remove mapping + db.MappingTables.Clear(); + + //Create class with default value + db.DbFirst.IsCreateDefaultValue().CreateClassFile("c:\\DemoSqlite\\4", "Demo.Models"); + + + //Mapping and Attribute + db.MappingTables.Add("ClassStudent", "Student"); + db.MappingColumns.Add("NewId", "Id", "ClassStudent"); + db.DbFirst.IsCreateAttribute().Where("Student").CreateClassFile("c:\\DemoSqlite\\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:\\DemoSqlite\\6"); + } + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/6_ComplexModel.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/6_ComplexModel.cs new file mode 100644 index 000000000..5ca494f05 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Demos/7_Filter.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/7_Filter.cs new file mode 100644 index 000000000..cbaf45bef --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Demos/8_JoinSql.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/8_JoinSql.cs new file mode 100644 index 000000000..78adb85b8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Demos/DemoBase.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Demos/DemoBase.cs new file mode 100644 index 000000000..eb8ab2f53 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite, 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.NetCore2/SqlSeverTest/SqliteTest/Models/DataTestInfo.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/DataTestInfo.cs new file mode 100644 index 000000000..935aefaff --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Models/DataTestInfo2.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/DataTestInfo2.cs new file mode 100644 index 000000000..8f425a4c1 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Models/Enum.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/Enum.cs new file mode 100644 index 000000000..09102a410 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Models/School.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/School.cs new file mode 100644 index 000000000..4373f3feb --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Models/Student.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/Student.cs new file mode 100644 index 000000000..421b87bcf --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/Models/ViewModelStudent.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Models/ViewModelStudent.cs new file mode 100644 index 000000000..6705f3dcb --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/PerformanceTesting/PerformanceBase.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/PerformanceTesting/PerformanceBase.cs new file mode 100644 index 000000000..cba502561 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/PerformanceTesting/PerformanceBase.cs @@ -0,0 +1,30 @@ +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.NetCore2/SqlSeverTest/SqliteTest/PerformanceTesting/SqlSugarPerformance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/PerformanceTesting/SqlSugarPerformance.cs new file mode 100644 index 000000000..686fa65c7 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite, + 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.NetCore2/SqlSeverTest/SqliteTest/Program.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Program.cs new file mode 100644 index 000000000..fdd5e1d2c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/Program.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; +using System.Linq.Expressions; +using SqlSugar; +using OrmTest.Models; +using System.Data.SqlClient; +using OrmTest.UnitTest; +using OrmTest.PerformanceTesting; + +namespace OrmTest +{ + class Program + { + static void Main(string[] args) + { + + /***SQLITE CORE case sensitive, Unit comment dropped***/ + + ///***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.NetCore2/SqlSeverTest/SqliteTest/SqliteTest.csproj b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/SqliteTest.csproj new file mode 100644 index 000000000..c2b9b36c5 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/SqliteTest.csproj @@ -0,0 +1,12 @@ + + + + Exe + netcoreapp2.0 + + + + + + + diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/DataTest.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/DataTest.cs new file mode 100644 index 000000000..87f3b32e4 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/DataTest.cs @@ -0,0 +1,79 @@ +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 guid = Guid.Parse("d8268a7e-a2d1-4329-9990-9bd801292415"); + 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, + Guid2 = guid, + 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).ExecuteReturnIdentity(); + var data = db.Queryable().InSingle(id); + if ( + insertObject.Datetime1.ToString("yyyy-MM-dd") != data.Datetime1.ToString("yyyy-MM-dd") || + insertObject.Decimal1 != data.Decimal1 || + insertObject.Float1 != data.Float1 || + insertObject.Float2 != data.Float2 || + insertObject.Int2 != data.Int2 || + insertObject.Money1 != data.Money1 || + insertObject.Guid2!=data.Guid2|| + 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") != data.Datetime1.ToString("yyyy-MM-dd") || + 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.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Delete.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Delete.cs new file mode 100644 index 000000000..ac61367cd --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Delete.cs @@ -0,0 +1,67 @@ +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 +{ + 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`", + 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"); + + var t6 = db.Deleteable().Where("id=@id",new { id=1}).ToSql(); + base.Check(@"DELETE FROM `STudent` WHERE id=@id", new List() { + new SugarParameter("@id",1) + }, t6.Key, t6.Value, "Delte t6 error"); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Field.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Field.cs new file mode 100644 index 000000000..1a1080346 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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 MySqlExpressionContext();//可以更换 + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Method.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Method.cs new file mode 100644 index 000000000..7bb81f322 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Method.cs @@ -0,0 +1,610 @@ +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"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(`Id` AS TEXT) = @Const0 )", new List() { + new SugarParameter("@Const0","a") + }, "ExtendToString error"); + } + + private void ConvetToString() + { + Expression> exp = it => Convert.ToString(it.Id) == "a"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(`Id` AS TEXT) = @Const0 )", new List() { + new SugarParameter("@Const0","a") + }, "ConvetToString error"); + } + + + private void Length() + { + Expression> exp = it => SqlFunc.Length("aaaa") > 1; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(LENGTH(@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"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS SIGNED) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS DECIMAL(18,4)) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS TEXT) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS DECIMAL(18,4)) = @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"; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS TEXT) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(DATETIME(@MethodConst0) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(DATETIME(@MethodConst0) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS INTEGER) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(@MethodConst0 AS INTEGER) = @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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(CAST(STRFTIME('%Y', DATETIME(DATETIME(@MethodConst0), 'LOCALTIME')) AS INTEGER) = @Const2 )", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@Const2",1) + }, "DateValue error"); + } + + private void StartsWith() + { + Expression> exp = it => SqlFunc.StartsWith(it.Name, "a"); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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"); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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.Minute) == x2; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(DATETIME(DATETIME(@MethodConst0), '+11 Minutes') = @Const3 )", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",11),new SugarParameter("@Const3",x2) + }, "DateAddByType error"); + } + private void DateAddDay() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateAdd(x2, 1) == x2; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, "(DATE(DATETIME(@MethodConst0), '+1 days') = @Const2 )", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",1),new SugarParameter("@Const2",x2) + }, "DateAddDay error"); + } + + private void DateIsSameByType() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateIsSame(x2, x2, DateType.Millisecond); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " Cast((JulianDay(@MethodConst0) - JulianDay(@MethodConst1)) *86400000 As INTEGER)", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2) + }, "DateIsSameByType error"); + } + private void DateIsSameByDay() + { + var x2 = DateTime.Now; + Expression> exp = it => SqlFunc.DateIsSame(x2, x2); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + expContext.Resolve(exp, ResolveExpressType.WhereSingle); + var value = expContext.Result.GetString(); + var pars = expContext.Parameters; + base.Check(value, pars, " Cast((JulianDay(@MethodConst0) - JulianDay(@MethodConst1)) *1 As INTEGER)", new List() { + new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2) + }, "DateIsSameDay error"); + } + + private void Equals() + { + Expression> exp = it => SqlFunc.Equals(it.Name, "a"); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext2 = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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"); + SqliteExpressionContext expContext2 = new SqliteExpressionContext(); + 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"); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); ; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); ; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); ; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); ; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); ; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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); + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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; + SqliteExpressionContext expContext = new SqliteExpressionContext(); + 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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Select.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Select.cs new file mode 100644 index 000000000..4686721ce --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Where.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/ExpressionTest/Where.cs new file mode 100644 index 000000000..567b9d76d --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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 MySqlExpressionContext(); + 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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Insert.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Insert.cs new file mode 100644 index 000000000..74f21583f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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 LAST_INSERT_ROWID();", + 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 LAST_INSERT_ROWID();", 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 LAST_INSERT_ROWID();", + 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` + (`SchoolId`,`CreateTime`) + VALUES + (@SchoolId,@CreateTime) ;SELECT LAST_INSERT_ROWID();", +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` + (`SchoolId`,`Name`,`CreateTime`) + VALUES + (@SchoolId,@Name,@CreateTime) ;SELECT LAST_INSERT_ROWID();", +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 LAST_INSERT_ROWID();", + 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 IgnoreColumnList(); + 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.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Mapping .cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Mapping .cs new file mode 100644 index 000000000..05abeb29e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/PerformanceTest.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/PerformanceTest.cs new file mode 100644 index 000000000..3ac2b9286 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/JoinQuery.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/JoinQuery.cs new file mode 100644 index 000000000..7fc2b3e0c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite }); + db.Ado.IsEnableLogEvent = true; + db.Ado.LogEventStarting = (sql, pars) => + { + Console.WriteLine(sql + " " + pars); + }; + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/SelectQuery.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/SelectQuery.cs new file mode 100644 index 000000000..5db6517ee --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/SingleQuery.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/SingleQuery.cs new file mode 100644 index 000000000..45ce5012a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Query/SingleQuery.cs @@ -0,0 +1,119 @@ +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` ", 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(@"SELECT `ID`,`SchoolId`,`Name`,`CreateTime` FROM `STudent` ORDER BY `ID` ASC LIMIT 0,3", null, t4.Key, null, "single t4 Error"); + + var t5 = db.Queryable().OrderBy(it => it.Id).Skip(3).ToSql(); + base.Check(@"SELECT `ID`,`SchoolId`,`Name`,`CreateTime` FROM `STudent` LIMIT 3,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(@"SELECT `ID`,`SchoolId`,`Name`,`CreateTime` FROM `STudent` ORDER BY `ID` DESC LIMIT 10,10", 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(@"SELECT `ID`,`SchoolId`,`Name`,`CreateTime` FROM `STudent` WHERE ( `ID` = @Id0 ) AND (`Name` like '%'||@MethodConst1||'%') ORDER BY `ID` DESC LIMIT 10,10", 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.Sqlite }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/Attribute.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/Attribute.cs new file mode 100644 index 000000000..e0e8da931 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/AutoClose.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/AutoClose.cs new file mode 100644 index 000000000..d6cf58435 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/MapColumn.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/MapColumn.cs new file mode 100644 index 000000000..5b3301226 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/MapTable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Setting/MapTable.cs new file mode 100644 index 000000000..f5b2b11e7 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/UnitTestBase.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/UnitTestBase.cs new file mode 100644 index 000000000..286075238 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Update.cs b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/UnitTest/Update.cs new file mode 100644 index 000000000..0c2641cae --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/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` 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` 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` = @Const1 , `Name` = @Const0 WHERE ( `ID` = @Id2 )", new List() { + new SugarParameter("@Const0","x"), + new SugarParameter("@Const1",18), + new SugarParameter("@Id2",11)}, + t10.Key, + t10.Value, + "Update 10 error" + ); + } + + public SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { ConnectionString = Config.ConnectionString, DbType = DbType.Sqlite, IsAutoCloseConnection = true }); + return db; + } + } +}