Échec de désérialisation d'objet dans la mise à niveau d'ojdbc14 vers ojdbc6

** Si vous êtes pressé, téléchargez simplement le fichier ojdbc6.jar personnalisé et utilisez-le. Vous n'avez rien d'autre à faire.

https://drive.google.com/open?id=0Bz2PT96Cb0tSRk5XNGU3TUdHS1U

Résumé de ma réponse

Tout d'abord, décompilez les classes mentionnées ci-dessous.

• oracle.sql.DatumWithConnection.class

• oracle.sql.BLOB.class
Ajoutez ensuite les anciens serialVersionUID dans ces classes. (Les anciens identifiants de version sont disponibles dans le journal des erreurs)
Après cela, recompilez les classes.
Enfin, mettez à jour ojdbc6.jar avec les nouvelles classes pour obtenir une bibliothèque ojdbc mise à jour et personnalisée. C'est tout.

Si vous souhaitez créer le JAR manuellement, lisez et suivez les instructions ci-dessous.

Comment créer le JAR personnalisé

Tout d'abord, décompilez les classes mentionnées ci-dessous dans le fichier ojdbc6.jar.

• oracle.sql.DatumWithConnection.class

• oracle.sql.BLOB.class

Pour décompiler, vous pouvez utiliser "Java Decompiler" à http://jd.benow.ca/

(Ce sont les classes qui posaient problème lors de la lecture d'un objet BLOB enregistré à partir de la base de données.)

Créez un projet Java simple (Fichier--> Nouveau--> JavaProject) dans eclipse ou utilisez le Projet simple J'ai créé.

Si vous créez un nouveau projet, ajoutez les fichiers Java décompilés avec la structure d'emballage appropriée (oracle.sql). Vous devez également ajouter le fichier ojdbc6.jar au chemin de construction de ce projet.

Ajoutez ensuite les anciens serialVersionUID dans ces fichiers java décompilés. (Des modifications supplémentaires sont également nécessaires pour compiler ces fichiers java. Veuillez vous référer aux fichiers java mis à jour ci-dessous)
```
 DatumWithConnection.java ->    private static final long serialVersionUID = 491462912477014233L;

 BLOB.java          ->  private static final long serialVersionUID = 2160152488501369185L;
```
Après cela, construisez le projet et récupérez les classes recompilées.
Enfin, mettez à jour ojdbc6.jar avec les nouvelles classes pour obtenir une bibliothèque ojdbc mise à niveau et personnalisée. C'est tout

5.1 Créez un nouveau dossier avec le nom "JAR mis à jour".

5.2 Copiez le fichier ojdbc6.jar dans ce dossier.D:\JARS\Updated JAR\ojdbc.jar

5.3 Sous ce dossier, créez deux nouveaux dossiers pour créer la structure du package pour les fichiers de classe (\oracle\sql)

5.4 Ajoutez les deux fichiers de classe dans le dossier "sql".
```
 D:\JARS\Updated JAR\oracle\sql\DatumWithConnection.class

 D:\JARS\Updated JAR\oracle\sql\BLOB.class
```
5.5 Ouvrez une nouvelle ligne de commande et remplacez le répertoire (cd) par l'emplacement où se trouve le fichier jar.
```
>cd D:\JARS\Updated JAR
```
5.6 Pour mettre à jour le fichier jar avec les nouveaux fichiers de classe, utilisez les commandes mentionnées ci-dessous dans la ligne de commande.
```
>jar uf ojdbc6.jar oracle\sql\DatumWithConnection.class

>jar uf ojdbc6.jar oracle\sql\BLOB.class
```
5.7 Vous avez maintenant un fichier ojdbc6.jar personnalisé qui fonctionne avec les objets BLOB qui ont été sérialisés et enregistrés avec ojdbc14.jar

Classes Java mises à jour.

DatumWithConnection.java

    package oracle.sql;


    import java.sql.Connection;
    import java.sql.SQLException;
    import oracle.jdbc.driver.DatabaseError;
    import oracle.jdbc.driver.OracleDriver;
    import oracle.jdbc.internal.OracleDatumWithConnection;

    public abstract class DatumWithConnection
      extends Datum
      implements OracleDatumWithConnection
    {

    private static final long serialVersionUID = 491462912477014233L;

    private oracle.jdbc.internal.OracleConnection physicalConnection = null;

      oracle.jdbc.internal.OracleConnection getPhysicalConnection()
      {
        if (this.physicalConnection == null) {
          try
          {
            this.physicalConnection = ((oracle.jdbc.internal.OracleConnection)new OracleDriver().defaultConnection());
          }
          catch (SQLException localSQLException) {}
        }
        return this.physicalConnection;
      }

      public DatumWithConnection(byte[] paramArrayOfByte)
        throws SQLException
      {
        super(paramArrayOfByte);
      }

      public DatumWithConnection() {}

      public static void assertNotNull(Connection paramConnection)
        throws SQLException
      {
        if (paramConnection == null)
        {
          SQLException localSQLException = DatabaseError.createSqlException(null, 68, "Connection is null");
          localSQLException.fillInStackTrace();
          throw localSQLException;
        }
      }

      public static void assertNotNull(TypeDescriptor paramTypeDescriptor)
        throws SQLException
      {
        if (paramTypeDescriptor == null)
        {
          SQLException localSQLException = DatabaseError.createSqlException(null, 61);
          localSQLException.fillInStackTrace();
          throw localSQLException;
        }
      }

      public void setPhysicalConnectionOf(Connection paramConnection)
      {
        this.physicalConnection = ((oracle.jdbc.OracleConnection)paramConnection).physicalConnectionWithin();
      }

      public Connection getJavaSqlConnection()
        throws SQLException
      {
        return getPhysicalConnection().getWrapper();
      }

      public oracle.jdbc.OracleConnection getOracleConnection()
        throws SQLException
      {
        return getPhysicalConnection().getWrapper();
      }

      public oracle.jdbc.internal.OracleConnection getInternalConnection()
        throws SQLException
      {
        return getPhysicalConnection();
      }

      /**
       * @deprecated
       */
      public oracle.jdbc.driver.OracleConnection getConnection()
        throws SQLException
      {
        oracle.jdbc.driver.OracleConnection localOracleConnection = null;
        try
        {
          localOracleConnection = (oracle.jdbc.driver.OracleConnection)((oracle.jdbc.driver.OracleConnection)this.physicalConnection).getWrapper();
        }
        catch (ClassCastException localClassCastException)
        {
          SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 103);
          localSQLException.fillInStackTrace();
          throw localSQLException;
        }
        return localOracleConnection;
      }

      protected oracle.jdbc.internal.OracleConnection getConnectionDuringExceptionHandling()
      {
        return this.physicalConnection;
      }

      private static final String _Copyright_2007_Oracle_All_Rights_Reserved_ = null;
      public static final boolean TRACE = false;
    }

BLOB.java

    package oracle.sql;

    import java.io.ByteArrayInputStream;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.io.Reader;
    import java.sql.Blob;
    import java.sql.Connection;
    import java.sql.SQLException;
    import oracle.jdbc.LargeObjectAccessMode;
    import oracle.jdbc.driver.DatabaseError;
    import oracle.jdbc.internal.OracleBlob;

    public class BLOB extends DatumWithConnection implements OracleBlob {

        private static final long serialVersionUID = 2160152488501369185L;

        public static final int MAX_CHUNK_SIZE = 32768;
        public static final int DURATION_SESSION = 10;
        public static final int DURATION_CALL = 12;
        static final int OLD_WRONG_DURATION_SESSION = 1;
        static final int OLD_WRONG_DURATION_CALL = 2;
        public static final int MODE_READONLY = 0;
        public static final int MODE_READWRITE = 1;
        BlobDBAccess dbaccess;
        int dbChunkSize;
        boolean isFree;
        boolean fromObject;
        private long cachedLobLength;
        private byte[] prefetchData;
        private int prefetchDataSize;
        private boolean activePrefetch;
        static final int KDLCTLSIZE = 16;
        static final int KDF_FLAG = 88;
        static final int KDLIDDAT = 8;
        private static final String _Copyright_2007_Oracle_All_Rights_Reserved_ = null;
        public static final boolean TRACE = false;
        public static Object localObject;


        protected BLOB() {
            this.dbChunkSize = -1;
            this.isFree = false;

            this.fromObject = false;

            this.cachedLobLength = -1L;

            this.prefetchDataSize = 0;
            this.activePrefetch = false;
        }

        public BLOB(oracle.jdbc.OracleConnection paramOracleConnection) throws SQLException {
            this(paramOracleConnection, null);
        }

        public BLOB(oracle.jdbc.OracleConnection paramOracleConnection, byte[] paramArrayOfByte, boolean paramBoolean)
                throws SQLException {
            this(paramOracleConnection, paramArrayOfByte);

            this.fromObject = paramBoolean;
        }

        public BLOB(oracle.jdbc.OracleConnection paramOracleConnection, byte[] paramArrayOfByte) throws SQLException {
            super(paramArrayOfByte);

            this.dbChunkSize = -1;
            this.isFree = false;

            this.fromObject = false;

            this.cachedLobLength = -1L;

            this.prefetchDataSize = 0;
            this.activePrefetch = false;

            assertNotNull(paramOracleConnection);
            setPhysicalConnectionOf(paramOracleConnection);

            this.dbaccess = getPhysicalConnection().createBlobDBAccess();

            this.dbaccess.incrementTempLobReferenceCount(paramArrayOfByte);
        }

        public long length() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            long l = -1L;

            if ((this.activePrefetch) && (this.cachedLobLength != -1L))
                l = this.cachedLobLength;
            else if (canReadBasicLobDataInLocator())
                l = dilLength();
            else
                l = getDBAccess().length(this);
            return l;
        }

        public byte[] getBytes(long paramLong, int paramInt) throws SQLException {
            if (this.isFree) {
                localObject = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 192);
                ((SQLException) localObject).fillInStackTrace();
                throw ((SQLException) localObject);
            }
            if ((paramInt < 0) || (paramLong < 1L)) {
                localObject = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 68, "getBytes()");
                ((SQLException) localObject).fillInStackTrace();
                throw ((SQLException) localObject);
            }

            if (canReadBasicLobDataInLocator()) {
                return dilGetBytes(paramLong, paramInt);
            }

            Object localObject = null;

            if (paramInt == 0) {
                return new byte[0];
            }
            if ((this.activePrefetch) && (((this.cachedLobLength == 0L)
                    || ((this.cachedLobLength > 0L) && (paramLong - 1L >= this.cachedLobLength))))) {
                localObject = null;
            } else {
                long l = 0L;
                byte[] arrayOfByte;
                if ((this.activePrefetch) && (this.cachedLobLength != -1L))
                    arrayOfByte = new byte[Math.min((int) this.cachedLobLength, paramInt)];
                else {
                    arrayOfByte = new byte[paramInt];
                }

                l = getBytes(paramLong, paramInt, arrayOfByte);

                if (l > 0L) {
                    if (l == paramInt) {
                        localObject = arrayOfByte;
                    } else {
                        localObject = new byte[(int) l];

                        System.arraycopy(arrayOfByte, 0, localObject, 0, (int) l);
                    }
                }
            }

            return ((byte[])localObject);
        }

        public InputStream getBinaryStream() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            if (canReadBasicLobDataInLocator()) {
                return dilGetBinaryStream(1L);
            }
            return getDBAccess().newInputStream(this, getBufferSize(), 0L);
        }

        public long position(byte[] paramArrayOfByte, long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().position(this, paramArrayOfByte, paramLong);
        }

        public long position(Blob paramBlob, long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().position(this, (BLOB) paramBlob, paramLong);
        }

        public int getBytes(long paramLong, int paramInt, byte[] paramArrayOfByte) throws SQLException {
            SQLException localSQLException;
            if (this.isFree) {
                localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            if ((paramInt < 0) || (paramLong < 0L)) {
                localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 68,
                        "getBytes()");
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }

            if (paramArrayOfByte.length < paramInt) {
                paramInt = paramArrayOfByte.length;
            }
            return getDBAccess().getBytes(this, paramLong, paramInt, paramArrayOfByte);
        }

        public int putBytes(long paramLong, byte[] paramArrayOfByte) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return setBytes(paramLong, paramArrayOfByte);
        }

        public int putBytes(long paramLong, byte[] paramArrayOfByte, int paramInt) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return setBytes(paramLong, paramArrayOfByte, 0, paramInt);
        }

        public OutputStream getBinaryOutputStream() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return setBinaryStream(1L);
        }

        public byte[] getLocator() {
            return getBytes();
        }

        public void setLocator(byte[] paramArrayOfByte) {
            setBytes(paramArrayOfByte);
        }

        public int getChunkSize() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            if (this.dbChunkSize <= 0) {
                this.dbChunkSize = getDBAccess().getChunkSize(this);
            }

            return this.dbChunkSize;
        }

        public int getBufferSize() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            int i = getChunkSize();
            int j = i;

            if ((i >= 32768) || (i <= 0)) {
                j = 32768;
            } else {
                j = 32768 / i * i;
            }

            return j;
        }

        public static BLOB empty_lob() throws SQLException {
            return getEmptyBLOB();
        }

        public static BLOB getEmptyBLOB() throws SQLException {
            byte[] arrayOfByte = new byte[86];

            arrayOfByte[1] = 84;
            arrayOfByte[5] = 24;

            BLOB localBLOB = new BLOB();

            localBLOB.setShareBytes(arrayOfByte);

            return localBLOB;
        }

        public boolean isEmptyLob() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            boolean bool = (shareBytes()[5] & 0x10) != 0;

            return bool;
        }

        public boolean isSecureFile() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            boolean bool = (shareBytes()[7] & 0xFFFFFF80) != 0;
            return bool;
        }

        public OutputStream getBinaryOutputStream(long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().newOutputStream(this, getBufferSize(), paramLong, false);
        }

        public InputStream getBinaryStream(long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            if (canReadBasicLobDataInLocator()) {
                return dilGetBinaryStream(paramLong);
            }
            return getDBAccess().newInputStream(this, getBufferSize(), paramLong);
        }

        public void trim(long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            truncate(paramLong);
        }

        public static BLOB createTemporary(Connection paramConnection, boolean paramBoolean, int paramInt)
                throws SQLException {
            int i = paramInt;

            if (paramInt == 1) {
                i = 10;
            }
            if (paramInt == 2) {
                i = 12;
            }
            if ((paramConnection == null) || ((i != 10) && (i != 12))) {
                localObject = DatabaseError.createSqlException(null, 68,
                        "'conn' should not be null and 'duration' should either be equal to DURATION_SESSION or to DURATION_CALL");

                ((SQLException) localObject).fillInStackTrace();
                throw ((SQLException) localObject);
            }

            Object localObject = ((oracle.jdbc.OracleConnection) paramConnection).physicalConnectionWithin();

            return ((BLOB) getDBAccess((Connection) localObject).createTemporaryBlob((Connection) localObject, paramBoolean,
                    i));
        }

        public static void freeTemporary(BLOB paramBLOB) throws SQLException {
            if (paramBLOB == null) {
                return;
            }
            paramBLOB.freeTemporary();
        }

        public static boolean isTemporary(BLOB paramBLOB) throws SQLException {
            if (paramBLOB == null) {
                return false;
            }
            return paramBLOB.isTemporary();
        }

        public void freeTemporary() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }

            int i = getDBAccess().decrementTempLobReferenceCount(shareBytes());

            if (i == 0)
                getDBAccess().freeTemporary(this, this.fromObject);
        }

        public boolean isTemporary() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().isTemporary(this);
        }

        public void open(LargeObjectAccessMode paramLargeObjectAccessMode) throws SQLException {
            open(paramLargeObjectAccessMode.getCode());
        }

        public void open(int paramInt) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            getDBAccess().open(this, paramInt);
        }

        public void close() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            getDBAccess().close(this);
        }

        public boolean isOpen() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().isOpen(this);
        }

        public int setBytes(long paramLong, byte[] paramArrayOfByte) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }

            return getDBAccess().putBytes(this, paramLong, paramArrayOfByte, 0,
                    (paramArrayOfByte != null) ? paramArrayOfByte.length : 0);
        }

        public int setBytes(long paramLong, byte[] paramArrayOfByte, int paramInt1, int paramInt2) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().putBytes(this, paramLong, paramArrayOfByte, paramInt1, paramInt2);
        }

        public OutputStream setBinaryStream(long paramLong) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return getDBAccess().newOutputStream(this, getBufferSize(), paramLong, true);
        }

        public void truncate(long paramLong) throws SQLException {
            SQLException localSQLException;
            if (this.isFree) {
                localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            if (paramLong < 0L) {
                localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 68,
                        "'len' should be >= 0. ");
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }

            getDBAccess().trim(this, paramLong);
        }

        public Object toJdbc() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return this;
        }

        public boolean isConvertibleTo(Class paramClass) {
            String str = paramClass.getName();

            return ((str.compareTo("java.io.InputStream") == 0) || (str.compareTo("java.io.Reader") == 0));
        }

        public Reader characterStreamValue() throws SQLException {
            getInternalConnection();
            return getDBAccess().newConversionReader(this, 8);
        }

        public InputStream asciiStreamValue() throws SQLException {
            getInternalConnection();
            return getDBAccess().newConversionInputStream(this, 2);
        }

        public InputStream binaryStreamValue() throws SQLException {
            return getBinaryStream();
        }

        public Object makeJdbcArray(int paramInt) {
            return new BLOB[paramInt];
        }

        public BlobDBAccess getDBAccess() throws SQLException {
            SQLException localSQLException;
            if (this.dbaccess == null) {
                if (isEmptyLob()) {
                    localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 98);
                    localSQLException.fillInStackTrace();
                    throw localSQLException;
                }

                this.dbaccess = getInternalConnection().createBlobDBAccess();
            }

            if (getPhysicalConnection().isClosed()) {
                localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 8);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }

            return this.dbaccess;
        }

        public static BlobDBAccess getDBAccess(Connection paramConnection) throws SQLException {
            return ((oracle.jdbc.OracleConnection) paramConnection).physicalConnectionWithin().createBlobDBAccess();
        }

        public Connection getJavaSqlConnection() throws SQLException {
            if (this.isFree) {
                SQLException localSQLException = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException.fillInStackTrace();
                throw localSQLException;
            }
            return super.getJavaSqlConnection();
        }

        public final void setLength(long paramLong) {
            this.cachedLobLength = paramLong;
        }

        public final void setChunkSize(int paramInt) {
            this.dbChunkSize = paramInt;
        }

        public final void setPrefetchedData(byte[] paramArrayOfByte) {
            if (paramArrayOfByte == null)
                setPrefetchedData(null, 0);
            else
                setPrefetchedData(paramArrayOfByte, paramArrayOfByte.length);
        }

        public final void setPrefetchedData(byte[] paramArrayOfByte, int paramInt) {
            this.prefetchData = paramArrayOfByte;
            this.prefetchDataSize = paramInt;
        }

        public final byte[] getPrefetchedData() {
            return this.prefetchData;
        }

        public final int getPrefetchedDataSize() {
            return this.prefetchDataSize;
        }

        public final void setActivePrefetch(boolean paramBoolean) {
            if ((this.activePrefetch) && (!(paramBoolean)))
                clearCachedData();
            this.activePrefetch = paramBoolean;
        }

        public final void clearCachedData() {
            this.cachedLobLength = -1L;
            this.prefetchData = null;
        }

        public final boolean isActivePrefetch() {
            return this.activePrefetch;
        }

        boolean canReadBasicLobDataInLocator() throws SQLException {
            byte[] arrayOfByte = shareBytes();
            if ((arrayOfByte == null) || (arrayOfByte.length < 102)) {
              return false;
            }
            if (!getPhysicalConnection().isDataInLocatorEnabled()) {
              return false;
            }
            int i = arrayOfByte[6] & 0xFF;
            int j = arrayOfByte[7] & 0xFF;
            int k = (i & 0x8) == 8 ? 1 : 0;
            int m = (j & 0xFFFFFF80) == -128 ? 1 : 0;
            int n = 0;
            if ((k != 0) && (m == 0))
            {
              n = ((arrayOfByte[88] & 0xFF) & 0x8) == 8 ? 1 : 0;
            }
            return (k != 0) && (m == 0) && (n != 0);
        }

        int dilLength() {
            return (shareBytes().length - 86 - 16);
        }

        byte[] dilGetBytes(long paramLong, int paramInt) throws SQLException {
            if (paramInt == 0) {
                return new byte[0];
            }

            if (dilLength() == 0) {
                return null;
            }
            int i = (int) Math.min(paramInt, dilLength() - (paramLong - 1L));

            if (i <= 0) {
                return null;
            }

            byte[] arrayOfByte = new byte[i];
            System.arraycopy(shareBytes(), (int) (paramLong - 1L) + 86 + 16, arrayOfByte, 0, i);
            return arrayOfByte;
        }

        InputStream dilGetBinaryStream(long paramLong) throws SQLException {
            if (paramLong < 0L) {
                throw new IllegalArgumentException("Illegal Arguments");
            }

            byte[] arrayOfByte = dilGetBytes(paramLong, dilLength());

            if (arrayOfByte == null) {
                arrayOfByte = new byte[0];
            }

            return new ByteArrayInputStream(arrayOfByte);
        }

        public void free() throws SQLException {
            if (this.isFree)
                return;
            if (isOpen())
                close();
            if (isTemporary())
                freeTemporary();
            this.isFree = true;
            this.dbaccess = null;
        }

        public InputStream getBinaryStream(long paramLong1, long paramLong2) throws SQLException {
            if (this.isFree) {
                SQLException localSQLException1 = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        192);
                localSQLException1.fillInStackTrace();
                throw localSQLException1;
            }
            if (canReadBasicLobDataInLocator()) {
                return dilGetBinaryStream(paramLong1, paramLong2);
            }
            long l = length();
            if ((paramLong1 < 1L) || (paramLong2 < 0L) || (paramLong1 > l) || (paramLong1 - 1L + paramLong2 > l)) {
                SQLException localSQLException2 = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(),
                        68);
                localSQLException2.fillInStackTrace();
                throw localSQLException2;
            }
            return getDBAccess().newInputStream(this, getChunkSize(), paramLong1, paramLong2);
        }

        InputStream dilGetBinaryStream(long paramLong1, long paramLong2) throws SQLException {
            int i = dilLength();
            if ((paramLong1 < 1L) || (paramLong2 < 0L) || (paramLong1 > i) || (paramLong1 - 1L + paramLong2 > i)) {
                localObject = DatabaseError.createSqlException(getConnectionDuringExceptionHandling(), 68);
                ((SQLException) localObject).fillInStackTrace();
                throw ((SQLException) localObject);
            }
            byte[] localObject = dilGetBytes(paramLong1, i - (int) (paramLong1 - 1L));
            return ((InputStream) new ByteArrayInputStream(localObject, 0, (int) paramLong2));
        }
    }