From 6b905b93b7feb2ce2805f123a5a7acfd7cec0f63 Mon Sep 17 00:00:00 2001 From: sunkaixuna <610262374@qq.com> Date: Sun, 5 Sep 2021 11:23:00 +0800 Subject: [PATCH] Add oscar database --- .../SqlSeverTest/OscarTest/Config.cs | 31 ++ .../OscarTest/Demo/Demo0_SqlSugarClient.cs | 416 ++++++++++++++++++ .../OscarTest/Demo/Demo1_Queryable.cs | 341 ++++++++++++++ .../OscarTest/Demo/Demo2_Updateable.cs | 107 +++++ .../OscarTest/Demo/Demo3_Insertable.cs | 56 +++ .../OscarTest/Demo/Demo4_Deleteable.cs | 48 ++ .../OscarTest/Demo/Demo5_SqlQueryable.cs | 37 ++ .../OscarTest/Demo/Demo6_Queue.cs | 52 +++ .../SqlSeverTest/OscarTest/Demo/Demo7_Ado.cs | 57 +++ .../OscarTest/Demo/Demo8_Saveable.cs | 48 ++ .../OscarTest/Demo/Demo9_EntityMain.cs | 46 ++ .../OscarTest/Demo/DemoA_DbMain.cs | 42 ++ .../SqlSeverTest/OscarTest/Demo/DemoB_Aop.cs | 68 +++ .../OscarTest/Demo/DemoD_DbFirst.cs | 75 ++++ .../OscarTest/Demo/DemoE_CodeFirst.cs | 40 ++ .../OscarTest/Demo/DemoF_Utilities.cs | 46 ++ .../OscarTest/Demo/DemoG_SimpleClient.cs | 36 ++ .../OscarTest/Demo/Democ_GobalFilter.cs | 77 ++++ .../OscarTest/Models/AttributeTable.cs | 20 + .../SqlSeverTest/OscarTest/Models/CarType.cs | 7 + .../SqlSeverTest/OscarTest/Models/Custom.cs | 14 + .../OscarTest/Models/EntityMapper.cs | 15 + .../SqlSeverTest/OscarTest/Models/Mapper.cs | 54 +++ .../Models/MyCustomAttributeTable.cs | 20 + .../SqlSeverTest/OscarTest/Models/Order.cs | 24 + .../OscarTest/Models/OrderItem.cs | 18 + .../SqlSeverTest/OscarTest/Models/TestTree.cs | 17 + .../SqlSeverTest/OscarTest/Models/Tree.cs | 20 + .../OscarTest/Models/ViewOrder.cs | 13 + .../SqlSeverTest/OscarTest/OscarTest.csproj | 12 + .../SqlSeverTest/OscarTest/Program.cs | 40 ++ .../SqlSeverTest/SqlSeverTest.sln | 8 +- .../SqlSeverTest/SqlSugar/Enum/DbType.cs | 3 +- .../SqlSugar/OnlyCore/DataExtensions.cs | 129 ++++++ .../Oscar/CodeFirst/OscarCodeFirst.cs | 74 ++++ .../Realization/Oscar/DbBind/OscarDbBind.cs | 128 ++++++ .../Realization/Oscar/DbFirst/OscarDbFirst.cs | 11 + .../Oscar/DbMaintenance/OscarDbMaintenance.cs | 402 +++++++++++++++++ .../Oscar/Insertable/OscarInserttable.cs | 74 ++++ .../Realization/Oscar/OscarProvider.cs | 163 +++++++ .../Oscar/Queryable/OscarQueryable.cs | 69 +++ .../Oscar/SqlBuilder/OscarBuilder.cs | 97 ++++ .../Oscar/SqlBuilder/OscarDeleteBuilder.cs | 7 + .../SqlBuilder/OscarExpressionContext.cs | 283 ++++++++++++ .../Oscar/SqlBuilder/OscarInsertBuilder.cs | 93 ++++ .../Oscar/SqlBuilder/OscarQueryBuilder.cs | 94 ++++ .../Oscar/SqlBuilder/OscarUpdateBuilder.cs | 184 ++++++++ .../SqlSeverTest/SqlSugar/SqlSugar.csproj | 1 + 48 files changed, 3715 insertions(+), 2 deletions(-) create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Config.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo0_SqlSugarClient.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo1_Queryable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo2_Updateable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo3_Insertable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo4_Deleteable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo5_SqlQueryable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo6_Queue.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo7_Ado.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo8_Saveable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo9_EntityMain.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoA_DbMain.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoB_Aop.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoD_DbFirst.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoE_CodeFirst.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoF_Utilities.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoG_SimpleClient.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Democ_GobalFilter.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/AttributeTable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/CarType.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Custom.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/EntityMapper.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Mapper.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/MyCustomAttributeTable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Order.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/OrderItem.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/TestTree.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Tree.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/ViewOrder.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/OscarTest.csproj create mode 100644 Src/Asp.NetCore2/SqlSeverTest/OscarTest/Program.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/CodeFirst/OscarCodeFirst.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbBind/OscarDbBind.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbFirst/OscarDbFirst.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbMaintenance/OscarDbMaintenance.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Insertable/OscarInserttable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/OscarProvider.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Queryable/OscarQueryable.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarBuilder.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarDeleteBuilder.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarExpressionContext.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarInsertBuilder.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarQueryBuilder.cs create mode 100644 Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarUpdateBuilder.cs diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Config.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Config.cs new file mode 100644 index 000000000..c8c29c8d8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Config.cs @@ -0,0 +1,31 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + /// + /// Setting up the database name does not require you to create the database + /// 设置好数据库名不需要你去手动建库 + /// + public class Config + { + /// + /// Account have permission to create database + /// 用有建库权限的数据库账号 + /// + public static string ConnectionString = "PORT=5432;DATABASE=SqlSugar4xTest;HOST=localhost;PASSWORD=haosql;USER ID=postgres"; + /// + /// Account have permission to create database + /// 用有建库权限的数据库账号 + /// + public static string ConnectionString2 = "PORT=5432;DATABASE=SqlSugar4xTest2;HOST=localhost;PASSWORD=haosql;USER ID=postgres"; + /// + /// Account have permission to create database + /// 用有建库权限的数据库账号 + /// + public static string ConnectionString3 = "PORT=5432;DATABASE=SqlSugar4xTest3;HOST=localhost;PASSWORD=haosql;USER ID=postgres"; + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo0_SqlSugarClient.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo0_SqlSugarClient.cs new file mode 100644 index 000000000..8fffe703e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo0_SqlSugarClient.cs @@ -0,0 +1,416 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +namespace OrmTest +{ + public class Demo0_SqlSugarClient + { + + public static void Init() + { + SqlSugarClient();//Create db + DbContext();//Optimizing SqlSugarClient usage + SingletonPattern();//Singleten Pattern + DistributedTransactionExample(); + MasterSlave();//Read-write separation + CustomAttribute(); + } + + private static void MasterSlave() + { + Console.WriteLine(""); + Console.WriteLine("#### MasterSlave Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString,//Master Connection + DbType = DbType.Oscar, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + SlaveConnectionConfigs = new List() { + new SlaveConnectionConfig() { HitRate=10, ConnectionString=Config.ConnectionString2 } , + new SlaveConnectionConfig() { HitRate=10, ConnectionString=Config.ConnectionString2 } + } + }); + db.Aop.OnLogExecuted = (s, p) => + { + Console.WriteLine(db.Ado.Connection.ConnectionString); + }; + Console.WriteLine("Master:"); + db.Insertable(new Order() { Name = "abc", CustomId = 1, CreateTime = DateTime.Now }).ExecuteCommand(); + Console.WriteLine("Slave:"); + db.Queryable().First(); + Console.WriteLine("#### MasterSlave End ####"); + } + + private static void SqlSugarClient() + { + //Create db + Console.WriteLine("#### SqlSugarClient Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + //If no exist create datebase + db.DbMaintenance.CreateDatabase(); + + //Use db query + var dt = db.Ado.GetDataTable("select 1"); + + //Create tables + db.CodeFirst.InitTables(typeof(OrderItem),typeof(Order)); + var id = db.Insertable(new Order() { Name = "order1", CustomId = 1, Price = 0, CreateTime = DateTime.Now }).ExecuteReturnIdentity(); + + //Insert data + db.Insertable(new OrderItem() { OrderId = id, Price = 0, CreateTime=DateTime.Now }).ExecuteCommand(); + Console.WriteLine("#### SqlSugarClient End ####"); + + } + + private static void DbContext() + { + Console.WriteLine(""); + Console.WriteLine("#### DbContext Start ####"); + var insertObj = new Order { Name = "jack", CreateTime = DateTime.Now }; + var InsertObjs = new Order[] { insertObj }; + + DbContext context = new DbContext(); + + context.Db.CodeFirst.InitTables();//Create Tables + ; + var orderDb = context.OrderDb; + + //Select + var data1 = orderDb.GetById(1); + var data2 = orderDb.GetList(); + var data3 = orderDb.GetList(it => it.Id == 1); + var data4 = orderDb.GetSingle(it => it.Id == 1); + var p = new PageModel() { PageIndex = 1, PageSize = 2 }; + var data5 = orderDb.GetPageList(it => it.Name == "xx", p); + Console.Write(p.TotalCount); + var data6 = orderDb.GetPageList(it => it.Name == "xx", p, it => it.Name, OrderByType.Asc); + Console.Write(p.TotalCount); + List conModels = new List(); + conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1", FieldValueConvertFunc=it=>Convert.ToInt32(it) });//id=1 + var data7 = orderDb.GetPageList(conModels, p, it => it.Name, OrderByType.Asc); + orderDb.AsQueryable().Where(x => x.Id == 1).ToList(); + + //Insert + orderDb.Insert(insertObj); + orderDb.InsertRange(InsertObjs); + var id = orderDb.InsertReturnIdentity(insertObj); + orderDb.AsInsertable(insertObj).ExecuteCommand(); + + + //Delete + orderDb.Delete(insertObj); + orderDb.DeleteById(11111); + orderDb.DeleteById(new int[] { 1111, 2222 }); + orderDb.Delete(it => it.Id == 1111); + orderDb.AsDeleteable().Where(it => it.Id == 1111).ExecuteCommand(); + + //Update + orderDb.Update(insertObj); + orderDb.UpdateRange(InsertObjs); + orderDb.Update(it => new Order() { Name = "a", }, it => it.Id == 1); + orderDb.AsUpdateable(insertObj).UpdateColumns(it => new { it.Name }).ExecuteCommand(); + + //Use Inherit DbContext + OrderDal dal = new OrderDal(); + var data = dal.GetById(1); + var list = dal.GetList(); + + Console.WriteLine("#### DbContext End ####"); + } + + private static void CustomAttribute() + { + Console.WriteLine(""); + Console.WriteLine("#### Custom Attribute Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString, + DbType = DbType.Oscar, + IsAutoCloseConnection = true, + InitKeyType = InitKeyType.Attribute, + ConfigureExternalServices = new ConfigureExternalServices() + { + EntityService = (property, column) => + { + + var attributes = property.GetCustomAttributes(true);//get all attributes + + if (attributes.Any(it => it is KeyAttribute))// by attribute set primarykey + { + column.IsPrimarykey = true; + } + }, + EntityNameService = (type, entity) => + { + var attributes = type.GetCustomAttributes(true); + if (attributes.Any(it => it is TableAttribute)) + { + entity.DbTableName = (attributes.First(it => it is TableAttribute) as TableAttribute).Name; + } + } + } + }); + db.CodeFirst.InitTables();//Create Table + + db.Insertable(new AttributeTable() { Id = Guid.NewGuid().ToString(), Name = "Name" }).ExecuteCommand(); + var list = db.Queryable().ToList(); + + Console.WriteLine("#### Custom Attribute End ####"); + } + + + private static void SingletonPattern() + { + Console.WriteLine(""); + Console.WriteLine("#### Singleton Pattern Start ####"); + Console.WriteLine("Db_Id:" + singleDb.ContextID); + Console.WriteLine("Db_Id:" + singleDb.ContextID); + var task = new Task(() => + { + Console.WriteLine("Task DbId:" + singleDb.ContextID); + new Task(() => + { + Console.WriteLine("_Task_Task DbId:" + singleDb.ContextID); + Console.WriteLine("_Task_Task DbId:" + singleDb.ContextID); + + }).Start(); + Console.WriteLine("Task DbId:" + singleDb.ContextID); + }); + task.Start(); + task.Wait(); + System.Threading.Thread.Sleep(500); + Console.WriteLine(string.Join(",", singleDb.TempItems.Keys)); + + Console.WriteLine("#### Singleton Pattern end ####"); + } + + static SqlSugarClient singleDb = new SqlSugarClient( + new ConnectionConfig() + { + ConfigId = 1, + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents() + { + OnLogExecuting = (sql, p) => { Console.WriteLine(sql); } + } + }); + + + private static void DistributedTransactionExample() + { + Console.WriteLine(""); + Console.WriteLine("#### Distributed TransactionExample Start ####"); + SqlSugarClient db = new SqlSugarClient(new List() + { + new ConnectionConfig(){ ConfigId="1", DbType=DbType.Oscar, ConnectionString=Config.ConnectionString,InitKeyType=InitKeyType.Attribute,IsAutoCloseConnection=true }, + new ConnectionConfig(){ ConfigId="2", DbType=DbType.Oscar, ConnectionString=Config.ConnectionString2 ,InitKeyType=InitKeyType.Attribute ,IsAutoCloseConnection=true} + }); + + //use db1 + db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(Order), typeof(OrderItem));// + db.Insertable(new Order() { Name = "order1", CreateTime = DateTime.Now }).ExecuteCommand(); + Console.WriteLine(db.CurrentConnectionConfig.DbType + ":" + db.Queryable().Count()); + + //use db2 + db.ChangeDatabase("2"); + db.DbMaintenance.CreateDatabase();//Create Database2 + db.CodeFirst.SetStringDefaultLength(200).InitTables(typeof(Order), typeof(OrderItem)); + db.Insertable(new Order() { Name = "order1", CreateTime = DateTime.Now }).ExecuteCommand(); + Console.WriteLine(db.CurrentConnectionConfig.DbType + ":" + db.Queryable().Count()); + + // Example 1 + Console.WriteLine("Example 1"); + try + { + db.BeginTran(); + + db.ChangeDatabase("1");//use db1 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use db2 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + throw new Exception(); + db.CommitTran(); + } + catch + { + db.RollbackTran(); + Console.WriteLine("---Roll back"); + db.ChangeDatabase("1");//use db1 + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use db2 + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + } + + + + // Example 2 + Console.WriteLine("Example 2"); + + var result=db.UseTran(() => + { + + db.ChangeDatabase("1");//use db1 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use db2 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + throw new Exception(""); + + }); + if (result.IsSuccess == false) { + Console.WriteLine("---Roll back"); + db.ChangeDatabase("1");//use db1 + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use db2 + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + } + + // Example 3 + Console.WriteLine("Example 3"); + + var result2 = db.UseTranAsync(() => + { + + db.ChangeDatabase("1");//use db1 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use db2 + db.Deleteable().ExecuteCommand(); + Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + throw new Exception(""); + + }); + result2.Wait(); + if (result.IsSuccess == false) + { + Console.WriteLine("---Roll back"); + db.ChangeDatabase("1");//use sqlserver + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + + db.ChangeDatabase("2");//use mysql + Console.WriteLine(db.CurrentConnectionConfig.DbType); + Console.WriteLine(db.Queryable().Count()); + } + + Console.WriteLine("#### Distributed TransactionExample End ####"); + } + } + + /// + /// DbContext Example 1 + /// + public class DbContext + { + + public SqlSugarClient Db; + public DbContext() + { + Db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString, + DbType = DbType.Oscar, + IsAutoCloseConnection = true, + InitKeyType = InitKeyType.Attribute, + AopEvents = new AopEvents() + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + } + } + }); + } + public SimpleClient OrderDb => new SimpleClient(Db); + public SimpleClient OrderItemDb => new SimpleClient(Db); + } + + + public class OrderDal : DbContext + { + + } + /// + /// DbContext Example 2 + /// + /// + public class DbContext where T : class, new() + { + + public SqlSugarClient Db; + public DbContext() + { + Db = new SqlSugarClient(new ConnectionConfig() + { + ConnectionString = Config.ConnectionString, + DbType = DbType.Oscar, + IsAutoCloseConnection = true, + InitKeyType = InitKeyType.Attribute, + AopEvents = new AopEvents() + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + } + } + }); + } + public SimpleClient CurrentDb => new SimpleClient(Db); + public virtual T GetById(int id) + { + return CurrentDb.GetById(id); + } + public virtual List GetList() + { + return CurrentDb.GetList(); + } + public virtual bool Delete(int id) + { + return CurrentDb.DeleteById(id); + } + } + +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo1_Queryable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo1_Queryable.cs new file mode 100644 index 000000000..0fc78968c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo1_Queryable.cs @@ -0,0 +1,341 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Data; +using System.Dynamic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + public class Demo1_Queryable + { + + public static void Init() + { + EasyExamples(); + QueryConditions(); + JoinTable(); + Async(); + NoEntity(); + Mapper(); + SqlFuncTest(); + Subquery(); + ReturnType(); + } + + private static void EasyExamples() + { + Console.WriteLine(""); + Console.WriteLine("#### Examples Start ####"); + var db = GetInstance(); + var dbTime = db.GetDate(); + var getAll = db.Queryable().ToList(); + var getOrderBy = db.Queryable().OrderBy(it => it.Name,OrderByType.Desc).ToList(); + var getOrderBy2 = db.Queryable().OrderBy(it => it.Id).OrderBy(it => it.Name, OrderByType.Desc).ToList(); + var getOrderBy3 = db.Queryable().OrderBy(it =>new { it.Name,it.Id}).ToList(); + var getRandom = db.Queryable().OrderBy(it => SqlFunc.GetRandom()).First(); + var getByPrimaryKey = db.Queryable().InSingle(2); + var getSingleOrDefault = db.Queryable().Where(it => it.Id == 1).Single(); + var getFirstOrDefault = db.Queryable().First(); + var getByWhere = db.Queryable().Where(it => it.Id == 1 || it.Name == "a").ToList(); + var getByWhere2 = db.Queryable().Where(it => it.Id == DateTime.Now.Year).ToList(); + var getByFuns = db.Queryable().Where(it => SqlFunc.IsNullOrEmpty(it.Name)).ToList(); + var getByFuns2 = db.Queryable().GroupBy(it => it.Name).Select(it => SqlFunc.AggregateDistinctCount(it.Price)).ToList(); + Console.WriteLine("#### Examples End ####"); + } + + private static void ReturnType() + { + Console.WriteLine(""); + Console.WriteLine("#### ReturnType Start ####"); + var db = GetInstance(); + List list = db.Queryable().ToList(); + + Order item = db.Queryable().First(it => it.Id == 1); + + DataTable dataTable = db.Queryable().Select(it => it.Id).ToDataTable(); + + var json = db.Queryable().ToJson(); + + List listInt = db.Queryable().Select(it => it.Id).ToList(); + + var dynamic = db.Queryable().Select().ToList(); + + var viewModel = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId , + JoinType.Left, o.CustomId == c.Id + )) + .Select().ToList(); + + var newDynamic = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, o.CustomId == c.Id + )) + .Select((o, i, c) => new { orderName = o.Name, cusName=c.Name }).ToList(); + + var newClass = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, o.CustomId == c.Id + )) + .Select((o, i, c) => new ViewOrder { Name=o.Name, CustomName=c.Name }).ToList(); + + + var oneClass = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, o.CustomId == c.Id + )) + .Select((o, i, c) => c).ToList(); + + var twoClass = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, o.CustomId == c.Id + )) + .Select((o, i, c) => new { o,i}).ToList(); + + List> ListDic = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, o.CustomId == c.Id + )) + .Select().ToList().Select(it => it.ToDictionary(x => x.Key, x => x.Value)).ToList(); + Console.WriteLine("#### ReturnType End ####"); + } + + private static void Subquery() + { + Console.WriteLine(""); + Console.WriteLine("#### Subquery Start ####"); + var db = GetInstance(); + + var list = db.Queryable().Take(10).Select(it => new + { + customName=SqlFunc.Subqueryable().Where("it.CustomId=id").Select(s=>s.Name), + customName2 = SqlFunc.Subqueryable().Where("it.CustomId = id").Where(s => true).Select(s => s.Name) + }).ToList(); + + var list2 = db.Queryable().Where(it => SqlFunc.Subqueryable().Where(i => i.OrderId == it.Id).Any()).ToList(); + + Console.WriteLine("#### Subquery End ####"); + } + + private static void SqlFuncTest() + { + Console.WriteLine(""); + Console.WriteLine("#### SqlFunc Start ####"); + var db = GetInstance(); + var index= db.Queryable().Select(it => SqlFunc.Contains("a", "cccacc")).First(); + + Console.WriteLine("#### SqlFunc End ####"); + } + + private static void Mapper() + { + Console.WriteLine(""); + Console.WriteLine("#### Mapper Start ####"); + var db = GetInstance(); + //Creater Table + db.CodeFirst.InitTables(typeof(Tree)); + db.DbMaintenance.TruncateTable("tree"); + db.Insertable(new Tree() { Id = 1, Name = "root" }).ExecuteCommand(); + db.Insertable(new Tree() { Id = 11, Name = "child1",ParentId=1 }).ExecuteCommand(); + db.Insertable(new Tree() { Id = 12, Name = "child2",ParentId=1 }).ExecuteCommand(); + db.Insertable(new Tree() { Id = 2, Name = "root" }).ExecuteCommand(); + db.Insertable(new Tree() { Id = 22, Name = "child3", ParentId = 2 }).ExecuteCommand(); + + // Same property name mapping,Both entities have parentId + var list = db.Queryable().Mapper(it => it.Parent, it => it.ParentId).ToList(); + + + //If both entities have parentId, I don't want to associate with parentId. + var list1 =db.Queryable() + //parent=(select * from parent where id=it.parentid) + .Mapper(it=>it.Parent,it=>it.ParentId, it=>it.Parent.Id) + //Child=(select * from parent where ParentId=it.id) + .Mapper(it => it.Child, it => it.Id, it => it.Parent.ParentId) + .ToList(); + //one to one + var list2 = db.Queryable().Mapper(it => it.Order, it => it.OrderId).ToList(); + + //one to many + var list3 = db.Queryable().Mapper(it => it.Items, it => it.Items.First().OrderId).ToList(); + + //many to many + db.CodeFirst.InitTables(); + + db.Insertable(new A() { Name = "A" }).ExecuteCommand(); + db.Insertable(new B() { Name = "B" }).ExecuteCommand(); + db.Insertable(new ABMapping() { AId = 1, BId = 1 }).ExecuteCommand(); + + var list4 = db.Queryable() + .Mapper(it => it.A, it => it.AId) + .Mapper(it => it.B, it => it.BId).ToList(); + + //Manual mode + var result = db.Queryable().Take(10).Select().Mapper((itemModel, cache) => + { + var allItems = cache.Get(orderList => { + var allIds = orderList.Select(it => it.Id).ToList(); + return db.Queryable().Where(it => allIds.Contains(it.OrderId)).ToList();//Execute only once + }); + itemModel.Items = allItems.Where(it => it.OrderId==itemModel.Id).ToList();//Every time it's executed + }).ToList(); + + Console.WriteLine("#### End Start ####"); + } + + private static void NoEntity() + { + Console.WriteLine(""); + Console.WriteLine("#### No Entity Start ####"); + var db = GetInstance(); + + var list = db.Queryable().AS("order").Where("id=id", new { id = 1 }).ToList(); + + var list2 = db.Queryable("o").AS("order").AddJoinInfo("OrderDetail", "i", "o.id=i.OrderId").Where("id=id", new { id = 1 }).Select("o.*").ToList(); + Console.WriteLine("#### No Entity End ####"); + } + + private static void JoinTable() + { + Console.WriteLine(""); + Console.WriteLine("#### Join Table Start ####"); + var db = GetInstance(); + + //Simple join + var list = db.Queryable((o, i, c) => o.Id == i.OrderId&&c.Id == o.CustomId) + .Select() + .ToList(); + + //Join table + var list2 = db.Queryable((o, i, c) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId, + JoinType.Left, c.Id == o.CustomId + )) + .Select().ToList(); + + //Join queryable + var query1 = db.Queryable((o, i) => new JoinQueryInfos( + JoinType.Left, o.Id == i.OrderId + )) + .Where(o => o.Name == "jack"); + + var query2 = db.Queryable(); + var list3=db.Queryable(query1, query2,JoinType.Left, (p1, p2) => p1.CustomId == p2.Id).Select().ToList(); + + Console.WriteLine("#### Join Table End ####"); + } + + private static void QueryConditions() + { + Console.WriteLine(""); + Console.WriteLine("#### Query Conditions Start ####"); + + SqlSugarClient db = GetInstance(); + + /*** By expression***/ + + //id=@id + var list = db.Queryable().Where(it => it.Id == 1).ToList(); + //id=@id or name like '%'+@name+'%' + var list2 = db.Queryable().Where(it => it.Id == 1 || it.Name.Contains("jack")).ToList(); + + + //Create expression + var exp = Expressionable.Create() + .And(it => it.Id == 1) + .Or(it => it.Name.Contains("jack")).ToExpression(); + var list3 = db.Queryable().Where(exp).ToList(); + + + /*** By sql***/ + + //id=@id + var list4 = db.Queryable().Where("id=@id", new { id = 1 }).ToList(); + //id=@id or name like '%'+@name+'%' + var list5 = db.Queryable().Where("id=@id or name like @name ", new { id = 1, name = "%jack%" }).ToList(); + + + + /*** By dynamic***/ + + //id=1 + var conModels = new List(); + conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" , FieldValueConvertFunc=it=>Convert.ToInt32(it) });//id=1 + var student = db.Queryable().Where(conModels).ToList(); + + //Complex use case + List Order = new List(); + conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1", FieldValueConvertFunc = it => Convert.ToInt32(it) });//id=1 + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Like, FieldValue = "1", FieldValueConvertFunc = it => Convert.ToInt32(it) });// id like '%1%' + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.IsNullOrEmpty }); + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.In, FieldValue = "1,2,3" }); + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.NotIn, FieldValue = "1,2,3" }); + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.NoEqual, FieldValue = "1,2,3" }); + //conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.IsNot, FieldValue = null });// id is not null + + conModels.Add(new ConditionalCollections() + { + ConditionalList = new List>()// (id=1 or id=2 and id=1) + { + //new KeyValuePair( WhereType.And ,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" }), + new KeyValuePair (WhereType.Or,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "2" , FieldValueConvertFunc = it => Convert.ToInt32(it) }), + new KeyValuePair ( WhereType.And,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "2" ,FieldValueConvertFunc = it => Convert.ToInt32(it)}) + } + }); + var list6 = db.Queryable().Where(conModels).ToList(); + + /*** Conditional builder ***/ + + // use whereif + string name = ""; + int id = 1; + var query = db.Queryable() + .WhereIF(!string.IsNullOrEmpty(name), it => it.Name.Contains(name)) + .WhereIF(id > 0, it => it.Id == id).ToList(); + //clone new Queryable + var query2 = db.Queryable().Where(it => it.Id == 1); + var list7 = query2.Clone().Where(it => it.Name == "jack").ToList();//id=1 and name = jack + var list8 = query2.Clone().Where(it => it.Name == "tom").ToList();//id=1 and name = tom + + Console.WriteLine("#### Condition Screening End ####"); + + + + } + + private static void Async() + { + Console.WriteLine(""); + Console.WriteLine("#### Async Start ####"); + + SqlSugarClient db = GetInstance(); + var task1 = db.Queryable().FirstAsync(); + task1.Wait(); + var task2 = db.Queryable().Where(it => it.Id == 1).ToListAsync(); + + + task2.Wait(); + + Console.WriteLine("#### Async End ####"); + } + + private static SqlSugarClient GetInstance() + { + return new SqlSugarClient(new ConnectionConfig() + { + DbType = SqlSugar.DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo2_Updateable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo2_Updateable.cs new file mode 100644 index 000000000..fa56a0d82 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo2_Updateable.cs @@ -0,0 +1,107 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo2_Updateable + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Updateable Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + + + /*** 1.entity or List ***/ + + var updateObj = new Order() { Id = 1, Name = "order1" }; + var updateObjs = new List { + new Order() { Id = 11, Name = "order11" }, + new Order() { Id = 12, Name = "order12" } + }; + + //update all columns by primary key + var result = db.Updateable(updateObj).ExecuteCommand();//update single + var result2 = db.Updateable(updateObjs).ExecuteCommand();//update List + + //Ignore Name and Price + var result3 = db.Updateable(updateObj).IgnoreColumns(it => new { it.CreateTime, it.Price }).ExecuteCommand(); + + //only update Name and CreateTime + var result4 = db.Updateable(updateObj).UpdateColumns(it => new { it.Name, it.CreateTime }).ExecuteCommand(); + + //If there is no primary key + var result5 = db.Updateable(updateObj).WhereColumns(it => new { it.Id }).ExecuteCommand();//update single by id + var result6 = db.Updateable(updateObjs).WhereColumns(it => new { it.Id }).ExecuteCommand();//update List by id + + + + + /*** 2.by expression ***/ + + //update name,createtime + var result7 = db.Updateable(it => new Order() { Name = "a", CreateTime = DateTime.Now }).Where(it => it.Id == 11).ExecuteCommand(); + var result71 = db.Updateable().SetColumns(it => new Order() { Name = "a", CreateTime = DateTime.Now }).Where(it => it.Id == 11).ExecuteCommand(); + //only update name + var result8 = db.Updateable(it => it.Name == "Name").Where(it => it.Id == 1).ExecuteCommand(); + var result81 = db.Updateable().SetColumns(it => it.Name == "Name" ).Where(it => it.Id == 1).ExecuteCommand(); + // + + + + + /*** 3.by Dictionary ***/ + var dt = new Dictionary(); + dt.Add("id", 1); + dt.Add("name", "abc"); + dt.Add("createTime", DateTime.Now); + var dtList = new List>(); + dtList.Add(dt); + + var t66 = db.Updateable(dt).AS("order").WhereColumns("id").ExecuteCommand(); + var t666 = db.Updateable(dtList).AS("order").WhereColumns("id").ExecuteCommand(); + + + + /*** 4.Other instructions ***/ + + var caseValue = "1"; + //Do not update NULL columns + db.Updateable(updateObj).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommand(); + + //if 1 update name else if 2 update name,createtime + db.Updateable(updateObj) + .UpdateColumnsIF(caseValue == "1", it => new { it.Name }) + .UpdateColumnsIF(caseValue == "2", it => new { it.Name, it.CreateTime }) + .ExecuteCommand(); + //Use Lock + db.Updateable(updateObj).With(SqlWith.UpdLock).ExecuteCommand(); + + //Where Sql + //db.Updateable(updateObj).Where("id=@x", new { x = 1 }).ExecuteCommand(); + + Console.WriteLine("#### Updateable End ####"); + } + + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo3_Insertable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo3_Insertable.cs new file mode 100644 index 000000000..ab6163bfe --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo3_Insertable.cs @@ -0,0 +1,56 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo3_Insertable + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Insertable Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + var insertObj = new Order() { Id = 1, Name = "order1",Price=0 }; + var updateObjs = new List { + new Order() { Id = 11, Name = "order11", Price=0 }, + new Order() { Id = 12, Name = "order12" , Price=0} + }; + + //Ignore CreateTime + db.Insertable(insertObj).IgnoreColumns(it => new { it.CreateTime }).ExecuteReturnIdentity();//get identity + db.Insertable(insertObj).IgnoreColumns("CreateTime").ExecuteReturnIdentity(); + + //Only insert Name and Price + db.Insertable(insertObj).InsertColumns(it => new { it.Name, it.Price }).ExecuteReturnIdentity(); + db.Insertable(insertObj).InsertColumns("Name", "Price").ExecuteReturnIdentity(); + + //ignore null columns + db.Insertable(updateObjs).ExecuteCommand();//get change row count + + //Use Lock + db.Insertable(insertObj).With(SqlWith.UpdLock).ExecuteCommand(); + + Console.WriteLine("#### Insertable End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo4_Deleteable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo4_Deleteable.cs new file mode 100644 index 000000000..ca9a58b5e --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo4_Deleteable.cs @@ -0,0 +1,48 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo4_Deleteable + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Deleteable Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + //by entity + db.Deleteable().Where(new Order() { Id = 1111 }).ExecuteCommand(); + + //by primary key + db.Deleteable().In(1111).ExecuteCommand(); + + //by primary key array + db.Deleteable().In(new int[] { 1111, 2222 }).ExecuteCommand(); + + //by expression + db.Deleteable().Where(it => it.Id == 11111).ExecuteCommand(); + + Console.WriteLine("#### Deleteable End ####"); + + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo5_SqlQueryable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo5_SqlQueryable.cs new file mode 100644 index 000000000..aa235aed8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo5_SqlQueryable.cs @@ -0,0 +1,37 @@ + +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo5_SqlQueryable + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### SqlQueryable Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true + }); + + int total = 0; + var list = db.SqlQueryable("select * from \"order\"").ToPageList(1, 2, ref total); + + + //by expression + var list2 = db.SqlQueryable("select * from \"order\"").Where(it => it.Id == 1).ToPageList(1, 2); + //by sql + var list3 = db.SqlQueryable("select * from \"order\"").Where("id=@id", new { id = 1 }).ToPageList(1, 2); + + Console.WriteLine("#### SqlQueryable End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo6_Queue.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo6_Queue.cs new file mode 100644 index 000000000..53e641491 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo6_Queue.cs @@ -0,0 +1,52 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo6_Queue + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Queue Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + db.Insertable(new Order() { Name = "a" }).AddQueue(); + db.Insertable(new Order() { Name = "b" }).AddQueue(); + db.SaveQueues(); + + + db.Insertable(new Order() { Name = "a" }).AddQueue(); + db.Insertable(new Order() { Name = "b" }).AddQueue(); + db.Insertable(new Order() { Name = "c" }).AddQueue(); + db.Insertable(new Order() { Name = "d" }).AddQueue(); + var ar = db.SaveQueuesAsync(); + ar.Wait(); + + db.Queryable().AddQueue(); + db.Queryable().AddQueue(); + db.AddQueue("select * from `order` where id=@id", new { id = 10000 }); + /* var result2 = db.SaveQueues()*/; + + Console.WriteLine("#### Queue End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo7_Ado.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo7_Ado.cs new file mode 100644 index 000000000..b561decdf --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo7_Ado.cs @@ -0,0 +1,57 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo7_Ado + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Ado Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + //sql + var dt = db.Ado.GetDataTable("select * from \"order\" where @id>0 or name=@name", new List(){ + new SugarParameter("@id",1), + new SugarParameter("@name","2") + }); + + //sql + var dt2 = db.Ado.GetDataTable("select * from \"order\" where @id>0 or name=@name", new { id = 1, name = "2" }); + + //Stored Procedure + //var dt3 = db.Ado.UseStoredProcedure().GetDataTable("sp_school", new { name = "张三", age = 0 }); + //var nameP = new SugarParameter("@name", "张三"); + //var ageP = new SugarParameter("@age", null, true);//isOutput=true + //var dt4 = db.Ado.UseStoredProcedure().GetDataTable("sp_school", nameP, ageP); + + + + //There are many methods to under db.ado + var list= db.Ado.SqlQuery("select * from \"order\" "); + var intValue=db.Ado.SqlQuerySingle("select 1"); + db.Ado.ExecuteCommand("delete from \"order\" where id>1000"); + //db.Ado.xxx + Console.WriteLine("#### Ado End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo8_Saveable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo8_Saveable.cs new file mode 100644 index 000000000..44e2528a0 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo8_Saveable.cs @@ -0,0 +1,48 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo8_Saveable + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Saveable Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + + //insert or update + db.Saveable(new Order() { Id=1, Name="jack" }).ExecuteReturnEntity(); + + + //insert or update + db.Saveable(new Order() { Id = 1000, Name = "jack", CreateTime=DateTime.Now }) + .InsertColumns(it => new { it.Name,it.CreateTime, it.Price})//if insert into name,CreateTime,Price + .UpdateColumns(it => new { it.Name, it.CreateTime })//if update set name CreateTime + .ExecuteReturnEntity(); + + Console.WriteLine(""); + Console.WriteLine("#### Saveable End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo9_EntityMain.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo9_EntityMain.cs new file mode 100644 index 000000000..1938d6a97 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Demo9_EntityMain.cs @@ -0,0 +1,46 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Demo9_EntityMain + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### EntityMain Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + var entityInfo = db.EntityMaintenance.GetEntityInfo(); + foreach (var column in entityInfo.Columns) + { + Console.WriteLine(column.DbColumnName); + } + + var dbColumnsName = db.EntityMaintenance.GetDbColumnName("Name"); + + var dbTableName = db.EntityMaintenance.GetTableName(); + + //more https://github.com/sunkaixuan/SqlSugar/wiki/9.EntityMain + Console.WriteLine("#### EntityMain End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoA_DbMain.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoA_DbMain.cs new file mode 100644 index 000000000..e55ac890a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoA_DbMain.cs @@ -0,0 +1,42 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class DemoA_DbMain + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### DbMain Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + var tables = db.DbMaintenance.GetTableInfoList(); + foreach (var table in tables) + { + Console.WriteLine(table.Description); + } + //more https://github.com/sunkaixuan/SqlSugar/wiki/a.DbMain + Console.WriteLine("#### DbMain End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoB_Aop.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoB_Aop.cs new file mode 100644 index 000000000..8bcd4ba4a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoB_Aop.cs @@ -0,0 +1,68 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class DemoB_Aop + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Aop Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true + }); + db.Aop.OnLogExecuted = (sql, pars) => //SQL executed event + { + Console.WriteLine("OnLogExecuted"+sql); + }; + db.Aop.OnLogExecuting = (sql, pars) => //SQL executing event (pre-execution) + { + Console.WriteLine("OnLogExecuting" + sql); + }; + db.Aop.OnError = (exp) =>//SQL execution error event + { + //exp.sql + }; + db.Aop.OnExecutingChangeSql = (sql, pars) => //SQL executing event (pre-execution,SQL script can be modified) + { + return new KeyValuePair(sql, pars); + }; + db.Aop.OnDiffLogEvent = it =>//Get data changes + { + var editBeforeData = it.BeforeData; + var editAfterData = it.AfterData; + var sql = it.Sql; + var parameter = it.Parameters; + var businessData = it.BusinessData; + var time = it.Time; + var diffType = it.DiffType;//enum insert 、update and delete + Console.WriteLine(businessData); + Console.WriteLine(editBeforeData[0].Columns[1].Value); + Console.WriteLine("to"); + Console.WriteLine(editAfterData[0].Columns[1].Value); + //Write logic + }; + + + db.Queryable().ToList(); + db.Queryable().ToList(); + + //OnDiffLogEvent + var data = db.Queryable().First(); + data.Name = "changeName"; + db.Updateable(data).EnableDiffLogEvent("--update Order--").ExecuteCommand(); + + Console.WriteLine("#### Aop End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoD_DbFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoD_DbFirst.cs new file mode 100644 index 000000000..82d2511bd --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoD_DbFirst.cs @@ -0,0 +1,75 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + public class DemoD_DbFirst + { + public static void Init() + { + Console.WriteLine(); + Console.WriteLine("#### DbFirst Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true + }); + + db.DbFirst.CreateClassFile("c:\\Demo\\1", "Models"); + + + db.DbFirst.Where("Student").CreateClassFile("c:\\Demo\\2", "Models"); + + + db.DbFirst.Where(it => it.ToLower().StartsWith("view")).CreateClassFile("c:\\Demo\\3", "Models"); + + + db.DbFirst.Where(it => it.ToLower().StartsWith("view")).CreateClassFile("c:\\Demo\\4", "Models"); + + + db.DbFirst.IsCreateAttribute().CreateClassFile("c:\\Demo\\5", "Models"); + + + db.DbFirst.IsCreateDefaultValue().CreateClassFile("c:\\Demo\\6", "Demo.Models"); + + + db.DbFirst. SettingClassTemplate(old => { return old;}) + .SettingNamespaceTemplate(old =>{ return old;}) + .SettingPropertyDescriptionTemplate(old => + { + return @" /// + /// Desc_New:{PropertyDescription} + /// Default_New:{DefaultValue} + /// Nullable_New:{IsNullable} + /// "; + }) + .SettingPropertyTemplate(old =>{return old;}) + .SettingConstructorTemplate(old =>{return old; }) + .CreateClassFile("c:\\Demo\\7"); + + + + foreach (var item in db.DbMaintenance.GetTableInfoList()) + { + string entityName = item.Name.ToUpper();/*Format class name*/ + db.MappingTables.Add(entityName , item.Name); + foreach (var col in db.DbMaintenance.GetColumnInfosByTableName(item.Name)) + { + db.MappingColumns.Add(col.DbColumnName.ToUpper() /*Format class property name*/, col.DbColumnName, entityName); + } + } + db.DbFirst.IsCreateAttribute().CreateClassFile("c:\\Demo\\8", "Models"); + + + //Use Razor Template + //db.DbFirst.UseRazorAnalysis(RazorFirst.DefaultRazorClassTemplate).CreateClassFile(""); + + Console.WriteLine("#### DbFirst End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoE_CodeFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoE_CodeFirst.cs new file mode 100644 index 000000000..b9f83e034 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoE_CodeFirst.cs @@ -0,0 +1,40 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + public class DemoE_CodeFirst + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### CodeFirst Start ####"); + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString3, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true + }); + db.DbMaintenance.CreateDatabase(); + db.CodeFirst.InitTables(typeof(CodeFirstTable1));//Create CodeFirstTable1 + db.Insertable(new CodeFirstTable1() { Name = "a", Text="a" }).ExecuteCommand(); + var list = db.Queryable().ToList(); + Console.WriteLine("#### CodeFirst end ####"); + } + } + + public class CodeFirstTable1 + { + [SugarColumn(IsIdentity = true, IsPrimaryKey = true)] + public int Id { get; set; } + public string Name { get; set; } + [SugarColumn(ColumnDataType = "varchar(255)")]//custom + public string Text { get; set; } + [SugarColumn(IsNullable = true)] + public DateTime CreateTime { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoF_Utilities.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoF_Utilities.cs new file mode 100644 index 000000000..ef949850c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoF_Utilities.cs @@ -0,0 +1,46 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class DemoF_Utilities + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Utilities Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + + List ids = Enumerable.Range(1, 100).ToList(); + db.Utilities.PageEach(ids, 10, list => + { + Console.WriteLine(string.Join("," ,list)); + }); + + var list2= db.Utilities.DataTableToList(db.Ado.GetDataTable("select * from \"order\"")); + + //more https://github.com/sunkaixuan/SqlSugar/wiki/f.Utilities + Console.WriteLine("#### Utilities End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoG_SimpleClient.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoG_SimpleClient.cs new file mode 100644 index 000000000..060b79d75 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/DemoG_SimpleClient.cs @@ -0,0 +1,36 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class DemoG_SimpleClient + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### SimpleClient Start ####"); + + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() + { + DbType = DbType.Oscar, + ConnectionString = Config.ConnectionString, + InitKeyType = InitKeyType.Attribute, + IsAutoCloseConnection = true, + AopEvents = new AopEvents + { + OnLogExecuting = (sql, p) => + { + Console.WriteLine(sql); + Console.WriteLine(string.Join(",", p?.Select(it => it.ParameterName + ":" + it.Value))); + } + } + }); + + Console.WriteLine("#### SimpleClient End ####"); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Democ_GobalFilter.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Democ_GobalFilter.cs new file mode 100644 index 000000000..76db22902 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Demo/Democ_GobalFilter.cs @@ -0,0 +1,77 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + public class DemoC_GobalFilter + { + public static void Init() + { + Console.WriteLine(""); + Console.WriteLine("#### Filter Start ####"); + var db = GetInstance(); + + + var sql = db.Queryable().ToSql(); + //SELECT [Id],[Name],[Price],[CreateTime] FROM `order` WHERE isDelete=0 + Console.WriteLine(sql); + + + var sql2 = db.Queryable((main,ot)=> main.Id==ot.OrderId).ToSql(); + //SELECT [Id],[Name],[Price],[CreateTime] FROM `order` main ,[OrderDetail] ot WHERE ( [main].[Id] = [ot].[OrderId] ) AND main.isDelete=0 + Console.WriteLine(sql2); + + + var sql3 = db.Queryable().Filter("Myfilter").ToSql();// Myfilter+Gobal + //SELECT [Id],[Name],[Price],[CreateTime] FROM `order` WHERE Name='jack' AND isDelete=0 + Console.WriteLine(sql3); + + var sql4 = db.Queryable().Filter("Myfilter",isDisabledGobalFilter:true).ToSql();//only Myfilter + //SELECT [Id],[Name],[Price],[CreateTime] FROM `order` WHERE Name='jack' + Console.WriteLine(sql4); + Console.WriteLine("#### Filter End ####"); + } + + + public static SqlSugarClient GetInstance() + { + SqlSugarClient db = new SqlSugarClient(new ConnectionConfig() { DbType = DbType.Oscar, ConnectionString = Config.ConnectionString, IsAutoCloseConnection = true }); + + //single table query gobal filter + db.QueryFilter.Add(new SqlFilterItem() + { + FilterValue = filterDb => + { + //Writable logic + return new SqlFilterResult() { Sql = " isDelete=0" };//Global string perform best + } + }); + + //Multi-table query gobal filter + db.QueryFilter.Add(new SqlFilterItem() + { + FilterValue = filterDb => + { + //Writable logic + return new SqlFilterResult() { Sql = " main.isDelete=0" }; + }, + IsJoinQuery=true + }); + + //Specific filters + db.QueryFilter.Add(new SqlFilterItem() + { + FilterName= "Myfilter", + FilterValue = filterDb => + { + //Writable logic + return new SqlFilterResult() { Sql = "Name='jack'" }; + } + }); + return db; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/AttributeTable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/AttributeTable.cs new file mode 100644 index 000000000..c1a43ad12 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/AttributeTable.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + [Table("MyAttributeTable")] + //[SugarTable("CustomAttributeTable")] + public class AttributeTable + { + + [Key] + //[SugarColumn(IsPrimaryKey =true)] + public string Id { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/CarType.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/CarType.cs new file mode 100644 index 000000000..00dc12710 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/CarType.cs @@ -0,0 +1,7 @@ +namespace OrmTest +{ + public class CarType + { + public bool State { get; set; } + } +} \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Custom.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Custom.cs new file mode 100644 index 000000000..3b8871c57 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Custom.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Custom + { + public int Id { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/EntityMapper.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/EntityMapper.cs new file mode 100644 index 000000000..b597012fb --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/EntityMapper.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SqlSugar; +namespace OrmTest +{ + [SugarTable("MyEntityMapper")] + public class EntityMapper + { + [SugarColumn(ColumnName ="MyName")] + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Mapper.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Mapper.cs new file mode 100644 index 000000000..8d7991d6c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Mapper.cs @@ -0,0 +1,54 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + [SugarTable("OrderDetail")] + public class OrderItemInfo + { + [SqlSugar.SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int ItemId { get; set; } + public int OrderId { get; set; } + public decimal? Price { get; set; } + [SqlSugar.SugarColumn(IsNullable = true)] + public DateTime? CreateTime { get; set; } + [SugarColumn(IsIgnore = true)] + public Order Order { get; set; } + } + [SugarTable("Order")] + public class OrderInfo + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int Id { get; set; } + public string Name { get; set; } + [SugarColumn(IsIgnore = true)] + public List Items { get; set; } + } + public class ABMapping + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int AId { get; set; } + public int BId { get; set; } + [SugarColumn(IsIgnore = true)] + public A A { get; set; } + [SugarColumn(IsIgnore = true)] + public B B { get; set; } + + } + public class A + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int Id { get; set; } + public string Name { get; set; } + } + public class B + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int Id { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/MyCustomAttributeTable.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/MyCustomAttributeTable.cs new file mode 100644 index 000000000..11359d062 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/MyCustomAttributeTable.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel.DataAnnotations; +using System.ComponentModel.DataAnnotations.Schema; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + [Table("CustomAttributeTable")] + //[SugarTable("CustomAttributeTable")] + public class MyCustomAttributeTable + { + + [Key] + //[SugarColumn(IsPrimaryKey =true)] + public string Id { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Order.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Order.cs new file mode 100644 index 000000000..d7ff068b8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Order.cs @@ -0,0 +1,24 @@ +using SqlSugar; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + + public class Order + { + [SugarColumn(IsPrimaryKey = true, IsIdentity = true)] + public int Id { get; set; } + + public string Name { get; set; } + public decimal Price { get; set; } + [SugarColumn(IsNullable = true)] + public DateTime CreateTime { get; set; } + [SugarColumn(IsNullable =true)] + public int CustomId { get; set; } + [SugarColumn(IsIgnore = true)] + public List Items { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/OrderItem.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/OrderItem.cs new file mode 100644 index 000000000..ae3262c7c --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/OrderItem.cs @@ -0,0 +1,18 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OrmTest +{ + [SqlSugar.SugarTable("OrderDetail")] + public class OrderItem + { + [SqlSugar.SugarColumn(IsPrimaryKey =true, IsIdentity =true)] + public int ItemId { get; set; } + public int OrderId { get; set; } + public decimal? Price { get; set; } + [SqlSugar.SugarColumn(IsNullable = true)] + public DateTime? CreateTime { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/TestTree.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/TestTree.cs new file mode 100644 index 000000000..b8250828a --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/TestTree.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class TestTree + { + [SqlSugar.SugarColumn(ColumnDataType = "hierarchyid")] + public string TreeId { get; set; } + [SqlSugar.SugarColumn(ColumnDataType = "Geography")] + public string GId { get; set; } + public string Name { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Tree.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Tree.cs new file mode 100644 index 000000000..d2878de64 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/Tree.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace OrmTest +{ + public class Tree + { + [SqlSugar.SugarColumn(IsPrimaryKey =true)] + public int Id { get; set; } + public string Name { get; set; } + public int ParentId { get; set; } + [SqlSugar.SugarColumn(IsIgnore = true)] + public Tree Parent { get; set; } + [SqlSugar.SugarColumn(IsIgnore = true)] + public List Child { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/ViewOrder.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/ViewOrder.cs new file mode 100644 index 000000000..fcd465747 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Models/ViewOrder.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 ViewOrder:Order + { + public string CustomName { get; set; } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/OscarTest.csproj b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/OscarTest.csproj new file mode 100644 index 000000000..60f929097 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/OscarTest.csproj @@ -0,0 +1,12 @@ + + + + Exe + netcoreapp3.1 + + + + + + + diff --git a/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Program.cs b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Program.cs new file mode 100644 index 000000000..f3aa08ac7 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/OscarTest/Program.cs @@ -0,0 +1,40 @@ +using System; + +namespace OrmTest +{ + class Program + { + static void Main(string[] args) + { + //Demo + Demo0_SqlSugarClient.Init(); + Demo1_Queryable.Init(); + Demo2_Updateable.Init(); + Demo3_Insertable.Init(); + Demo4_Deleteable.Init(); + Demo5_SqlQueryable.Init(); + Demo6_Queue.Init(); + Demo7_Ado.Init(); + Demo8_Saveable.Init(); + Demo9_EntityMain.Init(); + DemoA_DbMain.Init(); + DemoB_Aop.Init(); + DemoC_GobalFilter.Init(); + DemoD_DbFirst.Init(); ; + DemoE_CodeFirst.Init(); + DemoF_Utilities.Init(); + DemoG_SimpleClient.Init(); + + //Unit test + //NewUnitTest.Init(); + + //Rest Data + //NewUnitTest.RestData(); + + Console.WriteLine("all successfully."); + Console.ReadKey(); + } + + + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln index 092dc515a..cd6ea7aac 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSeverTest.sln @@ -21,7 +21,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DmOrmTest", "DmOrmTest\DmOr EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "KdbndpTest", "KdbndpTest\KdbndpTest.csproj", "{21744B61-74AB-4706-9A52-C9D0C4AAD19E}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CacheTest", "CacheTest\CacheTest.csproj", "{2EC6C9BD-6B8F-4EC3-B4ED-EAEFD8BB735C}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CacheTest", "CacheTest\CacheTest.csproj", "{2EC6C9BD-6B8F-4EC3-B4ED-EAEFD8BB735C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OscarTest", "OscarTest\OscarTest.csproj", "{29925F8E-6495-463A-ABBD-C050AE85E130}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -69,6 +71,10 @@ Global {2EC6C9BD-6B8F-4EC3-B4ED-EAEFD8BB735C}.Debug|Any CPU.Build.0 = Debug|Any CPU {2EC6C9BD-6B8F-4EC3-B4ED-EAEFD8BB735C}.Release|Any CPU.ActiveCfg = Release|Any CPU {2EC6C9BD-6B8F-4EC3-B4ED-EAEFD8BB735C}.Release|Any CPU.Build.0 = Release|Any CPU + {29925F8E-6495-463A-ABBD-C050AE85E130}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {29925F8E-6495-463A-ABBD-C050AE85E130}.Debug|Any CPU.Build.0 = Debug|Any CPU + {29925F8E-6495-463A-ABBD-C050AE85E130}.Release|Any CPU.ActiveCfg = Release|Any CPU + {29925F8E-6495-463A-ABBD-C050AE85E130}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/DbType.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/DbType.cs index 7765f14c0..80b3414e1 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/DbType.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/DbType.cs @@ -13,6 +13,7 @@ namespace SqlSugar Oracle, PostgreSQL, Dm, - Kdbndp + Kdbndp, + Oscar } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs index 78a5255a9..65a9932f9 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/OnlyCore/DataExtensions.cs @@ -11,6 +11,8 @@ using System.Data; using Microsoft.Data.SqlClient; using System.Linq; using System.Threading.Tasks; +using System.Data.OscarClient; + namespace SqlSugar { @@ -896,4 +898,131 @@ namespace SqlSugar } } } + + + /// + /// 数据填充器 + /// + public class OscarDataAdapter : IDataAdapter + { + private OscarCommand command; + private string sql; + private OscarConnection _sqlConnection; + + /// + /// SqlDataAdapter + /// + /// + public OscarDataAdapter(OscarCommand command) + { + this.command = command; + } + + public OscarDataAdapter() + { + + } + + /// + /// SqlDataAdapter + /// + /// + /// + public OscarDataAdapter(string sql, OscarConnection _sqlConnection) + { + this.sql = sql; + this._sqlConnection = _sqlConnection; + } + + /// + /// SelectCommand + /// + public OscarCommand SelectCommand + { + get + { + if (this.command == null) + { + this.command = new OscarCommand(this.sql, this._sqlConnection); + } + return this.command; + } + set + { + this.command = value; + } + } + + /// + /// Fill + /// + /// + public void Fill(DataTable dt) + { + if (dt == null) + { + dt = new DataTable(); + } + var columns = dt.Columns; + var rows = dt.Rows; + using (OscarDataReader dr = command.ExecuteReader()) + { + for (int i = 0; i < dr.FieldCount; i++) + { + string name = dr.GetName(i).Trim(); + if (!columns.Contains(name)) + columns.Add(new DataColumn(name, dr.GetFieldType(i))); + } + + while (dr.Read()) + { + DataRow daRow = dt.NewRow(); + for (int i = 0; i < columns.Count; i++) + { + daRow[columns[i].ColumnName] = dr.GetValue(i); + } + dt.Rows.Add(daRow); + } + } + + } + + /// + /// Fill + /// + /// + public void Fill(DataSet ds) + { + if (ds == null) + { + ds = new DataSet(); + } + using (OscarDataReader dr = command.ExecuteReader()) + { + do + { + var dt = new DataTable(); + var columns = dt.Columns; + var rows = dt.Rows; + for (int i = 0; i < dr.FieldCount; i++) + { + string name = dr.GetName(i).Trim(); + if (!columns.Contains(name)) + columns.Add(new DataColumn(name, dr.GetFieldType(i))); + } + + while (dr.Read()) + { + DataRow daRow = dt.NewRow(); + for (int i = 0; i < columns.Count; i++) + { + daRow[columns[i].ColumnName] = dr.GetValue(i); + } + dt.Rows.Add(daRow); + } + ds.Tables.Add(dt); + } while (dr.NextResult()); + } + } + } } \ No newline at end of file diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/CodeFirst/OscarCodeFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/CodeFirst/OscarCodeFirst.cs new file mode 100644 index 000000000..32ac5d448 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/CodeFirst/OscarCodeFirst.cs @@ -0,0 +1,74 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class OscarCodeFirst : CodeFirstProvider + { + public override void NoExistLogic(EntityInfo entityInfo) + { + var tableName = GetTableName(entityInfo); + //Check.Exception(entityInfo.Columns.Where(it => it.IsPrimarykey).Count() > 1, "Use Code First ,The primary key must not exceed 1"); + List columns = new List(); + if (entityInfo.Columns.HasValue()) + { + foreach (var item in entityInfo.Columns.Where(it=>it.IsIgnore==false)) + { + DbColumnInfo dbColumnInfo = this.EntityColumnToDbColumn(entityInfo, tableName, item); + columns.Add(dbColumnInfo); + } + } + this.Context.DbMaintenance.CreateTable(tableName, columns,true); + } + protected override DbColumnInfo EntityColumnToDbColumn(EntityInfo entityInfo, string tableName, EntityColumnInfo item) + { + var propertyType = UtilMethods.GetUnderType(item.PropertyInfo); + var result = new DbColumnInfo() + { + TableId = entityInfo.Columns.IndexOf(item), + DbColumnName = item.DbColumnName.HasValue() ? item.DbColumnName : item.PropertyName, + IsPrimarykey = item.IsPrimarykey, + IsIdentity = item.IsIdentity, + TableName = tableName, + IsNullable = item.IsNullable, + DefaultValue = item.DefaultValue, + ColumnDescription = item.ColumnDescription, + Length = item.Length + }; + if (propertyType == UtilConstants.DecType) + { + result.Scale = item.DecimalDigits; + result.DecimalDigits = item.DecimalDigits; + } + GetDbType(item, propertyType, result); + if (result.DataType.Equals("varchar", StringComparison.CurrentCultureIgnoreCase) && result.Length == 0) + { + result.Length = 1; + } + return result; + } + + protected override void ConvertColumns(List dbColumns) + { + foreach (var item in dbColumns) + { + if (item.DataType == "DateTime") + { + item.Length = 0; + } + } + } + + protected override void ChangeKey(EntityInfo entityInfo, string tableName, EntityColumnInfo item) + { + this.Context.DbMaintenance.UpdateColumn(tableName, EntityColumnToDbColumn(entityInfo, tableName, item)); + if (!item.IsPrimarykey) + this.Context.DbMaintenance.DropConstraint(tableName,null); + if (item.IsPrimarykey) + this.Context.DbMaintenance.AddPrimaryKey(tableName, item.DbColumnName); + } + + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbBind/OscarDbBind.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbBind/OscarDbBind.cs new file mode 100644 index 000000000..802a5ad5f --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbBind/OscarDbBind.cs @@ -0,0 +1,128 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +namespace SqlSugar +{ + public class OscarDbBind : DbBindProvider + { + public override string GetPropertyTypeName(string dbTypeName) + { + dbTypeName = dbTypeName.ToLower(); + var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName || it.Key.ToLower() == dbTypeName); + if (propertyTypes == null) + { + return "other"; + } + else if (dbTypeName == "xml" || dbTypeName == "string"|| dbTypeName == "jsonb"|| dbTypeName == "json") + { + return "string"; + }else if (dbTypeName == "bpchar")//数据库char datatype 查询出来的时候是 bpchar + { + return "char"; + } + if (dbTypeName == "byte[]") + { + return "byte[]"; + } + else if (propertyTypes == null || propertyTypes.Count() == 0) + { + if (dbTypeName.StartsWith("_")) + { + var dbTypeName2 = dbTypeName.TrimStart('_'); + return MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName2 || it.Key.ToLower() == dbTypeName2).Select(it => it.Value + "[]").First(); + } + Check.ThrowNotSupportedException(string.Format(" \"{0}\" Type NotSupported, DbBindProvider.GetPropertyTypeName error.", dbTypeName)); + return null; + } + else if (propertyTypes.First().Value == CSharpDataType.byteArray) + { + return "byte[]"; + } + else + { + return propertyTypes.First().Value.ToString(); + } + } + public override List> MappingTypes + { + get + { + var extService = this.Context.CurrentConnectionConfig.ConfigureExternalServices; + if (extService != null && extService.AppendDataReaderTypeMappings.HasValue()) + { + return extService.AppendDataReaderTypeMappings.Union(MappingTypesConst).ToList(); + } + else + { + return MappingTypesConst; + } + } + } + public static List> MappingTypesConst = new List>(){ + + new KeyValuePair("int2",CSharpDataType.@short), + new KeyValuePair("smallint",CSharpDataType.@short), + new KeyValuePair("int4",CSharpDataType.@int), + new KeyValuePair("integer",CSharpDataType.@int), + new KeyValuePair("int8",CSharpDataType.@long), + new KeyValuePair("bigint",CSharpDataType.@long), + new KeyValuePair("float4",CSharpDataType.@float), + new KeyValuePair("real",CSharpDataType.@float), + new KeyValuePair("float8",CSharpDataType.@double), + new KeyValuePair("double precision",CSharpDataType.@int), + new KeyValuePair("numeric",CSharpDataType.@decimal), + new KeyValuePair("decimal",CSharpDataType.@decimal), + new KeyValuePair("path",CSharpDataType.@decimal), + new KeyValuePair("point",CSharpDataType.@decimal), + new KeyValuePair("polygon",CSharpDataType.@decimal), + + new KeyValuePair("boolean",CSharpDataType.@bool), + new KeyValuePair("bool",CSharpDataType.@bool), + new KeyValuePair("box",CSharpDataType.@bool), + new KeyValuePair("bytea",CSharpDataType.@bool), + + new KeyValuePair("varchar",CSharpDataType.@string), + new KeyValuePair("character varying",CSharpDataType.@string), + new KeyValuePair("geometry",CSharpDataType.@string), + new KeyValuePair("name",CSharpDataType.@string), + new KeyValuePair("text",CSharpDataType.@string), + new KeyValuePair("char",CSharpDataType.@string), + new KeyValuePair("character",CSharpDataType.@string), + new KeyValuePair("cidr",CSharpDataType.@string), + new KeyValuePair("circle",CSharpDataType.@string), + new KeyValuePair("tsquery",CSharpDataType.@string), + new KeyValuePair("tsvector",CSharpDataType.@string), + new KeyValuePair("txid_snapshot",CSharpDataType.@string), + new KeyValuePair("uuid",CSharpDataType.Guid), + new KeyValuePair("xml",CSharpDataType.@string), + new KeyValuePair("json",CSharpDataType.@string), + + new KeyValuePair("interval",CSharpDataType.@decimal), + new KeyValuePair("lseg",CSharpDataType.@decimal), + new KeyValuePair("macaddr",CSharpDataType.@decimal), + new KeyValuePair("money",CSharpDataType.@decimal), + new KeyValuePair("timestamp",CSharpDataType.DateTime), + new KeyValuePair("timestamp with time zone",CSharpDataType.DateTime), + new KeyValuePair("timestamptz",CSharpDataType.DateTime), + new KeyValuePair("timestamp without time zone",CSharpDataType.DateTime), + new KeyValuePair("date",CSharpDataType.DateTime), + new KeyValuePair("time",CSharpDataType.DateTime), + new KeyValuePair("time with time zone",CSharpDataType.DateTime), + new KeyValuePair("timetz",CSharpDataType.DateTime), + new KeyValuePair("time without time zone",CSharpDataType.DateTime), + + new KeyValuePair("bit",CSharpDataType.byteArray), + new KeyValuePair("bit varying",CSharpDataType.byteArray), + new KeyValuePair("varbit",CSharpDataType.@byte), + new KeyValuePair("time",CSharpDataType.TimeSpan), + }; + public override List StringThrow + { + get + { + return new List() { "int32", "datetime", "decimal", "double", "byte" }; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbFirst/OscarDbFirst.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbFirst/OscarDbFirst.cs new file mode 100644 index 000000000..c282ed1b0 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbFirst/OscarDbFirst.cs @@ -0,0 +1,11 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class OscarDbFirst : DbFirstProvider + { + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbMaintenance/OscarDbMaintenance.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbMaintenance/OscarDbMaintenance.cs new file mode 100644 index 000000000..41ec4aa30 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/DbMaintenance/OscarDbMaintenance.cs @@ -0,0 +1,402 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class OscarDbMaintenance : DbMaintenanceProvider + { + #region DML + protected override string GetDataBaseSql + { + get + { + return "SELECT datname FROM pg_database"; + } + } + protected override string GetColumnInfosByTableNameSql + { + get + { + string sql = @"select cast (pclass.oid as int4) as TableId,cast(ptables.tablename as varchar) as TableName, + pcolumn.column_name as DbColumnName,pcolumn.udt_name as DataType, + CASE WHEN pcolumn.numeric_scale >0 THEN pcolumn.numeric_precision ELSE pcolumn.character_maximum_length END as Length, + pcolumn.column_default as DefaultValue, + pcolumn.numeric_scale as DecimalDigits, + pcolumn.numeric_scale as Scale, + col_description(pclass.oid, pcolumn.ordinal_position) as ColumnDescription, + case when pkey.colname = pcolumn.column_name + then true else false end as IsPrimaryKey, + case when pcolumn.column_default like 'nextval%' + then true else false end as IsIdentity, + case when pcolumn.is_nullable = 'YES' + then true else false end as IsNullable + from (select * from pg_tables where tablename = '{0}' and schemaname='public') ptables inner join pg_class pclass + on ptables.tablename = pclass.relname inner join (SELECT * + FROM information_schema.columns + ) pcolumn on pcolumn.table_name = ptables.tablename + left join ( + select pg_class.relname,pg_attribute.attname as colname from + pg_constraint inner join pg_class + on pg_constraint.conrelid = pg_class.oid + inner join pg_attribute on pg_attribute.attrelid = pg_class.oid + and pg_attribute.attnum = pg_constraint.conkey[1] + inner join pg_type on pg_type.oid = pg_attribute.atttypid + where pg_constraint.contype='p' + ) pkey on pcolumn.table_name = pkey.relname + order by ptables.tablename"; + return sql; + } + } + protected override string GetTableInfoListSql + { + get + { + return @"select cast(relname as varchar) as Name, + cast(obj_description(relfilenode,'pg_class') as varchar) as Description from pg_class c + where relkind = 'r' and relname not like 'pg_%' and relname not like 'sql_%' order by relname"; + } + } + protected override string GetViewInfoListSql + { + get + { + return @"select cast(relname as varchar) as Name,cast(Description as varchar) from pg_description + join pg_class on pg_description.objoid = pg_class.oid + where objsubid = 0 and relname in (SELECT viewname from pg_views + WHERE schemaname ='public')"; + } + } + #endregion + + #region DDL + protected override string CreateDataBaseSql + { + get + { + return "CREATE DATABASE {0}"; + } + } + protected override string AddPrimaryKeySql + { + get + { + return "ALTER TABLE {0} ADD PRIMARY KEY({2}) /*{1}*/"; + } + } + protected override string AddColumnToTableSql + { + get + { + return "ALTER TABLE {0} ADD COLUMN {1} {2}{3} {4} {5} {6}"; + } + } + protected override string AlterColumnToTableSql + { + get + { + return "alter table {0} ALTER COLUMN {1} {2}{3} {4} {5} {6}"; + } + } + protected override string BackupDataBaseSql + { + get + { + return "mysqldump.exe {0} -uroot -p > {1} "; + } + } + protected override string CreateTableSql + { + get + { + return "CREATE TABLE {0}(\r\n{1} $PrimaryKey)"; + } + } + protected override string CreateTableColumn + { + get + { + return "{0} {1}{2} {3} {4} {5}"; + } + } + protected override string TruncateTableSql + { + get + { + return "TRUNCATE TABLE {0}"; + } + } + protected override string BackupTableSql + { + get + { + return "create table {0} as (select * from {1} limit {2} offset 0)"; + } + } + protected override string DropTableSql + { + get + { + return "DROP TABLE {0}"; + } + } + protected override string DropColumnToTableSql + { + get + { + return "ALTER TABLE {0} DROP COLUMN {1}"; + } + } + protected override string DropConstraintSql + { + get + { + return "ALTER TABLE {0} DROP CONSTRAINT {1}"; + } + } + protected override string RenameColumnSql + { + get + { + return "ALTER TABLE {0} RENAME {1} TO {2}"; + } + } + protected override string AddColumnRemarkSql => "comment on column {1}.{0} is '{2}'"; + + protected override string DeleteColumnRemarkSql => "comment on column {1}.{0} is ''"; + + protected override string IsAnyColumnRemarkSql { get { throw new NotSupportedException(); } } + + protected override string AddTableRemarkSql => "comment on table {0} is '{1}'"; + + protected override string DeleteTableRemarkSql => "comment on table {0} is ''"; + + protected override string IsAnyTableRemarkSql { get { throw new NotSupportedException(); } } + + protected override string RenameTableSql => "alter table 表名 {0} to {1}"; + + protected override string CreateIndexSql + { + get + { + return "CREATE {3} INDEX Index_{0}_{2} ON {0} ({1})"; + } + } + protected override string AddDefaultValueSql + { + get + { + return "ALTER TABLE {0} ALTER COLUMN {1} SET DEFAULT {2}"; + } + } + protected override string IsAnyIndexSql + { + get + { + return " Select count(1) from (SELECT to_regclass('{0}') as c ) t where t.c is not null"; + } + } + + #endregion + + #region Check + protected override string CheckSystemTablePermissionsSql + { + get + { + return "select 1 from information_schema.columns limit 1 offset 0"; + } + } + #endregion + + #region Scattered + protected override string CreateTableNull + { + get + { + return "DEFAULT NULL"; + } + } + protected override string CreateTableNotNull + { + get + { + return "NOT NULL"; + } + } + protected override string CreateTablePirmaryKey + { + get + { + return "PRIMARY KEY"; + } + } + protected override string CreateTableIdentity + { + get + { + return "serial"; + } + } + #endregion + + #region Methods + public override bool UpdateColumn(string tableName, DbColumnInfo columnInfo) + { + tableName = this.SqlBuilder.GetTranslationTableName(tableName); + var columnName= this.SqlBuilder.GetTranslationColumnName(columnInfo.DbColumnName); + string sql = GetUpdateColumnSql(tableName, columnInfo); + this.Context.Ado.ExecuteCommand(sql); + var isnull = columnInfo.IsNullable?" DROP NOT NULL ": " SET NOT NULL "; + this.Context.Ado.ExecuteCommand(string.Format("alter table {0} alter {1} {2}",tableName,columnName, isnull)); + return true; + } + + protected override string GetUpdateColumnSql(string tableName, DbColumnInfo columnInfo) + { + string columnName = this.SqlBuilder.GetTranslationColumnName(columnInfo.DbColumnName); + tableName = this.SqlBuilder.GetTranslationTableName(tableName); + string dataSize = GetSize(columnInfo); + string dataType = columnInfo.DataType; + if (!string.IsNullOrEmpty(dataType)) + { + dataType = " type " + dataType; + } + string nullType = ""; + string primaryKey = null; + string identity = null; + string result = string.Format(this.AlterColumnToTableSql, tableName, columnName, dataType, dataSize, nullType, primaryKey, identity); + return result; + } + + /// + ///by current connection string + /// + /// + /// + public override bool CreateDatabase(string databaseName, string databaseDirectory = null) + { + if (databaseDirectory != null) + { + if (!FileHelper.IsExistDirectory(databaseDirectory)) + { + FileHelper.CreateDirectory(databaseDirectory); + } + } + var oldDatabaseName = this.Context.Ado.Connection.Database; + var connection = this.Context.CurrentConnectionConfig.ConnectionString; + connection = connection.Replace(oldDatabaseName, "postgres"); + var newDb = new SqlSugarClient(new ConnectionConfig() + { + DbType = this.Context.CurrentConnectionConfig.DbType, + IsAutoCloseConnection = true, + ConnectionString = connection + }); + if (!GetDataBaseList(newDb).Any(it => it.Equals(databaseName, StringComparison.CurrentCultureIgnoreCase))) + { + newDb.Ado.ExecuteCommand(string.Format(CreateDataBaseSql, this.SqlBuilder.SqlTranslationLeft+databaseName+this.SqlBuilder.SqlTranslationRight, databaseDirectory)); + } + return true; + } + public override bool AddRemark(EntityInfo entity) + { + var db = this.Context; + var columns = entity.Columns.Where(it => it.IsIgnore == false).ToList(); + + foreach (var item in columns) + { + if (item.ColumnDescription != null) + { + db.DbMaintenance.AddColumnRemark(item.DbColumnName, item.DbTableName, item.ColumnDescription); + + } + } + //table remak + if (entity.TableDescription != null) + { + db.DbMaintenance.AddTableRemark(entity.DbTableName, entity.TableDescription); + } + return true; + } + public override bool CreateTable(string tableName, List columns, bool isCreatePrimaryKey = true) + { + if (columns.HasValue()) + { + foreach (var item in columns) + { + if (item.DbColumnName.Equals("GUID", StringComparison.CurrentCultureIgnoreCase) && item.Length == 0) + { + item.Length = 10; + } + } + } + string sql = GetCreateTableSql(tableName, columns); + string primaryKeyInfo = null; + if (columns.Any(it => it.IsPrimarykey) && isCreatePrimaryKey) + { + primaryKeyInfo = string.Format(", Primary key({0})", string.Join(",", columns.Where(it => it.IsPrimarykey).Select(it => this.SqlBuilder.GetTranslationColumnName(it.DbColumnName.ToLower())))); + + } + sql = sql.Replace("$PrimaryKey", primaryKeyInfo); + this.Context.Ado.ExecuteCommand(sql); + return true; + } + protected override string GetCreateTableSql(string tableName, List columns) + { + List columnArray = new List(); + Check.Exception(columns.IsNullOrEmpty(), "No columns found "); + foreach (var item in columns) + { + string columnName = item.DbColumnName; + string dataType = item.DataType; + if (dataType == "varchar" && item.Length == 0) + { + item.Length = 1; + } + if (dataType == "uuid") + { + item.Length = 50; + dataType = "varchar"; + } + string dataSize = item.Length > 0 ? string.Format("({0})", item.Length) : null; + if (item.DecimalDigits > 0&&item.Length>0 && dataType == "numeric") + { + dataSize = $"({item.Length},{item.DecimalDigits})"; + } + string nullType = item.IsNullable ? this.CreateTableNull : CreateTableNotNull; + string primaryKey = null; + string addItem = string.Format(this.CreateTableColumn, this.SqlBuilder.GetTranslationColumnName(columnName.ToLower()), dataType, dataSize, nullType, primaryKey, ""); + if (item.IsIdentity) + { + string length = dataType.Substring(dataType.Length - 1); + string identityDataType = "serial" + length; + addItem = addItem.Replace(dataType, identityDataType); + } + columnArray.Add(addItem); + } + string tableString = string.Format(this.CreateTableSql, this.SqlBuilder.GetTranslationTableName(tableName.ToLower()), string.Join(",\r\n", columnArray)); + return tableString; + } + public override bool IsAnyConstraint(string constraintName) + { + throw new NotSupportedException("PgSql IsAnyConstraint NotSupportedException"); + } + public override bool BackupDataBase(string databaseName, string fullFileName) + { + Check.ThrowNotSupportedException("PgSql BackupDataBase NotSupported"); + return false; + } + + public override List GetColumnInfosByTableName(string tableName, bool isCache = true) + { + var result= base.GetColumnInfosByTableName(tableName.TrimEnd('"').TrimStart('"').ToLower(), isCache); + if (result == null || result.Count() == 0) + { + result = base.GetColumnInfosByTableName(tableName, isCache); + } + return result; + } + #endregion + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Insertable/OscarInserttable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Insertable/OscarInserttable.cs new file mode 100644 index 000000000..f2369df96 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Insertable/OscarInserttable.cs @@ -0,0 +1,74 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class OscarInserttable : InsertableProvider where T : class, new() + { + public override int ExecuteReturnIdentity() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey",this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); + RestoreMapping(); + var result = Ado.GetScalar(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()).ObjToInt(); + return result; + } + public override async Task ExecuteReturnIdentityAsync() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); + RestoreMapping(); + var obj = await Ado.GetScalarAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()); + var result = obj.ObjToInt(); + return result; + } + public override KeyValuePair> ToSql() + { + var result= base.ToSql(); + return new KeyValuePair>(result.Key.Replace("$PrimaryKey", GetPrimaryKeys().FirstOrDefault()), result.Value); + } + + public override long ExecuteReturnBigIdentity() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); + RestoreMapping(); + var result = Convert.ToInt64(Ado.GetScalar(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()) ?? "0"); + return result; + } + public override async Task ExecuteReturnBigIdentityAsync() + { + InsertBuilder.IsReturnIdentity = true; + PreToSql(); + string sql = InsertBuilder.ToSqlString().Replace("$PrimaryKey", this.SqlBuilder.GetTranslationColumnName(GetIdentityKeys().FirstOrDefault())); + RestoreMapping(); + var result = Convert.ToInt64(await Ado.GetScalarAsync(sql, InsertBuilder.Parameters == null ? null : InsertBuilder.Parameters.ToArray()) ?? "0"); + return result; + } + + public override bool ExecuteCommandIdentityIntoEntity() + { + var result = InsertObjs.First(); + var identityKeys = GetIdentityKeys(); + if (identityKeys.Count == 0) { return this.ExecuteCommand() > 0; } + var idValue = ExecuteReturnBigIdentity(); + Check.Exception(identityKeys.Count > 1, "ExecuteCommandIdentityIntoEntity does not support multiple identity keys"); + var identityKey = identityKeys.First(); + object setValue = 0; + if (idValue > int.MaxValue) + setValue = idValue; + else + setValue = Convert.ToInt32(idValue); + var propertyName = this.Context.EntityMaintenance.GetPropertyName(identityKey); + typeof(T).GetProperties().First(t => t.Name.ToUpper() == propertyName.ToUpper()).SetValue(result, setValue, null); + return idValue > 0; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/OscarProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/OscarProvider.cs new file mode 100644 index 000000000..7f8ce2ca5 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/OscarProvider.cs @@ -0,0 +1,163 @@ +using System; +using System.Collections.Generic; +using System.Data; +using System.Data.Common; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Data.OscarClient; + +namespace SqlSugar +{ + public partial class OscarProvider : AdoProvider + { + public OscarProvider() { } + public override IDbConnection Connection + { + get + { + if (base._DbConnection == null) + { + try + { + var OscarConnectionString = base.Context.CurrentConnectionConfig.ConnectionString; + base._DbConnection = new OscarConnection(OscarConnectionString); + } + catch (Exception ex) + { + Check.Exception(true, ErrorMessage.ConnnectionOpen, ex.Message); + } + } + return base._DbConnection; + } + set + { + base._DbConnection = value; + } + } + + public override void BeginTran(string transactionName) + { + base.BeginTran(); + } + /// + /// Only SqlServer + /// + /// + /// + public override void BeginTran(IsolationLevel iso, string transactionName) + { + base.BeginTran(iso); + } + public override IDataAdapter GetAdapter() + { + return new OscarDataAdapter(); + } + public override DbCommand GetCommand(string sql, SugarParameter[] parameters) + { + OscarCommand sqlCommand = new OscarCommand(sql, (OscarConnection)this.Connection); + sqlCommand.CommandType = this.CommandType; + sqlCommand.CommandTimeout = this.CommandTimeOut; + if (this.Transaction != null) + { + sqlCommand.Transaction = (OscarTransaction)this.Transaction; + } + if (parameters.HasValue()) + { + IDataParameter[] ipars = ToIDbDataParameter(parameters); + sqlCommand.Parameters.AddRange((OscarParameter[])ipars); + } + CheckConnection(); + return sqlCommand; + } + public override void SetCommandToAdapter(IDataAdapter dataAdapter, DbCommand command) + { + ((OscarDataAdapter)dataAdapter).SelectCommand = (OscarCommand)command; + } + /// + /// if mysql return MySqlParameter[] pars + /// if sqlerver return SqlParameter[] pars ... + /// + /// + /// + public override IDataParameter[] ToIDbDataParameter(params SugarParameter[] parameters) + { + if (parameters == null || parameters.Length == 0) return null; + OscarParameter[] result = new OscarParameter[parameters.Length]; + int index = 0; + var isVarchar = this.Context.IsVarchar(); + foreach (var parameter in parameters) + { + if (parameter.Value == null) parameter.Value = DBNull.Value; + var sqlParameter = new OscarParameter(); + sqlParameter.ParameterName = parameter.ParameterName; + sqlParameter.Size = parameter.Size; + sqlParameter.Value = parameter.Value; + sqlParameter.DbType = parameter.DbType; + sqlParameter.Direction = parameter.Direction; + if (parameter.IsJson) + { + sqlParameter.OscarDbType = OscarDbType.Text; + } + if (parameter.IsArray) + { + // sqlParameter.Value = this.Context.Utilities.SerializeObject(sqlParameter.Value); + var type = sqlParameter.Value.GetType(); + if (ArrayMapping.ContainsKey(type)) + { + sqlParameter.OscarDbType = ArrayMapping[type] | OscarDbType.Array; + } + else + { + Check.Exception(true, sqlParameter.Value.GetType().Name + " No Support"); + } + } + if (sqlParameter.Direction == 0) + { + sqlParameter.Direction = ParameterDirection.Input; + } + result[index] = sqlParameter; + if (sqlParameter.Direction.IsIn(ParameterDirection.Output, ParameterDirection.InputOutput, ParameterDirection.ReturnValue)) + { + if (this.OutputParameters == null) this.OutputParameters = new List(); + this.OutputParameters.RemoveAll(it => it.ParameterName == sqlParameter.ParameterName); + this.OutputParameters.Add(sqlParameter); + } + if (isVarchar && sqlParameter.DbType == System.Data.DbType.String) + { + sqlParameter.DbType = System.Data.DbType.AnsiString; + } + ++index; + } + return result; + } + + + static readonly Dictionary ArrayMapping = new Dictionary() + { + { typeof(int[]),OscarDbType.Integer}, + { typeof(short[]),OscarDbType.SmallInt}, + { typeof(long[]),OscarDbType.BigInt}, + { typeof(decimal[]),OscarDbType.Numeric}, + { typeof(char[]),OscarDbType.Text}, + { typeof(byte[]),OscarDbType.Bytea}, + { typeof(bool[]),OscarDbType.Boolean}, + {typeof(DateTime[]),OscarDbType.Date}, + {typeof(float[]),OscarDbType.Real}, + + + { typeof(int?[]),OscarDbType.Integer}, + { typeof(short?[]),OscarDbType.SmallInt}, + { typeof(long?[]),OscarDbType.BigInt}, + { typeof(decimal?[]),OscarDbType.Numeric}, + { typeof(char?[]),OscarDbType.Text}, + { typeof(byte?[]),OscarDbType.Bytea}, + { typeof(bool?[]),OscarDbType.Boolean}, + {typeof(DateTime?[]),OscarDbType.Date}, + + + { typeof(string[]), OscarDbType.Text}, + {typeof(float?[]),OscarDbType.Real}, + }; + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Queryable/OscarQueryable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Queryable/OscarQueryable.cs new file mode 100644 index 000000000..de7d72039 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/Queryable/OscarQueryable.cs @@ -0,0 +1,69 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace SqlSugar +{ + public class OscarQueryable : QueryableProvider + { + public override ISugarQueryable With(string withString) + { + return this; + } + + public override ISugarQueryable PartitionBy(string groupFileds) + { + this.GroupBy(groupFileds); + return this; + } + } + public class OscarQueryable : QueryableProvider + { + public new ISugarQueryable With(string withString) + { + return this; + } + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } + public class OscarQueryable : QueryableProvider + { + + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarBuilder.cs new file mode 100644 index 000000000..bcdbd9627 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarBuilder.cs @@ -0,0 +1,97 @@ +using System; +using System.Linq; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public class OscarBuilder : SqlBuilderProvider + { + public override string SqlTranslationLeft + { + get + { + return "\""; + } + } + public override string SqlTranslationRight + { + get + { + return "\""; + } + } + public override string SqlDateNow + { + get + { + return "current_date"; + } + } + public override string FullSqlDateNow + { + get + { + return "select current_date"; + } + } + + public bool isAutoToLower + { + get + { + if (this.Context.CurrentConnectionConfig.MoreSettings == null) return true; + return this.Context.CurrentConnectionConfig.MoreSettings.PgSqlIsAutoToLower; + } + } + public override string GetTranslationColumnName(string propertyName) + { + if (propertyName.Contains(SqlTranslationLeft)) return propertyName; + else + return SqlTranslationLeft + propertyName.ToLower(isAutoToLower) + SqlTranslationRight; + } + + //public override string GetNoTranslationColumnName(string name) + //{ + // return name.TrimEnd(Convert.ToChar(SqlTranslationRight)).TrimStart(Convert.ToChar(SqlTranslationLeft)).ToLower(); + //} + public override string GetTranslationColumnName(string entityName, string propertyName) + { + Check.ArgumentNullException(entityName, string.Format(ErrorMessage.ObjNotExist, "Table Name")); + Check.ArgumentNullException(propertyName, string.Format(ErrorMessage.ObjNotExist, "Column Name")); + var context = this.Context; + var mappingInfo = context + .MappingColumns + .FirstOrDefault(it => + it.EntityName.Equals(entityName, StringComparison.CurrentCultureIgnoreCase) && + it.PropertyName.Equals(propertyName, StringComparison.CurrentCultureIgnoreCase)); + return (mappingInfo == null ? SqlTranslationLeft + propertyName.ToLower(isAutoToLower) + SqlTranslationRight : SqlTranslationLeft + mappingInfo.DbColumnName.ToLower(isAutoToLower) + SqlTranslationRight); + } + + public override string GetTranslationTableName(string name) + { + Check.ArgumentNullException(name, string.Format(ErrorMessage.ObjNotExist, "Table Name")); + var context = this.Context; + + var mappingInfo = context + .MappingTables + .FirstOrDefault(it => it.EntityName.Equals(name, StringComparison.CurrentCultureIgnoreCase)); + name = (mappingInfo == null ? name : mappingInfo.DbTableName); + if (name.Contains(".")&& !name.Contains("(")) + { + return string.Join(".", name.ToLower(isAutoToLower).Split('.').Select(it => SqlTranslationLeft + it + SqlTranslationRight)); + } + else if (name.Contains("(")) + { + return name; + } + else if (name.Contains(SqlTranslationLeft) && name.Contains(SqlTranslationRight)) + { + return name; + } + else + { + return SqlTranslationLeft + name.ToLower(isAutoToLower).TrimEnd('"').TrimStart('"') + SqlTranslationRight; + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarDeleteBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarDeleteBuilder.cs new file mode 100644 index 000000000..2b3f59941 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarDeleteBuilder.cs @@ -0,0 +1,7 @@ +namespace SqlSugar +{ + public class OscarDeleteBuilder : DeleteBuilder + { + + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarExpressionContext.cs new file mode 100644 index 000000000..c8e6b63cb --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarExpressionContext.cs @@ -0,0 +1,283 @@ +using System; +using System.Linq; +namespace SqlSugar +{ + public class OscarExpressionContext : ExpressionContext, ILambdaExpressions + { + public SqlSugarProvider Context { get; set; } + public OscarExpressionContext() + { + base.DbMehtods = new OscarLMethod(); + } + public override string SqlTranslationLeft + { + get + { + return "\""; + } + } + public override string SqlTranslationRight + { + get + { + return "\""; + } + } + public override string GetTranslationText(string name) + { + return SqlTranslationLeft + name.ToLower(isAutoToLower) + SqlTranslationRight; + } + public bool isAutoToLower + { + get + { + return base.PgSqlIsAutoToLower; + } + } + public override string GetTranslationTableName(string entityName, bool isMapping = true) + { + Check.ArgumentNullException(entityName, string.Format(ErrorMessage.ObjNotExist, "Table Name")); + if (IsTranslationText(entityName)) return entityName; + isMapping = isMapping && this.MappingTables.HasValue(); + var isComplex = entityName.Contains(UtilConstants.Dot); + if (isMapping && isComplex) + { + var columnInfo = entityName.Split(UtilConstants.DotChar); + var mappingInfo = this.MappingTables.FirstOrDefault(it => it.EntityName.Equals(columnInfo.Last(), StringComparison.CurrentCultureIgnoreCase)); + if (mappingInfo != null) + { + columnInfo[columnInfo.Length - 1] = mappingInfo.EntityName; + } + return string.Join(UtilConstants.Dot, columnInfo.Select(it => GetTranslationText(it))); + } + else if (isMapping) + { + var mappingInfo = this.MappingTables.FirstOrDefault(it => it.EntityName.Equals(entityName, StringComparison.CurrentCultureIgnoreCase)); + + var tableName = mappingInfo?.DbTableName+""; + if (tableName.Contains(".")) + { + tableName = string.Join(UtilConstants.Dot, tableName.Split(UtilConstants.DotChar).Select(it => GetTranslationText(it))); + return tableName; + } + + return SqlTranslationLeft + (mappingInfo == null ? entityName : mappingInfo.DbTableName).ToLower(isAutoToLower) + SqlTranslationRight; + } + else if (isComplex) + { + return string.Join(UtilConstants.Dot, entityName.Split(UtilConstants.DotChar).Select(it => GetTranslationText(it))); + } + else + { + return GetTranslationText(entityName); + } + } + public override string GetTranslationColumnName(string columnName) + { + Check.ArgumentNullException(columnName, string.Format(ErrorMessage.ObjNotExist, "Column Name")); + if (columnName.Substring(0, 1) == this.SqlParameterKeyWord) + { + return columnName; + } + if (IsTranslationText(columnName)) return columnName; + if (columnName.Contains(UtilConstants.Dot)) + { + return string.Join(UtilConstants.Dot, columnName.Split(UtilConstants.DotChar).Select(it => GetTranslationText(it))); + } + else + { + return GetTranslationText(columnName); + } + } + public override string GetDbColumnName(string entityName, string propertyName) + { + if (this.MappingColumns.HasValue()) + { + var mappingInfo = this.MappingColumns.SingleOrDefault(it => it.EntityName == entityName && it.PropertyName == propertyName); + return (mappingInfo == null ? propertyName : mappingInfo.DbColumnName).ToLower(isAutoToLower); + } + else + { + return propertyName.ToLower(isAutoToLower); + } + } + } + public class OscarLMethod : DefaultDbMethod, IDbMethods + { + public override string IIF(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + var parameter3 = model.Args[2]; + if (parameter.Type == UtilConstants.BoolType) + { + parameter.MemberName = parameter.MemberName.ToString().Replace("=1", "=true"); + parameter2.MemberName = false; + parameter3.MemberName = true; + } + return string.Format("( CASE WHEN {0} THEN {1} ELSE {2} END )", parameter.MemberName, parameter2.MemberName, parameter3.MemberName); + } + public override string DateValue(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + var format = "dd"; + if (parameter2.MemberValue.ObjToString() == DateType.Year.ToString()) + { + format = "yyyy"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Month.ToString()) + { + format = "MM"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Day.ToString()) + { + format = "dd"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Hour.ToString()) + { + format = "hh"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Minute.ToString()) + { + format = "mm"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Second.ToString()) + { + format = "ss"; + } + if (parameter2.MemberValue.ObjToString() == DateType.Millisecond.ToString()) + { + format = "ss"; + } + return string.Format(" cast( to_char({1},'{0}')as integer ) ", format, parameter.MemberName); + } + + public override string Contains(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + return string.Format(" ({0} like concat('%',{1},'%')) ", parameter.MemberName, parameter2.MemberName ); + } + + public override string StartsWith(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + return string.Format(" ({0} like concat({1},'%')) ", parameter.MemberName, parameter2.MemberName); + } + + public override string EndsWith(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + return string.Format(" ({0} like concat('%',{1}))", parameter.MemberName,parameter2.MemberName); + } + + public override string DateIsSameDay(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + return string.Format(" (date_part('day',{0}-{1})=0) ", parameter.MemberName, parameter2.MemberName); ; + } + + public override string DateIsSameByType(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + var parameter3 = model.Args[2]; + return string.Format(" (date_part('{2}',{0}-{1})=0) ", parameter.MemberName, parameter2.MemberName, parameter3.MemberValue); + } + + public override string ToDate(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS timestamp)", parameter.MemberName); + } + public override string DateAddByType(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + var parameter3 = model.Args[2]; + return string.Format(" ({1} + ({2}||'{0}')::INTERVAL) ", parameter3.MemberValue, parameter.MemberName, parameter2.MemberName); + } + + public override string DateAddDay(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter2 = model.Args[1]; + return string.Format(" ({0} + ({1}||'day')::INTERVAL) ", parameter.MemberName, parameter2.MemberName); + } + + public override string ToInt32(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS INT4)", parameter.MemberName); + } + + public override string ToInt64(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS INT8)", parameter.MemberName); + } + + public override string ToString(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS VARCHAR)", parameter.MemberName); + } + + public override string ToGuid(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS VARCHAR)", parameter.MemberName); + } + + public override string ToDouble(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS DECIMAL(18,4))", parameter.MemberName); + } + + public override string ToBool(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS boolean)", parameter.MemberName); + } + + public override string ToDecimal(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" CAST({0} AS DECIMAL(18,4))", parameter.MemberName); + } + + public override string Length(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format(" LENGTH({0})", parameter.MemberName); + } + public override string MergeString(params string[] strings) + { + return " concat("+string.Join(",", strings).Replace("+", "") + ") "; + } + public override string IsNull(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter1 = model.Args[1]; + return string.Format("(CASE WHEN {0} IS NULL THEN {1} ELSE {0} END)", parameter.MemberName, parameter1.MemberName); + } + public override string GetDate() + { + return "NOW()"; + } + public override string GetRandom() + { + return "RANDOM()"; + } + + public override string EqualTrue(string fieldName) + { + return "( " + fieldName + "=true )"; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarInsertBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarInsertBuilder.cs new file mode 100644 index 000000000..419e6bbb2 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarInsertBuilder.cs @@ -0,0 +1,93 @@ +using System; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class OscarInsertBuilder : InsertBuilder + { + public override string SqlTemplate + { + get + { + if (IsReturnIdentity) + { + return @"INSERT INTO {0} + ({1}) + VALUES + ({2}) returning $PrimaryKey"; + } + else + { + return @"INSERT INTO {0} + ({1}) + VALUES + ({2}) ;"; + + } + } + } + public override string SqlTemplateBatch => "INSERT INTO {0} ({1})"; + public override string SqlTemplateBatchUnion => " VALUES "; + + public override string SqlTemplateBatchSelect => " {0} "; + + public override string ToSqlString() + { + if (IsNoInsertNull) + { + DbColumnInfoList = DbColumnInfoList.Where(it => it.Value != null).ToList(); + } + var groupList = DbColumnInfoList.GroupBy(it => it.TableId).ToList(); + var isSingle = groupList.Count() == 1; + string columnsString = string.Join(",", groupList.First().Select(it => Builder.GetTranslationColumnName(it.DbColumnName))); + if (isSingle) + { + string columnParametersString = string.Join(",", this.DbColumnInfoList.Select(it => Builder.SqlParameterKeyWord + it.DbColumnName)); + return string.Format(SqlTemplate, GetTableNameString, columnsString, columnParametersString); + } + else + { + StringBuilder batchInsetrSql = new StringBuilder(); + int pageSize = 200; + int pageIndex = 1; + int totalRecord = groupList.Count; + int pageCount = (totalRecord + pageSize - 1) / pageSize; + while (pageCount >= pageIndex) + { + batchInsetrSql.AppendFormat(SqlTemplateBatch, GetTableNameString, columnsString); + int i = 0; + foreach (var columns in groupList.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList()) + { + var isFirst = i == 0; + if (isFirst) + { + batchInsetrSql.Append(SqlTemplateBatchUnion); + } + batchInsetrSql.Append("\r\n ( " + string.Join(",", columns.Select(it => + { + object value = null; + if (it.Value is DateTime) + { + value = ((DateTime)it.Value).ToString("O"); + } + else + { + value = it.Value; + } + if (value == null||value==DBNull.Value) + { + return string.Format(SqlTemplateBatchSelect, "NULL"); + } + return string.Format(SqlTemplateBatchSelect, "'" + value.ObjToString().ToSqlFilter() + "'"); + })) + "),"); + ++i; + } + pageIndex++; + batchInsetrSql.Remove(batchInsetrSql.Length - 1,1).Append("\r\n;\r\n"); + } + return batchInsetrSql.ToString(); + } + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarQueryBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarQueryBuilder.cs new file mode 100644 index 000000000..370efcdd3 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarQueryBuilder.cs @@ -0,0 +1,94 @@ +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SqlSugar +{ + public partial class OscarQueryBuilder : QueryBuilder + { + #region Sql Template + public override string PageTempalte + { + get + { + /* + SELECT * FROM TABLE WHERE CONDITION ORDER BY ID DESC LIMIT 10 offset 0 + */ + var template = "SELECT {0} FROM {1} {2} {3} {4} LIMIT {6} offset {5}"; + return template; + } + } + public override string DefaultOrderByTemplate + { + get + { + return "ORDER BY NOW() "; + } + } + + #endregion + + #region Common Methods + public override bool IsComplexModel(string sql) + { + return Regex.IsMatch(sql, @"AS ""\w+\.\w+""")|| Regex.IsMatch(sql, @"AS ""\w+\.\w+\.\w+"""); + } + public override string ToSqlString() + { + base.AppendFilter(); + string oldOrderValue = this.OrderByValue; + string result = null; + sql = new StringBuilder(); + sql.AppendFormat(SqlTemplate, GetSelectValue, GetTableNameString, GetWhereValueString, GetGroupByString + HavingInfos, (Skip != null || Take != null) ? null : GetOrderByString); + if (IsCount) { return sql.ToString(); } + if (Skip != null && Take == null) + { + if (this.OrderByValue == "ORDER BY ") this.OrderByValue += GetSelectValue.Split(',')[0]; + result = string.Format(PageTempalte, GetSelectValue, GetTableNameString, GetWhereValueString, GetGroupByString + HavingInfos, (Skip != null || Take != null) ? null : GetOrderByString, Skip.ObjToInt(), long.MaxValue); + } + else if (Skip == null && Take != null) + { + if (this.OrderByValue == "ORDER BY ") this.OrderByValue += GetSelectValue.Split(',')[0]; + result = string.Format(PageTempalte, GetSelectValue, GetTableNameString, GetWhereValueString, GetGroupByString + HavingInfos, GetOrderByString, 0, Take.ObjToInt()); + } + else if (Skip != null && Take != null) + { + if (this.OrderByValue == "ORDER BY ") this.OrderByValue += GetSelectValue.Split(',')[0]; + result = string.Format(PageTempalte, GetSelectValue, GetTableNameString, GetWhereValueString, GetGroupByString + HavingInfos, GetOrderByString, Skip.ObjToInt() > 0 ? Skip.ObjToInt() : 0, Take); + } + else + { + result = sql.ToString(); + } + this.OrderByValue = oldOrderValue; + result = GetSqlQuerySql(result); + return result; + } + + #endregion + + #region Get SQL Partial + public override string GetSelectValue + { + get + { + string result = string.Empty; + if (this.SelectValue == null || this.SelectValue is string) + { + result = GetSelectValueByString(); + } + else + { + result = GetSelectValueByExpression(); + } + if (this.SelectType == ResolveExpressType.SelectMultiple) + { + this.SelectCacheKey = this.SelectCacheKey + string.Join("-", this.JoinQueryInfos.Select(it => it.TableName)); + } + return result; + } + } + + #endregion + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarUpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarUpdateBuilder.cs new file mode 100644 index 000000000..34a3dae87 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oscar/SqlBuilder/OscarUpdateBuilder.cs @@ -0,0 +1,184 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace SqlSugar +{ + public class OscarUpdateBuilder : UpdateBuilder + { + public override string SqlTemplateBatch + { + get + { + return @"UPDATE {1} {2} SET {0} FROM ${{0}} "; + } + } + public override string SqlTemplateJoin + { + get + { + return @" (VALUES + {0} + + ) AS T ({2}) WHERE {1} + "; + } + } + + public override string SqlTemplateBatchUnion + { + get + { + return ","; + } + } + + public override object FormatValue(object value) + { + if (value == null) + { + return "NULL"; + } + else + { + var type = value.GetType(); + if (type == UtilConstants.DateType) + { + var date = value.ObjToDate(); + if (date < Convert.ToDateTime("1900-1-1")) + { + date = Convert.ToDateTime("1900-1-1"); + } + return "'" + date.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'"; + } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } + else if (type.IsEnum()) + { + return Convert.ToInt64(value); + } + else if (type == UtilConstants.BoolType) + { + return value.ObjToBool() ? "1" : "0"; + } + else if (type == UtilConstants.StringType || type == UtilConstants.ObjType) + { + return "'" + value.ToString().ToSqlFilter() + "'"; + } + else + { + return "'" + value.ToString() + "'"; + } + } + } + + protected override string TomultipleSqlString(List> groupList) + { + Check.Exception(PrimaryKeys == null || PrimaryKeys.Count == 0, " Update List need Primary key"); + int pageSize = 200; + int pageIndex = 1; + int totalRecord = groupList.Count; + int pageCount = (totalRecord + pageSize - 1) / pageSize; + StringBuilder batchUpdateSql = new StringBuilder(); + while (pageCount >= pageIndex) + { + StringBuilder updateTable = new StringBuilder(); + string setValues = string.Join(",", groupList.First().Where(it => it.IsPrimarykey == false && (it.IsIdentity == false || (IsOffIdentity && it.IsIdentity))).Select(it => + { + if (SetValues.IsValuable()) + { + var setValue = SetValues.Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName)); + if (setValue != null && setValue.Any()) + { + return setValue.First().Value; + } + } + var result = string.Format("{0}=T.{0}", Builder.GetTranslationColumnName(it.DbColumnName)); + return result; + })); + string tempColumnValue = string.Join(",", groupList.First().Select(it => + { + if (SetValues.IsValuable()) + { + var setValue = SetValues.Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName)); + if (setValue != null && setValue.Any()) + { + return setValue.First().Value; + } + } + var result = Builder.GetTranslationColumnName(it.DbColumnName); + return result; + })); + batchUpdateSql.AppendFormat(SqlTemplateBatch.ToString(), setValues, GetTableNameStringNoWith, TableWithString); + int i = 0; + var tableColumnList = this.Context.DbMaintenance.GetColumnInfosByTableName(GetTableNameStringNoWith); + + foreach (var columns in groupList.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList()) + { + var isFirst = i == 0; + if (!isFirst) + { + updateTable.Append(SqlTemplateBatchUnion); + } + updateTable.Append("\r\n (" + string.Join(",", columns.Select(it => + { + var columnInfo = tableColumnList.FirstOrDefault(x => x.DbColumnName.Equals(it.DbColumnName, StringComparison.OrdinalIgnoreCase)); + var dbType = columnInfo?.DataType; + if (dbType == null) { + var typeName = it.PropertyType.Name.ToLower(); + if (typeName == "int32") + typeName = "int"; + if (typeName == "int64") + typeName = "long"; + if (typeName == "int16") + typeName = "short"; + if (typeName == "boolean") + typeName = "bool"; + + var isAnyType = OscarDbBind.MappingTypesConst.Where(x => x.Value.ToString().ToLower() == typeName).Any(); + if (isAnyType) + { + dbType = OscarDbBind.MappingTypesConst.Where(x => x.Value.ToString().ToLower() == typeName).FirstOrDefault().Key; + } + else { + dbType = "varchar"; + } + } + return string.Format("CAST({0} AS {1})", FormatValue(it.Value), dbType); + + })) + ")"); + ++i; + } + pageIndex++; + updateTable.Append("\r\n"); + string whereString = null; + if (this.WhereValues.HasValue()) + { + foreach (var item in WhereValues) + { + var isFirst = whereString == null; + whereString += (isFirst ? null : " AND "); + whereString += item; + } + } + else if (PrimaryKeys.HasValue()) + { + foreach (var item in PrimaryKeys) + { + var isFirst = whereString == null; + whereString += (isFirst ? null : " AND "); + whereString += string.Format("{0}.{1}=T.{1}", GetTableNameStringNoWith, Builder.GetTranslationColumnName(item)); + } + } + var format = string.Format(SqlTemplateJoin, updateTable, whereString, tempColumnValue); + batchUpdateSql.Replace("${0}", format); + batchUpdateSql.Append(";"); + } + return batchUpdateSql.ToString(); + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj index 1c42f2e11..fe0a2c604 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/SqlSugar.csproj @@ -25,6 +25,7 @@ +