@Override public MassIndexer typesToIndexInParallel(int numberOfThreads) { if ( numberOfThreads < 1 ) { throw new IllegalArgumentException( "numberOfThreads must be at least 1" ); } this.typesToIndexInParallel = Math.min( numberOfThreads, rootEntities.size() ); return this; }
@Override public MassIndexer typesToIndexInParallel(int threadsToIndexObjects) { atLeastOneValidation( threadsToIndexObjects ); this.typesToIndexInParallel = Math.min( threadsToIndexObjects, rootEntities.size() ); return this; }
@Override public boolean areSingleTermDeletesSafe() { return indexMetadataIsComplete && getEntitiesInIndexManager().size() == 1; }
@Override public boolean areSingleTermDeletesSafe() { return indexMetadataIsComplete && getEntitiesInIndexManager().size() == 1; }
public BatchCoordinator(GridDialect gridDialect, IndexedTypeSet rootEntities, ExtendedSearchIntegrator searchFactoryImplementor, SessionFactoryImplementor sessionFactory, int typesToIndexInParallel, CacheMode cacheMode, boolean optimizeAtEnd, boolean purgeAtStart, boolean optimizeAfterPurge, MassIndexerProgressMonitor monitor, String tenantId) { this.gridDialect = gridDialect; this.tenantId = tenantId; this.rootIndexedTypes = rootEntities; this.searchFactoryImplementor = searchFactoryImplementor; this.sessionFactory = sessionFactory; this.typesToIndexInParallel = typesToIndexInParallel; this.cacheMode = cacheMode; this.optimizeAtEnd = optimizeAtEnd; this.purgeAtStart = purgeAtStart; this.optimizeAfterPurge = optimizeAfterPurge; this.monitor = monitor; this.endAllSignal = new CountDownLatch( rootEntities.size() ); this.errorHandler = searchFactoryImplementor.getErrorHandler(); }
private Collection<IndexManager> uniqueIndexManagerForTypes(IndexedTypeSet entityTypes) { HashMap<String,IndexManager> uniqueBackends = new HashMap<String, IndexManager>( entityTypes.size() ); for ( IndexedTypeIdentifier type : entityTypes ) { EntityIndexBinding indexBindingForEntity = integrator.getIndexBinding( type ); if ( indexBindingForEntity != null ) { Set<IndexManager> indexManagers = indexBindingForEntity.getIndexManagerSelector().all(); for ( IndexManager im : indexManagers ) { uniqueBackends.put( im.getIndexName(), im ); } } } return uniqueBackends.values(); }
public static IndexedTypeSet composite(final IndexedTypeSet setA, final IndexedTypeSet setB) { if ( setA.isEmpty() ) { return setB; } else if ( setB.isEmpty() ) { return setA; } else if ( setB.equals( setA ) ) { return setA; } else { HashSet<IndexedTypeIdentifier> newSet = new HashSet<>( setA.size() + setB.size() ); setA.forEach( newSet::add ); setB.forEach( newSet::add ); return fromSafeHashSet( newSet ); } }
private Collection<IndexManager> uniqueIndexManagerForTypes(IndexedTypeSet entityTypes) { HashMap<String,IndexManager> uniqueBackends = new HashMap<String, IndexManager>( entityTypes.size() ); for ( IndexedTypeIdentifier type : entityTypes ) { EntityIndexBinding indexBindingForEntity = integrator.getIndexBinding( type ); if ( indexBindingForEntity != null ) { Set<IndexManager> indexManagers = indexBindingForEntity.getIndexManagerSelector().all(); for ( IndexManager im : indexManagers ) { uniqueBackends.put( im.getIndexName(), im ); } } } return uniqueBackends.values(); }
public static IndexedTypeSet composite(final IndexedTypeSet setA, final IndexedTypeSet setB) { if ( setA.isEmpty() ) { return setB; } else if ( setB.isEmpty() ) { return setA; } else if ( setB.equals( setA ) ) { return setA; } else { HashSet<IndexedTypeIdentifier> newSet = new HashSet<>( setA.size() + setB.size() ); setA.forEach( newSet::add ); setB.forEach( newSet::add ); return fromSafeHashSet( newSet ); } }
public Loader buildLoader() { if ( criteria != null ) { return getCriteriaLoader(); } else if ( targetedEntities.size() == 1 ) { return getSingleEntityLoader(); } else { return getMultipleEntitiesLoader(); } }
private DocumentBuilderIndexedEntity getDocumentBuilder(IndexedTypeIdentifier entityType, ExtendedSearchIntegrator extendedIntegrator) { IndexedTypeSet indexedEntities = extendedIntegrator.getIndexedTypesPolymorphic( entityType.asTypeSet() ); if ( indexedEntities.size() > 0 ) { return extendedIntegrator.getIndexBinding( indexedEntities.iterator().next() ).getDocumentBuilder(); } else { return null; } }
/** * Internal and experimental! Creates a {@link CacheQuery}, filtered according to the given {@link HSQuery}. * * @param hSearchQuery {@link HSQuery} * @return the CacheQuery object which can be used to iterate through results */ public <E> CacheQuery<E> getQuery(HSQuery hSearchQuery) { if (timeoutExceptionFactory != null) { hSearchQuery.timeoutExceptionFactory(timeoutExceptionFactory); } Class<?>[] classes = hSearchQuery.getTargetedEntities().toPojosSet().toArray(new Class[hSearchQuery.getTargetedEntities().size()]); queryInterceptor.enableClasses(classes); return new CacheQueryImpl<>(hSearchQuery, cache, queryInterceptor.getKeyTransformationHandler()); }
private void assertIsDoubleSet(IndexedTypeSet typeSet) { Assert.assertFalse( "Verify it's not a singleton", typeSet == IndexedTypeSets.empty() ); Assert.assertFalse( typeSet.isEmpty() ); Assert.assertEquals( 2, typeSet.size() ); Iterator<IndexedTypeIdentifier> iterator = typeSet.iterator(); Assert.assertTrue( iterator.hasNext() ); iterator.next(); // increment once iterator.next(); // increment twice Assert.assertFalse( iterator.hasNext() ); iterator.forEachRemaining( l -> Assert.fail( "should never happen" ) ); //no more elements Set<Class<?>> pojosSet = typeSet.toPojosSet(); Assert.assertTrue( pojosSet.contains( TYPE_A.getPojoType() ) ); Assert.assertTrue( pojosSet.contains( TYPE_B.getPojoType() ) ); Assert.assertEquals( 2, pojosSet.size() ); }
@Test public void testGetIndexedTypesNoTypeIndexed() { SearchConfigurationForTest cfg = getManualConfiguration(); SearchIntegrator si = integratorResource.create( cfg ); IndexedTypeSet indexedClasses = si.getIndexedTypeIdentifiers(); assertEquals( "Wrong number of indexed entities", 0, indexedClasses.size() ); }
private void assertIsEmpty(IndexedTypeSet typeSet) { Assert.assertTrue( "Verify the singleton optimisation applies", typeSet == IndexedTypeSets.empty() ); Assert.assertTrue( typeSet.isEmpty() ); Assert.assertEquals( 0, typeSet.size() ); typeSet.iterator().forEachRemaining( l -> Assert.fail( "should never happen" ) ); Assert.assertEquals( 0, typeSet.toPojosSet().size() ); }
private void assertIsSingletonSet(IndexedTypeSet typeSet, Class<?> someType, boolean recursive) { Assert.assertFalse( "Verify it's not a singleton", typeSet == IndexedTypeSets.empty() ); Assert.assertFalse( typeSet.isEmpty() ); Assert.assertEquals( 1, typeSet.size() ); Iterator<IndexedTypeIdentifier> iterator = typeSet.iterator(); Assert.assertTrue( iterator.hasNext() ); IndexedTypeIdentifier firstElement = iterator.next(); // increment once Assert.assertFalse( iterator.hasNext() ); iterator.forEachRemaining( l -> Assert.fail( "should never happen" ) ); //no more elements Set<Class<?>> pojosSet = typeSet.toPojosSet(); Assert.assertTrue( pojosSet.contains( someType ) ); Assert.assertEquals( 1, pojosSet.size() ); IndexedTypeSet typeSet2 = firstElement.asTypeSet(); if ( recursive ) { assertIsSingletonSet( typeSet2, someType, false ); } Assert.assertEquals( typeSet2, typeSet2 ); Assert.assertEquals( firstElement.getPojoType(), someType ); }
@Test public void testGetIndexedTypeSingleIndexedType() { SearchConfigurationForTest cfg = getManualConfiguration(); SearchMapping mapping = new SearchMapping(); mapping .entity( Foo.class ).indexed() .property( "id", FIELD ).documentId() ; cfg.setProgrammaticMapping( mapping ); SearchIntegrator si = integratorResource.create( cfg ); IndexedTypeSet indexedClasses = si.getIndexedTypeIdentifiers(); assertEquals( "Wrong number of indexed entities", 1, indexedClasses.size() ); assertTrue( indexedClasses.iterator().next().equals( new PojoIndexedTypeIdentifier( Foo.class ) ) ); }
/** * Verifies if the indexing interceptor is aware of a specific list of types. * * @param cache the cache containing the indexes * @param types vararg listing the types the indexing engine should know */ private void assertIndexingKnows(Cache<Object, Object> cache, Class<?>... types) { ComponentRegistry cr = cache.getAdvancedCache().getComponentRegistry(); SearchIntegrator searchIntegrator = cr.getComponent(SearchIntegrator.class); assertNotNull(searchIntegrator); IndexedTypeMap<EntityIndexBinding> indexBindingForEntity = searchIntegrator.unwrap(ExtendedSearchIntegrator.class).getIndexBindings(); assertNotNull(indexBindingForEntity); IndexedTypeSet keySet = indexBindingForEntity.keySet(); assertEquals(types.length, keySet.size()); assertTrue(keySet.containsAll(IndexedTypeSets.fromClasses(types))); }
@Test public void testGetIndexedTypesMultipleTypes() { SearchConfigurationForTest cfg = getManualConfiguration(); SearchMapping mapping = new SearchMapping(); mapping .entity( Foo.class ).indexed() .property( "id", FIELD ).documentId() .entity( Bar.class ).indexed() .property( "id", FIELD ).documentId() ; cfg.setProgrammaticMapping( mapping ); SearchIntegrator si = integratorResource.create( cfg ); IndexedTypeSet indexedClasses = si.getIndexedTypeIdentifiers(); assertEquals( "Wrong number of indexed entities", 2, indexedClasses.size() ); }