Example #1
0
 private void assertCommonSuperType(Type firstType, Type secondType, Type expected) {
   TypeRegistry typeManager = new TypeRegistry();
   assertEquals(
       typeManager.getCommonSuperType(firstType, secondType), Optional.ofNullable(expected));
   assertEquals(
       typeManager.getCommonSuperType(secondType, firstType), Optional.ofNullable(expected));
 }
Example #2
0
 private void assertCommonSuperType(String firstType, String secondType, String expected) {
   assertEquals(
       typeRegistry.getCommonSuperType(createType(firstType), createType(secondType)),
       Optional.ofNullable(expected).map(this::createType));
   assertEquals(
       typeRegistry.getCommonSuperType(createType(secondType), createType(firstType)),
       Optional.ofNullable(expected).map(this::createType));
 }
Example #3
0
 @Test
 public void testCoerceTypeBase() throws Exception {
   assertEquals(
       typeRegistry.coerceTypeBase(createDecimalType(21, 1), "decimal"),
       Optional.of(createDecimalType(21, 1)));
   assertEquals(
       typeRegistry.coerceTypeBase(BIGINT, "decimal"), Optional.of(createDecimalType(19, 0)));
   assertEquals(
       typeRegistry.coerceTypeBase(INTEGER, "decimal"), Optional.of(createDecimalType(10, 0)));
   assertEquals(
       typeRegistry.coerceTypeBase(TINYINT, "decimal"), Optional.of(createDecimalType(3, 0)));
   assertEquals(
       typeRegistry.coerceTypeBase(SMALLINT, "decimal"), Optional.of(createDecimalType(5, 0)));
 }
Example #4
0
  @Test
  public void testIsTypeOnlyCoercion() {
    assertTrue(typeRegistry.isTypeOnlyCoercion(BIGINT, BIGINT));
    assertTrue(isTypeOnlyCoercion("varchar(42)", "varchar(44)"));
    assertFalse(isTypeOnlyCoercion("varchar(44)", "varchar(42)"));

    assertTrue(isTypeOnlyCoercion("array(varchar(42))", "array(varchar(44))"));
    assertFalse(isTypeOnlyCoercion("array(varchar(44))", "array(varchar(42))"));

    assertTrue(isTypeOnlyCoercion("decimal(22,1)", "decimal(23,1)"));
    assertTrue(isTypeOnlyCoercion("decimal(2,1)", "decimal(3,1)"));
    assertFalse(isTypeOnlyCoercion("decimal(23,1)", "decimal(22,1)"));
    assertFalse(isTypeOnlyCoercion("decimal(3,1)", "decimal(2,1)"));
    assertFalse(isTypeOnlyCoercion("decimal(3,1)", "decimal(22,1)"));

    assertTrue(isTypeOnlyCoercion("array(decimal(22,1))", "array(decimal(23,1))"));
    assertTrue(isTypeOnlyCoercion("array(decimal(2,1))", "array(decimal(3,1))"));
    assertFalse(isTypeOnlyCoercion("array(decimal(23,1))", "array(decimal(22,1))"));
    assertFalse(isTypeOnlyCoercion("array(decimal(3,1))", "array(decimal(2,1))"));

    assertTrue(
        isTypeOnlyCoercion("map(decimal(2,1), decimal(2,1))", "map(decimal(2,1), decimal(3,1))"));
    assertFalse(
        isTypeOnlyCoercion("map(decimal(2,1), decimal(2,1))", "map(decimal(2,1), decimal(23,1))"));
    assertFalse(
        isTypeOnlyCoercion("map(decimal(2,1), decimal(2,1))", "map(decimal(2,1), decimal(3,2))"));
    assertTrue(
        isTypeOnlyCoercion("map(decimal(22,1), decimal(2,1))", "map(decimal(23,1), decimal(3,1))"));
    assertFalse(
        isTypeOnlyCoercion("map(decimal(23,1), decimal(3,1))", "map(decimal(22,1), decimal(2,1))"));
  }
Example #5
0
 @Test
 public void testCanCoerceIsTransitive() throws Exception {
   Set<Type> types = getStandardPrimitiveTypes();
   for (Type transitiveType : types) {
     for (Type resultType : types) {
       if (typeRegistry.canCoerce(transitiveType, resultType)) {
         for (Type sourceType : types) {
           if (typeRegistry.canCoerce(sourceType, transitiveType)) {
             if (!typeRegistry.canCoerce(sourceType, resultType)) {
               fail(
                   format(
                       "'%s' -> '%s' coercion is missing when transitive coercion is possible: '%s' -> '%s' -> '%s'",
                       sourceType, resultType, sourceType, transitiveType, resultType));
             }
           }
         }
       }
     }
   }
 }
Example #6
0
 private Set<Type> getStandardPrimitiveTypes() {
   ImmutableSet.Builder<Type> builder = ImmutableSet.builder();
   // add unparametrized types
   builder.addAll(typeRegistry.getTypes());
   // add corner cases for parametrized types
   builder.add(createDecimalType(1, 0));
   builder.add(createDecimalType(17, 0));
   builder.add(createDecimalType(38, 0));
   builder.add(createDecimalType(17, 17));
   builder.add(createDecimalType(38, 38));
   builder.add(createVarcharType(0));
   builder.add(createUnboundedVarcharType());
   return builder.build();
 }
Example #7
0
  @Test
  public void testCastOperatorsExistForCoercions() {
    FunctionRegistry functionRegistry =
        new FunctionRegistry(
            typeRegistry,
            new BlockEncodingManager(typeRegistry),
            new FeaturesConfig().setExperimentalSyntaxEnabled(true));

    Set<Type> types = getStandardPrimitiveTypes();
    for (Type sourceType : types) {
      for (Type resultType : types) {
        if (typeRegistry.canCoerce(sourceType, resultType)
            && sourceType != UNKNOWN
            && resultType != UNKNOWN) {
          assertTrue(
              functionRegistry.canResolveOperator(
                  OperatorType.CAST, resultType, ImmutableList.of(sourceType)),
              format(
                  "'%s' -> '%s' coercion exists but there is no cast operator",
                  sourceType, resultType));
        }
      }
    }
  }
Example #8
0
  @Test
  public void testCanCoerce() {
    assertTrue(typeRegistry.canCoerce(BIGINT, BIGINT));
    assertTrue(typeRegistry.canCoerce(UNKNOWN, BIGINT));
    assertFalse(typeRegistry.canCoerce(BIGINT, UNKNOWN));

    assertTrue(typeRegistry.canCoerce(BIGINT, DOUBLE));
    assertTrue(typeRegistry.canCoerce(DATE, TIMESTAMP));
    assertTrue(typeRegistry.canCoerce(DATE, TIMESTAMP_WITH_TIME_ZONE));
    assertTrue(typeRegistry.canCoerce(TIME, TIME_WITH_TIME_ZONE));
    assertTrue(typeRegistry.canCoerce(TIMESTAMP, TIMESTAMP_WITH_TIME_ZONE));
    assertTrue(typeRegistry.canCoerce(VARCHAR, JONI_REGEXP));
    assertTrue(typeRegistry.canCoerce(VARCHAR, RE2J_REGEXP));
    assertTrue(typeRegistry.canCoerce(VARCHAR, LIKE_PATTERN));
    assertTrue(typeRegistry.canCoerce(VARCHAR, JSON_PATH));

    assertTrue(typeRegistry.canCoerce(FLOAT, DOUBLE));
    assertTrue(typeRegistry.canCoerce(TINYINT, FLOAT));
    assertTrue(typeRegistry.canCoerce(SMALLINT, FLOAT));
    assertTrue(typeRegistry.canCoerce(INTEGER, FLOAT));
    assertTrue(typeRegistry.canCoerce(BIGINT, FLOAT));

    assertFalse(typeRegistry.canCoerce(DOUBLE, BIGINT));
    assertFalse(typeRegistry.canCoerce(TIMESTAMP, TIME_WITH_TIME_ZONE));
    assertFalse(typeRegistry.canCoerce(TIMESTAMP_WITH_TIME_ZONE, TIMESTAMP));
    assertFalse(typeRegistry.canCoerce(VARBINARY, VARCHAR));
    assertFalse(canCoerce("float", "decimal(37,1)"));
    assertFalse(canCoerce("float", "decimal(37,37)"));
    assertFalse(canCoerce("double", "decimal(37,1)"));
    assertFalse(canCoerce("double", "decimal(37,37)"));

    assertTrue(canCoerce("unknown", "array(bigint)"));
    assertFalse(canCoerce("array(bigint)", "unknown"));
    assertTrue(canCoerce("array(bigint)", "array(double)"));
    assertFalse(canCoerce("array(double)", "array(bigint)"));
    assertTrue(canCoerce("map(bigint,double)", "map(bigint,double)"));
    assertTrue(canCoerce("map(bigint,double)", "map(double,double)"));
    assertTrue(canCoerce("row(a bigint,b double,c varchar)", "row(a bigint,b double,c varchar)"));

    assertTrue(canCoerce("varchar(42)", "varchar(42)"));
    assertTrue(canCoerce("varchar(42)", "varchar(44)"));
    assertFalse(canCoerce("varchar(44)", "varchar(42)"));

    assertTrue(canCoerce("decimal(22,1)", "decimal(23,1)"));
    assertFalse(canCoerce("decimal(23,1)", "decimal(22,1)"));
    assertFalse(canCoerce("bigint", "decimal(18,0)"));
    assertTrue(canCoerce("bigint", "decimal(19,0)"));
    assertTrue(canCoerce("bigint", "decimal(37,1)"));
    assertTrue(canCoerce("array(bigint)", "array(decimal(20,1))"));
    assertFalse(canCoerce("array(bigint)", "array(decimal(2,1))"));

    assertTrue(canCoerce("decimal(3,2)", "double"));
    assertTrue(canCoerce("decimal(22,1)", "double"));
    assertTrue(canCoerce("decimal(3,2)", "float"));
    assertTrue(canCoerce("decimal(22,1)", "float"));

    assertFalse(canCoerce("integer", "decimal(9,0)"));
    assertTrue(canCoerce("integer", "decimal(10,0)"));
    assertTrue(canCoerce("integer", "decimal(37,1)"));

    assertFalse(canCoerce("tinyint", "decimal(2,0)"));
    assertTrue(canCoerce("tinyint", "decimal(3,0)"));
    assertTrue(canCoerce("tinyint", "decimal(37,1)"));

    assertFalse(canCoerce("smallint", "decimal(4,0)"));
    assertTrue(canCoerce("smallint", "decimal(5,0)"));
    assertTrue(canCoerce("smallint", "decimal(37,1)"));
  }
Example #9
0
 private Type createType(String signature) {
   return typeRegistry.getType(TypeSignature.parseTypeSignature(signature));
 }
Example #10
0
 private boolean isTypeOnlyCoercion(String actual, String expected) {
   return typeRegistry.isTypeOnlyCoercion(createType(actual), createType(expected));
 }
Example #11
0
 private boolean canCoerce(String actual, String expected) {
   return typeRegistry.canCoerce(createType(actual), createType(expected));
 }