Java Type.equals方法代码示例

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
public static JDBCType jdbcType(Type type)
{
    if (type.equals(BooleanType.BOOLEAN)) {
        return JDBCType.BOOLEAN;
    }
    if (type.equals(BigintType.BIGINT) || type.equals(TimestampType.TIMESTAMP)) {
        return JDBCType.BIGINT;
    }
    if (type.equals(DoubleType.DOUBLE)) {
        return JDBCType.DOUBLE;
    }
    if (type.equals(DateType.DATE)) {
        return JDBCType.INTEGER;
    }
    if (type.equals(VarcharType.VARCHAR)) {
        return JDBCType.VARBINARY;
    }
    return null;
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private static ColumnStats doComputeColumnStats(OrcReader orcReader, long columnId, Type type)
        throws IOException
{
    int columnIndex = columnIndex(orcReader.getColumnNames(), columnId);
    OrcRecordReader reader = orcReader.createRecordReader(ImmutableMap.of(columnIndex, type), OrcPredicate.TRUE, UTC, new AggregatedMemoryContext());

    if (type.equals(BooleanType.BOOLEAN)) {
        return indexBoolean(type, reader, columnIndex, columnId);
    }
    if (type.equals(BigintType.BIGINT) ||
            type.equals(DateType.DATE) ||
            type.equals(TimestampType.TIMESTAMP)) {
        return indexLong(type, reader, columnIndex, columnId);
    }
    if (type.equals(DoubleType.DOUBLE)) {
        return indexDouble(type, reader, columnIndex, columnId);
    }
    if (type.equals(VarcharType.VARCHAR)) {
        return indexString(type, reader, columnIndex, columnId);
    }
    return null;
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
@Override
public ScalarFunctionImplementation specialize(Map<String, Type> types, int arity, TypeManager typeManager, FunctionRegistry functionRegistry)
{
    Type fromType = types.get("F");
    Type toType = types.get("T");

    Class<?> returnType = Primitives.wrap(toType.getJavaType());
    MethodHandle tryCastHandle;

    if (fromType.equals(UNKNOWN)) {
        tryCastHandle = dropArguments(constant(returnType, null), 0, Void.class);
    }
    else {
        // the resulting method needs to return a boxed type
        Signature signature = functionRegistry.getCoercion(fromType, toType);
        MethodHandle coercion = functionRegistry.getScalarFunctionImplementation(signature).getMethodHandle();
        coercion = coercion.asType(methodType(returnType, coercion.type()));

        MethodHandle exceptionHandler = dropArguments(constant(returnType, null), 0, RuntimeException.class);
        tryCastHandle = catchException(coercion, RuntimeException.class, exceptionHandler);
    }

    return new ScalarFunctionImplementation(true, ImmutableList.of(true), tryCastHandle, isDeterministic());
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
@Override
public final long getLong()
{
    long millis = getMillis();

    Type type = columnHandle.getType();
    if (type.equals(DATE)) {
        return TimeUnit.MILLISECONDS.toDays(millis);
    }
    if (type.equals(TIMESTAMP) || type.equals(TIME)) {
        return millis;
    }
    if (type.equals(TIMESTAMP_WITH_TIME_ZONE) || type.equals(TIME_WITH_TIME_ZONE)) {
        return packDateTimeWithZone(millis, 0);
    }

    return millis;
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private void analyzeHaving(QuerySpecification node, RelationType tupleDescriptor, AnalysisContext context)
{
    if (node.getHaving().isPresent()) {
        Expression predicate = node.getHaving().get();

        ExpressionAnalysis expressionAnalysis = analyzeExpression(predicate, tupleDescriptor, context);
        analysis.recordSubqueries(node, expressionAnalysis);

        Type predicateType = expressionAnalysis.getType(predicate);
        if (!predicateType.equals(BOOLEAN) && !predicateType.equals(UNKNOWN)) {
            throw new SemanticException(TYPE_MISMATCH, predicate, "HAVING clause must evaluate to a boolean: actual type %s", predicateType);
        }

        analysis.setHaving(node, predicate);
    }
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
public static Type typeForMagicLiteral(Type type)
{
    Class<?> clazz = type.getJavaType();
    clazz = Primitives.unwrap(clazz);

    if (clazz == long.class) {
        return BIGINT;
    }
    if (clazz == double.class) {
        return DOUBLE;
    }
    if (!clazz.isPrimitive()) {
        if (type.equals(VARCHAR)) {
            return VARCHAR;
        }
        else {
            return VARBINARY;
        }
    }
    if (clazz == boolean.class) {
        return BOOLEAN;
    }
    throw new IllegalArgumentException("Unhandled Java type: " + clazz.getName());
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
@Override
protected ExtractionResult visitComparisonExpression(ComparisonExpression node, Boolean complement)
{
    Optional<NormalizedSimpleComparison> optionalNormalized = toNormalizedSimpleComparison(session, metadata, types, node);
    if (!optionalNormalized.isPresent()) {
        return super.visitComparisonExpression(node, complement);
    }
    NormalizedSimpleComparison normalized = optionalNormalized.get();

    Symbol symbol = Symbol.fromQualifiedName(normalized.getNameReference().getName());
    Type type = checkedTypeLookup(symbol);
    NullableValue value = normalized.getValue();

    // Handle the cases where implicit coercions can happen in comparisons
    // TODO: how to abstract this out
    if (value.getType().equals(DOUBLE) && type.equals(BIGINT)) {
        return process(coerceDoubleToLongComparison(normalized), complement);
    }
    if (value.getType().equals(BIGINT) && type.equals(DOUBLE)) {
        value = NullableValue.of(DOUBLE, ((Long) value.getValue()).doubleValue());
    }
    checkState(value.isNull() || value.getType().equals(type), "INVARIANT: comparison should be working on the same types");
    return createComparisonExtractionResult(normalized.getComparisonType(), symbol, type, value.getValue(), complement);
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
@Override
public Slice getSlice(int fieldId)
{
    checkState(!closed, "Cursor is closed");

    Type type = types[fieldId];
    if (!type.equals(VARCHAR) && !type.equals(VARBINARY) && !isStructuralType(hiveTypes[fieldId])) {
        // we don't use Preconditions.checkArgument because it requires boxing fieldId, which affects inner loop performance
        throw new IllegalArgumentException(format("Expected field to be VARCHAR or VARBINARY, actual %s (field %s)", type, fieldId));
    }

    if (!loaded[fieldId]) {
        parseStringColumn(fieldId);
    }
    return slices[fieldId];
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private void checkFieldType(int field, Type... expected)
{
    log.info("INFORMATION: AmpoolRecordCursor checkFieldType() called.");

    Type actual = getType(field);
    for (Type type : expected) {
        if (actual.equals(type)) {
            return;
        }
    }
    String expectedTypes = Joiner.on(", ").join(expected);
    throw new IllegalArgumentException(format("Expected field %s to be type %s but is %s", field, expectedTypes, actual));
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private static StorageType toStorageType(Type type)
{
    Class<?> javaType = type.getJavaType();
    if (javaType == boolean.class) {
        return StorageType.BOOLEAN;
    }
    if (javaType == long.class) {
        return StorageType.LONG;
    }
    if (javaType == double.class) {
        return StorageType.DOUBLE;
    }
    if (javaType == Slice.class) {
        if (type.equals(VarcharType.VARCHAR)) {
            return StorageType.STRING;
        }
        if (type.equals(VarbinaryType.VARBINARY)) {
            return StorageType.BYTES;
        }
    }
    if (isArrayType(type)) {
        return arrayOf(toStorageType(type.getTypeParameters().get(0)));
    }
    if (isMapType(type)) {
        return mapOf(toStorageType(type.getTypeParameters().get(0)), toStorageType(type.getTypeParameters().get(1)));
    }
    throw new PrestoException(NOT_SUPPORTED, "No storage type for type: " + type);
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private Type coerceToSingleType(StackableAstVisitorContext<AnalysisContext> context, Node node, String message, Expression first, Expression second)
{
    Type firstType = null;
    if (first != null) {
        firstType = process(first, context);
    }
    Type secondType = null;
    if (second != null) {
        secondType = process(second, context);
    }

    if (firstType == null) {
        return secondType;
    }
    if (secondType == null) {
        return firstType;
    }
    if (firstType.equals(secondType)) {
        return firstType;
    }

    // coerce types if possible
    if (canCoerce(firstType, secondType)) {
        expressionCoercions.put(first, secondType);
        return secondType;
    }
    if (canCoerce(secondType, firstType)) {
        expressionCoercions.put(second, firstType);
        return firstType;
    }
    throw new SemanticException(TYPE_MISMATCH, node, message, firstType, secondType);
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private List<String> toConjuncts(List<JdbcColumnHandle> columns, TupleDomain<ColumnHandle> tupleDomain)
{
    ImmutableList.Builder<String> builder = ImmutableList.builder();
    for (JdbcColumnHandle column : columns) {
        Type type = column.getColumnType();
        if (type.equals(BigintType.BIGINT) || type.equals(DoubleType.DOUBLE) || type.equals(BooleanType.BOOLEAN)) {
            Domain domain = tupleDomain.getDomains().get().get(column);
            if (domain != null) {
                builder.add(toPredicate(column.getColumnName(), domain));
            }
        }
    }
    return builder.build();
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
@Override
public long getLong(int field)
{
    checkState(!closed, "cursor is closed");
    try {
        Type type = getType(field);
        if (type.equals(BigintType.BIGINT)) {
            return resultSet.getLong(field + 1);
        }
        if (type.equals(DateType.DATE)) {
            // JDBC returns a date using a timestamp at midnight in the JVM timezone
            long localMillis = resultSet.getDate(field + 1).getTime();
            // Convert it to a midnight in UTC
            long utcMillis = ISOChronology.getInstance().getZone().getMillisKeepLocal(UTC, localMillis);
            // convert to days
            return TimeUnit.MILLISECONDS.toDays(utcMillis);
        }
        if (type.equals(TimeType.TIME)) {
            Time time = resultSet.getTime(field + 1);
            return UTC_CHRONOLOGY.millisOfDay().get(time.getTime());
        }
        if (type.equals(TimestampType.TIMESTAMP)) {
            Timestamp timestamp = resultSet.getTimestamp(field + 1);
            return timestamp.getTime();
        }
        throw new PrestoException(INTERNAL_ERROR, "Unhandled type for long: " + type.getTypeSignature());
    }
    catch (SQLException e) {
        throw handleSqlException(e);
    }
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private static List<Page> createPages(int pageCount, int channelCount, Type type)
{
    int positionCount = PageBuilderStatus.DEFAULT_MAX_PAGE_SIZE_IN_BYTES / (channelCount * 8);

    List<Page> pages = new ArrayList<>(pageCount);
    for (int numPage = 0; numPage < pageCount; numPage++) {
        Block[] blocks = new Block[channelCount];
        for (int numChannel = 0; numChannel < channelCount; numChannel++) {
            if (type.equals(BIGINT)) {
                blocks[numChannel] = BlockAssertions.createLongSequenceBlock(0, positionCount);
            }
            else if (type.equals(VARCHAR)) {
                blocks[numChannel] = BlockAssertions.createStringSequenceBlock(0, positionCount);
            }
            else if (type.equals(DOUBLE)) {
                blocks[numChannel] = BlockAssertions.createDoubleSequenceBlock(0, positionCount);
            }
            else if (type.equals(BOOLEAN)) {
                blocks[numChannel] = BlockAssertions.createBooleanSequenceBlock(0, positionCount);
            }
            else {
                throw new IllegalArgumentException("Unsupported type: " + type);
            }
        }
        pages.add(new Page(blocks));
    }
    return pages;
}
 

import com.facebook.presto.spi.type.Type; //导入方法依赖的package包/类
private static int jdbcDataType(Type type)
{
    if (type.equals(BOOLEAN)) {
        return Types.BOOLEAN;
    }
    if (type.equals(BIGINT)) {
        return Types.BIGINT;
    }
    if (type.equals(DOUBLE)) {
        return Types.DOUBLE;
    }
    if (type.equals(VARCHAR)) {
        return Types.LONGNVARCHAR;
    }
    if (type.equals(VARBINARY)) {
        return Types.LONGVARBINARY;
    }
    if (type.equals(TIME)) {
        return Types.TIME;
    }
    if (type.equals(TIME_WITH_TIME_ZONE)) {
        return Types.TIME_WITH_TIMEZONE;
    }
    if (type.equals(TIMESTAMP)) {
        return Types.TIMESTAMP;
    }
    if (type.equals(TIMESTAMP_WITH_TIME_ZONE)) {
        return Types.TIMESTAMP_WITH_TIMEZONE;
    }
    if (type.equals(DATE)) {
        return Types.DATE;
    }
    if (type instanceof ArrayType) {
        return Types.ARRAY;
    }
    return Types.JAVA_OBJECT;
}