/** * Creates a ObjectSelect that fetches data for an {@link ObjEntity} * determined from a provided class and uses provided expression for its * qualifier. */ public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType, Expression expression) { return query(entityType).fetchDataRows().where(expression); }
/** * Appends a qualifier expression of this query. An equivalent to * {@link #and(Expression...)} that can be used a syntactic sugar. * * @return this object */ public ObjectSelect<T> where(Expression expression) { return and(expression); }
/** * Creates a ObjectSelect that fetches data for {@link ObjEntity} determined * from provided "entityName", but fetches the result of a provided type. * This factory method is most often used with generic classes that by * themselves are not enough to resolve the entity to fetch. */ public static <T> ObjectSelect<T> query(Class<T> resultType, String entityName) { return new ObjectSelect<T>().entityName(entityName); }
/** * Creates a ObjectSelect that selects objects of a given persistent class * and uses provided expression for its qualifier. */ public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression, List<Ordering> orderings) { return new ObjectSelect<T>().entityType(entityType).where(expression).orderBy(orderings); }
/** * Creates a ObjectSelect that selects objects of a given persistent class * and uses provided expression for its qualifier. */ public static <T> ObjectSelect<T> query(Class<T> entityType, Expression expression) { return new ObjectSelect<T>().entityType(entityType).where(expression); }
private Map<TargetAttribute, Map<Object, Object>> fetchRelated( ObjectContext context, Map<TargetAttribute, Set<Object>> fkMap) { if (fkMap.isEmpty()) { return Collections.emptyMap(); } // map of *path* to map of *pk* to *object*... Map<TargetAttribute, Map<Object, Object>> related = new HashMap<>(); fkMap.forEach((a, fks) -> { if (!fks.isEmpty()) { TargetAttribute relatedPk = a.getForeignKey().get().getTarget(); String relatedPath = relatedPk.getNormalizedPath().substring(ASTDbPath.DB_PREFIX.length()); String relatedEntityName = relatedPk.getEntity().getName(); Map<Object, Object> relatedFetched = new HashMap<>((int) (fks.size() / 0.75)); ObjectSelect .query(Object.class) .entityName(relatedEntityName) .where(ExpressionFactory.inDbExp(relatedPath, fks)) .select(context) // map by fk value (which is a PK of the matched object of course) .forEach(r -> relatedFetched.put(Cayenne.pkForObject((Persistent) r), r)); related.put(a, relatedFetched); } }); return related; }
@SuppressWarnings("unchecked") public static <A> A findById(ObjectContext context, Class<A> type, AgEntity<?> agEntity, Object id) { ObjEntity entity = context.getEntityResolver().getObjEntity(type); // sanity checking... if (entity == null) { throw new AgException(Status.INTERNAL_SERVER_ERROR, "Unknown entity class: " + type); } if (id == null) { throw new AgException(Status.BAD_REQUEST, "No id specified"); } if (id instanceof Map) { Map<String, Object> ids = (Map<String, Object>) id; ObjectSelect<A> query = ObjectSelect.query(type); for (Map.Entry<String, Object> entry : ids.entrySet()) { query.and(ExpressionFactory.matchDbExp( entity.getDbEntity().getAttribute(entry.getKey()).getName(), entry.getValue() )); } return query.selectOne(context); } else { AgAttribute attribute = agEntity.getIds().iterator().next(); return ObjectSelect.query(type, new ASTEqual(attribute.getPathExp(), id)).selectOne(context); } } }
@Test public void testPost_SingleId() { Response response1 = target("/single-id") .queryParam("exclude", "age", "description") .request() .post(Entity.json("{\"id\":\"John\"}")); assertEquals(Response.Status.CREATED.getStatusCode(), response1.getStatus()); E20 e20 = ObjectSelect.query(E20.class).selectFirst(newContext()); assertNotNull(e20); assertEquals("John", e20.getName()); assertEquals("{\"data\":[{\"id\":\"John\",\"name\":\"John\"}],\"total\":1}", response1.readEntity(String.class)); Response response2 = target("/single-id").queryParam("exclude", "age", "description").request().post( Entity.json("{\"id\":\"John\"}")); assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response2.getStatus()); assertTrue(response2.readEntity(String.class).contains("object already exists")); }
public List<T> match(ObjectContext context, Map<Object, Map<String, Object>> mappedSegment) { Collection<Object> keys = mappedSegment.keySet(); List<Expression> expressions = new ArrayList<>(keys.size()); for (Object key : keys) { Expression e = mapper.expressionForKey(key); if (e != null) { expressions.add(e); } } // no keys (?) if (expressions.isEmpty()) { return Collections.emptyList(); } else { return ObjectSelect.query(type).where(ExpressionFactory.or(expressions)).select(context); } } }
/** * Creates a ObjectSelect that fetches data for an {@link ObjEntity} * determined from a provided class. */ public static ObjectSelect<DataRow> dataRowQuery(Class<?> entityType) { return query(entityType).fetchDataRows(); }
/** * Creates a ObjectSelect that fetches DataRows for a {@link DbEntity} * determined from provided "dbEntityName" and uses provided expression for * its qualifier. * * @return this object */ public static ObjectSelect<DataRow> dbQuery(String dbEntityName, Expression expression) { return new ObjectSelect<DataRow>().fetchDataRows().dbEntityName(dbEntityName).where(expression); }
private Map<?, ?> toMap_AttchedObject_MultiStepPath(ObjectContext context, Persistent persistent) { Iterator<CayenneMapEntry> pathComponents = Cayenne.getObjEntity(persistent).getDbEntity() .resolvePathComponents(this); LinkedList<DbRelationship> reversedPathComponents = new LinkedList<>(); while (pathComponents.hasNext()) { CayenneMapEntry component = pathComponents.next(); if (component instanceof DbRelationship) { DbRelationship rel = (DbRelationship) component; DbRelationship reverseRelationship = rel.getReverseRelationship(); if (reverseRelationship == null) { reverseRelationship = rel.createReverseRelationship(); } reversedPathComponents.addFirst(reverseRelationship); } else { break; // an attribute can only occur at the end of the path } } DbEntity finalEntity = reversedPathComponents.get(0).getSourceEntity(); StringBuilder reversedPathStr = new StringBuilder(); for (int i = 0; i < reversedPathComponents.size(); i++) { reversedPathStr.append(reversedPathComponents.get(i).getName()); if (i < reversedPathComponents.size() - 1) { reversedPathStr.append('.'); } } return ObjectSelect.dbQuery(finalEntity.getName()) .where(ExpressionFactory.matchDbExp(reversedPathStr.toString(), persistent)).selectOne(context); }
/** * Creates a ObjectSelect that fetches DataRows for a {@link DbEntity} * determined from provided "dbEntityName". */ public static ObjectSelect<DataRow> dbQuery(String dbEntityName) { return new ObjectSelect<DataRow>().fetchDataRows().dbEntityName(dbEntityName); }
/** * Creates a ObjectSelect that selects objects of a given persistent class. */ public static <T> ObjectSelect<T> query(Class<T> entityType) { return new ObjectSelect<T>().entityType(entityType); }
public ObjectSelect<T> cacheStrategy(QueryCacheStrategy strategy, String cacheGroup) { return cacheStrategy(strategy).cacheGroup(cacheGroup); }
@Test public void testPost_MultiId() { Response response1 = target("/multi-id").queryParam("exclude", "description").request().post( Entity.json("{\"id\":{\"age\":18,\"name\":\"John\"}}")); assertEquals(Response.Status.CREATED.getStatusCode(), response1.getStatus()); E21 e21 = ObjectSelect.query(E21.class).selectFirst(newContext()); assertNotNull(e21); assertEquals(Integer.valueOf(18), e21.getAge()); assertEquals("John", e21.getName()); assertEquals("{\"data\":[{\"id\":{\"age\":18,\"name\":\"John\"},\"age\":18,\"name\":\"John\"}],\"total\":1}", response1.readEntity(String.class)); Response response2 = target("/multi-id").queryParam("exclude", "description").request().post( Entity.json("{\"id\":{\"age\":18,\"name\":\"John\"}}")); assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response2.getStatus()); assertTrue(response2.readEntity(String.class).contains("object already exists")); }
@Test public void testPost() { ObjectContext context = newContext(); Response response1 = target("/e4").request() .post(Entity.json("{\"cVarchar\":\"zzz\"}")); assertEquals(Status.CREATED.getStatusCode(), response1.getStatus()); E4 e41 = ObjectSelect.query(E4.class).selectFirst(context); assertNotNull(e41); Assert.assertEquals("zzz", e41.getCVarchar()); int id1 = Cayenne.intPKForObject(e41); assertEquals( "{\"data\":[{\"id\":" + id1 + ",\"cBoolean\":null,\"cDate\":null,\"cDecimal\":null,\"cInt\":null," + "\"cTime\":null,\"cTimestamp\":null,\"cVarchar\":\"zzz\"}],\"total\":1}", response1.readEntity(String.class)); Response response2 = target("/e4").request() .post(Entity.json("{\"cVarchar\":\"TTTT\"}")); assertEquals(Status.CREATED.getStatusCode(), response2.getStatus()); List<E4> e4s = context.select(new SelectQuery<E4>(E4.class)); assertEquals(2, e4s.size()); assertTrue(e4s.remove(e41)); E4 e42 = e4s.get(0); Assert.assertEquals("TTTT", e42.getCVarchar()); int id2 = Cayenne.intPKForObject(e42); assertEquals( "{\"data\":[{\"id\":" + id2 + ",\"cBoolean\":null,\"cDate\":null,\"cDecimal\":null,\"cInt\":null," + "\"cTime\":null,\"cTimestamp\":null,\"cVarchar\":\"TTTT\"}],\"total\":1}", response2.readEntity(String.class)); }
/** * AND's provided expressions to the existing WHERE clause expression. * * @return this object */ public ObjectSelect<T> and(Expression... expressions) { if (expressions == null || expressions.length == 0) { return this; } return and(Arrays.asList(expressions)); }
/** * Appends a qualifier expression of this query, using provided expression * String and an array of position parameters. This is an equivalent to * calling "and". * * @return this object */ public ObjectSelect<T> where(String expressionString, Object... parameters) { return and(ExpressionFactory.exp(expressionString, parameters)); }