@SuppressWarnings("unchecked") private static <T> void updateMax(Map<Integer, Literal<?>> upperBounds, int id, Literal<T> max) { Literal<T> currentMax = (Literal<T>) upperBounds.get(id); if (currentMax == null || max.comparator().compare(max.value(), currentMax.value()) > 0) { upperBounds.put(id, max); } }
@Override public <T> Boolean gtEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) >= 0; }
@Override public <T> Boolean lt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) < 0; }
@Override public <T> Boolean gt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) > 0; }
@Override public <T> Boolean ltEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) <= 0; }
@Override public <T> Boolean eq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) == 0; }
@Override public <T> Expression eq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) == 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression ltEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) <= 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression gtEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) >= 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression gt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) > 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression notEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) != 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Boolean gt(BoundReference<T> ref, Literal<T> lit) { ByteBuffer upperBound = stats.get(ref.pos()).upperBound(); if (upperBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T upper = Conversions.fromByteBuffer(ref.type(), upperBound); int cmp = lit.comparator().compare(upper, lit.value()); if (cmp <= 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean gtEq(BoundReference<T> ref, Literal<T> lit) { ByteBuffer upperBound = stats.get(ref.pos()).upperBound(); if (upperBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T upper = Conversions.fromByteBuffer(ref.type(), upperBound); int cmp = lit.comparator().compare(upper, lit.value()); if (cmp < 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Test public void testBinaryUnsignedComparator() { // b1 < b2 because comparison is unsigned, and -1 has msb set ByteBuffer b1 = ByteBuffer.wrap(new byte[] { 1, 1, 2 }); ByteBuffer b2 = ByteBuffer.wrap(new byte[] { 1, -1, 2 }); Comparator<ByteBuffer> cmp = Literal.of(b1).comparator(); Assert.assertTrue("Negative bytes should sort after positive bytes", cmp.compare(b1, b2) < 0); }
@Test public void testNullHandling() { ByteBuffer buf = ByteBuffer.allocate(0); Comparator<ByteBuffer> cmp = Literal.of(buf).comparator(); Assert.assertTrue("null comes before non-null", cmp.compare(null, buf) < 0); Assert.assertTrue("null comes before non-null", cmp.compare(buf, null) > 0); Assert.assertEquals("null equals null", 0, cmp.compare(null, null)); } }
@Test public void testStringAndUtf8() { String s1 = "abc"; Utf8 s2 = new Utf8("abc"); Comparator<CharSequence> stringComp = Literal.of(s1).comparator(); Assert.assertEquals("Should consider String and Utf8 equal", 0, stringComp.compare(s1, s2)); Comparator<CharSequence> utf8Comp = Literal.of(s2).comparator(); Assert.assertEquals("Should consider String and Utf8 equal", 0, utf8Comp.compare(s1, s2)); }
@Test public void testNullHandling() { String s1 = "abc"; Comparator<CharSequence> cmp = Literal.of(s1).comparator(); Assert.assertTrue("null comes before non-null", cmp.compare(null, s1) < 0); Assert.assertTrue("null comes before non-null", cmp.compare(s1, null) > 0); Assert.assertEquals("null equals null", 0, cmp.compare(null, null)); } }
@Test public void testNullHandling() { Comparator<Long> cmp = Literal.of(34L).comparator(); Assert.assertTrue("null comes before non-null", cmp.compare(null, 34L) < 0); Assert.assertTrue("null comes before non-null", cmp.compare(34L, null) > 0); Assert.assertEquals("null equals null", 0, cmp.compare(null, null)); } }
@Test public void testFixedUnsignedComparator() { // b1 < b2 because comparison is unsigned, and -1 has msb set ByteBuffer b1 = ByteBuffer.wrap(new byte[] { 1, 1, 2 }); ByteBuffer b2 = ByteBuffer.wrap(new byte[] { 1, -1, 2 }); Literal<ByteBuffer> fixedLit = Literal.of(b1).to(Types.FixedType.ofLength(3)); Comparator<ByteBuffer> cmp = fixedLit.comparator(); Assert.assertTrue("Negative bytes should sort after positive bytes", cmp.compare(b1, b2) < 0); }
private <T> void checkValue(Literal<T> lit) throws Exception { Literal<T> copy = TestHelpers.roundTripSerialize(lit); Assert.assertEquals("Literal's comparator should consider values equal", 0, lit.comparator().compare(lit.value(), copy.value())); Assert.assertEquals("Copy's comparator should consider values equal", 0, copy.comparator().compare(lit.value(), copy.value())); } }