Dapper 可以将用户定义的复合类型传递给 PostgreSQL 函数吗？

Question

我试图弄清楚如何使用 Dapper 将用户定义的复合类型传递给 PostgreSQL 函数。我知道这在 SQL Server 上是可能的，而且我已经有了使用 Dapper+SQL Server 的工作示例，但是，我对如何使用 PostgreSQL 做同样的事情很不了解。

从我读过的一些内容来看，我不确定 Dapper+PostgreSQL 是否可行，但我知道它确实适用于普通的 Npgsql（我也有一个工作示例）。

那么，如何使用 Dapper 调用接受用户定义复合类型的 PostgreSQL 函数？

示例用户定义的复合类型

CREATE TYPE hero AS (
    first_name text,
    last_name text
);

接受用户定义的复合类型的示例 PostgreSQL 函数

CREATE OR REPLACE FUNCTION testfuncthattakesinudt(our_hero hero)
    RETURNS SETOF characters 
    LANGUAGE 'sql'

    STABLE
    ROWS 1000
AS $BODY$

    SELECT  *
    FROM    characters
    WHERE   first_name = COALESCE(our_hero.first_name, '')
    AND     last_name = COALESCE(our_hero.last_name, '');

$BODY$;

理论 C# 示例

[Test]
public void UsingDapper_Query_CallFunctionThatTakesInUserDefinedCompositeType_FunctionUsesUserDefinedCompositeType()
{
    // Arrange
    using (var conn = new NpgsqlConnection(_getConnectionStringToDatabase()))
    {
        var funcName = "testfuncthattakesinudt";
        var expect = CharacterTestData.First();

        // Act
        var result = conn.Query<Character>(funcName,
            new
            {
                our_hero = new
                {
                    first_name = CharacterTestData.First().first_name,
                    last_name = CharacterTestData.First().last_name
                }
            },
            commandType: CommandType.StoredProcedure
        );

        // Assert
        Assert.AreEqual(expect, result);
    }
}

我知道使用普通的 Npgsql，有必要创建类似于以下内容的参数：

var udtCompositeParameter = new NpgsqlParameter
{
    ParameterName = "our_hero",
    Value = new
    {
        first_name = CharacterTestData.First().first_name,
        last_name = CharacterTestData.First().last_name
    },
    DataTypeName = "hero"
};

但是使用Dapper，我还没有找到设置DataTypeName或类似的方法。我尝试了许多不同的方法来塑造 Dapper 的参数（例如使用类似DynamicParameter和指定的东西dbType: DbType.Object），但无论如何，我总是得到一些与复合类型相关的类似错误。我还查看了Dapper 源代码，但从我所见，PostgreSQL 特定测试和那些似乎与我正在尝试做的测试一致的测试是针对 SQL Server 量身定制的。

Answer 1

更新

基于这个答案，我们能够将该概念应用于这个问题，并提供一个更清晰的结果，不需要使用TypeHandlers.

工作集成测试

public void Query_CallFunctionThatTakesInUserDefinedType_FunctionUsesUserDefinedType()
{
    // Arrange
    using (var conn = Db.GetConnection())
    {
        var functionName = "test_function_that_takes_in_udt";
        var expect = CharacterTestData.First();

        // Act
        var result = conn.Query<Character>(functionName,
            new 
            {
                our_hero = new HeroParameter(
                    CharacterTestData.First().FirstName,
                    CharacterTestData.First().LastName
                )
            },
            commandType: CommandType.StoredProcedure
        ).FirstOrDefault();

        // Assert
        Assert.AreEqual(expect, result);
    }
}

注意自最初的问题以来，上面的代码中有一些重构（例如名称），但是 PostgreSQL 函数的主体没有改变。与此答案相关的最值得注意的重构是如何创建连接：

public NpgsqlConnection GetConnection()
{
    var connection = new NpgsqlConnection(GetConnectionStringToDatabase());
    Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true;
    connection.Open();
    connection.ReloadTypes();

    /*
     * 
     * Ideally, should move this to be handled for _all_ connections like:
     *      NpgsqlConnection.GlobalTypeMapper.MapEnum<SomeEnum>("some_enum_type");
     *      NpgsqlConnection.GlobalTypeMapper.MapComposite<SomeType>("some_composite_type");
     *  
     */
    connection.TypeMapper.MapComposite<Hero>("hero");

    return connection;
}

支持英雄参数

public class HeroParameter : ICustomQueryParameter
{
    private readonly Hero _hero;

    public HeroParameter(string firstName, string lastName)
    {
        _hero = new Hero(firstName, lastName);
    }

    public void AddParameter(IDbCommand command, string name)
    {
        var parameter = new NpgsqlParameter
        {
            ParameterName = name,
            Value = _hero,
            DataTypeName = "hero"
        };
        command.Parameters.Add(parameter);
    }
}

在我们的情况下，不使用TypeHandlers被证明是非常有利的。

这是由于 PostgreSQL 在从函数返回时可能使用 UDT/复合类型的挑剔本质。例如，如果 UDT 是返回的 2 个或更多列之一，则 PostgreSQL 将返回 UDT 列形状为 的结果集(val1, val2)。但是，如果返回的只是UDT，PostgreSQL 会将 UDT 的各个属性扩展到各个列，就像SELECT表中的普通属性一样。

例如，考虑以下函数：

CREATE OR REPLACE FUNCTION example_function()
    RETURNS hero
    LANGUAGE SQL
AS
$$
SELECT ('Peter', 'Parker')::hero as heroes
$$

在这种情况下，为了使其TypeHandler正常工作，我们需要结果采用以下格式：

|-----------------|
|      heroes     |
|-----------------|
| (Peter, Parker) |
|-----------------|

这是因为在像 之类的调用之后conn.Query<Hero>(...)，Dapper 会将第一列（并且仅第一列）传递给期望TypeHandler它执行必要的转换。

但是，上述函数的输出example_function实际上将以以下扩展格式返回结果：

|------------|-----------|
| first_name | last_name |
|------------|-----------|
|   Peter    |  Parker   |
|------------|-----------|

这意味着传递给该方法的Typeof就是在此示例中。valueTypeHandler.Parse()string

但是，对于在返回 2 个或更多列时将 UDT 作为其中一列返回的函数，则会TypeHandler按预期工作，因为单个列的值将传递给该Parse方法。

考虑这个更新的函数：

|-----------------|
|      heroes     |
|-----------------|
| (Peter, Parker) |
|-----------------|

它以以下格式返回输出：

|------|-----------------|
| year |      hero       |
|------|-----------------|
| 1962 | (Peter, Parker) |
|------|-----------------|

这是下面原始解决方案的不足之处。在那个例子中，我（还）没有使用该Parse方法。但是，一旦我需要实现该函数来支持返回UDT ，则TypeHandler根据 PostgreSQL 返回 UDT 的方式（如上面所示），该函数将无法工作。

原答案

对于其他可能偶然发现这个问题的人来说，这对我有用，尽管我对此不是很满意，所以我愿意接受更好的解决方案来解决这个问题。

工作集成测试

|------------|-----------|
| first_name | last_name |
|------------|-----------|
|   Peter    |  Parker   |
|------------|-----------|

支持 HeroTypeHandler

CREATE OR REPLACE FUNCTION example_function()
    RETURNS TABLE (year integer, hero hero)
    LANGUAGE SQL
AS
$$
SELECT 1962 AS year, ('Peter', 'Parker')::hero AS hero
$$

修复似乎分为两部分：

1. 有必要添加 aHeroTypeHandler并通过 映射它SqlMapper.AddTypeHandler。
2. 我需要通过将我的类型映射Hero到我的 PostgreSQL 复合类型。然而，我的直觉（到目前为止）是，这只是我在与自己的集成测试作斗争，因为在真实的应用程序中，在应用程序开始时全局注册所有复合类型可能（？）是理想的选择。（或者如果有很多，可能不是由于性能原因？）heroconn.TypeMapper.MapComposite

但我不喜欢这个解决方案的是，我的解决方案并HeroTypeHandler没有真正提供任何真正的价值（没有双关语）。通过简单地分配value工作parameter.Value，我的猜测是，这是 Dapper 会为通话所做的事情，但显然不是。(?) 如果我有很多复合类型，我宁愿不需要对它们这样做。

请注意，由于我只关心将此类型发送到PostgreSQL 函数，因此我发现没有必要实现该Parse方法，因此NotImplementedException. 青年MMV

另外，由于自从我发布原始问题以来进行了一些重构，还存在一些其他细微差别。然而，它们与上面详述的整体修复无关。