private SearchRequestBuilder prepareSearch(Query query) { Assert.notNull(query.getIndices(), "No index defined for Query"); Assert.notNull(query.getTypes(), "No type defined for Query"); int startRecord = 0; SearchRequestBuilder searchRequestBuilder = client .prepareSearch(toArray(query.getIndices())) .setSearchType(query.getSearchType()) .setTypes(toArray(query.getTypes())); if (query.getPageable() != null) { startRecord = query.getPageable().getPageNumber() * query.getPageable().getPageSize(); searchRequestBuilder.setSize(query.getPageable().getPageSize()); } searchRequestBuilder.setFrom(startRecord); if (!query.getFields().isEmpty()) { searchRequestBuilder.addFields(toArray(query.getFields())); } if (query.getSort() != null) { for (Sort.Order order : query.getSort()) { searchRequestBuilder.addSort( order.getProperty(), order.getDirection() == Sort.Direction.DESC ? SortOrder.DESC : SortOrder.ASC); } } if (query.getMinScore() > 0) { searchRequestBuilder.setMinScore(query.getMinScore()); } return searchRequestBuilder; }
private <T> MultiGetResponse getMultiResponse(Query searchQuery, Class<T> clazz) { String indexName = isNotEmpty(searchQuery.getIndices()) ? searchQuery.getIndices().get(0) : getPersistentEntityFor(clazz).getIndexName(); String type = isNotEmpty(searchQuery.getTypes()) ? searchQuery.getTypes().get(0) : getPersistentEntityFor(clazz).getIndexType(); Assert.notNull(indexName, "No index defined for Query"); Assert.notNull(type, "No type define for Query"); Assert.notEmpty(searchQuery.getIds(), "No Id define for Query"); MultiGetRequestBuilder builder = client.prepareMultiGet(); for (String id : searchQuery.getIds()) { MultiGetRequest.Item item = new MultiGetRequest.Item(indexName, type, id); if (searchQuery.getRoute() != null) { item = item.routing(searchQuery.getRoute()); } if (searchQuery.getFields() != null && !searchQuery.getFields().isEmpty()) { item = item.fields(toArray(searchQuery.getFields())); } builder.add(item); } return builder.execute().actionGet(); }
/** * Selects all entities matching the given type and {@link Query}. By default, the entities will * be created based on the values within the primary key field for the specified type (this is * usually the desired behavior). * * <p>Example: * * <pre> * manager.find(Person.class, Query.select().where("name LIKE ? OR age > ?", "Joe", 9).limit(10)); * </pre> * * <p>This method delegates the call to {@link #find(Class, String, Query)}, passing the primary * key field for the given type as the <code>String</code> parameter. * * @param type The type of the entities to retrieve. * @param query The {@link Query} instance to be used to determine the results. * @return An array of entities of the given type which match the specified query. */ public <T extends RawEntity<K>, K> T[] find(Class<T> type, Query query) throws SQLException { String selectField = Common.getPrimaryKeyField(type, getFieldNameConverter()); query.resolveFields(type, getFieldNameConverter()); String[] fields = query.getFields(); if (fields.length == 1) { selectField = fields[0]; } return find(type, selectField, query); }
private void assertValues() { if (!valuesToInsert.isEmpty()) { if (columns.isEmpty()) { throw new IllegalStateException("No columns were specified to insert into."); } assertValueSetSizes(columns.size()); } else if (query != null) { if (columns.size() != query.getFields().size()) { throw new IllegalStateException( "Number of properties being selected must match the number of columns " + "specified."); } } else if (!defaultValues) { throw new IllegalStateException("No values to insert were specified."); } }
/** * Selects all entities of the specified type which match the given <code>Query</code>. This * method creates a <code>PreparedStatement</code> using the <code>Query</code> instance specified * against the table represented by the given type. This query is then executed (with the * parameters specified in the query). The method then iterates through the result set and * extracts the specified field, mapping an entity of the given type to each row. This array of * entities is returned. * * @param type The type of the entities to retrieve. * @param field The field value to use in the creation of the entities. This is usually the * primary key field of the corresponding table. * @param query The {@link Query} instance to use in determining the results. * @return An array of entities of the given type which match the specified query. */ public <T extends RawEntity<K>, K> T[] find(Class<T> type, String field, Query query) throws SQLException { List<T> back = new ArrayList<T>(); query.resolveFields(type, getFieldNameConverter()); // <ian> Version version = type.getAnnotation(Version.class); if (version != null && !version.findInitial()) { // Add initial version check to exclude // objects that have only been created and not saved yet. if (query.getWhereClause() == null) { query.where(version.value() + " != ?", version.initial()); } else { // Preserve existing WHERE clause and parameters String whereClause = new StringBuilder() .append(query.getWhereClause()) .append(" AND ") .append(version.value()) .append(" != ?") .toString(); Object[] paramsOld = query.getWhereParams(); Object[] paramsNew = new Object[paramsOld.length + 1]; System.arraycopy(paramsOld, 0, paramsNew, 0, paramsOld.length); paramsNew[paramsNew.length - 1] = version.initial(); query.setWhereClause(whereClause); query.setWhereParams(paramsNew); } } // </ian> Preload preloadAnnotation = type.getAnnotation(Preload.class); if (preloadAnnotation != null) { if (!query.getFields()[0].equals("*") && query.getJoins().isEmpty()) { String[] oldFields = query.getFields(); List<String> newFields = new ArrayList<String>(); for (String newField : preloadAnnotation.value()) { newField = newField.trim(); int fieldLoc = -1; for (int i = 0; i < oldFields.length; i++) { if (oldFields[i].equals(newField)) { fieldLoc = i; break; } } if (fieldLoc < 0) { newFields.add(newField); } else { newFields.add(oldFields[fieldLoc]); } } if (!newFields.contains("*")) { for (String oldField : oldFields) { if (!newFields.contains(oldField)) { newFields.add(oldField); } } } query.setFields(newFields.toArray(new String[newFields.size()])); } } Connection conn = getProvider().getConnection(); try { String sql = null; tableNameConverterLock.readLock().lock(); try { sql = query.toSQL(type, provider, tableNameConverter, getFieldNameConverter(), false); } finally { tableNameConverterLock.readLock().unlock(); } Logger.getLogger("net.java.ao").log(Level.INFO, sql); PreparedStatement stmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); provider.setQueryStatementProperties(stmt, query); query.setParameters(this, stmt); ResultSet res = stmt.executeQuery(); provider.setQueryResultSetProperties(res, query); while (res.next()) { T entity = peer( type, Common.getPrimaryKeyType(type) .pullFromDatabase(this, res, Common.getPrimaryKeyClassType(type), field)); CacheLayer cacheLayer = getProxyForEntity(entity).getCacheLayer(entity); for (String cacheField : query.getCanonicalFields(type, fieldNameConverter)) { cacheLayer.put(cacheField, res.getObject(cacheField)); } back.add(entity); } res.close(); stmt.close(); } finally { conn.close(); } return back.toArray((T[]) Array.newInstance(type, back.size())); }