From 636f8a16dfd54098ba547e68abd7a497320ab916 Mon Sep 17 00:00:00 2001 From: Piotr Findeisen Date: Wed, 19 Oct 2022 13:20:00 +0200 Subject: [PATCH 1/4] Add type test for bounded varchar --- .../java/io/trino/type/AbstractTestType.java | 2 +- .../io/trino/type/TestBoundedVarcharType.java | 75 +++++++++++++++++++ ...ype.java => TestUnboundedVarcharType.java} | 27 ++----- 3 files changed, 82 insertions(+), 22 deletions(-) create mode 100644 core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java rename core/trino-main/src/test/java/io/trino/type/{TestVarcharType.java => TestUnboundedVarcharType.java} (67%) diff --git a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java index 7e4cdab12ea3..a322a67bc827 100644 --- a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java +++ b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java @@ -77,7 +77,7 @@ public abstract class AbstractTestType private final Class objectValueType; private final Block testBlock; - private final Type type; + protected final Type type; private final TypeOperators typeOperators; protected final BlockTypeOperators blockTypeOperators; private final BlockPositionEqual equalOperator; diff --git a/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java b/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java new file mode 100644 index 000000000000..923c07166380 --- /dev/null +++ b/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java @@ -0,0 +1,75 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.trino.type; + +import io.airlift.slice.Slice; +import io.airlift.slice.Slices; +import io.trino.spi.block.Block; +import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.Type; +import io.trino.spi.type.VarcharType; +import org.testng.annotations.Test; + +import static io.trino.spi.type.VarcharType.createVarcharType; +import static org.testng.Assert.assertEquals; + +public class TestBoundedVarcharType + extends AbstractTestType +{ + public TestBoundedVarcharType() + { + super(createVarcharType(6), String.class, createTestBlock(createVarcharType(6))); + } + + private static Block createTestBlock(VarcharType type) + { + BlockBuilder blockBuilder = type.createBlockBuilder(null, 15); + type.writeString(blockBuilder, "apple"); + type.writeString(blockBuilder, "apple"); + type.writeString(blockBuilder, "apple"); + type.writeString(blockBuilder, "banana"); + type.writeString(blockBuilder, "banana"); + type.writeString(blockBuilder, "banana"); + type.writeString(blockBuilder, "banana"); + type.writeString(blockBuilder, "banana"); + type.writeString(blockBuilder, "cherry"); + type.writeString(blockBuilder, "cherry"); + type.writeString(blockBuilder, "date"); + return blockBuilder.build(); + } + + @Override + protected Object getGreaterValue(Object value) + { + return Slices.utf8Slice(((Slice) value).toStringUtf8() + "_"); + } + + @Test + public void testRange() + { + Type.Range range = type.getRange().get(); + + String expectedMax = new StringBuilder() + .appendCodePoint(Character.MAX_CODE_POINT) + .appendCodePoint(Character.MAX_CODE_POINT) + .appendCodePoint(Character.MAX_CODE_POINT) + .appendCodePoint(Character.MAX_CODE_POINT) + .appendCodePoint(Character.MAX_CODE_POINT) + .appendCodePoint(Character.MAX_CODE_POINT) + .toString(); + + assertEquals(Slices.utf8Slice(""), range.getMin()); + assertEquals(Slices.utf8Slice(expectedMax), range.getMax()); + } +} diff --git a/core/trino-main/src/test/java/io/trino/type/TestVarcharType.java b/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java similarity index 67% rename from core/trino-main/src/test/java/io/trino/type/TestVarcharType.java rename to core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java index 5c0624044f2a..45a68002e951 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestVarcharType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java @@ -17,23 +17,20 @@ import io.airlift.slice.Slices; import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; -import io.trino.spi.type.Type; -import io.trino.spi.type.VarcharType; import org.testng.annotations.Test; import static io.trino.spi.type.VarcharType.VARCHAR; -import static io.trino.spi.type.VarcharType.createVarcharType; -import static org.testng.Assert.assertEquals; +import static org.assertj.core.api.Assertions.assertThat; -public class TestVarcharType +public class TestUnboundedVarcharType extends AbstractTestType { - public TestVarcharType() + public TestUnboundedVarcharType() { super(VARCHAR, String.class, createTestBlock()); } - public static Block createTestBlock() + private static Block createTestBlock() { BlockBuilder blockBuilder = VARCHAR.createBlockBuilder(null, 15); VARCHAR.writeString(blockBuilder, "apple"); @@ -59,19 +56,7 @@ protected Object getGreaterValue(Object value) @Test public void testRange() { - VarcharType type = createVarcharType(5); - - Type.Range range = type.getRange().get(); - - String expectedMax = new StringBuilder() - .appendCodePoint(Character.MAX_CODE_POINT) - .appendCodePoint(Character.MAX_CODE_POINT) - .appendCodePoint(Character.MAX_CODE_POINT) - .appendCodePoint(Character.MAX_CODE_POINT) - .appendCodePoint(Character.MAX_CODE_POINT) - .toString(); - - assertEquals(Slices.utf8Slice(""), range.getMin()); - assertEquals(Slices.utf8Slice(expectedMax), range.getMax()); + assertThat(type.getRange()) + .isEmpty(); } } From 1b7e6fac039307169ad12ed2d590bd79d54c926e Mon Sep 17 00:00:00 2001 From: Piotr Findeisen Date: Tue, 18 Oct 2022 16:30:26 +0200 Subject: [PATCH 2/4] Test Type.getRange for every type --- .../src/test/java/io/trino/type/AbstractTestType.java | 8 ++++++++ .../src/test/java/io/trino/type/TestBigintType.java | 10 ++++++++++ .../java/io/trino/type/TestBoundedVarcharType.java | 9 ++++----- .../src/test/java/io/trino/type/TestIntegerType.java | 10 ++++++++++ .../src/test/java/io/trino/type/TestSmallintType.java | 10 ++++++++++ .../src/test/java/io/trino/type/TestTinyintType.java | 10 ++++++++++ .../java/io/trino/type/TestUnboundedVarcharType.java | 9 --------- 7 files changed, 52 insertions(+), 14 deletions(-) diff --git a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java index a322a67bc827..3be8741cdef3 100644 --- a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java +++ b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java @@ -65,6 +65,7 @@ import static java.lang.String.format; import static java.util.Collections.unmodifiableSortedMap; import static java.util.Objects.requireNonNull; +import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertFalse; @@ -186,6 +187,13 @@ public void testBlock() } } + @Test + public void testRange() + { + assertThat(type.getRange()) + .isEmpty(); + } + protected void assertPositionEquals(Block block, int position, Object expectedStackValue, Object expectedObjectValue) { long hash = 0; diff --git a/core/trino-main/src/test/java/io/trino/type/TestBigintType.java b/core/trino-main/src/test/java/io/trino/type/TestBigintType.java index 451c897c06be..74ce723eb49a 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestBigintType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestBigintType.java @@ -15,8 +15,10 @@ import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.Type.Range; import static io.trino.spi.type.BigintType.BIGINT; +import static org.testng.Assert.assertEquals; public class TestBigintType extends AbstractTestType @@ -48,4 +50,12 @@ protected Object getGreaterValue(Object value) { return ((Long) value) + 1; } + + @Override + public void testRange() + { + Range range = type.getRange().orElseThrow(); + assertEquals(range.getMin(), Long.MIN_VALUE); + assertEquals(range.getMax(), Long.MAX_VALUE); + } } diff --git a/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java b/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java index 923c07166380..c5b512cdfb7b 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestBoundedVarcharType.java @@ -19,7 +19,6 @@ import io.trino.spi.block.BlockBuilder; import io.trino.spi.type.Type; import io.trino.spi.type.VarcharType; -import org.testng.annotations.Test; import static io.trino.spi.type.VarcharType.createVarcharType; import static org.testng.Assert.assertEquals; @@ -55,10 +54,10 @@ protected Object getGreaterValue(Object value) return Slices.utf8Slice(((Slice) value).toStringUtf8() + "_"); } - @Test + @Override public void testRange() { - Type.Range range = type.getRange().get(); + Type.Range range = type.getRange().orElseThrow(); String expectedMax = new StringBuilder() .appendCodePoint(Character.MAX_CODE_POINT) @@ -69,7 +68,7 @@ public void testRange() .appendCodePoint(Character.MAX_CODE_POINT) .toString(); - assertEquals(Slices.utf8Slice(""), range.getMin()); - assertEquals(Slices.utf8Slice(expectedMax), range.getMax()); + assertEquals(range.getMin(), Slices.utf8Slice("")); + assertEquals(range.getMax(), Slices.utf8Slice(expectedMax)); } } diff --git a/core/trino-main/src/test/java/io/trino/type/TestIntegerType.java b/core/trino-main/src/test/java/io/trino/type/TestIntegerType.java index 94e3ddae963a..e6cb9e21e0df 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestIntegerType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestIntegerType.java @@ -15,8 +15,10 @@ import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.Type.Range; import static io.trino.spi.type.IntegerType.INTEGER; +import static org.testng.Assert.assertEquals; public class TestIntegerType extends AbstractTestType @@ -48,4 +50,12 @@ protected Object getGreaterValue(Object value) { return ((Long) value) + 1; } + + @Override + public void testRange() + { + Range range = type.getRange().orElseThrow(); + assertEquals(range.getMin(), (long) Integer.MIN_VALUE); + assertEquals(range.getMax(), (long) Integer.MAX_VALUE); + } } diff --git a/core/trino-main/src/test/java/io/trino/type/TestSmallintType.java b/core/trino-main/src/test/java/io/trino/type/TestSmallintType.java index 20032f39a038..2a12ffb07dbe 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestSmallintType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestSmallintType.java @@ -15,8 +15,10 @@ import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.Type.Range; import static io.trino.spi.type.SmallintType.SMALLINT; +import static org.testng.Assert.assertEquals; public class TestSmallintType extends AbstractTestType @@ -48,4 +50,12 @@ protected Object getGreaterValue(Object value) { return ((Long) value) + 1; } + + @Override + public void testRange() + { + Range range = type.getRange().orElseThrow(); + assertEquals(range.getMin(), (long) Short.MIN_VALUE); + assertEquals(range.getMax(), (long) Short.MAX_VALUE); + } } diff --git a/core/trino-main/src/test/java/io/trino/type/TestTinyintType.java b/core/trino-main/src/test/java/io/trino/type/TestTinyintType.java index a50541cc25ec..33d5e5e749fb 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestTinyintType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestTinyintType.java @@ -15,8 +15,10 @@ import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.Type.Range; import static io.trino.spi.type.TinyintType.TINYINT; +import static org.testng.Assert.assertEquals; public class TestTinyintType extends AbstractTestType @@ -48,4 +50,12 @@ protected Object getGreaterValue(Object value) { return ((Long) value) + 1; } + + @Override + public void testRange() + { + Range range = type.getRange().orElseThrow(); + assertEquals(range.getMin(), (long) Byte.MIN_VALUE); + assertEquals(range.getMax(), (long) Byte.MAX_VALUE); + } } diff --git a/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java b/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java index 45a68002e951..df798a054c4b 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestUnboundedVarcharType.java @@ -17,10 +17,8 @@ import io.airlift.slice.Slices; import io.trino.spi.block.Block; import io.trino.spi.block.BlockBuilder; -import org.testng.annotations.Test; import static io.trino.spi.type.VarcharType.VARCHAR; -import static org.assertj.core.api.Assertions.assertThat; public class TestUnboundedVarcharType extends AbstractTestType @@ -52,11 +50,4 @@ protected Object getGreaterValue(Object value) { return Slices.utf8Slice(((Slice) value).toStringUtf8() + "_"); } - - @Test - public void testRange() - { - assertThat(type.getRange()) - .isEmpty(); - } } From d09db5dbf5cedf9c10f8f33df5620ba1f9a775c3 Mon Sep 17 00:00:00 2001 From: Piotr Findeisen Date: Wed, 19 Oct 2022 13:46:08 +0200 Subject: [PATCH 3/4] Produce valid value in short timestamp test --- .../src/test/java/io/trino/type/TestTimestampType.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java b/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java index a0cbbdab7e55..594d5a8f6327 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java @@ -47,6 +47,6 @@ public static Block createTestBlock() @Override protected Object getGreaterValue(Object value) { - return ((Long) value) + 1; + return ((Long) value) + 1_000; } } From 87351b03c2c90a00520284a90f6dee2ba674cdf0 Mon Sep 17 00:00:00 2001 From: Piotr Findeisen Date: Wed, 19 Oct 2022 13:42:42 +0200 Subject: [PATCH 4/4] Add test for long timestamp type --- .../java/io/trino/type/AbstractTestType.java | 4 ++ .../io/trino/type/TestLongTimestampType.java | 54 +++++++++++++++++++ ...pType.java => TestShortTimestampType.java} | 4 +- 3 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 core/trino-main/src/test/java/io/trino/type/TestLongTimestampType.java rename core/trino-main/src/test/java/io/trino/type/{TestTimestampType.java => TestShortTimestampType.java} (96%) diff --git a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java index 3be8741cdef3..8a5cf01ae29a 100644 --- a/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java +++ b/core/trino-main/src/test/java/io/trino/type/AbstractTestType.java @@ -23,6 +23,7 @@ import io.trino.spi.block.BlockEncodingSerde; import io.trino.spi.block.TestingBlockEncodingSerde; import io.trino.spi.type.ArrayType; +import io.trino.spi.type.LongTimestamp; import io.trino.spi.type.MapType; import io.trino.spi.type.RowType; import io.trino.spi.type.Type; @@ -481,6 +482,9 @@ private static Object getNonNullValueForType(Type type) if (type.getJavaType() == Slice.class) { return Slices.utf8Slice("_"); } + if (type.getJavaType() == LongTimestamp.class) { + return new LongTimestamp(1, 0); + } if (type instanceof ArrayType) { ArrayType arrayType = (ArrayType) type; Type elementType = arrayType.getElementType(); diff --git a/core/trino-main/src/test/java/io/trino/type/TestLongTimestampType.java b/core/trino-main/src/test/java/io/trino/type/TestLongTimestampType.java new file mode 100644 index 000000000000..08723115d959 --- /dev/null +++ b/core/trino-main/src/test/java/io/trino/type/TestLongTimestampType.java @@ -0,0 +1,54 @@ +/* + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.trino.type; + +import io.trino.spi.block.Block; +import io.trino.spi.block.BlockBuilder; +import io.trino.spi.type.LongTimestamp; +import io.trino.spi.type.SqlTimestamp; + +import static io.trino.spi.type.TimestampType.TIMESTAMP_NANOS; + +public class TestLongTimestampType + extends AbstractTestType +{ + public TestLongTimestampType() + { + super(TIMESTAMP_NANOS, SqlTimestamp.class, createTestBlock()); + } + + public static Block createTestBlock() + { + BlockBuilder blockBuilder = TIMESTAMP_NANOS.createBlockBuilder(null, 15); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(1111_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(1111_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(1111_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(2222_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(2222_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(2222_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(2222_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(2222_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(3333_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(3333_123, 123_000)); + TIMESTAMP_NANOS.writeObject(blockBuilder, new LongTimestamp(4444_123, 123_000)); + return blockBuilder.build(); + } + + @Override + protected Object getGreaterValue(Object value) + { + LongTimestamp timestamp = (LongTimestamp) value; + return new LongTimestamp(timestamp.getEpochMicros() + 1, 0); + } +} diff --git a/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java b/core/trino-main/src/test/java/io/trino/type/TestShortTimestampType.java similarity index 96% rename from core/trino-main/src/test/java/io/trino/type/TestTimestampType.java rename to core/trino-main/src/test/java/io/trino/type/TestShortTimestampType.java index 594d5a8f6327..02ef97cfd3d6 100644 --- a/core/trino-main/src/test/java/io/trino/type/TestTimestampType.java +++ b/core/trino-main/src/test/java/io/trino/type/TestShortTimestampType.java @@ -19,10 +19,10 @@ import static io.trino.spi.type.TimestampType.TIMESTAMP_MILLIS; -public class TestTimestampType +public class TestShortTimestampType extends AbstractTestType { - public TestTimestampType() + public TestShortTimestampType() { super(TIMESTAMP_MILLIS, SqlTimestamp.class, createTestBlock()); }