![[Jenkins]](/jenkins/static/c1408a8d/images/svgs/logo.svg){kind=logo}
Package: CriteriaRunner
CriteriaRunner
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| CriteriaRunner(Logger, DataAccessor) |
|
|
|
|
|
||||||||||||||||||||
| lambda$selectByLanguageTag$7(String, OWLClassY) |
|
|
|
|
|
||||||||||||||||||||
| lambda$selectByTypeContainingMember$8(Optional, OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testFindByAttributeValueIn$2(OWLClassD, OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testFindByAttributeValueIn$3(List, OWLClassD) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testJoinOnPluralAttribute$4(OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testJoinOnPluralAttribute$5(OWLClassJ, OWLClassJ) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testOrderBy$1(OWLClassT, OWLClassT) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testSelectUsingMathFloorFunction$6(OWLClassM, OWLClassM) |
|
|
|
|
|
||||||||||||||||||||
| lambda$testSimpleFindAll$0(OWLClassA, OWLClassA) |
|
|
|
|
|
||||||||||||||||||||
| selectByIdAndRelatedAttributeValueIsCommutative() |
|
|
|
|
|
||||||||||||||||||||
| selectByLanguageTag() |
|
|
|
|
|
||||||||||||||||||||
| selectByTypeContainingMember() |
|
|
|
|
|
||||||||||||||||||||
| static {...} |
|
|
|
|
|
||||||||||||||||||||
| testFindByAttributeValueIn() |
|
|
|
|
|
||||||||||||||||||||
| testFindByConjunctionOfAttributes() |
|
|
|
|
|
||||||||||||||||||||
| testFindByConjunctionOfAttributesInList() |
|
|
|
|
|
||||||||||||||||||||
| testFindByDataNotPropertyAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testFindByDataNotPropertyAttributeAndPropertyAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testFindByDataPropertyAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testFindByDisjunctionOfAttributes() |
|
|
|
|
|
||||||||||||||||||||
| testFindByLiteral() |
|
|
|
|
|
||||||||||||||||||||
| testFindByObjectPropertyAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testFindByParameterExpression() |
|
|
|
|
|
||||||||||||||||||||
| testFindByTransitiveAttributeValue() |
|
|
|
|
|
||||||||||||||||||||
| testFindByUnnamedParameterExpression() |
|
|
|
|
|
||||||||||||||||||||
| testJoinOnPluralAttribute() |
|
|
|
|
|
||||||||||||||||||||
| testOrderBy() |
|
|
|
|
|
||||||||||||||||||||
| testQueryOnlyRootWithEmptyWhereClauseWorks() |
|
|
|
|
|
||||||||||||||||||||
| testSelectByIdentifierAndAttributeEquality() |
|
|
|
|
|
||||||||||||||||||||
| testSelectByIdentifierEquality() |
|
|
|
|
|
||||||||||||||||||||
| testSelectByIdentifierInCollection() |
|
|
|
|
|
||||||||||||||||||||
| testSelectUsingMathFloorFunction() |
|
|
|
|
|
||||||||||||||||||||
| testSelectUsingStringUppercaseFunction() |
|
|
|
|
|
||||||||||||||||||||
| testSimpleCount() |
|
|
|
|
|
||||||||||||||||||||
| testSimpleFindAll() |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /*
2: * JOPA
3: * Copyright (C) 2024 Czech Technical University in Prague
4: *
5: * This library is free software; you can redistribute it and/or
6: * modify it under the terms of the GNU Lesser General Public
7: * License as published by the Free Software Foundation; either
8: * version 3.0 of the License, or (at your option) any later version.
9: *
10: * This library is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13: * Lesser General Public License for more details.
14: *
15: * You should have received a copy of the GNU Lesser General Public
16: * License along with this library.
17: */
18: package cz.cvut.kbss.jopa.test.query.runner;
19:
20: import cz.cvut.kbss.jopa.model.query.TypedQuery;
21: import cz.cvut.kbss.jopa.model.query.criteria.CriteriaQuery;
22: import cz.cvut.kbss.jopa.model.query.criteria.ParameterExpression;
23: import cz.cvut.kbss.jopa.model.query.criteria.Predicate;
24: import cz.cvut.kbss.jopa.model.query.criteria.Root;
25: import cz.cvut.kbss.jopa.model.query.criteria.CriteriaBuilder;
26: import cz.cvut.kbss.jopa.test.OWLClassA;
27: import cz.cvut.kbss.jopa.test.OWLClassA_;
28: import cz.cvut.kbss.jopa.test.OWLClassD;
29: import cz.cvut.kbss.jopa.test.OWLClassJ;
30: import cz.cvut.kbss.jopa.test.OWLClassM;
31: import cz.cvut.kbss.jopa.test.OWLClassT;
32: import cz.cvut.kbss.jopa.test.OWLClassY;
33: import cz.cvut.kbss.jopa.test.environment.DataAccessor;
34: import cz.cvut.kbss.jopa.test.environment.Generators;
35: import cz.cvut.kbss.jopa.test.environment.TestEnvironment;
36: import cz.cvut.kbss.jopa.test.query.QueryTestEnvironment;
37: import cz.cvut.kbss.ontodriver.model.LangString;
38: import org.junit.jupiter.api.Test;
39: import org.slf4j.Logger;
40:
41: import java.net.URI;
42: import java.util.ArrayList;
43: import java.util.Comparator;
44: import java.util.List;
45: import java.util.Locale;
46: import java.util.Optional;
47: import java.util.Set;
48: import java.util.stream.Collectors;
49:
50: import static cz.cvut.kbss.jopa.test.environment.util.ContainsSameEntities.containsSameEntities;
51: import static java.util.function.Predicate.not;
52: import static org.hamcrest.MatcherAssert.assertThat;
53: import static org.hamcrest.Matchers.hasItem;
54: import static org.hamcrest.Matchers.lessThanOrEqualTo;
55: import static org.junit.jupiter.api.Assertions.assertEquals;
56: import static org.junit.jupiter.api.Assertions.assertFalse;
57: import static org.junit.jupiter.api.Assertions.assertNotEquals;
58: import static org.junit.jupiter.api.Assertions.assertNotNull;
59: import static org.junit.jupiter.api.Assertions.assertTrue;
60:
61: public abstract class CriteriaRunner extends BaseQueryRunner {
62:
63: protected CriteriaRunner(Logger logger, DataAccessor dataAccessor) {
64: super(logger, dataAccessor);
65: }
66:
67: @Test
68: public void testSimpleFindAll() {
69: final List<OWLClassA> expected = QueryTestEnvironment.getData(OWLClassA.class);
70: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
71: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
72: Root<OWLClassA> root = query.from(OWLClassA.class);
73: query.select(root);
74: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
75: final List<OWLClassA> result = tq.getResultList();
76:
77: assertEquals(expected.size(), result.size());
78:• for (OWLClassA a : result) {
79: assertNotNull(a.getStringAttribute());
80: assertTrue(expected.stream().anyMatch(aa -> aa.getUri().equals(a.getUri())));
81: }
82: }
83:
84: @Test
85: public void testSimpleCount() {
86: final List<OWLClassA> expected = QueryTestEnvironment.getData(OWLClassA.class);
87: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
88: CriteriaQuery<Integer> query = cb.createQuery(Integer.class);
89: Root<OWLClassA> root = query.from(OWLClassA.class);
90: query.select(cb.count(root));
91: final Integer result = getEntityManager().createQuery(query).getSingleResult();
92:
93: assertEquals(expected.size(), result);
94: }
95:
96: @Test
97: public void testFindByDataPropertyAttribute() {
98: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
99: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
100: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
101: Root<OWLClassA> root = query.from(OWLClassA.class);
102: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), expected.getStringAttribute(), "en");
103: query.select(root).where(restriction);
104: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
105: final OWLClassA result = tq.getSingleResult();
106:
107: assertEquals(expected.getUri(), result.getUri());
108: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
109: assertEquals(expected.getTypes(), result.getTypes());
110: }
111:
112: @Test
113: public void testFindByDataNotPropertyAttribute() {
114: final OWLClassA unexpected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
115: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
116: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
117: Root<OWLClassA> root = query.from(OWLClassA.class);
118: Predicate restriction =
119: cb.equal(root.getAttr(OWLClassA_.stringAttribute), unexpected.getStringAttribute(), "en");
120: query.select(root).where(cb.not(restriction));
121: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
122: final List<OWLClassA> result = tq.getResultList();
123:
124:• for (OWLClassA item : result) {
125: assertNotEquals(unexpected.getUri(), item.getUri());
126: assertNotEquals(unexpected.getStringAttribute(), item.getStringAttribute());
127: }
128: }
129:
130: @Test
131: public void testFindByDataNotPropertyAttributeAndPropertyAttribute() {
132: final OWLClassT unexpected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
133: final int intThreshold = QueryTestEnvironment.getData(OWLClassT.class).size() / 2;
134: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
135: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
136: Root<OWLClassT> root = query.from(OWLClassT.class);
137: Predicate firstRestriction = cb.not(cb.equal(root.getAttr("owlClassA"), unexpected.getOwlClassA().getUri()));
138: Predicate secondRestriction = cb.lessThan(root.getAttr("intAttribute"), intThreshold);
139: Predicate restrictions = cb.and(firstRestriction, secondRestriction);
140: query.select(root).where(restrictions);
141: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
142: final List<OWLClassT> result = tq.getResultList();
143:
144: assertFalse(result.isEmpty());
145:• for (OWLClassT item : result) {
146: assertNotEquals(unexpected.getUri(), item.getUri());
147:• assertTrue(intThreshold > item.getIntAttribute());
148: }
149: }
150:
151: @Test
152: public void testFindByObjectPropertyAttribute() {
153: final OWLClassD expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassD.class));
154: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
155: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
156: Root<OWLClassD> root = query.from(OWLClassD.class);
157: Predicate restriction = cb.equal(root.getAttr("owlClassA"), expected.getOwlClassA().getUri());
158: query.select(root).where(restriction);
159: TypedQuery<OWLClassD> tq = getEntityManager().createQuery(query);
160: final OWLClassD result = tq.getSingleResult();
161:
162: assertEquals(expected.getUri(), result.getUri());
163: assertEquals(expected.getOwlClassA().getUri(), result.getOwlClassA().getUri());
164: }
165:
166: @Test
167: public void testFindByConjunctionOfAttributes() {
168: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
169: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
170: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
171: Root<OWLClassT> root = query.from(OWLClassT.class);
172: Predicate firstRestriction = cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri());
173: Predicate secondRestriction = cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute());
174: query.select(root).where(firstRestriction, secondRestriction);
175: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
176: final List<OWLClassT> result = tq.getResultList();
177:
178: assertFalse(result.isEmpty());
179:• for (OWLClassT item : result) {
180: assertEquals(sample.getOwlClassA().getUri(), item.getOwlClassA().getUri());
181: assertThat(item.getIntAttribute(), lessThanOrEqualTo(sample.getIntAttribute()));
182: }
183: }
184:
185: @Test
186: public void testFindByConjunctionOfAttributesInList() {
187: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
188: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
189: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
190: Root<OWLClassT> root = query.from(OWLClassT.class);
191: List<Predicate> restrictions = new ArrayList<>();
192: restrictions.add(cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri()));
193: restrictions.add(cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute()));
194: query.select(root).where(restrictions);
195: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
196: final List<OWLClassT> result = tq.getResultList();
197:
198: assertFalse(result.isEmpty());
199:• for (OWLClassT item : result) {
200: assertEquals(sample.getOwlClassA().getUri(), item.getOwlClassA().getUri());
201: assertThat(item.getIntAttribute(), lessThanOrEqualTo(sample.getIntAttribute()));
202: }
203: }
204:
205: @Test
206: public void testOrderBy() {
207: final List<OWLClassT> expected = QueryTestEnvironment.getData(OWLClassT.class);
208: expected.sort(Comparator.comparing(OWLClassT::getIntAttribute));
209: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
210: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
211: Root<OWLClassT> root = query.from(OWLClassT.class);
212: query.select(root).orderBy(cb.asc(root.getAttr("intAttribute")));
213: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
214: final List<OWLClassT> result = tq.getResultList();
215:
216: assertEquals(expected.size(), result.size());
217:• for (OWLClassT t : result) {
218: assertTrue(expected.stream().anyMatch(tt -> tt.getUri().equals(t.getUri())));
219: }
220: }
221:
222: @Test
223: public void testFindByDisjunctionOfAttributes() {
224: final OWLClassT sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassT.class));
225: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
226: CriteriaQuery<OWLClassT> query = cb.createQuery(OWLClassT.class);
227: Root<OWLClassT> root = query.from(OWLClassT.class);
228: Predicate firstRestriction = cb.equal(root.getAttr("owlClassA"), sample.getOwlClassA().getUri());
229: Predicate secondRestriction = cb.lessThanOrEqual(root.getAttr("intAttribute"), sample.getIntAttribute());
230: query.select(root).where(cb.or(firstRestriction, secondRestriction));
231: TypedQuery<OWLClassT> tq = getEntityManager().createQuery(query);
232: final List<OWLClassT> result = tq.getResultList();
233:
234: assertFalse(result.isEmpty());
235:• for (OWLClassT item : result) {
236: boolean matches = item.getOwlClassA().getUri().equals(sample.getOwlClassA().getUri());
237:• matches |= item.getIntAttribute() <= sample.getIntAttribute();
238: assertTrue(matches);
239: }
240: }
241:
242: @Test
243: public void testFindByTransitiveAttributeValue() {
244: final OWLClassD expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassD.class));
245: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
246: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
247: Root<OWLClassD> root = query.from(OWLClassD.class);
248: Predicate restrictions = cb.equal(root.getAttr("owlClassA").getAttr("stringAttribute"),
249: expected.getOwlClassA().getStringAttribute(), "en");
250: query.select(root).where(restrictions);
251: TypedQuery<OWLClassD> tq = getEntityManager().createQuery(query);
252: final OWLClassD result = tq.getSingleResult();
253:
254: assertEquals(expected.getUri(), result.getUri());
255: assertEquals(expected.getOwlClassA().getUri(), result.getOwlClassA().getUri());
256: }
257:
258: @Test
259: public void testFindByParameterExpression() {
260: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
261: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
262: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
263: Root<OWLClassA> root = query.from(OWLClassA.class);
264: final ParameterExpression<String> strAtt = cb.parameter(String.class, "pOne");
265: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), strAtt);
266: query.select(root).where(restriction);
267: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
268: tq.setParameter(strAtt, expected.getStringAttribute(), "en");
269: final OWLClassA result = tq.getSingleResult();
270:
271: assertEquals(expected.getUri(), result.getUri());
272: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
273: assertEquals(expected.getTypes(), result.getTypes());
274: }
275:
276: @Test
277: public void testFindByUnnamedParameterExpression() {
278: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
279: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
280: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
281: Root<OWLClassA> root = query.from(OWLClassA.class);
282: final ParameterExpression<String> strAtt = cb.parameter(String.class);
283: Predicate restriction = cb.equal(root.getAttr(OWLClassA_.stringAttribute), strAtt);
284: query.select(root).where(restriction);
285: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
286: tq.setParameter(strAtt, expected.getStringAttribute(), "en");
287: final OWLClassA result = tq.getSingleResult();
288:
289: assertEquals(expected.getUri(), result.getUri());
290: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
291: assertEquals(expected.getTypes(), result.getTypes());
292: }
293:
294: @Test
295: public void testFindByLiteral() {
296: final OWLClassA expected = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
297: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
298: CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
299: Root<OWLClassA> root = query.from(OWLClassA.class);
300: Predicate restriction =
301: cb.equal(root.getAttr(OWLClassA_.stringAttribute), cb.literal(expected.getStringAttribute(), "en"));
302: query.select(root).where(restriction);
303: TypedQuery<OWLClassA> tq = getEntityManager().createQuery(query);
304: final OWLClassA result = tq.getSingleResult();
305:
306: assertEquals(expected.getUri(), result.getUri());
307: assertEquals(expected.getStringAttribute(), result.getStringAttribute());
308: assertEquals(expected.getTypes(), result.getTypes());
309: }
310:
311: @Test
312: public void testFindByAttributeValueIn() {
313: final List<OWLClassA> aInstances = QueryTestEnvironment.getData(OWLClassA.class);
314: final List<OWLClassA> matching;
315:• if (Generators.randomBoolean()) {
316: matching = aInstances.subList(0, aInstances.size() / 2);
317: } else {
318: matching = aInstances.subList(aInstances.size() / 2, aInstances.size());
319: }
320: final List<OWLClassD> expected = QueryTestEnvironment.getData(OWLClassD.class).stream()
321: .filter(d -> matching.stream().anyMatch(
322: a -> d.getOwlClassA().getUri().equals(a.getUri())))
323: .collect(Collectors.toList());
324: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
325: CriteriaQuery<OWLClassD> query = cb.createQuery(OWLClassD.class);
326: Root<OWLClassD> root = query.from(OWLClassD.class);
327: query.select(root).where(root.getAttr("owlClassA").in(matching));
328:
329: final List<OWLClassD> result = getEntityManager().createQuery(query).getResultList();
330: assertThat(result, containsSameEntities(expected));
331: }
332:
333: /**
334: * Bug #135
335: */
336: @Test
337: public void testJoinOnPluralAttribute() {
338: final List<OWLClassJ> jInstances = QueryTestEnvironment.getData(OWLClassJ.class);
339: final OWLClassJ matching = Generators.getRandomItem(jInstances);
340: final Set<LangString> stringSet =
341: matching.getOwlClassA().stream()
342: .map(a -> new LangString(a.getStringAttribute(), TestEnvironment.PERSISTENCE_LANGUAGE))
343: .collect(Collectors.toSet());
344:
345: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
346: final CriteriaQuery<OWLClassJ> query = cb.createQuery(OWLClassJ.class);
347: final Root<OWLClassJ> root = query.from(OWLClassJ.class);
348: query.select(root).where(root.getAttr("owlClassA").getAttr("stringAttribute").in(stringSet));
349:
350: final List<OWLClassJ> result = getEntityManager().createQuery(query).getResultList();
351: assertFalse(result.isEmpty());
352: assertTrue(result.stream().anyMatch(j -> j.getUri().equals(matching.getUri())));
353: }
354:
355: @Test
356: public void testQueryOnlyRootWithEmptyWhereClauseWorks() {
357: final List<OWLClassA> aInstances = QueryTestEnvironment.getData(OWLClassA.class);
358: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
359: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
360: final Root<OWLClassA> root = query.from(OWLClassA.class);
361: query.select(root).where();
362:
363: final List<OWLClassA> result = getEntityManager().createQuery(query).getResultList();
364: assertThat(result, containsSameEntities(aInstances));
365: }
366:
367: /**
368: * Enhancement #138
369: */
370: @Test
371: public void testSelectByIdentifierEquality() {
372: final OWLClassA instance = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
373: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
374: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
375: final Root<OWLClassA> root = query.from(OWLClassA.class);
376: query.select(root).where(cb.equal(root.getAttr("uri"), instance.getUri()));
377:
378: final OWLClassA result = getEntityManager().createQuery(query).getSingleResult();
379: assertEquals(instance.getUri(), result.getUri());
380: }
381:
382: /**
383: * Enhancement #138
384: */
385: @Test
386: public void testSelectByIdentifierInCollection() {
387: final List<OWLClassA> matchingInstances = QueryTestEnvironment.getData(OWLClassA.class).subList(0,
388: Generators.randomPositiveInt(2, QueryTestEnvironment.getData(OWLClassA.class).size()));
389: final List<URI> ids = matchingInstances.stream().map(OWLClassA::getUri).collect(Collectors.toList());
390: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
391: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
392: final Root<OWLClassA> root = query.from(OWLClassA.class);
393: query.select(root).where(root.getAttr("uri").in(ids));
394:
395: final List<OWLClassA> result = getEntityManager().createQuery(query).getResultList();
396: assertThat(result, containsSameEntities(matchingInstances));
397: }
398:
399: @Test
400: public void testSelectUsingStringUppercaseFunction() {
401: final List<OWLClassA> instances = QueryTestEnvironment.getData(OWLClassA.class);
402: final OWLClassA sample = Generators.getRandomItem(instances);
403: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
404: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
405: final Root<OWLClassA> root = query.from(OWLClassA.class);
406: final ParameterExpression<String> param = cb.parameter(String.class);
407: query.select(root).where(cb.like(cb.upper(root.getAttr("stringAttribute")), param));
408:
409: final List<OWLClassA> result = getEntityManager().createQuery(query)
410: .setParameter(param,
411: sample.getStringAttribute().substring(0, 5)
412: .toUpperCase(Locale.ROOT) + ".+")
413: .getResultList();
414: assertFalse(result.isEmpty());
415: assertThat(result, hasItem(sample));
416: }
417:
418: @Test
419: public void testSelectUsingMathFloorFunction() {
420: final List<OWLClassM> instances = QueryTestEnvironment.getData(OWLClassM.class);
421: final OWLClassM match = Generators.getRandomItem(instances);
422: final double value = Math.floor(match.getDoubleAttribute());
423: final CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
424: final CriteriaQuery<OWLClassM> query = cb.createQuery(OWLClassM.class);
425: final Root<OWLClassM> root = query.from(OWLClassM.class);
426: final ParameterExpression<Double> param = cb.parameter(Double.class);
427: query.select(root).where(cb.equal(cb.floor(root.getAttr("doubleAttribute")), param));
428:
429: final List<OWLClassM> result = getEntityManager().createQuery(query)
430: .setParameter(param, value)
431: .getResultList();
432: assertFalse(result.isEmpty());
433: assertTrue(result.stream().anyMatch(rm -> rm.getKey().equals(match.getKey())));
434: }
435:
436: @Test
437: public void testSelectByIdentifierAndAttributeEquality() {
438: final OWLClassA instance = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
439: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
440: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
441: final Root<OWLClassA> root = query.from(OWLClassA.class);
442: query.select(root).where(
443: cb.equal(root.getAttr("stringAttribute"), instance.getStringAttribute(), TestEnvironment.PERSISTENCE_LANGUAGE),
444: cb.equal(root.getAttr("uri"), instance.getUri())
445: );
446:
447: final OWLClassA result = getEntityManager().createQuery(query).getSingleResult();
448: assertEquals(instance.getUri(), result.getUri());
449: }
450:
451: /**
452: * Bug #178.
453: */
454: @Test
455: public void selectByIdAndRelatedAttributeValueIsCommutative() {
456: final OWLClassD instance = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassD.class));
457: CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
458: final CriteriaQuery<OWLClassD> queryIdFirst = cb.createQuery(OWLClassD.class);
459: final Root<OWLClassD> rootIdFirst = queryIdFirst.from(OWLClassD.class);
460: queryIdFirst.select(rootIdFirst).where(
461: cb.equal(rootIdFirst.getAttr("uri"), instance.getUri()),
462: cb.equal(rootIdFirst.getAttr("owlClassA").getAttr("stringAttribute"), instance.getOwlClassA()
463: .getStringAttribute(), TestEnvironment.PERSISTENCE_LANGUAGE));
464:
465: final OWLClassD resultIfFirst = getEntityManager().createQuery(queryIdFirst).getSingleResult();
466: assertEquals(instance.getUri(), resultIfFirst.getUri());
467:
468:
469: final CriteriaQuery<OWLClassD> queryIdSecond = cb.createQuery(OWLClassD.class);
470: final Root<OWLClassD> rootIdSecond = queryIdSecond.from(OWLClassD.class);
471: queryIdSecond.select(rootIdSecond).where(
472: cb.equal(rootIdSecond.getAttr("owlClassA").getAttr("stringAttribute"), instance.getOwlClassA()
473: .getStringAttribute(), TestEnvironment.PERSISTENCE_LANGUAGE),
474: cb.equal(rootIdSecond.getAttr("uri"), instance.getUri()));
475: final OWLClassD resultIdSecond = getEntityManager().createQuery(queryIdSecond).getSingleResult();
476: assertEquals(instance.getUri(), resultIdSecond.getUri());
477: }
478:
479: @Test
480: public void selectByLanguageTag() {
481: final String language = Generators.getRandomItem(List.of("de", "cs", "fr"));
482: final List<OWLClassY> expected = QueryTestEnvironment.getData(OWLClassY.class).stream()
483: .filter(y -> y.getSingularString().getLanguages()
484: .contains(language))
485: .collect(Collectors.toList());
486: final CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
487: final CriteriaQuery<OWLClassY> query = cb.createQuery(OWLClassY.class);
488: final Root<OWLClassY> root = query.from(OWLClassY.class);
489: query.select(root).where(cb.equal(cb.lang(root.getAttr("singularString")), language));
490:
491: final List<OWLClassY> result = getEntityManager().createQuery(query).getResultList();
492: assertThat(result, containsSameEntities(expected));
493: }
494:
495: @Test
496: public void selectByTypeContainingMember() {
497: final OWLClassA sample = Generators.getRandomItem(QueryTestEnvironment.getData(OWLClassA.class));
498: final Optional<String> type = sample.getTypes().stream().filter(not(QueryTestEnvironment.COMMON_TYPE::equals)).findFirst();
499:• assert type.isPresent();
500: final CriteriaBuilder cb = getEntityManager().getCriteriaBuilder();
501: final CriteriaQuery<OWLClassA> query = cb.createQuery(OWLClassA.class);
502: final Root<OWLClassA> root = query.from(OWLClassA.class);
503: query.select(root).where(cb.isMember(URI.create(type.get()), root.getAttr("types")));
504:
505: final List<OWLClassA> result = getEntityManager().createQuery(query).getResultList();
506: assertFalse(result.isEmpty());
507: result.forEach(r -> assertThat(r.getTypes(), hasItem(type.get())));
508: }
509: }