private QueryResponse makeResponse(Query q) {
List<?> list = q.list();
int numResults = list.size();
String[] projection = ((BaseQuery) q).getProjection();
int projSize = projection != null ? projection.length : 0;
List<WrappedMessage> results =
new ArrayList<WrappedMessage>(projSize == 0 ? numResults : numResults * projSize);
for (Object o : list) {
if (projSize == 0) {
results.add(new WrappedMessage(o));
} else {
Object[] row = (Object[]) o;
for (int j = 0; j < projSize; j++) {
results.add(new WrappedMessage(row[j]));
}
}
}
QueryResponse response = new QueryResponse();
response.setTotalResults(q.getResultSize());
response.setNumResults(numResults);
response.setProjectionSize(projSize);
response.setResults(results);
return response;
}
private List<Object> executeQuery() {
List<Object> results;
QueryOperation op = cache.getOperationsFactory().newQueryOperation(this);
QueryResponse response = op.execute();
totalResults = (int) response.getTotalResults();
if (response.getProjectionSize() > 0) {
results = new ArrayList<Object>(response.getResults().size() / response.getProjectionSize());
Iterator<WrappedMessage> it = response.getResults().iterator();
while (it.hasNext()) {
Object[] row = new Object[response.getProjectionSize()];
for (int i = 0; i < response.getProjectionSize(); i++) {
row[i] = it.next().getValue();
}
results.add(row);
}
} else {
results = new ArrayList<Object>(response.getResults().size());
SerializationContext serCtx = getSerializationContext();
for (WrappedMessage r : response.getResults()) {
try {
byte[] bytes = (byte[]) r.getValue();
Object o = ProtobufUtil.fromWrappedByteArray(serCtx, bytes);
results.add(o);
} catch (IOException e) {
throw new HotRodClientException(e);
}
}
}
return results;
}
private QueryResponse executeNonIndexedQuery(
AdvancedCache<byte[], byte[]> cache, SerializationContext serCtx, QueryRequest request)
throws IOException {
boolean compatMode = cache.getCacheConfiguration().compatibility().enabled();
Class<? extends Matcher> matcherImplClass =
compatMode ? CompatibilityReflectionMatcher.class : ProtobufMatcher.class;
EmbeddedQuery eq =
new EmbeddedQuery(
cache,
request.getJpqlString(),
request.getStartOffset(),
request.getMaxResults(),
matcherImplClass);
List<?> list = eq.list();
int projSize = 0;
if (eq.getProjection() != null && eq.getProjection().length > 0) {
projSize = eq.getProjection().length;
}
List<WrappedMessage> results =
new ArrayList<WrappedMessage>(projSize == 0 ? list.size() : list.size() * projSize);
for (Object o : list) {
if (projSize == 0) {
if (compatMode) {
// if we are in compat mode then this is the real object so need to marshall it first
o = ProtobufUtil.toWrappedByteArray(serCtx, o);
}
results.add(new WrappedMessage(o));
} else {
Object[] row = (Object[]) o;
for (int j = 0; j < projSize; j++) {
results.add(new WrappedMessage(row[j]));
}
}
}
QueryResponse response = new QueryResponse();
response.setTotalResults(eq.getResultSize());
response.setNumResults(list.size());
response.setProjectionSize(projSize);
response.setResults(results);
return response;
}
/** Execute Lucene index query. */
private QueryResponse executeQuery(
AdvancedCache<byte[], byte[]> cache, SerializationContext serCtx, QueryRequest request) {
final SearchManager searchManager = Search.getSearchManager(cache);
final SearchIntegrator searchFactory = searchManager.getSearchFactory();
final QueryCache queryCache = ComponentRegistryUtils.getQueryCache(cache); // optional component
LuceneQueryParsingResult parsingResult;
Query luceneQuery;
if (queryCache != null) {
KeyValuePair<String, Class> queryCacheKey =
new KeyValuePair<String, Class>(request.getJpqlString(), LuceneQueryParsingResult.class);
parsingResult = queryCache.get(queryCacheKey);
if (parsingResult == null) {
parsingResult = parseQuery(cache, serCtx, request.getJpqlString(), searchFactory);
queryCache.put(queryCacheKey, parsingResult);
}
} else {
parsingResult = parseQuery(cache, serCtx, request.getJpqlString(), searchFactory);
}
luceneQuery = parsingResult.getQuery();
if (!cache.getCacheConfiguration().compatibility().enabled()) {
// restrict on entity type
QueryBuilder qb =
searchFactory.buildQueryBuilder().forEntity(parsingResult.getTargetEntity()).get();
luceneQuery =
qb.bool()
.must(
qb.keyword()
.onField(TYPE_FIELD_NAME)
.ignoreFieldBridge()
.ignoreAnalyzer()
.matching(parsingResult.getTargetEntityName())
.createQuery())
.must(luceneQuery)
.createQuery();
}
CacheQuery cacheQuery = searchManager.getQuery(luceneQuery, parsingResult.getTargetEntity());
if (parsingResult.getSort() != null) {
cacheQuery = cacheQuery.sort(parsingResult.getSort());
}
int projSize = 0;
if (parsingResult.getProjections() != null && !parsingResult.getProjections().isEmpty()) {
projSize = parsingResult.getProjections().size();
cacheQuery =
cacheQuery.projection(parsingResult.getProjections().toArray(new String[projSize]));
}
if (request.getStartOffset() > 0) {
cacheQuery = cacheQuery.firstResult((int) request.getStartOffset());
}
if (request.getMaxResults() > 0) {
cacheQuery = cacheQuery.maxResults(request.getMaxResults());
}
List<?> list = cacheQuery.list();
List<WrappedMessage> results =
new ArrayList<WrappedMessage>(projSize == 0 ? list.size() : list.size() * projSize);
for (Object o : list) {
if (projSize == 0) {
results.add(new WrappedMessage(o));
} else {
Object[] row = (Object[]) o;
for (int j = 0; j < projSize; j++) {
results.add(new WrappedMessage(row[j]));
}
}
}
QueryResponse response = new QueryResponse();
response.setTotalResults(cacheQuery.getResultSize());
response.setNumResults(list.size());
response.setProjectionSize(projSize);
response.setResults(results);
return response;
}
