Java Blob类代码示例

import java.sql.Blob; //导入依赖的package包/类
public void exportBackup(int id, OutputStream out) {
	Connection conn = null;
	PreparedStatement pstmt = null;
	try {
		conn = DBPower.getConnection(table.getId());
		conn.setAutoCommit(false);
		pstmt = conn.prepareStatement(SELECT_CONTENT_SQL);
		pstmt.setInt(1, id);
		ResultSet rs = pstmt.executeQuery();
		if (rs.next()) {
			Blob blob = rs.getBlob(1);
			InputStream in = blob.getBinaryStream();
			byte[] buf = new byte[1024];
			int len = 0;
			while ((len = in.read(buf)) != -1) {
				out.write(buf, 0, len);
			}
			in.close();
		}
		conn.commit();
	} catch (Exception e) {
		log.error( "", e );
	} finally {
		DBUtil.close(pstmt, conn);
	}
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
@SuppressWarnings( {"unchecked" } )
public <X> X unwrap(byte[] value, Class<X> type, WrapperOptions options) {
	if ( value == null ) {
		return null;
	}
	if ( Byte[].class.isAssignableFrom( type ) ) {
		return (X) value;
	}
	if ( byte[].class.isAssignableFrom( type ) ) {
		return (X) value;
	}
	if ( InputStream.class.isAssignableFrom( type ) ) {
		return (X) new ByteArrayInputStream( value );
	}
	if ( BinaryStream.class.isAssignableFrom( type ) ) {
		return (X) new BinaryStreamImpl( value );
	}
	if ( Blob.class.isAssignableFrom( type ) ) {
		return (X) options.getLobCreator().createBlob( value );
	}

	throw unknownUnwrap( type );
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
public <X> byte[] wrap(X value, WrapperOptions options) {
	if ( value == null ) {
		return null;
	}
	if ( Byte[].class.isInstance( value ) ) {
		return unwrapBytes( (Byte[]) value );
	}
	if ( byte[].class.isInstance( value ) ) {
		return (byte[]) value;
	}
	if ( InputStream.class.isInstance( value ) ) {
		return DataHelper.extractBytes( (InputStream) value );
	}
	if ( Blob.class.isInstance( value ) || DataHelper.isNClob( value.getClass() ) ) {
		try {
			return DataHelper.extractBytes( ( (Blob) value ).getBinaryStream() );
		}
		catch (SQLException e) {
			throw new HibernateException( "Unable to access lob stream", e );
		}
	}

	throw unknownWrap( value.getClass() );
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
public byte[] getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
	Blob blob = rs.getBlob(columnIndex);
	byte[] returnValue = null;
	if (null != blob) {
		returnValue = blob.getBytes(1, (int) blob.length());
	}
	return returnValue;
}
 

import java.sql.Blob; //导入依赖的package包/类
/** Sets a parameter in the PreparedStatement.
 * @param engineType The engine type as defined in init.xml
 * @param pstmt The PreparedStatement.
 * @param parameterIndex The index of the parameter that is to be set.
 * @param value The object to be assigned to the parameter.
 * @throws SQLException if a database access error occurs.
 */
public void setAppObject(PreparedStatement pstmt, int parameterIndex, Object value, String engineType)
throws SQLException {
    if (value != null) {
        if (!(value instanceof byte[]))
            value = DataTypeMapper.instance().map(value, byte[].class);
        if ("oracle".equalsIgnoreCase(engineType) && !supportsStdLob(pstmt)) {
            Blob blob = createBlob(pstmt.getConnection(), (byte[]) value);
            pstmt.setBlob(parameterIndex, blob);
        } else {
            byte[] bytes = (byte[]) value;
            InputStream stream = new BufferedInputStream(new ByteArrayInputStream(bytes));
            pstmt.setBinaryStream(parameterIndex, stream, bytes.length);
        }
    } else
        pstmt.setNull(parameterIndex, getSqlType(Defaults.BLOB, engineType));
}
 

import java.sql.Blob; //导入依赖的package包/类
Object convertColumnValue(Object value, int column, int type) {

        if (value == null) {
            return value;
        }

        try {
            if (value instanceof Clob) {
                return ((Clob) value).getSubString(
                    1, (int) ((Clob) value).length());
            } else if (value instanceof Blob) {
                return ((Blob) value).getBytes(
                    1, (int) ((Blob) value).length());
            }
        } catch (SQLException e) {
            return null;
        }

        return (value);
    }
 

import java.sql.Blob; //导入依赖的package包/类
private static ConcurrentHashMap<Class, Integer> buildJdbcJavaClassMappings() {
	ConcurrentHashMap<Class, Integer> jdbcJavaClassMappings = new ConcurrentHashMap<Class, Integer>();

	// these mappings are the ones outlined specifically in the spec
	jdbcJavaClassMappings.put( String.class, Types.VARCHAR );
	jdbcJavaClassMappings.put( BigDecimal.class, Types.NUMERIC );
	jdbcJavaClassMappings.put( Boolean.class, Types.BIT );
	jdbcJavaClassMappings.put( Integer.class, Types.INTEGER );
	jdbcJavaClassMappings.put( Long.class, Types.BIGINT );
	jdbcJavaClassMappings.put( Float.class, Types.REAL );
	jdbcJavaClassMappings.put( Double.class, Types.DOUBLE );
	jdbcJavaClassMappings.put( byte[].class, Types.LONGVARBINARY );
	jdbcJavaClassMappings.put( java.sql.Date.class, Types.DATE );
	jdbcJavaClassMappings.put( Time.class, Types.TIME );
	jdbcJavaClassMappings.put( Timestamp.class, Types.TIMESTAMP );
	jdbcJavaClassMappings.put( Blob.class, Types.BLOB );
	jdbcJavaClassMappings.put( Clob.class, Types.CLOB );
	jdbcJavaClassMappings.put( Array.class, Types.ARRAY );
	jdbcJavaClassMappings.put( Struct.class, Types.STRUCT );
	jdbcJavaClassMappings.put( Ref.class, Types.REF );
	jdbcJavaClassMappings.put( Class.class, Types.JAVA_OBJECT );

	// additional "common sense" registrations
	jdbcJavaClassMappings.put( Character.class, Types.CHAR );
	jdbcJavaClassMappings.put( char[].class, Types.VARCHAR );
	jdbcJavaClassMappings.put( Character[].class, Types.VARCHAR );
	jdbcJavaClassMappings.put( Byte[].class, Types.LONGVARBINARY );
	jdbcJavaClassMappings.put( java.util.Date.class, Types.TIMESTAMP );
	jdbcJavaClassMappings.put( Calendar.class, Types.TIMESTAMP );

	return jdbcJavaClassMappings;
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
public void setBlobAsBytes(PreparedStatement ps, int paramIndex, final byte[] content)
		throws SQLException {

	if (content != null) {
		Blob blob = (Blob) createLob(ps, false, new LobCallback() {
			@Override
			public void populateLob(Object lob) throws Exception {
				Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream");
				OutputStream out = (OutputStream) methodToInvoke.invoke(lob);
				FileCopyUtils.copy(content, out);
			}
		});
		ps.setBlob(paramIndex, blob);
		if (logger.isDebugEnabled()) {
			logger.debug("Set bytes for Oracle BLOB with length " + blob.length());
		}
	}
	else {
		ps.setBlob(paramIndex, (Blob) null);
		logger.debug("Set Oracle BLOB to null");
	}
}
 

import java.sql.Blob; //导入依赖的package包/类
public Blob getBlob(int nColNumber) throws TechnicalException
{		
	if(m_resultSet != null)
	{
		try
		{
			Blob blVal = m_resultSet.getBlob(nColNumber);
			return blVal;
		}
		catch (SQLException e)
		{
			forceCloseOnExceptionCatched();
			ProgrammingException.throwException(ProgrammingException.DB_ERROR_RESULT_SET_COL_ACCESS_INT+nColNumber, m_csQuery, e);
		}			
	}
	return null;
}
 

import java.sql.Blob; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * <p>
 * Caché requires {@code java.sql.Blob} instances to be explicitly freed.
 */
@Override
protected Object getObjectFromBlob(ResultSet rs, String colName) throws ClassNotFoundException, IOException, SQLException {
    Blob blob = rs.getBlob(colName);
    if (blob == null) {
        return null;
    } else {
        try {
            if (blob.length() == 0) {
                return null;
            } else {
                InputStream binaryInput = blob.getBinaryStream();
                if (binaryInput == null) {
                    return null;
                } else if (binaryInput instanceof ByteArrayInputStream && ((ByteArrayInputStream) binaryInput).available() == 0 ) {
                    return null;
                } else {
                    ObjectInputStream in = new ObjectInputStream(binaryInput);
                    try {
                        return in.readObject();
                    } finally {
                        in.close();
                    }
                }
            }
        } finally {
            blob.free();
        }
    }
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
public void setBlobAsBinaryStream(
		PreparedStatement ps, int paramIndex, final InputStream binaryStream, int contentLength)
		throws SQLException {

	if (binaryStream != null) {
		Blob blob = (Blob) createLob(ps, false, new LobCallback() {
			@Override
			public void populateLob(Object lob) throws Exception {
				Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream", (Class[]) null);
				OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
				FileCopyUtils.copy(binaryStream, out);
			}
		});
		ps.setBlob(paramIndex, blob);
		if (logger.isDebugEnabled()) {
			logger.debug("Set binary stream for Oracle BLOB with length " + blob.length());
		}
	}
	else {
		ps.setBlob(paramIndex, (Blob) null);
		logger.debug("Set Oracle BLOB to null");
	}
}
 

import java.sql.Blob; //导入依赖的package包/类
/**
 * Retrieves the byte position in the <code>BLOB</code> value
 * designated by this <code>Blob</code> object at which
 * <code>pattern</code> begins.  The search begins at position
 * <code>start</code>.
 *
 * @param pattern the <code>Blob</code> object designating
 *      the <code>BLOB</code> value for which to search
 * @param start the position in the <code>BLOB</code> value
 *        at which to begin searching; the first position is 1
 * @return the position at which the pattern begins, else -1
 * @exception SQLException if there is an error accessing the
 *        <code>BLOB</code> value
 *
 * @since JDK 1.2, HSQLDB 1.7.2
 */
public long position(final Blob pattern, long start) throws SQLException {

    final byte[] ldata = data;
    final int    dlen  = ldata.length;

    if (start > dlen || pattern == null) {
        return -1;
    } else if (start < 1) {
        start = 0;
    } else {
        start--;
    }

    final long plen = pattern.length();

    if (plen == 0 || start > ((long) dlen) - plen) {
        return -1;
    }

    // by now, we know plen <= Integer.MAX_VALUE
    final int iplen = (int) plen;
    byte[]    bap;

    if (pattern instanceof jdbcBlob) {
        bap = ((jdbcBlob) pattern).data;
    } else {
        bap = pattern.getBytes(1, iplen);
    }

    final int  stop = dlen - iplen;
    final byte b0   = bap[0];

    outer_loop:
    for (int i = (int) start; i <= stop; i++) {
        if (ldata[i] != b0) {
            continue;
        }

        int len     = iplen;
        int doffset = i;
        int poffset = 0;

        while (len-- > 0) {
            if (ldata[doffset++] != bap[poffset++]) {
                continue outer_loop;
            }
        }

        return i + 1;
    }

    return -1;
}
 

import java.sql.Blob; //导入依赖的package包/类
protected boolean testValue(final Object value) {
    if (value == null) {
        return false;
    }
    final String valueStr;
    if (value instanceof Blob) {
        valueStr = LobHelper.blobToString((Blob) value);
    } else if (value instanceof Clob) {
        valueStr = LobHelper.clobToString((Clob) value);
    } else {
        valueStr = value.toString();
    }
    switch (mode) {
        case LITERAL_FIND:
            if (filterStr == null || filterStr.length() == 0) {
            return true;
        } else {
            return valueStr.toUpperCase().contains(filterStr.toUpperCase());
        }
        case LITERAL_MATCH:
            if (filterStr == null || filterStr.length() == 0) {
            return true;
        } else {
            return filterStr.equals(valueStr);
        }
        case REGEX_FIND:
            return pattern.matcher(valueStr).find();
        case REGEX_MATCH:
            return pattern.matcher(valueStr).matches();
        default:
            throw new RuntimeException(UNKOWN_MODE);
    }
}
 

import java.sql.Blob; //导入依赖的package包/类
@Override
protected boolean useToString(int column) {
    Class klass = getModel().getColumnClass(column);
    if (Blob.class.isAssignableFrom(klass)
            || Clob.class.isAssignableFrom(klass)) {
        return false;
    }
    return super.useToString(column);
}
 

import java.sql.Blob; //导入依赖的package包/类
public Blob getBlob(String parameterName) throws SQLException {
    try {
        if (this.wrappedStmt != null) {
            return ((CallableStatement) this.wrappedStmt).getBlob(parameterName);
        }
        throw SQLError.createSQLException("No operations allowed after statement closed", SQLError.SQL_STATE_GENERAL_ERROR, this.exceptionInterceptor);

    } catch (SQLException sqlEx) {
        checkAndFireConnectionError(sqlEx);
    }

    return null;
}