private Object getFieldValue( IndexableField field ) { Number numericFieldValue = field.numericValue(); return numericFieldValue != null ? numericFieldValue : field.stringValue(); }
/** Returns the string value of the field with the given name if any exist in * this document, or null. If multiple fields exist with this name, this * method returns the first value added. If only binary fields with this name * exist, returns null. * For a numeric {@link StoredField} it returns the string value of the number. If you want * the actual numeric field instance back, use {@link #getField}. */ public final String get(String name) { for (IndexableField field : fields) { if (field.name().equals(name) && field.stringValue() != null) { return field.stringValue(); } } return null; }
/** * Extract the Apache Geode key term from a lucene document */ public static Term getKeyTerm(Document doc) { IndexableField field = doc.getField(KEY_FIELD); if (field.stringValue() != null) { return new Term(KEY_FIELD, field.stringValue()); } else { return new Term(KEY_FIELD, field.binaryValue()); } }
/** * Extract the Apache Geode key from a lucene document */ public static Object getKey(Document doc) { IndexableField field = doc.getField(KEY_FIELD); if (field.stringValue() != null) { return field.stringValue(); } else { return keyFromBytes(field.binaryValue()); } }
private Collection<Object> getResultCollection(IndexableField[] fieldsInDoc, boolean isNumeric) { Collection<Object> results = new LinkedHashSet(); for (IndexableField field : fieldsInDoc) { if (isNumeric) { results.add((Object) field.numericValue()); } else { results.add(field.stringValue()); } } return results; } }
private Collection<Object> getResultCollection(IndexableField[] fieldsInDoc, boolean isNumeric) { Collection<Object> results = new LinkedHashSet(); for (IndexableField field : fieldsInDoc) { if (isNumeric) { results.add((Object) field.numericValue()); } else { results.add(field.stringValue()); } } return results; } }
private void removeFromCache( long entityId ) throws IOException { IndexSearcher searcher = searcherManager.acquire(); try { Query query = type.idTermQuery( entityId ); TopDocs docs = searcher.search( query, 1 ); if ( docs.totalHits > 0 ) { Document document = searcher.doc( docs.scoreDocs[0].doc ); for ( IndexableField field : document.getFields() ) { String key = field.name(); Object value = field.stringValue(); removeFromCache( entityId, key, value ); } } } finally { searcherManager.release( searcher ); } }
@Test void readAllDocuments() { LuceneAllDocumentsReader allDocumentsReader = createAllDocumentsReader(); List<Document> documents = Iterators.asList( allDocumentsReader.iterator() ); assertEquals( 3, documents.size(), "Should have 1 document from first partition and 2 from second one." ); assertEquals( "1", documents.get( 0 ).getField( "value" ).stringValue() ); assertEquals( "3", documents.get( 1 ).getField( "value" ).stringValue() ); assertEquals( "4", documents.get( 2 ).getField( "value" ).stringValue() ); }
@Test public void testIgnoreMissing() { String[] fields = new String[] {"s", "i", "s2", "o"}; PdxLuceneSerializer mapper = new PdxLuceneSerializer(); PdxInstance pdxInstance = mock(PdxInstance.class); when(pdxInstance.hasField("s")).thenReturn(true); when(pdxInstance.hasField("i")).thenReturn(true); when(pdxInstance.hasField("o")).thenReturn(true); when(pdxInstance.hasField("o2")).thenReturn(true); when(pdxInstance.getField("s")).thenReturn("a"); when(pdxInstance.getField("i")).thenReturn(5); when(pdxInstance.getField("o")).thenReturn(new Object()); when(pdxInstance.getField("o2")).thenReturn(new Object()); Document doc = invokeSerializer(mapper, pdxInstance, fields); assertEquals(2, doc.getFields().size()); assertEquals("a", doc.getField("s").stringValue()); assertEquals(5, doc.getField("i").numericValue()); }
@Test public void testNullField() { String[] fields = new String[] {"s", "i"}; PdxLuceneSerializer mapper = new PdxLuceneSerializer(); PdxInstance pdxInstance = mock(PdxInstance.class); when(pdxInstance.hasField("s")).thenReturn(true); when(pdxInstance.hasField("i")).thenReturn(true); when(pdxInstance.getField("s")).thenReturn("a"); when(pdxInstance.getField("i")).thenReturn(null); Document doc = invokeSerializer(mapper, pdxInstance, fields); assertEquals(1, doc.getFields().size()); assertEquals("a", doc.getField("s").stringValue()); assertNull(doc.getField("i")); } }
@Test public void testWriteFields() { String[] fields = new String[] {"s", "i"}; PdxLuceneSerializer mapper = new PdxLuceneSerializer(); PdxInstance pdxInstance = mock(PdxInstance.class); when(pdxInstance.hasField("s")).thenReturn(true); when(pdxInstance.hasField("i")).thenReturn(true); when(pdxInstance.getField("s")).thenReturn("a"); when(pdxInstance.getField("i")).thenReturn(5); Document doc = invokeSerializer(mapper, pdxInstance, fields); assertEquals(2, doc.getFields().size()); assertEquals("a", doc.getField("s").stringValue()); assertEquals(5, doc.getField("i").numericValue()); }
@Test public void shouldParseRegionValueFieldForString() { String[] fields = new String[] {"name", "contacts.name", "contacts.email", "contacts.revenue", "contacts.address", "contacts.homepage.id", "contacts.homepage.title", "contacts.homepage.content", LuceneService.REGION_VALUE_FIELD}; FlatFormatSerializer serializer = new FlatFormatSerializer(); String str = new String("Hello world"); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, str, fields); assertEquals(1, doc1.getFields().size()); assertEquals("Hello world", doc1.getField(LuceneService.REGION_VALUE_FIELD).stringValue()); }
@Test public void testIgnoreInvalid() { String[] fields = new String[] {"s", "o", "s2"}; ReflectionLuceneSerializer mapper = new ReflectionLuceneSerializer(Type2.class, fields); Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, "b"); Document doc = invokeSerializer(mapper, type2, fields); assertEquals(2, doc.getFields().size()); assertEquals("a", doc.getField("s").stringValue()); assertEquals("b", doc.getField("s2").stringValue()); }
@Test public void shouldNotParseNestedObjectWithoutFields() { String[] fields = new String[] {"name", "contacts", "contacts.homepage", "contacts.missing", "missing2"}; FlatFormatSerializer serializer = new FlatFormatSerializer(); HashSet<Person> contacts1 = new HashSet(); Person contact1 = new Person("Tommi Jackson", new String[] {"5036330001", "5036330002"}, 1); Person contact2 = new Person("Tommi2 Skywalker", new String[] {"5036330003", "5036330004"}, 2); contacts1.add(contact1); contacts1.add(contact2); ArrayList<String> phoneNumbers = new ArrayList(); phoneNumbers.add("5035330001"); phoneNumbers.add("5035330002"); Page[] myHomePages1 = new Page[] {new Page(131), new Page(132)}; Customer customer = new Customer("Tommy Jackson", phoneNumbers, contacts1, myHomePages1); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, customer, fields); assertEquals(1, doc1.getFields().size()); assertEquals("Tommy Jackson", doc1.getField("name").stringValue()); }
@Test void stringWithMaximumLengthShouldBeAllowed() { String longestString = RandomStringUtils.randomAscii( IndexWriter.MAX_TERM_LENGTH ); Document document = documentRepresentingProperties( (long) 123, longestString ); assertEquals( longestString, document.getField( String.key( 0 ) ).stringValue() ); }
@Test public void verifyFieldCountsInDocument() { String[] fields = new String[] {"name", "phoneNumbers", "myHomePages.content", "contacts.name", "contacts.email", "contacts.phoneNumbers", "contacts.address", "contacts.revenue", "contacts.homepage.id", "contacts.homepage.title", "contacts.homepage.content", LuceneService.REGION_VALUE_FIELD}; FlatFormatSerializer serializer = new FlatFormatSerializer(); Person contact1 = new Person("Tommi Jackson", new String[] {"5036330001", "5036330002"}, 1); Person contact2 = new Person("Tommi2 Skywalker", new String[] {"5036330003", "5036330004"}, 2); HashSet<Person> contacts1 = new HashSet(); contacts1.add(contact1); contacts1.add(contact2); ArrayList<String> phoneNumbers = new ArrayList(); phoneNumbers.add("5035330001"); phoneNumbers.add("5035330002"); Page[] myHomePages1 = new Page[] {new Page(131), new Page(132)}; Customer customer = new Customer("Tommy Jackson", phoneNumbers, contacts1, myHomePages1); Document doc1 = SerializerTestHelper.invokeSerializer(serializer, customer, fields); assertEquals(23, doc1.getFields().size()); assertEquals("Tommy Jackson", doc1.getField("name").stringValue()); }
@Test public void shouldIndexPrimitiveStringIfRequested() { HeterogeneousLuceneSerializer mapper = new HeterogeneousLuceneSerializer(); Document doc = SerializerTestHelper.invokeSerializer(mapper, "sample value", new String[] {LuceneService.REGION_VALUE_FIELD}); assertEquals(1, doc.getFields().size()); assertEquals("sample value", doc.getField(LuceneService.REGION_VALUE_FIELD).stringValue()); }
@Test public void testNullField() { String[] fields = new String[] {"s", "o", "s2"}; ReflectionLuceneSerializer mapper = new ReflectionLuceneSerializer(Type2.class, fields); Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, null); Document doc = invokeSerializer(mapper, type2, fields); assertEquals(1, doc.getFields().size()); assertEquals("a", doc.getField("s").stringValue()); assertNull(doc.getField("s2")); } }
/** * This is a test of {@code populateDocument} so it should be rather in {@code AnalyzerGuruTest} * however it lacks the pre-requisite indexing phase. */ @Test public void testIndexPath() throws IOException { SearchEngine instance = new SearchEngine(); // Use as broad search as possible. instance.setFile("c"); instance.search(); ScoreDoc[] scoredocs = instance.scoreDocs(); assertTrue("need some search hits to perform the check",scoredocs.length > 0); for (ScoreDoc sd : scoredocs) { Document doc = instance.doc(sd.doc); assertFalse("PATH field should not contain backslash characters", doc.getField(QueryBuilder.PATH).stringValue().contains("\\")); } } }
@Test public void testAllFields() { String[] allFields = new String[] {"s", "i", "l", "d", "f", "s2"}; ReflectionLuceneSerializer mapper1 = new ReflectionLuceneSerializer(Type1.class, allFields); ReflectionLuceneSerializer mapper2 = new ReflectionLuceneSerializer(Type2.class, allFields); Type1 type1 = new Type1("a", 1, 2L, 3.0, 4.0f); Type2 type2 = new Type2("a", 1, 2L, 3.0, 4.0f, "b"); Document doc1 = invokeSerializer(mapper1, type1, allFields); assertEquals(5, doc1.getFields().size()); assertEquals("a", doc1.getField("s").stringValue()); assertEquals(1, doc1.getField("i").numericValue()); assertEquals(2L, doc1.getField("l").numericValue()); assertEquals(3.0, doc1.getField("d").numericValue()); assertEquals(4.0f, doc1.getField("f").numericValue()); Document doc2 = invokeSerializer(mapper2, type2, allFields); assertEquals(6, doc2.getFields().size()); assertEquals("a", doc2.getField("s").stringValue()); assertEquals("b", doc2.getField("s2").stringValue()); assertEquals(1, doc2.getField("i").numericValue()); assertEquals(2L, doc2.getField("l").numericValue()); assertEquals(3.0, doc2.getField("d").numericValue()); assertEquals(4.0f, doc2.getField("f").numericValue()); }