コード例 #1
0
  public void testAdded() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");

    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    List<Object> found = cacheQuery.list();

    AssertJUnit.assertEquals(2, found.size());
    assert found.contains(person2);
    assert found.contains(person3);
    assert !found.contains(person4) : "This should not contain object person4";

    person4 = new Person();
    person4.setName("Mighty Goat");
    person4.setBlurb("Also eats grass");

    cache1.put("mighty", person4);

    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    found = cacheQuery.list();

    AssertJUnit.assertEquals(3, found.size());
    assert found.contains(person2);
    assert found.contains(person3);
    assert found.contains(person4) : "This should now contain object person4";
  }
コード例 #2
0
  public void testModified() throws Exception {
    prepareTestData();
    assertQueryInterceptorPresent(cache2);

    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("playing");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);

    List<Object> found = cacheQuery.list();

    assert found.size() == 1 : "Expected list of size 1, was of size " + found.size();
    assert found.get(0).equals(person1);

    person1.setBlurb("Likes pizza");
    cache1.put("Navin", person1);

    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("pizza");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);

    found = cacheQuery.list();

    assert found.size() == 1;
    assert found.get(0).equals(person1);
  }
コード例 #3
0
  @SuppressWarnings("unchecked")
  private CapedwarfLogQueryResult fetchCapedwarfRequestLogs(CapedwarfLogQuery logQuery) {
    List<CapedwarfRequestLogs> list;
    int resultCount;
    List<String> requestIds = logQuery.getQuery().getRequestIds();
    if (requestIds.isEmpty()) {
      CacheQuery cacheQuery = createRequestLogsQuery(logQuery);
      list = (List<CapedwarfRequestLogs>) (List) cacheQuery.list();
      resultCount = cacheQuery.getResultSize();
    } else {
      list = new ArrayList<>(requestIds.size());
      for (String requestId : requestIds) {
        CapedwarfRequestLogs requestLogs = (CapedwarfRequestLogs) store.get(requestId);
        if (requestLogs != null) {
          list.add(requestLogs);
        }
      }
      resultCount = list.size();
    }
    for (int i = 0; i < list.size(); i++) {
      CapedwarfRequestLogs capedwarfRequestLogs = list.get(i);
      list.set(i, capedwarfRequestLogs.clone());
    }

    return new CapedwarfLogQueryResult(list, resultCount);
  }
コード例 #4
0
ファイル: LuceneSearch.java プロジェクト: jagazee/teiid-8.7
  public static List<Object> performSearch(
      Select command, Class<?> type, String cacheName, CacheContainerWrapper cache)
      throws TranslatorException {

    LogManager.logTrace(LogConstants.CTX_CONNECTOR, "Using Lucene Searching."); // $NON-NLS-1$

    // Map<?, ?> cache,
    SearchManager searchManager = Search.getSearchManager((Cache<?, ?>) cache.getCache(cacheName));

    QueryBuilder queryBuilder = searchManager.buildQueryBuilderForClass(type).get();

    BooleanJunction<BooleanJunction> junction = queryBuilder.bool();
    boolean createdQueries = buildQueryFromWhereClause(command.getWhere(), junction, queryBuilder);

    Query query = null;
    if (createdQueries) {
      query = junction.createQuery();
    } else {
      query = queryBuilder.all().createQuery();
    }

    CacheQuery cacheQuery = searchManager.getQuery(query, type); // rootNodeType

    List<Object> results = cacheQuery.list();
    if (results == null || results.isEmpty()) {
      return Collections.emptyList();
    }

    return results;
  }
コード例 #5
0
ファイル: KeyTypeTest.java プロジェクト: flashboss/infinispan
  public void testPrimitiveAndStringKeys() {
    String key1 = "key1";
    int key2 = 2;
    byte key3 = (byte) 3;
    float key4 = (float) 4;
    long key5 = (long) 5;
    short key6 = (short) 6;
    boolean key7 = true;
    double key8 = (double) 8;
    char key9 = '9';

    cache.put(key1, person1);
    cache.put(key2, person1);
    cache.put(key3, person1);
    cache.put(key4, person1);
    cache.put(key5, person1);
    cache.put(key6, person1);
    cache.put(key7, person1);
    cache.put(key8, person1);
    cache.put(key9, person1);

    // Going to search the 'blurb' field for 'owns'
    Term term = new Term("blurb", "owns");
    CacheQuery cacheQuery = new QueryFactory(cache, qh).getQuery(new TermQuery(term));
    assert cacheQuery.getResultSize() == 9;

    List<Object> found = cacheQuery.list();
    for (int i = 0; i < 9; i++) {
      assert found.get(i).equals(person1);
    }
  }
コード例 #6
0
  public void testFaceting() throws Exception {
    QueryBuilder queryBuilder = qf.buildQueryBuilderForClass(Car.class).get();

    FacetingRequest request =
        queryBuilder
            .facet()
            .name(facetName)
            .onField(indexFieldName)
            .discrete()
            .createFacetingRequest();

    Query luceneQuery = queryBuilder.all().createQuery();

    CacheQuery query = qf.getQuery(luceneQuery);

    query.getFacetManager().enableFaceting(request);

    List<Facet> facetList = query.getFacetManager().getFacets(facetName);

    assertEquals("Wrong number of facets", 2, facetList.size());

    assertEquals("4000", facetList.get(0).getValue());
    assertEquals(2, facetList.get(0).getCount());
    assertEquals(indexFieldName, facetList.get(0).getFieldName());

    assertEquals("2341", facetList.get(1).getValue());
    assertEquals(1, facetList.get(1).getCount());
    assertEquals(indexFieldName, facetList.get(1).getFieldName());
  }
 private List searchByName(String name, Cache c) {
   SearchManager sm = Search.getSearchManager(c);
   CacheQuery q = sm.getQuery(SEntity.searchByName(name), SEntity.class);
   int resultSize = q.getResultSize();
   List l = q.list();
   assert l.size() == resultSize;
   return q.list();
 }
コード例 #8
0
  @SuppressWarnings("unchecked")
  private void fetchAppLogLines(RequestLogs requestLogs, CapedwarfLogQuery logQuery) {
    CacheQuery query = createAppLogLinesQuery(requestLogs);
    //        FetchOptions fetchOptions = createAppLogFetchOptions(logQuery);

    List<CapedwarfAppLogLine> capedwarfAppLogLines =
        (List<CapedwarfAppLogLine>) (List) query.list();
    for (CapedwarfAppLogLine capedwarfAppLogLine : capedwarfAppLogLines) {
      requestLogs.getAppLogLines().add(capedwarfAppLogLine.getAppLogLine());
    }
  }
コード例 #9
0
 public void simpleIndexTest() throws ParseException {
   cache.put("1", new Person("A Person's Name", "A paragraph containing some text", 75));
   CacheQuery cq = TestQueryHelperFactory.createCacheQuery(cache, "name", "Person");
   assertEquals(1, cq.getResultSize());
   List<Object> l = cq.list();
   assertEquals(1, l.size());
   Person p = (Person) l.get(0);
   assertEquals("A Person's Name", p.getName());
   assertEquals("A paragraph containing some text", p.getBlurb());
   assertEquals(75, p.getAge());
 }
コード例 #10
0
ファイル: PutAllTest.java プロジェクト: jerrinot/infinispan
  public void testOverwriteNotIndexedValue() {
    final long id = 10;

    cache.put(id, new NotIndexedType("name1"));

    Map<Object, Object> map = new HashMap<Object, Object>();
    map.put(id, new TestEntity("name2", "surname2", id, "note"));
    cache.putAll(map);

    CacheQuery q1 = queryByNameField("name2", AnotherTestEntity.class);
    assertEquals(1, q1.getResultSize());
    assertEquals(TestEntity.class, q1.list().get(0).getClass());
  }
コード例 #11
0
 private CacheQuery createAppLogLinesQuery(RequestLogs requestLogs) {
   QueryBuilder queryBuilder =
       searchManager.buildQueryBuilderForClass(CapedwarfAppLogLine.class).get();
   Query query =
       queryBuilder
           .keyword()
           .onField(CapedwarfAppLogLine.REQUEST_ID)
           .matching(requestLogs.getRequestId())
           .createQuery();
   CacheQuery cacheQuery = searchManager.getQuery(query, CapedwarfAppLogLine.class);
   cacheQuery.sort(new Sort(new SortField(CapedwarfAppLogLine.SEQUENCE_NUMBER, SortField.LONG)));
   return cacheQuery;
 }
コード例 #12
0
  private CacheQuery createRequestLogsQuery(CapedwarfLogQuery logQuery) {
    LogQuery query = logQuery.getQuery();
    QueryBuilder queryBuilder =
        searchManager.buildQueryBuilderForClass(CapedwarfRequestLogs.class).get();
    List<Query> queries = new ArrayList<Query>();
    if (query.getStartTimeUsec() != null) {
      queries.add(
          queryBuilder
              .range()
              .onField(CapedwarfRequestLogs.END_TIME_USEC)
              .above(query.getStartTimeUsec())
              .createQuery());
    }
    if (query.getEndTimeUsec() != null) {
      queries.add(
          queryBuilder
              .range()
              .onField(CapedwarfRequestLogs.END_TIME_USEC)
              .below(query.getEndTimeUsec())
              .createQuery());
    }
    if (query.getMinLogLevel() != null) {
      queries.add(
          queryBuilder
              .range()
              .onField(CapedwarfRequestLogs.MAX_LOG_LEVEL)
              .above(query.getMinLogLevel().ordinal())
              .createQuery());
    }

    boolean onlyCompleteRequests = !Boolean.TRUE.equals(query.getIncludeIncomplete());
    if (onlyCompleteRequests) {
      queries.add(
          queryBuilder
              .keyword()
              .onField(CapedwarfRequestLogs.FINISHED)
              .matching(Boolean.TRUE)
              .createQuery());
    }

    Query luceneQuery = getQuery(queryBuilder, queries);
    CacheQuery cacheQuery = searchManager.getQuery(luceneQuery, CapedwarfRequestLogs.class);
    cacheQuery.sort(
        new Sort(new SortField(CapedwarfRequestLogs.END_TIME_USEC, SortField.LONG, true)));
    cacheQuery.firstResult(logQuery.getOptions().getOffset());
    if (logQuery.getOptions().getLimit() != null) {
      cacheQuery.maxResults(logQuery.getOptions().getLimit());
    }
    return cacheQuery;
  }
コード例 #13
0
ファイル: KeyTypeTest.java プロジェクト: flashboss/infinispan
  public void testCustomKeys() {
    CustomKey key1 = new CustomKey(1, 2, 3);
    CustomKey key2 = new CustomKey(900, 800, 700);
    CustomKey key3 = new CustomKey(1024, 2048, 4096);

    cache.put(key1, person1);
    cache.put(key2, person1);
    cache.put(key3, person1);

    Term term = new Term("blurb", "owns");
    CacheQuery cacheQuery = new QueryFactory(cache, qh).getQuery(new TermQuery(term));
    int i;
    assert (i = cacheQuery.getResultSize()) == 3 : "Expected 3, was " + i;
  }
コード例 #14
0
 private void queryTest() {
   cache.put("jekyll", new TestEntity("Henry", "Jekyll", 1, "dissociate identity disorder"));
   cache.put("hyde", new TestEntity("Edward", "Hyde", 2, "dissociate identity disorder"));
   SearchManager sm = Search.getSearchManager(cache);
   Query query =
       sm.buildQueryBuilderForClass(TestEntity.class)
           .get()
           .keyword()
           .onField("name")
           .matching("Henry")
           .createQuery();
   CacheQuery q = sm.getQuery(query);
   assertEquals(1, q.getResultSize());
   assertEquals(TestEntity.class, q.list().get(0).getClass());
 }
コード例 #15
0
  public void testRemoved() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    List<Object> found = cacheQuery.list();

    assert found.size() == 2;
    assert found.contains(person2);
    assert found.contains(person3) : "This should still contain object person3";

    cache1.remove(key3);

    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    found = cacheQuery.list();
  }
コード例 #16
0
  public void testGetResultSize() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("playing");
    cacheQuery = Search.getSearchManager(cache2).getQuery(luceneQuery);
    List<Object> found = cacheQuery.list();

    AssertJUnit.assertEquals(1, found.size());
  }
コード例 #17
0
  public void testSearchKeyTransformer() throws Exception {
    Cache cache1 = caches().get(0);
    Cache cache2 = caches().get(1);

    SearchManager manager = Search.getSearchManager(cache1);
    SearchManager manager1 = Search.getSearchManager(cache2);
    manager.registerKeyTransformer(CustomKey3.class, CustomKey3Transformer.class);
    manager1.registerKeyTransformer(CustomKey3.class, CustomKey3Transformer.class);

    prepareTestedObjects();

    TransactionManager transactionManager = cache1.getAdvancedCache().getTransactionManager();

    CustomKey3 customeKey1 = new CustomKey3(key1);
    CustomKey3 customeKey2 = new CustomKey3(key2);
    CustomKey3 customeKey3 = new CustomKey3(key3);

    // Put the 3 created objects in the cache1.
    if (transactionsEnabled()) transactionManager.begin();
    cache1.put(customeKey1, person1);
    cache1.put(customeKey2, person2);
    cache2.put(customeKey3, person3);
    if (transactionsEnabled()) transactionManager.commit();

    queryParser = createQueryParser("blurb");
    Query luceneQuery = queryParser.parse("Eats");

    CacheQuery cacheQuery = manager.getQuery(luceneQuery);

    ResultIterator found =
        cacheQuery.iterator(new FetchOptions().fetchMode(FetchOptions.FetchMode.LAZY));

    int counter = 0;
    while (found.hasNext()) {
      found.next();
      counter++;
    }

    AssertJUnit.assertEquals(2, counter);
  }
コード例 #18
0
  @Override
  public List<Comment> getCommentsBySongId(String songId) {
    if (songId == null) {
      throw new IllegalArgumentException("Song id is null.");
    }
    ArrayList<Comment> comments = new ArrayList<Comment>();
    commentCache = provider.getCacheContainer().getCache("commentcache");
    SearchManager sm = Search.getSearchManager((Cache<String, Object>) commentCache);
    QueryBuilder queryBuilder = sm.buildQueryBuilderForClass(Comment.class).get();

    Query q = queryBuilder.keyword().onField("songId").matching(songId).createQuery();
    logger.debug("Lucene query: " + q);

    CacheQuery cq = sm.getQuery(q, Comment.class);

    for (Object o : cq.list()) {
      if (o instanceof Comment) {
        comments.add(((Comment) o));
      }
    }
    return comments;
  }
コード例 #19
0
  public void testClear() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");
    luceneQuery = queryParser.parse("eats");
    cacheQuery = Search.getSearchManager(cache1).getQuery(luceneQuery);

    Query[] queries = new Query[2];
    queries[0] = luceneQuery;

    luceneQuery = queryParser.parse("playing");
    queries[1] = luceneQuery;

    Query luceneQuery = queries[0].combine(queries);
    CacheQuery cacheQuery = Search.getSearchManager(cache1).getQuery(luceneQuery);
    AssertJUnit.assertEquals(3, cacheQuery.getResultSize());

    cache2.clear();

    AssertJUnit.assertEquals(3, cacheQuery.getResultSize());
    cacheQuery = Search.getSearchManager(cache1).getQuery(luceneQuery);

    AssertJUnit.assertEquals(0, cacheQuery.getResultSize());
  }
コード例 #20
0
  public void testSimple() throws Exception {
    prepareTestData();
    cacheQuery = createCacheQuery(cache2, "blurb", "playing");

    List<Object> found = cacheQuery.list();

    assert found.size() == 1;

    if (found.get(0) == null) {
      log.warn("found.get(0) is null");
      Person p1 = cache2.get(key1);
      if (p1 == null) {
        log.warn("Person p1 is null in sc2 and cannot actually see the data of person1 in sc1");
      } else {
        log.trace("p1 name is  " + p1.getName());
      }
    }

    assert found.get(0).equals(person1);
  }
コード例 #21
0
  public void testFullTextFilterOnOff() throws Exception {
    prepareTestData();
    queryParser = createQueryParser("blurb");
    Query luceneQuery = queryParser.parse("eats");

    CacheQuery query = Search.getSearchManager(cache1).getQuery(luceneQuery);
    FullTextFilter filter = query.enableFullTextFilter("personFilter");
    filter.setParameter("blurbText", "cheese");

    AssertJUnit.assertEquals(1, query.getResultSize());
    List result = query.list();

    Person person = (Person) result.get(0);
    AssertJUnit.assertEquals("MiniGoat", person.getName());
    AssertJUnit.assertEquals("Eats cheese", person.getBlurb());

    // Disabling the fullTextFilter.
    query.disableFullTextFilter("personFilter");
    AssertJUnit.assertEquals(2, query.getResultSize());
  }
コード例 #22
0
  @Test
  public void testIndexAndQuery() throws Exception {
    SearchManager searchManager = Search.getSearchManager(cache);

    cache.put(123405, new Bond(new Date(System.currentTimeMillis()), 450L));
    assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Bond.class);

    cache.put(123502, new Debenture("GB", 116d));
    assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Debenture.class);

    cache.put(223456, new Bond(new Date(System.currentTimeMillis()), 550L));
    assertEfficientIndexingUsed(searchManager.unwrap(SearchIntegrator.class), Bond.class);

    CacheQuery query = searchManager.getQuery(new MatchAllDocsQuery(), Bond.class, Debenture.class);
    assertEquals(query.list().size(), 3);

    CacheQuery queryBond = searchManager.getQuery(new MatchAllDocsQuery(), Bond.class);
    assertEquals(queryBond.getResultSize(), 2);

    CacheQuery queryDeb = searchManager.getQuery(new MatchAllDocsQuery(), Debenture.class);
    assertEquals(queryDeb.getResultSize(), 1);
  }
コード例 #23
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;
  }
コード例 #24
0
 protected int countIndex() {
   SearchManager searchManager = Search.getSearchManager(cache1);
   CacheQuery q = searchManager.getQuery(new MatchAllDocsQuery(), Transaction.class);
   return q.getResultSize();
 }