anotasi hibernasi yang tepat untuk byte []

Saya memiliki aplikasi yang menggunakan anotasi hibernate 3.1 dan JPA. Ini memiliki beberapa objek dengan atribut byte [] (ukuran 1k - 200k). Ia menggunakan anotasi JPA @Lob, dan hibernate 3.1 dapat membacanya dengan baik di semua database utama - tampaknya menyembunyikan kekhasan vendor JDBC Blob (sebagaimana mestinya).

@Entity
public class ConfigAttribute {
  @Lob
  public byte[] getValueBuffer() {
    return m_valueBuffer;
  }
}

Kami harus meningkatkan ke 3.5, ketika kami menemukan bahwa hibernate 3.5 rusak (dan tidak akan memperbaiki) kombinasi anotasi ini di postgresql (tanpa solusi). Saya belum menemukan perbaikan yang jelas sejauh ini, tetapi saya perhatikan bahwa jika saya hanya menghapus @Lob, itu menggunakan bytea tipe postgresql (yang berfungsi, tetapi hanya pada postgres).

annotation                   postgres     oracle      works on
-------------------------------------------------------------
byte[] + @Lob                oid          blob        oracle
byte[]                       bytea        raw(255)    postgresql
byte[] + @Type(PBA)          oid          blob        oracle
byte[] + @Type(BT)           bytea        blob        postgresql

once you use @Type, @Lob seems to not be relevant
note: oracle seems to have deprecated the "raw" type since 8i.

Saya mencari cara untuk memiliki kelas beranotasi tunggal (dengan properti blob) yang portabel di seluruh database utama.

• Apa cara portabel untuk menganotasi properti byte []?
• Apakah ini diperbaiki di beberapa versi hibernasi terbaru?

Pembaruan: Setelah membaca blog ini, saya akhirnya menemukan solusi asli dalam masalah JIRA: Rupanya Anda seharusnya menghapus @Lob dan memberi anotasi pada properti sebagai:

@Type(type="org.hibernate.type.PrimitiveByteArrayBlobType") 
byte[] getValueBuffer() {...

Namun, ini tidak berhasil untuk saya - saya masih mendapatkan OID, bukan bytea; namun hal itu berhasil untuk penulis masalah JIRA, yang sepertinya menginginkan oid.

Setelah jawaban dari A. Garcia, saya kemudian mencoba kombo ini, yang sebenarnya berfungsi pada postgresql, tetapi tidak pada oracle.

@Type(type="org.hibernate.type.BinaryType") 
byte[] getValueBuffer() {...

Yang benar-benar perlu saya lakukan adalah mengontrol @ org.hibernate.annotations. Ketik kombinasi (@Lob + byte [] yang dipetakan) ke (di postgresql).

Berikut adalah potongan dari 3.5.5. Final dari MaterializedBlobType (sql type Blob). Menurut blog Steve, postgresql ingin Anda menggunakan Streams untuk bytea (jangan tanya saya mengapa) dan jenis Blob kustom postgresql untuk oids. Perhatikan juga bahwa menggunakan setBytes () di JDBC juga untuk bytea (dari pengalaman sebelumnya). Jadi ini menjelaskan mengapa use-stream tidak memengaruhi mereka berdua menganggap 'bytea'.

public void set(PreparedStatement st, Object value, int index) {
 byte[] internalValue = toInternalFormat( value );
 if ( Environment.useStreamsForBinary() ) {
  // use streams = true
   st.setBinaryStream( index, 
    new ByteArrayInputStream( internalValue ), internalValue.length );
 }
 else {
  // use streams = false
  st.setBytes( index, internalValue );
 }
}

Ini menghasilkan:

ERROR: column "signature" is of type oid but expression is of type bytea

Perbarui Pertanyaan logis berikutnya adalah: "mengapa tidak mengubah definisi tabel secara manual ke bytea" dan menyimpan (@Lob + byte [])? Ini tidak bekerja, UNTIL Anda mencoba untuk menyimpan null byte []. Yang menurut driver postgreSQL adalah ekspresi tipe OID dan tipe kolom adalah bytea - ini karena hibernate (dengan benar) memanggil JDBC.setNull () dan bukan JDBC.setBytes (null) yang diharapkan driver PG.

ERROR: column "signature" is of type bytea but expression is of type oid

Sistem tipe dalam mode hibernasi saat ini sedang dalam proses (menurut komentar penghentian 3.5.5). Faktanya, begitu banyak kode 3.5.5 yang tidak digunakan lagi, sulit untuk mengetahui apa yang harus dilihat saat melakukan sub-klasifikasi PostgreSQLDialect).

AFAKT, Types.BLOB / 'oid' pada postgresql harus dipetakan ke beberapa tipe kustom yang menggunakan akses JDBC gaya OID (yaitu objek PostgresqlBlobType dan NOT MaterializedBlobType). Saya tidak pernah benar-benar berhasil menggunakan Blobs dengan postgresql, tetapi saya tahu bahwa bytea hanya berfungsi seperti yang saya harapkan.

Saat ini saya melihat BatchUpdateException - kemungkinan driver tidak mendukung batching.

Kutipan bagus dari 2004: "Untuk menyimpulkan ocehan saya, saya akan mengatakan mereka kita harus menunggu driver JDBC melakukan LOB dengan benar sebelum mengubah Hibernate."

Referensi:

• https://forum.hibernate.org/viewtopic.php?p=2393203
• https://forum.hibernate.org/viewtopic.php?p=2435174
• http://hibernate.atlassian.net/browse/HHH-4617
• http://postgresql.1045698.n5.nabble.com/Migration-to-Hibernate-3-5-final-td2175339.html
• https://jira.springframework.org/browse/SPR-2318
• https://forums.hibernate.org/viewtopic.php?p=2203382&sid=b526a17d9cf60a80f13d40cf8082aafd
• http://virgo47.wordpress.com/2008/06/13/jpa-postgresql-and-bytea-vs-oid-type/

Apa cara portabel untuk menganotasi properti byte []?

Itu tergantung pada apa yang Anda inginkan. JPA bisa tetap tanpa anotasi byte[]. Dari spesifikasi JPA 2.0:

11.1.6 Anotasi Dasar

The Basicpenjelasan adalah jenis yang paling sederhana dari pemetaan untuk kolom database. The Basicpenjelasan dapat diterapkan untuk properti atau contoh variabel terus-menerus dari salah satu jenis berikut: Java primitif, jenis, pembungkus dari tipe primitif, java.lang.String, java.math.BigInteger, java.math.BigDecimal, java.util.Date, java.util.Calendar, java.sql.Date, java.sql.Time, java.sql.Timestamp, byte[],Byte[] , char[], Character[], enum, dan jenis lainnya yang mengimplementasikan Serializable. Seperti yang dijelaskan di Bagian 2.8, penggunaan Basicanotasi adalah opsional untuk bidang persisten dan properti jenis ini. Jika anotasi Dasar tidak ditentukan untuk bidang atau properti seperti itu, nilai default dari anotasi Dasar akan diterapkan.

Dan Hibernate akan memetakannya "secara default" ke SQL VARBINARY(atau SQL LONGVARBINARYtergantung Columnukurannya?) Yang ditangani PostgreSQL dengan file bytea.

Tetapi jika Anda ingin byte[]disimpan dalam Objek Besar, Anda harus menggunakan file @Lob. Dari spesifikasi:

11.1.24 Penjelasan Lob

Sebuah LobMenentukan penjelasan bahwa properti persisten atau lapangan harus bertahan sebagai sebuah objek besar untuk jenis objek besar database yang didukung. Aplikasi portabel harus menggunakan Lobanotasi saat memetakan ke Lobtipe database . The Lobpenjelasan dapat digunakan dalam hubungannya dengan penjelasan Basic atau dengan ElementCollectionpenjelasan ketika nilai koleksi elemen dari tipe dasar. A Lobdapat berupa biner atau tipe karakter. The Lobjenis disimpulkan dari jenis bidang persisten atau properti dan, kecuali tali dan karakter jenis, default untuk Blob.

Dan Hibernate akan memetakannya ke SQL BLOByang ditangani PostgreSQL dengan file oid .

Apakah ini diperbaiki di beberapa versi hibernasi terbaru?

Nah, masalahnya adalah saya tidak tahu persis apa masalahnya. Tetapi setidaknya saya dapat mengatakan bahwa tidak ada yang berubah sejak 3.5.0-Beta-2 (di mana perubahan telah diperkenalkan) di cabang 3.5.x.

Tetapi pemahaman saya tentang masalah seperti HHH-4876 , HHH-4617 dan PostgreSQL dan BLOBs (disebutkan di javadoc PostgreSQLDialect) adalah bahwa Anda seharusnya mengatur properti berikut

hibernate.jdbc.use_streams_for_binary=false

jika Anda ingin menggunakan oidie byte[]with @Lob(yang menurut pemahaman saya karena VARBINARYbukan yang Anda inginkan dengan Oracle). Apakah kamu sudah mencobanya?

Sebagai alternatif, HHH-4876 menyarankan penggunaan usang PrimitiveByteArrayBlobTypeuntuk mendapatkan perilaku lama (pra Hibernate 3.5).

Referensi

• Spesifikasi JPA 2.0
  • Bagian 2.8 "Pemetaan Default untuk Non-Relasi Bidang atau Properti"
  • Bagian 11.1.6 "Anotasi Dasar"
  • Bagian 11.1.24 "Penjelasan Lob"

Sumber daya

• http://opensource.atlassian.com/projects/hibernate/browse/HHH-4876
• http://opensource.atlassian.com/projects/hibernate/browse/HHH-4617
• http://relation.to/Bloggers/PostgreSQLAndBLOBs

Inilah yang dikatakan oleh O'reilly Enterprise JavaBeans, 3.0

JDBC memiliki tipe khusus untuk objek yang sangat besar ini. Jenis java.sql.Blob mewakili data biner , dan java.sql.Clob mewakili data karakter.

Ini dia kode sumber PostgreSQLDialect

public PostgreSQLDialect() {
    super();
    ...
    registerColumnType(Types.VARBINARY, "bytea");
    /**
      * Notice it maps java.sql.Types.BLOB as oid
      */
    registerColumnType(Types.BLOB, "oid");
}

Jadi apa yang bisa Anda lakukan

Ganti PostgreSQLDialect sebagai berikut

public class CustomPostgreSQLDialect extends PostgreSQLDialect {

    public CustomPostgreSQLDialect() {
        super();

        registerColumnType(Types.BLOB, "bytea");
    }
}

Sekarang tentukan saja dialek khusus Anda

<property name="hibernate.dialect" value="br.com.ar.dialect.CustomPostgreSQLDialect"/>

Dan gunakan anotasi JPA @Lob portabel Anda

@Lob
public byte[] getValueBuffer() {

MEMPERBARUI

Berikut telah diekstrak di sini

Saya memiliki aplikasi yang berjalan dalam hibernate 3.3.2 dan aplikasi berfungsi dengan baik , dengan semua bidang gumpalan menggunakan oid (byte [] di java)

...

Bermigrasi ke hibernasi 3.5 semua bidang blob tidak berfungsi lagi , dan log server menunjukkan: ERROR org.hibernate.util.JDBCExceptionReporter - ERROR: kolom berjenis oid tetapi ekspresi bertipe bytea

yang bisa dijelaskan disini

Secara umum ini bukan bug di PG JDBC , tetapi perubahan implementasi default Hibernate dalam versi 3.5 . Dalam situasi saya, pengaturan properti yang kompatibel pada koneksi tidak membantu .

...

Terlebih lagi ini yang saya lihat di 3.5 - beta 2, dan saya tidak tahu apakah ini diperbaiki adalah Hibernate - tanpa @Type annotation - akan otomatis membuat kolom tipe oid, tetapi akan mencoba membaca ini sebagai bytea

Menarik karena ketika dia memetakan Type.BOLB sebagai bytea (Lihat CustomPostgreSQLDialect) Dia mendapatkan

Tidak dapat menjalankan pembaruan batch JDBC

saat memasukkan atau memperbarui

Saya menggunakan Hibernate 4.2.7.SP1 dengan Postgres 9.3 dan berikut ini berfungsi untuk saya:

@Entity
public class ConfigAttribute {
  @Lob
  public byte[] getValueBuffer() {
    return m_valueBuffer;
  }
}

karena Oracle tidak memiliki masalah dengan itu, dan untuk Postgres saya menggunakan dialek khusus:

public class PostgreSQLDialectCustom extends PostgreSQL82Dialect {

    @Override
    public SqlTypeDescriptor remapSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor) {
    if (sqlTypeDescriptor.getSqlType() == java.sql.Types.BLOB) {
      return BinaryTypeDescriptor.INSTANCE;
    }
    return super.remapSqlTypeDescriptor(sqlTypeDescriptor);
  }
}

keuntungan dari solusi ini saya anggap, bahwa saya dapat menjaga stoples hibernasi tidak tersentuh.

Untuk masalah kompatibilitas Postgres / Oracle lainnya dengan Hibernate, lihat posting blog saya .

Saya akhirnya mendapatkan ini bekerja. Ini memperluas solusi dari A. Garcia, bagaimanapun, karena masalahnya terletak pada tipe hibernate tipe MaterializedBlob hanya pemetaan Blob> bytea tidak cukup, kita memerlukan pengganti MaterializedBlobType yang bekerja dengan dukungan blob hibernate yang rusak. Implementasi ini hanya bekerja dengan bytea, tetapi mungkin orang dari masalah JIRA yang menginginkan OID dapat berkontribusi dalam implementasi OID.

Sayangnya, mengganti jenis ini saat runtime sangat merepotkan, karena mereka harus menjadi bagian dari Dialek. Kalau saja penambahan JIRA ini masuk ke 3.6 itu bisa.

public class PostgresqlMateralizedBlobType extends AbstractSingleColumnStandardBasicType<byte[]> {
 public static final PostgresqlMateralizedBlobType INSTANCE = new PostgresqlMateralizedBlobType();

 public PostgresqlMateralizedBlobType() {
  super( PostgresqlBlobTypeDescriptor.INSTANCE, PrimitiveByteArrayTypeDescriptor.INSTANCE );
 }

  public String getName() {
   return "materialized_blob";
  }
}

Banyak dari ini mungkin bisa statis (apakah getBinder () benar-benar membutuhkan contoh baru?), Tetapi saya tidak begitu memahami hibernate internal jadi ini sebagian besar adalah salin + tempel + ubah.

public class PostgresqlBlobTypeDescriptor extends BlobTypeDescriptor implements SqlTypeDescriptor {
  public static final BlobTypeDescriptor INSTANCE = new PostgresqlBlobTypeDescriptor();

  public <X> ValueBinder<X> getBinder(final JavaTypeDescriptor<X> javaTypeDescriptor) {
   return new PostgresqlBlobBinder<X>(javaTypeDescriptor, this);
  }
  public <X> ValueExtractor<X> getExtractor(final JavaTypeDescriptor<X> javaTypeDescriptor) {
   return new BasicExtractor<X>( javaTypeDescriptor, this ) {
    protected X doExtract(ResultSet rs, String name, WrapperOptions options) throws SQLException { 
      return (X)rs.getBytes(name);
    }
   };
  }
}

public class PostgresqlBlobBinder<J> implements ValueBinder<J> {
 private final JavaTypeDescriptor<J> javaDescriptor;
 private final SqlTypeDescriptor sqlDescriptor;

 public PostgresqlBlobBinder(JavaTypeDescriptor<J> javaDescriptor, SqlTypeDescriptor sqlDescriptor) { 
  this.javaDescriptor = javaDescriptor; this.sqlDescriptor = sqlDescriptor;
 }  
 ...
 public final void bind(PreparedStatement st, J value, int index, WrapperOptions options) 
 throws SQLException {
  st.setBytes(index, (byte[])value);
 }
}

saya memperbaiki masalah saya dengan menambahkan anotasi @Lob yang akan membuat byte [] di oracle sebagai blob, tetapi anotasi ini akan membuat bidang sebagai oid yang tidak berfungsi dengan baik, Untuk membuat byte [] dibuat sebagai bytea saya membuat dialek pelanggan untuk postgres seperti di bawah ini

Public class PostgreSQLDialectCustom extends PostgreSQL82Dialect {
    public PostgreSQLDialectCustom() {
        System.out.println("Init PostgreSQLDialectCustom");
        registerColumnType( Types.BLOB, "bytea" );

      }

    @Override
    public SqlTypeDescriptor remapSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor) {
    if (sqlTypeDescriptor.getSqlType() == java.sql.Types.BLOB) {
      return BinaryTypeDescriptor.INSTANCE;
    }
    return super.remapSqlTypeDescriptor(sqlTypeDescriptor);
  }
 }

Juga perlu mengganti parameter untuk Dialek

spring.jpa.properties.hibernate.dialect = com.ntg.common.DBCompatibilityHelper.PostgreSQLDialectCustom

lebih banyak petunjuk dapat ditemukan di: https://dzone.com/articles/postgres-and-oracle

Saya berhasil melakukannya dengan mengganti anotasi dengan file XML untuk Postgres. Anotasi disimpan untuk Oracle. Menurut pendapat saya, dalam hal ini akan lebih baik kita menimpa pemetaan masalah-beberapa enity ini dengan pemetaan xml. Kita dapat mengganti satu / beberapa entitas dengan pemetaan xml. Jadi kami akan menggunakan anotasi untuk basis data kami yang sebagian besar didukung, dan file xml untuk basis data satu sama lain.

Catatan: kita hanya perlu mengganti satu kelas, jadi ini bukan masalah besar. Baca lebih lanjut dari contoh saya Contoh untuk mengganti anotasi dengan XML

Pada Postgres @Lob melanggar byte [] saat mencoba menyimpannya sebagai oid, dan untuk String juga terjadi masalah yang sama. Kode di bawah ini melanggar postgres yang berfungsi dengan baik di oracle.

@Lob
private String stringField;

dan

@Lob
private byte[]   someByteStream;

Untuk memperbaiki di atas pada postgres telah menulis di bawah hibernate.dialect kustom

public class PostgreSQLDialectCustom extends PostgreSQL82Dialect{

public PostgreSQLDialectCustom()
{
    super();
    registerColumnType(Types.BLOB, "bytea");
}

 @Override
 public SqlTypeDescriptor remapSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor) {
    if (Types.CLOB == sqlTypeDescriptor.getSqlType()) {
      return LongVarcharTypeDescriptor.INSTANCE;
    }
    return super.remapSqlTypeDescriptor(sqlTypeDescriptor);
  }
}

Sekarang konfigurasikan dialek khusus dalam mode hibernasi

hibernate.dialect=X.Y.Z.PostgreSQLDialectCustom   

XYZ adalah nama paket.

Sekarang bekerja dengan baik. CATATAN- Versi Hibernate saya - 5.2.8. Versi Postgres akhir- 9.6.3

Terima kasih Justin, Pascal karena telah membimbing saya ke arah yang benar. Saya juga menghadapi masalah yang sama dengan Hibernate 3.5.3. Penelitian dan petunjuk Anda ke kelas yang tepat telah membantu saya mengidentifikasi masalah dan melakukan perbaikan.

Untuk keuntungan bagi mereka yang masih terjebak dengan Hibernate 3.5 dan menggunakan kombinasi oid + byte [] + @LoB, berikut adalah apa yang telah saya lakukan untuk memperbaiki masalah tersebut.

1. Saya membuat BlobType kustom memperluas MaterializedBlobType dan menimpa set dan metode get dengan akses gaya oid.

   public class CustomBlobType extends MaterializedBlobType {
   
   private static final String POSTGRESQL_DIALECT = PostgreSQLDialect.class.getName();
   
   /**
    * Currently set dialect.
    */
   private String dialect = hibernateConfiguration.getProperty(Environment.DIALECT);
   
   /*
    * (non-Javadoc)
    * @see org.hibernate.type.AbstractBynaryType#set(java.sql.PreparedStatement, java.lang.Object, int)
    */
   @Override
   public void set(PreparedStatement st, Object value, int index) throws HibernateException, SQLException {
       byte[] internalValue = toInternalFormat(value);
   
       if (POSTGRESQL_DIALECT.equals(dialect)) {
           try {
   
   //I had access to sessionFactory through a custom sessionFactory wrapper.
   st.setBlob(index, Hibernate.createBlob(internalValue, sessionFactory.getCurrentSession()));
               } catch (SystemException e) {
                   throw new HibernateException(e);
               }
           } else {
               st.setBytes(index, internalValue);
           }
       }
   
   /*
    * (non-Javadoc)
    * @see org.hibernate.type.AbstractBynaryType#get(java.sql.ResultSet, java.lang.String)
    */
   @Override
   public Object get(ResultSet rs, String name) throws HibernateException, SQLException {
       Blob blob = rs.getBlob(name);
       if (rs.wasNull()) {
           return null;
       }
       int length = (int) blob.length();
       return toExternalFormat(blob.getBytes(1, length));
     }
   }

   2. Daftarkan CustomBlobType dengan Hibernate. Berikut adalah apa yang saya lakukan untuk mencapai itu.

      hibernateConfiguration= new AnnotationConfiguration();
      Mappings mappings = hibernateConfiguration.createMappings();
      mappings.addTypeDef("materialized_blob", "x.y.z.BlobType", null);