Como inserir um registro atualizável com coluna JSON no PostgreSQL usando JOOQ?

Versões atuais do jOOQ

jOOQ tem suporte nativo para JSON e JSONB tipos de dados, para que você não precise fazer nada específico.

Resposta histórica

Desde o jOOQ 3.5, você pode registrar seus próprios tipos de dados personalizados para o gerador de código, conforme documentado aqui:

http://www.jooq.org/doc/latest/manual/code-generation/custom-data-type-bindings

Ao contrário de um Converter , uma Binding determina como seu tipo de dados está sendo tratado no nível JDBC dentro do jOOQ, sem que o jOOQ saiba sobre sua implementação. Ou seja, você não apenas definirá como converter entre <T> e <U> tipos (T =tipo de banco de dados, U =user type), mas você também poderá definir como são esses tipos:

Renderizado como SQL
Ligado a declarações preparadas
Ligado a SQLOutput
Registrado em CallableStatements como parâmetros OUT
Buscado de ResultSets
Buscado de SQLInput
Buscado de CallableStatements como parâmetros OUT

Um exemplo de Binding para uso com Jackson para produzir JsonNode tipos é dado aqui:

public class PostgresJSONJacksonJsonNodeBinding 
implements Binding<Object, JsonNode> {

    @Override
    public Converter<Object, JsonNode> converter() {
        return new PostgresJSONJacksonJsonNodeConverter();
    }

    @Override
    public void sql(BindingSQLContext<JsonNode> ctx) throws SQLException {

        // This ::json cast is explicitly needed by PostgreSQL:
        ctx.render().visit(DSL.val(ctx.convert(converter()).value())).sql("::json");
    }

    @Override
    public void register(BindingRegisterContext<JsonNode> ctx) throws SQLException {
        ctx.statement().registerOutParameter(ctx.index(), Types.VARCHAR);
    }

    @Override
    public void set(BindingSetStatementContext<JsonNode> ctx) throws SQLException {
        ctx.statement().setString(
            ctx.index(), 
            Objects.toString(ctx.convert(converter()).value()));
    }

    @Override
    public void get(BindingGetResultSetContext<JsonNode> ctx) throws SQLException {
        ctx.convert(converter()).value(ctx.resultSet().getString(ctx.index()));
    }

    @Override
    public void get(BindingGetStatementContext<JsonNode> ctx) throws SQLException {
        ctx.convert(converter()).value(ctx.statement().getString(ctx.index()));
    }

    // The below methods aren't needed in PostgreSQL:

    @Override
    public void set(BindingSetSQLOutputContext<JsonNode> ctx) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }

    @Override
    public void get(BindingGetSQLInputContext<JsonNode> ctx) throws SQLException {
        throw new SQLFeatureNotSupportedException();
    }
}

E o Converter que é usado acima pode ser visto aqui:

public class PostgresJSONJacksonJsonNodeConverter 
implements Converter<Object, JsonNode> {
    @Override
    public JsonNode from(Object t) {
        try {
            return t == null 
              ? NullNode.instance 
              : new ObjectMapper().readTree(t + "");
        }
        catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public Object to(JsonNode u) {
        try {
            return u == null || u.equals(NullNode.instance) 
              ? null 
              : new ObjectMapper().writeValueAsString(u);
        }
        catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

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

    @Override
    public Class<JsonNode> toType() {
        return JsonNode.class;
    }
}

Agora você pode registrar a ligação acima por meio da configuração do gerador de código:

<customType>
    <name>com.example.PostgresJSONJacksonJsonNodeBinding</name>
    <type>com.fasterxml.jackson.databind.JsonNode</type>
    <binding>com.example.PostgresJSONJacksonJsonNodeBinding</binding>
</customType>

<forcedType>
    <name>com.example.PostgresJSONJacksonJsonNodeBinding</name>
    <expression>my_schema\.table\.json_field</expression>
</forcedType>