Add QuestDbTest

Src/Asp.NetCore2/QuestDbTest/Config.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest
+{
+    /// <summary>
+    /// Setting up the database name does not require you to create the database
+    /// 设置好数据库名不需要你去手动建库
+    /// </summary>
+    public class Config
+    {
+        /// <summary>
+        /// Account have permission to create database
+        /// 用有建库权限的数据库账号
+        /// </summary>
+        public static string ConnectionString = "host=localhost;port=8812;username=admin;password=quest;database=qdb;ServerCompatibilityMode=NoTypeLoading;";
+        /// <summary>
+        /// Account have permission to create database
+        /// 用有建库权限的数据库账号
+        /// </summary>
+        public static string ConnectionString2 = ConnectionString;
+        /// <summary>
+        /// Account have permission to create database
+        /// 用有建库权限的数据库账号
+        /// </summary>
+        public static string ConnectionString3 = ConnectionString;
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Demo/Demo0_SqlSugarClient.cs

@@ -0,0 +1,423 @@
+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.QuestDB,
+                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.QuestDB,
+                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.SqlQuery<dynamic>("select 1");
+
+            //Create tables
+            db.CodeFirst.InitTables(typeof(OrderItem),typeof(Order));
+            var xx=db.Insertable(new Order() { Name = "order1", CustomId = 1, Price = 0, CreateTime = DateTime.Now })
+               .ToSqlString();
+            db.Ado.ExecuteCommand(xx);
+            //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", 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.QuestDB,
+                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.QuestDB,
+                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.QuestDB, ConnectionString=Config.ConnectionString,InitKeyType=InitKeyType.Attribute,IsAutoCloseConnection=true },
+            //    new ConnectionConfig(){ ConfigId="2", DbType=DbType.QuestDB, ConnectionString=Config.ConnectionString2 ,InitKeyType=InitKeyType.Attribute ,IsAutoCloseConnection=true}
+            //});
+
+            //var db1 = db.Ado.Connection.Database;
+            ////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");
+            //var db2 = db.Ado.Connection.Database;
+            //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());
+
+            //if (db2 == db1)
+            //{
+            //    return;
+            //}
+            //// 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.QuestDB,
+                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.QuestDB,
+                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.NetCore2/QuestDbTest/Demo/Demo1_Queryable.cs

@@ -0,0 +1,382 @@
+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<Order>().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 btime = Convert.ToDateTime("2021-1-1");
+            var etime = Convert.ToDateTime("2022-1-12");
+            var test01 = db.Queryable<Order>().Select(it =>  SqlFunc.DateDiff(DateType.Year,btime, etime)).ToList();
+            var test02 = db.Queryable<Order>().Select(it => SqlFunc.DateDiff(DateType.Day, btime, etime)).ToList();
+            var test03 = db.Queryable<Order>().Select(it => SqlFunc.DateDiff(DateType.Month, btime, etime)).ToList();
+            var test04 = db.Queryable<Order>().Select(it => SqlFunc.DateDiff(DateType.Second, DateTime.Now, DateTime.Now.AddMinutes(2))).ToList();
+            var q1 = db.Queryable<Order>().Take(1);
+            var q2 = db.Queryable<Order>().Take(2);
+            var test05 = db.UnionAll(q1, q2).ToList();
+            var test06 = db.Queryable<Order>().
+              Where(it => it.Price == 0 ? true : it.Name == it.Name)
+              .ToList();
+            Console.WriteLine("#### Examples End ####");
+            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();
+
+            List<Dictionary<string, object>> ListDic = db.Queryable<Order, OrderItem, Custom>((o, i, c) => new JoinQueryInfos(
+                  JoinType.Left, o.Id == i.OrderId,
+                  JoinType.Left, o.CustomId == c.Id
+                ))
+                .Select<ExpandoObject>().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<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.Contains("a", "cccacc")).First();
+            var list = db.Queryable<Order>().Select(it => new ViewOrder()
+            {
+
+                Id = SqlFunc.AggregateSum(SqlFunc.IF(it.Id > 0).Return(1).End(0))
+            }).ToList();
+            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();
+
+            // 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)
+              .Where(it => it.A.Id == 1).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();
+
+            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" , FieldValueConvertFunc=it=>Convert.ToInt32(it) });//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", 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<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" , FieldValueConvertFunc = it => Convert.ToInt32(it) }),
+                new  KeyValuePair<WhereType, ConditionalModel> ( WhereType.And,new ConditionalModel() { FieldName = "id", ConditionalType = ConditionalType.Equal, FieldValue = "2" ,FieldValueConvertFunc = it => Convert.ToInt32(it)})
+            }
+            });
+            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
+            db.CodeFirst.InitTables<Tree>();
+            //无限级高性能导航映射
+            var treeRoot = db.Queryable<Tree>().Where(it => it.Id == 1).ToList();
+            db.ThenMapper(treeRoot, item =>
+            {
+                item.Child = db.Queryable<Tree>().SetContext(x => x.ParentId, () => item.Id, item).ToList();
+            });
+            db.ThenMapper(treeRoot.SelectMany(it => it.Child), it =>
+            {
+                it.Child = db.Queryable<Tree>().SetContext(x => x.ParentId, () => it.Id, it).ToList();
+            });
+            db.ThenMapper(treeRoot.SelectMany(it => it.Child).SelectMany(it => it.Child), it =>
+            {
+                it.Child = db.Queryable<Tree>().SetContext(x => x.ParentId, () => it.Id, it).ToList();
+            });
+            db.ThenMapper(treeRoot.SelectMany(it => it.Child).SelectMany(it => it.Child).SelectMany(it => it.Child), it =>
+            {
+                it.Child = db.Queryable<Tree>().SetContext(x => x.ParentId, () => it.Id, it).ToList();
+            });
+            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.QuestDB,
+                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.NetCore2/QuestDbTest/Demo/Demo2_Updateable.cs

@@ -0,0 +1,110 @@
+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.QuestDB,
+                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").Where(it => it.Id == 1).ExecuteCommand();
+            var result81 = db.Updateable<Order>()
+                .SetColumns(it => it.Name == "Name" )
+                  .SetColumns(it => it.CreateTime == DateTime.Now)
+                .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();
+
+            Console.WriteLine("#### Updateable End ####");
+        }
+
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Demo/Demo3_Insertable.cs

@@ -0,0 +1,146 @@
+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.QuestDB,
+                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.CodeFirst.InitTables<RootTable0, TwoItem, TwoItem2, TwoItem3>();
+            db.CodeFirst.InitTables<ThreeItem2>();
+            db.DbMaintenance.TruncateTable("RootTable0");
+            db.DbMaintenance.TruncateTable("TwoItem");
+            db.DbMaintenance.TruncateTable("TwoItem2");
+            db.DbMaintenance.TruncateTable("TwoItem3");
+            db.DbMaintenance.TruncateTable("ThreeItem2");
+            Console.WriteLine("SubInsert Start");
+
+            db.Insertable(new Order()
+            {
+                Name = "订单 1",
+                CustomId = 1,
+                Price = 100,
+                CreateTime = DateTime.Now,
+                Id = 0,
+                Items = new List<OrderItem>() {
+                      new OrderItem(){
+                         
+                           OrderId=0,
+                            Price=1,
+                             ItemId=1
+                       },
+                      new OrderItem(){
+                           CreateTime=DateTime.Now,
+                           OrderId=0,
+                            Price=2,
+                             ItemId=2
+                       }
+                 }
+            })
+            .AddSubList(it => it.Items.First().OrderId).ExecuteCommand();
+
+
+
+            db.Insertable(new List<RootTable0>() {
+                new RootTable0()
+            {
+                 Name="aa",
+                   TwoItem2=new TwoItem2() {
+                      Id="1",
+                       ThreeItem2=new List<ThreeItem2>(){
+                            new ThreeItem2(){ Name="a", TwoItem2Id="1" },
+                            new ThreeItem2(){ Id=2, Name="a2", TwoItem2Id="2" }
+                        }
+                   },
+                   TwoItem=new TwoItem()
+                   {
+                       Name ="itema" ,
+                       RootId=2
+                   },
+                   TwoItem3=new List<TwoItem3>(){
+                       new TwoItem3(){  Id=0, Name="a",Desc="" },
+
+                   }
+            },
+                new RootTable0()
+            {
+                 Name="bb",
+                   TwoItem2=new TwoItem2() {
+                      Id="2"
+                  },
+                    TwoItem=new TwoItem()
+                   {
+                       Name ="itemb" ,
+                       RootId=2,
+
+                   },
+                    TwoItem3=new List<TwoItem3>(){
+                       new TwoItem3(){ Id=1, Name="b",Desc="" },
+                              new TwoItem3(){ Id=2, Name="b1",Desc="1" },
+                   }
+            }
+            })
+           .AddSubList(it => it.TwoItem.RootId)
+           .AddSubList(it => new SubInsertTree()
+           {
+               Expression = it.TwoItem2.RootId,
+               ChildExpression = new List<SubInsertTree>() {
+                       new SubInsertTree(){
+                            Expression=it.TwoItem2.ThreeItem2.First().TwoItem2Id
+                       }
+                  }
+           })
+           .AddSubList(it => it.TwoItem3)
+           .ExecuteCommand();
+
+            Console.WriteLine("#### Insertable End ####");
+        }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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 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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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();
+            db.Insertable(data).EnableDiffLogEvent("--inser Order--").ExecuteCommand();
+            Console.WriteLine("#### Aop End ####");
+        }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Demo/DemoD_DbFirst.cs

@@ -0,0 +1,78 @@
+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.QuestDB,
+                ConnectionString = Config.ConnectionString,
+                InitKeyType = InitKeyType.Attribute,
+                IsAutoCloseConnection = true,
+                MoreSettings=new ConnMoreSettings() {
+                     PgSqlIsAutoToLower=false
+                }
+            });
+
+            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.NetCore2/QuestDbTest/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.QuestDB,
+                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 = "varchar(255)")]//custom
+        public string Text { get; set; }
+        [SugarColumn(IsNullable = true)]
+        public DateTime CreateTime { get; set; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/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.QuestDB,
+                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.NetCore2/QuestDbTest/Demo/DemoH_Snowflake.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PgSqlTest.Demo
+{
+    class DemoH_Snowflake
+    {
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Demo/DemoJ_Report.cs

@@ -0,0 +1,141 @@
+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.QuestDB,
+                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,DateTime.Now.AddYears(-1),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.NetCore2/QuestDbTest/Demo/DemoN_SplitTable.cs

@@ -0,0 +1,96 @@
+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("#### DemoN_SplitTable Start ####");
+            SqlSugarClient db = new SqlSugarClient(new ConnectionConfig()
+            {
+                DbType = DbType.QuestDB,
+                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);
+
+
+            var first = db.Queryable<OrderSpliteTest>()
+          .SplitTable(DateTime.MaxValue, DateTime.Now)
+          .First();//no table
+
+
+            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.NetCore2/QuestDbTest/Demo/DemoO_Fastest.cs

@@ -0,0 +1,62 @@
+using OrmTest;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest 
+{
+    public class TestFAST11
+    {
+        [SqlSugar.SugarColumn(IsArray =true, ColumnDataType ="text []")]
+        public string[] Array { get; set; }
+
+        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 ="json")]
+        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.QuestDB,
+                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<TestFAST11>();
+            db.Fastest<TestFAST11>().BulkCopy(new List<TestFAST11>() { 
+              new TestFAST11(){ Array=new string[]{ "2"}, Date=DateTime.Now, Id=Guid.NewGuid()+"", Sex=1 , X=11,json=new string[]{ "x"} }
+            });
+            var data = new List<TestFAST11>() {
+              new TestFAST11(){ Array=new string[]{ "2"}, Date=DateTime.Now, Id=Guid.NewGuid()+"", Sex=1 , X=11,json=new string[]{ "x"} }
+            };
+            //db.Updateable(data).ExecuteCommand();
+            db.Fastest<TestFAST11>().BulkUpdate(data);
+            var x = db.Queryable<TestFAST11>().ToList();
+ 
+        }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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.QuestDB, 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;
+        }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Models/CarType.cs

@@ -0,0 +1,7 @@
+namespace OrmTest
+{
+    public class CarType
+    {
+        public bool State { get;  set; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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<OrderItem> 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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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,SqlParameterDbType =System.Data.DbType.Date)]
+        public DateTime CreateTime { get; set; }
+        [SugarColumn(IsNullable =true)]
+        public int CustomId { get; set; }
+        [SugarColumn(IsIgnore = true)]
+        public List<OrderItem> Items { get; set; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Models/SubInsertTest.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace OrmTest
+{
+    public class RootTable0
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey =true,IsIdentity =true)]
+        public int Id { get; set; }
+        public string Name { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore =true)]
+        public TwoItem TwoItem { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public TwoItem2 TwoItem2 { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public List<TwoItem3> TwoItem3 { get; set; }
+    }
+    public class TwoItem
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
+        public int Id { get; set; }
+        public int RootId { get; set; }
+        public string Name { get; set; }
+    }
+    public class TwoItem2
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true)]
+        public string Id { get; set; }
+        public int RootId { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore =true)]
+        public List<ThreeItem2> ThreeItem2 { get; set; }
+    }
+    public class TwoItem3
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true)]
+        public int Id { get; set; }
+        public string  Name { get; set; }
+        public string Desc { get; set; }
+    }
+    public class ThreeItem2
+    {
+       [SqlSugar.SugarColumn(IsPrimaryKey = true)]
+
+        public int  Id { get; set; }
+        public string Name { get; set; }
+        public string TwoItem2Id { get; set; }
+    }
+
+    public class Country
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true)]
+        public int Id { get; set; }
+        public string Name { get; set; }
+
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public List<Province> Provinces { get; set; }
+    }
+
+    public class Province
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey =true)]
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public int CountryId { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public List<City> citys { get; set; }
+    }
+
+    public class City
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true)]
+        public int Id { get; set; }
+        public int ProvinceId { get; set; }
+        public string Name { get; set; }
+    }
+
+
+    public class Country1
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true,IsIdentity =true)]
+        public int Id { get; set; }
+        public string Name { get; set; }
+
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public List<Province1> Provinces { get; set; }
+    }
+
+    public class Province1
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true,IsIdentity =true)]
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public int CountryId { get; set; }
+        [SqlSugar.SugarColumn(IsIgnore = true)]
+        public List<City1> citys { get; set; }
+    }
+
+    public class City1
+    {
+        [SqlSugar.SugarColumn(IsPrimaryKey = true,IsIdentity =true)]
+        public int Id { get; set; }
+        public int ProvinceId { get; set; }
+        public string Name { get; set; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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<Tree> Child { get; set; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/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; }
+    }
+}

Src/Asp.NetCore2/QuestDbTest/Program.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace OrmTest
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            //Demo
+            Demo0_SqlSugarClient.Init();
+            DemoO_Fastest.Init();
+            Demo1_Queryable.Init();
+            Demo2_Updateable.Init();
+            Demo3_Insertable.Init();
+            DemoN_SplitTable.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();
+            DemoJ_Report.Init();
+            //Unit test
+            //NewUnitTest.Init();
+ 
+
+            Console.WriteLine("all successfully.");
+            Console.ReadKey();
+        }
+
+ 
+    }
+}

Src/Asp.NetCore2/QuestDbTest/QuestDbTest.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\SqlSugar\SqlSugar.csproj" />
+  </ItemGroup>
+
+</Project>