Java StandardBasicTypes.INTEGER属性代码示例

public Type toType(String propertyName) throws QueryException {
	if ( propertyName.equals(CollectionPropertyNames.COLLECTION_ELEMENTS) ) {
		return memberPersister.getElementType();
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_INDICES) ) {
		if ( !memberPersister.hasIndex() ) throw new QueryException("unindexed collection before indices()");
		return memberPersister.getIndexType();
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_SIZE) ) {
		return StandardBasicTypes.INTEGER;
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_MAX_INDEX) ) {
		return memberPersister.getIndexType();
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_MIN_INDEX) ) {
		return memberPersister.getIndexType();
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_MAX_ELEMENT) ) {
		return memberPersister.getElementType();
	}
	else if ( propertyName.equals(CollectionPropertyNames.COLLECTION_MIN_ELEMENT) ) {
		return memberPersister.getElementType();
	}
	else {
		//return memberPersister.getPropertyType(propertyName);
		throw new QueryException("illegal syntax near collection: " + propertyName);
	}
}
 

public Type getDataType() {
	if ( expectedType != null ) {
		return expectedType;
	}

	switch ( getType() ) {
		case NUM_INT:
			return StandardBasicTypes.INTEGER;
		case NUM_FLOAT:
			return StandardBasicTypes.FLOAT;
		case NUM_LONG:
			return StandardBasicTypes.LONG;
		case NUM_DOUBLE:
			return StandardBasicTypes.DOUBLE;
		case NUM_BIG_INTEGER:
			return StandardBasicTypes.BIG_INTEGER;
		case NUM_BIG_DECIMAL:
			return StandardBasicTypes.BIG_DECIMAL;
		case QUOTED_STRING:
			return StandardBasicTypes.STRING;
		case TRUE:
		case FALSE:
			return StandardBasicTypes.BOOLEAN;
		default:
			return null;
	}
}
 

@Override
public TypedValue[] getTypedValues(Criteria criteria, CriteriaQuery criteriaQuery) throws HibernateException {
	return new TypedValue[] { new TypedValue( StandardBasicTypes.INTEGER, size ) };
}
 

public Type getDiscriminatorType() {
	return StandardBasicTypes.INTEGER;
}
 

@Override
public Type getReturnType(Type firstArgumentType, Mapping mapping) {
	final int jdbcType = determineJdbcTypeCode( firstArgumentType, mapping );

	// First allow the actual type to control the return value; the underlying sqltype could
	// actually be different
	if ( firstArgumentType == StandardBasicTypes.BIG_INTEGER ) {
		return StandardBasicTypes.BIG_INTEGER;
	}
	else if ( firstArgumentType == StandardBasicTypes.BIG_DECIMAL ) {
		return StandardBasicTypes.BIG_DECIMAL;
	}
	else if ( firstArgumentType == StandardBasicTypes.LONG
			|| firstArgumentType == StandardBasicTypes.SHORT
			|| firstArgumentType == StandardBasicTypes.INTEGER ) {
		return StandardBasicTypes.LONG;
	}
	else if ( firstArgumentType == StandardBasicTypes.FLOAT || firstArgumentType == StandardBasicTypes.DOUBLE)  {
		return StandardBasicTypes.DOUBLE;
	}

	// finally use the jdbcType if == on Hibernate types did not find a match.
	//
	//	IMPL NOTE : we do not match on Types.NUMERIC because it could be either, so we fall-through to the
	// 		first argument type
	if ( jdbcType == Types.FLOAT
			|| jdbcType == Types.DOUBLE
			|| jdbcType == Types.DECIMAL
			|| jdbcType == Types.REAL) {
		return StandardBasicTypes.DOUBLE;
	}
	else if ( jdbcType == Types.BIGINT
			|| jdbcType == Types.INTEGER
			|| jdbcType == Types.SMALLINT
			|| jdbcType == Types.TINYINT ) {
		return StandardBasicTypes.LONG;
	}

	// as a last resort, return the type of the first argument
	return firstArgumentType;
}
 

@Override
public Type getReturnType(Type firstArgumentType, Mapping mapping) throws QueryException {
	return StandardBasicTypes.INTEGER;
}
 

@Override
public Type getReturnType(Type columnType, Mapping mapping) throws QueryException {
	return StandardBasicTypes.INTEGER;
}
 

@Override
public Type getReturnType(Type columnType, Mapping mapping) {
	return StandardBasicTypes.INTEGER;
}
 

private Type resolveDataType() {
	// TODO : we may also want to check that the types here map to exactly one column/JDBC-type
	//      can't think of a situation where arithmetic expression between multi-column mappings
	//      makes any sense.
	final Node lhs = getLeftHandOperand();
	final Node rhs = getRightHandOperand();

	final Type lhType = ( lhs instanceof SqlNode ) ? ( (SqlNode) lhs ).getDataType() : null;
	final Type rhType = ( rhs instanceof SqlNode ) ? ( (SqlNode) rhs ).getDataType() : null;

	if ( isDateTimeType( lhType ) || isDateTimeType( rhType ) ) {
		return resolveDateTimeArithmeticResultType( lhType, rhType );
	}
	else {
		if ( lhType == null ) {
			if ( rhType == null ) {
				// we do not know either type
				// BLIND GUESS!
				return StandardBasicTypes.DOUBLE;
			}
			else {
				// we know only the rhs-hand type, so use that
				return rhType;
			}
		}
		else {
			if ( rhType == null ) {
				// we know only the lhs-hand type, so use that
				return lhType;
			}
			else {
				if ( lhType == StandardBasicTypes.DOUBLE || rhType == StandardBasicTypes.DOUBLE ) {
					return StandardBasicTypes.DOUBLE;
				}
				if ( lhType == StandardBasicTypes.FLOAT || rhType == StandardBasicTypes.FLOAT ) {
					return StandardBasicTypes.FLOAT;
				}
				if ( lhType == StandardBasicTypes.BIG_DECIMAL || rhType == StandardBasicTypes.BIG_DECIMAL ) {
					return StandardBasicTypes.BIG_DECIMAL;
				}
				if ( lhType == StandardBasicTypes.BIG_INTEGER || rhType == StandardBasicTypes.BIG_INTEGER ) {
					return StandardBasicTypes.BIG_INTEGER;
				}
				if ( lhType == StandardBasicTypes.LONG || rhType == StandardBasicTypes.LONG ) {
					return StandardBasicTypes.LONG;
				}
				if ( lhType == StandardBasicTypes.INTEGER || rhType == StandardBasicTypes.INTEGER ) {
					return StandardBasicTypes.INTEGER;
				}
				return lhType;
			}
		}
	}
}