public static void createIndex(Cache cache, String... fieldNames) { final LuceneIndexFactory indexFactory = LuceneServiceProvider.get(cache).createIndexFactory(); indexFactory.setFields(fieldNames).create(INDEX_NAME, REGION_NAME); }
private String getMonitorKey(LuceneIndex index) { return index.getRegionPath() + "_" + index.getName(); }
public LuceneIndexMetrics listIndexMetrics(String regionPath, String indexName) { LuceneIndex index = this.service.getIndex(indexName, regionPath); return index == null ? null : getIndexMetrics(index); }
/** * Verify that a query returns the expected map of key-value. Ordering is ignored. */ public static <K> void verifyQueryKeyAndValues(LuceneQuery<K, Object> query, HashMap expectedResults) throws LuceneQueryException { HashMap actualResults = new HashMap<>(); final PageableLuceneQueryResults<K, Object> results = query.findPages(); while (results.hasNext()) { results.next().stream().forEach(struct -> { Object value = struct.getValue(); actualResults.put(struct.getKey(), value); }); } assertEquals(expectedResults, actualResults); }
public static void verifyIndexFinishFlushing(Cache cache, String indexName, String regionName) throws InterruptedException { LuceneService luceneService = LuceneServiceProvider.get(cache); LuceneIndex index = luceneService.getIndex(indexName, regionName); boolean flushed = luceneService.waitUntilFlushed(indexName, regionName, 60000, TimeUnit.MILLISECONDS); assertTrue(flushed); }
private void registerIndex(LuceneIndex index) { String regionAndIndex = getUniqueIndexName(index.getName(), index.getRegionPath()); if (hasIndexBeenDestroyed(regionAndIndex)) { ((InternalLuceneIndex) index).destroy(true); throw new LuceneIndexDestroyedException(index.getName(), index.getRegionPath()); } else { if (!indexMap.containsKey(regionAndIndex)) { indexMap.put(regionAndIndex, index); } definedIndexMap.remove(regionAndIndex); } }
@Override public void execute(FunctionContext<Object> context) { RegionFunctionContext ctx = (RegionFunctionContext) context; ResultSender<Boolean> resultSender = ctx.getResultSender(); Region region = ctx.getDataSet(); Cache cache = region.getCache(); String indexName = (String) ctx.getArguments(); if (indexName == null) { throw new IllegalArgumentException("Missing index name"); } LuceneService luceneService = LuceneServiceProvider.get(cache); LuceneIndex luceneIndex = luceneService.getIndex(indexName, region.getFullPath()); if (luceneIndex == null) { resultSender.lastResult(false); } else { resultSender.lastResult(luceneIndex.isIndexingInProgress()); } }
public LuceneIndexMetrics[] listIndexMetrics(String regionPath) { if (!regionPath.startsWith(Region.SEPARATOR)) { regionPath = Region.SEPARATOR + regionPath; } List<LuceneIndexMetrics> indexMetrics = new ArrayList(); for (LuceneIndex index : this.service.getAllIndexes()) { if (index.getRegionPath().equals(regionPath)) { indexMetrics.add(getIndexMetrics(index)); } } return indexMetrics.toArray(new LuceneIndexMetrics[indexMetrics.size()]); }
@Before public void createCache() { CacheFactory cf = getCacheFactory(); this.cache = cf.create(); luceneService = LuceneServiceProvider.get(this.cache); }
@Override public Collection<Document> toDocuments(LuceneIndex index, Object value) { if (value == null) { return Collections.emptyList(); } LuceneSerializer mapper = getFieldMapper(value, index.getFieldNames()); Collection<Document> docs = mapper.toDocuments(index, value); if (logger.isDebugEnabled()) { logger.debug("HeterogeneousLuceneSerializer.toDocuments:" + docs); } return docs; }
@Test public void shouldParseTopLevelPdxStringField() { String[] fields = new String[] {"status"}; FlatFormatSerializer serializer = new FlatFormatSerializer(); PdxInstance pdx = createPdxInstance(); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, pdx, fields); IndexableField[] fieldsInDoc = doc1.getFields("status"); Collection<Object> results = getResultCollection(fieldsInDoc, false); assertEquals(1, results.size()); assertTrue(results.contains("active")); }
public static Document invokeSerializer(LuceneSerializer mapper, Object object, String[] fields) { LuceneIndex index = Mockito.mock(LuceneIndex.class); Mockito.when(index.getFieldNames()).thenReturn(fields); Collection<Document> docs = mapper.toDocuments(index, object); assertEquals(1, docs.size()); return docs.iterator().next(); } }
private void registerDefinedIndex(final String indexName, final String regionPath, final LuceneIndexCreationProfile luceneIndexCreationProfile) { String regionAndIndex = LuceneServiceImpl.getUniqueIndexName(indexName, regionPath); if (definedIndexMap.containsKey(regionAndIndex) || indexMap.containsKey(regionAndIndex)) { throw new LuceneIndexExistsException(indexName, regionPath); } definedIndexMap.put(regionAndIndex, luceneIndexCreationProfile); }
public LuceneIndexMetrics[] listIndexMetrics() { Collection<LuceneIndex> indexes = this.service.getAllIndexes(); LuceneIndexMetrics[] indexMetrics = new LuceneIndexMetrics[indexes.size()]; int i = 0; for (LuceneIndex index : this.service.getAllIndexes()) { indexMetrics[i++] = getIndexMetrics(index); } return indexMetrics; }
private LuceneIndexCreationProfile getDummySerializerCreationProfile() { return new LuceneIndexCreationProfile(INDEX_NAME, REGION_NAME, new String[] {"field1"}, new StandardAnalyzer(), null, new DummyLuceneSerializer()); }
private void addFieldValueForNonCollectionObject(Document doc, String indexedFieldName, Object fieldValue, List<String> tokenizedFields) { if (tokenizedFields.size() == 1) { SerializerUtil.addField(doc, indexedFieldName, fieldValue); } else { addFieldValue(doc, indexedFieldName, fieldValue, tokenizedFields.subList(1, tokenizedFields.size())); } }
private Query getQuery(final LuceneQueryProvider queryProvider, final LuceneIndex index) { Query query = null; try { query = queryProvider.getQuery(index); } catch (LuceneQueryException e) { logger.warn("", e); throw new FunctionException(e); } return query; }
@Test public void shouldParseSecondTopLevelPdxStringField() { String[] fields = new String[] {"positions.secId"}; FlatFormatSerializer serializer = new FlatFormatSerializer(); PdxInstance pdx = createPdxInstance(); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, pdx, fields); IndexableField[] fieldsInDoc = doc1.getFields("positions.secId"); Collection<Object> results = getResultCollection(fieldsInDoc, false); assertEquals(2, results.size()); assertTrue(results.contains("IBM")); assertTrue(results.contains("AAPL")); }
@Test public void shouldParseSecondTopLevelPdxDoubleField() { String[] fields = new String[] {"positions.sharesOutstanding"}; FlatFormatSerializer serializer = new FlatFormatSerializer(); PdxInstance pdx = createPdxInstance(); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, pdx, fields); IndexableField[] fieldsInDoc = doc1.getFields("positions.sharesOutstanding"); Collection<Object> results = getResultCollection(fieldsInDoc, true); assertEquals(2, results.size()); assertTrue(results.contains(5000.0)); assertTrue(results.contains(4000.0)); }