java.sql.Blob Java Examples

@Override
    public LocatedBlocks getLocatedBlocks(String src, long start, long length) throws IOException {
        try {
            try (PreparedStatement statement = connection.prepareStatement("call SYSCS_UTIL.SYSCS_HDFS_OPERATION(?, ?)")) {
                statement.setString(1, src);
                statement.setString(2, "blocks");
                try (ResultSet rs = statement.executeQuery()) {
                    if (!rs.next()) {
                        throw new IOException("No results for getFileStatus");
                    }
                    Blob blob = rs.getBlob(1);
                    byte[] bytes = blob.getBytes(1, (int) blob.length());
                    HdfsProtos.LocatedBlocksProto lbp = HdfsProtos.LocatedBlocksProto.parseFrom(bytes);

// TODO                    return PBHelper.convert(lbp);
                    return null;
                }
            }
        } catch (SQLException e) {
            throw new IOException(e);
        }
    }
 

protected void insertToGFXDTable(Connection conn, int[] eid, String[] emp_name,
    int[] deptid, Date[] since, String[] addr, Blob[] picture, String[] ssn,
    int size, List<SQLException> exceptions, boolean isPut) throws SQLException {
  PreparedStatement stmt = conn.prepareStatement(isPut ? put : insert);
  int tid = getMyTid();
  int count = -1;
  
  for (int i=0 ; i<size ; i++) {
    try {
      count = insertToTable(stmt, eid[i], emp_name[i], deptid[i], since[i], addr[i], 
          picture[i], ssn[i], tid, isPut); 
      if (count != ((Integer)verifyRowCount.get(tid+"_insert"+i)).intValue()) {
        Log.getLogWriter().info("Gfxd insert has different row count from that of derby " +
          "derby inserted " + ((Integer)verifyRowCount.get(tid+"_insert"+i)).intValue() +
          " but gfxd inserted " + count);
      }
    } catch (SQLException se) {
      SQLHelper.handleGFGFXDException(se, exceptions);  
    }
  }
}
 

private static void checkBlob(ResultSet rs, int index, byte[] expected, int key) {
    try {
        byte[] actual = rs.getBytes(index);
        Assert.assertArrayEquals(expected, actual);

        if (expected != null) {
            DataInputStream dataInputStream = new DataInputStream(rs.getBinaryStream(index));
            byte[] actualFromStream = new byte[actual.length];
            dataInputStream.readFully(actualFromStream);
            Assert.assertArrayEquals("error at key " + key, expected, actualFromStream);

            Blob blob = rs.getBlob(index);
            assertEquals("error at key " + key, blob.length(), actual.length);

            DataInputStream dataInputStream2 = new DataInputStream(blob.getBinaryStream());
            byte[] actualFromStream2 = new byte[actual.length];
            dataInputStream2.readFully(actualFromStream2);
            Assert.assertArrayEquals("error at key " + key, expected, actualFromStream2);
        }

        byte[] object = (byte[]) rs.getObject(index);
        Assert.assertArrayEquals((byte[]) expected, object);
    } catch (SQLException | IOException e) {
        throw new RuntimeException(e);
    }
}
 

private List<byte[]> getRollbackInfo(String xid, long branchId, Connection conn, String resourceId) throws SQLException {

        ResultSet rs = null;
        PreparedStatement selectPST = null;
        selectPST = conn.prepareStatement(SELECT_UNDO_LOG_SQL);
        selectPST.setLong(1, branchId);
        selectPST.setString(2, xid);
        rs = selectPST.executeQuery();

        List<byte[]> result = new ArrayList<>();

        try {
            while (rs.next()) {
                Blob b = rs.getBlob("rollback_info");
                byte[] rollbackInfo = BlobUtils.blob2Bytes(b);
                result.add(rollbackInfo);
            }
        } finally {
            rs.close();
        }

        return result;

    }
 

@Override
public void setBlob(int parameterIndex, Blob x) {
    if (x == null) {
        setNull(parameterIndex);
    } else {
        try {
            ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();

            bytesOut.write('\'');
            StringUtils.escapeblockFast(x.getBytes(1, (int) x.length()), bytesOut, (int) x.length(),
                    this.session.getServerSession().useAnsiQuotedIdentifiers());
            bytesOut.write('\'');

            setValue(parameterIndex, bytesOut.toByteArray(), MysqlType.BLOB);
        } catch (Throwable t) {
            throw ExceptionFactory.createException(t.getMessage(), t);
        }
    }
}
 

static final Object setObject(int targetType, Blob source) {
    switch (targetType) {
    case ClientTypes.BLOB:
        return source;
    default:
        throw new IllegalArgumentException("SQLState.LANG_DATA_TYPE_SET_MISMATCH java.sql.Blob" + ClientTypes.getTypeString(targetType));
    }
}
 

@Override
    public void setPreparedValue(PreparedStatement pStm, int col, Object o, int type ) 
            throws SQLException
    {
        if( type == Types.BLOB 
        		|| type == Types.LONGVARBINARY 
        		|| type == Types.VARBINARY
        		|| type == Types.BINARY )
        {
        	if( o != null )
        	{
	            o = outputValue( o );
	            
//	            System.out.println( "BLOB class: " + o.getClass() + " Type: " + type + " Col: " + col );
	            if( o instanceof byte[] )
	            {
	                pStm.setBytes( col + 1, ( byte[] )o );
	            }
	            else
	            {
	            	Blob b = ( Blob )o;
	                pStm.setBytes( col + 1, b.getBytes( 1, ( int )b.length() ) );
	            }
        	}
        	else
        	{
        		pStm.setBytes( col + 1, null );
        	}
        }
        else
        {
        	super.setPreparedValue( pStm, col, o, type );
        }
    }
 

@Override
public Blob getBlob(int columnIndex) throws SQLException {
	if (this.lobsInExtFile) {
		return super.getBlob(columnIndex);
	} else {
		// data is in the main export file, stored in hex format.
		String hexData = getCurrentRow()[columnIndex - 1];
		byte[] data = null;
		if (hexData != null) {
			data = fromHexString(hexData, 0, hexData.length());
			// fromHexString() returns null if the hex string
			// is invalid one. It is invalid if the data string
			// length is not multiple of 2 or the data string
			// contains non-hex characters.
			if (data != null) {
				this.wasNull = false;
				return new ImportBlob(data);
			} else {
				throw new SQLException(
						"An invalid hexadecimal string '" + hexData
								+ "' detected in the import file at line "
								+ getCurrentLineNumber() + " column "
								+ columnIndex, "XIE0N", 20000);
			}
		} else {
			this.wasNull = true;
			return null;
		}
	}
}
 

@Override
public void setBlobAsBytes(PreparedStatement ps, int paramIndex, @Nullable byte[] content)
		throws SQLException {

	if (streamAsLob) {
		if (content != null) {
			ps.setBlob(paramIndex, new ByteArrayInputStream(content), content.length);
		}
		else {
			ps.setBlob(paramIndex, (Blob) null);
		}
	}
	else if (wrapAsLob) {
		if (content != null) {
			ps.setBlob(paramIndex, new PassThroughBlob(content));
		}
		else {
			ps.setBlob(paramIndex, (Blob) null);
		}
	}
	else {
		ps.setBytes(paramIndex, content);
	}
	if (logger.isDebugEnabled()) {
		logger.debug(content != null ? "Set bytes for BLOB with length " + content.length :
				"Set BLOB to null");
	}
}
 

private InputStream getInputStream(String resPath, ResultSet rs) throws SQLException, IOException {
    if (rs == null) {
        return null;
    }

    Blob blob = rs.getBlob(META_TABLE_CONTENT);

    if (blob == null || blob.length() == 0) {
        return openPushdown(resPath); // empty bytes is pushdown indicator
    } else {
        return blob.getBinaryStream();
    }
}
 

/**
 * Retrieve a JDBC column value from a ResultSet, using the most appropriate
 * value type. The returned value should be a detached value object, not having
 * any ties to the active ResultSet: in particular, it should not be a Blob or
 * Clob object but rather a byte array or String representation, respectively.
 * <p>Uses the {@code getObject(index)} method, but includes additional "hacks"
 * to get around Oracle 10g returning a non-standard object for its TIMESTAMP
 * datatype and a {@code java.sql.Date} for DATE columns leaving out the
 * time portion: These columns will explicitly be extracted as standard
 * {@code java.sql.Timestamp} object.
 * @param rs is the ResultSet holding the data
 * @param index is the column index
 * @return the value object
 * @throws SQLException if thrown by the JDBC API
 * @see java.sql.Blob
 * @see java.sql.Clob
 * @see java.sql.Timestamp
 */
@Nullable
public static Object getResultSetValue(ResultSet rs, int index) throws SQLException {
	Object obj = rs.getObject(index);
	String className = null;
	if (obj != null) {
		className = obj.getClass().getName();
	}
	if (obj instanceof Blob) {
		Blob blob = (Blob) obj;
		obj = blob.getBytes(1, (int) blob.length());
	}
	else if (obj instanceof Clob) {
		Clob clob = (Clob) obj;
		obj = clob.getSubString(1, (int) clob.length());
	}
	else if ("oracle.sql.TIMESTAMP".equals(className) || "oracle.sql.TIMESTAMPTZ".equals(className)) {
		obj = rs.getTimestamp(index);
	}
	else if (className != null && className.startsWith("oracle.sql.DATE")) {
		String metaDataClassName = rs.getMetaData().getColumnClassName(index);
		if ("java.sql.Timestamp".equals(metaDataClassName) || "oracle.sql.TIMESTAMP".equals(metaDataClassName)) {
			obj = rs.getTimestamp(index);
		}
		else {
			obj = rs.getDate(index);
		}
	}
	else if (obj instanceof java.sql.Date) {
		if ("java.sql.Timestamp".equals(rs.getMetaData().getColumnClassName(index))) {
			obj = rs.getTimestamp(index);
		}
	}
	return obj;
}
 

private static ConcurrentHashMap<Class, Integer> buildJavaClassToJdbcTypeCodeMappings() {
	final ConcurrentHashMap<Class, Integer> workMap = new ConcurrentHashMap<>();

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


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

	return workMap;
}
 

public <T> T getObject( int parameterIndex, Class<T> type )
    throws SQLException
{
    // checkForClosedStatement() should be called by all of the
    // more specific methods to which we forward this call

    if ( type == null )
    {
        throw mismatchException( "NULL", parameterIndex );
    }

    Object   retval;
        
    if ( String.class.equals( type ) ) { retval = getString( parameterIndex ); }
    else if ( BigDecimal.class.equals( type ) ) { retval = getBigDecimal( parameterIndex ); }
    else if ( Boolean.class.equals( type ) ) { retval = Boolean.valueOf( getBoolean(parameterIndex ) ); }
    else if ( Byte.class.equals( type ) ) { retval = Byte.valueOf( getByte( parameterIndex ) ); }
    else if ( Short.class.equals( type ) ) { retval = Short.valueOf( getShort( parameterIndex ) ); }
    else if ( Integer.class.equals( type ) ) { retval = Integer.valueOf( getInt( parameterIndex ) ); }
    else if ( Long.class.equals( type ) ) { retval = Long.valueOf( getLong( parameterIndex ) ); }
    else if ( Float.class.equals( type ) ) { retval = Float.valueOf( getFloat( parameterIndex ) ); }
    else if ( Double.class.equals( type ) ) { retval = Double.valueOf( getDouble( parameterIndex ) ); }
    else if ( Date.class.equals( type ) ) { retval = getDate( parameterIndex ); }
    else if ( Time.class.equals( type ) ) { retval = getTime( parameterIndex ); }
    else if ( Timestamp.class.equals( type ) ) { retval = getTimestamp( parameterIndex ); }
    else if ( Blob.class.equals( type ) ) { retval = getBlob( parameterIndex ); }
    else if ( Clob.class.equals( type ) ) { retval = getClob( parameterIndex ); }
    else if ( type.isArray() && type.getComponentType().equals( byte.class ) ) { retval = getBytes( parameterIndex ); }
    else { retval = getObject( parameterIndex ); }

    if ( wasNull() ) { retval = null; }

    if ( (retval == null) || (type.isInstance( retval )) ) { return type.cast( retval ); }
            
    throw mismatchException( type.getName(), parameterIndex );
}
 

@Override
public Blob createBlob() throws SQLException {
    try {
        return wrapped.createBlob();
    }
    catch (SQLException x) {
        this.reusable = !pool.checkConnectionFailure(x);
        throw x;
    }
}
 

@Override
public Blob getBlob(final String colName) throws SQLException {
    try {
        return resultSet.getBlob(colName);
    } catch (final SQLException e) {
        handleException(e);
        return null;
    }
}
 

@Override
public void release(Blob blob) {
	if ( blobs == null ) {
		log.debug( "Request to release Blob, but appears no Blobs have ever been registered" );
		return;
	}
	blobs.remove( blob );
}
 

public void setBlob(int parameterIndex, Blob x) throws SQLException {
	delegate.setBlob(parameterIndex, x);
}
 

public void updateBlob(String columnName, Blob x) throws SQLException {
    this.targetResultSet.updateBlob(columnName, x);
}
 

@Override
public void setBlob(int i, Blob x) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateBlob(String columnLabel, Blob x) {
    throw new UnsupportedOperationException();
}
 

@Override
public void updateBlob(int columnIndex, Blob x) throws SQLException {}
 

@Override
public Blob createBlob() throws SQLException {
    return null;
}
 

public Blob getBlob(String parameterName) throws SQLException {
    return getPhysCs().getBlob(parameterName);
}
 

@Override
public Blob createBlob() throws SQLException {
    return null;
}
 

/**
 * Delegates to {@link ResultSet#getObject(String, Class)} without throwing a {@link AbstractMethodError}.
 *
 * @param <T>
 *            See {@link ResultSet#getObject(String, Class)}
 * @param resultSet
 *            See {@link ResultSet#getObject(String, Class)}
 * @param columnLabel
 *            See {@link ResultSet#getObject(String, Class)}
 * @param type
 *            See {@link ResultSet#getObject(String, Class)}
 * @return See {@link ResultSet#getObject(String, Class)}
 * @throws SQLException
 *             See {@link ResultSet#getObject(String, Class)}
 * @see ResultSet#getObject(int, Class)
 */
@SuppressWarnings("unchecked")
public static <T> T getObject(final ResultSet resultSet, final String columnLabel, final Class<T> type)
        throws SQLException {
    try {
        return resultSet.getObject(columnLabel, type);
    } catch (final AbstractMethodError e) {
        // Numbers
        if (type == Integer.class) {
            return (T) Integer.valueOf(resultSet.getInt(columnLabel));
        }
        if (type == Long.class) {
            return (T) Long.valueOf(resultSet.getLong(columnLabel));
        }
        if (type == Double.class) {
            return (T) Double.valueOf(resultSet.getDouble(columnLabel));
        }
        if (type == Float.class) {
            return (T) Float.valueOf(resultSet.getFloat(columnLabel));
        }
        if (type == Short.class) {
            return (T) Short.valueOf(resultSet.getShort(columnLabel));
        }
        if (type == BigDecimal.class) {
            return (T) resultSet.getBigDecimal(columnLabel);
        }
        if (type == Byte.class) {
            return (T) Byte.valueOf(resultSet.getByte(columnLabel));
        }
        // Dates
        if (type == Date.class) {
            return (T) resultSet.getDate(columnLabel);
        }
        if (type == Time.class) {
            return (T) resultSet.getTime(columnLabel);
        }
        if (type == Timestamp.class) {
            return (T) resultSet.getTimestamp(columnLabel);
        }
        // Streams
        if (type == InputStream.class) {
            return (T) resultSet.getBinaryStream(columnLabel);
        }
        if (type == Reader.class) {
            return (T) resultSet.getCharacterStream(columnLabel);
        }
        // Other
        if (type == Object.class) {
            return (T) resultSet.getObject(columnLabel);
        }
        if (type == Boolean.class) {
            return (T) Boolean.valueOf(resultSet.getBoolean(columnLabel));
        }
        if (type == Array.class) {
            return (T) resultSet.getArray(columnLabel);
        }
        if (type == Blob.class) {
            return (T) resultSet.getBlob(columnLabel);
        }
        if (type == Clob.class) {
            return (T) resultSet.getClob(columnLabel);
        }
        if (type == Ref.class) {
            return (T) resultSet.getRef(columnLabel);
        }
        if (type == RowId.class) {
            return (T) resultSet.getRowId(columnLabel);
        }
        if (type == SQLXML.class) {
            return (T) resultSet.getSQLXML(columnLabel);
        }
        if (type == URL.class) {
            return (T) resultSet.getURL(columnLabel);
        }
        throw new SQLFeatureNotSupportedException(
                String.format("resultSet=%s, columnLabel=%s, type=%s", resultSet, columnLabel, type));
    }
}
 

public static EdmProperty mockEdmProperty(final String entityName, final String propertyName) throws EdmException {
  EdmProperty edmProperty = EasyMock.createMock(EdmProperty.class);

  if (propertyName.equals(JPATypeMock.PROPERTY_NAME_MINT) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_ENUM) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MSTRING) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MDATETIME) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MBLOB) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_CLOB) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MCARRAY) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MC) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MCHAR) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MCHARARRAY) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_XMLADAPTER) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MSHORT) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock2.PROPERTY_NAME_MFLOAT) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock2.PROPERTY_NAME_MUUID) ||
      propertyName.equals(JPARelatedTypeMock.PROPERTY_NAME_MLONG) ||
      propertyName.equals(JPARelatedTypeMock.PROPERTY_NAME_MBYTE) ||
      propertyName.equals(JPARelatedTypeMock.PROPERTY_NAME_MDOUBLE) ||
      propertyName.equals(JPARelatedTypeMock.PROPERTY_NAME_MBYTEARRAY) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MDATE) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MDATE1) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MTIME) ||
      propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MTIMESTAMP)) {

    EdmSimpleType edmType = EasyMock.createMock(EdmSimpleType.class);
    EasyMock.expect(edmProperty.getType()).andReturn(edmType).anyTimes();
    EasyMock.expect(edmProperty.getFacets()).andReturn(null).anyTimes();
    EasyMock.expect(edmType.getKind()).andReturn(EdmTypeKind.SIMPLE).anyTimes();
    if (propertyName.equals(JPATypeMock.PROPERTY_NAME_MSTRING) ||
        propertyName.equals(JPATypeMock.PROPERTY_NAME_ENUM) ||
        propertyName.equals(JPATypeMock.PROPERTY_NAME_MCARRAY) ||
        propertyName.equals(JPATypeMock.PROPERTY_NAME_MC) ||
        propertyName.equals(JPATypeMock.PROPERTY_NAME_MCHAR) ||
        propertyName.equals(JPATypeMock.PROPERTY_NAME_MCHARARRAY)) {
      EasyMock.<Class<?>> expect(edmType.getDefaultType()).andReturn(String.class).anyTimes();
    } else if (propertyName.equals(JPATypeMock.PROPERTY_NAME_MBLOB)) {
      EasyMock.<Class<?>> expect(edmType.getDefaultType()).andReturn(Blob.class).anyTimes();
    } else if (propertyName.equals(JPATypeMock.PROPERTY_NAME_XMLADAPTER)) {
  	  EasyMock.<Class<?>> expect(edmType.getDefaultType())
  	  	.andReturn(String.class).anyTimes();
    } else {
      EasyMock.<Class<?>> expect(edmType.getDefaultType()).andReturn(Integer.class).anyTimes();
    }

    EasyMock.expect(edmType.isCompatible(EasyMock.isA(EdmSimpleType.class))).andReturn(true).anyTimes();
    EasyMock.replay(edmType);
    EasyMock.expect(edmProperty.getName()).andReturn(propertyName).anyTimes();
    
    
    
    EasyMock.expect(edmProperty.getMapping()).andReturn((EdmMapping) mockEdmMapping(entityName, propertyName, null))
        .anyTimes();

  } else if (propertyName.equals(JPATypeMock.JPATypeEmbeddableMock.PROPERTY_NAME_MEMBEDDABLE) ||
      propertyName.equals(JPATypeMock.PROPERTY_NAME_MCOMPLEXTYPE)) {
    EdmComplexType complexType = mockComplexType(propertyName);

    EasyMock.expect(edmProperty.getType()).andReturn(complexType).anyTimes();
    EasyMock.expect(edmProperty.getName()).andReturn(propertyName).anyTimes();
    EasyMock.expect(edmProperty.getMapping()).andReturn((EdmMapping) mockEdmMapping(null, propertyName, null))
        .anyTimes();
    EasyMock.expect(edmProperty.getFacets()).andReturn(null).anyTimes();

  }

  EasyMock.replay(edmProperty);
  return edmProperty;
}
 

@Override
public void setBlob(int i, Blob x) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void setBlob(int i, Blob x) throws SQLException {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void updateBlob(String columnLabel, Blob x) throws SQLException {
	// TODO Auto-generated method stub

}
 

@Override
public Blob getBlob(String arg0) throws SQLException {
  throw new SQLException(Constant.METHOD_NOT_SUPPORTED);
}