Can't infer NpgsqlDbType for type XXX" exception when trying to pass composite type array as parameter from c# code for postgreSQL function.

[adityarana3]

Steps to reproduce

Code Sample:
register composite type in constructor

NpgsqlConnection.GlobalTypeMapper.MapComposite<CompositeTypeOption>("composite_type");

**code in function:**

```c#
var compositeTypeOption= new List<CompositeTypeOption>();
foreach (DataRow row in datatable.Rows)
{
    compositeTypeOption.Add(new FileFilterOption { filterextensions = row["filterextensions"].ToString(), filtertypes = row["filtertypes"].ToString(), filtername = row["filtername"].ToString() });
}

var parameters = new[]
{
    new NpgsqlParameter("par_id", workkardId),
    new NpgsqlParameter{ParameterName = "par_composit_type",Direction = ParameterDirection.Input,Value =compositeTypeOption.ToArray() ,DataTypeName="composite_type"}
};

var entity = ExecuteComplexQuery<WorkkardFileView>("postgres_function_name", CommandType.StoredProcedure, parameters);

The issue

*message : System.NotSupportedException
Can't infer NpgsqlDbType for type CompositeTypes.CompositeTypeOption

Exception message:
Stack trace:

### Further technical details

Npgsql version: 4.0.2.0
PostgreSQL version: PostgreSQL 10.3 (Ubuntu 10.3-1.pgdg16.04+1) on x86_64-pc-linux-gnu, compiled by gcc (Ubuntu 5.4.0-6ubuntu1~16.04.9) 5.4.0 20160609, 64-bit
Operating system: Ubuntu 

[roji]

Can you please post the actual code sending the query (ExecuteComplexQuery())?

[adityarana3]

ExecuteComplexQuery Code

protected virtual ReadOnlyCollection<TComplex> ExecuteComplexQuery<TComplex>(string sproc, CommandType commandType, DbParameter[] parameters)
           where TComplex : class
        {
            ReadOnlyCollection<TComplex> collection;
            var dataSet = new DataSet();
            IEnumerable<TComplex> results;

            var customEntityMapping = GetMappingOfIMappableEntity<TComplex>();

            using (var connection = new ConnectionProvider(readConnectionString).Connection)
            {
                if (connection.State != ConnectionState.Open)
                    connection.Open();

                using (var command = new NpgsqlCommand(sproc, connection as NpgsqlConnection) { CommandType = commandType, CommandTimeout = 0 })
                {
                    try
                    {
                        var ngParameters = parameters as IEnumerable<NpgsqlParameter>;

                        if (parameters != null)
                            command.Parameters.AddRange(SetDBNull(parameters));

                        var hasRefcursor = ngParameters.Count(x => x.NpgsqlDbType == NpgsqlDbType.Refcursor) > 0;

                        if (hasRefcursor)
                        {
                            using (var transaction = connection.BeginTransaction())
                            {
                                try
                                {
                                    var reader = command.ExecuteReader();
                                    reader.Dispose();

                                    using (var fetchCommand = new NpgsqlCommand())
                                    {
                                        fetchCommand.Connection = command.Connection;
                                        fetchCommand.Transaction = transaction as NpgsqlTransaction;
                                        fetchCommand.CommandTimeout = command.CommandTimeout;
                                        fetchCommand.CommandText = GetFetchCommand(parameters); ;
                                        fetchCommand.CommandType = CommandType.Text;

                                        using (var cursorReader = fetchCommand.ExecuteReader())
                                        {
                                            var list = MapReader<TComplex>.ToObjectList(cursorReader, customEntityMapping);
                                            collection = list.ToReadOnlyCollection();
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    throw ex;
                                }
                                finally
                                {
                                    transaction.Commit();
                                }
                            }
                        }
                        else
                        {
                            using (var reader = command.ExecuteReader(CommandBehavior.CloseConnection))
                            {
                                var list = MapReader<TComplex>.ToObjectList(reader, customEntityMapping);
                                collection = list.ToReadOnlyCollection();
                            }
                        }
                    }

                    catch (Exception error)
                    {
                        throw error;
                    }

                    finally
                    {
                        if (connection.State == ConnectionState.Open) connection.Close();
                    }
                }
            }

            return collection;
        }

[adityarana3]

NPGSQL 3.2.7 following parameter working fine

new NpgsqlParameter{ParameterName = "par_composit_type",NpgsqlDbType = NpgsqlDbType.Composite,Direction = ParameterDirection.Input,Value =compositeTypeOption.ToArray() ,SpecificType=typeof(CompositeTypeOption[])},

Now I upgrade it to 4.0.2.0
What should I pass "NpgsqlDbType" for following parameter?

new NpgsqlParameter{ParameterName = "par_composit_type",Direction = ParameterDirection.Input,Value =compositeTypeOption.ToArray() ,DataTypeName="composite_type"}

[adityarana3]

Is there any update?

[YohDeadfall]

You should add square brackets to the data type name.

DataTypeName="composite_type[]"

[roji]

One additional comment: if you mapped your composite with Npgsql as described in the docs, then you don't need to set either NpgsqlDbType or DataTypeName, just set the parameter's value and npgsql will infer from it's type.

[adityarana3]

Thanks for giving support now it's working on my end.