Object javaValue = TypeHelper.getJavaValue(type, value); if (javaValue instanceof Long) { return KuduPredicate.newComparisonPredicate(columnSchema, op, (Long) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Integer) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Short) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Byte) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (String) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Double) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Float) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (Boolean) javaValue); return KuduPredicate.newComparisonPredicate(columnSchema, op, (byte[]) javaValue);
private KuduPredicate createInListPredicate(ColumnSchema columnSchema, DiscreteValues discreteValues) { com.facebook.presto.spi.type.Type type = TypeHelper.fromKuduColumn(columnSchema); List<Object> javaValues = discreteValues.getValues().stream().map(value -> TypeHelper.getJavaValue(type, value)).collect(toImmutableList()); return KuduPredicate.newInListPredicate(columnSchema, javaValues); }
builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema)); builder.addPredicate(KuduPredicate.newIsNotNullPredicate(columnSchema));
for (long v : testValues) { KuduPredicate equal = KuduPredicate.newComparisonPredicate(col, ComparisonOp.EQUAL, v); Assert.assertEquals(values.contains(v) ? 1 : 0, countRows(table, equal)); KuduPredicate.newComparisonPredicate(col, ComparisonOp.GREATER_EQUAL, v); Assert.assertEquals(values.tailSet(v).size(), countRows(table, greaterEqual)); KuduPredicate.newComparisonPredicate(col, ComparisonOp.LESS_EQUAL, v); Assert.assertEquals(values.headSet(v, true).size(), countRows(table, lessEqual)); KuduPredicate.newComparisonPredicate(col, ComparisonOp.GREATER, v); Assert.assertEquals(values.tailSet(v, false).size(), countRows(table, greater)); KuduPredicate.newComparisonPredicate(col, ComparisonOp.LESS, v); Assert.assertEquals(values.headSet(v).size(), countRows(table, less)); KuduPredicate isNotNull = KuduPredicate.newIsNotNullPredicate(col); Assert.assertEquals(values.size(), countRows(table, isNotNull)); KuduPredicate isNull = KuduPredicate.newIsNullPredicate(col); Assert.assertEquals(1, countRows(table, isNull));
@Test public void testToString() { Assert.assertEquals("`bool` = true", KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true).toString()); Assert.assertEquals("`byte` = 11", KuduPredicate.newComparisonPredicate(byteCol, EQUAL, 11).toString()); Assert.assertEquals("`short` = 11", KuduPredicate.newComparisonPredicate(shortCol, EQUAL, 11).toString()); Assert.assertEquals("`int` = -123", KuduPredicate.newComparisonPredicate(intCol, EQUAL, -123).toString()); Assert.assertEquals("`long` = 5454", KuduPredicate.newComparisonPredicate(longCol, EQUAL, 5454).toString()); Assert.assertEquals("`float` = 123.456", KuduPredicate.newComparisonPredicate(floatCol, EQUAL, 123.456f).toString()); Assert.assertEquals("`double` = 123.456", KuduPredicate.newComparisonPredicate(doubleCol, EQUAL, 123.456).toString()); Assert.assertEquals("`decimal32` = 123.45", KuduPredicate.newComparisonPredicate(decimal32Col, EQUAL, BigDecimal.valueOf(12345, 2)).toString()); Assert.assertEquals("`decimal64` = 123456789.10", KuduPredicate.newComparisonPredicate(decimal64Col, EQUAL, BigDecimal.valueOf(12345678910L, 2)).toString()); Assert.assertEquals("`decimal128` = 1234567891011121314.15", KuduPredicate.newComparisonPredicate(decimal128Col, EQUAL, new BigDecimal("1234567891011121314.15")).toString()); Assert.assertEquals("`string` = \"my string\"", KuduPredicate.newComparisonPredicate(stringCol, EQUAL, "my string").toString()); Assert.assertEquals("`binary` = 0xAB01CD", KuduPredicate.newComparisonPredicate( binaryCol, EQUAL, new byte[] { (byte) 0xAB, (byte) 0x01, (byte) 0xCD }).toString()); Assert.assertEquals("`int` IN (-10, 0, 10)",
public KuduPredicate toPredicate(ColumnSchema column) { KuduPredicate predicate; switch (this.type) { case IS_IN: predicate = KuduPredicate.newInListPredicate(column, (List) this.value); break; case IS_NULL: predicate = KuduPredicate.newIsNullPredicate(column); break; case IS_NOT_NULL: predicate = KuduPredicate.newIsNotNullPredicate(column); break; default: predicate = predicateComparator(column); break; } return predicate; }
KuduPredicate.newInListPredicate(a, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newInListPredicate(a, ImmutableList.of((byte) 0, (byte) 1, (byte) 8))); KuduPredicate.newInListPredicate(b, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newInListPredicate(b, ImmutableList.of((byte) 0, (byte) 1)), KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, 0), KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newComparisonPredicate(b, ComparisonOp.EQUAL, 1), KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1))); KuduPredicate.newInListPredicate(a, ImmutableList.of((byte) 0, (byte) 1)), KuduPredicate.newInListPredicate(b, ImmutableList.of((byte) 0, (byte) 1)), KuduPredicate.newInListPredicate(c, ImmutableList.of((byte) 0, (byte) 1)));
ComparisonOp op, byte[] value) { checkColumn(column, Type.BINARY); case GREATER_EQUAL: if (value.length == 0) { return newIsNotNullPredicate(column); return new KuduPredicate(PredicateType.RANGE, column, value, null); case EQUAL: return new KuduPredicate(PredicateType.EQUALITY, column, value, null); case LESS: if (value.length == 0) { return none(column); return new KuduPredicate(PredicateType.RANGE, column, null, value); default: throw new RuntimeException("unknown comparison op");
testMerge(KuduPredicate.newComparisonPredicate(boolCol, GREATER_EQUAL, false), KuduPredicate.newComparisonPredicate(boolCol, LESS, true), new KuduPredicate(KuduPredicate.PredicateType.EQUALITY, boolCol, Bytes.fromBoolean(false), null)); testMerge(KuduPredicate.newComparisonPredicate(boolCol, GREATER_EQUAL, false), KuduPredicate.newComparisonPredicate(boolCol, LESS_EQUAL, true), KuduPredicate.newIsNotNullPredicate(boolCol)); testMerge(KuduPredicate.newComparisonPredicate(byteCol, GREATER_EQUAL, 0), KuduPredicate.newComparisonPredicate(byteCol, LESS, 10), new KuduPredicate(RANGE, byteCol, new byte[] { (byte) 0 }, new byte[] { (byte) 10 })); testMerge(KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 12, (byte) 14, (byte) 16, (byte) 18)), KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 14, (byte) 18, (byte) 20)), KuduPredicate.newInListPredicate(byteCol, ImmutableList.of((byte) 14, (byte) 18))); testMerge(KuduPredicate.newComparisonPredicate(shortCol, GREATER_EQUAL, 0), KuduPredicate.newComparisonPredicate(shortCol, LESS, 10), new KuduPredicate(RANGE, shortCol, Bytes.fromShort((short) 0), Bytes.fromShort((short) 10)));
testMerge(KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0)); testMerge(KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 1), KuduPredicate.none(intCol)); testMerge(KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10)); testMerge(KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 10), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 0), KuduPredicate.none(intCol)); testMerge(KuduPredicate.newComparisonPredicate(intCol, LESS, 10), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 5), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 5)); testMerge(KuduPredicate.newComparisonPredicate(intCol, LESS, 0), KuduPredicate.newComparisonPredicate(intCol, EQUAL, 10), KuduPredicate.none(intCol)); testMerge(KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 0), KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 0)); testMerge(KuduPredicate.newComparisonPredicate(intCol, GREATER_EQUAL, 0),
@Test public void testLessEqual() { Assert.assertEquals(KuduPredicate.newComparisonPredicate(byteCol, LESS_EQUAL, 10), KuduPredicate.newComparisonPredicate(byteCol, LESS, 11)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(shortCol, LESS_EQUAL, 10), KuduPredicate.newComparisonPredicate(shortCol, LESS, 11)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(intCol, LESS_EQUAL, 10), KuduPredicate.newComparisonPredicate(intCol, LESS, 11)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(longCol, LESS_EQUAL, 10), KuduPredicate.newComparisonPredicate(longCol, LESS, 11)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(floatCol, LESS_EQUAL, 12.345f), KuduPredicate.newComparisonPredicate(floatCol, LESS, Math.nextAfter(12.345f, Float.POSITIVE_INFINITY))); Assert.assertEquals(KuduPredicate.newComparisonPredicate(doubleCol, LESS_EQUAL, 12.345), KuduPredicate.newComparisonPredicate(doubleCol, LESS, Math.nextAfter(12.345, Float.POSITIVE_INFINITY))); Assert.assertEquals( KuduPredicate.newComparisonPredicate(decimal32Col, LESS_EQUAL, BigDecimal.valueOf(12345,2)), KuduPredicate.newComparisonPredicate(decimal32Col, LESS, BigDecimal.valueOf(12346,2))); Assert.assertEquals(KuduPredicate.newComparisonPredicate(stringCol, LESS_EQUAL, "a"), KuduPredicate.newComparisonPredicate(stringCol, LESS, "a\0")); Assert.assertEquals(KuduPredicate.newComparisonPredicate(binaryCol, LESS_EQUAL, new byte[] { (byte) 10 }), KuduPredicate.newComparisonPredicate(binaryCol, LESS, new byte[] { (byte) 10, (byte) 0 })); Assert.assertEquals(KuduPredicate.newComparisonPredicate(byteCol, LESS_EQUAL, Byte.MAX_VALUE), KuduPredicate.newIsNotNullPredicate(byteCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(shortCol, LESS_EQUAL, Short.MAX_VALUE), KuduPredicate.newIsNotNullPredicate(shortCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(intCol, LESS_EQUAL, Integer.MAX_VALUE), KuduPredicate.newIsNotNullPredicate(intCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(longCol, LESS_EQUAL, Long.MAX_VALUE), KuduPredicate.newIsNotNullPredicate(longCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(floatCol, LESS_EQUAL, Float.MAX_VALUE),
testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "b\0"), KuduPredicate.newComparisonPredicate(stringCol, LESS, "b"), KuduPredicate.none(stringCol)); testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "b"), KuduPredicate.newComparisonPredicate(stringCol, LESS, "b"), KuduPredicate.none(stringCol)); testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "b"), KuduPredicate.newComparisonPredicate(stringCol, LESS, "b\0"), KuduPredicate.newComparisonPredicate(stringCol, EQUAL, "b")); testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "a"), KuduPredicate.newComparisonPredicate(stringCol, LESS, "a\0\0"), new KuduPredicate(RANGE, stringCol, Bytes.fromString("a"), Bytes.fromString("a\0\0"))); testMerge(KuduPredicate.newComparisonPredicate(stringCol, GREATER_EQUAL, "a"), stringInList("a", "c", "b", ""), stringInList("a", "b", "c")); testMerge(KuduPredicate.newIsNotNullPredicate(stringCol), stringInList("a", "c", "b", ""), stringInList("", "a", "b", "c"));
Assert.assertEquals(KuduPredicate.newIsNotNullPredicate(boolCol), KuduPredicate.newComparisonPredicate(boolCol, GREATER_EQUAL, false)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true), KuduPredicate.newComparisonPredicate(boolCol, GREATER, false)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, false), KuduPredicate.newComparisonPredicate(boolCol, EQUAL, false)); Assert.assertEquals(KuduPredicate.none(boolCol), KuduPredicate.newComparisonPredicate(boolCol, LESS, false)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, false), KuduPredicate.newComparisonPredicate(boolCol, LESS_EQUAL, false)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true), KuduPredicate.newComparisonPredicate(boolCol, GREATER_EQUAL, true)); Assert.assertEquals(KuduPredicate.none(boolCol), KuduPredicate.newComparisonPredicate(boolCol, GREATER, true)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true), KuduPredicate.newComparisonPredicate(boolCol, EQUAL, true)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(boolCol, EQUAL, false), KuduPredicate.newComparisonPredicate(boolCol, LESS, true)); Assert.assertEquals(KuduPredicate.newIsNotNullPredicate(boolCol), KuduPredicate.newComparisonPredicate(boolCol, LESS_EQUAL, true));
ComparisonOp op, long value) { checkColumn(column, Type.INT8, Type.INT16, Type.INT32, Type.INT64, Type.UNIXTIME_MICROS); long minValue = minIntValue(column.getType()); long maxValue = maxIntValue(column.getType()); Preconditions.checkArgument(value <= maxValue && value >= minValue, "integer value out of range for %s column: %s", return newIsNotNullPredicate(column); } else if (op == ComparisonOp.GREATER) { if (value == maxValue) { return none(column); case GREATER_EQUAL: if (value == minValue) { return newIsNotNullPredicate(column); } else if (value == maxValue) { return new KuduPredicate(PredicateType.EQUALITY, column, bytes, null); return new KuduPredicate(PredicateType.RANGE, column, bytes, null); case EQUAL: return new KuduPredicate(PredicateType.EQUALITY, column, bytes, null); case LESS: if (value == minValue) { return none(column); return new KuduPredicate(PredicateType.RANGE, column, null, bytes); default:
switch (pb.getPredicateCase()) { case EQUALITY: return new KuduPredicate(PredicateType.EQUALITY, column, pb.getEquality().getValue().toByteArray(), null); case RANGE: { Common.ColumnPredicatePB.Range range = pb.getRange(); return new KuduPredicate(PredicateType.RANGE, column, range.hasLower() ? range.getLower().toByteArray() : null, range.hasUpper() ? range.getUpper().toByteArray() : null); return newIsNotNullPredicate(column); case IS_NULL: return newIsNullPredicate(column); case IN_LIST: { Common.ColumnPredicatePB.InList inList = pb.getInList(); values.add(value.toByteArray()); return buildInList(column, values);
@Test public void testLess() { Assert.assertEquals(KuduPredicate.newComparisonPredicate(byteCol, LESS, Byte.MIN_VALUE), KuduPredicate.none(byteCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(shortCol, LESS, Short.MIN_VALUE), KuduPredicate.none(shortCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(intCol, LESS, Integer.MIN_VALUE), KuduPredicate.none(intCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(longCol, LESS, Long.MIN_VALUE), KuduPredicate.none(longCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(floatCol, LESS, Float.NEGATIVE_INFINITY), KuduPredicate.none(floatCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(doubleCol, LESS, Double.NEGATIVE_INFINITY), KuduPredicate.none(doubleCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(decimal32Col, LESS, DecimalUtil.minValue(DecimalUtil.MAX_DECIMAL32_PRECISION, 2)), KuduPredicate.none(decimal32Col)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(decimal64Col, LESS, DecimalUtil.minValue(DecimalUtil.MAX_DECIMAL64_PRECISION, 2)), KuduPredicate.none(decimal64Col)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(decimal128Col, LESS, DecimalUtil.minValue(DecimalUtil.MAX_DECIMAL128_PRECISION, 2)), KuduPredicate.none(decimal128Col)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(stringCol, LESS, ""), KuduPredicate.none(stringCol)); Assert.assertEquals(KuduPredicate.newComparisonPredicate(binaryCol, LESS, new byte[] {}), KuduPredicate.none(binaryCol)); }
/** * Builds an IN list predicate from a collection of raw values. The collection * must be sorted and deduplicated. * * @param column the column * @param values the IN list values * @return an IN list predicate */ private static KuduPredicate buildInList(ColumnSchema column, Collection<byte[]> values) { // IN (true, false) predicates can be simplified to IS NOT NULL. if (column.getType().getDataType(column.getTypeAttributes()) == Common.DataType.BOOL && values.size() > 1) { return newIsNotNullPredicate(column); } switch (values.size()) { case 0: return KuduPredicate.none(column); case 1: return new KuduPredicate(PredicateType.EQUALITY, column, values.iterator().next(), null); default: return new KuduPredicate(column, values.toArray(new byte[values.size()][])); } }
/** * Creates a new comparison predicate on a timestamp column. * @param column the column schema * @param op the comparison operation * @param value the value to compare against */ public static KuduPredicate newComparisonPredicate(ColumnSchema column, ComparisonOp op, Timestamp value) { checkColumn(column, Type.UNIXTIME_MICROS); long micros = TimestampUtil.timestampToMicros(value); return newComparisonPredicate(column, op, micros); }
return type == PredicateType.IS_NULL ? none(column) : this; return type == PredicateType.IS_NULL ? this : none(column); case NONE: return this; case IS_NOT_NULL: return other; case IS_NULL: return none(column); case EQUALITY: { if (other.type == PredicateType.EQUALITY) { if (compare(column, lower, other.lower) != 0) { return none(this.column); } else { return this; if (other.rangeContains(lower)) { return this; } else { return none(this.column); return other.merge(this); return other.merge(this); } else { Preconditions.checkState(other.type == PredicateType.RANGE); byte[] newLower = other.lower == null || (lower != null && compare(column, lower, other.lower) >= 0) ? lower : other.lower; byte[] newUpper = other.upper == null || (upper != null && compare(column, upper, other.upper) <= 0) ? upper : other.upper; if (newLower != null && newUpper != null && compare(column, newLower, newUpper) >= 0) {
@Override public void exitIS_NULL_FILTER_EXP(KuduSQLExpressionParser.IS_NULL_FILTER_EXPContext ctx) { super.exitIS_NULL_FILTER_EXP(ctx); String columnName = extractColumnNameFromContext(ctx.idorcolumnname()); if (columnSchemaLookups.containsKey(columnName)) { kuduPredicateList.add(KuduPredicate.newIsNullPredicate(columnSchemaLookups.get(columnName))); } else { LOG.error(columnName + " is not a valid column name for this kudu table"); isSuccessfullyParsed = false; } }