Пример #1
0
  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;
  }
Пример #2
0
  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;
  }
Пример #3
0
  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;
  }
Пример #4
0
  /** 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;
  }