Examples with UnknownType com.facebook.presto.common.type.UnknownType used on opensource projects

Example 1 with UnknownType

use of com.facebook.presto.common.type.UnknownType in project presto by prestodb.

the class AbstractTestType method assertPositionValue.

private void assertPositionValue(Block block, int position, Object expectedStackValue, long expectedHash, Object expectedObjectValue) {
    Object objectValue = type.getObjectValue(SESSION.getSqlFunctionProperties(), 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) {
        }
    }
    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) {
        }
    }
    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) {
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
    } 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) {
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
    } 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) {
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
    } 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) {
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getObject(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
    } 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) {
        }
        try {
            type.getLong(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getDouble(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
        try {
            type.getSlice(block, position);
            fail("Expected IllegalStateException or UnsupportedOperationException");
        } catch (IllegalStateException | UnsupportedOperationException expected) {
        }
    }
}

Example 2 with UnknownType

use of com.facebook.presto.common.type.UnknownType in project presto by prestodb.

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 com.facebook.presto.common.type.UnknownType in project presto by prestodb.

the class AbstractTestType method verifyInvalidPositionHandling.

private void verifyInvalidPositionHandling(Block block) {
    try {
        type.getObjectValue(SESSION.getSqlFunctionProperties(), block, -1);
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    }
    try {
        type.getObjectValue(SESSION.getSqlFunctionProperties(), block, block.getPositionCount());
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    }
    try {
        type.hash(block, -1);
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    }
    try {
        type.hash(block, block.getPositionCount());
        fail("expected RuntimeException");
    } catch (RuntimeException expected) {
    }
    if (type.isComparable() && !(type instanceof UnknownType)) {
        Block other = toBlock(getNonNullValue());
        try {
            type.equalTo(block, -1, other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            type.equalTo(block, block.getPositionCount(), other, 0);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
    }
    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) {
        }
    }
    if (type.getJavaType() == boolean.class) {
        try {
            type.getBoolean(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            type.getBoolean(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
    } else if (type.getJavaType() == long.class) {
        try {
            type.getLong(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            type.getLong(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
    } else if (type.getJavaType() == double.class) {
        try {
            type.getDouble(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            type.getDouble(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
    } else if (type.getJavaType() == Slice.class) {
        try {
            type.getSlice(block, -1);
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
        try {
            type.getSlice(block, block.getPositionCount());
            fail("expected RuntimeException");
        } catch (RuntimeException expected) {
        }
    }
}

Example 4 with UnknownType

use of com.facebook.presto.common.type.UnknownType in project presto by prestodb.

the class ArrayJoin method specializeArrayJoin.

private static BuiltInScalarFunctionImplementation specializeArrayJoin(Map<String, Type> types, FunctionAndTypeManager functionAndTypeManager, List<Boolean> nullableArguments, MethodHandle methodHandleStack, MethodHandle methodHandleProvidedBlock) {
    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, methodHandleStack.bindTo(null), Optional.empty());
    } else {
        try {
            MethodHandle cast = functionAndTypeManager.getJavaScalarFunctionImplementation(functionAndTypeManager.lookupCast(CAST, type.getTypeSignature(), VARCHAR_TYPE_SIGNATURE)).getMethodHandle();
            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());
            }
            // if the cast doesn't take a SqlFunctionProperties, create an adapter that drops the provided session
            if (cast.type().parameterArray()[0] != SqlFunctionProperties.class) {
                cast = MethodHandles.dropArguments(cast, 0, SqlFunctionProperties.class);
            }
            // Adapt a target cast that takes (SqlFunctionProperties, ?) to one that takes (Block, int, SqlFunctionProperties), 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 targetStack = MethodHandles.insertArguments(methodHandleStack, 0, cast);
            MethodHandle targetProvidedBlock = MethodHandles.insertArguments(methodHandleProvidedBlock, 0, cast);
            return new BuiltInScalarFunctionImplementation(ImmutableList.of(new ScalarFunctionImplementationChoice(false, argumentProperties, STACK, targetStack, Optional.empty()), new ScalarFunctionImplementationChoice(false, argumentProperties, PROVIDED_BLOCKBUILDER, targetProvidedBlock, Optional.empty())));
        } catch (PrestoException e) {
            throw new PrestoException(INVALID_FUNCTION_ARGUMENT, format("Input type %s not supported", type), e);
        }
    }
}