/** * Creates a query that selects DataRows and uses default routing. */ public static SQLSelect<DataRow> dataRowQuery(String sql) { return new SQLSelect<>(sql); }
public SQLSelect<T> cacheStrategy(QueryCacheStrategy strategy, String cacheGroup) { return cacheStrategy(strategy).cacheGroup(cacheGroup); }
/** * Equivalent of setting {@link CapsStrategy#LOWER} */ public SQLSelect<T> lowerColumnNames() { return columnNameCaps(CapsStrategy.LOWER); }
@Override public RowReader getReader(Map<String, ?> parameters) { // TODO: fetching DataRows and then converting them to Object[] is kind // of expensive... maybe we can create Object[] bypassing DR, ideally by // iterating a JDBC ResultSet SQLSelect<DataRow> select = SQLSelect.dataRowQuery(sqlTemplate); select.params(parameters); switch (capsStrategy) { case LOWER: select.lowerColumnNames(); break; case UPPER: select.upperColumnNames(); break; case DEFAULT: select.upperColumnNames(); break; } return new JdbcRowReader(attributes, context.iterator(select)); } }
@Test public void testRelate_ToMany_New() { insert("e2", "id, name", "24, 'xxx'"); Response response = target("/e2/24/e3s") .request() .post(Entity.json("{\"name\":\"zzz\"}")); assertEquals(Status.OK.getStatusCode(), response.getStatus()); assertEquals("{\"data\":[{REPLACED_ID,\"name\":\"zzz\",\"phoneNumber\":null}],\"total\":1}", response.readEntity(String.class).replaceFirst("\"id\":[\\d]+", "REPLACED_ID")); assertEquals(1, intForQuery("SELECT count(1) FROM utest.e3")); DataRow row = SQLSelect.dataRowQuery("SELECT e2_id, name FROM utest.e3").lowerColumnNames() .selectOne(newContext()); assertEquals("zzz", row.get("name")); assertEquals(24, row.get("e2_id")); }
template.setFetchingDataRows(isFetchingDataRows()); template.setRoot(root); template.setDefaultTemplate(getSql()); template.setCacheGroup(cacheGroup); template.setCacheStrategy(cacheStrategy); template.setStatementFetchSize(statementFetchSize); if (isFetchingScalars()) { SQLResult resultMap = new SQLResult(); resultMap.addColumnResult("x");
public SQLSelect<T> params(String name, Object value) { params(Collections.singletonMap(name, value)); return this; }
/** * Instructs Cayenne to look for query results in the "shared" cache when * running the query. This is a short-hand notation for: * * <pre> * query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE, cacheGroup); * </pre> */ public SQLSelect<T> sharedCache(String cacheGroup) { return cacheStrategy(QueryCacheStrategy.SHARED_CACHE, cacheGroup); }
@Test public void testRelate_ToMany_New_CompoundId() { insert("e17", "id1, id2, name", "1, 1, 'aaa'"); Response response = target("/e17/e18s") .matrixParam("parentId1", 1) .matrixParam("parentId2", 1) .request() .post(Entity.json("{\"name\":\"xxx\"}")); assertEquals(Status.OK.getStatusCode(), response.getStatus()); assertEquals("{\"data\":[{REPLACED_ID,\"name\":\"xxx\"}],\"total\":1}", response.readEntity(String.class).replaceFirst("\"id\":[\\d]+", "REPLACED_ID")); assertEquals(1, intForQuery("SELECT count(1) FROM utest.e18")); DataRow row = SQLSelect.dataRowQuery("SELECT e17_id1, e17_id2, name FROM utest.e18").lowerColumnNames() .selectOne(newContext()); assertEquals("xxx", row.get("name")); assertEquals(1, row.get("e17_id1")); assertEquals(1, row.get("e17_id2")); }
/** * Instructs Cayenne to look for query results in the "shared" cache when * running the query. This is a short-hand notation for: * * <pre> * query.cacheStrategy(QueryCacheStrategy.SHARED_CACHE); * </pre> */ public SQLSelect<T> sharedCache() { return cacheStrategy(QueryCacheStrategy.SHARED_CACHE); }
/** * Creates a query that selects scalar values and uses default routing. */ public static <T> SQLSelect<T> scalarQuery(Class<T> type, String sql) { SQLSelect<T> query = new SQLSelect<>(sql); query.scalarType = type; return query; }
/** * Instructs Cayenne to look for query results in the "local" cache when * running the query. This is a short-hand notation for: * * <pre> * query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE); * </pre> */ public SQLSelect<T> localCache() { return cacheStrategy(QueryCacheStrategy.LOCAL_CACHE); }
/** * Equivalent of setting {@link CapsStrategy#UPPER} */ public SQLSelect<T> upperColumnNames() { return columnNameCaps(CapsStrategy.UPPER); }
/** * Creates a query that selects DataObjects. */ public static <T> SQLSelect<T> query(Class<T> type, String sql) { return new SQLSelect<>(type, sql); }
/** * Instructs Cayenne to look for query results in the "local" cache when * running the query. This is a short-hand notation for: * * <pre> * query.cacheStrategy(QueryCacheStrategy.LOCAL_CACHE, cacheGroup); * </pre> */ public SQLSelect<T> localCache(String cacheGroup) { return cacheStrategy(QueryCacheStrategy.LOCAL_CACHE, cacheGroup); }
/** * Creates a query that selects DataRows and uses routing based on the * provided DataMap name. */ public static SQLSelect<DataRow> dataRowQuery(String dataMapName, String sql) { SQLSelect<DataRow> query = new SQLSelect<>(sql); query.dataMapName = dataMapName; return query; }
/** * Creates a query that selects scalar values and uses routing based on the * provided DataMap name. */ public static <T> SQLSelect<T> scalarQuery(Class<T> type, String dataMapName, String sql) { SQLSelect<T> query = new SQLSelect<>(sql); query.dataMapName = dataMapName; query.scalarType = type; return query; }