#270 step 7: extract DatabaseProvider memo-lookup helpers

The five provider ResolveDatabaseType + ResolveXxxDbType methods were
all carrying the same memo-lookup prologue: try DatabaseTypeMemo /
ParameterTypeMemo; if absent and the type is Nullable<T>, look up T
instead, copy the result to the nullable's slot for next-time, and
return. Only the fallback after that miss differs per provider
(PG → Npgsql plugin type map; SS/Oracle/MySQL → NotSupportedException;
SQLite → null/Text).

Move the lookup-with-nullable-promote into DatabaseProvider as two
shared protected helpers — ResolveDatabaseTypeFromMemo and
ResolveParameterTypeFromMemo — and rewrite each provider's two Resolve*
methods as one-or-two-liners that combine the helper with the provider-
specific fallback.

The audit also suggested templating determineParameterType but I held
back: in SS/Oracle/MySQL/SQLite the post-Resolve branches (IsEnum,
IsArray, DBNull, IsConstructedGenericType) are largely unreachable
because their Resolve always returns a sentinel fallback rather than
null. Removing that dead code would technically preserve behaviour but
risks edge cases that aren't covered by the current tests, so I left
those bodies alone.

Net diff: -97 LOC across the five provider files. No behaviour change.
Tests pass:
- PostgreSQL: 69/69 (Provider + TypeMapping + ToParameterType filter)
- SQL Server: 8/8 (+8 pre-existing skips)
- SQLite: 45/45
- MySQL: 37/37

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jeremydmiller

src/Weasel.Core/DatabaseProvider.cs

@@ -1,6 +1,7 @@
 using System.Data.Common;
 using ImTools;
 using JasperFx.Core;
+using JasperFx.Core.Reflection;
 using Weasel.Core.Names;
 
 namespace Weasel.Core;
@@ -170,6 +171,53 @@ public void RegisterMapping(Type type, string databaseType, TParameterType? para
         ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, parameterType));
     }
 
+    /// <summary>
+    ///     Shared memo lookup for the database-type string of a CLR type, with the
+    ///     standard nullable-promote fallback (if <c>T?</c> is asked but <c>T</c> is
+    ///     in the memo, copy the entry to <c>T?</c> and return it). Returns null
+    ///     when neither the type nor its inner-nullable is mapped — subclasses then
+    ///     apply provider-specific fallbacks (PG queries Npgsql's plugin type map,
+    ///     SS/Oracle/MySQL throw, SQLite returns null to signal "TEXT/JSON").
+    /// </summary>
+    protected string? ResolveDatabaseTypeFromMemo(Type type)
+    {
+        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
+        {
+            return value;
+        }
+
+        if (type.IsNullable() && DatabaseTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var inner))
+        {
+            DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, inner));
+            return inner;
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    ///     Shared memo lookup for the provider parameter-type enum of a CLR type,
+    ///     mirror of <see cref="ResolveDatabaseTypeFromMemo" />. Subclasses apply
+    ///     their own fallback when this returns null (PG queries Npgsql plugin;
+    ///     SS returns <c>Variant</c>; Oracle returns <c>Varchar2</c>; MySQL returns
+    ///     <c>VarChar</c>; SQLite returns <c>Text</c>).
+    /// </summary>
+    protected TParameterType? ResolveParameterTypeFromMemo(Type type)
+    {
+        if (ParameterTypeMemo.Value.TryFind(type, out var value))
+        {
+            return value;
+        }
+
+        if (type.IsNullable() && ParameterTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var inner))
+        {
+            ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, inner));
+            return inner;
+        }
+
+        return null;
+    }
+
     protected abstract Type[] determineClrTypesForParameterType(TParameterType dbType);
 
     public TParameter AddParameter(TCommand command, object? value, TParameterType? dbType = null)

src/Weasel.MySql/MySqlProvider.cs

@@ -36,35 +36,14 @@ protected override void storeMappings()
 
     private string? ResolveDatabaseType(Type type)
     {
-        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (!type.IsNullable() ||
-            !DatabaseTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var databaseType))
-            throw new NotSupportedException(
-                $"Weasel.MySql does not (yet) support database type mapping to {type.FullNameInCode()}");
-
-        DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, databaseType));
-        return databaseType;
+        return ResolveDatabaseTypeFromMemo(type)
+               ?? throw new NotSupportedException(
+                   $"Weasel.MySql does not (yet) support database type mapping to {type.FullNameInCode()}");
     }
 
     private MySqlDbType? ResolveMySqlDbType(Type type)
     {
-        if (ParameterTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (type.IsNullable() &&
-            ParameterTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var parameterType))
-        {
-            ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, parameterType));
-            return parameterType;
-        }
-
-        return MySqlDbType.VarChar;
+        return ResolveParameterTypeFromMemo(type) ?? MySqlDbType.VarChar;
     }
 
     protected override Type[] determineClrTypesForParameterType(MySqlDbType dbType)

src/Weasel.Oracle/OracleProvider.cs

@@ -36,35 +36,14 @@ protected override void storeMappings()
 
     private string? ResolveDatabaseType(Type type)
     {
-        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (!type.IsNullable() ||
-            !DatabaseTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var databaseType))
-            throw new NotSupportedException(
-                $"Weasel.Oracle does not (yet) support database type mapping to {type.FullNameInCode()}");
-
-        DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, databaseType));
-        return databaseType;
+        return ResolveDatabaseTypeFromMemo(type)
+               ?? throw new NotSupportedException(
+                   $"Weasel.Oracle does not (yet) support database type mapping to {type.FullNameInCode()}");
     }
 
     private OracleDbType? ResolveOracleDbType(Type type)
     {
-        if (ParameterTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (type.IsNullable() &&
-            ParameterTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var parameterType))
-        {
-            ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, parameterType));
-            return parameterType;
-        }
-
-        return OracleDbType.Varchar2;
+        return ResolveParameterTypeFromMemo(type) ?? OracleDbType.Varchar2;
     }
 
     protected override Type[] determineClrTypesForParameterType(OracleDbType dbType)

src/Weasel.Postgresql/PostgresqlProvider.cs

@@ -51,29 +51,31 @@ protected override void storeMappings()
     // custom npgsql mappings prior to execution.
     private string? ResolveDatabaseType(Type type)
     {
-        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
+        // Try the shared base memo (with nullable-promote) first; on a miss, ask
+        // Npgsql's type-mapping plugin (handles JsonB, NpgsqlRange<T>, …) and
+        // cache the answer so subsequent lookups are O(1).
+        var cached = ResolveDatabaseTypeFromMemo(type);
+        if (cached != null)
         {
-            return value;
+            return cached;
         }
 
-        value = GetTypeMapping(type)?.DataTypeName;
-
+        var value = GetTypeMapping(type)?.DataTypeName;
         DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, value));
-
         return value;
     }
 
     private NpgsqlDbType? ResolveNpgsqlDbType(Type type)
     {
-        if (ParameterTypeMemo.Value.TryFind(type, out var value))
+        // Same pattern as ResolveDatabaseType but for the NpgsqlDbType enum.
+        var cached = ResolveParameterTypeFromMemo(type);
+        if (cached != null)
         {
-            return value;
+            return cached;
         }
 
-        value = GetTypeMapping(type)?.NpgsqlDbType;
-
+        var value = GetTypeMapping(type)?.NpgsqlDbType;
         ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, value));
-
         return value;
     }
 

src/Weasel.SqlServer/SqlServerProvider.cs

@@ -37,36 +37,14 @@ protected override void storeMappings()
     // custom Sql mappings prior to execution.
     private string? ResolveDatabaseType(Type type)
     {
-        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (!type.IsNullable() ||
-            !DatabaseTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var databaseType))
-            throw new NotSupportedException(
-                $"Weasel.SqlServer does not (yet) support database type mapping to {type.FullNameInCode()}");
-
-        DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, databaseType));
-        return databaseType;
-
+        return ResolveDatabaseTypeFromMemo(type)
+               ?? throw new NotSupportedException(
+                   $"Weasel.SqlServer does not (yet) support database type mapping to {type.FullNameInCode()}");
     }
 
     private SqlDbType? ResolveSqlDbType(Type type)
     {
-        if (ParameterTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (type.IsNullable() &&
-            ParameterTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var parameterType))
-        {
-            ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, parameterType));
-            return parameterType;
-        }
-
-        return SqlDbType.Variant;
+        return ResolveParameterTypeFromMemo(type) ?? SqlDbType.Variant;
     }
 
 

src/Weasel.Sqlite/SqliteProvider.cs

@@ -47,37 +47,14 @@ protected override void storeMappings()
 
     private string? ResolveDatabaseType(Type type)
     {
-        if (DatabaseTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (!type.IsNullable() ||
-            !DatabaseTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var databaseType))
-        {
-            // For unmapped types, default to TEXT for JSON storage
-            return null;
-        }
-
-        DatabaseTypeMemo.Swap(d => d.AddOrUpdate(type, databaseType));
-        return databaseType;
+        // Unmapped types fall through to TEXT in GetDatabaseType (for JSON storage),
+        // so we just return null on a memo miss and let the caller decide.
+        return ResolveDatabaseTypeFromMemo(type);
     }
 
     private SqliteType? ResolveSqliteType(Type type)
     {
-        if (ParameterTypeMemo.Value.TryFind(type, out var value))
-        {
-            return value;
-        }
-
-        if (type.IsNullable() &&
-            ParameterTypeMemo.Value.TryFind(type.GetInnerTypeFromNullable(), out var parameterType))
-        {
-            ParameterTypeMemo.Swap(d => d.AddOrUpdate(type, parameterType));
-            return parameterType;
-        }
-
-        return SqliteType.Text;
+        return ResolveParameterTypeFromMemo(type) ?? SqliteType.Text;
     }
 
     protected override Type[] determineClrTypesForParameterType(SqliteType dbType)