org.apache.ojb.broker.platforms.BlobWrapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of db-ojb Show documentation
ObJectRelationalBridge (OJB) is an Object/Relational mapping tool that allows transparent persistence for Java Objects against relational databases.
The newest version!
package org.apache.ojb.broker.platforms;

/* Copyright 2003-2005 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import org.apache.commons.lang.BooleanUtils;
import org.apache.ojb.broker.util.ClassHelper;

import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * Wraps the Oracle BLOB type and makes it accessible via reflection
 * without having to import the Oracle Classes.
 * @author Matthew Baird
 * @author Erik Forkalsrud
 * @author Martin Kalén
 * @version CVS $Id: BlobWrapper.java,v 1.1 2007-08-24 22:17:35 ewestfal Exp $
 */
public class BlobWrapper
{
	protected Object m_blob;

    // Fields - values must be looked up via reflection not be compile-time Oracle-version dependent
    protected static Field durationSession;
    protected static Field durationCall;
    protected static Field modeReadOnly;
    protected static Field modeReadWrite;

	// Methods
	protected static Method createTemporary;
    protected static Method freeTemporary;
	protected static Method open;
	protected static Method isOpen;
	protected static Method getBinaryStream;
	protected static Method getBinaryOutputStream;
	protected static Method getBufferSize;
	protected static Method close;
	protected static Method trim;

    /**
     * Initialize all methods and fields via reflection.
     */
    static
    {
        try
        {
            Class blobClass = ClassHelper.getClass("oracle.sql.BLOB", false);
            createTemporary = blobClass.getMethod("createTemporary", new Class[]{Connection.class, Boolean.TYPE, Integer.TYPE});
            freeTemporary = blobClass.getMethod("freeTemporary", null);
            open = blobClass.getMethod("open", new Class[]{Integer.TYPE});
            isOpen = blobClass.getMethod("isOpen", null);
            getBinaryStream = blobClass.getMethod("getBinaryStream", null);
            getBinaryOutputStream = blobClass.getMethod("getBinaryOutputStream", null);
            getBufferSize = blobClass.getMethod("getBufferSize", null);
            close = blobClass.getMethod("close", null);
            trim = blobClass.getMethod("trim", new Class[]{Long.TYPE});

            durationSession = ClassHelper.getField(blobClass, "DURATION_SESSION");
            durationCall = ClassHelper.getField(blobClass, "DURATION_CALL");
            modeReadOnly = ClassHelper.getField(blobClass, "MODE_READONLY");
            modeReadWrite = ClassHelper.getField(blobClass, "MODE_READWRITE");
        }
        catch (Exception ignore)
        {
            // ignore it
        }
    }

    public Object getBlob()
    {
        return m_blob;
    }

    public void setBlob(Object blob)
    {
        m_blob = blob;
    }

    protected static int staticIntFieldValue(Field field) {
        int value = 0;
        try {
            value = field.getInt(null);
        } catch (Exception ignore) {
            value = -1;
        }
        return value;
    }

    public static int getDurationSessionValue() {
        return staticIntFieldValue(durationSession);
    }

    public static int getDurationCallValue() {
        return staticIntFieldValue(durationCall);
    }

    public static int getModeReadOnlyValue() {
        return staticIntFieldValue(modeReadOnly);
    }

    public static int getModeReadWriteValue() {
        return staticIntFieldValue(modeReadWrite);
    }

    public static BlobWrapper createTemporary(Connection conn, boolean b, int i) throws Exception
    {
        BlobWrapper retval = new BlobWrapper();
        // Passing null to invoke static method
        retval.setBlob(createTemporary.invoke(null, new Object[]{conn, BooleanUtils.toBooleanObject(b), new Integer(i)}));
        return retval;
    }

    public void open(int i) throws SQLException
    {
        if (m_blob == null) {
            return;
        }
        try
        {
            open.invoke(m_blob, new Object[]{new Integer(i)});
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }
    }

    public boolean isOpen() throws SQLException
    {
        if (m_blob == null) {
            return false;
        }
        
		boolean blobOpen = false;
		try
		{
			Boolean retval = (Boolean) isOpen.invoke(m_blob, null);
            if (retval != null) {
                blobOpen = retval.booleanValue();
            }
		}
		catch (Throwable e)
		{
			throw new SQLException(e.getMessage());
		}
		return blobOpen;
    }

    public InputStream getBinaryStream() throws SQLException
    {
        if (m_blob == null) {
            return null;
        }
        InputStream retval = null;
        try
        {
            retval = (InputStream) getBinaryStream.invoke(m_blob, null);
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }
        return retval;
    }

    public OutputStream getBinaryOutputStream() throws SQLException
    {
        if (m_blob == null) {
            return null;
        }
        OutputStream retval = null;
        try
        {
            retval = (OutputStream) getBinaryOutputStream.invoke(m_blob, null);
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }
        return retval;
    }

    public int getBufferSize() throws SQLException
    {
        if (m_blob == null) {
            return 0;
        }
        Integer retval = null;
        try
        {
            retval = (Integer) getBufferSize.invoke(m_blob, null);
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }
        return retval.intValue();
    }

    public void close() throws SQLException
    {
        if (m_blob == null) {
            return;
        }
        try
        {
            close.invoke(m_blob, null);
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }

    }

    public void trim(long l) throws SQLException
    {
        if (m_blob == null) {
            return;
        }
        try
        {
            trim.invoke(m_blob, new Object[]{new Long(l)});
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }

    }

    public void freeTemporary() throws SQLException
    {
        if (m_blob == null) {
            return;
        }
        try
        {
            freeTemporary.invoke(m_blob, null);
        }
        catch (Throwable e)
        {
            throw new SQLException(e.getMessage());
        }
    }

}