Skip to content

Commit ea3b0a8

Browse files
jeffgbutlerjeffgbutler
authored
Merge pull request #921 from jeffgbutler/improve-conditions
Condition Filter and Map are now Interfaces
2 parents a2f93dd + 7cb17bd commit ea3b0a8

36 files changed

+534
-399
lines changed

‎CHANGELOG.md‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -103,7 +103,8 @@ Runtime behavior changes:
103103
- Rendering for all the conditions (isEqualTo, etc.) has changed. This should be transparent to most users unless you
104104
have coded a direct implementation of `VisitableCondition`. The change makes it easier to code custom conditions that
105105
are not supported by the library out of the box. The statement renderers now call methods `renderCondition` and
106-
`renderLeftColumn` that you can override to implement any rendering you need.
106+
`renderLeftColumn` that you can override to implement any rendering you need. In addition, we've made `filter` and
107+
`map` support optional if you implement custom conditions
107108

108109
## Release 1.5.2 - June 3, 2024
109110

‎src/main/java/org/mybatis/dynamic/sql/AbstractListValueCondition.java‎

Lines changed: 50 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -73,16 +73,6 @@ protected <R, S extends AbstractListValueCondition<R>> S mapSupport(Function<? s
7373
}
7474
}
7575

76-
/**
77-
* If not empty, apply the predicate to each value in the list and return a new condition with the filtered values.
78-
* Else returns an empty condition (this).
79-
*
80-
* @param predicate predicate applied to the values, if not empty
81-
*
82-
* @return a new condition with filtered values if renderable, otherwise an empty condition
83-
*/
84-
public abstract AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
85-
8676
public abstract String operator();
8777

8878
@Override
@@ -100,4 +90,54 @@ private FragmentAndParameters toFragmentAndParameters(T value, RenderingContext
10090
.withParameter(parameterInfo.parameterMapKey(), leftColumn.convertParameterType(value))
10191
.build();
10292
}
93+
94+
/**
95+
* Conditions may implement Filterable to add optionality to rendering.
96+
*
97+
* <p>If a condition is Filterable, then a user may add a filter to the usage of the condition that makes a decision
98+
* whether to render the condition at runtime. Conditions that fail the filter will be dropped from the
99+
* rendered SQL.
100+
*
101+
* <p>Implementations of Filterable may call
102+
* {@link AbstractListValueCondition#filterSupport(Predicate, Function, AbstractListValueCondition, Supplier)} as
103+
* a common implementation of the filtering algorithm.
104+
*
105+
* @param <T> the Java type related to the database column type
106+
*/
107+
public interface Filterable<T> {
108+
/**
109+
* If renderable and the value matches the predicate, returns this condition. Else returns a condition
110+
* that will not render.
111+
*
112+
* @param predicate predicate applied to the value, if renderable
113+
* @return this condition if renderable and the value matches the predicate, otherwise a condition
114+
* that will not render.
115+
*/
116+
AbstractListValueCondition<T> filter(Predicate<? super T> predicate);
117+
}
118+
119+
/**
120+
* Conditions may implement Mappable to alter condition values or types during rendering.
121+
*
122+
* <p>If a condition is Mappable, then a user may add a mapper to the usage of the condition that can alter the
123+
* values of a condition, or change that datatype.
124+
*
125+
* <p>Implementations of Mappable may call
126+
* {@link AbstractListValueCondition#mapSupport(Function, Function, Supplier)} as
127+
* a common implementation of the mapping algorithm.
128+
*
129+
* @param <T> the Java type related to the database column type
130+
*/
131+
public interface Mappable<T> {
132+
/**
133+
* If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
134+
* condition that will not render (this).
135+
*
136+
* @param mapper a mapping function to apply to the value, if renderable
137+
* @param <R> type of the new condition
138+
* @return a new condition with the result of applying the mapper to the value of this condition,
139+
* if renderable, otherwise a condition that will not render.
140+
*/
141+
<R> AbstractListValueCondition<R> map(Function<? super T, ? extends R> mapper);
142+
}
103143
}

‎src/main/java/org/mybatis/dynamic/sql/AbstractNoValueCondition.java‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,4 +38,30 @@ protected <S extends AbstractNoValueCondition<?>> S filterSupport(BooleanSupplie
3838
public FragmentAndParameters renderCondition(RenderingContext renderingContext, BindableColumn<T> leftColumn) {
3939
return FragmentAndParameters.fromFragment(operator());
4040
}
41+
42+
/**
43+
* Conditions may implement Filterable to add optionality to rendering.
44+
*
45+
* <p>If a condition is Filterable, then a user may add a filter to the usage of the condition that makes a decision
46+
* whether to render the condition at runtime. Conditions that fail the filter will be dropped from the
47+
* rendered SQL.
48+
*
49+
* <p>Implementations of Filterable may call
50+
* {@link AbstractNoValueCondition#filterSupport(BooleanSupplier, Supplier, AbstractNoValueCondition)} as
51+
* a common implementation of the filtering algorithm.
52+
*/
53+
public interface Filterable {
54+
/**
55+
* If renderable and the supplier returns true, returns this condition. Else returns a condition that will not
56+
* render.
57+
*
58+
* @param booleanSupplier
59+
* function that specifies whether the condition should render
60+
* @param <S>
61+
* condition type - not used except for compilation compliance
62+
*
63+
* @return this condition if renderable and the supplier returns true, otherwise a condition that will not render.
64+
*/
65+
<S> AbstractNoValueCondition<S> filter(BooleanSupplier booleanSupplier);
66+
}
4167
}

‎src/main/java/org/mybatis/dynamic/sql/AbstractSingleValueCondition.java‎

Lines changed: 50 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -54,16 +54,6 @@ protected <R, S extends AbstractSingleValueCondition<R>> S mapSupport(Function<?
5454
}
5555
}
5656

57-
/**
58-
* If renderable and the value matches the predicate, returns this condition. Else returns a condition
59-
* that will not render.
60-
*
61-
* @param predicate predicate applied to the value, if renderable
62-
* @return this condition if renderable and the value matches the predicate, otherwise a condition
63-
* that will not render.
64-
*/
65-
public abstract AbstractSingleValueCondition<T> filter(Predicate<? super T> predicate);
66-
6757
public abstract String operator();
6858

6959
@Override
@@ -75,4 +65,54 @@ public FragmentAndParameters renderCondition(RenderingContext renderingContext,
7565
.withParameter(parameterInfo.parameterMapKey(), leftColumn.convertParameterType(value()))
7666
.build();
7767
}
68+
69+
/**
70+
* Conditions may implement Filterable to add optionality to rendering.
71+
*
72+
* <p>If a condition is Filterable, then a user may add a filter to the usage of the condition that makes a decision
73+
* whether to render the condition at runtime. Conditions that fail the filter will be dropped from the
74+
* rendered SQL.
75+
*
76+
* <p>Implementations of Filterable may call
77+
* {@link AbstractSingleValueCondition#filterSupport(Predicate, Supplier, AbstractSingleValueCondition)} as
78+
* a common implementation of the filtering algorithm.
79+
*
80+
* @param <T> the Java type related to the database column type
81+
*/
82+
public interface Filterable<T> {
83+
/**
84+
* If renderable and the value matches the predicate, returns this condition. Else returns a condition
85+
* that will not render.
86+
*
87+
* @param predicate predicate applied to the value, if renderable
88+
* @return this condition if renderable and the value matches the predicate, otherwise a condition
89+
* that will not render.
90+
*/
91+
AbstractSingleValueCondition<T> filter(Predicate<? super T> predicate);
92+
}
93+
94+
/**
95+
* Conditions may implement Mappable to alter condition values or types during rendering.
96+
*
97+
* <p>If a condition is Mappable, then a user may add a mapper to the usage of the condition that can alter the
98+
* values of a condition, or change that datatype.
99+
*
100+
* <p>Implementations of Mappable may call
101+
* {@link AbstractSingleValueCondition#mapSupport(Function, Function, Supplier)} as
102+
* a common implementation of the mapping algorithm.
103+
*
104+
* @param <T> the Java type related to the database column type
105+
*/
106+
public interface Mappable<T> {
107+
/**
108+
* If renderable, apply the mapping to the value and return a new condition with the new value. Else return a
109+
* condition that will not render (this).
110+
*
111+
* @param mapper a mapping function to apply to the value, if renderable
112+
* @param <R> type of the new condition
113+
* @return a new condition with the result of applying the mapper to the value of this condition,
114+
* if renderable, otherwise a condition that will not render.
115+
*/
116+
<R> AbstractSingleValueCondition<R> map(Function<? super T, ? extends R> mapper);
117+
}
78118
}

‎src/main/java/org/mybatis/dynamic/sql/AbstractTwoValueCondition.java‎

Lines changed: 75 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -67,27 +67,6 @@ protected <R, S extends AbstractTwoValueCondition<R>> S mapSupport(Function<? su
6767
}
6868
}
6969

70-
/**
71-
* If renderable and the values match the predicate, returns this condition. Else returns a condition
72-
* that will not render.
73-
*
74-
* @param predicate predicate applied to the values, if renderable
75-
* @return this condition if renderable and the values match the predicate, otherwise a condition
76-
* that will not render.
77-
*/
78-
public abstract AbstractTwoValueCondition<T> filter(BiPredicate<? super T, ? super T> predicate);
79-
80-
/**
81-
* If renderable and both values match the predicate, returns this condition. Else returns a condition
82-
* that will not render. This function implements a short-circuiting test. If the
83-
* first value does not match the predicate, then the second value will not be tested.
84-
*
85-
* @param predicate predicate applied to both values, if renderable
86-
* @return this condition if renderable and the values match the predicate, otherwise a condition
87-
* that will not render.
88-
*/
89-
public abstract AbstractTwoValueCondition<T> filter(Predicate<? super T> predicate);
90-
9170
public abstract String operator1();
9271

9372
public abstract String operator2();
@@ -107,4 +86,79 @@ public FragmentAndParameters renderCondition(RenderingContext renderingContext,
10786
.withParameter(parameterInfo2.parameterMapKey(), leftColumn.convertParameterType(value2()))
10887
.build();
10988
}
89+
90+
/**
91+
* Conditions may implement Filterable to add optionality to rendering.
92+
*
93+
* <p>If a condition is Filterable, then a user may add a filter to the usage of the condition that makes a decision
94+
* whether to render the condition at runtime. Conditions that fail the filter will be dropped from the
95+
* rendered SQL.
96+
*
97+
* <p>Implementations of Filterable may call
98+
* {@link AbstractTwoValueCondition#filterSupport(Predicate, Supplier, AbstractTwoValueCondition)}
99+
* or {@link AbstractTwoValueCondition#filterSupport(BiPredicate, Supplier, AbstractTwoValueCondition)} as
100+
* a common implementation of the filtering algorithm.
101+
*
102+
* @param <T> the Java type related to the database column type
103+
*/
104+
public interface Filterable<T> {
105+
/**
106+
* If renderable and the values match the predicate, returns this condition. Else returns a condition
107+
* that will not render.
108+
*
109+
* @param predicate predicate applied to the values, if renderable
110+
* @return this condition if renderable and the values match the predicate, otherwise a condition
111+
* that will not render.
112+
*/
113+
AbstractTwoValueCondition<T> filter(BiPredicate<? super T, ? super T> predicate);
114+
115+
/**
116+
* If renderable and both values match the predicate, returns this condition. Else returns a condition
117+
* that will not render. This function implements a short-circuiting test. If the
118+
* first value does not match the predicate, then the second value will not be tested.
119+
*
120+
* @param predicate predicate applied to both values, if renderable
121+
* @return this condition if renderable and the values match the predicate, otherwise a condition
122+
* that will not render.
123+
*/
124+
AbstractTwoValueCondition<T> filter(Predicate<? super T> predicate);
125+
}
126+
127+
/**
128+
* Conditions may implement Mappable to alter condition values or types during rendering.
129+
*
130+
* <p>If a condition is Mappable, then a user may add a mapper to the usage of the condition that can alter the
131+
* values of a condition, or change that datatype.
132+
*
133+
* <p>Implementations of Mappable may call
134+
* {@link AbstractTwoValueCondition#mapSupport(Function, Function, BiFunction, Supplier)} as
135+
* a common implementation of the mapping algorithm.
136+
*
137+
* @param <T> the Java type related to the database column type
138+
*/
139+
public interface Mappable<T> {
140+
/**
141+
* If renderable, apply the mappings to the values and return a new condition with the new values. Else return a
142+
* condition that will not render (this).
143+
*
144+
* @param mapper1 a mapping function to apply to the first value, if renderable
145+
* @param mapper2 a mapping function to apply to the second value, if renderable
146+
* @param <R> type of the new condition
147+
* @return a new condition with the result of applying the mappers to the values of this condition,
148+
* if renderable, otherwise a condition that will not render.
149+
*/
150+
<R> AbstractTwoValueCondition<R> map(Function<? super T, ? extends R> mapper1,
151+
Function<? super T, ? extends R> mapper2);
152+
153+
/**
154+
* If renderable, apply the mapping to both values and return a new condition with the new values. Else return a
155+
* condition that will not render (this).
156+
*
157+
* @param mapper a mapping function to apply to both values, if renderable
158+
* @param <R> type of the new condition
159+
* @return a new condition with the result of applying the mappers to the values of this condition,
160+
* if renderable, otherwise a condition that will not render.
161+
*/
162+
<R> AbstractTwoValueCondition<R> map(Function<? super T, ? extends R> mapper);
163+
}
110164
}

‎src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java‎

Lines changed: 17 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -882,68 +882,69 @@ static IsEqualTo<Boolean> isFalse() {
882882
}
883883

884884
// conditions for strings only
885-
static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
885+
static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(String value) {
886886
return IsLikeCaseInsensitive.of(value);
887887
}
888888

889-
static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {
889+
static IsLikeCaseInsensitive<String> isLikeCaseInsensitive(Supplier<String> valueSupplier) {
890890
return isLikeCaseInsensitive(valueSupplier.get());
891891
}
892892

893-
static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(@Nullable String value) {
893+
static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(@Nullable String value) {
894894
return value == null ? IsLikeCaseInsensitive.empty() : IsLikeCaseInsensitive.of(value);
895895
}
896896

897-
static IsLikeCaseInsensitive isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
897+
static IsLikeCaseInsensitive<String> isLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
898898
return isLikeCaseInsensitiveWhenPresent(valueSupplier.get());
899899
}
900900

901-
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
901+
static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(String value) {
902902
return IsNotLikeCaseInsensitive.of(value);
903903
}
904904

905-
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
905+
static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
906906
return isNotLikeCaseInsensitive(valueSupplier.get());
907907
}
908908

909-
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {
909+
static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(@Nullable String value) {
910910
return value == null ? IsNotLikeCaseInsensitive.empty() : IsNotLikeCaseInsensitive.of(value);
911911
}
912912

913-
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitiveWhenPresent(Supplier<@Nullable String> valueSupplier) {
913+
static IsNotLikeCaseInsensitive<String> isNotLikeCaseInsensitiveWhenPresent(
914+
Supplier<@Nullable String> valueSupplier) {
914915
return isNotLikeCaseInsensitiveWhenPresent(valueSupplier.get());
915916
}
916917

917-
static IsInCaseInsensitive isInCaseInsensitive(String... values) {
918+
static IsInCaseInsensitive<String> isInCaseInsensitive(String... values) {
918919
return IsInCaseInsensitive.of(values);
919920
}
920921

921-
static IsInCaseInsensitive isInCaseInsensitive(Collection<String> values) {
922+
static IsInCaseInsensitive<String> isInCaseInsensitive(Collection<String> values) {
922923
return IsInCaseInsensitive.of(values);
923924
}
924925

925-
static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(@Nullable String... values) {
926+
static IsInCaseInsensitiveWhenPresent<String> isInCaseInsensitiveWhenPresent(@Nullable String... values) {
926927
return IsInCaseInsensitiveWhenPresent.of(values);
927928
}
928929

929-
static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(
930+
static IsInCaseInsensitiveWhenPresent<String> isInCaseInsensitiveWhenPresent(
930931
@Nullable Collection<@Nullable String> values) {
931932
return values == null ? IsInCaseInsensitiveWhenPresent.empty() : IsInCaseInsensitiveWhenPresent.of(values);
932933
}
933934

934-
static IsNotInCaseInsensitive isNotInCaseInsensitive(String... values) {
935+
static IsNotInCaseInsensitive<String> isNotInCaseInsensitive(String... values) {
935936
return IsNotInCaseInsensitive.of(values);
936937
}
937938

938-
static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection<String> values) {
939+
static IsNotInCaseInsensitive<String> isNotInCaseInsensitive(Collection<String> values) {
939940
return IsNotInCaseInsensitive.of(values);
940941
}
941942

942-
static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(@Nullable String... values) {
943+
static IsNotInCaseInsensitiveWhenPresent<String> isNotInCaseInsensitiveWhenPresent(@Nullable String... values) {
943944
return IsNotInCaseInsensitiveWhenPresent.of(values);
944945
}
945946

946-
static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(
947+
static IsNotInCaseInsensitiveWhenPresent<String> isNotInCaseInsensitiveWhenPresent(
947948
@Nullable Collection<@Nullable String> values) {
948949
return values == null ? IsNotInCaseInsensitiveWhenPresent.empty() :
949950
IsNotInCaseInsensitiveWhenPresent.of(values);

‎src/main/java/org/mybatis/dynamic/sql/util/StringUtilities.java‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,8 @@
1515
*/
1616
package org.mybatis.dynamic.sql.util;
1717

18+
import java.util.function.Function;
19+
1820
import org.jspecify.annotations.Nullable;
1921

2022
public interface StringUtilities {
@@ -59,4 +61,8 @@ static String formatConstantForSQL(String in) {
5961
String escaped = in.replace("'", "''"); //$NON-NLS-1$ //$NON-NLS-2$
6062
return "'" + escaped + "'"; //$NON-NLS-1$ //$NON-NLS-2$
6163
}
64+
65+
static Function<String, String> mapToUpperCase(Function<String, String> f) {
66+
return f.andThen(String::toUpperCase);
67+
}
6268
}

0 commit comments

Comments
 (0)