使用jOOQ转换PostgreSQLUUID数组的类型

Question

我试图将PostgreSQL（9.4）UUID绑定到每个UUID周围的包装类数组。请注意，这些包装器在整个应用程序中都是集成的，因此删除它们不是一个选项。我正在使用jOOQ和它的maven插件（3.5.1）来生成PoJo、记录和表类。

我在绑定数据库模式时遇到问题的相关部分如下所示：

create table foo (
    id uuid primary key,
    ids uuid[] not null
);

然后，我尝试使用forcedType元素转换该类，但它生成的类无法编译。放弃这一点，我只是将它们作为UUID生成，直到我遇到一些问题，其中数组值不能转换为UUID，PostgreSQL认为该数组在我的查询中是一个文本数组[1]。

为了解决这个问题，我尝试添加一个绑定和一个转换器，其中转换器用我们的包装器包装UUID，绑定将强制转换表达式添加到生成的SQL中。如果我编写了一个流畅的查询[4]，那么这可以很好地工作，但是在插入记录时，它不能正常工作。当我逐段构建数组查询时，insert语句以“array”结束。长度-1’参数化零件。我怀疑我需要重写绑定类的get和set方法，但是我发现这方面的文档有点少。

所以我的问题是，在jOOQ中绑定UUID数组的正确方法是什么，使用还是不使用绑定类？此外，在此过程中是否可以将其转换为T数组？

1. 查询（名称已更改）

public BazId getBazIdBySearchingFooIdsInReverse(
        @NotNull final OtherId otherId,
        @NotNull final SomethingId somethingId,
        @NotNull final String barTypeName,
        @NotNull final SomethingElseId somethingElseId) {
    final Bar bar = BAR.as("bar");
    final Foo foo = FOO.as("foo");
    return db.select(BAZ.ID)
             .from(BAZ)
             .join(bar)
             .on(BAZ.SOMETHING_ID.eq(bar.SOMETHING_ID))
             .join(foo)
             .on(bar.FOO_ID.eq(foo.ID))
             .join("lateral unnest(foo.ids) with ordinality as x (id,ord)")
             .on("x.id=foo.id")
             .join(BAR_TYPE)
             .on(bar.BAR_TYPE_ID.eq(BAR_TYPE.ID)
                                .and(BAR_TYPE.NAME.equalIgnoreCase(barTypeName)))
             .where(BAZ.SOMETHING_ID.eq(somethingId))
             .and(BAZ.SOMETHING_ELSE_ID.eq(somethingElseId))
             .and(bar.OTHER_ID.eq(otherId))
             .orderBy(DSL.field("x.ord").desc())
             .limit(1)
             .fetchOneInto(BazId.class); //Wraps a UUID
}

public class FooIdsBinding extends DefaultBinding<Object[], FooId[]> {
    private static final long serialVersionUID = 0L;

    private static final UUIDConverter converter = new UUIDConverter();

    public FooIdsBinding() {
        super(new FooIdsConverter());
    }

    @Override
    public void sql(final BindingSQLContext<FooId[]> ctx) {
        final RenderContext render = ctx.render();
        render.sql("array[");
        final UUID[] uuids = ctx.convert(converter).value();
        for (int i = 0, last = uuids.length - 1; i <= last; ++i) {
            render.visit(DSL.val(uuids[i])).sql("::uuid");
            if (i != last) {
                render.sql(',');
            }
        }
        render.sql("]::uuid[]");
    }

    @Override
    public void register(final BindingRegisterContext<FooId[]> ctx) throws SQLException {
        ctx.statement().registerOutParameter(ctx.index(), Types.ARRAY);
    }

    static class BaseUUIDConverter {

        public FooId[] from(final Object[] from) {
            return from == null ? null : Arrays.stream(from)
                                               .map(that -> new FooId((UUID)that))
                                               .collect(Collectors.toList())
                                               .toArray(new FooId[from.length]);
        }

        public UUID[] to(final FooId[] from) {
            return from == null ? null : Arrays.stream(from)
                                               .map(FooId::getUuid)
                                               .collect(Collectors.toList())
                                               .toArray(new UUID[from.length]);
        }

        public Class<FooId[]> toType() {
            return FooId[].class;
        }
    }

    private static class UUIDConverter extends BaseUUIDConverter implements Converter<UUID[], FooId[]> {

        @Override
        public FooId[] from(final UUID[] that) {
            return super.from(that);
        }

        @Override
        public Class<UUID[]> fromType() {
            return UUID[].class;
        }
    }
}

public class FooIdConverter extends FooIdsBinding.BaseUUIDConverter implements Converter<Object[],FooId[]> {
    private static final long serialVersionUID = 0L;

    @Override
    public Class<Object[]> fromType() {
        return (Class)UUID[].class;
    }
}

    db.insertInto(FOO)
      .set(FOO.ID, new FooId())
      .set(FOO.IDS, new FooId[]{new FooId(),new FooId()})
      .execute();

    foo = new FooRecord();
    foo.setId(new FooId());
    foo.setIds(new FooId[]{new FooId(),new FooId()});
    db.executeInsert(foo);

使现代化

我最终得到了这个绑定和转换器，它工作正常。我原以为我需要将数组的每个元素强制转换为uuid，我的实现给jOOQ的sql生成带来了问题，但我认为我只看到了与错误相关的错误，当jOOQ在我将绑定#寄存器#重写为数组之前。

>

转换器

public class FooIdConverter implements Converter<Object[],FooId[]> {

    private static final long serialVersionUID = 1L;

    @Override
    public FooId[] from(final Object[] from) {
        return from == null ? null : Arrays.stream(from)
                                           .map(that -> new FooId((UUID)that))
                                           .collect(Collectors.toList())
                                           .toArray(new FooId[from.length]);
    }

    @Override
    public UUID[] to(final FooId[] from) {
        return from == null ? null : Arrays.stream(from)
                                           .map(FooId::getUuid)
                                           .collect(Collectors.toList())
                                           .toArray(new UUID[from.length]);
    }

    @Override
    @SuppressWarnings("unchecked")
    public Class<Object[]> fromType() {
        return (Class)UUID[].class;
    }

    @Override
    public Class<FooId[]> toType() {
        return FooId[].class;
    }
}

结合

public class FooIdBinding extends DefaultBinding<Object[], FooId[]> {

    private static final long serialVersionUID = 1L;

    public FooIdBinding() {
        super(new FooIdConverter());
    }

    @Override
    public void sql(final BindingSQLContext<FooId[]> ctx) {
        super.sql(ctx);
        ctx.render().sql("::uuid[]");
    }

    @Override
    public void register(final BindingRegisterContext<FooId[]> ctx) throws SQLException {
        ctx.statement().registerOutParameter(ctx.index(), Types.ARRAY);
    }

    @Override
    public void get(final BindingGetResultSetContext<FooId[]> ctx) throws SQLException {
        ctx.value(_convert(ctx.resultSet().getArray(ctx.index())));
    }

    @Override
    public void get(final BindingGetStatementContext<FooId[]> ctx) throws SQLException {
        ctx.value(_convert(ctx.statement().getArray(ctx.index())));
    }

    @Override
    public void get(final BindingGetSQLInputContext<FooId[]> ctx) throws SQLException {
        ctx.value(_convert(ctx.input().readArray()));
    }

    @Override
    public void set(final BindingSetStatementContext<FooId[]> ctx) throws SQLException {
        final PreparedStatement ps = ctx.statement();
        ps.setArray(ctx.index(), ps.getConnection().createArrayOf("uuid", ctx.value()));
    }

    @Override
    public void set(final BindingSetSQLOutputContext<FooId[]> ctx) throws SQLException {
        throw new UnsupportedOperationException();
    }

    protected FooId[] _convert(final Array array) throws SQLException {
        if (array == null) {
            return null;
        } else {
            return converter().from(((UUID[]) array.getArray()));
        }
    }
}

Answer 1

jOOQ代码生成器中似乎存在一个bug，它阻止覆盖UUID[]类型：#4388