refactor async/DbSet/DbContext...

src/Versions.props

@@ -1,6 +1,6 @@
 <Project>
     <PropertyGroup>
-        <Version>2.1.2</Version>
+        <Version>2.2.0-develop</Version>
         <VitLinq_Version>[3.1.2, 3.2.0)</VitLinq_Version>
     </PropertyGroup>
 </Project>

src/Vitorm.EntityGenerate/Extensions/IDbSet_Extensions_Origin.cs

@@ -5,33 +5,33 @@ namespace Vitorm
     public static partial class IDbSet_Extensions
     {
         // #0 Schema :  Create Drop
-        private static void TryCreateTable<Entity>(this IDbSet data) => (data as DbSet<Entity>).TryCreateTable();
-        private static void TryDropTable<Entity>(this IDbSet data) => (data as DbSet<Entity>).TryDropTable();
+        private static void TryCreateTable<Entity>(this IDbSet data) => ((IDbSet<Entity>)data).TryCreateTable();
+        private static void TryDropTable<Entity>(this IDbSet data) => ((IDbSet<Entity>)data).TryDropTable();
 
 
         // #1 Create :  Add AddRange
-        private static Entity Add<Entity>(this IDbSet data, Entity entity) => (data as DbSet<Entity>).Add(entity);
-        private static void AddRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => (data as DbSet<Entity>).AddRange(entities);
+        private static Entity Add<Entity>(this IDbSet data, Entity entity) => ((IDbSet<Entity>)data).Add(entity);
+        private static void AddRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => ((IDbSet<Entity>)data).AddRange(entities);
 
 
 
 
         // #2 Retrieve : Get Query
-        private static Entity Get<Entity>(this IDbSet data, object keyValue) => (data as DbSet<Entity>).Get(keyValue);
-        private static IQueryable<Entity> Query<Entity>(this IDbSet data) => (data as DbSet<Entity>).Query();
+        private static Entity Get<Entity>(this IDbSet data, object keyValue) => ((IDbSet<Entity>)data).Get(keyValue);
+        private static IQueryable<Entity> Query<Entity>(this IDbSet data) => ((IDbSet<Entity>)data).Query();
 
 
         // #3 Update: Update UpdateRange
-        private static int Update<Entity>(this IDbSet data, Entity entity) => (data as DbSet<Entity>).Update(entity);
-        private static int UpdateRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => (data as DbSet<Entity>).UpdateRange(entities);
+        private static int Update<Entity>(this IDbSet data, Entity entity) => ((IDbSet<Entity>)data).Update(entity);
+        private static int UpdateRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => ((IDbSet<Entity>)data).UpdateRange(entities);
 
 
         // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        private static int Delete<Entity>(this IDbSet data, Entity entity) => (data as DbSet<Entity>).Delete(entity);
-        private static int DeleteRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => (data as DbSet<Entity>).DeleteRange(entities);
+        private static int Delete<Entity>(this IDbSet data, Entity entity) => ((IDbSet<Entity>)data).Delete(entity);
+        private static int DeleteRange<Entity>(this IDbSet data, IEnumerable<Entity> entities) => ((IDbSet<Entity>)data).DeleteRange(entities);
 
-        private static int DeleteByKey<Entity>(this IDbSet data, object keyValue) => (data as DbSet<Entity>).DeleteByKey(keyValue);
-        private static int DeleteByKeys<Entity, Key>(this IDbSet data, IEnumerable<Key> keys) => (data as DbSet<Entity>).DeleteByKeys(keys);
+        private static int DeleteByKey<Entity>(this IDbSet data, object keyValue) => ((IDbSet<Entity>)data).DeleteByKey(keyValue);
+        private static int DeleteByKeys<Entity, Key>(this IDbSet data, IEnumerable<Key> keys) => ((IDbSet<Entity>)data).DeleteByKeys(keys);
 
 
 

src/Vitorm.EntityGenerate/Extensions/SqlDbContext_EntityType_Extensions.cs

@@ -31,7 +31,7 @@ namespace Vitorm
             else
             {
                 var entityDescriptor = dbContext.entityLoader.LoadDescriptorWithoutCache(entityType).entityDescriptor;
-                dbSet = Vitorm.Sql.DbSetConstructor.CreateDbSet(dbContext, entityDescriptor);
+                dbSet = Vitorm.Sql.SqlDbSetConstructor.CreateDbSet(dbContext, entityDescriptor);
             }
             return dbSet;
         }

src/Vitorm.MySql/DataProvider.cs

@@ -10,12 +10,12 @@ namespace Vitorm.MySql
         protected Dictionary<string, object> config;
         protected DbConfig dbConfig;
 
-        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseMySql(dbConfig);
 
         public override void Init(Dictionary<string, object> config)
         {
             this.config = config;
             this.dbConfig = new(config);
         }
+        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseMySql(dbConfig);
     }
 }

src/Vitorm.MySql/DbConfig.cs

@@ -39,7 +39,7 @@ namespace Vitorm.MySql
         public int? commandTimeout { get; set; }
 
 
-        public static string ChangeDatabaseForConnecitonString(string connectionString, string databaseName)
+        public static string ChangeDatabaseForConnectionString(string connectionString, string databaseName)
             => new ConnectionStringBuilder(connectionString) { Database = databaseName }.ConnectionString;
 
         public static string GetDatabaseName(string connectionString) => new ConnectionStringBuilder(connectionString).Database;
@@ -50,7 +50,7 @@ namespace Vitorm.MySql
         public DbConnectionProvider ToDbConnectionProvider()
             => new DbConnectionProvider(
                 createDbConnection: CreateDbConnection,
-                changeDatabaseForConnectionString: ChangeDatabaseForConnecitonString,
+                changeDatabaseForConnectionString: ChangeDatabaseForConnectionString,
                 getDatabaseName: GetDatabaseName,
                 connectionString: connectionString,
                 readOnlyConnectionString: readOnlyConnectionString

src/Vitorm.SqlServer/DataProvider.cs

@@ -10,12 +10,11 @@ namespace Vitorm.SqlServer
         protected Dictionary<string, object> config;
         protected DbConfig dbConfig;
 
-        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseSqlServer(dbConfig);
-
         public override void Init(Dictionary<string, object> config)
         {
             this.config = config;
             this.dbConfig = new(config);
         }
+        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseSqlServer(dbConfig);
     }
 }

src/Vitorm.SqlServer/DbConfig.cs

@@ -39,7 +39,7 @@ namespace Vitorm.SqlServer
         public int? commandTimeout { get; set; }
 
 
-        public static string ChangeDatabaseForConnecitonString(string connectionString, string databaseName)
+        public static string ChangeDatabaseForConnectionString(string connectionString, string databaseName)
             => new ConnectionStringBuilder(connectionString) { InitialCatalog = databaseName }.ConnectionString;
 
         public static string GetDatabaseName(string connectionString) => new ConnectionStringBuilder(connectionString).InitialCatalog;
@@ -50,7 +50,7 @@ namespace Vitorm.SqlServer
         public DbConnectionProvider ToDbConnectionProvider()
             => new DbConnectionProvider(
                 createDbConnection: CreateDbConnection,
-                changeDatabaseForConnectionString: ChangeDatabaseForConnecitonString,
+                changeDatabaseForConnectionString: ChangeDatabaseForConnectionString,
                 getDatabaseName: GetDatabaseName,
                 connectionString: connectionString,
                 readOnlyConnectionString: readOnlyConnectionString

src/Vitorm.Sqlite/DataProvider.cs

@@ -10,12 +10,12 @@ namespace Vitorm.Sqlite
         protected Dictionary<string, object> config;
         protected DbConfig dbConfig;
 
-        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseSqlite(dbConfig);
-
         public override void Init(Dictionary<string, object> config)
         {
             this.config = config;
             this.dbConfig = new(config);
         }
+        public override SqlDbContext CreateDbContext() => new SqlDbContext().UseSqlite(dbConfig);
+
     }
 }

src/Vitorm.Sqlite/DbConfig.cs

@@ -39,7 +39,7 @@ namespace Vitorm.Sqlite
         public int? commandTimeout { get; set; }
 
 
-        public static string ChangeDatabaseForConnecitonString(string connectionString, string databaseName)
+        public static string ChangeDatabaseForConnectionString(string connectionString, string databaseName)
             => new ConnectionStringBuilder(connectionString) { DataSource = databaseName }.ConnectionString;
 
         public static string GetDatabaseName(string connectionString) => new ConnectionStringBuilder(connectionString).DataSource;
@@ -50,7 +50,7 @@ namespace Vitorm.Sqlite
         public DbConnectionProvider ToDbConnectionProvider()
             => new DbConnectionProvider(
                 createDbConnection: CreateDbConnection,
-                changeDatabaseForConnectionString: ChangeDatabaseForConnecitonString,
+                changeDatabaseForConnectionString: ChangeDatabaseForConnectionString,
                 getDatabaseName: GetDatabaseName,
                 connectionString: connectionString,
                 readOnlyConnectionString: readOnlyConnectionString

src/Vitorm/Async/DataProvider/SqlDataProvider.Async.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-using Vitorm.Sql;
-
-namespace Vitorm.DataProvider
-{
-    public abstract partial class SqlDataProvider : IDataProvider
-    {
-        public virtual async Task<T> InvokeInDbAsync<T>(Func<SqlDbContext, Task<T>> func)
-        {
-            using var dbContext = CreateDbContext();
-            return await func(dbContext);
-        }
-
-        public virtual async Task InvokeInDbAsync(Func<SqlDbContext, Task> func)
-        {
-            using var dbContext = CreateDbContext();
-            await func(dbContext);
-        }
-
-
-        // #0 Schema :  Create Drop Truncate
-        public virtual async Task TryCreateTableAsync<Entity>() => await InvokeInDbAsync(db => db.TryCreateTableAsync<Entity>());
-        public virtual async Task TryDropTableAsync<Entity>() => await InvokeInDbAsync(db => db.TryDropTableAsync<Entity>());
-        public virtual async Task TruncateAsync<Entity>() => await InvokeInDbAsync(db => db.TruncateAsync<Entity>());
-
-
-        // #1 Create :  Add AddRange
-        public virtual async Task<Entity> AddAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.AddAsync<Entity>(entity));
-        public virtual async Task AddRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.AddRangeAsync<Entity>(entities));
-
-        // #2 Retrieve : Get Query
-        public virtual async Task<Entity> GetAsync<Entity>(object keyValue) => await InvokeInDbAsync(db => db.GetAsync<Entity>(keyValue));
-
-
-        // #3 Update: Update UpdateRange
-        public virtual async Task<int> UpdateAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.UpdateAsync<Entity>(entity));
-        public virtual async Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.UpdateRangeAsync<Entity>(entities));
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public virtual async Task<int> DeleteAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.DeleteAsync<Entity>(entity));
-        public virtual async Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.DeleteRangeAsync<Entity>(entities));
-
-        public virtual async Task<int> DeleteByKeyAsync<Entity>(object keyValue) => await InvokeInDbAsync(db => db.DeleteByKeyAsync<Entity>(keyValue));
-        public virtual async Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys) => await InvokeInDbAsync(db => db.DeleteByKeysAsync<Entity, Key>(keys));
-
-    }
-}

src/Vitorm/Async/DbContext.Async.cs

@@ -1,40 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Vitorm
-{
-    public abstract partial class DbContext
-    {
-
-        // #0 Schema :  Create Drop Truncate
-        public abstract Task TryCreateTableAsync<Entity>();
-        public abstract Task TryDropTableAsync<Entity>();
-        public abstract Task TruncateAsync<Entity>();
-
-
-        // #1 Create :  Add AddRange
-        public abstract Task<Entity> AddAsync<Entity>(Entity entity);
-        public abstract Task AddRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-        // #2 Retrieve : Get Query
-        public abstract Task<Entity> GetAsync<Entity>(object keyValue);
-        //public virtual IQueryable<Entity> Query<Entity>() => throw new NotImplementedException();
-
-
-        // #3 Update: Update UpdateRange
-        public abstract Task<int> UpdateAsync<Entity>(Entity entity);
-        public abstract Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public abstract Task<int> DeleteAsync<Entity>(Entity entity);
-        public abstract Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-
-        public abstract Task<int> DeleteByKeyAsync<Entity>(object keyValue);
-        public abstract Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys);
-
-
-
-    }
-}

src/Vitorm/Async/DbSet.Async.cs

@@ -1,36 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Vitorm
-{
-    public partial class DbSet<Entity> : IDbSet<Entity>
-    {
-        // #0 Schema :  Create Drop Truncate
-        public virtual Task TryCreateTableAsync() => dbContext.TryCreateTableAsync<Entity>();
-        public virtual Task TryDropTableAsync() => dbContext.TryDropTableAsync<Entity>();
-        public virtual Task TruncateAsync() => dbContext.TruncateAsync<Entity>();
-
-
-        // #1 Create :  Add AddRange
-        public virtual Task<Entity> AddAsync(Entity entity) => dbContext.AddAsync<Entity>(entity);
-        public virtual Task AddRangeAsync(IEnumerable<Entity> entities) => dbContext.AddRangeAsync<Entity>(entities);
-
-
-        // #2 Retrieve : Get Query
-        public virtual Task<Entity> GetAsync(object keyValue) => dbContext.GetAsync<Entity>(keyValue);
-
-
-        // #3 Update: Update UpdateRange
-        public virtual Task<int> UpdateAsync(Entity entity) => dbContext.UpdateAsync<Entity>(entity);
-        public virtual Task<int> UpdateRangeAsync(IEnumerable<Entity> entities) => dbContext.UpdateRangeAsync<Entity>(entities);
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public virtual Task<int> DeleteAsync(Entity entity) => dbContext.DeleteAsync<Entity>(entity);
-        public virtual Task<int> DeleteRangeAsync(IEnumerable<Entity> entities) => dbContext.DeleteRangeAsync<Entity>(entities);
-        public virtual Task<int> DeleteByKeyAsync(object keyValue) => dbContext.DeleteByKeyAsync<Entity>(keyValue);
-        public virtual Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys) => dbContext.DeleteByKeysAsync<Entity, Key>(keys);
-
-
-    }
-}

src/Vitorm/Async/IDbContext.Async.cs

@@ -1,35 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Vitorm
-{
-    public partial interface IDbContext
-    {
-        // #0 Schema :  Create Drop
-        Task TryCreateTableAsync<Entity>();
-        Task TryDropTableAsync<Entity>();
-        Task TruncateAsync<Entity>();
-
-
-        // #1 Create :  Add AddRange
-        Task<Entity> AddAsync<Entity>(Entity entity);
-        Task AddRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-        // #2 Retrieve : Get Query
-        Task<Entity> GetAsync<Entity>(object keyValue);
-        //IQueryable<Entity> Query<Entity>();
-
-
-        // #3 Update: Update UpdateRange
-        Task<int> UpdateAsync<Entity>(Entity entity);
-        Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        Task<int> DeleteAsync<Entity>(Entity entity);
-        Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities);
-
-        Task<int> DeleteByKeyAsync<Entity>(object keyValue);
-        Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys);
-    }
-}

src/Vitorm/Async/IDbSet.Async.cs

@@ -1,39 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace Vitorm
-{
-    public partial interface IDbSet
-    {
-
-        // #0 Schema :  Create Drop Truncate
-        Task TryCreateTableAsync();
-        Task TryDropTableAsync();
-        Task TruncateAsync();
-    }
-
-    public partial interface IDbSet<Entity> : IDbSet
-    {
-        // #1 Create :  Add AddRange
-        Task<Entity> AddAsync(Entity entity);
-        Task AddRangeAsync(IEnumerable<Entity> entities);
-
-        // #2 Retrieve : Get Query
-        Task<Entity> GetAsync(object keyValue);
-        //IQueryable<Entity> Query();
-
-
-        // #3 Update: Update UpdateRange
-        Task<int> UpdateAsync(Entity entity);
-        Task<int> UpdateRangeAsync(IEnumerable<Entity> entities);
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        Task<int> DeleteAsync(Entity entity);
-        Task<int> DeleteRangeAsync(IEnumerable<Entity> entities);
-        Task<int> DeleteByKeyAsync(object keyValue);
-        Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys);
-
-
-    }
-}

src/Vitorm/Async/Sql/SqlDbContext.ExecuteAsync.cs

@@ -1,65 +0,0 @@
-using System.Collections.Generic;
-using System.Data;
-using System.Threading.Tasks;
-
-namespace Vitorm.Sql
-{
-    public partial class SqlDbContext : DbContext
-    {
-
-        public virtual async Task<int> ExecuteWithTransactionAsync(string sql, IDictionary<string, object> param = null, IDbTransaction transaction = null)
-        {
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-
-            return await sqlExecutor.ExecuteAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-        }
-
-        public virtual async Task<int> ExecuteAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return await sqlExecutor.ExecuteAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return await sqlExecutor.ExecuteAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-
-        public virtual async Task<IDataReader> ExecuteReaderAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return await sqlExecutor.ExecuteReaderAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return await sqlExecutor.ExecuteReaderAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-
-        public virtual async Task<object> ExecuteScalarAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return await sqlExecutor.ExecuteScalarAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return await sqlExecutor.ExecuteScalarAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-
-
-
-    }
-}

src/Vitorm/DataProvider/DataProvider.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Vitorm.DataProvider
+{
+    public abstract class DataProvider : IDataProvider
+    {
+        public abstract DbContext CreateDbContext();
+        public abstract void Init(Dictionary<string, object> config);
+
+
+        #region Sync Method
+
+        // #0 Schema :  Create
+        public virtual void TryCreateTable<Entity>() => CreateDbContext().TryCreateTable<Entity>();
+        public virtual void TryDropTable<Entity>() => CreateDbContext().TryDropTable<Entity>();
+        public virtual void Truncate<Entity>() => CreateDbContext().Truncate<Entity>();
+
+
+        // #1 Create :  Add AddRange
+        public virtual Entity Add<Entity>(Entity entity) => CreateDbContext().Add<Entity>(entity);
+        public virtual void AddRange<Entity>(IEnumerable<Entity> entities) => CreateDbContext().AddRange<Entity>(entities);
+
+        // #2 Retrieve : Get Query
+        public virtual Entity Get<Entity>(object keyValue) => CreateDbContext().Get<Entity>(keyValue);
+        public virtual IQueryable<Entity> Query<Entity>() => CreateDbContext().Query<Entity>();
+
+
+        // #3 Update: Update UpdateRange
+        public virtual int Update<Entity>(Entity entity) => CreateDbContext().Update<Entity>(entity);
+        public virtual int UpdateRange<Entity>(IEnumerable<Entity> entities) => CreateDbContext().UpdateRange<Entity>(entities);
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        public virtual int Delete<Entity>(Entity entity) => CreateDbContext().Delete<Entity>(entity);
+        public virtual int DeleteRange<Entity>(IEnumerable<Entity> entities) => CreateDbContext().DeleteRange<Entity>(entities);
+
+        public virtual int DeleteByKey<Entity>(object keyValue) => CreateDbContext().DeleteByKey<Entity>(keyValue);
+        public virtual int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys) => CreateDbContext().DeleteByKeys<Entity, Key>(keys);
+
+        #endregion
+
+
+
+        #region Async Method
+
+        // #0 Schema :  Create
+        public virtual Task TryCreateTableAsync<Entity>() => CreateDbContext().TryCreateTableAsync<Entity>();
+        public virtual Task TryDropTableAsync<Entity>() => CreateDbContext().TryDropTableAsync<Entity>();
+        public virtual Task TruncateAsync<Entity>() => CreateDbContext().TruncateAsync<Entity>();
+
+
+        // #1 Create :  Add AddRange
+        public virtual Task<Entity> AddAsync<Entity>(Entity entity) => CreateDbContext().AddAsync<Entity>(entity);
+        public virtual Task AddRangeAsync<Entity>(IEnumerable<Entity> entities) => CreateDbContext().AddRangeAsync<Entity>(entities);
+
+        // #2 Retrieve : Get Query
+        public virtual Task<Entity> GetAsync<Entity>(object keyValue) => CreateDbContext().GetAsync<Entity>(keyValue);
+
+
+
+        // #3 Update: Update UpdateRange
+        public virtual Task<int> UpdateAsync<Entity>(Entity entity) => CreateDbContext().UpdateAsync<Entity>(entity);
+        public virtual Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities) => CreateDbContext().UpdateRangeAsync<Entity>(entities);
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        public virtual Task<int> DeleteAsync<Entity>(Entity entity) => CreateDbContext().DeleteAsync<Entity>(entity);
+        public virtual Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities) => CreateDbContext().DeleteRangeAsync<Entity>(entities);
+
+        public virtual Task<int> DeleteByKeyAsync<Entity>(object keyValue) => CreateDbContext().DeleteByKeyAsync<Entity>(keyValue);
+        public virtual Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys) => CreateDbContext().DeleteByKeysAsync<Entity, Key>(keys);
+
+        #endregion
+
+    }
+}

src/Vitorm/DataProvider/SqlDataProvider.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 using Vitorm.Sql;
 
@@ -15,6 +16,9 @@ namespace Vitorm.DataProvider
         public abstract void Init(Dictionary<string, object> config);
 
 
+
+        #region Sync Method
+
         public virtual T InvokeInDb<T>(Func<SqlDbContext, T> func)
         {
             using var dbContext = CreateDbContext();
@@ -55,5 +59,55 @@ namespace Vitorm.DataProvider
         public virtual int DeleteByKey<Entity>(object keyValue) => InvokeInDb(db => db.DeleteByKey<Entity>(keyValue));
         public virtual int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys) => InvokeInDb(db => db.DeleteByKeys<Entity, Key>(keys));
 
+
+
+
+
+        #endregion
+
+
+
+        #region Async Method
+
+        public virtual async Task<T> InvokeInDbAsync<T>(Func<SqlDbContext, Task<T>> func)
+        {
+            using var dbContext = CreateDbContext();
+            return await func(dbContext);
+        }
+
+        public virtual async Task InvokeInDbAsync(Func<SqlDbContext, Task> func)
+        {
+            using var dbContext = CreateDbContext();
+            await func(dbContext);
+        }
+
+
+        // #0 Schema :  Create Drop Truncate
+        public virtual async Task TryCreateTableAsync<Entity>() => await InvokeInDbAsync(db => db.TryCreateTableAsync<Entity>());
+        public virtual async Task TryDropTableAsync<Entity>() => await InvokeInDbAsync(db => db.TryDropTableAsync<Entity>());
+        public virtual async Task TruncateAsync<Entity>() => await InvokeInDbAsync(db => db.TruncateAsync<Entity>());
+
+
+        // #1 Create :  Add AddRange
+        public virtual async Task<Entity> AddAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.AddAsync<Entity>(entity));
+        public virtual async Task AddRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.AddRangeAsync<Entity>(entities));
+
+        // #2 Retrieve : Get Query
+        public virtual async Task<Entity> GetAsync<Entity>(object keyValue) => await InvokeInDbAsync(db => db.GetAsync<Entity>(keyValue));
+
+
+        // #3 Update: Update UpdateRange
+        public virtual async Task<int> UpdateAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.UpdateAsync<Entity>(entity));
+        public virtual async Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.UpdateRangeAsync<Entity>(entities));
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        public virtual async Task<int> DeleteAsync<Entity>(Entity entity) => await InvokeInDbAsync(db => db.DeleteAsync<Entity>(entity));
+        public virtual async Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities) => await InvokeInDbAsync(db => db.DeleteRangeAsync<Entity>(entities));
+
+        public virtual async Task<int> DeleteByKeyAsync<Entity>(object keyValue) => await InvokeInDbAsync(db => db.DeleteByKeyAsync<Entity>(keyValue));
+        public virtual async Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys) => await InvokeInDbAsync(db => db.DeleteByKeysAsync<Entity, Key>(keys));
+        #endregion
+
     }
 }

src/Vitorm/DbContext.Event.cs

@@ -3,7 +3,7 @@ using System.Collections.Generic;
 
 namespace Vitorm
 {
-    public abstract partial class DbContext : IDbContext, IDisposable
+    public partial class DbContext : IDbContext, IDisposable
     {
         public static Action<ExecuteEventArgument> event_DefaultOnExecuting;
         public Action<ExecuteEventArgument> event_OnExecuting = event_DefaultOnExecuting;

src/Vitorm/DbContext.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 using Vit.Linq.ExpressionNodes;
 using Vit.Linq.ExpressionNodes.ExpressionConvertor.MethodCalls;
@@ -9,11 +10,11 @@ using Vitorm.Entity;
 
 namespace Vitorm
 {
-    public abstract partial class DbContext : IDbContext, IDisposable
+    public partial class DbContext : IDbContext, IDisposable
     {
-        public DbContext()
+        public DbContext(Func<IDbContext, IEntityDescriptor, IDbSet> dbSetCreator = null)
         {
-            dbSetCreator = DefaultDbSetCreator;
+            this.dbSetCreator = dbSetCreator ?? Vitorm.DefaultDbSetConstructor.CreateDbSet;
         }
 
 
@@ -32,12 +33,7 @@ namespace Vitorm
 
 
         #region DbSet
-        protected IDbSet DefaultDbSetCreator(IEntityDescriptor entityDescriptor)
-        {
-            return DbSetConstructor.CreateDbSet(this, entityDescriptor);
-        }
-
-        protected virtual Func<IEntityDescriptor, IDbSet> dbSetCreator { set; get; }
+        protected virtual Func<IDbContext, IEntityDescriptor, IDbSet> dbSetCreator { set; get; }
 
         protected Dictionary<Type, IDbSet> dbSetMap = null;
 
@@ -47,14 +43,14 @@ namespace Vitorm
 
             var entityDescriptor = GetEntityDescriptor(entityType);
 
-            dbSet = dbSetCreator(entityDescriptor);
+            dbSet = dbSetCreator(this, entityDescriptor);
             if (dbSet == null) return null;
 
             dbSetMap ??= new();
             dbSetMap[entityType] = dbSet;
             return dbSet;
         }
-        public virtual IDbSet CreateDbSet(IEntityDescriptor entityDescriptor) => dbSetCreator(entityDescriptor);
+        public virtual IDbSet CreateDbSet(IEntityDescriptor entityDescriptor) => dbSetCreator(this, entityDescriptor);
         public virtual IDbSet<Entity> DbSet<Entity>()
         {
             return DbSet(typeof(Entity)) as IDbSet<Entity>;
@@ -84,8 +80,8 @@ namespace Vitorm
             dbSet?.ChangeTable(tableName);
             return dbSet;
         }
-        public virtual DbSet<Entity> ChangeTable<Entity>(string tableName)
-            => ChangeTable(typeof(Entity), tableName) as DbSet<Entity>;
+        public virtual IDbSet<Entity> ChangeTable<Entity>(string tableName)
+            => ChangeTable(typeof(Entity), tableName) as IDbSet<Entity>;
 
 
         public virtual IDbSet ChangeTableBack(Type entityType)
@@ -94,8 +90,8 @@ namespace Vitorm
             dbSet?.ChangeTableBack();
             return dbSet;
         }
-        public virtual DbSet<Entity> ChangeTableBack<Entity>()
-            => ChangeTableBack(typeof(Entity)) as DbSet<Entity>;
+        public virtual IDbSet<Entity> ChangeTableBack<Entity>()
+            => ChangeTableBack(typeof(Entity)) as IDbSet<Entity>;
 
         #endregion
 
@@ -106,36 +102,72 @@ namespace Vitorm
 
 
 
+
+        #region Sync Method
         // #0 Schema :  Create Drop
-        public abstract void TryCreateTable<Entity>();
-        public abstract void TryDropTable<Entity>();
-        public abstract void Truncate<Entity>();
+        public virtual void TryCreateTable<Entity>() => DbSet<Entity>().TryCreateTable();
+        public virtual void TryDropTable<Entity>() => DbSet<Entity>().TryDropTable();
+        public virtual void Truncate<Entity>() => DbSet<Entity>().Truncate();
 
 
         // #1 Create :  Add AddRange
-        public abstract Entity Add<Entity>(Entity entity);
-        public abstract void AddRange<Entity>(IEnumerable<Entity> entities);
+        public virtual Entity Add<Entity>(Entity entity) => DbSet<Entity>().Add(entity);
+        public virtual void AddRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().AddRange(entities);
 
-        // #2 Retrieve : Get Query
-        public abstract Entity Get<Entity>(object keyValue);
-        public abstract IQueryable<Entity> Query<Entity>();
+
+        // #2 Retrieve : Get
+        public virtual Entity Get<Entity>(object keyValue) => DbSet<Entity>().Get(keyValue);
+        public virtual IQueryable<Entity> Query<Entity>() => DbSet<Entity>().Query();
 
 
         // #3 Update: Update UpdateRange
-        public abstract int Update<Entity>(Entity entity);
-        public abstract int UpdateRange<Entity>(IEnumerable<Entity> entities);
+        public virtual int Update<Entity>(Entity entity) => DbSet<Entity>().Update(entity);
+        public virtual int UpdateRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().UpdateRange(entities);
 
 
         // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public abstract int Delete<Entity>(Entity entity);
-        public abstract int DeleteRange<Entity>(IEnumerable<Entity> entities);
+        public virtual int Delete<Entity>(Entity entity) => DbSet<Entity>().Delete(entity);
+        public virtual int DeleteRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().DeleteRange(entities);
 
+        public virtual int DeleteByKey<Entity>(object keyValue) => DbSet<Entity>().DeleteByKey(keyValue);
+        public virtual int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys) => DbSet<Entity>().DeleteByKeys<Key>(keys);
 
-        public abstract int DeleteByKey<Entity>(object keyValue);
-        public abstract int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys);
+        #endregion
 
 
 
+        #region Async Method
+
+        // #0 Schema :  Create Drop Truncate
+        public virtual Task TryCreateTableAsync<Entity>() => DbSet<Entity>().TryCreateTableAsync();
+        public virtual Task TryDropTableAsync<Entity>() => DbSet<Entity>().TryDropTableAsync();
+        public virtual Task TruncateAsync<Entity>() => DbSet<Entity>().TruncateAsync();
+
+
+        // #1 Create :  Add AddRange
+        public virtual Task<Entity> AddAsync<Entity>(Entity entity) => DbSet<Entity>().AddAsync(entity);
+        public virtual Task AddRangeAsync<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().AddRangeAsync(entities);
+
+
+
+        // #2 Retrieve : Get Query
+        public virtual Task<Entity> GetAsync<Entity>(object keyValue) => DbSet<Entity>().GetAsync(keyValue);
+
+
+        // #3 Update: Update UpdateRange
+        public virtual Task<int> UpdateAsync<Entity>(Entity entity) => DbSet<Entity>().UpdateAsync(entity);
+        public virtual Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().UpdateRangeAsync(entities);
+
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        public virtual Task<int> DeleteAsync<Entity>(Entity entity) => DbSet<Entity>().DeleteAsync(entity);
+        public virtual Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().DeleteRangeAsync(entities);
+
+        public virtual Task<int> DeleteByKeyAsync<Entity>(object keyValue) => DbSet<Entity>().DeleteByKeyAsync(keyValue);
+        public virtual Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys) => DbSet<Entity>().DeleteByKeysAsync<Key>(keys);
+        #endregion
+
 
 
     }

src/Vitorm/DbSet.cs

@@ -2,22 +2,23 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 
 using Vitorm.Entity;
 
 namespace Vitorm
 {
-    public class DbSetConstructor
+    public class DefaultDbSetConstructor
     {
-        public static IDbSet CreateDbSet(DbContext dbContext, IEntityDescriptor entityDescriptor)
+        public static IDbSet CreateDbSet(IDbContext dbContext, IEntityDescriptor entityDescriptor)
         {
             return _CreateDbSet.MakeGenericMethod(entityDescriptor.entityType)
                      .Invoke(null, new object[] { dbContext, entityDescriptor }) as IDbSet;
         }
 
-        static readonly MethodInfo _CreateDbSet = new Func<DbContext, IEntityDescriptor, IDbSet>(CreateDbSet<object>)
+        static readonly MethodInfo _CreateDbSet = new Func<IDbContext, IEntityDescriptor, IDbSet>(CreateDbSet<object>)
                    .Method.GetGenericMethodDefinition();
-        public static IDbSet<Entity> CreateDbSet<Entity>(DbContext dbContext, IEntityDescriptor entityDescriptor)
+        public static IDbSet<Entity> CreateDbSet<Entity>(IDbContext dbContext, IEntityDescriptor entityDescriptor)
         {
             return new DbSet<Entity>(dbContext, entityDescriptor);
         }
@@ -27,13 +28,13 @@ namespace Vitorm
 
     public partial class DbSet<Entity> : IDbSet<Entity>
     {
-        public virtual DbContext dbContext { get; protected set; }
+        public virtual IDbContext dbContext { get; protected set; }
 
         protected IEntityDescriptor _entityDescriptor;
         public virtual IEntityDescriptor entityDescriptor => _entityDescriptor;
 
 
-        public DbSet(DbContext dbContext, IEntityDescriptor entityDescriptor)
+        public DbSet(IDbContext dbContext, IEntityDescriptor entityDescriptor)
         {
             this.dbContext = dbContext;
             this._entityDescriptor = entityDescriptor;
@@ -44,6 +45,9 @@ namespace Vitorm
         public virtual IEntityDescriptor ChangeTableBack() => _entityDescriptor = _entityDescriptor.GetOriginEntityDescriptor();
 
 
+
+        #region Sync Method
+
         // #0 Schema :  Create Drop
         public virtual void TryCreateTable() => dbContext.TryCreateTable<Entity>();
         public virtual void TryDropTable() => dbContext.TryDropTable<Entity>();
@@ -72,5 +76,42 @@ namespace Vitorm
         public virtual int DeleteByKeys<Key>(IEnumerable<Key> keys) => dbContext.DeleteByKeys<Entity, Key>(keys);
 
 
+        #endregion
+
+
+
+
+
+        #region Async
+
+
+        // #0 Schema :  Create Drop Truncate
+        public virtual Task TryCreateTableAsync() => dbContext.TryCreateTableAsync<Entity>();
+        public virtual Task TryDropTableAsync() => dbContext.TryDropTableAsync<Entity>();
+        public virtual Task TruncateAsync() => dbContext.TruncateAsync<Entity>();
+
+
+        // #1 Create :  Add AddRange
+        public virtual Task<Entity> AddAsync(Entity entity) => dbContext.AddAsync<Entity>(entity);
+        public virtual Task AddRangeAsync(IEnumerable<Entity> entities) => dbContext.AddRangeAsync<Entity>(entities);
+
+
+        // #2 Retrieve : Get Query
+        public virtual Task<Entity> GetAsync(object keyValue) => dbContext.GetAsync<Entity>(keyValue);
+
+
+        // #3 Update: Update UpdateRange
+        public virtual Task<int> UpdateAsync(Entity entity) => dbContext.UpdateAsync<Entity>(entity);
+        public virtual Task<int> UpdateRangeAsync(IEnumerable<Entity> entities) => dbContext.UpdateRangeAsync<Entity>(entities);
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        public virtual Task<int> DeleteAsync(Entity entity) => dbContext.DeleteAsync<Entity>(entity);
+        public virtual Task<int> DeleteRangeAsync(IEnumerable<Entity> entities) => dbContext.DeleteRangeAsync<Entity>(entities);
+        public virtual Task<int> DeleteByKeyAsync(object keyValue) => dbContext.DeleteByKeyAsync<Entity>(keyValue);
+        public virtual Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys) => dbContext.DeleteByKeysAsync<Entity, Key>(keys);
+
+        #endregion
+
     }
 }

src/Vitorm/Extensions/Orm_Extensions/Orm_Extensions_ToExecuteString.cs

@@ -12,7 +12,7 @@ namespace Vitorm
     public static partial class Orm_Extensions
     {
         /// <summary>
-        /// if MySql or SqlServer or Sqlite , will get sql string
+        /// if RDBMS , will return sql string
         /// </summary>
         /// <param name="source"></param>
         /// <returns></returns>

src/Vitorm/IDbContext.cs

@@ -1,10 +1,13 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Vitorm
 {
     public partial interface IDbContext
     {
+        #region Sync Method
+
         // #0 Schema :  Create Drop
         void TryCreateTable<Entity>();
         void TryDropTable<Entity>();
@@ -31,5 +34,40 @@ namespace Vitorm
 
         int DeleteByKey<Entity>(object keyValue);
         int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys);
+
+        #endregion
+
+
+
+        #region Async Method
+
+        // #0 Schema :  Create Drop
+        Task TryCreateTableAsync<Entity>();
+        Task TryDropTableAsync<Entity>();
+        Task TruncateAsync<Entity>();
+
+
+        // #1 Create :  Add AddRange
+        Task<Entity> AddAsync<Entity>(Entity entity);
+        Task AddRangeAsync<Entity>(IEnumerable<Entity> entities);
+
+        // #2 Retrieve : Get Query
+        Task<Entity> GetAsync<Entity>(object keyValue);
+        //IQueryable<Entity> Query<Entity>();
+
+
+        // #3 Update: Update UpdateRange
+        Task<int> UpdateAsync<Entity>(Entity entity);
+        Task<int> UpdateRangeAsync<Entity>(IEnumerable<Entity> entities);
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        Task<int> DeleteAsync<Entity>(Entity entity);
+        Task<int> DeleteRangeAsync<Entity>(IEnumerable<Entity> entities);
+
+        Task<int> DeleteByKeyAsync<Entity>(object keyValue);
+        Task<int> DeleteByKeysAsync<Entity, Key>(IEnumerable<Key> keys);
+
+        #endregion
     }
 }

src/Vitorm/IDbSet.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 using Vitorm.Entity;
 
@@ -8,20 +9,35 @@ namespace Vitorm
     public partial interface IDbSet
     {
         IEntityDescriptor entityDescriptor { get; }
-        DbContext dbContext { get; }
+        IDbContext dbContext { get; }
+
+
+        #region Sync Method
 
         // #0 Schema :  ChangeTable
         IEntityDescriptor ChangeTable(string tableName);
         IEntityDescriptor ChangeTableBack();
 
-        // #0 Schema :  Create Drop
+        // #0 Schema :  Create Drop Truncate
         void TryCreateTable();
         void TryDropTable();
         void Truncate();
+        #endregion
+
+
+        #region Async Method
+
+        // #0 Schema :  Create Drop Truncate
+        Task TryCreateTableAsync();
+        Task TryDropTableAsync();
+        Task TruncateAsync();
+        #endregion
     }
 
     public partial interface IDbSet<Entity> : IDbSet
     {
+        #region Sync Method
+
         // #1 Create :  Add AddRange
         Entity Add(Entity entity);
         void AddRange(IEnumerable<Entity> entities);
@@ -41,7 +57,32 @@ namespace Vitorm
         int DeleteRange(IEnumerable<Entity> entities);
         int DeleteByKey(object keyValue);
         int DeleteByKeys<Key>(IEnumerable<Key> keys);
+        #endregion
+
+
+        #region Async Method
+
+        // #1 Create :  Add AddRange
+        Task<Entity> AddAsync(Entity entity);
+        Task AddRangeAsync(IEnumerable<Entity> entities);
+
+        // #2 Retrieve : Get Query
+        Task<Entity> GetAsync(object keyValue);
+        //IQueryable<Entity> Query();
+
+
+        // #3 Update: Update UpdateRange
+        Task<int> UpdateAsync(Entity entity);
+        Task<int> UpdateRangeAsync(IEnumerable<Entity> entities);
+
+
+        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
+        Task<int> DeleteAsync(Entity entity);
+        Task<int> DeleteRangeAsync(IEnumerable<Entity> entities);
+        Task<int> DeleteByKeyAsync(object keyValue);
+        Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys);
 
+        #endregion
 
     }
 }

src/Vitorm/Sql/SqlDbContext.Database.Execute.cs

@@ -1,76 +0,0 @@
-using System.Collections.Generic;
-using System.Data;
-
-namespace Vitorm.Sql
-{
-    public partial class SqlDbContext : DbContext
-    {
-
-        #region Execute
-        protected SqlExecutor sqlExecutor;
-        public static int? defaultCommandTimeout;
-        public int? commandTimeout;
-
-        public virtual int ExecuteWithTransaction(string sql, IDictionary<string, object> param = null, IDbTransaction transaction = null)
-        {
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-
-            return sqlExecutor.Execute(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-        }
-
-        public virtual int Execute(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            this.Event_OnExecuting(sql, param);
-
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return sqlExecutor.Execute(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return sqlExecutor.Execute(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-
-        public virtual IDataReader ExecuteReader(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            this.Event_OnExecuting(sql, param);
-
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return sqlExecutor.ExecuteReader(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return sqlExecutor.ExecuteReader(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-
-        public virtual object ExecuteScalar(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
-        {
-            this.Event_OnExecuting(sql, param);
-
-            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
-            var transaction = GetCurrentTransaction();
-
-            if (useReadOnly && transaction == null)
-            {
-                return sqlExecutor.ExecuteScalar(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
-            }
-            else
-            {
-                return sqlExecutor.ExecuteScalar(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
-            }
-        }
-        #endregion
-
-
-
-    }
-}

src/Vitorm/Sql/SqlDbContext.Database.Transaction.cs

@@ -1,25 +0,0 @@
-using System;
-using System.Data;
-
-using Vitorm.Sql.Transaction;
-
-namespace Vitorm.Sql
-{
-    public partial class SqlDbContext : DbContext
-    {
-
-        #region Transaction
-        public virtual Func<SqlDbContext, ITransactionScope> createTransactionScope { set; get; }
-                    = (dbContext) => new SqlTransactionScope(dbContext);
-        protected virtual ITransactionScope transactionScope { get; set; }
-
-        public virtual IDbTransaction BeginTransaction()
-        {
-            transactionScope ??= createTransactionScope(this);
-            return transactionScope.BeginTransaction();
-        }
-        public virtual IDbTransaction GetCurrentTransaction() => transactionScope?.GetCurrentTransaction();
-
-        #endregion
-    }
-}

src/Vitorm/Sql/SqlDbContext.Execute.cs

@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Threading.Tasks;
+
+using Vitorm.Sql.Transaction;
+
+namespace Vitorm.Sql
+{
+    public partial class SqlDbContext : DbContext
+    {
+        protected SqlExecutor sqlExecutor;
+        public static int? defaultCommandTimeout;
+        public int? commandTimeout;
+
+
+        #region Transaction
+        public virtual Func<SqlDbContext, ITransactionScope> createTransactionScope { set; get; }
+                    = (dbContext) => new SqlTransactionScope(dbContext);
+        protected virtual ITransactionScope transactionScope { get; set; }
+
+        public virtual IDbTransaction BeginTransaction()
+        {
+            transactionScope ??= createTransactionScope(this);
+            return transactionScope.BeginTransaction();
+        }
+        public virtual IDbTransaction GetCurrentTransaction() => transactionScope?.GetCurrentTransaction();
+
+        #endregion
+
+
+
+        #region Sync Method
+        public virtual int ExecuteWithTransaction(string sql, IDictionary<string, object> param = null, IDbTransaction transaction = null)
+        {
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+
+            return sqlExecutor.Execute(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+        }
+
+        public virtual int Execute(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            this.Event_OnExecuting(sql, param);
+
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return sqlExecutor.Execute(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return sqlExecutor.Execute(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        public virtual IDataReader ExecuteReader(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            this.Event_OnExecuting(sql, param);
+
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return sqlExecutor.ExecuteReader(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return sqlExecutor.ExecuteReader(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        public virtual object ExecuteScalar(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            this.Event_OnExecuting(sql, param);
+
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return sqlExecutor.ExecuteScalar(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return sqlExecutor.ExecuteScalar(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        #endregion
+
+
+
+        #region Async Method
+
+        public virtual async Task<int> ExecuteWithTransactionAsync(string sql, IDictionary<string, object> param = null, IDbTransaction transaction = null)
+        {
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+
+            return await sqlExecutor.ExecuteAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+        }
+
+        public virtual async Task<int> ExecuteAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return await sqlExecutor.ExecuteAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return await sqlExecutor.ExecuteAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        public virtual async Task<IDataReader> ExecuteReaderAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return await sqlExecutor.ExecuteReaderAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return await sqlExecutor.ExecuteReaderAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        public virtual async Task<object> ExecuteScalarAsync(string sql, IDictionary<string, object> param = null, int? commandTimeout = null, bool useReadOnly = false)
+        {
+            commandTimeout ??= this.commandTimeout ?? defaultCommandTimeout;
+            var transaction = GetCurrentTransaction();
+
+            if (useReadOnly && transaction == null)
+            {
+                return await sqlExecutor.ExecuteScalarAsync(readOnlyDbConnection, sql, param: param, commandTimeout: commandTimeout);
+            }
+            else
+            {
+                return await sqlExecutor.ExecuteScalarAsync(dbConnection, sql, param: param, transaction: transaction, commandTimeout: commandTimeout);
+            }
+        }
+
+        #endregion
+
+
+
+    }
+}

src/Vitorm/Sql/SqlDbContext.cs

@@ -1,26 +1,27 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Linq.Expressions;
 
 using Vit.Linq;
 
 using Vitorm.Entity;
 using Vitorm.Sql.DataReader.EntityReader;
 using Vitorm.Sql.SqlTranslate;
+using Vitorm.StreamQuery;
 
 namespace Vitorm.Sql
 {
     public partial class SqlDbContext : DbContext
     {
-        public SqlDbContext()
+        public SqlDbContext() : base(DefaultDbSetCreator)
         {
-            dbSetCreator = DefaultDbSetCreator;
         }
 
         #region DbSet
-        protected new IDbSet DefaultDbSetCreator(IEntityDescriptor entityDescriptor)
+        static IDbSet DefaultDbSetCreator(IDbContext dbContext, IEntityDescriptor entityDescriptor)
         {
-            return DbSetConstructor.CreateDbSet(this, entityDescriptor);
+            return SqlDbSetConstructor.CreateDbSet(dbContext, entityDescriptor);
         }
 
         #endregion
@@ -94,7 +95,7 @@ namespace Vitorm.Sql
         /// <summary>
         /// to identify whether contexts are from the same database
         /// </summary>
-        protected virtual string dbGroupName => "SqlDbSet_" + dbConnectionProvider.dbHashCode;
+        public virtual string dbGroupName => "SqlDbSet_" + dbConnectionProvider.dbHashCode;
         public virtual string databaseName => dbConnectionProvider.databaseName;
 
         public virtual void ChangeDatabase(string databaseName)
@@ -128,43 +129,25 @@ namespace Vitorm.Sql
         }
 
 
+        #region Query
+        public Action<SqlDbContext, Expression, Type, object> AfterQuery;
+        public virtual SqlDbContext AutoDisposeAfterQuery()
+        {
+            AfterQuery += (_, _, _, _) => Dispose();
+            return this;
+        }
 
 
-        // #0 Schema :  Create Drop
-        public override void TryCreateTable<Entity>() => DbSet<Entity>().TryCreateTable();
-        public override void TryDropTable<Entity>() => DbSet<Entity>().TryDropTable();
-        public override void Truncate<Entity>() => DbSet<Entity>().Truncate();
-
-
-        // #1 Create :  Add AddRange
-        public override Entity Add<Entity>(Entity entity) => DbSet<Entity>().Add(entity);
-        public override void AddRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().AddRange(entities);
-
-
-
-        // #2 Retrieve : Get
-        public override Entity Get<Entity>(object keyValue) => DbSet<Entity>().Get(keyValue);
-
-
-
-        // #3 Update: Update UpdateRange
-        public override int Update<Entity>(Entity entity) => DbSet<Entity>().Update(entity);
-
-        public override int UpdateRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().UpdateRange(entities);
-
-
-
-        // #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public override int Delete<Entity>(Entity entity) => DbSet<Entity>().Delete(entity);
-        public override int DeleteRange<Entity>(IEnumerable<Entity> entities) => DbSet<Entity>().DeleteRange(entities);
-
-        public override int DeleteByKey<Entity>(object keyValue) => DbSet<Entity>().DeleteByKey(keyValue);
-        public override int DeleteByKeys<Entity, Key>(IEnumerable<Key> keys) => DbSet<Entity>().DeleteByKeys<Key>(keys);
-
+        #region StreamReader
+        public static StreamReader defaultStreamReader = new StreamReader();
+        public StreamReader streamReader = defaultStreamReader;
+        #endregion
 
+        public bool query_ToListAndTotalCount_InvokeInOneExecute = true;
 
 
 
+        #endregion
 
 
 

src/Vitorm/Async/Sql/SqlDbSet.Async.cs → src/Vitorm/Sql/SqlDbSet.Async.cs

@@ -8,21 +8,21 @@ using Vitorm.Sql.SqlTranslate;
 
 namespace Vitorm.Sql
 {
-    public partial class SqlDbSet<Entity> : DbSet<Entity>
+    public partial class SqlDbSet<Entity>
     {
         #region #0 Schema :  Create Drop Truncate
-        public override async Task TryCreateTableAsync()
+        public virtual async Task TryCreateTableAsync()
         {
             string sql = sqlTranslateService.PrepareTryCreateTable(entityDescriptor);
             await sqlDbContext.ExecuteAsync(sql: sql);
         }
 
-        public override async Task TryDropTableAsync()
+        public virtual async Task TryDropTableAsync()
         {
             string sql = sqlTranslateService.PrepareTryDropTable(entityDescriptor);
             await sqlDbContext.ExecuteAsync(sql: sql);
         }
-        public override async Task TruncateAsync()
+        public virtual async Task TruncateAsync()
         {
             string sql = sqlTranslateService.PrepareTruncate(entityDescriptor);
             await sqlDbContext.ExecuteAsync(sql: sql);
@@ -31,7 +31,7 @@ namespace Vitorm.Sql
 
 
         #region #1 Create :  Add AddRange
-        public override async Task<Entity> AddAsync(Entity entity)
+        public virtual async Task<Entity> AddAsync(Entity entity)
         {
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
 
@@ -64,7 +64,7 @@ namespace Vitorm.Sql
             return entity;
         }
 
-        public override async Task AddRangeAsync(IEnumerable<Entity> entities)
+        public virtual async Task AddRangeAsync(IEnumerable<Entity> entities)
         {
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
             Dictionary<EAddType, (string sql, Func<object, Dictionary<string, object>> GetSqlParams)> sqlMaps = new();
@@ -108,7 +108,7 @@ namespace Vitorm.Sql
 
 
         #region #2 Retrieve : Get Query
-        public override async Task<Entity> GetAsync(object keyValue)
+        public virtual async Task<Entity> GetAsync(object keyValue)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -143,7 +143,7 @@ namespace Vitorm.Sql
         #endregion
 
         #region #3 Update: Update UpdateRange
-        public override async Task<int> UpdateAsync(Entity entity)
+        public virtual async Task<int> UpdateAsync(Entity entity)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -159,7 +159,7 @@ namespace Vitorm.Sql
 
             return affectedRowCount;
         }
-        public override async Task<int> UpdateRangeAsync(IEnumerable<Entity> entities)
+        public virtual async Task<int> UpdateRangeAsync(IEnumerable<Entity> entities)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -180,19 +180,19 @@ namespace Vitorm.Sql
         #endregion
 
         #region #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public override async Task<int> DeleteAsync(Entity entity)
+        public virtual async Task<int> DeleteAsync(Entity entity)
         {
             var key = entityDescriptor.key.GetValue(entity);
             return await DeleteByKeyAsync(key);
         }
 
-        public override async Task<int> DeleteRangeAsync(IEnumerable<Entity> entities)
+        public virtual async Task<int> DeleteRangeAsync(IEnumerable<Entity> entities)
         {
             var keys = entities.Select(entity => entityDescriptor.key.GetValue(entity)).ToList();
             return await DeleteByKeysAsync(keys);
         }
 
-        public override async Task<int> DeleteByKeyAsync(object keyValue)
+        public virtual async Task<int> DeleteByKeyAsync(object keyValue)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -210,7 +210,7 @@ namespace Vitorm.Sql
             return affectedRowCount;
         }
 
-        public override async Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys)
+        public virtual async Task<int> DeleteByKeysAsync<Key>(IEnumerable<Key> keys)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);

src/Vitorm/Sql/SqlDbContext.Query.cs → src/Vitorm/Sql/SqlDbSet.Query.cs

@@ -9,29 +9,20 @@ using Vit.Linq.ExpressionNodes.ComponentModel;
 using Vitorm.Sql.QueryExecutor;
 using Vitorm.StreamQuery;
 
-using StreamReader = Vitorm.StreamQuery.StreamReader;
-
 namespace Vitorm.Sql
 {
-    public partial class SqlDbContext : DbContext
+    public partial class SqlDbSet<Entity>
     {
-        public Action<SqlDbContext, Expression, Type, object> AfterQuery;
-        public virtual SqlDbContext AutoDisposeAfterQuery()
-        {
-            AfterQuery += (_, _, _, _) => Dispose();
-            return this;
-        }
 
-
-        public override IQueryable<Entity> Query<Entity>()
+        public virtual IQueryable<Entity> Query()
         {
-            return QueryableBuilder.Build<Entity>(QueryExecutor, dbGroupName);
+            return QueryableBuilder.Build<Entity>(QueryExecutor, sqlDbContext.dbGroupName);
         }
 
         protected object QueryExecutor(Expression expression, Type expressionResultType)
         {
             object result = null;
-            Action dispose = () => AfterQuery?.Invoke(this, expression, expressionResultType, result);
+            Action dispose = () => sqlDbContext.AfterQuery?.Invoke(sqlDbContext, expression, expressionResultType, result);
             try
             {
                 return result = ExecuteQuery(expression, expressionResultType, dispose);
@@ -43,6 +34,7 @@ namespace Vitorm.Sql
             }
         }
 
+
         #region QueryExecutor
 
         public static Dictionary<string, IQueryExecutor> defaultQueryExecutors = CreateDefaultQueryExecutors();
@@ -110,34 +102,27 @@ namespace Vitorm.Sql
         #endregion
 
 
-        #region StreamReader
-        public static StreamReader defaultStreamReader = new StreamReader();
-        public StreamReader streamReader = defaultStreamReader;
-        #endregion
-
-
-        public bool query_ToListAndTotalCount_InvokeInOneExecute = true;
-
         protected virtual bool QueryIsFromSameDb(object obj, Type elementType)
         {
             if (obj is not IQueryable query) return false;
 
-            if (dbGroupName == QueryableBuilder.GetQueryConfig(query) as string) return true;
+            if (sqlDbContext.dbGroupName == QueryableBuilder.GetQueryConfig(query) as string) return true;
 
             if (QueryableBuilder.BuildFrom(query))
                 throw new InvalidOperationException("not allow query from different data source , queryable type: " + obj?.GetType().FullName);
 
             return false;
         }
+
         protected virtual object ExecuteQuery(Expression expression, Type expressionResultType, Action dispose)
         {
             // #1 convert to ExpressionNode 
-            ExpressionNode_Lambda node = convertService.ConvertToData_LambdaNode(expression, autoReduce: true, isArgument: QueryIsFromSameDb);
+            ExpressionNode_Lambda node = sqlDbContext.convertService.ConvertToData_LambdaNode(expression, autoReduce: true, isArgument: QueryIsFromSameDb);
             //var strNode = Json.Serialize(node);
 
 
             // #2 convert to Stream
-            var stream = streamReader.ReadFromNode(node);
+            var stream = sqlDbContext.streamReader.ReadFromNode(node);
             //var strStream = Json.Serialize(stream);
 
             if (stream is not CombinedStream combinedStream) combinedStream = new CombinedStream("tmp") { source = stream };
@@ -145,7 +130,7 @@ namespace Vitorm.Sql
             var executorArg = new QueryExecutorArgument
             {
                 combinedStream = combinedStream,
-                dbContext = this,
+                dbContext = sqlDbContext,
                 expression = expression,
                 expressionResultType = expressionResultType,
                 dispose = dispose,

src/Vitorm/Sql/SqlDbSet.cs

@@ -8,9 +8,9 @@ using Vitorm.Sql.SqlTranslate;
 
 namespace Vitorm.Sql
 {
-    public class DbSetConstructor
+    public class SqlDbSetConstructor
     {
-        public static IDbSet CreateDbSet(SqlDbContext dbContext, IEntityDescriptor entityDescriptor)
+        public static IDbSet CreateDbSet(IDbContext dbContext, IEntityDescriptor entityDescriptor)
         {
             return _CreateDbSet.MakeGenericMethod(entityDescriptor.entityType)
                      .Invoke(null, new object[] { dbContext, entityDescriptor }) as IDbSet;
@@ -26,29 +26,41 @@ namespace Vitorm.Sql
     }
 
 
-    public partial class SqlDbSet<Entity> : DbSet<Entity>
+    public partial class SqlDbSet<Entity> : IDbSet<Entity>
     {
+        public virtual IDbContext dbContext { get; protected set; }
+
+        protected IEntityDescriptor _entityDescriptor;
+        public virtual IEntityDescriptor entityDescriptor => _entityDescriptor;
 
-        public virtual SqlDbContext sqlDbContext => (SqlDbContext)dbContext;
 
-        public SqlDbSet(SqlDbContext dbContext, IEntityDescriptor entityDescriptor) : base(dbContext, entityDescriptor)
+        public SqlDbSet(DbContext dbContext, IEntityDescriptor entityDescriptor)
         {
+            this.dbContext = dbContext;
+            this._entityDescriptor = entityDescriptor;
         }
 
+        // #0 Schema :  ChangeTable
+        public virtual IEntityDescriptor ChangeTable(string tableName) => _entityDescriptor = _entityDescriptor.WithTable(tableName);
+        public virtual IEntityDescriptor ChangeTableBack() => _entityDescriptor = _entityDescriptor.GetOriginEntityDescriptor();
+
+
+        public virtual SqlDbContext sqlDbContext => (SqlDbContext)dbContext;
+
         protected virtual ISqlTranslateService sqlTranslateService => sqlDbContext.sqlTranslateService;
 
         #region #0 Schema :  Create Drop Truncate
-        public override void TryCreateTable()
+        public virtual void TryCreateTable()
         {
             string sql = sqlTranslateService.PrepareTryCreateTable(entityDescriptor);
             sqlDbContext.Execute(sql: sql);
         }
-        public override void TryDropTable()
+        public virtual void TryDropTable()
         {
             string sql = sqlTranslateService.PrepareTryDropTable(entityDescriptor);
             sqlDbContext.Execute(sql: sql);
         }
-        public override void Truncate()
+        public virtual void Truncate()
         {
             string sql = sqlTranslateService.PrepareTruncate(entityDescriptor);
             sqlDbContext.Execute(sql: sql);
@@ -57,7 +69,7 @@ namespace Vitorm.Sql
 
 
         #region #1 Create :  Add AddRange
-        public override Entity Add(Entity entity)
+        public virtual Entity Add(Entity entity)
         {
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
 
@@ -89,7 +101,7 @@ namespace Vitorm.Sql
 
             return entity;
         }
-        public override void AddRange(IEnumerable<Entity> entities)
+        public virtual void AddRange(IEnumerable<Entity> entities)
         {
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
             Dictionary<EAddType, (string sql, Func<object, Dictionary<string, object>> GetSqlParams)> sqlMaps = new();
@@ -133,7 +145,7 @@ namespace Vitorm.Sql
 
 
         #region #2 Retrieve : Get Query
-        public override Entity Get(object keyValue)
+        public virtual Entity Get(object keyValue)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -162,11 +174,10 @@ namespace Vitorm.Sql
             return default;
 
         }
-        public override IQueryable<Entity> Query() => dbContext.Query<Entity>();
         #endregion
 
         #region #3 Update: Update UpdateRange
-        public override int Update(Entity entity)
+        public virtual int Update(Entity entity)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -182,7 +193,7 @@ namespace Vitorm.Sql
 
             return affectedRowCount;
         }
-        public override int UpdateRange(IEnumerable<Entity> entities)
+        public virtual int UpdateRange(IEnumerable<Entity> entities)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -203,19 +214,19 @@ namespace Vitorm.Sql
         #endregion
 
         #region #4 Delete : Delete DeleteRange DeleteByKey DeleteByKeys
-        public override int Delete(Entity entity)
+        public virtual int Delete(Entity entity)
         {
             var key = entityDescriptor.key.GetValue(entity);
             return DeleteByKey(key);
         }
 
-        public override int DeleteRange(IEnumerable<Entity> entities)
+        public virtual int DeleteRange(IEnumerable<Entity> entities)
         {
             var keys = entities.Select(entity => entityDescriptor.key.GetValue(entity)).ToList();
             return DeleteByKeys(keys);
         }
 
-        public override int DeleteByKey(object keyValue)
+        public virtual int DeleteByKey(object keyValue)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);
@@ -233,7 +244,7 @@ namespace Vitorm.Sql
             return affectedRowCount;
         }
 
-        public override int DeleteByKeys<Key>(IEnumerable<Key> keys)
+        public virtual int DeleteByKeys<Key>(IEnumerable<Key> keys)
         {
             // #0 get arg
             SqlTranslateArgument arg = new SqlTranslateArgument(sqlDbContext, entityDescriptor);

test/IssuesTest/Vitorm.MsTest.Issue000_099/Issues/Issue_005_Test.cs

@@ -63,7 +63,7 @@ namespace Vitorm.MsTest.Issue000_099.Issues
             }
             {
                 var query = dbSet.Query().Where(m => m.isEven.Value).OrderBy(m => m.isEven).Select(m => new { m.id, m.isEven });
-                var sql = query.ToExecuteString();
+
                 var users = query.ToList();
                 var user = users.First();
                 Assert.AreEqual(2, user.id);

test/Vitorm.Data.Console/Program.cs

@@ -23,7 +23,7 @@ namespace App
             {
                 var user = Data.Get<User>(1);
                 var users = Data.Query<User>().Where(u => u.name.Contains("li")).ToList();
-                var sql = Data.Query<User>().Where(u => u.name.Contains("li")).ToExecuteString();
+                //var sql = Data.Query<User>().Where(u => u.name.Contains("li")).ToExecuteString();
             }
 
             // #5 Update Records
@@ -56,7 +56,6 @@ namespace App
                         orderby user.id
                         select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var users = query.ToList();
             }
 
@@ -92,7 +91,6 @@ namespace App
             {
                 // select * from User where IIF(t0.fatherId is not null, true, false);
                 var query = Data.Query<User>().Where(u => DbFunction.Call<bool>("IIF", u.fatherId != null, true, false));
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
             }
         }

test/Vitorm.MySql.MsTest/CustomTest/DatabaseSchemaName_Test.cs

@@ -1,6 +1,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace Vitorm.MsTest.CommonTest
+namespace Vitorm.MsTest.CustomTest
 {
 
     [TestClass]

test/Vitorm.MySql.MsTest/CustomTest/DbFunction_Test.cs

@@ -18,7 +18,7 @@ namespace Vitorm.MsTest.CustomTest
             // select IF(500<1000,true,false)
             {
                 var query = userQuery.Where(u => DbFunction.Call<bool>("IF", u.fatherId != null, true, false));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(3, userList.Last().id);
@@ -26,7 +26,7 @@ namespace Vitorm.MsTest.CustomTest
 
             {
                 var query = userQuery.Where(u => u.birth < DbFunction.Call<DateTime>("now"));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
             }
@@ -34,7 +34,7 @@ namespace Vitorm.MsTest.CustomTest
             // coalesce(parameter1,parameter2, …)
             {
                 var query = userQuery.Where(u => DbFunction.Call<int?>("coalesce", u.fatherId, u.motherId) != null);
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(1, userList.First().id);

test/Vitorm.MySql.MsTest/CustomTest/Property_Guid_Test.cs

@@ -2,7 +2,7 @@
 
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace Vitorm.MsTest.CommonTest
+namespace Vitorm.MsTest.CustomTest
 {
     /// <summary>
     /// https://www.damirscorner.com/blog/posts/20240223-GuidValuesInMySqlWithEfCore.html

test/Vitorm.SqlServer.MsTest/CustomTest/DbFunction_Test.cs

@@ -18,7 +18,7 @@ namespace Vitorm.MsTest.CustomTest
             // select * from [User] where IIF(userFatherId is not null, 1, 0) = 1 
             {
                 var query = userQuery.Where(u => DbFunction.Call<int>("IIF", u.fatherId != null, 1, 0) == 1);
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(3, userList.Last().id);
@@ -26,7 +26,7 @@ namespace Vitorm.MsTest.CustomTest
 
             {
                 var query = userQuery.Where(u => u.birth < DbFunction.Call<DateTime>("GETDATE"));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
             }
@@ -34,7 +34,7 @@ namespace Vitorm.MsTest.CustomTest
             // coalesce(parameter1,parameter2, …)
             {
                 var query = userQuery.Where(u => DbFunction.Call<int?>("coalesce", u.fatherId, u.motherId) != null);
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(1, userList.First().id);

test/Vitorm.Sqlite.Console/Program.cs

@@ -25,7 +25,6 @@ namespace App
             {
                 var user = dbContext.Get<User>(1);
                 var users = dbContext.Query<User>().Where(u => u.name.Contains("li")).ToList();
-                var sql = dbContext.Query<User>().Where(u => u.name.Contains("li")).ToExecuteString();
             }
 
             // #5 Update Records
@@ -58,7 +57,6 @@ namespace App
                         orderby user.id
                         select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var users = query.ToList();
             }
 
@@ -92,7 +90,6 @@ namespace App
             {
                 // select * from User where IIF(t0.fatherId is not null, true, false);
                 var query = dbContext.Query<User>().Where(u => DbFunction.Call<bool>("IIF", u.fatherId != null, true, false));
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
             }
         }

test/Vitorm.Sqlite.MsTest/CommonTest/EntityLoader_CustomLoader_Test.cs

@@ -29,7 +29,6 @@ namespace Vitorm.MsTest.CommonTest
             // #1 EntityLoaderAttribute
             {
                 var users = dbContext.Query<CustomUser2>().Where(m => m.name == "u146").ToList();
-                var sql = dbContext.Query<CustomUser2>().Where(m => m.name == "u146").ToExecuteString();
                 Assert.AreEqual(1, users.Count());
                 Assert.AreEqual(1, users[0].id);
             }

test/Vitorm.Sqlite.MsTest/CommonTest/Event_Test.cs

@@ -1,7 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-using Vit.Linq;
-
 namespace Vitorm.MsTest.CommonTest
 {
 
@@ -73,17 +71,17 @@ namespace Vitorm.MsTest.CommonTest
                 var result = dbContext.Query<User>().Count();
             }
             using (assertDisposable = new())
-            {
-                var result = dbContext.Query<User>().ToExecuteString();
-            }
-            using (assertDisposable = new())
             {
                 var result = dbContext.Query<User>().FirstOrDefault();
             }
-            using (assertDisposable = new())
-            {
-                var result = dbContext.Query<User>().ToListAndTotalCount();
-            }
+            //using (assertDisposable = new())
+            //{
+            //    var result = dbContext.Query<User>().ToExecuteString();
+            //}
+            //using (assertDisposable = new())
+            //{
+            //    var result = dbContext.Query<User>().ToListAndTotalCount();
+            //}
 
         }
 

test/Vitorm.Sqlite.MsTest/CommonTest/Property_Bool_Test.cs

@@ -65,7 +65,6 @@ namespace Vitorm.MsTest.CommonTest
             }
             {
                 var query = dbSet.Query().Where(m => m.isEven.Value).OrderBy(m => m.isEven).Select(m => new { m.id, m.isEven });
-                var sql = query.ToExecuteString();
                 var users = query.ToList();
                 var user = users.First();
                 Assert.AreEqual(2, user.id);

test/Vitorm.Sqlite.MsTest/CommonTest/Property_String_Like_Test.cs

@@ -18,7 +18,7 @@ namespace Vitorm.MsTest.CommonTest
             // StartsWith
             {
                 var query = userQuery.Where(u => u.name.StartsWith("u35"));
-                //var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(1, userList.Count);
                 Assert.AreEqual(3, userList.First().id);
@@ -27,7 +27,7 @@ namespace Vitorm.MsTest.CommonTest
             // EndsWith
             {
                 var query = userQuery.Where(u => u.name.EndsWith("356"));
-                //var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(1, userList.Count);
                 Assert.AreEqual(3, userList.First().id);
@@ -36,7 +36,7 @@ namespace Vitorm.MsTest.CommonTest
             // Contains
             {
                 var query = userQuery.Where(u => u.name.Contains("35"));
-                //var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(1, userList.Count);
                 Assert.AreEqual(3, userList.First().id);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_Count_Test.cs

@@ -217,8 +217,6 @@ namespace Vitorm.MsTest.CommonTest
             if (config?.skip.HasValue == true) query = query.Skip(config.skip.Value);
             if (config?.take.HasValue == true) query = query.Take(config.take.Value);
 
-            var sql = query.ToExecuteString();
-
             var rows = query.ToList();
             int expectedCount = rows.Count;
 

test/Vitorm.Sqlite.MsTest/CommonTest/Query_Distinct_Test.cs

@@ -18,7 +18,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.Select(u => u.fatherId).Distinct();
 
-                //var sql = query.ToExecuteString();
                 var fatherIds = query.ToList();
 
                 Assert.AreEqual(3, fatherIds.Count);
@@ -27,7 +26,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.Select(u => new { u.fatherId }).Distinct();
 
-                //var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 var fatherIds = userList.Select(u => u.fatherId).ToList();
 
@@ -39,7 +37,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(100);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 var fatherIds = userList.Select(u => u.fatherId).ToList();
                 var motherIds = userList.Select(u => u.motherId).ToList();
@@ -51,7 +48,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.Select(u => new { user = u, u.fatherId, u.motherId }).Distinct();
 
-                //var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(6, userList.Count);
@@ -59,7 +55,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.Distinct();
 
-                //var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(6, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_Group_Test.cs

@@ -22,7 +22,6 @@ namespace Vitorm.MsTest.CommonTest
                         group user by new { user.fatherId, user.motherId } into userGroup
                         select new { userGroup.Key.fatherId, userGroup.Key.motherId };
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
 
                 Assert.AreEqual(3, rows.Count);
@@ -42,7 +41,6 @@ namespace Vitorm.MsTest.CommonTest
                         })
                         ;
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
 
                 Assert.AreEqual(3, rows.Count);
@@ -69,7 +67,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
 
                 Assert.AreEqual(1, rows.Count);
@@ -98,7 +95,6 @@ namespace Vitorm.MsTest.CommonTest
                         .Take(1)
                         ;
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
 
                 Assert.AreEqual(1, rows.Count);
@@ -135,7 +131,6 @@ namespace Vitorm.MsTest.CommonTest
                     })
                     ;
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
 
                 Assert.AreEqual(3, rows.Count);
@@ -156,7 +151,6 @@ namespace Vitorm.MsTest.CommonTest
                     ;
 
                 var rows = query.ToList();
-                var sql = query.ToExecuteString();
 
                 Assert.AreEqual(2, rows.Count);
                 Assert.AreEqual(5, rows[0].fatherId);
@@ -171,7 +165,6 @@ namespace Vitorm.MsTest.CommonTest
                     ;
 
                 var rows = query.ToList();
-                var sql = query.ToExecuteString();
 
                 Assert.AreEqual(2, rows.Count);
                 Assert.AreEqual(5, rows[0].fatherId);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_InnerJoin_ByJoin_Test.cs

@@ -23,7 +23,6 @@ namespace Vitorm.MsTest.CommonTest
                     where user.id > 2
                     select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -41,7 +40,6 @@ namespace Vitorm.MsTest.CommonTest
                     .Where(row => row.user.id > 2)
                     .Select(row => new { row.user, row.father });
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -76,7 +74,6 @@ namespace Vitorm.MsTest.CommonTest
                     };
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -118,7 +115,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -150,7 +146,6 @@ namespace Vitorm.MsTest.CommonTest
                         , (user, father) => new { user, father }
                     );
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(3, userList.Count);
@@ -167,7 +162,6 @@ namespace Vitorm.MsTest.CommonTest
                         , (user, father) => new { user, father }
                     ).Where(row => row.user.id > 2);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -184,7 +178,6 @@ namespace Vitorm.MsTest.CommonTest
                     ).Where(row => row.user.id > 2)
                     .Select(row => new { userId = row.user.id, fatherId = row.father.id });
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -202,7 +195,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_InnerJoin_BySelectMany_Test.cs

@@ -23,7 +23,6 @@ namespace Vitorm.MsTest.CommonTest
                     where user.id > 2
                     select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -41,7 +40,6 @@ namespace Vitorm.MsTest.CommonTest
                     .Where(row => row.user.id > 2)
                     .Select(row => new { row.user, row.father });
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -75,7 +73,6 @@ namespace Vitorm.MsTest.CommonTest
                     };
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -113,7 +110,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(1);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(1, userList.Count);
@@ -178,7 +174,6 @@ namespace Vitorm.MsTest.CommonTest
                                 motherName = mother.name,
                             };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(2, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_LeftJoin_ByGroupJoin_Test.cs

@@ -23,7 +23,6 @@ namespace Vitorm.MsTest.CommonTest
                     orderby user.id
                     select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -50,7 +49,6 @@ namespace Vitorm.MsTest.CommonTest
                     .OrderBy(row2 => row2.row.user.id)
                     .Select(row2 => new { row2.row.user, row2.father });
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -89,7 +87,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(2);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(2, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_LeftJoin_BySelectMany_Test.cs

@@ -29,7 +29,6 @@ namespace Vitorm.MsTest.CommonTest
                         .OrderBy(row => row.user.id)
                         .Select(row => new { row.user, row.father });
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -70,7 +69,6 @@ namespace Vitorm.MsTest.CommonTest
 
                 query = query.Skip(1).Take(2);
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(2, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_Method_Test.cs

@@ -57,7 +57,6 @@ namespace Vitorm.MsTest.CommonTest
                              })
                             .Skip(1).Take(2);
 
-                //var sql = query.ToExecuteString();
                 var list = query.ToList();
 
                 Assert.AreEqual(2, list.Count);
@@ -134,8 +133,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.OrderByDescending(user => user.id);
 
-                //var sql = query.ToExecuteString();
-
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
                 Assert.AreEqual(6, userList[0].id);
@@ -144,8 +141,6 @@ namespace Vitorm.MsTest.CommonTest
             {
                 var query = userQuery.OrderByDescending(user => user.id).Select(user => new { fid = user.fatherId, user.id });
 
-                //var sql = query.ToExecuteString();
-
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
                 Assert.AreEqual(6, userList[0].id);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_ScopeParam_LeftJoin_Test.cs

@@ -27,7 +27,6 @@ namespace Vitorm.MsTest.CommonTest
                         orderby user.id
                         select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -47,7 +46,6 @@ namespace Vitorm.MsTest.CommonTest
                         orderby user.id
                         select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -71,7 +69,6 @@ namespace Vitorm.MsTest.CommonTest
                         orderby user.id
                         select new { user, father };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_ScopeParam_Test.cs

@@ -26,7 +26,6 @@ namespace Vitorm.MsTest.CommonTest
                         orderby user.id
                         select new { user };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -43,7 +42,6 @@ namespace Vitorm.MsTest.CommonTest
                         orderby user.id
                         select new { user };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);
@@ -64,7 +62,6 @@ namespace Vitorm.MsTest.CommonTest
                 orderby user.id
                 select new { user };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
 
                 Assert.AreEqual(4, userList.Count);

test/Vitorm.Sqlite.MsTest/CommonTest/Query_Select_Test.cs

@@ -62,7 +62,6 @@ namespace Vitorm.MsTest.CommonTest
                         trueValue = true,
                     };
 
-                var sql = query.ToExecuteString();
                 var rows = query.ToList();
             }
 
@@ -77,7 +76,7 @@ namespace Vitorm.MsTest.CommonTest
                         uniqueId1 = user.id + "_" + user.fatherId + "_" + user.motherId,
                         uniqueId2 = $"{user.id}_{user.fatherId}_{user.motherId}"
                     };
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
                 Assert.AreEqual("1_4_6", userList[0].uniqueId1);
@@ -106,7 +105,6 @@ namespace Vitorm.MsTest.CommonTest
                     select new User2(user.id)
                     ;
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 Assert.AreEqual(5, userList.Count);
 
@@ -120,7 +118,6 @@ namespace Vitorm.MsTest.CommonTest
                     select new User2(user.name)
                     ;
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 Assert.AreEqual(5, userList.Count);
             }
@@ -137,7 +134,6 @@ namespace Vitorm.MsTest.CommonTest
                     }
                     ;
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 Assert.AreEqual(5, userList.Count);
 
@@ -154,7 +150,6 @@ namespace Vitorm.MsTest.CommonTest
                         fatherId = 12,
                     };
 
-                var sql = query.ToExecuteString();
                 var userList = query.ToList();
                 Assert.AreEqual(5, userList.Count);
             }

test/Vitorm.Sqlite.MsTest/CustomTest/DbFunction_Test.cs

@@ -18,7 +18,7 @@ namespace Vitorm.MsTest.CustomTest
             // select * from `User` as t0  where IIF(`t0`.`fatherId` is not null, true, false )
             {
                 var query = userQuery.Where(u => DbFunction.Call<bool>("IIF", u.fatherId != null, true, false));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(3, userList.Last().id);
@@ -26,14 +26,14 @@ namespace Vitorm.MsTest.CustomTest
 
             {
                 var query = userQuery.Where(u => u.birth == DbFunction.Call<DateTime?>("datetime", "2021-01-01 00:00:00", "+2 hours"));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(1, userList.Count);
                 Assert.AreEqual(2, userList.First().id);
             }
             {
                 var query = userQuery.Where(u => u.birth == DbFunction.Call<DateTime>("datetime", "2021-01-01 00:00:00", "+" + u.id + " hours"));
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(6, userList.Count);
                 Assert.AreEqual(1, userList.First().id);
@@ -42,7 +42,7 @@ namespace Vitorm.MsTest.CustomTest
             // coalesce(parameter1,parameter2, …)
             {
                 var query = userQuery.Where(u => DbFunction.Call<int?>("coalesce", u.fatherId, u.motherId) != null);
-                var sql = query.ToExecuteString();
+
                 var userList = query.ToList();
                 Assert.AreEqual(3, userList.Count);
                 Assert.AreEqual(1, userList.First().id);