@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; }
if ( targetedClasses.isEmpty() ) { String msg = entityType.getName() + " is not an indexed entity or a subclass of an indexed entity"; throw new IllegalArgumentException( msg ); entities.addAll( targetedClasses.toPojosSet() );
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; } }
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 ); } }
/** * Returns the given type itself if it is indexed, otherwise the first found indexed sub-type. * * @param entityType the type of interest * @param factory search factory * @return the given type itself if it is indexed, otherwise the first found indexed sub-type or {@code null} if * neither the given type nor any of its sub-types are indexed */ private IndexedTypeIdentifier getIndexBoundType(IndexedTypeIdentifier entityType, ExtendedSearchIntegrator factory) { if ( factory.getIndexBinding( entityType ) != null ) { return entityType; } IndexedTypeSet indexedSubTypes = factory.getIndexedTypesPolymorphic( entityType.asTypeSet() ); if ( !indexedSubTypes.isEmpty() ) { return indexedSubTypes.iterator().next(); } return null; }
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() ); }
public static IndexedTypeSet subtraction(IndexedTypeSet referenceSet, IndexedTypeSet subtraend) { if ( referenceSet.isEmpty() || subtraend.isEmpty() ) { return referenceSet; } else { HashSetIndexedTypeSet casted = (HashSetIndexedTypeSet) referenceSet; Set<IndexedTypeIdentifier> cloned = casted.cloneInternalSet(); for ( IndexedTypeIdentifier toRemove : subtraend ) { cloned.remove( toRemove ); } if ( cloned.isEmpty() ) { return empty(); } if ( cloned.size() == 1 ) { return cloned.iterator().next().asTypeSet(); } else { return new HashSetIndexedTypeSet( cloned ); } } }
/** * 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 AbstractHSQuery(ExtendedSearchIntegrator extendedIntegrator, IndexedTypeSet targetedEntities, IndexedTypeMap<CustomTypeMetadata> customTypeMetadata) { this.extendedIntegrator = extendedIntegrator; this.timeoutExceptionFactory = extendedIntegrator.getDefaultTimeoutExceptionFactory(); if ( targetedEntities == null ) { targetedEntities = IndexedTypeSets.empty(); } this.targetedEntities = targetedEntities; this.indexedTargetedEntities = extendedIntegrator.getIndexedTypesPolymorphic( targetedEntities ); if ( targetedEntities.size() > 0 && indexedTargetedEntities.size() == 0 ) { IndexedTypeSet configuredTargetEntities = extendedIntegrator.getConfiguredTypesPolymorphic( targetedEntities ); if ( configuredTargetEntities.isEmpty() ) { throw LOG.targetedEntityTypesNotConfigured( StringHelper.join( targetedEntities, "," ) ); } else { throw LOG.targetedEntityTypesNotIndexed( StringHelper.join( targetedEntities, "," ) ); } } if ( customTypeMetadata == null ) { this.customTypeMetadata = IndexedTypeMaps.empty(); } else { this.customTypeMetadata = customTypeMetadata; } }
public Set<Class<?>> getRootEntities() { return this.rootEntities.toPojosSet(); }
DeleteExtWorkExecutor(Workspace workspace) { super( workspace ); managedType = workspace.getEntitiesInIndexManager().iterator().next(); builder = workspace.getDocumentBuilder( managedType ); idIsNumeric = isIdNumeric( builder ); }
/** * 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))); }
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() ); }
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 static IndexedTypeSet subtraction(IndexedTypeSet referenceSet, IndexedTypeSet subtraend) { if ( referenceSet.isEmpty() || subtraend.isEmpty() ) { return referenceSet; } else { HashSetIndexedTypeSet casted = (HashSetIndexedTypeSet) referenceSet; Set<IndexedTypeIdentifier> cloned = casted.cloneInternalSet(); for ( IndexedTypeIdentifier toRemove : subtraend ) { cloned.remove( toRemove ); } if ( cloned.isEmpty() ) { return empty(); } if ( cloned.size() == 1 ) { return cloned.iterator().next().asTypeSet(); } else { return new HashSetIndexedTypeSet( cloned ); } } }
/** * 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, IndexedQueryMode queryMode) { if (timeoutExceptionFactory != null) { hSearchQuery.timeoutExceptionFactory(timeoutExceptionFactory); } Class<?>[] classes = hSearchQuery.getTargetedEntities().toPojosSet().toArray(new Class[hSearchQuery.getTargetedEntities().size()]); queryInterceptor.enableClasses(classes); if (queryMode == IndexedQueryMode.BROADCAST) { ExecutorService asyncExecutor = queryInterceptor.getAsyncExecutor(); return new ClusteredCacheQueryImpl<>(new QueryDefinition(hSearchQuery), asyncExecutor, cache, keyTransformationHandler, null); } else { return new CacheQueryImpl<>(hSearchQuery, cache, keyTransformationHandler); } }
private AbstractHSQuery(ExtendedSearchIntegrator extendedIntegrator, IndexedTypeSet targetedEntities, IndexedTypeMap<CustomTypeMetadata> customTypeMetadata) { this.extendedIntegrator = extendedIntegrator; this.timeoutExceptionFactory = extendedIntegrator.getDefaultTimeoutExceptionFactory(); if ( targetedEntities == null ) { targetedEntities = IndexedTypeSets.empty(); } this.targetedEntities = targetedEntities; this.indexedTargetedEntities = extendedIntegrator.getIndexedTypesPolymorphic( targetedEntities ); if ( targetedEntities.size() > 0 && indexedTargetedEntities.size() == 0 ) { IndexedTypeSet configuredTargetEntities = extendedIntegrator.getConfiguredTypesPolymorphic( targetedEntities ); if ( configuredTargetEntities.isEmpty() ) { throw LOG.targetedEntityTypesNotConfigured( StringHelper.join( targetedEntities, "," ) ); } else { throw LOG.targetedEntityTypesNotIndexed( StringHelper.join( targetedEntities, "," ) ); } } if ( customTypeMetadata == null ) { this.customTypeMetadata = IndexedTypeMaps.empty(); } else { this.customTypeMetadata = customTypeMetadata; } }
public void postInitialize(IndexedTypeSet indexedClassesSet) { Set<Class<?>> indexedClasses = indexedClassesSet.toPojosSet(); //we initialize only once because we no longer have a reference to the reflectionManager //in theory Class<?> plainClass = beanClass; if ( entityState == EntityState.NON_INDEXABLE ) { throw new AssertionFailure( "A non indexed entity is post processed" ); } Set<Class<?>> tempMappedSubclasses = new HashSet<Class<?>>(); //together with the caller this creates a o(2), but I think it's still faster than create the up hierarchy for each class for ( Class<?> currentClass : indexedClasses ) { if ( plainClass != currentClass && plainClass.isAssignableFrom( currentClass ) ) { tempMappedSubclasses.add( currentClass ); } } this.mappedSubclasses = Collections.unmodifiableSet( tempMappedSubclasses ); Class<?> superClass = plainClass.getSuperclass(); this.isRoot = true; while ( superClass != null ) { if ( indexedClasses.contains( superClass ) ) { this.isRoot = false; break; } superClass = superClass.getSuperclass(); } }
/** * Returns the given type itself if it is indexed, otherwise the first found indexed sub-type. * * @param entityType the type of interest * @param factory search factory * @return the given type itself if it is indexed, otherwise the first found indexed sub-type or {@code null} if * neither the given type nor any of its sub-types are indexed */ private IndexedTypeIdentifier getIndexBoundType(IndexedTypeIdentifier entityType, ExtendedSearchIntegrator factory) { if ( factory.getIndexBinding( entityType ) != null ) { return entityType; } IndexedTypeSet indexedSubTypes = factory.getIndexedTypesPolymorphic( entityType.asTypeSet() ); if ( !indexedSubTypes.isEmpty() ) { return indexedSubTypes.iterator().next(); } return null; }
UpdateExtWorkExecutor(Workspace workspace, AddWorkExecutor addDelegate) { super( null, null ); this.workspace = workspace; this.addDelegate = addDelegate; this.managedType = workspace.getEntitiesInIndexManager().iterator().next(); this.builder = workspace.getDocumentBuilder( managedType ); this.idIsNumeric = DeleteWorkExecutor.isIdNumeric( builder ); }