Don't forget about global mappers

Author: asherber

StaTypPocoQueries.PetaPoco.Tests/QueryTests.cs

@@ -65,15 +65,7 @@ public QueryTests()
             _mockDb.Setup(m => m.Provider).Returns(new AngleDatabaseProvider());
             _mockDb.Setup(m => m.DefaultMapper).Returns(new ConventionMapper());
 
-            FlushPocoDataCache();            
-        }
-
-        private void FlushPocoDataCache()
-        {
-            // This avoids having to upgrade PP just to get FlushCaches()
-            var cache = typeof(PocoData).GetField("_pocoDatas", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
-            var flush = cache.GetType().GetMethod("Flush");
-            flush.Invoke(cache, null);
+            Mappers.RevokeAll();
         }
 
         [Theory, AutoData]
@@ -112,19 +104,37 @@ public void Query_Should_Use_Plain_Value_With_No_Value_Converter(FoodEnum food)
         }
 
         [Theory, AutoData]
-        public void Query_Should_Use_Mapper_For_Names(string value)
+        public void Query_Should_Use_Default_Mapper_For_Names(string value)
         {
             _mockDb.Setup(m => m.DefaultMapper).Returns(new UnderscoreMapper());
             _mockDb.Object.Query<MyClass>(c => c.MultiWordName == value);
             _lastSql.Should().BeEquivalentTo(new Sql("WHERE <multi_word_name> = @0", value));
         }
 
         [Theory, AutoData]
-        public void Query_Should_Use_Mapper_For_Values(string value)
+        public void Query_Should_Use_Default_Mapper_For_Values(string value)
         {
             _mockDb.Setup(m => m.DefaultMapper).Returns(new SubstituteStringMapper());
             _mockDb.Object.Query<MyClass>(c => c.Name == value);
             _lastSql.Should().BeEquivalentTo(new Sql("WHERE <Name> = @0", "SUBSTITUTE STRING"));
         }
+
+        [Theory, AutoData]
+        public void Query_Should_Use_Global_Mapper_For_Names(string value)
+        {
+            Mappers.Register(typeof(MyClass), new UnderscoreMapper());
+            
+            _mockDb.Object.Query<MyClass>(c => c.MultiWordName == value);
+            _lastSql.Should().BeEquivalentTo(new Sql("WHERE <multi_word_name> = @0", value));
+        }
+
+        [Theory, AutoData]
+        public void Query_Should_Use_Global_Mapper_For_Values(string value)
+        {
+            Mappers.Register(typeof(MyClass), new SubstituteStringMapper());
+
+            _mockDb.Object.Query<MyClass>(c => c.Name == value);
+            _lastSql.Should().BeEquivalentTo(new Sql("WHERE <Name> = @0", "SUBSTITUTE STRING"));
+        }
     }
 }

StaTypPocoQueries.PetaPoco/SqlTranslator.cs

@@ -64,22 +64,33 @@ public Sql Translate<T>(FSharpExpr<FSharpFunc<T, bool>> query)
 
         private string GetColumnName(MemberInfo mi)
         {
+            var result = mi.Name;
+
             if (mi is PropertyInfo pi)
             {
-                var pd = PocoData.ForType(mi.DeclaringType, _db.DefaultMapper);
-                return pd.GetColumnName(pi.Name);
+                var mapper = GetMapper(pi);
+
+                try
+                {
+                    var ci = mapper.GetColumnInfo(pi);
+                    result = ci.ColumnName;
+                }
+                catch { }
             }
-            else
-                return mi.Name;
+
+            return result;
         }
 
 
         private object GetConvertedValue(PropertyInfo pi, object input)
         {
-            var converter = _db.DefaultMapper.GetToDbConverter(pi);            
+            var mapper = GetMapper(pi);
+            var converter = mapper.GetToDbConverter(pi);            
             return converter == null ? input : converter(input);
         }
 
+        private IMapper GetMapper(PropertyInfo pi) => Mappers.GetMapper(pi.DeclaringType, _db.DefaultMapper);
+
         private FSharpFunc<MemberInfo, string> FsGetColumnName
             => ExpressionToSql.AsFsFunc<MemberInfo, string>(GetColumnName);