Update core

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/FastestProvider.cs

@@ -133,7 +133,10 @@ namespace SqlSugar
             await buider.ExecuteBulkCopyAsync(dt);
             //var queryTemp = this.context.Queryable<T>().AS(dt.TableName).ToList();//test
             var result = await buider.UpdateByTempAsync(GetTableName(), dt.TableName, updateColumns, whereColumns);
+            if (this.context.CurrentConnectionConfig.DbType != DbType.Sqlite)
+            {
                 this.context.DbMaintenance.DropTable(dt.TableName);
+            }
             this.context.CurrentConnectionConfig.IsAutoCloseConnection = isAuto;
             buider.CloseDb();
             End(datas, false);

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/FastestProvider/Private.cs

@@ -18,7 +18,7 @@ namespace SqlSugar
                 case DbType.SqlServer:
                     return new SqlServerFastBuilder();
                 case DbType.Sqlite:
-                    break;
+                    return new SqliteFastBuilder(this.entityInfo);
                 case DbType.Oracle:
                     return new OracleFastBuilder(this.entityInfo);
                 case DbType.PostgreSQL:

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/Reportable/ReportableProvider.cs

@@ -206,19 +206,28 @@ namespace SqlSugar
             else if (type.IsIn(typeof(decimal), typeof(double)))
             {
                 Expression<Func<SingleColumnEntity<object>, object>> exp = it => Convert.ToDecimal(it.ColumnName);
-                var result = queryBuilder.GetExpressionValue(exp, ResolveExpressType.WhereSingle).GetResultString();
+                var result = queryBuilder.LambdaExpressions.DbMehtods.ToDecimal(new MethodCallExpressionModel() {
-                result = Regex.Replace(result, @"\[ColumnName\]", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
+                 Args=new List<MethodCallExpressionArgs>() { 
-                result = Regex.Replace(result, @"\`ColumnName\`", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
+                  new MethodCallExpressionArgs(){ 
-                result = Regex.Replace(result, @"""ColumnName""", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
+                   IsMember=true,
+                   MemberName= formatBuilder.FormatValue(value) 
+                  }
+                 }
+                });
                 return result;
             }
             else if (type.IsIn(typeof(DateTime))) 
             {
-                Expression<Func<SingleColumnEntity<object>, object>> exp= it => Convert.ToDateTime(it.ColumnName);
+                Expression<Func<SingleColumnEntity<object>, object>> exp = it => Convert.ToDecimal(it.ColumnName);
-                var result= queryBuilder.GetExpressionValue(exp,ResolveExpressType.WhereSingle).GetResultString();
+                var result = queryBuilder.LambdaExpressions.DbMehtods.ToDate(new MethodCallExpressionModel()
-                result = Regex.Replace(result, @"\[ColumnName\]", formatBuilder.FormatValue(value)+"",RegexOptions.IgnoreCase);
+                {
-                result = Regex.Replace(result, @"\`ColumnName\`", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
+                    Args = new List<MethodCallExpressionArgs>() {
-                result = Regex.Replace(result, @"""ColumnName""", formatBuilder.FormatValue(value) + "", RegexOptions.IgnoreCase);
+                  new MethodCallExpressionArgs(){
+                   IsMember=true,
+                   MemberName= formatBuilder.FormatValue(value)
+                  }
+                 }
+                });
                 return result;
             }
             else

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs

@@ -174,6 +174,11 @@ namespace SqlSugar
         }
         public virtual object FormatValue(object value)
         {
+            var N = "N";
+            if (this.Context.CurrentConnectionConfig.DbType == DbType.Sqlite) 
+            {
+                N = "";
+            }
             if (value == null)
             {
                 return "NULL";
@@ -212,7 +217,7 @@ namespace SqlSugar
                 }
                 else if (type == UtilConstants.StringType || type == UtilConstants.ObjType)
                 {
-                    return "N'" + value.ToString().ToSqlFilter() + "'";
+                    return N+"'" + value.ToString().ToSqlFilter() + "'";
                 }
                 else if (type == UtilConstants.DateTimeOffsetType)
                 {
@@ -221,11 +226,11 @@ namespace SqlSugar
                 }
                 else if (type == UtilConstants.FloatType) 
                 {
-                    return "N'" +Convert.ToDouble(value).ToString() + "'";
+                    return N+"'" +Convert.ToDouble(value).ToString() + "'";
                 }
                 else
                 {
-                    return "N'" + value.ToString() + "'";
+                    return N+"'" + value.ToString() + "'";
                 }
             }
         }

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs

@@ -840,6 +840,10 @@ namespace SqlSugar
             if (this.UpdateParameterIsNull)
             {
                 var whereSql = Regex.Replace(sql, ".* WHERE ", "", RegexOptions.Singleline);
+                if (sql.Contains("WHERE (EXISTS")) 
+                {
+                    whereSql=Regex.Match(sql, @"\(EXISTS.+").Value;
+                }
                 dt = this.Context.Queryable<T>().Where(whereSql).AddParameters(parameters).ToDataTable();
             }
             else 

Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteFastBuilder.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using Microsoft.Data.Sqlite;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SqlSugar
+{
+    public class SqliteFastBuilder : IFastBuilder
+    {
+        private EntityInfo entityInfo;
+        private bool IsUpdate = false;
+        private DataTable UpdateDataTable { get; set; }
+        public SqliteFastBuilder(EntityInfo entityInfo)
+        {
+            this.entityInfo = entityInfo;
+        }
+
+        public SqlSugarProvider Context { get; set; }
+
+        public void CloseDb()
+        {
+            if (this.Context.CurrentConnectionConfig.IsAutoCloseConnection)
+            {
+                this.Context.Close();
+            }
+        }
+
+        public async Task CreateTempAsync<T>(DataTable dt) where T : class, new()
+        {
+            await Task.Delay(0);
+            IsUpdate = true;
+        }
+
+
+        public async Task<int> ExecuteBulkCopyAsync(DataTable dt)
+        {
+            if (dt.Rows.Count == 0||IsUpdate)
+            {
+                this.UpdateDataTable = dt;
+                return 0;
+            }
+            foreach (var item in this.entityInfo.Columns)
+            {
+                if (item.IsIdentity && dt.Columns.Contains(item.DbColumnName))
+                {
+                    dt.Columns.Remove(item.DbColumnName);
+                }
+            }
+            var dictionary = this.Context.Utilities.DataTableToDictionaryList(dt.Rows.Cast<DataRow>().Take(1).CopyToDataTable());
+            int result = 0;
+            var cn = this.Context.Ado.Connection as SqliteConnection;
+            Open(cn);
+            if (this.Context.Ado.Transaction == null)
+            {
+                using (var transaction = cn.BeginTransaction())
+                {
+                    result = await _BulkCopy(dt, dictionary, result, cn);
+                    transaction.Commit();
+                }
+            }
+            else 
+            {
+                result = await _BulkCopy(dt, dictionary, result, cn);
+            }
+            return result;
+        }
+
+        private async Task<int> _BulkCopy(DataTable dt, List<Dictionary<string, object>> dictionary, int i, SqliteConnection cn)
+        {
+            using (var cmd = cn.CreateCommand())
+            {
+                cmd.CommandText = this.Context.Insertable(dictionary.First()).AS(dt.TableName).ToSql().Key.Replace(";SELECT LAST_INSERT_ROWID();","");
+
+                foreach (DataRow dataRow in dt.Rows)
+                {
+                    foreach (DataColumn item in dt.Columns)
+                    {
+                        cmd.Parameters.AddWithValue("@" + item.ColumnName, dataRow[item.ColumnName]);
+                    }
+                    i += await cmd.ExecuteNonQueryAsync();
+                }
+            }
+            return i;
+        }
+        private async Task<int> _BulkUpdate(DataTable dt, List<Dictionary<string, object>> dictionary, int i,string [] whereColums,string [] updateColums, SqliteConnection cn)
+        {
+            using (var cmd = cn.CreateCommand())
+            {
+                cmd.CommandText = this.Context.Updateable(dictionary.First())
+                    .WhereColumns(whereColums)
+                    .UpdateColumns(updateColums)
+                    .AS(dt.TableName).ToSql().Key;
+
+                foreach (DataRow dataRow in dt.Rows)
+                {
+                    foreach (DataColumn item in dt.Columns)
+                    {
+                        cmd.Parameters.AddWithValue("@" + item.ColumnName, dataRow[item.ColumnName]);
+                    }
+                    i += await cmd.ExecuteNonQueryAsync();
+                }
+            }
+            return i;
+        }
+        private static void Open(SqliteConnection cn)
+        {
+            if (cn.State != ConnectionState.Open)
+                cn.Open();
+        }
+
+        public async Task<int> UpdateByTempAsync(string tableName, string tempName, string[] updateColumns, string[] whereColumns)
+        {
+            var dt = UpdateDataTable;
+            if (dt.Rows.Count == 0)
+            {
+                return 0;
+            }
+            var dictionary = this.Context.Utilities.DataTableToDictionaryList(dt.Rows.Cast<DataRow>().Take(1).CopyToDataTable());
+            int result = 0;
+            var cn = this.Context.Ado.Connection as SqliteConnection;
+            Open(cn);
+            if (this.Context.Ado.Transaction == null)
+            {
+                using (var transaction = cn.BeginTransaction())
+                {
+                    result = await _BulkUpdate(dt, dictionary, result,whereColumns,updateColumns, cn);
+                    transaction.Commit();
+                }
+            }
+            else
+            {
+                result = await _BulkUpdate(dt, dictionary, result, whereColumns, updateColumns, cn);
+            }
+            return result;
+        }
+    }
+}