Add SqlSugar.Access and SqlSugar MySqlConnector

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                InitKeyType = InitKeyType.Attribute,
+                IsAutoCloseConnection = true,
+                SlaveConnectionConfigs = new List<SlaveConnectionConfig>() {
+                     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<Order>().First();
+            Console.WriteLine("#### MasterSlave End ####");
+        }
+
+        private static void SqlSugarClient()
+        {
+            //Create db
+            Console.WriteLine("#### SqlSugarClient Start ####");
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.MySqlConnector,
+                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<Order, OrderItem,Custom>();//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<IConditionalModel> conModels = new List<IConditionalModel>();
+            conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" });//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.MySqlConnector,
+                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<AttributeTable>();//Create Table
+
+            db.Insertable(new AttributeTable() { Id = Guid.NewGuid().ToString(), Name = "Name" }).ExecuteCommand();
+            var list = db.Queryable<AttributeTable>().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 SqlSugarScope singleDb = new SqlSugarScope(
+            new ConnectionConfig()
+            {
+                ConfigId = 1,
+                DbType = DbType.MySqlConnector,
+                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<ConnectionConfig>()
+            {
+                new ConnectionConfig(){ ConfigId="1", DbType=DbType.MySqlConnector, ConnectionString=Config.ConnectionString,InitKeyType=InitKeyType.Attribute,IsAutoCloseConnection=true },
+                new ConnectionConfig(){ ConfigId="2", DbType=DbType.MySqlConnector, 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<Order>().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<Order>().Count());
+
+            // Example 1
+            Console.WriteLine("Example 1");
+            try
+            {
+                db.BeginTran();
+
+                db.ChangeDatabase("1");//use db1
+                db.Deleteable<Order>().ExecuteCommand();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+
+                db.ChangeDatabase("2");//use db2
+                db.Deleteable<Order>().ExecuteCommand();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().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<Order>().Count());
+
+                db.ChangeDatabase("2");//use db2
+                Console.WriteLine(db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+            }
+
+
+
+            // Example 2
+            Console.WriteLine("Example 2");
+
+            var result=db.UseTran(() =>
+            {
+
+                db.ChangeDatabase("1");//use db1
+                db.Deleteable<Order>().ExecuteCommand();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+
+                db.ChangeDatabase("2");//use db2
+                db.Deleteable<Order>().ExecuteCommand();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().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<Order>().Count());
+
+                db.ChangeDatabase("2");//use db2
+                Console.WriteLine(db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+            }
+
+            // Example 3
+            Console.WriteLine("Example 3");
+
+            var result2 = db.UseTranAsync(async () =>
+            {
+
+                db.ChangeDatabase("1");//use db1
+                await db.Deleteable<Order>().ExecuteCommandAsync();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+
+                db.ChangeDatabase("2");//use db2
+                await db.Deleteable<Order>().ExecuteCommandAsync();
+                Console.WriteLine("---Delete all " + db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+                throw new Exception("");
+
+            });
+            result2.Wait();
+            if (result2.Result.IsSuccess == false)
+            {
+                Console.WriteLine("---Roll back");
+                db.ChangeDatabase("1");//use sqlserver
+                Console.WriteLine(db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+
+                db.ChangeDatabase("2");//use mysql
+                Console.WriteLine(db.CurrentConnectionConfig.DbType);
+                Console.WriteLine(db.Queryable<Order>().Count());
+            }
+
+            Console.WriteLine("#### Distributed TransactionExample End ####");
+        }
+    }
+
+    /// <summary>
+    /// DbContext Example 1
+    /// </summary>
+    public class DbContext
+    {
+
+        public SqlSugarClient Db;
+        public DbContext()
+        {
+            Db = new SqlSugarClient(new ConnectionConfig()
+            {
+                ConnectionString = Config.ConnectionString,
+                DbType = DbType.MySqlConnector,
+                IsAutoCloseConnection = true,
+                InitKeyType = InitKeyType.Attribute,
+                AopEvents = new AopEvents()
+                {
+                    OnLogExecuting = (sql, p) =>
+                    {
+                        Console.WriteLine(sql);
+                    }
+                }
+            });
+        }
+        public SimpleClient<Order> OrderDb => new SimpleClient<Order>(Db);
+        public SimpleClient<OrderItem> OrderItemDb => new SimpleClient<OrderItem>(Db);
+    }
+
+
+    public class OrderDal : DbContext<Order>
+    {
+
+    }
+    /// <summary>
+    /// DbContext  Example 2
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class DbContext<T> where T : class, new()
+    {
+
+        public SqlSugarClient Db;
+        public DbContext()
+        {
+            Db = new SqlSugarClient(new ConnectionConfig()
+            {
+                ConnectionString = Config.ConnectionString,
+                DbType = DbType.MySqlConnector,
+                IsAutoCloseConnection = true,
+                InitKeyType = InitKeyType.Attribute,
+                AopEvents = new AopEvents()
+                {
+                    OnLogExecuting = (sql, p) =>
+                    {
+                        Console.WriteLine(sql);
+                    }
+                }
+            });
+        }
+        public SimpleClient<T> CurrentDb => new SimpleClient<T>(Db);
+        public virtual T GetById(int id)
+        {
+            return CurrentDb.GetById(id);
+        }
+        public virtual List<T> GetList()
+        {
+            return CurrentDb.GetList();
+        }
+        public virtual bool Delete(int id)
+        {
+            return CurrentDb.DeleteById(id);
+        }
+    }
+
+}

Src/Asp.Net/MySqlConnectorTest/Demo/Demo1_Queryable.cs

@@ -0,0 +1,394 @@
+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();
+            ConfiQuery();
+        }
+        private static void ConfiQuery()
+        {
+            var db = GetInstance();
+            db.ConfigQuery.SetTable<Order>(it => it.Id, it => it.Name, "01", it => it.Id > 1);
+            db.ConfigQuery.SetTable<Order>(it => it.Id, it => it.Name, "02", it => it.Id > 2);
+            db.ConfigQuery.SetTable<Order>(it => it.Id, it => it.Name, null);
+            var list = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = it.ItemId.SelectAll(),
+                OrderName = it.OrderId.GetConfigValue<Order>("01")
+            }).ToList();
+            var list2 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = it.ItemId.SelectAll(),
+                OrderName = it.OrderId.GetConfigValue<Order>("02")
+            }).ToList();
+            var list3 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = it.ItemId.SelectAll(),
+                OrderName = it.OrderId.GetConfigValue<Order>()
+            }).ToList();
+
+            var list4 = db.Queryable<OrderItem>().Select(it => new OrderItem
+            {
+                ItemId = it.ItemId.SelectAll(),
+                OrderName = it.OrderId.GetConfigValue<Order>()
+            })
+            .Where(it => it.OrderId.GetConfigValue<Order>() == "order1")
+            .OrderBy(it => it.OrderId.GetConfigValue<Order>()).ToList();
+
+            var list5 = db.Queryable<Order, OrderItem>((o, i) => o.Id == i.OrderId)
+                        .OrderBy((o, i) => i.OrderId.GetConfigValue<Order>(), OrderByType.Desc)
+                        .Select<ViewOrder>((o, i) => new ViewOrder()
+                        {
+                            Id = o.Id.SelectAll(),
+                            Name = i.OrderId.GetConfigValue<Order>()
+                        })
+                        .ToList();
+        }
+        private static void EasyExamples()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### Examples Start ####");
+            var db = GetInstance();
+            var dbTime = db.GetDate();
+            var getAll = db.Queryable<Order>().ToList();
+            var getAll2 = db.Queryable<Order>().Where(it=>it.CreateTime.Day>=DateTime.Now.Date.Day).ToList();
+            var getOrderBy = db.Queryable<Order>().OrderBy(it => it.Name,OrderByType.Desc).ToList();
+            var getOrderBy2 = db.Queryable<Order>().OrderBy(it => it.Id).OrderBy(it => it.Name, OrderByType.Desc).ToList();
+            var getOrderBy3 = db.Queryable<Order>().OrderBy(it =>new { it.Name,it.Id}).ToList();
+            var getRandom = db.Queryable<Order>().OrderBy(it => SqlFunc.GetRandom()).First();
+            var getByPrimaryKey = db.Queryable<Order>().InSingle(2);
+            var getSingleOrDefault = db.Queryable<Order>().Where(it => it.Id == 1).Single();
+            var getFirstOrDefault = db.Queryable<Order>().First();
+            var getByWhere = db.Queryable<Order>().Where(it => it.Id == 1 || it.Name == "a").ToList();
+            var getByWhere2 = db.Queryable<Order>().Where(it => it.Id == DateTime.Now.Year).ToList();
+            var getByFuns = db.Queryable<Order>().Where(it => SqlFunc.IsNullOrEmpty(it.Name)).ToList();
+            var getByFuns2 = db.Queryable<Order>().GroupBy(it => it.Name).Select(it => SqlFunc.AggregateDistinctCount(it.Price)).ToList();
+            var dp = DateTime.Now;
+            var test05 = db.Queryable<Order>().Where(it => it.CreateTime.Month == dp.Month).ToList();
+            var fromatList = db.Queryable<Order>().Select(it => it.CreateTime.ToString("%Y-%m")).ToList();
+            var test06 = db.Queryable<Order>().Where(it => it.CreateTime.Date.Day >= DateTime.Now.Date.Day).ToList();
+            Console.WriteLine("#### Examples End ####");
+        }
+
+        private static void ReturnType()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### ReturnType Start ####");
+            var db = GetInstance();
+            List<Order> list = db.Queryable<Order>().ToList();
+
+            Order item = db.Queryable<Order>().First(it => it.Id == 1);
+
+            DataTable dataTable = db.Queryable<Order>().Select(it => it.Id).ToDataTable();
+
+            var json = db.Queryable<Order>().ToJson();
+
+            List<int> listInt = db.Queryable<Order>().Select(it => it.Id).ToList();
+
+            var dynamic = db.Queryable<Order>().Select<dynamic>().ToList();
+
+            var viewModel = db.Queryable<Order, OrderItem, Custom>((o, i, c) => new JoinQueryInfos(
+                    JoinType.Left, o.Id == i.OrderId  ,
+                    JoinType.Left, o.CustomId == c.Id 
+                ))
+                .Select<ViewOrder>().ToList();
+
+            var newDynamic = db.Queryable<Order, OrderItem, Custom>((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<Order, OrderItem, Custom>((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<Order, OrderItem, Custom>((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<Order, OrderItem, Custom>((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();
+
+ 
+           var mergeList= db.Queryable<Order>()
+                 .Select(it => new { id = it.Id })
+                 .MergeTable().Select<Order>().ToList();
+
+            Console.WriteLine("#### ReturnType End ####");
+        }
+
+        private static void Subquery()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### Subquery Start ####");
+            var db = GetInstance();
+
+            var list = db.Queryable<Order>().Take(10).Select(it => new
+            {
+                customName=SqlFunc.Subqueryable<Custom>().Where("it.CustomId=id").Select(s=>s.Name),
+                customName2 = SqlFunc.Subqueryable<Custom>().Where("it.CustomId = id").Where(s => true).Select(s => s.Name)
+            }).ToList();
+
+            var list2 = db.Queryable<Order>().Where(it => SqlFunc.Subqueryable<OrderItem>().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<Order>().Select(it => SqlFunc.CharIndex("a", "cccacc")).First();
+            var list2 = db.Queryable<Order>().Select(it => new
+            {
+                date = SqlFunc.ToDateShort(it.CreateTime),
+                datetime = SqlFunc.ToDate(it.CreateTime)
+            }).ToList();
+            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();
+            db.Insertable(new Tree() { Id = 222, Name = "child222", ParentId = 22 }).ExecuteCommand();
+            // Same property name mapping,Both entities have parentId
+            var list = db.Queryable<Tree>().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<Tree>()
+                                     //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<OrderItemInfo>().Mapper(it => it.Order, it => it.OrderId).ToList();
+
+            //one to many
+            var list3 = db.Queryable<Order>().Mapper(it => it.Items, it => it.Items.First().OrderId).ToList();
+
+            //many to many
+            db.CodeFirst.InitTables<A, B, ABMapping>();
+
+            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<ABMapping>()
+              .Mapper(it => it.A, it => it.AId)
+              .Mapper(it => it.B, it => it.BId).ToList();
+
+            //Manual mode
+            var result = db.Queryable<OrderInfo>().Take(10).Select<ViewOrder>().Mapper((itemModel, cache) =>
+            {
+                var allItems = cache.Get(orderList => {
+                    var allIds = orderList.Select(it => it.Id).ToList();
+                    return db.Queryable<OrderItem>().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();
+
+
+            var tree = db.Queryable<Tree>().ToTree(it => it.Child, it => it.ParentId, 0);
+            var parentList = db.Queryable<Tree>().ToParentList(it => it.ParentId, 22);
+            var parentList2 = db.Queryable<Tree>().ToParentList(it => it.ParentId, 222);
+            var parentList3 = db.Queryable<Tree>().ToParentList(it => it.ParentId, 2);
+            Console.WriteLine("#### End Start ####");
+        }
+
+        private static void NoEntity()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### No Entity Start ####");
+            var db = GetInstance();
+
+            var list = db.Queryable<dynamic>().AS("order").Where("id=id", new { id = 1 }).ToList();
+
+            var list2 = db.Queryable<dynamic>("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<Order, OrderItem, Custom>((o, i, c) => o.Id == i.OrderId&&c.Id == o.CustomId)
+                         .Select<ViewOrder>()
+                         .ToList();
+
+            //Join table
+            var list2 = db.Queryable<Order, OrderItem, Custom>((o, i, c) => new JoinQueryInfos(
+             JoinType.Left, o.Id == i.OrderId,
+             JoinType.Left, c.Id == o.CustomId
+            ))
+           .Select<ViewOrder>().ToList();
+
+            //Join queryable
+            var query1 = db.Queryable<Order, OrderItem>((o, i) => new JoinQueryInfos(
+              JoinType.Left, o.Id == i.OrderId
+            ))
+            .Where(o => o.Name == "jack");
+
+            var query2 = db.Queryable<Custom>();
+            var list3=db.Queryable(query1, query2,JoinType.Left, (p1, p2) => p1.CustomId == p2.Id).Select<ViewOrder>().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<Order>().Where(it => it.Id == 1).ToList();
+            //id=@id or name like '%'+@name+'%'
+            var list2 = db.Queryable<Order>().Where(it => it.Id == 1 || it.Name.Contains("jack")).ToList();
+
+
+            //Create expression 
+            var exp = Expressionable.Create<Order>()
+                            .And(it => it.Id == 1)
+                            .Or(it => it.Name.Contains("jack")).ToExpression();
+            var list3 = db.Queryable<Order>().Where(exp).ToList();
+
+
+            /*** By sql***/
+
+            //id=@id
+            var list4 = db.Queryable<Order>().Where("id=@id", new { id = 1 }).ToList();
+            //id=@id or name like '%'+@name+'%'
+            var list5 = db.Queryable<Order>().Where("id=@id or name like @name ", new { id = 1, name = "%jack%" }).ToList();
+
+
+
+            /*** By dynamic***/
+
+            //id=1
+            var conModels = new List<IConditionalModel>();
+            conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" });//id=1
+            var student = db.Queryable<Order>().Where(conModels).ToList();
+
+            //Complex use case
+            List<IConditionalModel> Order = new List<IConditionalModel>();
+            conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" });//id=1
+            conModels.Add(new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Like, FieldValue = "1" });// 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<KeyValuePair<WhereType, SqlSugar.ConditionalModel>>()//  (id=1 or id=2 and id=1)
+            {
+                //new  KeyValuePair<WhereType, ConditionalModel>( WhereType.And ,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "1" }),
+                new  KeyValuePair<WhereType, ConditionalModel> (WhereType.Or,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "2" }),
+                new  KeyValuePair<WhereType, ConditionalModel> ( WhereType.And,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "2" })
+            }
+            });
+            var list6 = db.Queryable<Order>().Where(conModels).ToList();
+
+            /*** Conditional builder ***/
+
+            // use whereif
+            string name = "";
+            int id = 1;
+            var query = db.Queryable<Order>()
+                            .WhereIF(!string.IsNullOrEmpty(name), it => it.Name.Contains(name))
+                            .WhereIF(id > 0, it => it.Id == id).ToList();
+            //clone new Queryable
+            var query2 = db.Queryable<Order>().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<Order>().FirstAsync();
+            task1.Wait();
+            var task2 = db.Queryable<Order>().Where(it => it.Id == 1).ToListAsync();
+
+        
+            task2.Wait();
+
+            Console.WriteLine("#### Async End ####");
+        }
+
+        private static SqlSugarClient GetInstance()
+        {
+            return new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = SqlSugar.DbType.MySqlConnector,
+                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)));
+                    }
+                }
+            });
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/Demo2_Updateable.cs

@@ -0,0 +1,108 @@
+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.MySqlConnector,
+                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<Order> {
+                 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<Class>
+
+            //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<Class> by id
+
+
+
+
+            /*** 2.by expression ***/
+
+            //update  name,createtime
+            var result7 = db.Updateable<Order>(it => new Order() { Name = "a", CreateTime = DateTime.Now }).Where(it => it.Id == 11).ExecuteCommand();
+            var result71 = db.Updateable<Order>().SetColumns(it => new Order() { Name = "a", CreateTime = DateTime.Now }).Where(it => it.Id == 11).ExecuteCommand();
+            //only update name
+            var result8 = db.Updateable<Order>(it => it.Name == "Name" + "1").Where(it => it.Id == 1).ExecuteCommand();
+            var result81 = db.Updateable<Order>().SetColumns(it => it.Name == "Name" + "1").Where(it => it.Id == 1).ExecuteCommand();
+            //
+
+
+
+
+            /*** 3.by Dictionary ***/
+            var dt = new Dictionary<string, object>();
+            dt.Add("id", 1);
+            dt.Add("name", "abc");
+            dt.Add("createTime", DateTime.Now);
+            var dtList = new List<Dictionary<string, object>>();
+            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();
+            var dataTable = db.Queryable<Order>().Select("id,name,1 as price").Take(2).ToDataTable();
+            db.Fastest<Order>().BulkUpdate("Order", dataTable, new string[] { "id" }, new string[] { "name" });
+            Console.WriteLine("#### Updateable End ####");
+        }
+
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/Demo3_Insertable.cs

@@ -0,0 +1,75 @@
+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.MySqlConnector,
+                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<Order> {
+                 new Order() { Id = 11, Name = "order11", Price=0 },
+                 new Order() { Id = 12, Name = "order12" , Price=0}
+            };
+            var x = db.Insertable(updateObjs).RemoveDataCache().IgnoreColumns(it => it.CreateTime).UseParameter().ExecuteCommand();
+            //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();
+
+            db.Deleteable<Order>().ExecuteCommand();
+            db.Insertable(new Order()
+            {
+                CreateTime = DateTime.Now,
+                CustomId = 11,
+                Name = "11",
+                Price = 11
+            }).UseMySql().ExecuteBulkCopy();
+            db.Insertable(new OrderItem()
+            {
+                CreateTime = DateTime.Now,
+                ItemId = 1,
+                OrderId = 1,
+                OrderName = "a",
+                Price = 11
+            }).UseMySql().ExecuteBulkCopy();
+            var data = db.Queryable<Order>().ToList();
+            db.Insertable(data).UseMySql().ExecuteBulkCopy();
+            db.Fastest<Order>().BulkUpdate(data);
+            Console.WriteLine("#### Insertable End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<Order>().Where(new Order() { Id = 1111 }).ExecuteCommand();
+
+            //by primary key
+            db.Deleteable<Order>().In(1111).ExecuteCommand();
+
+            //by primary key array
+            db.Deleteable<Order>().In(new int[] { 1111, 2222 }).ExecuteCommand();
+
+            //by expression
+            db.Deleteable<Order>().Where(it => it.Id == 11111).ExecuteCommand();
+
+            Console.WriteLine("#### Deleteable End ####");
+
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/Demo5_SqlQueryable.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 Demo5_SqlQueryable
+    {
+        public static void Init()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### SqlQueryable Start ####");
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.MySqlConnector,
+                ConnectionString = Config.ConnectionString,
+                InitKeyType = InitKeyType.Attribute,
+                IsAutoCloseConnection = true
+            });
+
+            int total = 0;
+            var list = db.SqlQueryable<Order>("select * from `order`").ToPageList(1, 2, ref total);
+
+
+            //by expression
+            var list2 = db.SqlQueryable<Order>("select * from `order`").Where(it => it.Id == 1).ToPageList(1, 2);
+            //by sql
+            var list3 = db.SqlQueryable<Order>("select * from `order`").Where("id=@id", new { id = 1 }).ToPageList(1, 2);
+
+            Console.WriteLine("#### SqlQueryable End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<Order>(new Order() { Name = "a" }).AddQueue();
+            db.Insertable<Order>(new Order() { Name = "b" }).AddQueue();
+            db.SaveQueues();
+
+
+            db.Insertable<Order>(new Order() { Name = "a" }).AddQueue();
+            db.Insertable<Order>(new Order() { Name = "b" }).AddQueue();
+            db.Insertable<Order>(new Order() { Name = "c" }).AddQueue();
+            db.Insertable<Order>(new Order() { Name = "d" }).AddQueue();
+            var ar = db.SaveQueuesAsync();
+            ar.Wait();
+
+            db.Queryable<Order>().AddQueue();
+            db.Queryable<Order>().AddQueue();
+            db.AddQueue("select * from `order` where id=@id", new { id = 10000 });
+            var result2 = db.SaveQueues<Order, Order, Order>();
+
+            Console.WriteLine("#### Queue End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/Demo7_Ado.cs

@@ -0,0 +1,59 @@
+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.MySqlConnector,
+                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<SugarParameter>(){
+              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<Order>("select * from `order` ");
+            var list2 = db.Ado.SqlQuery<Order,Order>("select * from `order` where 1=2;select * from `order` ");
+            var list3 = db.Ado.SqlQuery<int>(" delete from `order` where 2=15 ");
+            var intValue=db.Ado.SqlQuerySingle<int>("select 1");
+            db.Ado.ExecuteCommand("delete  from `order` where id>1000");
+            //db.Ado.xxx
+            Console.WriteLine("#### Ado End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<Order>(new Order() { Id=1, Name="jack" }).ExecuteReturnEntity();
+
+
+            //insert or update
+            db.Saveable<Order>(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 ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<Order>();
+            foreach (var column in entityInfo.Columns)
+            {
+                Console.WriteLine(column.DbColumnName);
+            }
+
+            var dbColumnsName = db.EntityMaintenance.GetDbColumnName<EntityMapper>("Name");
+
+            var dbTableName = db.EntityMaintenance.GetTableName<EntityMapper>();
+
+            //more https://github.com/sunkaixuan/SqlSugar/wiki/9.EntityMain
+            Console.WriteLine("#### EntityMain End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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 ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<string, SugarParameter[]>(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<Order>().ToList();
+            db.Queryable<OrderItem>().ToList();
+
+            //OnDiffLogEvent
+            var data = db.Queryable<Order>().First();
+            data.Name = "changeName";
+            db.Updateable(data).EnableDiffLogEvent("--update Order--").ExecuteCommand();
+
+            Console.WriteLine("#### Aop End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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 @"           /// <summary>
+                          /// Desc_New:{PropertyDescription}
+                          /// Default_New:{DefaultValue}
+                                /// Nullable_New:{IsNullable}
+                                /// </summary>";
+                        })
+                        .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 ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<CodeFirstTable1>().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 = "Nvarchar(255)")]//custom
+        public string Text { get; set; }
+        [SugarColumn(IsNullable = true)]
+        public DateTime CreateTime { get; set; }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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<int> ids = Enumerable.Range(1, 100).ToList();
+            db.Utilities.PageEach(ids, 10, list =>
+            {
+                Console.WriteLine(string.Join("," ,list));   
+            });
+
+            var list2= db.Utilities.DataTableToList<Order>(db.Ado.GetDataTable("select * from `order`"));
+
+            //more https://github.com/sunkaixuan/SqlSugar/wiki/f.Utilities
+            Console.WriteLine("#### Utilities End ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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.MySqlConnector,
+                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 ####");
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/DemoJ_Report.cs

@@ -0,0 +1,142 @@
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest
+{
+    public class DemoJ_Report
+    {
+        public static void Init()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### Utilities Start ####");
+
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.MySqlConnector,
+                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)));
+                    }
+                }
+            });
+            Demo1(db);
+            Demo2(db);
+            Demo3(db);
+        }
+
+        private static void Demo1(SqlSugarClient db)
+        {
+            var list = new List<int>() { 1, 2, 3 };
+            var query1 = db.Queryable<Order>();
+            var queryable2 = db.Reportable(list).ToQueryable<int>();
+            var x = db.Queryable(queryable2, query1, (x2, x1) => x1.Id.Equals(x2.ColumnName))
+                .Select((x2, x1) => new { x = x1.Id, x2 = x2.ColumnName  }).ToList();
+        }
+        private static void Demo2(SqlSugarClient db)
+        {
+            var list = db.Queryable<OrderItem>().ToList();
+            var query1 = db.Queryable<Order>();
+            var queryable2 = db.Reportable(list).ToQueryable();
+            var x = db.Queryable(query1, queryable2, (x1, x2) => x1.Id.Equals(x2.OrderId))
+                .Select((x1, x2) => new { name = x1.Name,id=x1.Id, orderid = x2.OrderId }).ToList();
+        }
+        private static void Demo3(SqlSugarClient db)
+        {
+            db.CodeFirst.InitTables<operateinfo>();
+            db.Deleteable<operateinfo>().ExecuteCommand();
+            db.Insertable(new operateinfo()
+            {
+                 id=1,
+                 operate_type=1,
+                 operate_time=Convert.ToDateTime("2021-1-1")
+            }).ExecuteCommand();
+            db.Insertable(new operateinfo()
+            {
+                id = 1,
+                operate_type = 1,
+                operate_time = Convert.ToDateTime("2021-1-2")
+            }).ExecuteCommand();
+            db.Insertable(new operateinfo()
+            {
+                id = 1,
+                operate_type = 1,
+                operate_time = Convert.ToDateTime("2021-3-1")
+            }).ExecuteCommand();
+            db.Insertable(new operateinfo()
+            {
+                id = 1,
+                operate_type = 1,
+                operate_time = Convert.ToDateTime("2021-3-2")
+            }).ExecuteCommand();
+            db.Insertable(new operateinfo()
+            {
+                id = 1,
+                operate_type = 1,
+                operate_time = Convert.ToDateTime("2021-4-2")
+            }).ExecuteCommand();
+
+
+            var queryableLeft = db.Reportable(ReportableDateType.MonthsInLast1years).ToQueryable<DateTime>();
+            var queryableRight = db.Queryable<operateinfo>();
+            var list= db.Queryable(queryableLeft, queryableRight, JoinType.Left,
+                (x1, x2) => x2.operate_time.ToString("yyyy-MM")==x1.ColumnName.ToString("yyyy-MM"))
+                .GroupBy((x1,x2)=>x1.ColumnName)
+                .Where(x1=>SqlFunc.Between(x1.ColumnName,"2021-01-01",DateTime.Now))
+                .Select((x1, x2) => new
+                {
+                    count=SqlFunc.AggregateSum(SqlFunc.IIF(x2.id>0,1,0)) ,
+                    date=x1.ColumnName.ToString("yyyy-MM")
+                    
+                }).ToList();
+        }
+
+
+        public partial class operateinfo
+        {
+            public operateinfo()
+            {
+
+
+            }
+            /// <summary>
+            /// Desc:操作序号
+            /// Default:
+            /// Nullable:False
+            /// </summary>           
+            public int id { get; set; }
+
+            /// <summary>
+            /// Desc:操作时间
+            /// Default:
+            /// Nullable:False
+            /// </summary>           
+            public DateTime operate_time { get; set; }
+
+            /// <summary>
+            /// Desc:操作类型
+            /// Default:
+            /// Nullable:False
+            /// </summary>           
+            public int operate_type { get; set; }
+
+            /// <summary>
+            /// Desc:操作人编号
+            /// Default:
+            /// Nullable:False
+            /// </summary>           
+            public int user_id { get; set; }
+
+        }
+    }
+
+}

Src/Asp.Net/MySqlConnectorTest/Demo/DemoN_SplitTable.cs

@@ -0,0 +1,89 @@
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest 
+{
+    public class DemoN_SplitTable
+    {
+        public static void Init()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### CodeFirst Start ####");
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.MySqlConnector,
+                ConnectionString = Config.ConnectionString,
+                InitKeyType = InitKeyType.Attribute,
+                IsAutoCloseConnection = true
+            });
+            db.Aop.OnLogExecuted = (s, p) =>
+            {
+                Console.WriteLine(s);
+            };
+
+            //初始化分表
+            db.CodeFirst.SplitTables().InitTables<OrderSpliteTest>();
+
+            Console.WriteLine();
+
+            //根据最近3个表进行查询
+            var list=db.Queryable<OrderSpliteTest>().Where(it=>it.Pk==Guid.NewGuid())
+                .SplitTable(tabs => tabs.Take(3))
+                .Where(it=>it.Time==DateTime.Now).ToOffsetPage(1,2);
+
+            Console.WriteLine();
+
+            //根据时间选出的表进行查询
+            var list2 = db.Queryable<OrderSpliteTest>().SplitTable(tabs => tabs.Where(it=> it.Date>=DateTime.Now.AddYears(-2))).ToList();
+
+            Console.WriteLine();
+
+            //删除数据只在最近3张表执行操作
+            var x = db.Deleteable<OrderSpliteTest>().Where(it=>it.Pk==Guid.NewGuid()).SplitTable(tabs => tabs.Take(3)).ExecuteCommand();
+           
+            Console.WriteLine();
+
+            var tableName = db.SplitHelper<OrderSpliteTest>().GetTableName(DateTime.Now.AddDays(-1));
+            var tableName2 = db.SplitHelper(new OrderSpliteTest() {  Time=DateTime.Now}).GetTableNames();
+            var tableName3 = db.SplitHelper(new List<OrderSpliteTest> {
+              new OrderSpliteTest() { Time = DateTime.Now },
+              new OrderSpliteTest() { Time = DateTime.Now },
+              new OrderSpliteTest() { Time = DateTime.Now.AddMonths(-10) }
+            }).GetTableNames();
+            var x2 = db.Updateable<OrderSpliteTest>()
+                .SetColumns(it=>it.Name=="a")
+                .Where(it => it.Pk == Guid.NewGuid())
+                .SplitTable(tabs => tabs.InTableNames(tableName2))
+                .ExecuteCommand();
+
+            Console.WriteLine();
+
+            //按日分表 
+            var x3 = db.Insertable(new OrderSpliteTest() { Name="A" }).SplitTable().ExecuteCommand();
+
+            Console.WriteLine();
+            ////强制分表类型
+            var x4 = db.Insertable(new OrderSpliteTest() { Name = "A" ,Time=DateTime.Now.AddDays(-1) }).SplitTable().ExecuteCommand();
+
+            var tableName21 = db.SplitHelper<OrderSpliteTest>().GetTableName(DateTime.Now.AddDays(-111));
+            var listNull = db.Queryable<OrderSpliteTest>().SplitTable(ta => ta.InTableNames(tableName21)).ToList();
+            Console.WriteLine("#### CodeFirst end ####");
+        }
+
+        [SplitTable(SplitType.Day)]
+        [SqlSugar.SugarTable("Taxxx0101_{year}{month}{day}")]
+        public class OrderSpliteTest 
+        {
+            [SugarColumn(IsPrimaryKey =true)]
+            public  Guid  Pk{ get; set; }
+            public string Name { get; set; }
+            [SugarColumn(IsNullable =true)]
+            [SplitField]
+            public DateTime Time { get; set; }
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/Demo/DemoO_Fastest.cs

@@ -0,0 +1,60 @@
+using OrmTest;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest 
+{
+    public class TestFAST111
+    {
+ 
+        public int Sex { get; set; }
+        public DateTime Date { get; set; }
+
+        [SqlSugar.SugarColumn(IsPrimaryKey =true)]
+        public string Id { get; set; }
+        [SqlSugar.SugarColumn(IsNullable  = true)]
+        public long X { get; set; }
+        [SqlSugar.SugarColumn(IsNullable = true,IsJson =true,ColumnDataType ="varchar(500)")]
+        public string [] json { get; set; }
+    }
+ 
+    public class DemoO_Fastest
+    {
+        public static void Init()
+        {
+            Console.WriteLine("");
+            Console.WriteLine("#### Insertable Start ####");
+
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.MySqlConnector,
+                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.CodeFirst.InitTables<TestFAST111>();
+            db.Fastest<TestFAST111>().BulkCopy(new List<TestFAST111>() { 
+              new TestFAST111(){  Date=DateTime.Now, Id=Guid.NewGuid()+"", Sex=1 , X=111,json=new string[]{ "x"} }
+            });
+            var data = new List<TestFAST111>() {
+              new TestFAST111(){   Date=DateTime.Now, Id=Guid.NewGuid()+"", Sex=2 , X=112,json=new string[]{ "x"} }
+            };
+            //db.Updateable(data).ExecuteCommand();
+            db.Fastest<TestFAST111>().BulkUpdate(data);
+            var x = db.Queryable<TestFAST111>().ToList();
+ 
+        }
+    }
+}

Src/Asp.Net/MySqlConnectorTest/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<Order>().ToSql();
+            //SELECT [Id],[Name],[Price],[CreateTime] FROM `order`  WHERE  isDelete=0 
+            Console.WriteLine(sql);
+
+
+            var sql2 = db.Queryable<Order,OrderItem>((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<Order>().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<Order>().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.MySqlConnector, 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;
+        }
+    }
+}