Skip to content

Commit d4425e6

Browse files
Yury-FridlyandYury-Fridlyand
committed
Make a common comparison operator.
Signed-off-by: Yury-Fridlyand <yuryf@bitquilltech.com>
1 parent ae778cf commit d4425e6

1 file changed

Lines changed: 33 additions & 76 deletions

File tree

‎core/src/main/java/org/opensearch/sql/expression/operator/predicate/BinaryPredicateOperator.java‎

Lines changed: 33 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@
2424
import java.time.LocalDateTime;
2525
import java.util.ArrayList;
2626
import java.util.List;
27+
import java.util.function.BiFunction;
2728
import java.util.stream.Collectors;
2829
import java.util.stream.Stream;
2930
import lombok.experimental.UtilityClass;
@@ -34,7 +35,12 @@
3435
import org.opensearch.sql.expression.function.BuiltinFunctionName;
3536
import org.opensearch.sql.expression.function.BuiltinFunctionRepository;
3637
import org.opensearch.sql.expression.function.DefaultFunctionResolver;
38+
import org.opensearch.sql.expression.function.FunctionBuilder;
3739
import org.opensearch.sql.expression.function.FunctionDSL;
40+
import org.opensearch.sql.expression.function.FunctionName;
41+
import org.opensearch.sql.expression.function.FunctionSignature;
42+
import org.opensearch.sql.expression.function.SerializableBiFunction;
43+
import org.opensearch.sql.expression.function.SerializableFunction;
3844
import org.opensearch.sql.utils.OperatorUtils;
3945

4046
/**
@@ -169,98 +175,49 @@ private static DefaultFunctionResolver xor() {
169175
}
170176

171177
private static DefaultFunctionResolver equal() {
172-
return FunctionDSL.define(BuiltinFunctionName.EQUAL.getName(),
173-
Stream.concat(
174-
ExprCoreType.coreTypes().stream()
175-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
176-
(v1, v2) -> ExprBooleanValue.of(v1.equals(v2))),
177-
BOOLEAN, type, type)),
178-
permuteTemporalTypesByPairs().stream()
179-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
180-
(v1, v2) -> ExprBooleanValue.of(convertTemporalToDateTime(v1)
181-
.equals(convertTemporalToDateTime(v2)))),
182-
BOOLEAN, pair.getLeft(), pair.getRight())))
183-
.collect(Collectors.toList()));
178+
return exprCallCompare(BuiltinFunctionName.EQUAL.getName(),
179+
(Comparable v1, Comparable v2) -> v1.equals(v2));
184180
}
185181

186182
private static DefaultFunctionResolver notEqual() {
187-
return FunctionDSL
188-
.define(BuiltinFunctionName.NOTEQUAL.getName(),
189-
Stream.concat(
190-
ExprCoreType.coreTypes().stream()
191-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
192-
(v1, v2) -> ExprBooleanValue.of(!v1.equals(v2))),
193-
BOOLEAN, type, type)),
194-
permuteTemporalTypesByPairs().stream()
195-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
196-
(v1, v2) -> ExprBooleanValue.of(!convertTemporalToDateTime(v1)
197-
.equals(convertTemporalToDateTime(v2)))),
198-
BOOLEAN, pair.getLeft(), pair.getRight())))
199-
.collect(Collectors.toList()));
183+
return exprCallCompare(BuiltinFunctionName.NOTEQUAL.getName(),
184+
(Comparable v1, Comparable v2) -> !v1.equals(v2));
200185
}
201186

202187
private static DefaultFunctionResolver less() {
203-
return FunctionDSL
204-
.define(BuiltinFunctionName.LESS.getName(),
205-
Stream.concat(
206-
ExprCoreType.coreTypes().stream()
207-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
208-
(v1, v2) -> ExprBooleanValue.of(v1.compareTo(v2) < 0)),
209-
BOOLEAN, type, type)),
210-
permuteTemporalTypesByPairs().stream()
211-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
212-
(v1, v2) -> ExprBooleanValue.of(convertTemporalToDateTime(v1)
213-
.compareTo(convertTemporalToDateTime(v2)) < 0)),
214-
BOOLEAN, pair.getLeft(), pair.getRight())))
215-
.collect(Collectors.toList()));
188+
return exprCallCompare(BuiltinFunctionName.LESS.getName(),
189+
(Comparable v1, Comparable v2) -> v1.compareTo(v2) < 0);
216190
}
217191

218192
private static DefaultFunctionResolver lte() {
219-
return FunctionDSL
220-
.define(BuiltinFunctionName.LTE.getName(),
221-
Stream.concat(
222-
ExprCoreType.coreTypes().stream()
223-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
224-
(v1, v2) -> ExprBooleanValue.of(v1.compareTo(v2) <= 0)),
225-
BOOLEAN, type, type)),
226-
permuteTemporalTypesByPairs().stream()
227-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
228-
(v1, v2) -> ExprBooleanValue.of(convertTemporalToDateTime(v1)
229-
.compareTo(convertTemporalToDateTime(v2)) <= 0)),
230-
BOOLEAN, pair.getLeft(), pair.getRight())))
231-
.collect(Collectors.toList()));
193+
return exprCallCompare(BuiltinFunctionName.LTE.getName(),
194+
(Comparable v1, Comparable v2) -> v1.compareTo(v2) <= 0);
232195
}
233196

234197
private static DefaultFunctionResolver greater() {
235-
return FunctionDSL
236-
.define(BuiltinFunctionName.GREATER.getName(),
237-
Stream.concat(
238-
ExprCoreType.coreTypes().stream()
239-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
240-
(v1, v2) -> ExprBooleanValue.of(v1.compareTo(v2) > 0)),
241-
BOOLEAN, type, type)),
242-
permuteTemporalTypesByPairs().stream()
243-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
244-
(v1, v2) -> ExprBooleanValue.of(convertTemporalToDateTime(v1)
245-
.compareTo(convertTemporalToDateTime(v2)) > 0)),
246-
BOOLEAN, pair.getLeft(), pair.getRight())))
247-
.collect(Collectors.toList()));
198+
return exprCallCompare(BuiltinFunctionName.GREATER.getName(),
199+
(Comparable v1, Comparable v2) -> v1.compareTo(v2) > 0);
248200
}
249201

250202
private static DefaultFunctionResolver gte() {
251-
return FunctionDSL
252-
.define(BuiltinFunctionName.GTE.getName(),
253-
Stream.concat(
254-
ExprCoreType.coreTypes().stream()
255-
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
256-
(v1, v2) -> ExprBooleanValue.of(v1.compareTo(v2) >= 0)),
257-
BOOLEAN, type, type)),
258-
permuteTemporalTypesByPairs().stream()
259-
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
260-
(v1, v2) -> ExprBooleanValue.of(convertTemporalToDateTime(v1)
261-
.compareTo(convertTemporalToDateTime(v2)) >= 0)),
203+
return exprCallCompare(BuiltinFunctionName.GTE.getName(),
204+
(Comparable v1, Comparable v2) -> v1.compareTo(v2) >= 0);
205+
}
206+
207+
private static DefaultFunctionResolver exprCallCompare(
208+
FunctionName function, SerializableBiFunction<Comparable, Comparable, Boolean> comparator) {
209+
return FunctionDSL.define(function,
210+
Stream.concat(
211+
ExprCoreType.coreTypes().stream()
212+
.map(type -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
213+
(v1, v2) -> ExprBooleanValue.of(comparator.apply(v1, v2))),
214+
BOOLEAN, type, type)),
215+
permuteTemporalTypesByPairs().stream()
216+
.map(pair -> FunctionDSL.impl(FunctionDSL.nullMissingHandling(
217+
(v1, v2) -> ExprBooleanValue.of(comparator.apply(
218+
convertTemporalToDateTime(v1), convertTemporalToDateTime(v2)))),
262219
BOOLEAN, pair.getLeft(), pair.getRight())))
263-
.collect(Collectors.toList()));
220+
.collect(Collectors.toList()));
264221
}
265222

266223
private static DefaultFunctionResolver like() {

0 commit comments

Comments
 (0)