Why does my query fail when passing an array of enums, but works with a single enum?

[Laky-64]

I'm trying to run a PostgreSQL query that accepts an array of custom enums as input. It works fine when I pass a single enum value, but it fails when I pass a slice (array) of enums.

Error:

bot           | 2025-07-21 13:37:35  Db        github.com.laky_64...    E  SECOND failed to encode args[0]: unable to encode []models.LinkStatusEnum{"available"} into text format for unknown type (OID 16392): cannot find encode plan
bot           |                                                             at NewDB( context.go:104 )                                                                                                                                  
bot           |                                                             at main.main( main.go:23 )            

My Enum:

type LinkStatusEnum string

const (
	LinkStatusEnumAvailable = "available"
	LinkStatusEnumFull      = "full"
	LinkStatusEnumClosed    = "closed"
	LinkStatusEnumInvalid   = "invalid"
)

func (e *LinkStatusEnum) Scan(value interface{}) error {
	if value == nil {
		*e = ""
		return nil
	}
	switch s := value.(type) {
	case []byte:
		*e = LinkStatusEnum(s)
	case string:
		*e = LinkStatusEnum(s)
	}
	return nil
}

func (ns LinkStatusEnum) Value() (driver.Value, error) {
	if ns == "" {
		return nil, nil
	}
	return string(ns), nil
}

My Function:

const test = `WITH input_data AS (
    SELECT
        UNNEST($1::link_status_enum[]) AS status
)
SELECT links.id, links.url, links.app_id, links.status, links.created_at, links.updated_at, links.last_availability FROM links
JOIN input_data i ON links.status = i.status`

func (ctx *LinkStore) Test(statuses []models.LinkStatusEnum) ([]models.Link, error) {
	var i []models.Link
	rows, errQuery := ctx.db.Query(
		ctx.cx,
		test,
		statuses,
	)
	defer rows.Close()
	if errQuery != nil {
		return nil, errQuery
	}
	for rows.Next() {
		var item models.Link
		errScan := rows.Scan(
			&item.ID,
			&item.URL,
			&item.AppID,
			&item.Status,
			&item.CreatedAt,
			&item.UpdatedAt,
			&item.LastAvailability,
		)
		if errScan != nil {
			if errors.Is(errScan, pgx.ErrNoRows) {
				errScan = nil
			}
			return nil, errScan
		}
		i = append(i, item)
	}
	if rows.Err() != nil {
		return nil, rows.Err()
	}
	return i, nil
}

[jackc]

pgx only knows what type a PostgreSQL value is based on the OID. Builtin types have constant OIDs, but custom types like enums have there own OID. When using a Go string with an unknown OID pgx simply passes the value along unmodified. That works fine for enums. But an array of enum needs to be encoded differently.

See the Go docs for the pgtype package. In particular you will probably want to look at LoadType and RegisterType.