Examples with UnknownType io.prestosql.spi.type.UnknownType used on opensource projects

Example 1 with UnknownType

use of io.prestosql.spi.type.UnknownType in project hetu-core by openlookeng.

the class ArrayJoin method specializeArrayJoin.

private static BuiltInScalarFunctionImplementation specializeArrayJoin(Map<String, Type> types, FunctionAndTypeManager functionAndTypeManager, List<Boolean> nullableArguments, MethodHandle methodHandle) {
    Type type = types.get("T");
    List<ArgumentProperty> argumentProperties = nullableArguments.stream().map(nullable -> nullable ? valueTypeArgumentProperty(USE_BOXED_TYPE) : valueTypeArgumentProperty(RETURN_NULL_ON_NULL)).collect(toImmutableList());
    if (type instanceof UnknownType) {
        return new BuiltInScalarFunctionImplementation(false, argumentProperties, methodHandle.bindTo(null), Optional.of(STATE_FACTORY));
    } else {
        try {
            BuiltInScalarFunctionImplementation castFunction = functionAndTypeManager.getBuiltInScalarFunctionImplementation(functionAndTypeManager.lookupCast(CastType.CAST, type.getTypeSignature(), VARCHAR_TYPE_SIGNATURE));
            MethodHandle getter;
            Class<?> elementType = type.getJavaType();
            if (elementType == boolean.class) {
                getter = GET_BOOLEAN;
            } else if (elementType == double.class) {
                getter = GET_DOUBLE;
            } else if (elementType == long.class) {
                getter = GET_LONG;
            } else if (elementType == Slice.class) {
                getter = GET_SLICE;
            } else {
                throw new UnsupportedOperationException("Unsupported type: " + elementType.getName());
            }
            MethodHandle cast = castFunction.getMethodHandle();
            // if the cast doesn't take a ConnectorSession, create an adapter that drops the provided session
            if (cast.type().parameterArray()[0] != ConnectorSession.class) {
                cast = MethodHandles.dropArguments(cast, 0, ConnectorSession.class);
            }
            // Adapt a target cast that takes (ConnectorSession, ?) to one that takes (Block, int, ConnectorSession), which will be invoked by the implementation
            // The first two arguments (Block, int) are filtered through the element type's getXXX method to produce the underlying value that needs to be passed to
            // the cast.
            cast = MethodHandles.permuteArguments(cast, MethodType.methodType(Slice.class, cast.type().parameterArray()[1], cast.type().parameterArray()[0]), 1, 0);
            cast = MethodHandles.dropArguments(cast, 1, int.class);
            cast = MethodHandles.dropArguments(cast, 1, Block.class);
            cast = MethodHandles.foldArguments(cast, getter.bindTo(type));
            MethodHandle target = MethodHandles.insertArguments(methodHandle, 0, cast);
            return new BuiltInScalarFunctionImplementation(false, argumentProperties, target, Optional.of(STATE_FACTORY));
        } catch (PrestoException e) {
            throw new PrestoException(INVALID_FUNCTION_ARGUMENT, String.format("Input type %s not supported", type), e);
        }
    }
}

Example 2 with UnknownType

use of io.prestosql.spi.type.UnknownType in project hetu-core by openlookeng.

the class AbstractTestType method createAlternatingNullsBlock.

private Block createAlternatingNullsBlock(Block testBlock) {
    BlockBuilder nullsBlockBuilder = type.createBlockBuilder(null, testBlock.getPositionCount());
    for (int position = 0; position < testBlock.getPositionCount(); position++) {
        if (testBlock.isNull(position)) {
            checkState(type instanceof UnknownType);
            nullsBlockBuilder.appendNull();
        } else if (type.getJavaType() == boolean.class) {
            type.writeBoolean(nullsBlockBuilder, type.getBoolean(testBlock, position));
        } else if (type.getJavaType() == long.class) {
            type.writeLong(nullsBlockBuilder, type.getLong(testBlock, position));
        } else if (type.getJavaType() == double.class) {
            type.writeDouble(nullsBlockBuilder, type.getDouble(testBlock, position));
        } else if (type.getJavaType() == Slice.class) {
            Slice slice = type.getSlice(testBlock, position);
            type.writeSlice(nullsBlockBuilder, slice, 0, slice.length());
        } else {
            type.writeObject(nullsBlockBuilder, type.getObject(testBlock, position));
        }
        nullsBlockBuilder.appendNull();
    }
    return nullsBlockBuilder.build();
}

Example 3 with UnknownType

use of io.prestosql.spi.type.UnknownType in project hetu-core by openlookeng.

the class AbstractTestType method assertPositionValue.

private void assertPositionValue(Block block, int position, Object expectedStackValue, long expectedHash, Object expectedObjectValue) {
    Object objectValue = type.getObjectValue(SESSION, block, position);
    assertEquals(objectValue, expectedObjectValue);
    if (objectValue != null) {
        assertInstanceOf(objectValue, objectValueType);
    }
    if (type.isComparable()) {
        assertEquals(hashPosition(type, block, position), expectedHash);
    } else {
        try {
            type.hash(block, position);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    }
    Block expectedBlock = createBlock(type, expectedStackValue);
    if (type.isComparable()) {
        assertTrue(positionEqualsPosition(type, block, position, block, position));
        assertTrue(positionEqualsPosition(type, block, position, expectedBlock, 0));
        assertTrue(positionEqualsPosition(type, expectedBlock, 0, block, position));
    }
    assertEquals(block.isNull(position), expectedStackValue == null);
    if (type.isOrderable()) {
        assertTrue(ASC_NULLS_FIRST.compareBlockValue(type, block, position, expectedBlock, 0) == 0);
        assertTrue(ASC_NULLS_LAST.compareBlockValue(type, block, position, expectedBlock, 0) == 0);
        assertTrue(DESC_NULLS_FIRST.compareBlockValue(type, block, position, expectedBlock, 0) == 0);
        assertTrue(DESC_NULLS_LAST.compareBlockValue(type, block, position, expectedBlock, 0) == 0);
    } else {
        try {
            type.compareTo(block, position, expectedBlock, 0);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    }
    verifyInvalidPositionHandling(block);
    if (block.isNull(position)) {
        if (type.isOrderable() && !(type instanceof UnknownType)) {
            Block nonNullValue = toBlock(getNonNullValue());
            assertTrue(ASC_NULLS_FIRST.compareBlockValue(type, block, position, nonNullValue, 0) < 0);
            assertTrue(ASC_NULLS_LAST.compareBlockValue(type, block, position, nonNullValue, 0) > 0);
            assertTrue(DESC_NULLS_FIRST.compareBlockValue(type, block, position, nonNullValue, 0) < 0);
            assertTrue(DESC_NULLS_LAST.compareBlockValue(type, block, position, nonNullValue, 0) > 0);
        }
        return;
    }
    if (type.isOrderable() && expectedStackValue != Boolean.TRUE) {
        Block greaterValue = toBlock(getGreaterValue(expectedStackValue));
        assertTrue(ASC_NULLS_FIRST.compareBlockValue(type, block, position, greaterValue, 0) < 0);
        assertTrue(ASC_NULLS_LAST.compareBlockValue(type, block, position, greaterValue, 0) < 0);
        assertTrue(DESC_NULLS_FIRST.compareBlockValue(type, block, position, greaterValue, 0) > 0);
        assertTrue(DESC_NULLS_LAST.compareBlockValue(type, block, position, greaterValue, 0) > 0);
    }
    if (type.getJavaType() == boolean.class) {
        assertEquals(type.getBoolean(block, position), expectedStackValue);
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == long.class) {
        assertEquals(type.getLong(block, position), expectedStackValue);
        try {
            type.getBoolean(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == double.class) {
        assertEquals(type.getDouble(block, position), expectedStackValue);
        try {
            type.getBoolean(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == Slice.class) {
        assertEquals(type.getSlice(block, position), expectedStackValue);
        try {
            type.getBoolean(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    } else {
        SliceOutput actualSliceOutput = new DynamicSliceOutput(100);
        writeBlock(blockEncodingSerde, actualSliceOutput, (Block) type.getObject(block, position));
        SliceOutput expectedSliceOutput = new DynamicSliceOutput(actualSliceOutput.size());
        writeBlock(blockEncodingSerde, expectedSliceOutput, (Block) expectedStackValue);
        assertEquals(actualSliceOutput.slice(), expectedSliceOutput.slice());
        try {
            type.getBoolean(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
        try {
            type.getSlice(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        // the exception could be ignored
        }
    }
}

Example 4 with UnknownType

use of io.prestosql.spi.type.UnknownType in project hetu-core by openlookeng.

the class AbstractTestType method verifyInvalidPositionHandling.

private void verifyInvalidPositionHandling(Block block) {
    try {
        type.getObjectValue(SESSION, block, -1);
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    // the exception could be ignored
    }
    try {
        type.getObjectValue(SESSION, block, block.getPositionCount());
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    // the exception could be ignored
    }
    try {
        type.hash(block, -1);
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    // the exception could be ignored
    }
    try {
        type.hash(block, block.getPositionCount());
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    // the exception could be ignored
    }
    if (type.isComparable() && !(type instanceof UnknownType)) {
        Block other = toBlock(getNonNullValue());
        try {
            type.equalTo(block, -1, other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
        try {
            type.equalTo(block, block.getPositionCount(), other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    }
    if (type.isOrderable() && !(type instanceof UnknownType)) {
        Block other = toBlock(getNonNullValue());
        try {
            ASC_NULLS_FIRST.compareBlockValue(type, block, -1, other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            ASC_NULLS_FIRST.compareBlockValue(type, block, block.getPositionCount(), other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    }
    if (type.getJavaType() == boolean.class) {
        try {
            type.getBoolean(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
        try {
            type.getBoolean(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == long.class) {
        try {
            type.getLong(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
        try {
            type.getLong(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == double.class) {
        try {
            type.getDouble(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
        try {
            type.getDouble(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    } else if (type.getJavaType() == Slice.class) {
        try {
            type.getSlice(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
        try {
            type.getSlice(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        // the exception could be ignored
        }
    }
}

Example 5 with UnknownType

use of io.prestosql.spi.type.UnknownType in project hetu-core by openlookeng.

the class TestTypeUtil method testParseType.

@Test
public void testParseType() {
    Type type = parseType(typeManager, "bigint");
    assertTrue(type instanceof BigintType);
    type = parseType(typeManager, "integer");
    assertTrue(type instanceof IntegerType);
    type = parseType(typeManager, "smallint");
    assertTrue(type instanceof SmallintType);
    type = parseType(typeManager, "boolean");
    assertTrue(type instanceof BooleanType);
    type = parseType(typeManager, "date");
    assertTrue(type instanceof DateType);
    type = parseType(typeManager, "real");
    assertTrue(type instanceof RealType);
    type = parseType(typeManager, "double");
    assertTrue(type instanceof DoubleType);
    type = parseType(typeManager, "HyperLogLog");
    assertTrue(type instanceof HyperLogLogType);
    type = parseType(typeManager, "P4HyperLogLog");
    assertTrue(type instanceof P4HyperLogLogType);
    type = parseType(typeManager, "timestamp");
    assertTrue(type instanceof TimestampType);
    type = parseType(typeManager, "timestamp with time zone");
    assertTrue(type instanceof TimestampWithTimeZoneType);
    type = parseType(typeManager, "time");
    assertTrue(type instanceof TimeType);
    type = parseType(typeManager, "time with time zone");
    assertTrue(type instanceof TimeWithTimeZoneType);
    type = parseType(typeManager, "varbinary");
    assertTrue(type instanceof VarbinaryType);
    type = parseType(typeManager, "unknown");
    assertTrue(type instanceof UnknownType);
}