Skip to content

Commit 0d7adf7

Browse files
daileyetdaileyet
committed
Fix the issue
1 parent f4fa9ca commit 0d7adf7

8 files changed

Lines changed: 181 additions & 64 deletions

File tree

‎src/openthinks/libs/sql/dhibernate/support/query/impl/AbstractQueryFilter.java‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,20 @@ public abstract class AbstractQueryFilter<E extends QueryFilter> implements Quer
4343
private String filterName;
4444
protected QueryFilter appenedFilter;
4545

46+
public AbstractQueryFilter() {
47+
}
48+
49+
public AbstractQueryFilter(Class<?> filterClass) {
50+
super();
51+
this.filterClass = filterClass;
52+
}
53+
54+
public AbstractQueryFilter(Class<?> filterClass, String filterName) {
55+
super();
56+
this.filterClass = filterClass;
57+
this.filterName = filterName;
58+
}
59+
4660
/**
4761
* @return the queryFilters
4862
*/

‎src/openthinks/libs/sql/dhibernate/support/query/impl/ContainerFilter.java‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,18 @@
3333
public class ContainerFilter extends AbstractQueryFilter<ContainerFilter> {
3434
private Object dynamicValue;
3535

36+
public ContainerFilter() {
37+
super();
38+
}
39+
40+
public ContainerFilter(Class<?> filterClass, String filterName) {
41+
super(filterClass, filterName);
42+
}
43+
44+
public ContainerFilter(Class<?> filterClass) {
45+
super(filterClass);
46+
}
47+
3648
/**
3749
* represent the statement : like '%<i>parameter</i>%'
3850
* @param value Object

‎src/openthinks/libs/sql/dhibernate/support/query/impl/EqualsFilter.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,14 @@ public class EqualsFilter extends AbstractQueryFilter<EqualsFilter> {
3636
public EqualsFilter() {
3737
}
3838

39+
public EqualsFilter(Class<?> filterClass, String filterName) {
40+
super(filterClass, filterName);
41+
}
42+
43+
public EqualsFilter(Class<?> filterClass) {
44+
super(filterClass);
45+
}
46+
3947
public EqualsFilter eq(Object value) {
4048
this.eqValue = value;
4149
return this;

‎src/openthinks/libs/sql/dhibernate/support/query/impl/FilterSQLTemplate.java‎

Lines changed: 38 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,6 @@
2828
import java.util.ArrayList;
2929
import java.util.Arrays;
3030
import java.util.Collection;
31-
import java.util.Iterator;
3231
import java.util.LinkedList;
3332
import java.util.List;
3433

@@ -54,60 +53,67 @@ public FilterSQLTemplate(ColumnAttributeMapping columnAttributeMapping, Class<?>
5453
setType(SQLType.QUERY);
5554
}
5655

57-
@SuppressWarnings("unchecked")
56+
/**
57+
* process the first head QueryFilter and iterate the next element;<BR>
58+
* it will go to add default QueryFilterConnect between two AbstractQueryFilter;<BR>
59+
* after the above operations, it will return the last element QueryFilter.
60+
* @param first QueryFilter the head of QueryFilter
61+
* @return QueryFilter
62+
*/
5863
protected QueryFilter getProcessNext(QueryFilter first) {
5964
QueryFilter next = null;
6065
if (first == null)
6166
return next;
6267

63-
if (first instanceof QueryFilterGroup) {//process group
64-
final List<QueryFilter> filters = ((QueryFilterGroup) first).getQueryFilters();
65-
LinkedList<QueryFilter> filtersTemp = new LinkedList<QueryFilter>();
66-
for (Iterator<QueryFilter> it = filters.iterator(); it.hasNext();) {
67-
QueryFilter e = it.next();
68-
getProcessNext(e);
69-
filtersTemp.add(e);
70-
filtersTemp.add(QueryFilterConnects.and());
71-
}
72-
if (filtersTemp.getLast() instanceof QueryFilterConnect) {
73-
filtersTemp.removeLast();
74-
}
75-
filters.clear();
76-
filters.addAll(filtersTemp);
68+
if (first instanceof QueryFilterGroup) {//process group add query filter connect between abstract query filters
69+
processGroup((QueryFilterGroup) first);
7770
}
7871

79-
while (first.hasNext()) {
72+
while (first.hasNext()) {//iterate the next element
8073
next = first.next();
8174
if (first instanceof QueryFilterConnect && next instanceof QueryFilterConnect)
8275
throw new IllegalQueryFilterException();
8376

84-
// add QueryFilterConnect between AbstractQueryFilters
77+
// add AndFilterConnect between AbstractQueryFilters
8578
if (!(first instanceof QueryFilterConnect) && !(next instanceof QueryFilterConnect)) {
8679
QueryFilter qf = QueryFilterConnects.and().append(next);
87-
((AbstractQueryFilter<QueryFilter>) first).appenedFilter = qf;
80+
((AbstractQueryFilter<?>) first).appenedFilter = qf;
8881
}
8982
first = next;
9083

9184
if (first instanceof QueryFilterGroup) {
92-
final List<QueryFilter> filters = ((QueryFilterGroup) first).getQueryFilters();
93-
LinkedList<QueryFilter> filtersTemp = new LinkedList<QueryFilter>();
94-
for (Iterator<QueryFilter> it = filters.iterator(); it.hasNext();) {
95-
QueryFilter e = it.next();
96-
getProcessNext(e);
97-
filtersTemp.add(e);
98-
filtersTemp.add(QueryFilterConnects.and());
99-
}
100-
if (filtersTemp.getLast() instanceof QueryFilterConnect) {
101-
filtersTemp.removeLast();
102-
}
103-
filters.clear();
104-
filters.addAll(filtersTemp);
85+
processGroup((QueryFilterGroup) first);
10586
}
10687

10788
}
10889
return next;
10990
}
11091

92+
/**
93+
* process the QueryFilterGroup element;<BR>
94+
* it will go to add default QueryFilterConnect between two AbstractQueryFilter in this group;<BR>
95+
* @param filterGroup QueryFilterGroup
96+
*/
97+
protected void processGroup(QueryFilterGroup filterGroup) {
98+
final List<QueryFilter> filters = filterGroup.getQueryFilters();
99+
LinkedList<QueryFilter> filtersTemp = new LinkedList<QueryFilter>();
100+
for (int index = 0, next_index = index + 1, count = filters.size(); index < count; index++) {
101+
QueryFilter e = filters.get(index);
102+
QueryFilter next_e = next_index < count ? filters.get(next_index) : null;
103+
getProcessNext(e);
104+
filtersTemp.add(e);
105+
//only add default AndFilterConnect when current and next element are both AbstractQueryFilter
106+
if (e instanceof AbstractQueryFilter && next_e instanceof AbstractQueryFilter) {
107+
filtersTemp.add(QueryFilterConnects.and());
108+
}
109+
}
110+
if (filtersTemp.getLast() instanceof QueryFilterConnect) {
111+
filtersTemp.removeLast();
112+
}
113+
filters.clear();
114+
filters.addAll(filtersTemp);
115+
}
116+
111117
@Override
112118
public String generateSQL() {
113119
if (this.queryFilter == null) {
@@ -117,22 +123,6 @@ public String generateSQL() {
117123
buffer.append(super.generateSQL());
118124
buffer.append(" WHERE ");
119125
QueryFilter first = this.queryFilter;
120-
// QueryFilter next;
121-
// TODO
122-
// if (first != null)
123-
// while (first.hasNext()) {
124-
// next = first.next();
125-
// if (first instanceof QueryFilterConnect
126-
// && next instanceof QueryFilterConnect)
127-
// throw new IllegalQueryFilterException();
128-
// // add QueryFilterConnect between AbstractQueryFilters
129-
// if (!(first instanceof QueryFilterConnect)
130-
// && !(next instanceof QueryFilterConnect)) {
131-
// QueryFilter qf = QueryFilterConnects.and().append(next);
132-
// ((AbstractQueryFilter<QueryFilter>) first).appenedFilter = qf;
133-
// }
134-
// first = next;
135-
// }
136126

137127
getProcessNext(first);
138128

‎src/openthinks/libs/sql/dhibernate/support/query/impl/NotEqualsFliter.java‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -36,6 +36,14 @@ public class NotEqualsFliter extends AbstractQueryFilter<NotEqualsFliter> {
3636
public NotEqualsFliter() {
3737
}
3838

39+
public NotEqualsFliter(Class<?> filterClass, String filterName) {
40+
super(filterClass, filterName);
41+
}
42+
43+
public NotEqualsFliter(Class<?> filterClass) {
44+
super(filterClass);
45+
}
46+
3947
public NotEqualsFliter neq(Object value) {
4048
this.neqValue = value;
4149
return this;

‎src/openthinks/libs/sql/dhibernate/support/query/impl/QueryFilterGroup.java‎

Lines changed: 26 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -41,21 +41,32 @@
4141
*/
4242
public class QueryFilterGroup extends AbstractQueryFilter<QueryFilterGroup> {
4343

44-
private final List<QueryFilter> queryFilters;
44+
private final List<QueryFilter> queryFilters = new ArrayList<QueryFilter>();
4545

4646
public QueryFilterGroup() {
47-
this.queryFilters = new ArrayList<QueryFilter>();
4847
}
4948

50-
@SuppressWarnings("unchecked")
51-
@Override
52-
public <T extends QueryFilter> T append(QueryFilter filter) {
49+
public QueryFilterGroup(Class<?> filterClass, String filterName) {
50+
super(filterClass, filterName);
51+
}
52+
53+
public QueryFilterGroup(Class<?> filterClass) {
54+
super(filterClass);
55+
}
56+
57+
/**
58+
* add the given query filter into this group, as a part of this group<BR>
59+
* different from {@link #append(QueryFilter)}
60+
* @param filter the child of {@link QueryFilter}
61+
* @return QueryFilterGroup
62+
*/
63+
public QueryFilterGroup push(QueryFilter filter) {
5364
if (filter instanceof AbstractQueryFilter) {
5465
((AbstractQueryFilter<?>) filter).filterClass(this.getFilterClass());
5566
}
5667
this.queryFilters.add(filter);
5768

58-
return (T) this;
69+
return this;
5970
}
6071

6172
@Override
@@ -80,6 +91,9 @@ private Object processSingleFilter(QueryFilter filter) {
8091
StringBuffer buffer = new StringBuffer();
8192
for (;;) {
8293
if (first instanceof Relativization) {
94+
if (first instanceof AbstractQueryFilter) {//set filter entity class again
95+
((AbstractQueryFilter<?>) first).filterClass(this.getFilterClass());
96+
}
8397
buffer.append(((Relativization) first).toSQL());
8498
}
8599
if (!first.hasNext()) {
@@ -116,11 +130,12 @@ private Object[] processSingleFilterParameter(QueryFilter filter) {
116130
for (;;) {
117131
if (first instanceof Relativization) {
118132
Object[] temps = ((Relativization) first).parameters();
119-
if (temps == null || temps.length == 0)
120-
continue;
121-
Object[] newParameters = Arrays.copyOf(paramters, paramters.length + temps.length);
122-
System.arraycopy(temps, 0, newParameters, paramters.length, temps.length);
123-
paramters = newParameters;
133+
if (temps == null || temps.length == 0) {//nothing to do
134+
} else {
135+
Object[] newParameters = Arrays.copyOf(paramters, paramters.length + temps.length);
136+
System.arraycopy(temps, 0, newParameters, paramters.length, temps.length);
137+
paramters = newParameters;
138+
}
124139
}
125140
if (!first.hasNext()) {
126141
break;

‎test/openthinks/libs/sql/FilterSqlTemplateTest.java‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
package openthinks.libs.sql;
2+
3+
import openthinks.libs.sql.dhibernate.support.FilterTemplate;
4+
import openthinks.libs.sql.dhibernate.support.query.QueryFilter;
5+
import openthinks.libs.sql.dhibernate.support.query.Relativization;
6+
import openthinks.libs.sql.dhibernate.support.query.impl.EqualsFilter;
7+
import openthinks.libs.sql.dhibernate.support.query.impl.OrFilterConnect;
8+
import openthinks.libs.sql.dhibernate.support.query.impl.QueryFilterGroup;
9+
import openthinks.libs.sql.lang.reflect.ReflectEngine;
10+
11+
import org.junit.Assert;
12+
import org.junit.Before;
13+
import org.junit.Test;
14+
15+
public class FilterSqlTemplateTest {
16+
Class<?> queryObjectType;
17+
QueryFilter firstFilter;
18+
Relativization relativization;
19+
20+
@Before
21+
public void setUp() {
22+
queryObjectType = Message.class;
23+
}
24+
25+
@Test
26+
public void testQueryFilter() {
27+
relativization = new EqualsFilter(queryObjectType).filter("messageId").eq("");
28+
String actual = relativization.toSQL().toString();
29+
String expected = "`message_id` = ?";
30+
Assert.assertEquals(expected.toLowerCase(), actual.toLowerCase().trim());
31+
32+
relativization = new EqualsFilter(queryObjectType).filter("messageId");
33+
actual = relativization.toSQL().toString();
34+
expected = "`message_id` is null";
35+
Assert.assertEquals(expected.toLowerCase(), actual.toLowerCase().trim());
36+
}
37+
38+
@Test
39+
public void testQueryFilterGroup() {
40+
QueryFilterGroup group = new QueryFilterGroup();
41+
group.push(new EqualsFilter().filter("messageId").eq(""));
42+
group.push(new OrFilterConnect());
43+
group.push(new EqualsFilter().filter("messageId").eq(""));
44+
this.firstFilter = group;
45+
46+
FilterTemplate template = ReflectEngine.createSQLTemplate(queryObjectType, this.firstFilter);
47+
String actual = template.generateSQL();
48+
String expected = "select * from `message` where ( `message_id` = ? or `message_id` = ? ) ";
49+
Assert.assertEquals(expected.toLowerCase(), actual.toLowerCase());
50+
}
51+
52+
@Test
53+
public void testQueryFilterGroupEmbed() {
54+
QueryFilterGroup group = new QueryFilterGroup();
55+
group.push(new EqualsFilter().filter("messageId").eq(""));
56+
group.push(new OrFilterConnect());
57+
this.firstFilter = group;
58+
QueryFilterGroup embedGrp = new QueryFilterGroup();
59+
embedGrp.push(new EqualsFilter().filter("messageId").eq(""));
60+
group.push(embedGrp);
61+
62+
FilterTemplate template = ReflectEngine.createSQLTemplate(queryObjectType, this.firstFilter);
63+
String actual = template.generateSQL();
64+
String expected = "select * from `message` where ( `message_id` = ? or ( `message_id` = ? ) ) ";
65+
Assert.assertEquals(expected.toLowerCase(), actual.toLowerCase());
66+
}
67+
}

‎test/openthinks/libs/sql/QueryFilterTest.java‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -45,21 +45,24 @@ void testEqual() {
4545
Session session = new TestSession();
4646
Query<Message> query = session.createQuery(Message.class);
4747
query.addFilter(new EqualsFilter().filter("messageId").eq("123"));
48+
query.addFilter(QueryFilterConnects.or());
49+
query.addFilter(QueryFilterConnects.or());
4850
query.addFilter(new ContainerFilter().filter("content").include("abc"));
4951
query.addFilter(QueryFilterConnects.or());
5052

51-
QueryFilter appended1 = new QueryFilterGroup();
52-
53+
QueryFilterGroup appended1 = new QueryFilterGroup();
5354
QueryFilter lasted = null;
5455

5556
lasted = new ContainerFilter().filter("content").startWith("BEGIN");
56-
appended1.append(lasted);
57+
appended1.push(lasted);
5758
lasted = new NotEqualsFliter().filter("messageId").neq("234");
58-
appended1.append(lasted);
59+
appended1.push(lasted);
5960
lasted = new NotEqualsFliter().filter("locale").neq("CN");
60-
appended1.append(lasted);
61+
appended1.push(lasted);
6162

6263
query.addFilter(appended1);
64+
65+
query.addFilter(new EqualsFilter().filter("locale").eq("US"));
6366
query.execute();
6467
}
6568

0 commit comments

Comments
 (0)