rename PrepareCreate to PrepareTryCreateTable

rename PrepareDrop to PrepareTryDropTable
move Dictionary<string, object> sqlParam to SqlTranslateArgument or QueryTranslateArgument

src/Vitorm.MySql/SqlTranslateService.cs

@@ -171,7 +171,7 @@ namespace Vitorm.MySql
 
 
         #region PrepareCreate
-        public override string PrepareCreate(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryCreateTable(IEntityDescriptor entityDescriptor)
         {
             /* //sql
 CREATE TABLE user (
@@ -229,7 +229,7 @@ CREATE TABLE {DelimitTableName(entityDescriptor)} (
         }
         #endregion
 
-        public override string PrepareDrop(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryDropTable(IEntityDescriptor entityDescriptor)
         {
             // DROP TABLE if exists `User`;
             return $@" DROP TABLE if exists {DelimitTableName(entityDescriptor)};";

src/Vitorm.SqlServer/SqlTranslateService.cs

@@ -195,7 +195,7 @@ namespace Vitorm.SqlServer
 
 
         #region PrepareCreate
-        public override string PrepareCreate(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryCreateTable(IEntityDescriptor entityDescriptor)
         {
             /* //sql
 if object_id(N'[dbo].[User]', N'U') is null
@@ -254,7 +254,7 @@ CREATE TABLE {DelimitTableName(entityDescriptor)} (
         }
         #endregion
 
-        public override string PrepareDrop(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryDropTable(IEntityDescriptor entityDescriptor)
         {
             // IF OBJECT_ID(N'User', N'U') IS NOT NULL  DROP TABLE [User];
             var tableName = DelimitTableName(entityDescriptor);

src/Vitorm.Sqlite/SqlTranslateService.cs

@@ -152,7 +152,7 @@ namespace Vitorm.Sqlite
 
 
         #region PrepareCreate
-        public override string PrepareCreate(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryCreateTable(IEntityDescriptor entityDescriptor)
         {
             /* //sql
 CREATE TABLE user (
@@ -203,7 +203,7 @@ CREATE TABLE {DelimitTableName(entityDescriptor)} (
         }
         #endregion
 
-        public override string PrepareDrop(IEntityDescriptor entityDescriptor)
+        public override string PrepareTryDropTable(IEntityDescriptor entityDescriptor)
         {
             // DROP TABLE if exists "User";
             return $@" DROP TABLE if exists {DelimitTableName(entityDescriptor)};";

src/Vitorm/Sql/SqlDbContext.cs

@@ -123,7 +123,7 @@ namespace Vitorm.Sql
             // #0 get arg
             var entityDescriptor = GetEntityDescriptor(typeof(Entity));
 
-            string sql = sqlTranslateService.PrepareCreate(entityDescriptor);
+            string sql = sqlTranslateService.PrepareTryCreateTable(entityDescriptor);
             Execute(sql: sql);
         }
         public override void TryDropTable<Entity>()
@@ -131,7 +131,7 @@ namespace Vitorm.Sql
             // #0 get arg
             var entityDescriptor = GetEntityDescriptor(typeof(Entity));
 
-            string sql = sqlTranslateService.PrepareDrop(entityDescriptor);
+            string sql = sqlTranslateService.PrepareTryDropTable(entityDescriptor);
             Execute(sql: sql);
         }
         #endregion
@@ -330,9 +330,9 @@ namespace Vitorm.Sql
                 var resultEntityType = streamToUpdate.fieldsToUpdate.New_GetType();
                 var arg = new QueryTranslateArgument(this, resultEntityType);
 
-                (string sql, Dictionary<string, object> sqlParam) = sqlTranslateService.PrepareExecuteUpdate(arg, streamToUpdate);
+                var sql = sqlTranslateService.PrepareExecuteUpdate(arg, streamToUpdate);
 
-                return Execute(sql: sql, param: sqlParam);
+                return Execute(sql: sql, param: arg.sqlParam);
             }
 
 
@@ -350,7 +350,7 @@ namespace Vitorm.Sql
                         // get arg
                         var arg = new QueryTranslateArgument(this, null);
 
-                        (string sql, Dictionary<string, object> sqlParam, IDbDataReader dataReader) = sqlTranslateService.PrepareQuery(arg, combinedStream);
+                        var sql = sqlTranslateService.PrepareQuery(arg, combinedStream);
                         return sql;
                     }
                 case nameof(Orm_Extensions.ExecuteDelete):
@@ -361,9 +361,8 @@ namespace Vitorm.Sql
                         var entityType = (combinedStream.source as SourceStream)?.GetEntityType();
                         var arg = new QueryTranslateArgument(this, entityType);
 
-                        (string sql, Dictionary<string, object> sqlParam) = sqlTranslateService.PrepareExecuteDelete(arg, combinedStream);
-
-                        var count = Execute(sql: sql, param: sqlParam);
+                        var sql = sqlTranslateService.PrepareExecuteDelete(arg, combinedStream);
+                        var count = Execute(sql: sql, param: arg.sqlParam);
                         return count;
                     }
                 case nameof(Queryable.FirstOrDefault) or nameof(Queryable.First) or nameof(Queryable.LastOrDefault) or nameof(Queryable.Last):
@@ -372,16 +371,15 @@ namespace Vitorm.Sql
                         var resultEntityType = expression.Type;
                         var arg = new QueryTranslateArgument(this, resultEntityType);
 
-                        (string sql, Dictionary<string, object> sqlParam, IDbDataReader dataReader) = sqlTranslateService.PrepareQuery(arg, combinedStream);
-
-                        using var reader = ExecuteReader(sql: sql, param: sqlParam, useReadOnly: true);
-                        return dataReader.ReadData(reader);
+                        var sql = sqlTranslateService.PrepareQuery(arg, combinedStream);
+                        using var reader = ExecuteReader(sql: sql, param: arg.sqlParam, useReadOnly: true);
+                        return arg.dataReader.ReadData(reader);
                     }
                 case nameof(Queryable.Count) or nameof(Queryable_Extensions.TotalCount):
                     {
                         return ExecuteQuery_Count(combinedStream);
                     }
-                case nameof(Queryable_Extensions.ToListAndTotalCount): 
+                case nameof(Queryable_Extensions.ToListAndTotalCount):
                     {
                         var resultEntityType = expression.Type.GetGenericArguments()?.FirstOrDefault()?.GetGenericArguments()?.FirstOrDefault();
                         return ExecuteQuery_ToListAndTotalCount(combinedStream, resultEntityType);
@@ -413,7 +411,8 @@ namespace Vitorm.Sql
                 // #1 ToList
                 {
                     combinedStream.method = nameof(Enumerable.ToList);
-                    (sqlToList, sqlParam, dataReader) = sqlTranslateService.PrepareQuery(arg, combinedStream);
+                    sqlToList = sqlTranslateService.PrepareQuery(arg, combinedStream);
+                    dataReader = arg.dataReader;
                 }
 
                 // #2 TotalCount
@@ -421,13 +420,13 @@ namespace Vitorm.Sql
                     combinedStream.method = nameof(Enumerable.Count);
                     (combinedStream.orders, combinedStream.skip, combinedStream.take) = (null, null, null);
 
-                    (sqlCount, sqlParam) = sqlTranslateService.PrepareCountQuery(arg, combinedStream);
+                    sqlCount = sqlTranslateService.PrepareCountQuery(arg, combinedStream);
                 }
 
                 // #3 read data
                 {
                     var sql = sqlCount + " ;\r\n" + sqlToList;
-                    using var reader = ExecuteReader(sql: sql, param: sqlParam, useReadOnly: true);
+                    using var reader = ExecuteReader(sql: sql, param: arg.sqlParam, useReadOnly: true);
                     reader.Read();
                     totalCount = Convert.ToInt32(reader[0]);
                     reader.NextResult();
@@ -457,18 +456,18 @@ namespace Vitorm.Sql
         /// </summary>
         /// <param name="combinedStream"></param>
         /// <returns></returns>
-        protected virtual int ExecuteQuery_Count(CombinedStream combinedStream) 
+        protected virtual int ExecuteQuery_Count(CombinedStream combinedStream)
         {
             // deal with skip and take , no need to pass to PrepareCountQuery
-            var queryArg = (combinedStream.orders,combinedStream.skip  , combinedStream.take);
-            (combinedStream.orders, combinedStream.skip, combinedStream.take) = (null,null,null);
+            var queryArg = (combinedStream.orders, combinedStream.skip, combinedStream.take);
+            (combinedStream.orders, combinedStream.skip, combinedStream.take) = (null, null, null);
 
             // get arg
             var arg = new QueryTranslateArgument(this, null);
 
-            (string sql, Dictionary<string, object> sqlParam) = sqlTranslateService.PrepareCountQuery(arg, combinedStream);
+            var sql = sqlTranslateService.PrepareCountQuery(arg, combinedStream);
 
-            var countValue = ExecuteScalar(sql: sql, param: sqlParam, useReadOnly: true);
+            var countValue = ExecuteScalar(sql: sql, param: arg.sqlParam, useReadOnly: true);
             var count = Convert.ToInt32(countValue);
             if (count > 0 && combinedStream.method == nameof(Queryable.Count))
             {
@@ -486,10 +485,10 @@ namespace Vitorm.Sql
         {
             var arg = new QueryTranslateArgument(this, resultEntityType);
 
-            (string sql, Dictionary<string, object> sqlParam, IDbDataReader dataReader) = sqlTranslateService.PrepareQuery(arg, combinedStream);
+            var sql = sqlTranslateService.PrepareQuery(arg, combinedStream);
 
-            using var reader = ExecuteReader(sql: sql, param: sqlParam, useReadOnly: true);
-            return dataReader.ReadData(reader);
+            using var reader = ExecuteReader(sql: sql, param: arg.sqlParam, useReadOnly: true);
+            return arg.dataReader.ReadData(reader);
         }
 
         #endregion
@@ -586,10 +585,10 @@ namespace Vitorm.Sql
             SqlTranslateArgument arg = new SqlTranslateArgument(this, entityDescriptor);
 
             // #1 prepare sql
-            (string sql, Dictionary<string, object> sqlParam) = sqlTranslateService.PrepareDeleteByKeys(arg, keys);
+            var sql = sqlTranslateService.PrepareDeleteByKeys(arg, keys);
 
             // #2 execute
-            var affectedRowCount = Execute(sql: sql, param: sqlParam);
+            var affectedRowCount = Execute(sql: sql, param: arg.sqlParam);
             return affectedRowCount;
         }
 

src/Vitorm/Sql/SqlTranslate/BaseQueryTranslateService.cs

@@ -184,7 +184,7 @@ namespace Vitorm.Sql.SqlTranslate
 
             {
                 var sqlColumns = reader.BuildSelect(arg, resultEntityType, sqlTranslator, arg.dbContext.convertService, stream.select, selectedFields);
-                arg.dataReader ??= reader;
+                arg.dataReader = reader;
                 return (stream.distinct == true ? "distinct " : "") + sqlColumns;
             }
         }

src/Vitorm/Sql/SqlTranslate/ISqlTranslateService.cs

@@ -41,8 +41,8 @@ namespace Vitorm.Sql.SqlTranslate
         string EvalExpression(QueryTranslateArgument arg, ExpressionNode data);
 
         // #0 Schema :  PrepareCreate PrepareDrop
-        string PrepareCreate(IEntityDescriptor entityDescriptor);
-        string PrepareDrop(IEntityDescriptor entityDescriptor);
+        string PrepareTryCreateTable(IEntityDescriptor entityDescriptor);
+        string PrepareTryDropTable(IEntityDescriptor entityDescriptor);
 
 
         // #1 Create :  PrepareAdd
@@ -53,22 +53,22 @@ namespace Vitorm.Sql.SqlTranslate
 
         // #2 Retrieve : PrepareGet PrepareQuery
         string PrepareGet(SqlTranslateArgument arg);
-        (string sql, Dictionary<string, object> sqlParam, IDbDataReader dataReader) PrepareQuery(QueryTranslateArgument arg, CombinedStream combinedStream);
-        (string sql, Dictionary<string, object> sqlParam) PrepareCountQuery(QueryTranslateArgument arg, CombinedStream combinedStream);
+        string PrepareQuery(QueryTranslateArgument arg, CombinedStream combinedStream);
+        string PrepareCountQuery(QueryTranslateArgument arg, CombinedStream combinedStream);
 
 
 
         // #3 Update: PrepareUpdate PrepareExecuteUpdate
         (string sql, Func<object, Dictionary<string, object>> GetSqlParams) PrepareUpdate(SqlTranslateArgument arg);
-        (string sql, Dictionary<string, object> sqlParam) PrepareExecuteUpdate(QueryTranslateArgument arg, CombinedStream combinedStream);
+        string PrepareExecuteUpdate(QueryTranslateArgument arg, CombinedStream combinedStream);
 
 
         // #4 Delete: PrepareDelete PrepareDeleteRange PrepareExecuteDelete
         string PrepareDelete(SqlTranslateArgument arg);
 
-        (string sql, Dictionary<string, object> sqlParam) PrepareDeleteByKeys<Key>(SqlTranslateArgument arg, IEnumerable<Key> keys);
+        string PrepareDeleteByKeys<Key>(SqlTranslateArgument arg, IEnumerable<Key> keys);
 
-        (string sql, Dictionary<string, object> sqlParam) PrepareExecuteDelete(QueryTranslateArgument arg, CombinedStream combinedStream);
+        string PrepareExecuteDelete(QueryTranslateArgument arg, CombinedStream combinedStream);
 
 
 

src/Vitorm/Sql/SqlTranslate/QueryTranslateArgument.cs

@@ -19,9 +19,24 @@ namespace Vitorm.Sql.SqlTranslate
 
 
         public IDbDataReader dataReader { get; set; }
-        public Dictionary<string, object> sqlParam { get; protected set; } = new Dictionary<string, object>();
+
+        public Dictionary<string, object> sqlParam { get; protected set; }
 
         protected int paramIndex = 0;
-        public string NewParamName() => "p" + (paramIndex++);
+
+        /// <summary>
+        /// add sqlParam and get the generated sqlParam name
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public string AddParamAndGetName(object value)
+        {
+            sqlParam ??= new();
+            var paramName = "p" + (paramIndex++);
+
+            sqlParam[paramName] = value;
+            return paramName;
+        }
+
     }
 }

src/Vitorm/Sql/SqlTranslate/SqlTranslateArgument.cs

@@ -1,4 +1,6 @@
-using Vitorm.Entity;
+using System.Collections.Generic;
+
+using Vitorm.Entity;
 
 namespace Vitorm.Sql.SqlTranslate
 {
@@ -12,5 +14,24 @@ namespace Vitorm.Sql.SqlTranslate
             this.dbContext = dbContext;
             this.entityDescriptor = entityDescriptor;
         }
+
+
+        public Dictionary<string, object> sqlParam { get; protected set; }
+
+        protected int paramIndex = 0;
+
+        /// <summary>
+        /// add sqlParam and get the generated sqlParam name
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public string AddParamAndGetName(object value)
+        {
+            sqlParam ??= new();
+            var paramName = "p" + (paramIndex++);
+
+            sqlParam[paramName] = value;
+            return paramName;
+        }
     }
 }

src/Vitorm/Sql/SqlTranslate/SqlTranslateService.cs

@@ -3,14 +3,12 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.RegularExpressions;
 
 using Vit.Linq.ExpressionTree.ComponentModel;
 
 using Vitorm.Entity;
-//using System.Range;
 using Vitorm.StreamQuery;
 
 namespace Vitorm.Sql.SqlTranslate
@@ -317,17 +315,15 @@ namespace Vitorm.Sql.SqlTranslate
                             foreach (var item in enumerable)
                             {
                                 if (item == null) continue;
+
+                                var paramName = arg.AddParamAndGetName(value: item);
                                 if (sql == null)
                                 {
                                     sql = new StringBuilder("(");
-                                    var paramName = arg.NewParamName();
-                                    arg.sqlParam[paramName] = item;
                                     sql.Append(GenerateParameterName(paramName));
                                 }
                                 else
                                 {
-                                    var paramName = arg.NewParamName();
-                                    arg.sqlParam[paramName] = item;
                                     sql.Append(",").Append(GenerateParameterName(paramName));
                                 }
                             }
@@ -336,8 +332,7 @@ namespace Vitorm.Sql.SqlTranslate
                         }
                         else
                         {
-                            var paramName = arg.NewParamName();
-                            arg.sqlParam[paramName] = value;
+                            var paramName = arg.AddParamAndGetName(value: value);
                             return GenerateParameterName(paramName);
                         }
 
@@ -366,9 +361,9 @@ namespace Vitorm.Sql.SqlTranslate
         #endregion
 
 
-        // #0 Schema :  PrepareCreate PrepareDrop
-        public abstract string PrepareCreate(IEntityDescriptor entityDescriptor);
-        public abstract string PrepareDrop(IEntityDescriptor entityDescriptor);
+        // #0 Schema :  PrepareTryCreateTable PrepareTryDropTable
+        public abstract string PrepareTryCreateTable(IEntityDescriptor entityDescriptor);
+        public abstract string PrepareTryDropTable(IEntityDescriptor entityDescriptor);
 
 
         #region #1 Create :  PrepareAdd
@@ -443,16 +438,14 @@ namespace Vitorm.Sql.SqlTranslate
         }
 
         protected abstract BaseQueryTranslateService queryTranslateService { get; }
-        public virtual (string sql, Dictionary<string, object> sqlParam, IDbDataReader dataReader) PrepareQuery(QueryTranslateArgument arg, CombinedStream combinedStream)
+        public virtual string PrepareQuery(QueryTranslateArgument arg, CombinedStream combinedStream)
         {
-            string sql = queryTranslateService.BuildQuery(arg, combinedStream);
-            return (sql, arg.sqlParam, arg.dataReader);
+            return queryTranslateService.BuildQuery(arg, combinedStream);
         }
 
-        public virtual (string sql, Dictionary<string, object> sqlParam) PrepareCountQuery(QueryTranslateArgument arg, CombinedStream combinedStream)
+        public virtual string PrepareCountQuery(QueryTranslateArgument arg, CombinedStream combinedStream)
         {
-            string sql = queryTranslateService.BuildCountQuery(arg, combinedStream);
-            return (sql, arg.sqlParam);
+            return queryTranslateService.BuildCountQuery(arg, combinedStream);
         }
 
         #endregion
@@ -501,10 +494,9 @@ namespace Vitorm.Sql.SqlTranslate
 
 
         protected abstract BaseQueryTranslateService executeUpdateTranslateService { get; }
-        public virtual (string sql, Dictionary<string, object> sqlParam) PrepareExecuteUpdate(QueryTranslateArgument arg, CombinedStream combinedStream)
+        public virtual string PrepareExecuteUpdate(QueryTranslateArgument arg, CombinedStream combinedStream)
         {
-            string sql = executeUpdateTranslateService.BuildQuery(arg, combinedStream);
-            return (sql, arg.sqlParam);
+            return executeUpdateTranslateService.BuildQuery(arg, combinedStream);
         }
 
         #endregion
@@ -525,7 +517,7 @@ namespace Vitorm.Sql.SqlTranslate
             return sql;
         }
 
-        public virtual (string sql, Dictionary<string, object> sqlParam) PrepareDeleteByKeys<Key>(SqlTranslateArgument arg, IEnumerable<Key> keys)
+        public virtual string PrepareDeleteByKeys<Key>(SqlTranslateArgument arg, IEnumerable<Key> keys)
         {
             //  delete from user where id in ( 7 ) ;
 
@@ -536,28 +528,27 @@ namespace Vitorm.Sql.SqlTranslate
 
             sql.Append("delete from ").Append(DelimitTableName(entityDescriptor)).Append(" where ").Append(DelimitIdentifier(entityDescriptor.keyName)).Append(" in (");
 
-            int keyIndex = 0;
-            foreach (var key in keys)
+            if (keys.Any())
             {
-                var paramName = "p" + (keyIndex++);
-                sql.Append(GenerateParameterName(paramName)).Append(",");
-                sqlParam[paramName] = key;
+                foreach (var key in keys)
+                {
+                    sql.Append(GenerateParameterName(arg.AddParamAndGetName(value: key))).Append(",");
+                }
+                sql.Length--;
+                sql.Append(");");
             }
-            if (keyIndex == 0) sql.Append("null);");
             else
             {
-                sql.Length--;
-                sql.Append(");");
+                sql.Append("null);");
             }
-            return (sql.ToString(), sqlParam);
+            return sql.ToString();
         }
 
 
         protected abstract BaseQueryTranslateService executeDeleteTranslateService { get; }
-        public virtual (string sql, Dictionary<string, object> sqlParam) PrepareExecuteDelete(QueryTranslateArgument arg, CombinedStream combinedStream)
+        public virtual string PrepareExecuteDelete(QueryTranslateArgument arg, CombinedStream combinedStream)
         {
-            string sql = executeDeleteTranslateService.BuildQuery(arg, combinedStream);
-            return (sql, arg.sqlParam);
+            return executeDeleteTranslateService.BuildQuery(arg, combinedStream);
         }
         #endregion