Examples with VarcharType io.trino.spi.type.VarcharType used on opensource projects

Example 1 with VarcharType

use of io.trino.spi.type.VarcharType in project TiBigData by tidb-incubator.

the class TiDBPageSink method appendColumn.

private void appendColumn(Page page, int position, int channel) throws SQLException {
    Block block = page.getBlock(channel);
    int parameter = channel + 1;
    if (block.isNull(position)) {
        statement.setObject(parameter, null);
        return;
    }
    Type type = columnTypes.get(channel);
    switch(type.getDisplayName()) {
        case "boolean":
            statement.setBoolean(parameter, type.getBoolean(block, position));
            break;
        case "tinyint":
            statement.setByte(parameter, SignedBytes.checkedCast(type.getLong(block, position)));
            break;
        case "smallint":
            statement.setShort(parameter, Shorts.checkedCast(type.getLong(block, position)));
            break;
        case "integer":
            statement.setInt(parameter, toIntExact(type.getLong(block, position)));
            break;
        case "bigint":
            statement.setLong(parameter, type.getLong(block, position));
            break;
        case "real":
            statement.setFloat(parameter, intBitsToFloat(toIntExact(type.getLong(block, position))));
            break;
        case "double":
            statement.setDouble(parameter, type.getDouble(block, position));
            break;
        case "date":
            // convert to midnight in default time zone
            long utcMillis = DAYS.toMillis(type.getLong(block, position));
            long localMillis = getInstanceUTC().getZone().getMillisKeepLocal(DateTimeZone.getDefault(), utcMillis);
            statement.setDate(parameter, new Date(localMillis));
            break;
        case "varbinary":
            statement.setBytes(parameter, type.getSlice(block, position).getBytes());
            break;
        default:
            if (type instanceof DecimalType) {
                statement.setBigDecimal(parameter, readBigDecimal((DecimalType) type, block, position));
            } else if (type instanceof VarcharType || type instanceof CharType) {
                statement.setString(parameter, type.getSlice(block, position).toStringUtf8());
            } else if (type instanceof TimestampType) {
                statement.setTimestamp(parameter, new Timestamp(type.getLong(block, position) / 1000 - TimeZone.getDefault().getRawOffset()));
            } else if (type instanceof TimeType) {
                statement.setTime(parameter, new Time(type.getLong(block, position)));
            } else {
                throw new TrinoException(NOT_SUPPORTED, "Unsupported column type: " + type.getDisplayName());
            }
    }
}

Example 2 with VarcharType

use of io.trino.spi.type.VarcharType in project trino by trinodb.

the class TransactionsSystemTable method createStringsBlock.

private static Block createStringsBlock(List<CatalogName> values) {
    VarcharType varchar = createUnboundedVarcharType();
    BlockBuilder builder = varchar.createBlockBuilder(null, values.size());
    for (CatalogName value : values) {
        if (value == null) {
            builder.appendNull();
        } else {
            varchar.writeString(builder, value.getCatalogName());
        }
    }
    return builder.build();
}

Example 3 with VarcharType

use of io.trino.spi.type.VarcharType in project trino by trinodb.

the class LiteralEncoder method toExpression.

public Expression toExpression(Session session, Object object, Type type) {
    requireNonNull(type, "type is null");
    if (object instanceof Expression) {
        return (Expression) object;
    }
    if (object == null) {
        if (type.equals(UNKNOWN)) {
            return new NullLiteral();
        }
        return new Cast(new NullLiteral(), toSqlType(type), false, true);
    }
    checkArgument(Primitives.wrap(type.getJavaType()).isInstance(object), "object.getClass (%s) and type.getJavaType (%s) do not agree", object.getClass(), type.getJavaType());
    if (type.equals(TINYINT)) {
        return new GenericLiteral("TINYINT", object.toString());
    }
    if (type.equals(SMALLINT)) {
        return new GenericLiteral("SMALLINT", object.toString());
    }
    if (type.equals(INTEGER)) {
        return new LongLiteral(object.toString());
    }
    if (type.equals(BIGINT)) {
        LongLiteral expression = new LongLiteral(object.toString());
        if (expression.getValue() >= Integer.MIN_VALUE && expression.getValue() <= Integer.MAX_VALUE) {
            return new GenericLiteral("BIGINT", object.toString());
        }
        return new LongLiteral(object.toString());
    }
    if (type.equals(DOUBLE)) {
        Double value = (Double) object;
        if (value.isNaN()) {
            return FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("nan")).build();
        }
        if (value.equals(Double.NEGATIVE_INFINITY)) {
            return ArithmeticUnaryExpression.negative(FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("infinity")).build());
        }
        if (value.equals(Double.POSITIVE_INFINITY)) {
            return FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("infinity")).build();
        }
        return new DoubleLiteral(object.toString());
    }
    if (type.equals(REAL)) {
        Float value = intBitsToFloat(((Long) object).intValue());
        if (value.isNaN()) {
            return new Cast(FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("nan")).build(), toSqlType(REAL));
        }
        if (value.equals(Float.NEGATIVE_INFINITY)) {
            return ArithmeticUnaryExpression.negative(new Cast(FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("infinity")).build(), toSqlType(REAL)));
        }
        if (value.equals(Float.POSITIVE_INFINITY)) {
            return new Cast(FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("infinity")).build(), toSqlType(REAL));
        }
        return new GenericLiteral("REAL", value.toString());
    }
    if (type instanceof DecimalType) {
        String string;
        if (isShortDecimal(type)) {
            string = Decimals.toString((long) object, ((DecimalType) type).getScale());
        } else {
            string = Decimals.toString((Int128) object, ((DecimalType) type).getScale());
        }
        return new Cast(new DecimalLiteral(string), toSqlType(type));
    }
    if (type instanceof VarcharType) {
        VarcharType varcharType = (VarcharType) type;
        Slice value = (Slice) object;
        if (varcharType.isUnbounded()) {
            return new GenericLiteral("VARCHAR", value.toStringUtf8());
        }
        StringLiteral stringLiteral = new StringLiteral(value.toStringUtf8());
        int boundedLength = varcharType.getBoundedLength();
        int valueLength = SliceUtf8.countCodePoints(value);
        if (boundedLength == valueLength) {
            return stringLiteral;
        }
        if (boundedLength > valueLength) {
            return new Cast(stringLiteral, toSqlType(type), false, true);
        }
        throw new IllegalArgumentException(format("Value [%s] does not fit in type %s", value.toStringUtf8(), varcharType));
    }
    if (type instanceof CharType) {
        StringLiteral stringLiteral = new StringLiteral(((Slice) object).toStringUtf8());
        return new Cast(stringLiteral, toSqlType(type), false, true);
    }
    if (type.equals(BOOLEAN)) {
        return new BooleanLiteral(object.toString());
    }
    if (type.equals(DATE)) {
        return new GenericLiteral("DATE", new SqlDate(toIntExact((Long) object)).toString());
    }
    if (type instanceof TimestampType) {
        TimestampType timestampType = (TimestampType) type;
        String representation;
        if (timestampType.isShort()) {
            representation = TimestampToVarcharCast.cast(timestampType.getPrecision(), (Long) object).toStringUtf8();
        } else {
            representation = TimestampToVarcharCast.cast(timestampType.getPrecision(), (LongTimestamp) object).toStringUtf8();
        }
        return new TimestampLiteral(representation);
    }
    if (type instanceof TimestampWithTimeZoneType) {
        TimestampWithTimeZoneType timestampWithTimeZoneType = (TimestampWithTimeZoneType) type;
        String representation;
        if (timestampWithTimeZoneType.isShort()) {
            representation = TimestampWithTimeZoneToVarcharCast.cast(timestampWithTimeZoneType.getPrecision(), (long) object).toStringUtf8();
        } else {
            representation = TimestampWithTimeZoneToVarcharCast.cast(timestampWithTimeZoneType.getPrecision(), (LongTimestampWithTimeZone) object).toStringUtf8();
        }
        if (!object.equals(parseTimestampWithTimeZone(timestampWithTimeZoneType.getPrecision(), representation))) {
        // Certain (point in time, time zone) pairs cannot be represented as a TIMESTAMP literal, as the literal uses local date/time in given time zone.
        // Thus, during DST backwards change by e.g. 1 hour, the local time is "repeated" twice and thus one local date/time logically corresponds to two
        // points in time, leaving one of them non-referencable.
        // TODO (https://github.com/trinodb/trino/issues/5781) consider treating such values as illegal
        } else {
            return new TimestampLiteral(representation);
        }
    }
    // If the stack value is not a simple type, encode the stack value in a block
    if (!type.getJavaType().isPrimitive() && type.getJavaType() != Slice.class && type.getJavaType() != Block.class) {
        object = nativeValueToBlock(type, object);
    }
    if (object instanceof Block) {
        SliceOutput output = new DynamicSliceOutput(toIntExact(((Block) object).getSizeInBytes()));
        BlockSerdeUtil.writeBlock(plannerContext.getBlockEncodingSerde(), output, (Block) object);
        object = output.slice();
    // This if condition will evaluate to true: object instanceof Slice && !type.equals(VARCHAR)
    }
    Type argumentType = typeForMagicLiteral(type);
    Expression argument;
    if (object instanceof Slice) {
        // HACK: we need to serialize VARBINARY in a format that can be embedded in an expression to be
        // able to encode it in the plan that gets sent to workers.
        // We do this by transforming the in-memory varbinary into a call to from_base64(<base64-encoded value>)
        Slice encoded = VarbinaryFunctions.toBase64((Slice) object);
        argument = FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(QualifiedName.of("from_base64")).addArgument(VARCHAR, new StringLiteral(encoded.toStringUtf8())).build();
    } else {
        argument = toExpression(session, object, argumentType);
    }
    ResolvedFunction resolvedFunction = plannerContext.getMetadata().getCoercion(session, QualifiedName.of(LITERAL_FUNCTION_NAME), argumentType, type);
    return FunctionCallBuilder.resolve(session, plannerContext.getMetadata()).setName(resolvedFunction.toQualifiedName()).addArgument(argumentType, argument).build();
}

Example 4 with VarcharType

use of io.trino.spi.type.VarcharType in project trino by trinodb.

the class HiveTypeTranslator method toTypeInfo.

public static TypeInfo toTypeInfo(Type type) {
    requireNonNull(type, "type is null");
    if (BOOLEAN.equals(type)) {
        return HIVE_BOOLEAN.getTypeInfo();
    }
    if (BIGINT.equals(type)) {
        return HIVE_LONG.getTypeInfo();
    }
    if (INTEGER.equals(type)) {
        return HIVE_INT.getTypeInfo();
    }
    if (SMALLINT.equals(type)) {
        return HIVE_SHORT.getTypeInfo();
    }
    if (TINYINT.equals(type)) {
        return HIVE_BYTE.getTypeInfo();
    }
    if (REAL.equals(type)) {
        return HIVE_FLOAT.getTypeInfo();
    }
    if (DOUBLE.equals(type)) {
        return HIVE_DOUBLE.getTypeInfo();
    }
    if (type instanceof VarcharType) {
        VarcharType varcharType = (VarcharType) type;
        if (varcharType.isUnbounded()) {
            return HIVE_STRING.getTypeInfo();
        }
        if (varcharType.getBoundedLength() <= HiveVarchar.MAX_VARCHAR_LENGTH) {
            return getVarcharTypeInfo(varcharType.getBoundedLength());
        }
        throw new TrinoException(NOT_SUPPORTED, format("Unsupported Hive type: %s. Supported VARCHAR types: VARCHAR(<=%d), VARCHAR.", type, HiveVarchar.MAX_VARCHAR_LENGTH));
    }
    if (type instanceof CharType) {
        CharType charType = (CharType) type;
        int charLength = charType.getLength();
        if (charLength <= HiveChar.MAX_CHAR_LENGTH) {
            return getCharTypeInfo(charLength);
        }
        throw new TrinoException(NOT_SUPPORTED, format("Unsupported Hive type: %s. Supported CHAR types: CHAR(<=%d).", type, HiveChar.MAX_CHAR_LENGTH));
    }
    if (VARBINARY.equals(type)) {
        return HIVE_BINARY.getTypeInfo();
    }
    if (DATE.equals(type)) {
        return HIVE_DATE.getTypeInfo();
    }
    if (type instanceof TimestampType) {
        return HIVE_TIMESTAMP.getTypeInfo();
    }
    if (type instanceof DecimalType) {
        DecimalType decimalType = (DecimalType) type;
        return new DecimalTypeInfo(decimalType.getPrecision(), decimalType.getScale());
    }
    if (isArrayType(type)) {
        TypeInfo elementType = toTypeInfo(type.getTypeParameters().get(0));
        return getListTypeInfo(elementType);
    }
    if (isMapType(type)) {
        TypeInfo keyType = toTypeInfo(type.getTypeParameters().get(0));
        TypeInfo valueType = toTypeInfo(type.getTypeParameters().get(1));
        return getMapTypeInfo(keyType, valueType);
    }
    if (isRowType(type)) {
        ImmutableList.Builder<String> fieldNames = ImmutableList.builder();
        for (TypeSignatureParameter parameter : type.getTypeSignature().getParameters()) {
            if (!parameter.isNamedTypeSignature()) {
                throw new IllegalArgumentException(format("Expected all parameters to be named type, but got %s", parameter));
            }
            NamedTypeSignature namedTypeSignature = parameter.getNamedTypeSignature();
            if (namedTypeSignature.getName().isEmpty()) {
                throw new TrinoException(NOT_SUPPORTED, format("Anonymous row type is not supported in Hive. Please give each field a name: %s", type));
            }
            fieldNames.add(namedTypeSignature.getName().get());
        }
        return getStructTypeInfo(fieldNames.build(), type.getTypeParameters().stream().map(HiveTypeTranslator::toTypeInfo).collect(toImmutableList()));
    }
    throw new TrinoException(NOT_SUPPORTED, format("Unsupported Hive type: %s", type));
}

Example 5 with VarcharType

use of io.trino.spi.type.VarcharType in project trino by trinodb.

the class HiveUtil method parsePartitionValue.

public static NullableValue parsePartitionValue(String partitionName, String value, Type type) {
    verifyPartitionTypeSupported(partitionName, type);
    boolean isNull = HIVE_DEFAULT_DYNAMIC_PARTITION.equals(value);
    if (type instanceof DecimalType) {
        DecimalType decimalType = (DecimalType) type;
        if (isNull) {
            return NullableValue.asNull(decimalType);
        }
        if (decimalType.isShort()) {
            if (value.isEmpty()) {
                return NullableValue.of(decimalType, 0L);
            }
            return NullableValue.of(decimalType, shortDecimalPartitionKey(value, decimalType, partitionName));
        } else {
            if (value.isEmpty()) {
                return NullableValue.of(decimalType, Int128.ZERO);
            }
            return NullableValue.of(decimalType, longDecimalPartitionKey(value, decimalType, partitionName));
        }
    }
    if (BOOLEAN.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(BOOLEAN);
        }
        if (value.isEmpty()) {
            return NullableValue.of(BOOLEAN, false);
        }
        return NullableValue.of(BOOLEAN, booleanPartitionKey(value, partitionName));
    }
    if (TINYINT.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(TINYINT);
        }
        if (value.isEmpty()) {
            return NullableValue.of(TINYINT, 0L);
        }
        return NullableValue.of(TINYINT, tinyintPartitionKey(value, partitionName));
    }
    if (SMALLINT.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(SMALLINT);
        }
        if (value.isEmpty()) {
            return NullableValue.of(SMALLINT, 0L);
        }
        return NullableValue.of(SMALLINT, smallintPartitionKey(value, partitionName));
    }
    if (INTEGER.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(INTEGER);
        }
        if (value.isEmpty()) {
            return NullableValue.of(INTEGER, 0L);
        }
        return NullableValue.of(INTEGER, integerPartitionKey(value, partitionName));
    }
    if (BIGINT.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(BIGINT);
        }
        if (value.isEmpty()) {
            return NullableValue.of(BIGINT, 0L);
        }
        return NullableValue.of(BIGINT, bigintPartitionKey(value, partitionName));
    }
    if (DATE.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(DATE);
        }
        return NullableValue.of(DATE, datePartitionKey(value, partitionName));
    }
    if (TIMESTAMP_MILLIS.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(TIMESTAMP_MILLIS);
        }
        return NullableValue.of(TIMESTAMP_MILLIS, timestampPartitionKey(value, partitionName));
    }
    if (REAL.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(REAL);
        }
        if (value.isEmpty()) {
            return NullableValue.of(REAL, (long) floatToRawIntBits(0.0f));
        }
        return NullableValue.of(REAL, floatPartitionKey(value, partitionName));
    }
    if (DOUBLE.equals(type)) {
        if (isNull) {
            return NullableValue.asNull(DOUBLE);
        }
        if (value.isEmpty()) {
            return NullableValue.of(DOUBLE, 0.0);
        }
        return NullableValue.of(DOUBLE, doublePartitionKey(value, partitionName));
    }
    if (type instanceof VarcharType) {
        if (isNull) {
            return NullableValue.asNull(type);
        }
        return NullableValue.of(type, varcharPartitionKey(value, partitionName, type));
    }
    if (type instanceof CharType) {
        if (isNull) {
            return NullableValue.asNull(type);
        }
        return NullableValue.of(type, charPartitionKey(value, partitionName, type));
    }
    if (type instanceof VarbinaryType) {
        if (isNull) {
            return NullableValue.asNull(type);
        }
        return NullableValue.of(type, Slices.utf8Slice(value));
    }
    throw new VerifyException(format("Unhandled type [%s] for partition: %s", type, partitionName));
}