add support IPrepareStatementFilter

dotnetcore · Jul 17, 2019 · 5172f9b · 5172f9b
2 parents 66a7dc3 + 6b3b963
commit 5172f9b
Show file tree

Hide file tree

Showing 5 changed files with 135 additions and 49 deletions.
diff --git a/build/version.props b/build/version.props
@@ -2,7 +2,7 @@
 	<PropertyGroup>
 		<VersionMajor>4</VersionMajor>
 		<VersionMinor>0</VersionMinor>
-		<VersionPatch>75</VersionPatch>
+		<VersionPatch>76</VersionPatch>
 		<VersionPrefix>$(VersionMajor).$(VersionMinor).$(VersionPatch)</VersionPrefix>
 	</PropertyGroup>
 </Project>
diff --git a/src/SmartSql.Test.Unit/SmartSqlFixture.cs b/src/SmartSql.Test.Unit/SmartSqlFixture.cs
@@ -1,8 +1,10 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using SmartSql.DbSession;
+using SmartSql.Middlewares.Filters;
 using Xunit;
 
 namespace SmartSql.Test.Unit
@@ -15,14 +17,15 @@ public class SmartSqlFixture : IDisposable
         public SmartSqlFixture()
         {
             LoggerFactory = new LoggerFactory(Enumerable.Empty<ILoggerProvider>(),
-                new LoggerFilterOptions { MinLevel = LogLevel.Debug });
+                new LoggerFilterOptions {MinLevel = LogLevel.Debug});
             var logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs", "SmartSql.log");
             LoggerFactory.AddFile(logPath, LogLevel.Trace);
 
             SmartSqlBuilder = new SmartSqlBuilder()
                 .UseXmlConfig()
                 .UseLoggerFactory(LoggerFactory)
                 .UseAlias(GLOBAL_SMART_SQL)
+                .AddFilter<TestPrepareStatementFilter>()
                 .Build();
             DbSessionFactory = SmartSqlBuilder.DbSessionFactory;
             SqlMapper = SmartSqlBuilder.SqlMapper;
@@ -43,4 +46,37 @@ public void Dispose()
     public class SmartSqlCollection : ICollectionFixture<SmartSqlFixture>
     {
     }
+
+
+    public class TestPrepareStatementFilter : IPrepareStatementFilter, ISetupSmartSql
+    {
+        private ILogger<TestPrepareStatementFilter> _logger;
+
+        public void OnInvoking(ExecutionContext context)
+        {
+            _logger.LogDebug("TestPrepareStatementFilter.OnInvoking");
+        }
+
+        public void OnInvoked(ExecutionContext context)
+        {
+            _logger.LogDebug("TestPrepareStatementFilter.OnInvoked");
+        }
+
+        public Task OnInvokingAsync(ExecutionContext context)
+        {
+            _logger.LogDebug("TestPrepareStatementFilter.OnInvokingAsync");
+            return Task.CompletedTask;
+        }
+
+        public Task OnInvokedAsync(ExecutionContext context)
+        {
+            _logger.LogDebug("TestPrepareStatementFilter.OnInvokedAsync");
+            return Task.CompletedTask;
+        }
+
+        public void SetupSmartSql(SmartSqlBuilder smartSqlBuilder)
+        {
+            _logger = smartSqlBuilder.LoggerFactory.CreateLogger<TestPrepareStatementFilter>();
+        }
+    }
 }
diff --git a/src/SmartSql/Middlewares/PrepareStatementMiddleware.cs b/src/SmartSql/Middlewares/PrepareStatementMiddleware.cs
@@ -34,54 +34,8 @@ private void InitParameters(ExecutionContext executionContext)
             BuildSql(executionContext.Request);
             BuildDbParameters(executionContext.Request);
             if (_logger.IsEnabled(LogLevel.Debug))
-
             {
-                var sourceParameters = executionContext.Request.Parameters.DbParameters.Values;
-                var cmdText = executionContext.Request.RealSql;
-                string dbParameterStr = string.Join(",", sourceParameters.Select(p => $"{p.ParameterName}={p.Value}"));
-                string realSql = _sqlParamAnalyzer.Replace(cmdText, (paramName, nameWithPrefix) =>
-                {
-                    var paramNameCompare = executionContext.SmartSqlConfig.Settings.IgnoreParameterCase
-                        ? StringComparison.CurrentCultureIgnoreCase
-                        : StringComparison.CurrentCulture;
-                    var dbParam = sourceParameters.FirstOrDefault(m =>
-                        String.Equals(m.ParameterName, paramName, paramNameCompare));
-                    if (dbParam == null)
-                    {
-                        return nameWithPrefix;
-                    }
-
-                    if (dbParam.Value == DBNull.Value)
-                    {
-                        return "NULL";
-                    }
-
-                    switch (dbParam.DbType)
-                    {
-                        case DbType.AnsiString:
-                        case DbType.AnsiStringFixedLength:
-                        case DbType.DateTime:
-                        case DbType.DateTime2:
-                        case DbType.DateTimeOffset:
-                        case DbType.Guid:
-                        case DbType.String:
-                        case DbType.StringFixedLength:
-                        case DbType.Time:
-                        case DbType.Xml:
-                        {
-                            return $"'{dbParam.Value}'";
-                        }
-
-                        case DbType.Boolean:
-                        {
-                            return ((bool) dbParam.Value) ? "1" : "0";
-                        }
-                    }
-
-                    return dbParam.Value.ToString();
-                });
-                _logger.LogDebug(
-                    $"Statement.Id:[{executionContext.Request.FullSqlId}],Sql:{Environment.NewLine}{cmdText}{Environment.NewLine}Parameters:[{dbParameterStr}]{Environment.NewLine}Sql with parameter value: {Environment.NewLine}{realSql}");
+                _logger.LogDebug(executionContext.FormatSql(true));
             }
         }
 

diff --git a/src/SmartSql/SmartSqlBuilder.cs b/src/SmartSql/SmartSqlBuilder.cs
@@ -85,6 +85,16 @@ private void SetupSmartSql()
 
             #endregion
 
+            #region Filters
+
+            foreach (var filter in Filters)
+            {
+                var setupSmartSql = filter as ISetupSmartSql;
+                setupSmartSql?.SetupSmartSql(this);
+            }
+
+            #endregion
+
             #region Pipeline
 
             var currentMiddleware = SmartSqlConfig.Pipeline;

diff --git a/src/SmartSql/Utils/ExecutionContextExtensions.cs b/src/SmartSql/Utils/ExecutionContextExtensions.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Data.Common;
+using System.Linq;
+using System.Text;
+
+namespace SmartSql.Utils
+{
+    public static class ExecutionContextExtensions
+    {
+        public static string FormatSql(this ExecutionContext executionContext, bool withParameterValue)
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+            var sourceParameters = executionContext.Request.Parameters.DbParameters.Values;
+            string dbParameterStr = string.Join(",", sourceParameters.Select(p => $"{p.ParameterName}={p.Value}"));
+            stringBuilder.AppendFormat("Statement.Id:[{0}],", executionContext.Request.FullSqlId);
+            stringBuilder.Append("Sql:");
+            stringBuilder.AppendLine();
+            stringBuilder.Append(executionContext.Request.RealSql);
+            stringBuilder.AppendLine();
+            stringBuilder.AppendFormat("Parameters:[{0}]", dbParameterStr);
+
+            if (!withParameterValue)
+            {
+                return stringBuilder.ToString();
+            }
+
+            stringBuilder.AppendLine();
+            stringBuilder.Append("Sql with parameter value: ");
+            stringBuilder.AppendLine();
+            string realSql = FormatSqlWithParameters(executionContext);
+            stringBuilder.Append(realSql);
+
+            return stringBuilder.ToString();
+        }
+
+        private static string FormatSqlWithParameters(this ExecutionContext executionContext)
+        {
+            var sourceParameters = executionContext.Request.Parameters.DbParameters.Values;
+            return executionContext.SmartSqlConfig.SqlParamAnalyzer.Replace(executionContext.Request.RealSql,
+                (paramName, nameWithPrefix) =>
+                {
+                    var paramNameCompare = executionContext.SmartSqlConfig.Settings.IgnoreParameterCase
+                        ? StringComparison.CurrentCultureIgnoreCase
+                        : StringComparison.CurrentCulture;
+                    var dbParam =
+                        sourceParameters.FirstOrDefault(
+                            m => String.Equals(m.ParameterName, paramName, paramNameCompare));
+                    if (dbParam == null)
+                    {
+                        return nameWithPrefix;
+                    }
+
+                    if (dbParam.Value == DBNull.Value)
+                    {
+                        return "NULL";
+                    }
+
+                    switch (dbParam.DbType)
+                    {
+                        case DbType.AnsiString:
+                        case DbType.AnsiStringFixedLength:
+                        case DbType.DateTime:
+                        case DbType.DateTime2:
+                        case DbType.DateTimeOffset:
+                        case DbType.Guid:
+                        case DbType.String:
+                        case DbType.StringFixedLength:
+                        case DbType.Time:
+                        case DbType.Xml:
+                        {
+                            return $"'{dbParam.Value}'";
+                        }
+
+                        case DbType.Boolean:
+                        {
+                            return ((bool) dbParam.Value) ? "1" : "0";
+                        }
+                    }
+
+                    return dbParam.Value.ToString();
+                });
+        }
+    }
+}