Java Types.BLOB属性代码示例

/**
 * JDBC 2.0 Set a BLOB parameter.
 * 
 * @param i
 *            the first parameter is 1, the second is 2, ...
 * @param x
 *            an object representing a BLOB
 * 
 * @throws SQLException
 *             if a database error occurs
 */
public void setBlob(int i, java.sql.Blob x) throws SQLException {
    if (x == null) {
        setNull(i, Types.BLOB);
    } else {
        ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();

        bytesOut.write('\'');
        escapeblockFast(x.getBytes(1, (int) x.length()), bytesOut, (int) x.length());
        bytesOut.write('\'');

        setInternal(i, bytesOut.toByteArray());

        this.parameterTypes[i - 1 + getParameterIndexOffset()] = Types.BLOB;
    }
}
 

/**
 * Validate the parameters passed to an execute method based on declared parameters.
 * Subclasses should invoke this method before every {@code executeQuery()}
 * or {@code update()} method.
 * @param parameters parameters supplied (may be {@code null})
 * @throws InvalidDataAccessApiUsageException if the parameters are invalid
 */
protected void validateParameters(Object[] parameters) throws InvalidDataAccessApiUsageException {
	checkCompiled();
	int declaredInParameters = 0;
	for (SqlParameter param : this.declaredParameters) {
		if (param.isInputValueProvided()) {
			if (!supportsLobParameters() &&
					(param.getSqlType() == Types.BLOB || param.getSqlType() == Types.CLOB)) {
				throw new InvalidDataAccessApiUsageException(
						"BLOB or CLOB parameters are not allowed for this kind of operation");
			}
			declaredInParameters++;
		}
	}
	validateParameterCount((parameters != null ? parameters.length : 0), declaredInParameters);
}
 

public static boolean useBufferRowExplicit(Field[] fields) {
    if (fields == null) {
        return false;
    }

    for (int i = 0; i < fields.length; i++) {
        switch (fields[i].getSQLType()) {
            case Types.BLOB:
            case Types.CLOB:
            case Types.LONGVARBINARY:
            case Types.LONGVARCHAR:
                return true;
        }
    }

    return false;
}
 

public Integer convert(String value) {
    if ("ARRAY".equals(value))   { return Types.ARRAY; }
    if ("BIGINT".equals(value))  { return Types.BIGINT; }
    if ("BINARY".equals(value))  { return Types.BINARY; }
    if ("BIT".equals(value))     { return Types.BIT; }
    if ("BLOB".equals(value))    { return Types.BLOB; }
    if ("BOOLEAN".equals(value)) { return Types.BOOLEAN; }
    if ("CHAR".equals(value))    { return Types.CHAR; }
    if ("CLOB".equals(value))    { return Types.CLOB; }
    return Types.OTHER;
}
 

private void doPreparedStatement(PreparedStatement ps, final DbDialect dbDialect, final Integer[] columnTypes,
                                 final String[] columnValues) throws SQLException {
    LobCreator lobCreator = null;
    for (int i = 0; i < columnTypes.length; i++) {
        int paramIndex = i + 1;
        String sqlValue = columnValues[i];
        int sqlType = columnTypes[i];
        Object param = SqlUtils.stringToSqlValue(sqlValue,
            sqlType,
            SqlUtils.isTextType(sqlType),
            dbDialect.isEmptyStringNulled());
        switch (sqlType) {
            case Types.CLOB:
                if (lobCreator == null) {
                    lobCreator = dbDialect.getLobHandler().getLobCreator();
                }

                lobCreator.setClobAsString(ps, paramIndex, (String) param);
                break;

            case Types.BLOB:
                if (lobCreator == null) {
                    lobCreator = dbDialect.getLobHandler().getLobCreator();
                }

                lobCreator.setBlobAsBytes(ps, paramIndex, (byte[]) param);
                break;
            case Types.TIME:
            case Types.TIMESTAMP:
            case Types.DATE:
                ps.setObject(paramIndex, sqlValue);
                break;
            default:
                StatementCreatorUtils.setParameterValue(ps, paramIndex, sqlType, null, param);
                break;
        }
    }
}
 

public boolean isBlobValue() {
	if(this.dataType==Types.BLOB)
	{
		return true;
	}
	else
	{
		return false;
	}
}
 

public String getSelectClauseNullString(int sqlType) {
        String literal;
        switch ( sqlType ) {
                case Types.LONGVARCHAR:
                case Types.VARCHAR:
                case Types.CHAR:
                        literal = "cast(null as varchar(100))";
                        break;
                case Types.LONGVARBINARY:
                case Types.VARBINARY:
                case Types.BINARY:
                        literal = "cast(null as varbinary(100))";
                        break;
                case Types.CLOB:
                        literal = "cast(null as clob)";
                        break;
                case Types.BLOB:
                        literal = "cast(null as blob)";
                        break;
                case Types.DATE:
                        literal = "cast(null as date)";
                        break;
                case Types.TIMESTAMP:
                        literal = "cast(null as timestamp)";
                        break;
                case Types.BOOLEAN:
                        literal = "cast(null as boolean)";
                        break;
                case Types.BIT:
                        literal = "cast(null as bit)";
                        break;
                case Types.TIME:
                        literal = "cast(null as time)";
                        break;
                default:
                        literal = "cast(null as int)";
        }
        return literal;
}
 

@SuppressWarnings("unchecked")
public static final void buildWithCallback(AbstractConfig config, ResultSet rs, final Callback callback) throws SQLException {
	ResultSetMetaData rsmd = rs.getMetaData();
	int columnCount = rsmd.getColumnCount();
	String[] labelNames = new String[columnCount + 1];
	int[] types = new int[columnCount + 1];
	buildLabelNamesAndTypes(rsmd, labelNames, types);
	while (rs.next()) {
		Record record = new Record();
		record.setColumnsMap(config.containerFactory.getColumnsMap());
		Map<String, Object> columns = record.getColumns();
		for (int i=1; i<=columnCount; i++) {
			Object value;
			if (types[i] < Types.BLOB)
				value = rs.getObject(i);
			else if (types[i] == Types.CLOB)
				value = ModelBuilder.handleClob(rs.getClob(i));
			else if (types[i] == Types.NCLOB)
				value = ModelBuilder.handleClob(rs.getNClob(i));
			else if (types[i] == Types.BLOB)
				value = ModelBuilder.handleBlob(rs.getBlob(i));
			else
				value = rs.getObject(i);
			
			columns.put(labelNames[i], value);
		}
		int rowIndex = rs.getRow();
		if (callback != null) {
			callback.invoke(record, rowIndex);
		}
	}
}
 

/**
 * Set the specified content via the LobCreator.
 */
@Override
public void setTypeValue(PreparedStatement ps, int paramIndex, int sqlType, String typeName)
		throws SQLException {
	if (sqlType == Types.BLOB) {
		if (this.content instanceof byte[] || this.content == null) {
			this.lobCreator.setBlobAsBytes(ps, paramIndex, (byte[]) this.content);
		}
		else if (this.content instanceof String) {
			this.lobCreator.setBlobAsBytes(ps, paramIndex, ((String) this.content).getBytes());
		}
		else if (this.content instanceof InputStream) {
			this.lobCreator.setBlobAsBinaryStream(ps, paramIndex, (InputStream) this.content, this.length);
		}
		else {
			throw new IllegalArgumentException(
					"Content type [" + this.content.getClass().getName() + "] not supported for BLOB columns");
		}
	}
	else if (sqlType == Types.CLOB) {
		if (this.content instanceof String || this.content == null) {
			this.lobCreator.setClobAsString(ps, paramIndex, (String) this.content);
		}
		else if (this.content instanceof InputStream) {
			this.lobCreator.setClobAsAsciiStream(ps, paramIndex, (InputStream) this.content, this.length);
		}
		else if (this.content instanceof Reader) {
			this.lobCreator.setClobAsCharacterStream(ps, paramIndex, (Reader) this.content, this.length);
		}
		else {
			throw new IllegalArgumentException(
					"Content type [" + this.content.getClass().getName() + "] not supported for CLOB columns");
		}
	}
	else {
		throw new IllegalArgumentException("SqlLobValue only supports SQL types BLOB and CLOB");
	}
}
 

/**
 * A column value can also be retrieved as a binary stream. This method is
 * suitable for retrieving LONGVARBINARY values.
 * 
 * @param columnIndex
 *            the first column is 1, the second is 2...
 * 
 * @return a Java InputStream that delivers the database column value as a
 *         stream of bytes. If the value is SQL NULL, then the result is
 *         null
 * 
 * @exception SQLException
 *                if a database access error occurs
 * 
 * @see getAsciiStream
 * @see getUnicodeStream
 */
protected InputStream getNativeBinaryStream(int columnIndex) throws SQLException {
    checkRowPos();

    int columnIndexMinusOne = columnIndex - 1;

    if (this.thisRow.isNull(columnIndexMinusOne)) {
        this.wasNullFlag = true;

        return null;
    }

    this.wasNullFlag = false;

    switch (this.fields[columnIndexMinusOne].getSQLType()) {
        case Types.BIT:
        case Types.BINARY:
        case Types.VARBINARY:
        case Types.BLOB:
        case Types.LONGVARBINARY:
            return this.thisRow.getBinaryInputStream(columnIndexMinusOne);
    }

    byte[] b = getNativeBytes(columnIndex, false);

    if (b != null) {
        return new ByteArrayInputStream(b);
    }

    return null;
}
 

private void setInOutParamsOnServer() throws SQLException {
    synchronized (checkClosed().getConnectionMutex()) {
        if (this.paramInfo.numParameters > 0) {
            for (Iterator<CallableStatementParam> paramIter = this.paramInfo.iterator(); paramIter.hasNext();) {

                CallableStatementParam inParamInfo = paramIter.next();

                //Fix for 5.5+
                if (inParamInfo.isOut && inParamInfo.isIn) {
                    if ((inParamInfo.paramName == null) && (hasParametersView())) {
                        inParamInfo.paramName = "nullnp" + inParamInfo.index;
                    }

                    String inOutParameterName = mangleParameterName(inParamInfo.paramName);
                    StringBuilder queryBuf = new StringBuilder(4 + inOutParameterName.length() + 1 + 1);
                    queryBuf.append("SET ");
                    queryBuf.append(inOutParameterName);
                    queryBuf.append("=?");

                    PreparedStatement setPstmt = null;

                    try {
                        setPstmt = ((Wrapper) this.connection.clientPrepareStatement(queryBuf.toString())).unwrap(PreparedStatement.class);

                        if (this.isNull[inParamInfo.index]) {
                            setPstmt.setBytesNoEscapeNoQuotes(1, "NULL".getBytes());

                        } else {
                            byte[] parameterAsBytes = getBytesRepresentation(inParamInfo.index);

                            if (parameterAsBytes != null) {
                                if (parameterAsBytes.length > 8 && parameterAsBytes[0] == '_' && parameterAsBytes[1] == 'b' && parameterAsBytes[2] == 'i'
                                        && parameterAsBytes[3] == 'n' && parameterAsBytes[4] == 'a' && parameterAsBytes[5] == 'r'
                                        && parameterAsBytes[6] == 'y' && parameterAsBytes[7] == '\'') {
                                    setPstmt.setBytesNoEscapeNoQuotes(1, parameterAsBytes);
                                } else {
                                    int sqlType = inParamInfo.desiredJdbcType;

                                    switch (sqlType) {
                                        case Types.BIT:
                                        case Types.BINARY:
                                        case Types.BLOB:
                                        case Types.JAVA_OBJECT:
                                        case Types.LONGVARBINARY:
                                        case Types.VARBINARY:
                                            setPstmt.setBytes(1, parameterAsBytes);
                                            break;
                                        default:
                                            // the inherited PreparedStatement methods have already escaped and quoted these parameters
                                            setPstmt.setBytesNoEscape(1, parameterAsBytes);
                                    }
                                }
                            } else {
                                setPstmt.setNull(1, Types.NULL);
                            }
                        }

                        setPstmt.executeUpdate();
                    } finally {
                        if (setPstmt != null) {
                            setPstmt.close();
                        }
                    }
                }
            }
        }
    }
}
 

@Override
public int[] sqlTypes() {
	return new int[] {Types.BLOB};
}
 

static public Class<?> getParameterJavaClass(int param_type) {
	switch (param_type) {
    	case Types.ARRAY: 
    		return Object[].class; 
        case Types.BIGINT: 
        	return Long.class; 
        case Types.BINARY: 
        	return byte[].class; 
        case Types.BIT: 
        	return Boolean.class; 
        case Types.BLOB: 
        	return java.sql.Blob.class; 
        case Types.BOOLEAN:
        	return Boolean.class; 
        case Types.CHAR: 
        	return String.class; 
        case Types.CLOB: 
        	return java.sql.Clob.class; 
        case Types.DATALINK: 
        	return java.net.URL.class; 
        case Types.DATE: 
        	return java.sql.Date.class; 
        case Types.DECIMAL: 
        	return java.math.BigDecimal.class; 
        case Types.DISTINCT: 
        	return Object.class; 
        case Types.DOUBLE: 
        	return Double.class; 
        case Types.FLOAT: 
        	return Double.class; 
        case Types.INTEGER: 
        	return Integer.class; 
        case Types.JAVA_OBJECT: 
        	return Object.class; 
        case Types.LONGVARBINARY: 
        	return byte[].class; 
        case Types.LONGVARCHAR: 
        	return String.class; 
        case Types.NCLOB: 
        	return java.sql.NClob.class; 
        case Types.NULL: 
        	return Object.class; 
        case Types.NUMERIC: 
        	return java.math.BigDecimal.class; 
        case Types.NCHAR: 
        case Types.NVARCHAR: 
        case Types.LONGNVARCHAR: 
        	return String.class; 
        case Types.OTHER: 
        	return Object.class; 
        case Types.REAL: 
        	return Float.class; 
        case Types.REF: 
        	return java.sql.Ref.class; 
        case Types.ROWID: 
        	return java.sql.RowId.class; 
        case Types.SMALLINT: 
        	return Short.class; 
        case Types.STRUCT: 
        	return java.sql.Struct.class; 
        case Types.SQLXML: 
        	return java.sql.SQLXML.class; 
        case Types.TIME: 
        	return java.sql.Time.class; 
        case Types.TIMESTAMP: 
        	return java.sql.Timestamp.class; 
        case Types.TINYINT: 
        	return Byte.class; 
        case Types.VARBINARY: 
        	return byte[].class; 
        case Types.VARCHAR: 
        	return String.class; 
        default: 
        	return Object.class;
       }
}
 

@Override
public String getSelectClauseNullString(int sqlType) {
	String v = "null";

	switch ( sqlType ) {
		case Types.BIT:
		case Types.TINYINT:
		case Types.SMALLINT:
		case Types.INTEGER:
		case Types.BIGINT:
		case Types.FLOAT:
		case Types.REAL:
		case Types.DOUBLE:
		case Types.NUMERIC:
		case Types.DECIMAL:
			v = "cast(null as decimal)";
			break;
		case Types.CHAR:
		case Types.VARCHAR:
		case Types.LONGVARCHAR:
			v = "cast(null as varchar(255))";
			break;
		case Types.DATE:
		case Types.TIME:
		case Types.TIMESTAMP:
			v = "cast(null as timestamp)";
			break;
		case Types.BINARY:
		case Types.VARBINARY:
		case Types.LONGVARBINARY:
		case Types.NULL:
		case Types.OTHER:
		case Types.JAVA_OBJECT:
		case Types.DISTINCT:
		case Types.STRUCT:
		case Types.ARRAY:
		case Types.BLOB:
		case Types.CLOB:
		case Types.REF:
		case Types.DATALINK:
		case Types.BOOLEAN:
			break;
		default:
			break;
	}
	return v;
}
 

/**
 * 根据Types获取字段类型
 *
 * @see Types
 * @return 对应字段的java类型
 */
public static FieldType getFieldType(Integer sqlType) {
    FieldType fieldType = sqlTypes.get("UNKNOWN");
    if (sqlType == null) {
        return fieldType;
    }

    // https://docs.oracle.com/javase/1.5.0/docs/guide/jdbc/getstart/mapping.html
    if (sqlType == Types.INTEGER) {
        fieldType = sqlTypes.get("INTEGER");
    } else if (sqlType == Types.VARCHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.CHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.LONGVARCHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.NVARCHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.NCHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.LONGNVARCHAR) {
        fieldType = sqlTypes.get("STRING");
    } else if (sqlType == Types.NUMERIC) {
        fieldType = sqlTypes.get("DECIMAL");
    } else if (sqlType == Types.DECIMAL) {
        fieldType = sqlTypes.get("DECIMAL");
    } else if (sqlType == Types.BIT) {
        fieldType = sqlTypes.get("BOOLEAN");
    } else if (sqlType == Types.BOOLEAN) {
        fieldType = sqlTypes.get("BOOLEAN");
    } else if (sqlType == Types.TINYINT) {
        fieldType = sqlTypes.get("INTEGER");
    } else if (sqlType == Types.SMALLINT) {
        fieldType = sqlTypes.get("INTEGER");
    } else if (sqlType == Types.BIGINT) {
        fieldType = sqlTypes.get("BIGINT");
    } else if (sqlType == Types.REAL) {
        fieldType = sqlTypes.get("REAL");
    } else if (sqlType == Types.FLOAT) {
        fieldType = sqlTypes.get("FLOAT");
    } else if (sqlType == Types.DOUBLE) {
        fieldType = sqlTypes.get("DOUBLE");
    } else if (sqlType == Types.DATE) {
        // java.sql.Date ?
        fieldType = sqlTypes.get("DATE");
    } else if (sqlType == Types.TIME) {
        // java.sql.Time ?
        fieldType = sqlTypes.get("TIME");
    } else if (sqlType == Types.TIMESTAMP) {
        // java.sql.Timestamp ?
        fieldType = sqlTypes.get("TIMESTAMP");
    } else if (sqlType == Types.BINARY
            || sqlType == Types.VARBINARY) {
        fieldType = sqlTypes.get("BINARY");
    } else if (sqlType == Types.CLOB) {
        fieldType = sqlTypes.get("CLOB");
    } else if (sqlType == Types.BLOB
            || sqlType == Types.LONGVARBINARY) {
        fieldType = sqlTypes.get("BLOB");
    } else {
        // DISTINCT, ARRAY, STRUCT, REF, JAVA_OBJECT.
        return fieldType;
    }
    return fieldType;
}