repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/scope/impl/SearchScopeImpl.java
|
package org.infinispan.search.mapper.scope.impl;
import org.hibernate.search.engine.backend.mapping.spi.BackendMappingContext;
import org.hibernate.search.engine.backend.session.spi.DetachedBackendSessionContext;
import org.hibernate.search.engine.common.EntityReference;
import org.hibernate.search.engine.search.aggregation.dsl.SearchAggregationFactory;
import org.hibernate.search.engine.search.predicate.dsl.SearchPredicateFactory;
import org.hibernate.search.engine.search.projection.dsl.SearchProjectionFactory;
import org.hibernate.search.engine.search.query.dsl.SearchQuerySelectStep;
import org.hibernate.search.engine.search.sort.dsl.SearchSortFactory;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.hibernate.search.mapper.pojo.scope.spi.PojoScopeDelegate;
import org.hibernate.search.mapper.pojo.scope.spi.PojoScopeSessionContext;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.scope.SearchWorkspace;
import org.infinispan.search.mapper.search.loading.context.impl.InfinispanLoadingContext;
public class SearchScopeImpl<E> implements SearchScope<E> {
private final BackendMappingContext mappingContext;
private final PojoScopeDelegate<EntityReference, E, PojoRawTypeIdentifier<? extends E>> delegate;
private final PojoSelectionEntityLoader<E> entityLoader;
public SearchScopeImpl(BackendMappingContext mappingContext,
PojoScopeDelegate<EntityReference, E, PojoRawTypeIdentifier<? extends E>> delegate,
PojoSelectionEntityLoader<E> entityLoader) {
this.mappingContext = mappingContext;
this.delegate = delegate;
this.entityLoader = entityLoader;
}
@Override
public SearchPredicateFactory predicate() {
return delegate.predicate();
}
@Override
public SearchSortFactory sort() {
return delegate.sort();
}
@Override
public SearchProjectionFactory<EntityReference, E> projection() {
return delegate.projection();
}
@Override
public SearchAggregationFactory aggregation() {
return delegate.aggregation();
}
@Override
public SearchWorkspace workspace() {
return new SearchWorkspaceImpl(delegate.workspace(DetachedBackendSessionContext.of(mappingContext, null)));
}
public SearchQuerySelectStep<?, EntityReference, E, ?, ?, ?> search(PojoScopeSessionContext sessionContext) {
return delegate.search(sessionContext, new InfinispanLoadingContext.Builder<>(entityLoader));
}
}
| 2,621
| 41.290323
| 113
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/scope/impl/SearchWorkspaceImpl.java
|
package org.infinispan.search.mapper.scope.impl;
import java.util.Collections;
import java.util.Set;
import org.hibernate.search.mapper.pojo.work.spi.PojoScopeWorkspace;
import org.hibernate.search.util.common.impl.Futures;
import org.infinispan.search.mapper.scope.SearchWorkspace;
class SearchWorkspaceImpl implements SearchWorkspace {
private final PojoScopeWorkspace delegate;
public SearchWorkspaceImpl(PojoScopeWorkspace delegate) {
this.delegate = delegate;
}
@Override
public void purge() {
Futures.unwrappedExceptionJoin(delegate.purge(Collections.emptySet()));
}
@Override
public void purge(Set<String> routingKeys) {
Futures.unwrappedExceptionJoin(delegate.purge(routingKeys));
}
@Override
public void flush() {
Futures.unwrappedExceptionJoin(delegate.flush());
}
@Override
public void refresh() {
Futures.unwrappedExceptionJoin(delegate.refresh());
}
@Override
public void mergeSegments() {
Futures.unwrappedExceptionJoin(delegate.mergeSegments());
}
}
| 1,064
| 24.357143
| 77
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/search/loading/context/impl/InfinispanLoadingContext.java
|
package org.infinispan.search.mapper.search.loading.context.impl;
import java.util.Optional;
import java.util.Set;
import org.hibernate.search.mapper.pojo.loading.spi.PojoLoadingTypeContext;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionLoadingContext;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionLoadingContextBuilder;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionLoadingStrategy;
import org.hibernate.search.mapper.pojo.model.spi.PojoRuntimeIntrospector;
import org.infinispan.search.mapper.model.impl.InfinispanRuntimeIntrospector;
/**
* @author Fabio Massimo Ercoli
*/
public final class InfinispanLoadingContext<E> implements PojoSelectionLoadingContext {
private final PojoSelectionEntityLoader<E> entityLoader;
public InfinispanLoadingContext(PojoSelectionEntityLoader<E> entityLoader) {
this.entityLoader = entityLoader;
}
@Override
public void checkOpen() {
// Nothing to do: we're always "open"
}
@Override
public PojoRuntimeIntrospector runtimeIntrospector() {
return new InfinispanRuntimeIntrospector();
}
@Override
public <T> PojoSelectionLoadingStrategy<? super T> loadingStrategy(PojoLoadingTypeContext<T> type) {
InfinispanSelectionLoadingStrategy<E> loadingStrategy = new InfinispanSelectionLoadingStrategy<>(entityLoader);
return (PojoSelectionLoadingStrategy<? super T>) loadingStrategy;
}
@Override
public <T> Optional<PojoSelectionLoadingStrategy<? super T>> loadingStrategyOptional(PojoLoadingTypeContext<T> type) {
return Optional.of( loadingStrategy( type ) );
}
public static final class Builder<E> implements PojoSelectionLoadingContextBuilder<Void> {
private final PojoSelectionEntityLoader<E> entityLoader;
public Builder(PojoSelectionEntityLoader<E> entityLoader) {
this.entityLoader = entityLoader;
}
@Override
public Void toAPI() {
// loading options are not used by ISPN
return null;
}
@Override
public InfinispanLoadingContext build() {
return new InfinispanLoadingContext(entityLoader);
}
}
private class InfinispanSelectionLoadingStrategy<E> implements PojoSelectionLoadingStrategy<E> {
private final PojoSelectionEntityLoader<E> entityLoader;
private InfinispanSelectionLoadingStrategy(PojoSelectionEntityLoader<E> entityLoader) {
this.entityLoader = entityLoader;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
InfinispanSelectionLoadingStrategy<?> that = (InfinispanSelectionLoadingStrategy<?>) o;
return entityLoader.equals(that.entityLoader);
}
@Override
public int hashCode() {
return entityLoader.hashCode();
}
@Override
public PojoSelectionEntityLoader<E> createLoader(Set<? extends PojoLoadingTypeContext<? extends E>> expectedTypes) {
return entityLoader;
}
}
}
| 3,222
| 32.572917
| 122
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/log/impl/Log.java
|
package org.infinispan.search.mapper.log.impl;
import org.hibernate.search.engine.environment.classpath.spi.ClassLoadingException;
import org.hibernate.search.util.common.SearchException;
import org.hibernate.search.util.common.logging.impl.ClassFormatter;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.FormatWith;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import org.jboss.logging.annotations.ValidIdRange;
/**
* Log abstraction for the search mapper module. For this module, message ids ranging from 14501 to 14800 inclusively
* have been reserved.
*
* @since 12.0
*/
@MessageLogger(projectCode = "ISPN")
@ValidIdRange(min = 14501, max = 14800)
public interface Log extends BasicLogger {
@Message(id = 14501, value = "Exception while retrieving the type model for '%1$s'.")
SearchException errorRetrievingTypeModel(@FormatWith(ClassFormatter.class) Class<?> clazz, @Cause Exception cause);
@Message(id = 14502, value = "Multiple entity types configured with the same name '%1$s': '%2$s', '%3$s'")
SearchException multipleEntityTypesWithSameName(String entityName, Class<?> previousType, Class<?> type);
@Message(id = 14503, value = "Infinispan Search Mapper does not support named types. The type with name '%1$s' does not exist.")
SearchException namedTypesNotSupported(String name);
@Message(id = 14504, value = "Unable to load class [%1$s]")
ClassLoadingException unableToLoadTheClass(String className, @Cause Throwable cause);
@Message(id = 14505, value = "Unknown entity name: '%1$s'.")
SearchException invalidEntityName(String entityName);
@Message(id = 14506, value = "Invalid type for '%1$s': the entity type must extend '%2$s'," +
" but entity type '%3$s' does not.")
SearchException invalidEntitySuperType(String entityName,
@FormatWith(ClassFormatter.class) Class<?> expectedSuperType,
@FormatWith(ClassFormatter.class) Class<?> actualJavaType);
}
| 2,066
| 45.977273
| 131
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/log/impl/InfinispanEventContextMessages.java
|
package org.infinispan.search.mapper.log.impl;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageBundle;
/**
* Message bundle for event contexts in the Infinispan Search mapper.
*/
@MessageBundle(projectCode = "ISPN")
public interface InfinispanEventContextMessages {
@Message(value = "Infinispan Search Mapping")
String mapping();
}
| 386
| 23.1875
| 69
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/model/impl/InfinispanBootstrapIntrospector.java
|
package org.infinispan.search.mapper.model.impl;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import org.hibernate.annotations.common.reflection.java.JavaReflectionManager;
import org.hibernate.search.mapper.pojo.model.hcann.spi.AbstractPojoHCAnnBootstrapIntrospector;
import org.hibernate.search.mapper.pojo.model.hcann.spi.PojoHCannOrmGenericContextHelper;
import org.hibernate.search.mapper.pojo.model.spi.GenericContextAwarePojoGenericTypeModel.RawTypeDeclaringContext;
import org.hibernate.search.mapper.pojo.model.spi.PojoBootstrapIntrospector;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeModel;
import org.hibernate.search.util.common.AssertionFailure;
import org.hibernate.search.util.common.impl.ReflectionHelper;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;
import org.hibernate.search.util.common.reflect.spi.ValueReadHandle;
import org.hibernate.search.util.common.reflect.spi.ValueReadHandleFactory;
import org.infinispan.search.mapper.log.impl.Log;
/**
* A very simple introspector roughly following Java Beans conventions.
* <p>
* As per JavaBeans conventions, only public getters are supported, and field access is not.
*/
public class InfinispanBootstrapIntrospector extends AbstractPojoHCAnnBootstrapIntrospector
implements PojoBootstrapIntrospector {
private static final Log log = LoggerFactory.make(Log.class, MethodHandles.lookup());
private final ValueReadHandleFactory valueReadHandleFactory;
private final PojoHCannOrmGenericContextHelper genericContextHelper;
private final Map<Class<?>, PojoRawTypeModel<?>> typeModelCache = new HashMap<>();
public InfinispanBootstrapIntrospector(ValueReadHandleFactory valueReadHandleFactory) {
super(new JavaReflectionManager(), valueReadHandleFactory);
this.valueReadHandleFactory = valueReadHandleFactory;
this.genericContextHelper = new PojoHCannOrmGenericContextHelper(this);
}
@Override
@SuppressWarnings("unchecked")
public <T> InfinispanRawTypeModel<T> typeModel(Class<T> clazz) {
if (clazz.isPrimitive()) {
/*
* We'll never manipulate the primitive type, as we're using generics everywhere,
* so let's consider every occurrence of the primitive type as an occurrence of its wrapper type.
*/
clazz = (Class<T>) ReflectionHelper.getPrimitiveWrapperType(clazz);
}
return (InfinispanRawTypeModel<T>) typeModelCache.computeIfAbsent(clazz, this::createTypeModel);
}
@Override
public PojoRawTypeModel<?> typeModel(String name) {
throw log.namedTypesNotSupported(name);
}
@Override
public ValueReadHandleFactory annotationValueReadHandleFactory() {
return valueReadHandleFactory;
}
ValueReadHandle<?> createValueReadHandle(Member member) throws IllegalAccessException {
if (member instanceof Method) {
Method method = (Method) member;
setAccessible(method);
return valueReadHandleFactory.createForMethod(method);
} else if (member instanceof Field) {
Field field = (Field) member;
setAccessible(field);
return valueReadHandleFactory.createForField(field);
} else {
throw new AssertionFailure("Unexpected type for a " + Member.class.getName() + ": " + member);
}
}
private <T> PojoRawTypeModel<T> createTypeModel(Class<T> clazz) {
PojoRawTypeIdentifier<T> typeIdentifier = PojoRawTypeIdentifier.of(clazz);
try {
return new InfinispanRawTypeModel<>(this, typeIdentifier,
new RawTypeDeclaringContext<>(genericContextHelper, clazz));
} catch (RuntimeException e) {
throw log.errorRetrievingTypeModel(clazz, e);
}
}
private static void setAccessible(AccessibleObject member) {
try {
// always set accessible to true as it bypasses the security model checks
// at execution time and is faster.
member.setAccessible(true);
} catch (SecurityException se) {
if (!Modifier.isPublic(((Member) member).getModifiers())) {
throw se;
}
}
}
}
| 4,425
| 40.754717
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/model/impl/InfinispanRuntimeIntrospector.java
|
package org.infinispan.search.mapper.model.impl;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.hibernate.search.mapper.pojo.model.spi.PojoRuntimeIntrospector;
public class InfinispanRuntimeIntrospector implements PojoRuntimeIntrospector {
private final PojoRuntimeIntrospector delegate = PojoRuntimeIntrospector.simple();
public InfinispanRuntimeIntrospector() {
}
@Override
public <T> PojoRawTypeIdentifier<? extends T> detectEntityType(T entity) {
return delegate.detectEntityType(entity);
}
@Override
public Object unproxy(Object value) {
return delegate.unproxy(value);
}
@Override
public boolean isIgnorableDataAccessThrowable(Throwable throwable) {
// Don't ignore any throwable by default.
return false;
}
}
| 820
| 27.310345
| 85
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/model/impl/InfinispanRawTypeModel.java
|
package org.infinispan.search.mapper.model.impl;
import org.hibernate.annotations.common.reflection.XProperty;
import org.hibernate.search.mapper.pojo.model.hcann.spi.AbstractPojoHCAnnRawTypeModel;
import org.hibernate.search.mapper.pojo.model.spi.GenericContextAwarePojoGenericTypeModel.RawTypeDeclaringContext;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import java.lang.reflect.Member;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Stream;
class InfinispanRawTypeModel<T> extends AbstractPojoHCAnnRawTypeModel<T, InfinispanBootstrapIntrospector> {
InfinispanRawTypeModel(InfinispanBootstrapIntrospector introspector, PojoRawTypeIdentifier<T> typeIdentifier,
RawTypeDeclaringContext<T> rawTypeDeclaringContext) {
super(introspector, typeIdentifier, rawTypeDeclaringContext);
}
@Override
@SuppressWarnings("unchecked") // xClass represents T, so its supertypes represent ? super T
public Stream<InfinispanRawTypeModel<? super T>> ascendingSuperTypes() {
return introspector.ascendingSuperClasses(xClass)
.map(xc -> (InfinispanRawTypeModel<? super T>) introspector.typeModel(xc));
}
@Override
@SuppressWarnings("unchecked") // xClass represents T, so its supertypes represent ? super T
public Stream<InfinispanRawTypeModel<? super T>> descendingSuperTypes() {
return introspector.descendingSuperClasses(xClass)
.map(xc -> (InfinispanRawTypeModel<? super T>) introspector.typeModel(xc));
}
@Override
protected InfinispanPropertyModel<?> createPropertyModel(String propertyName) {
List<XProperty> declaredXProperties = new ArrayList<>(2);
List<XProperty> methodAccessXProperties = declaredMethodAccessXPropertiesByName().get(propertyName);
if (methodAccessXProperties != null) {
declaredXProperties.addAll(methodAccessXProperties);
}
XProperty fieldAccessXProperty = declaredFieldAccessXPropertiesByName().get(propertyName);
if (fieldAccessXProperty != null) {
declaredXProperties.add(fieldAccessXProperty);
}
List<Member> members = findPropertyMember(propertyName);
if (members == null) {
return null;
}
return new InfinispanPropertyModel<>(
introspector, this, propertyName,
declaredXProperties, members
);
}
private List<Member> findPropertyMember(String propertyName) {
// Try using the getter first (if declared)...
List<Member> getters = findInSelfOrParents(t -> t.declaredPropertyGetters(propertyName));
if (getters != null) {
return getters;
}
// ... and fall back to the field (or null if not found)
Member field = findInSelfOrParents(t -> t.declaredPropertyField(propertyName));
return field == null ? null : Collections.singletonList(field);
}
private <T2> T2 findInSelfOrParents(Function<InfinispanRawTypeModel<?>, T2> getter) {
return ascendingSuperTypes()
.map(getter)
.filter(Objects::nonNull)
.findFirst()
.orElse(null);
}
}
| 3,249
| 39.625
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/model/impl/InfinispanPropertyModel.java
|
package org.infinispan.search.mapper.model.impl;
import java.lang.reflect.Member;
import java.util.List;
import org.hibernate.annotations.common.reflection.XProperty;
import org.hibernate.search.mapper.pojo.model.hcann.spi.AbstractPojoHCAnnPropertyModel;
import org.hibernate.search.util.common.reflect.spi.ValueReadHandle;
class InfinispanPropertyModel<T> extends AbstractPojoHCAnnPropertyModel<T, InfinispanBootstrapIntrospector> {
InfinispanPropertyModel(InfinispanBootstrapIntrospector introspector,
InfinispanRawTypeModel<?> holderTypeModel,
String name, List<XProperty> declaredXProperties,
List<Member> members) {
super(introspector, holderTypeModel, name, declaredXProperties, members);
}
@Override
@SuppressWarnings("unchecked") // By construction, we know the member returns values of type T
protected ValueReadHandle<T> createHandle(Member member) throws IllegalAccessException {
return (ValueReadHandle<T>) introspector.createValueReadHandle(member);
}
}
| 1,083
| 42.36
| 109
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/model/impl/InfinispanSimpleStringSetPojoPathFilterFactory.java
|
package org.infinispan.search.mapper.model.impl;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.hibernate.search.mapper.pojo.model.path.PojoModelPathPropertyNode;
import org.hibernate.search.mapper.pojo.model.path.PojoModelPathValueNode;
import org.hibernate.search.mapper.pojo.model.path.spi.PojoPathsDefinition;
/**
* A factory for filters expecting a simple string representation of dirty paths, in the form
* "propertyA.propertyB.propertyC".
* <p>
* See {@link PojoModelPathPropertyNode#toPropertyString()}.
*/
public class InfinispanSimpleStringSetPojoPathFilterFactory implements PojoPathsDefinition {
@Override
public List<String> preDefinedOrdinals() {
return Collections.emptyList(); // No pre-defined ordinals
}
@Override
public void interpretPaths(Set<String> target, Set<PojoModelPathValueNode> source) {
for (PojoModelPathValueNode path : source) {
target.add(path.parent().toPropertyString());
}
}
}
| 1,008
| 31.548387
| 93
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/SearchMapping.java
|
package org.infinispan.search.mapper.mapping;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import org.hibernate.search.engine.reporting.FailureHandler;
import org.hibernate.search.mapper.pojo.model.spi.PojoBootstrapIntrospector;
import org.infinispan.query.concurrent.FailureCounter;
import org.infinispan.search.mapper.mapping.metamodel.IndexMetamodel;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.session.SearchSession;
import org.infinispan.search.mapper.work.SearchIndexer;
import org.infinispan.util.concurrent.BlockingManager;
public interface SearchMapping extends AutoCloseable {
/**
* Create a {@link SearchScope} limited to the given type.
*
* @param type A type to include in the scope.
* @param <E> An entity type to include in the scope.
* @return The created scope.
* @see SearchScope
*/
default <E> SearchScope<E> scope(Class<E> type) {
return scope(Collections.singleton(type));
}
/**
* Create a {@link SearchScope} limited to the given types.
*
* @param types A collection of types to include in the scope.
* @param <E> An entity to include in the scope.
* @return The created scope.
* @see SearchScope
*/
<E> SearchScope<E> scope(Collection<? extends Class<? extends E>> types);
SearchScope<?> scopeAll();
FailureHandler getFailureHandler();
@Override
void close();
boolean isClose();
default boolean isRestarting() {
return false;
}
SearchSession getMappingSession();
SearchIndexer getSearchIndexer();
/**
* @param entityType The type of an possible-indexed entity.
* @return A {@link SearchIndexedEntity} for the indexed entity with the exact given type,
* if the type matches some indexed entity, otherwise {@code null}.
*/
SearchIndexedEntity indexedEntity(Class<?> entityType);
SearchIndexedEntity indexedEntity(String entityName);
/**
* @return A collection containing one {@link SearchIndexedEntity} for each indexed entity
*/
Collection<? extends SearchIndexedEntity> allIndexedEntities();
default Collection<? extends SearchIndexedEntity> indexedEntitiesForStatistics() {
return allIndexedEntities();
}
/**
* @return A set containing the name of {@link #allIndexedEntities() all indexed entities}.
*/
Set<String> allIndexedEntityNames();
//TODO: ISPN-12449 replace with a method with a method returning entity names.
// Currently this method returns java type, using byte[] to represents *all* protobuf types.
// So if we use java types, we can't discriminate between two protobuf types,
// which means for example that we can't reindex just one protobuf type;
// see the callers for more details.
Set<Class<?>> allIndexedEntityJavaClasses();
/**
* Releases all used resources (IO, threads)
* and restarts from the mapping configuration.
*/
default void reload() {
}
/**
* Releases some used resources (e.g.: threads), preserving some others (e.g.: IO)
* and restarts from the mapping configuration.
*/
default void restart() {
}
/**
* @param value An entity.
* @return The internal Java class for this entity after conversion,
* i.e. the Java class that will be returned by {@link #allIndexedEntityJavaClasses()}
* if this entity is potentially indexed.
* In practice, this is only useful to handle protobuf type: if an instance of ProtobufValueWrapper is passed,
* this will return byte[] because that's the type we use for protobuf values internally.
* For all other types, this just returns value.getClass().
* @see EntityConverter
*/
//TODO: ISPN-12449 this would be really simpler if we were just using entity names.
// see allIndexedEntityJavaClasses.
// However, there's a challenge here: we don't know the type of a ProtobufValueWrapper until it's deserialized,
// and deserializing is costly so we don't want to deserialize it until we know we need to index it...
Class<?> toConvertedEntityJavaClass(Object value);
Map<String, IndexMetamodel> metamodel();
int genericIndexingFailures();
int entityIndexingFailures();
static SearchMappingBuilder builder(PojoBootstrapIntrospector introspector, ClassLoader aggregatedClassLoader,
Collection<ProgrammaticSearchMappingProvider> mappingProviders,
BlockingManager blockingManager, FailureCounter failureCounter) {
return new SearchMappingBuilder(introspector, aggregatedClassLoader, mappingProviders,
blockingManager, failureCounter);
}
}
| 4,761
| 35.075758
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/ProgrammaticSearchMappingProvider.java
|
package org.infinispan.search.mapper.mapping;
/**
* An object responsible for configuring the Hibernate Search mapping.
*/
public interface ProgrammaticSearchMappingProvider {
/**
* Configure the Hibernate Search mapping as necessary using the given {@code context}.
*
* @param context A context exposing methods to configure the mapping.
*/
void configure(MappingConfigurationContext context);
}
| 424
| 25.5625
| 90
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/MappingConfigurationContext.java
|
package org.infinispan.search.mapper.mapping;
import org.hibernate.search.mapper.pojo.mapping.definition.programmatic.ProgrammaticMappingConfigurationContext;
public interface MappingConfigurationContext {
/**
* Start the definition of a programmatic mapping.
* @return A context to define the programmatic mapping.
*/
ProgrammaticMappingConfigurationContext programmaticMapping();
}
| 406
| 28.071429
| 112
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/SearchIndexedEntity.java
|
package org.infinispan.search.mapper.mapping;
import org.hibernate.search.engine.backend.index.IndexManager;
/**
* A descriptor of an indexed entity type, exposing in particular the index manager for this entity.
*/
public interface SearchIndexedEntity {
/**
* @return The Java class of the entity.
*/
Class<?> javaClass();
/**
* @return The name of the entity.
*/
String name();
/**
* @return The index manager this entity is indexed in.
*/
IndexManager indexManager();
}
| 523
| 19.153846
| 100
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/SearchMappingBuilder.java
|
package org.infinispan.search.mapper.mapping;
import java.lang.invoke.MethodHandles;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.hibernate.search.engine.cfg.ConfigurationPropertySource;
import org.hibernate.search.engine.cfg.spi.ConfigurationPropertyChecker;
import org.hibernate.search.engine.common.spi.SearchIntegration;
import org.hibernate.search.engine.common.spi.SearchIntegrationEnvironment;
import org.hibernate.search.engine.common.spi.SearchIntegrationFinalizer;
import org.hibernate.search.engine.common.spi.SearchIntegrationPartialBuildState;
import org.hibernate.search.engine.environment.bean.BeanReference;
import org.hibernate.search.mapper.pojo.bridge.IdentifierBridge;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.mapping.definition.programmatic.ProgrammaticMappingConfigurationContext;
import org.hibernate.search.mapper.pojo.model.spi.PojoBootstrapIntrospector;
import org.hibernate.search.util.common.impl.SuppressingCloser;
import org.hibernate.search.util.common.reflect.spi.ValueReadHandleFactory;
import org.infinispan.query.concurrent.FailureCounter;
import org.infinispan.search.mapper.impl.InfinispanMappingInitiator;
import org.infinispan.search.mapper.mapping.impl.ClassLoaderServiceImpl;
import org.infinispan.search.mapper.mapping.impl.IndexProperties;
import org.infinispan.search.mapper.mapping.impl.InfinispanMapping;
import org.infinispan.search.mapper.mapping.impl.InfinispanMappingKey;
import org.infinispan.search.mapper.model.impl.InfinispanBootstrapIntrospector;
import org.infinispan.util.concurrent.BlockingManager;
public final class SearchMappingBuilder {
public static InfinispanBootstrapIntrospector introspector(MethodHandles.Lookup lookup) {
ValueReadHandleFactory valueReadHandleFactory = ValueReadHandleFactory.usingMethodHandle(lookup);
return new InfinispanBootstrapIntrospector(valueReadHandleFactory);
}
private final ConfigurationPropertyChecker propertyChecker;
private final IndexProperties indexProperties = new IndexProperties();
private final ConfigurationPropertySource propertySource;
private final InfinispanMappingKey mappingKey;
private final InfinispanMappingInitiator mappingInitiator;
private final ClassLoaderServiceImpl classLoaderService;
SearchMappingBuilder(PojoBootstrapIntrospector introspector, ClassLoader aggregatedClassLoader,
Collection<ProgrammaticSearchMappingProvider> mappingProviders,
BlockingManager blockingManager, FailureCounter failureCounter) {
propertyChecker = ConfigurationPropertyChecker.create();
propertySource = indexProperties.createPropertySource(propertyChecker);
mappingKey = new InfinispanMappingKey();
mappingInitiator = new InfinispanMappingInitiator(introspector, mappingProviders, blockingManager, failureCounter);
// Enable annotated type discovery by default
mappingInitiator.annotatedTypeDiscoveryEnabled(true);
classLoaderService = (aggregatedClassLoader != null) ? new ClassLoaderServiceImpl(aggregatedClassLoader) : null;
}
public ProgrammaticMappingConfigurationContext programmaticMapping() {
return mappingInitiator.programmaticMapping();
}
/**
* Register a type as an entity type with the default name, its class name.
*
* @param type The type to be considered as an entity type.
* @return {@code this}, for call chaining.
*/
public SearchMappingBuilder addEntityType(Class<?> type) {
return addEntityType(type, type.getName());
}
/**
* Register a type as an entity type with the given name.
*
* @param type The type to be considered as an entity type.
* @param entityName The name of the entity.
* @return {@code this}, for call chaining.
*/
public SearchMappingBuilder addEntityType(Class<?> type, String entityName) {
mappingInitiator.addEntityType(type, entityName);
return this;
}
/**
* @param types The types to be considered as entity types.
* @return {@code this}, for call chaining.
*/
public SearchMappingBuilder addEntityTypes(Set<Class<?>> types) {
for (Class<?> type : types) {
addEntityType(type);
}
return this;
}
public SearchMappingBuilder setProvidedIdentifierBridge(BeanReference<? extends IdentifierBridge<Object>> providedIdentifierBridge) {
mappingInitiator.providedIdentifierBridge(providedIdentifierBridge);
return this;
}
public SearchMappingBuilder setEntityLoader(PojoSelectionEntityLoader<?> entityLoader) {
mappingInitiator.setEntityLoader(entityLoader);
return this;
}
public SearchMappingBuilder setEntityConverter(EntityConverter entityConverter) {
mappingInitiator.setEntityConverter(entityConverter);
return this;
}
public SearchMappingBuilder setProperty(String name, Object value) {
indexProperties.setProperty(name, value);
return this;
}
public SearchMappingBuilder setProperties(Map<String, Object> map) {
indexProperties.setProperties(map);
return this;
}
public SearchMapping build(Optional<SearchIntegration> previousIntegration) {
SearchIntegrationEnvironment.Builder envBuilder = SearchIntegrationEnvironment.builder(propertySource, propertyChecker);
if (classLoaderService != null) {
envBuilder.classResolver(classLoaderService);
envBuilder.resourceResolver(classLoaderService);
envBuilder.serviceResolver(classLoaderService);
}
SearchIntegrationEnvironment environment = envBuilder.build();
SearchIntegrationPartialBuildState integrationPartialBuildState = null;
SearchMapping mapping;
SearchIntegration integration;
try {
SearchIntegration.Builder integrationBuilder = (previousIntegration.isPresent()) ?
previousIntegration.get().restartBuilder(environment) :
SearchIntegration.builder(environment);
integrationBuilder.addMappingInitiator(mappingKey, mappingInitiator);
integrationPartialBuildState = integrationBuilder.prepareBuild();
SearchIntegrationFinalizer finalizer = integrationPartialBuildState.finalizer(propertySource, propertyChecker);
mapping = finalizer.finalizeMapping(mappingKey, (context, partialMapping) -> partialMapping.finalizeMapping());
integration = finalizer.finalizeIntegration();
} catch (RuntimeException e) {
new SuppressingCloser(e)
.push(environment)
.push(SearchIntegrationPartialBuildState::closeOnFailure, integrationPartialBuildState);
throw e;
}
try {
/*
* Since the user doesn't have access to the integration, but only to the (closeable) mapping,
* make sure to close the integration whenever the mapping is closed by the user.
*/
InfinispanMapping mappingImpl = (InfinispanMapping) mapping;
mappingImpl.setIntegration(integration);
return mappingImpl;
} catch (RuntimeException e) {
new SuppressingCloser(e).push(integration);
throw e;
}
}
}
| 7,307
| 43.024096
| 136
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/EntityConverter.java
|
package org.infinispan.search.mapper.mapping;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
/**
* Can convert an entity before indexing it.
*
* @author Fabio Massimo Ercoli
*/
public interface EntityConverter {
/**
* @return The type that is supposed to be converted
*/
Class<?> targetType();
/**
* @return The resulting converted type
*/
PojoRawTypeIdentifier<?> convertedTypeIdentifier();
/**
* Perform the conversion.
*
* @param entity The entity to convert
* @return The converted entity
*/
ConvertedEntity convert(Object entity);
/**
* The result of an entity conversion
*/
interface ConvertedEntity {
boolean skip();
String entityName();
Object value();
}
}
| 794
| 17.488372
| 72
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/SearchMappingCommonBuilding.java
|
package org.infinispan.search.mapper.mapping;
import java.util.Collection;
import java.util.Map;
import org.hibernate.search.backend.lucene.work.spi.LuceneWorkExecutorProvider;
import org.hibernate.search.engine.environment.bean.BeanReference;
import org.hibernate.search.mapper.pojo.bridge.IdentifierBridge;
import org.hibernate.search.mapper.pojo.model.spi.PojoBootstrapIntrospector;
import org.infinispan.query.concurrent.InfinispanIndexingFailureHandler;
import org.infinispan.util.concurrent.BlockingManager;
/**
* Stores some fields that could be useful to build a {@link SearchMappingBuilder} also at a later time.
*/
public class SearchMappingCommonBuilding {
private final BeanReference<? extends IdentifierBridge<Object>> identifierBridge;
private final Map<String, Object> properties;
private final ClassLoader aggregatedClassLoader;
private final Collection<ProgrammaticSearchMappingProvider> mappingProviders;
private final BlockingManager blockingManager;
private final LuceneWorkExecutorProvider luceneWorkExecutorProvider;
private final Integer numberOfShards;
public SearchMappingCommonBuilding(BeanReference<? extends IdentifierBridge<Object>> identifierBridge,
Map<String, Object> properties, ClassLoader aggregatedClassLoader,
Collection<ProgrammaticSearchMappingProvider> mappingProviders,
BlockingManager blockingManager,
LuceneWorkExecutorProvider luceneWorkExecutorProvider, Integer numberOfShards) {
this.identifierBridge = identifierBridge;
this.properties = properties;
this.aggregatedClassLoader = aggregatedClassLoader;
this.mappingProviders = mappingProviders;
this.blockingManager = blockingManager;
this.luceneWorkExecutorProvider = luceneWorkExecutorProvider;
this.numberOfShards = numberOfShards;
}
public SearchMappingBuilder builder(PojoBootstrapIntrospector introspector) {
InfinispanIndexingFailureHandler indexingFailureHandler = new InfinispanIndexingFailureHandler();
SearchMappingBuilder builder = SearchMapping.builder(introspector, aggregatedClassLoader, mappingProviders,
blockingManager, indexingFailureHandler.failureCounter())
.setProvidedIdentifierBridge(identifierBridge)
.setProperties(properties)
.setProperty("backend_work_executor_provider", luceneWorkExecutorProvider)
.setProperty("hibernate.search.background_failure_handler", indexingFailureHandler);
return builder;
}
}
| 2,649
| 49.961538
| 118
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/metamodel/ObjectFieldMetamodel.java
|
package org.infinispan.search.mapper.mapping.metamodel;
import java.util.LinkedHashMap;
import java.util.Map;
import org.hibernate.search.engine.backend.metamodel.IndexFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexObjectFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexObjectFieldTypeDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldTypeDescriptor;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class ObjectFieldMetamodel implements JsonSerialization {
private final boolean multiValued;
private final boolean multiValuedInRoot;
private final boolean nested;
private final Map<String, ValueFieldMetamodel> valueFields = new LinkedHashMap<>();
private final Map<String, ObjectFieldMetamodel> objectFields = new LinkedHashMap<>();
public ObjectFieldMetamodel(boolean multiValued, boolean multiValuedInRoot, IndexObjectFieldDescriptor descriptor) {
this.multiValued = multiValued;
this.multiValuedInRoot = multiValuedInRoot;
IndexObjectFieldTypeDescriptor type = descriptor.type();
nested = type.nested();
for (IndexFieldDescriptor field : descriptor.staticChildren()) {
String name = field.relativeName();
boolean fieldMultiValued = field.multiValued();
boolean fieldMultiValuedInRoot = field.multiValuedInRoot();
if (field.isValueField()) {
IndexValueFieldDescriptor valueField = field.toValueField();
IndexValueFieldTypeDescriptor fieldType = valueField.type();
valueFields.put(name, new ValueFieldMetamodel(fieldMultiValued, fieldMultiValuedInRoot, fieldType));
} else if (field.isObjectField()) {
// can recur safely since the index structure is a finite depth tree (no cycles)
objectFields.put(name, new ObjectFieldMetamodel(fieldMultiValued, fieldMultiValuedInRoot, field.toObjectField()));
}
}
}
public boolean isMultiValued() {
return multiValued;
}
public boolean isMultiValuedInRoot() {
return multiValuedInRoot;
}
public boolean isNested() {
return nested;
}
public Map<String, ValueFieldMetamodel> getValueFields() {
return valueFields;
}
public Map<String, ObjectFieldMetamodel> getObjectFields() {
return objectFields;
}
@Override
public Json toJson() {
Json object = Json.object("multi-valued", multiValued, "multi-valued-in-root", multiValuedInRoot, "nested", nested);
if (!valueFields.isEmpty()) {
object.set("value-fields", Json.make(valueFields));
}
if (!objectFields.isEmpty()) {
object.set("object-fields", Json.make(objectFields));
}
return object;
}
}
| 2,942
| 36.730769
| 126
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/metamodel/ValueFieldMetamodel.java
|
package org.infinispan.search.mapper.mapping.metamodel;
import java.util.Optional;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldTypeDescriptor;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class ValueFieldMetamodel implements JsonSerialization {
private final boolean multiValued;
private final boolean multiValuedInRoot;
private final Class<?> type;
private final Class<?> projectionType;
private final Class<?> argumentType;
private final boolean searchable;
private final boolean projectable;
private final boolean sortable;
private final boolean aggregable;
private final Optional<String> analyzer;
private final Optional<String> normalizer;
public ValueFieldMetamodel(boolean multiValued, boolean multiValuedInRoot, IndexValueFieldTypeDescriptor type) {
this.multiValued = multiValued;
this.multiValuedInRoot = multiValuedInRoot;
this.type = type.valueClass();
projectionType = type.projectedValueClass();
argumentType = type.dslArgumentClass();
searchable = type.searchable();
sortable = type.sortable();
projectable = type.projectable();
aggregable = type.aggregable();
analyzer = type.analyzerName();
normalizer = type.normalizerName();
}
public boolean isMultiValued() {
return multiValued;
}
public boolean isMultiValuedInRoot() {
return multiValuedInRoot;
}
public Class<?> getType() {
return type;
}
public Class<?> getProjectionType() {
return projectionType;
}
public Class<?> getArgumentType() {
return argumentType;
}
public boolean isSearchable() {
return searchable;
}
public boolean isProjectable() {
return projectable;
}
public boolean isSortable() {
return sortable;
}
public boolean isAggregable() {
return aggregable;
}
public Optional<String> getAnalyzer() {
return analyzer;
}
public Optional<String> getNormalizer() {
return normalizer;
}
@Override
public Json toJson() {
Json object = Json.object("multi-valued", multiValued, "multi-valued-in-root", multiValuedInRoot);
object.set("type", type);
object.set("projection-type", projectionType);
object.set("argument-type", argumentType);
object.set("searchable", searchable);
object.set("sortable", sortable);
object.set("projectable", projectable);
object.set("aggregable", aggregable);
if (analyzer.isPresent()) {
object.set("analyzer", analyzer.get());
}
if (normalizer.isPresent()) {
object.set("normalizer", normalizer.get());
}
return object;
}
}
| 2,814
| 25.064815
| 115
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/metamodel/IndexMetamodel.java
|
package org.infinispan.search.mapper.mapping.metamodel;
import java.util.LinkedHashMap;
import java.util.Map;
import org.hibernate.search.engine.backend.metamodel.IndexDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldTypeDescriptor;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.search.mapper.mapping.SearchIndexedEntity;
public class IndexMetamodel implements JsonSerialization {
private final String entityName;
private final String javaClassName;
private final String indexName;
private final Map<String, ValueFieldMetamodel> valueFields = new LinkedHashMap<>();
private final Map<String, ObjectFieldMetamodel> objectFields = new LinkedHashMap<>();
public IndexMetamodel(SearchIndexedEntity indexedEntity) {
IndexDescriptor descriptor = indexedEntity.indexManager().descriptor();
entityName = indexedEntity.name();
javaClassName = indexedEntity.javaClass().getName();
indexName = descriptor.hibernateSearchName();
for (IndexFieldDescriptor field : descriptor.staticFields()) {
String name = field.relativeName();
boolean multiValued = field.multiValued();
boolean multiValuedInRoot = field.multiValuedInRoot();
if (field.isValueField()) {
IndexValueFieldDescriptor valueField = field.toValueField();
IndexValueFieldTypeDescriptor type = valueField.type();
valueFields.put(name, new ValueFieldMetamodel(multiValued, multiValuedInRoot, type));
} else if (field.isObjectField()) {
objectFields.put(name, new ObjectFieldMetamodel(multiValued, multiValuedInRoot, field.toObjectField()));
}
}
}
public String getEntityName() {
return entityName;
}
public String getJavaClassName() {
return javaClassName;
}
public String getIndexName() {
return indexName;
}
public Map<String, ValueFieldMetamodel> getValueFields() {
return valueFields;
}
public Map<String, ObjectFieldMetamodel> getObjectFields() {
return objectFields;
}
@Override
public Json toJson() {
Json object = Json.object("entity-name", Json.make(entityName),
"java-class", Json.make(javaClassName),
"index-name", Json.make(indexName));
if (!valueFields.isEmpty()) {
object.set("value-fields", Json.make(valueFields));
}
if (!objectFields.isEmpty()) {
object.set("object-fields", Json.make(objectFields));
}
return object;
}
}
| 2,799
| 34.897436
| 116
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanTypeContextContainer.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeModel;
import org.infinispan.search.mapper.session.impl.InfinispanTypeContextProvider;
class InfinispanTypeContextContainer implements InfinispanTypeContextProvider {
// Use a LinkedHashMap for deterministic iteration
private final Map<String, InfinispanIndexedTypeContextImpl<?>> indexedTypeContextsByEntityName = new LinkedHashMap<>();
private final Map<Class<?>, InfinispanIndexedTypeContextImpl<?>> indexedTypeContextsByJavaType = new LinkedHashMap<>();
private InfinispanTypeContextContainer(Builder builder) {
for (InfinispanIndexedTypeContextImpl.Builder<?> contextBuilder : builder.indexedTypeContextBuilders) {
InfinispanIndexedTypeContextImpl<?> indexedTypeContext = contextBuilder.build();
indexedTypeContextsByEntityName.put(indexedTypeContext.name(), indexedTypeContext);
if (!indexedTypeContext.typeIdentifier().isNamed()) {
// If the type is named the java class is byte[] or ProtobufValueWrapper
// and multiple types may match that class, so we don't add it here.
indexedTypeContextsByJavaType.put(indexedTypeContext.typeIdentifier().javaClass(), indexedTypeContext);
}
}
}
@Override
@SuppressWarnings("unchecked")
public <E> InfinispanIndexedTypeContextImpl<E> indexedForExactType(Class<E> entityType) {
return (InfinispanIndexedTypeContextImpl<E>) indexedTypeContextsByJavaType.get(entityType);
}
@Override
public InfinispanIndexedTypeContextImpl<?> indexedForEntityName(String indexName) {
return indexedTypeContextsByEntityName.get(indexName);
}
@Override
public Collection<PojoRawTypeIdentifier<?>> allTypeIdentifiers() {
return indexedTypeContextsByEntityName.values().stream()
.map(InfinispanIndexedTypeContextImpl::typeIdentifier).collect(Collectors.toList());
}
Collection<InfinispanIndexedTypeContextImpl<?>> allIndexed() {
return indexedTypeContextsByEntityName.values();
}
static class Builder {
private final List<InfinispanIndexedTypeContextImpl.Builder<?>> indexedTypeContextBuilders = new ArrayList<>();
Builder() {
}
<E> InfinispanIndexedTypeContextImpl.Builder<E> addIndexed(PojoRawTypeModel<E> typeModel, String entityName) {
InfinispanIndexedTypeContextImpl.Builder<E> builder =
new InfinispanIndexedTypeContextImpl.Builder<>(typeModel.typeIdentifier(), entityName);
indexedTypeContextBuilders.add(builder);
return builder;
}
InfinispanTypeContextContainer build() {
return new InfinispanTypeContextContainer(this);
}
}
}
| 2,998
| 40.652778
| 122
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanMappingPartialBuildState.java
|
package org.infinispan.search.mapper.mapping.impl;
import org.hibernate.search.engine.mapper.mapping.building.spi.MappingPartialBuildState;
import org.hibernate.search.engine.mapper.mapping.spi.MappingImplementor;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.mapping.spi.PojoMappingDelegate;
import org.infinispan.query.concurrent.FailureCounter;
import org.infinispan.search.mapper.mapping.EntityConverter;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.util.concurrent.BlockingManager;
public class InfinispanMappingPartialBuildState implements MappingPartialBuildState {
private final PojoMappingDelegate mappingDelegate;
private final InfinispanTypeContextContainer typeContextContainer;
private final PojoSelectionEntityLoader<?> entityLoader;
private final EntityConverter entityConverter;
private final BlockingManager blockingManager;
private final FailureCounter failureCounter;
InfinispanMappingPartialBuildState(PojoMappingDelegate mappingDelegate,
InfinispanTypeContextContainer typeContextContainer,
PojoSelectionEntityLoader<?> entityLoader,
EntityConverter entityConverter,
BlockingManager blockingManager,
FailureCounter failureCounter) {
this.mappingDelegate = mappingDelegate;
this.typeContextContainer = typeContextContainer;
this.entityLoader = entityLoader;
this.entityConverter = entityConverter;
this.blockingManager = blockingManager;
this.failureCounter = failureCounter;
}
@Override
public void closeOnFailure() {
mappingDelegate.close();
}
public MappingImplementor<SearchMapping> finalizeMapping() {
return new InfinispanMapping(mappingDelegate, typeContextContainer, entityLoader, entityConverter,
blockingManager, failureCounter);
}
}
| 2,068
| 44.977778
| 104
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanIndexedTypeContextImpl.java
|
package org.infinispan.search.mapper.mapping.impl;
import org.hibernate.search.engine.backend.index.IndexManager;
import org.hibernate.search.engine.mapper.mapping.spi.MappedIndexManager;
import org.hibernate.search.engine.search.projection.spi.ProjectionMappedTypeContext;
import org.hibernate.search.mapper.pojo.identity.spi.IdentifierMapping;
import org.hibernate.search.mapper.pojo.mapping.building.spi.PojoIndexedTypeExtendedMappingCollector;
import org.hibernate.search.mapper.pojo.model.path.spi.PojoPathFilter;
import org.hibernate.search.mapper.pojo.model.spi.PojoPropertyModel;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.infinispan.search.mapper.mapping.SearchIndexedEntity;
import org.infinispan.search.mapper.session.impl.InfinispanIndexedTypeContext;
class InfinispanIndexedTypeContextImpl<E> implements SearchIndexedEntity, ProjectionMappedTypeContext,
InfinispanIndexedTypeContext<E> {
private final PojoRawTypeIdentifier<E> typeIdentifier;
private final String entityName;
private final IdentifierMapping identifierMapping;
private final MappedIndexManager indexManager;
private InfinispanIndexedTypeContextImpl(Builder<E> builder) {
this.typeIdentifier = builder.typeIdentifier;
this.entityName = builder.entityName;
this.identifierMapping = builder.identifierMapping;
this.indexManager = builder.indexManager;
}
@Override
public PojoRawTypeIdentifier<E> typeIdentifier() {
return typeIdentifier;
}
@Override
public String name() {
return entityName;
}
@Override
public IdentifierMapping identifierMapping() {
return identifierMapping;
}
@Override
public Class<?> javaClass() {
return typeIdentifier.javaClass();
}
@Override
public boolean loadingAvailable() {
return true;
}
@Override
public IndexManager indexManager() {
return indexManager.toAPI();
}
static class Builder<E> implements PojoIndexedTypeExtendedMappingCollector {
private final PojoRawTypeIdentifier<E> typeIdentifier;
private final String entityName;
private IdentifierMapping identifierMapping;
private MappedIndexManager indexManager;
private PojoPathFilter dirtyFilter;
Builder(PojoRawTypeIdentifier<E> typeIdentifier, String entityName) {
this.typeIdentifier = typeIdentifier;
this.entityName = entityName;
}
@Override
public void documentIdSourceProperty(PojoPropertyModel<?> documentIdSourceProperty) {
// Nothing to do
}
@Override
public void identifierMapping(IdentifierMapping identifierMapping) {
this.identifierMapping = identifierMapping;
}
@Override
public void dirtyFilter(PojoPathFilter dirtyFilter) {
// Nothing to do
}
@Override
public void indexManager(MappedIndexManager indexManager) {
this.indexManager = indexManager;
}
InfinispanIndexedTypeContextImpl<E> build() {
return new InfinispanIndexedTypeContextImpl<>(this);
}
}
}
| 3,123
| 31.541667
| 102
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanMapping.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.lang.invoke.MethodHandles;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.hibernate.search.engine.backend.common.spi.EntityReferenceFactory;
import org.hibernate.search.engine.common.spi.SearchIntegration;
import org.hibernate.search.engine.environment.thread.spi.ThreadPoolProvider;
import org.hibernate.search.engine.reporting.FailureHandler;
import org.hibernate.search.engine.search.projection.spi.ProjectionMappedTypeContext;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.mapping.spi.AbstractPojoMappingImplementor;
import org.hibernate.search.mapper.pojo.mapping.spi.PojoMappingDelegate;
import org.hibernate.search.mapper.pojo.massindexing.spi.PojoMassIndexerAgent;
import org.hibernate.search.mapper.pojo.massindexing.spi.PojoMassIndexerAgentCreateContext;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeIdentifier;
import org.hibernate.search.mapper.pojo.scope.spi.PojoScopeDelegate;
import org.hibernate.search.util.common.AssertionFailure;
import org.hibernate.search.util.common.impl.Closer;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;
import org.infinispan.query.concurrent.FailureCounter;
import org.hibernate.search.engine.common.EntityReference;
import org.infinispan.search.mapper.common.impl.EntityReferenceImpl;
import org.infinispan.search.mapper.log.impl.Log;
import org.infinispan.search.mapper.mapping.EntityConverter;
import org.infinispan.search.mapper.mapping.SearchIndexedEntity;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.search.mapper.mapping.metamodel.IndexMetamodel;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.scope.impl.SearchScopeImpl;
import org.infinispan.search.mapper.session.SearchSession;
import org.infinispan.search.mapper.session.impl.InfinispanIndexedTypeContext;
import org.infinispan.search.mapper.session.impl.InfinispanSearchSession;
import org.infinispan.search.mapper.session.impl.InfinispanSearchSessionMappingContext;
import org.infinispan.search.mapper.work.SearchIndexer;
import org.infinispan.search.mapper.work.impl.SearchIndexerImpl;
import org.infinispan.util.concurrent.BlockingManager;
public class InfinispanMapping extends AbstractPojoMappingImplementor<SearchMapping>
implements SearchMapping, InfinispanSearchSessionMappingContext, EntityReferenceFactory {
private static final Log log = LoggerFactory.make(Log.class, MethodHandles.lookup());
private final InfinispanTypeContextContainer typeContextContainer;
private final PojoSelectionEntityLoader<?> entityLoader;
private final EntityConverter entityConverter;
private final SearchSession mappingSession;
private final SearchIndexer searchIndexer;
private final FailureCounter failureCounter;
private final Set<String> allIndexedEntityNames;
private final Set<Class<?>> allIndexedEntityJavaClasses;
private SearchIntegration integration;
private boolean close = false;
InfinispanMapping(PojoMappingDelegate mappingDelegate, InfinispanTypeContextContainer typeContextContainer,
PojoSelectionEntityLoader<?> entityLoader, EntityConverter entityConverter,
BlockingManager blockingManager, FailureCounter failureCounter) {
super(mappingDelegate);
this.typeContextContainer = typeContextContainer;
this.entityLoader = entityLoader;
this.entityConverter = entityConverter;
this.mappingSession = new InfinispanSearchSession(this, entityLoader);
this.searchIndexer = new SearchIndexerImpl(mappingSession.createIndexer(), entityConverter, typeContextContainer,
blockingManager);
this.failureCounter = failureCounter;
this.allIndexedEntityNames = typeContextContainer.allIndexed().stream()
.map(SearchIndexedEntity::name).collect(Collectors.toSet());
this.allIndexedEntityJavaClasses = typeContextContainer.allIndexed().stream()
.map(SearchIndexedEntity::javaClass).collect(Collectors.toSet());
}
@Override
public void close() {
try (Closer<RuntimeException> closer = new Closer<>()) {
closer.push(SearchIntegration::close, integration);
closer.push(SearchIndexer::close, searchIndexer);
close = true;
}
}
@Override
public boolean isClose() {
return close;
}
@Override
public <E> SearchScope<E> scope(Collection<? extends Class<? extends E>> targetedTypes) {
return createScope(targetedTypes);
}
@Override
public SearchScope<?> scopeAll() {
return doCreateScope(typeContextContainer.allTypeIdentifiers());
}
@Override
public SearchSession getMappingSession() {
return mappingSession;
}
@Override
public SearchIndexer getSearchIndexer() {
return searchIndexer;
}
@Override
public SearchIndexedEntity indexedEntity(Class<?> entityType) {
return typeContextContainer.indexedForExactType(entityType);
}
@Override
public SearchIndexedEntity indexedEntity(String entityName) {
return typeContextContainer.indexedForEntityName(entityName);
}
@Override
public Collection<? extends SearchIndexedEntity> allIndexedEntities() {
return typeContextContainer.allIndexed();
}
@Override
public Set<String> allIndexedEntityNames() {
return allIndexedEntityNames;
}
@Override
public Set<Class<?>> allIndexedEntityJavaClasses() {
return allIndexedEntityJavaClasses;
}
@Override
public Class<?> toConvertedEntityJavaClass(Object value) {
if (value == null) {
return null;
}
Class<?> c = value.getClass();
if (entityConverter != null && c.equals(entityConverter.targetType())) {
return entityConverter.convertedTypeIdentifier().javaClass();
} else {
return c;
}
}
@Override
public Map<String, IndexMetamodel> metamodel() {
return allIndexedEntities().stream()
.map(indexedEntity -> new IndexMetamodel(indexedEntity))
.collect(Collectors.toMap(IndexMetamodel::getEntityName, Function.identity()));
}
@Override
public int genericIndexingFailures() {
return failureCounter.genericFailures();
}
@Override
public int entityIndexingFailures() {
return failureCounter.entityFailures();
}
@Override
public FailureHandler getFailureHandler() {
return delegate().failureHandler();
}
@Override
@SuppressWarnings("unchecked")
public <E> SearchScopeImpl<E> createScope(Collection<? extends Class<? extends E>> classes) {
Class<?> converterTargetType = entityConverter == null ? null : entityConverter.targetType();
List<PojoRawTypeIdentifier<? extends E>> typeIdentifiers = new ArrayList<>(classes.size());
for (Class<? extends E> clazz : classes) {
if (clazz.equals(converterTargetType)) {
// Include all protobuf types
typeIdentifiers.add((PojoRawTypeIdentifier<? extends E>) entityConverter.convertedTypeIdentifier());
} else {
typeIdentifiers.add(PojoRawTypeIdentifier.of(clazz));
}
}
return doCreateScope(typeIdentifiers);
}
@Override
public <E> SearchScopeImpl<E> createScope(Class<E> expectedSuperType, Collection<String> entityNames) {
List<PojoRawTypeIdentifier<? extends E>> typeIdentifiers = new ArrayList<>(entityNames.size());
for (String entityName : entityNames) {
typeIdentifiers.add(entityTypeIdentifier(expectedSuperType, entityName));
}
return doCreateScope(typeIdentifiers);
}
@Override
public SearchMapping toConcreteType() {
return this;
}
@Override
public ThreadPoolProvider threadPoolProvider() {
return delegate().threadPoolProvider();
}
@Override
public FailureHandler failureHandler() {
return delegate().failureHandler();
}
@Override
public PojoMassIndexerAgent createMassIndexerAgent(PojoMassIndexerAgentCreateContext context) {
// No coordination: we don't prevent automatic indexing from continuing while mass indexing.
return PojoMassIndexerAgent.noOp();
}
@Override
public EntityReference createEntityReference(String typeName, Object identifier) {
InfinispanIndexedTypeContext<?> typeContext = typeContextContainer.indexedForEntityName(typeName);
if (typeContext == null) {
throw new AssertionFailure(
"Type name " + typeName + " refers to an unknown type"
);
}
return new EntityReferenceImpl(typeContext.typeIdentifier(), typeContext.name(), identifier);
}
public SearchIntegration getIntegration() {
return integration;
}
public void setIntegration(SearchIntegration integration) {
this.integration = integration;
}
private <E> SearchScopeImpl<E> doCreateScope(Collection<PojoRawTypeIdentifier<? extends E>> typeIdentifiers) {
PojoScopeDelegate<EntityReference, E, PojoRawTypeIdentifier<? extends E>> pojoScopeDelegate =
delegate().createPojoScope(this, typeIdentifiers,
// Store the type identifier as additional metadata
typeIdentifier -> typeIdentifier);
return new SearchScopeImpl(this, pojoScopeDelegate, this.entityLoader);
}
private <T> PojoRawTypeIdentifier<? extends T> entityTypeIdentifier(Class<T> expectedSuperType, String entityName) {
InfinispanIndexedTypeContext<?> typeContext = typeContextContainer.indexedForEntityName(entityName);
if (typeContext == null) {
throw log.invalidEntityName(entityName);
}
PojoRawTypeIdentifier<?> typeIdentifier = typeContext.typeIdentifier();
Class<?> actualJavaType = typeIdentifier.javaClass();
if (!expectedSuperType.isAssignableFrom(actualJavaType)) {
throw log.invalidEntitySuperType(entityName, expectedSuperType, actualJavaType);
}
// The cast below is safe because we just checked above that the type extends "expectedSuperType", which extends T
@SuppressWarnings("unchecked")
PojoRawTypeIdentifier<? extends T> castedTypeIdentifier = (PojoRawTypeIdentifier<? extends T>) typeIdentifier;
return castedTypeIdentifier;
}
@Override
public ProjectionMappedTypeContext mappedTypeContext(String mappedTypeName) {
InfinispanIndexedTypeContextImpl<?> typeContext = typeContextContainer.indexedForEntityName(mappedTypeName);
if (typeContext == null) {
throw log.invalidEntityName(mappedTypeName);
}
return typeContext;
}
}
| 10,868
| 38.813187
| 120
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanContainedTypeContext.java
|
package org.infinispan.search.mapper.mapping.impl;
import org.hibernate.search.mapper.pojo.identity.spi.IdentifierMapping;
import org.hibernate.search.mapper.pojo.mapping.building.spi.PojoContainedTypeExtendedMappingCollector;
import org.hibernate.search.mapper.pojo.model.path.spi.PojoPathFilter;
import org.hibernate.search.mapper.pojo.model.spi.PojoPropertyModel;
/*
* There's nothing here at the moment, just a placeholder.
*/
class InfinispanContainedTypeContext {
private InfinispanContainedTypeContext() {
}
static class Builder implements PojoContainedTypeExtendedMappingCollector {
Builder() {
}
@Override
public void documentIdSourceProperty(PojoPropertyModel<?> documentIdSourceProperty) {
}
@Override
public void identifierMapping(IdentifierMapping identifierMapping) {
}
@Override
public void dirtyFilter(PojoPathFilter dirtyFilter) {
}
}
}
| 944
| 25.25
| 103
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/IndexProperties.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.util.HashMap;
import java.util.Map;
import org.hibernate.search.engine.cfg.ConfigurationPropertySource;
import org.hibernate.search.engine.cfg.EngineSettings;
import org.hibernate.search.engine.cfg.spi.AllAwareConfigurationPropertySource;
import org.hibernate.search.engine.cfg.spi.ConfigurationPropertyChecker;
/**
* @author Fabio Massimo Ercoli
*/
public class IndexProperties {
private final Map<String, Object> engineProperties = new HashMap<>();
private final Map<String, Object> backendProperties = new HashMap<>();
public void setProperty(String key, Object value) {
if (key.startsWith(EngineSettings.PREFIX)) {
// engine properties are passed to Search as they are,
// so they start with "hibernate.search."
engineProperties.put(key, value);
} else {
// backend properties are passed with BACKEND_PROPERTIES_PREFIX,
// so that the user doesn't need to set it for them
backendProperties.put(key, value);
}
}
public void setProperties(Map<String, Object> properties) {
properties.forEach(this::setProperty);
}
public ConfigurationPropertySource createPropertySource(ConfigurationPropertyChecker propertyChecker) {
ConfigurationPropertySource basePropertySource =
propertyChecker.wrap(AllAwareConfigurationPropertySource.fromMap(backendProperties))
.withPrefix(EngineSettings.BACKEND);
ConfigurationPropertySource propertySource =
basePropertySource.withOverride(AllAwareConfigurationPropertySource.fromMap(engineProperties));
defaultProperties();
return propertySource;
}
private void defaultProperties() {
backendProperties.put("type", "lucene");
backendProperties.put("analysis.configurer", new DefaultAnalysisConfigurer());
}
}
| 1,896
| 36.94
| 107
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/DefaultAnalysisConfigurer.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.util.Map;
import org.apache.lucene.analysis.Tokenizer;
import org.apache.lucene.analysis.core.KeywordTokenizer;
import org.apache.lucene.analysis.core.KeywordTokenizerFactory;
import org.apache.lucene.analysis.core.LowerCaseFilterFactory;
import org.apache.lucene.analysis.core.StopFilterFactory;
import org.apache.lucene.analysis.core.WhitespaceTokenizerFactory;
import org.apache.lucene.analysis.ngram.NGramTokenizerFactory;
import org.apache.lucene.analysis.snowball.SnowballPorterFilterFactory;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.analysis.standard.StandardTokenizerFactory;
import org.apache.lucene.analysis.util.TokenizerFactory;
import org.apache.lucene.util.AttributeFactory;
import org.hibernate.search.backend.lucene.analysis.LuceneAnalysisConfigurationContext;
import org.hibernate.search.backend.lucene.analysis.LuceneAnalysisConfigurer;
public class DefaultAnalysisConfigurer implements LuceneAnalysisConfigurer {
public static final String STANDARD_ANALYZER_NAME = "standard";
@Override
public void configure(LuceneAnalysisConfigurationContext context) {
context.analyzer(STANDARD_ANALYZER_NAME)
.instance(new StandardAnalyzer());
context.analyzer("simple").custom()
.tokenizer(StandardTokenizerFactory.class)
.tokenFilter(LowerCaseFilterFactory.class);
context.analyzer("whitespace").custom()
.tokenizer(WhitespaceTokenizerFactory.class);
context.analyzer("keyword").custom()
.tokenizer(KeywordTokenizerFactory.class);
context.analyzer("stemmer").custom()
.tokenizer(StandardTokenizerFactory.class)
.tokenFilter(LowerCaseFilterFactory.class)
.tokenFilter(StopFilterFactory.class)
.tokenFilter(SnowballPorterFilterFactory.class)
.param("language", "English");
context.analyzer("ngram").custom()
.tokenizer(NGramTokenizerFactory.class)
.param("minGramSize", "3")
.param("maxGramSize", "3")
.tokenFilter(LowerCaseFilterFactory.class)
.tokenFilter(StopFilterFactory.class);
context.analyzer("filename").custom()
.tokenizer(ConfigurableBufferSizeKeywordTokenizerFactory.class)
.param("bufferSize", "2048")
.tokenFilter(LowerCaseFilterFactory.class);
context.normalizer("lowercase").custom()
.tokenFilter(LowerCaseFilterFactory.class);
}
/**
* Similar to {@link KeywordTokenizerFactory} but with a configurable buffer size. This tokenizer factory accepts an
* integer param named <code>"bufferSize"</code> that defaults to <code>256</code>.
*/
public static final class ConfigurableBufferSizeKeywordTokenizerFactory extends TokenizerFactory {
private final int bufferSize;
public ConfigurableBufferSizeKeywordTokenizerFactory(Map<String, String> args) {
super(args);
bufferSize = getInt(args, "bufferSize", KeywordTokenizer.DEFAULT_BUFFER_SIZE);
if (!args.isEmpty()) {
throw new IllegalArgumentException("Unknown parameters: " + args);
}
}
@Override
public Tokenizer create(AttributeFactory factory) {
return new KeywordTokenizer(factory, bufferSize);
}
}
}
| 3,410
| 39.607143
| 119
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/ClassLoaderServiceImpl.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.net.URL;
import java.util.ServiceLoader;
import org.hibernate.search.engine.environment.classpath.spi.ClassResolver;
import org.hibernate.search.engine.environment.classpath.spi.ResourceResolver;
import org.hibernate.search.engine.environment.classpath.spi.ServiceResolver;
import org.hibernate.search.util.common.logging.impl.LoggerFactory;
import org.infinispan.search.mapper.log.impl.Log;
/**
* An implementation of the {@link ClassResolver}, {@link ResourceResolver} and {@link ServiceResolver}
* contracts that just delegates loading to an actual {@link ClassLoader}.
*
* @author anistor@redhat.com
* @since 9.2
*/
public final class ClassLoaderServiceImpl implements ClassResolver, ResourceResolver, ServiceResolver {
private static final Log log = LoggerFactory.make( Log.class, MethodHandles.lookup() );
private final ClassLoader classLoader;
public ClassLoaderServiceImpl(ClassLoader classLoader) {
this.classLoader = classLoader;
}
@Override
public Class<?> classForName(String className) {
try {
return Class.forName(className, true, classLoader);
} catch (Exception | LinkageError e) {
throw log.unableToLoadTheClass( className, e );
}
}
@Override
public InputStream locateResourceStream(String name) {
try {
InputStream is = classLoader.getResourceAsStream(name);
if (is != null) {
return is;
}
} catch (Exception e) {
// ignored
}
if (name.startsWith("/")) {
String stripped = name.substring(1);
try {
return new URL(stripped).openStream();
} catch (Exception e) {
// ignored
}
try {
return classLoader.getResourceAsStream(stripped);
} catch (Exception e) {
// ignored
}
}
return null;
}
@Override
public <S> Iterable<S> loadJavaServices(Class<S> serviceContract) {
return ServiceLoader.load(serviceContract, classLoader);
}
}
| 2,171
| 28.351351
| 103
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanMapperDelegate.java
|
package org.infinispan.search.mapper.mapping.impl;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.hibernate.search.mapper.pojo.mapping.building.spi.PojoContainedTypeExtendedMappingCollector;
import org.hibernate.search.mapper.pojo.mapping.building.spi.PojoIndexedTypeExtendedMappingCollector;
import org.hibernate.search.mapper.pojo.mapping.building.spi.PojoMapperDelegate;
import org.hibernate.search.mapper.pojo.mapping.spi.PojoMappingDelegate;
import org.hibernate.search.mapper.pojo.model.spi.PojoRawTypeModel;
import org.infinispan.query.concurrent.FailureCounter;
import org.infinispan.search.mapper.mapping.EntityConverter;
import org.infinispan.util.concurrent.BlockingManager;
public final class InfinispanMapperDelegate implements PojoMapperDelegate<InfinispanMappingPartialBuildState> {
private final InfinispanTypeContextContainer.Builder typeContextContainerBuilder =
new InfinispanTypeContextContainer.Builder();
private final PojoSelectionEntityLoader<?> entityLoader;
private final EntityConverter entityConverter;
private final BlockingManager blockingManager;
private final FailureCounter failureCounter;
public InfinispanMapperDelegate(PojoSelectionEntityLoader<?> entityLoader, EntityConverter entityConverter,
BlockingManager blockingManager, FailureCounter failureCounter) {
this.entityLoader = entityLoader;
this.entityConverter = entityConverter;
this.blockingManager = blockingManager;
this.failureCounter = failureCounter;
}
@Override
public void closeOnFailure() {
// Nothing to do
}
@Override
public <E> PojoIndexedTypeExtendedMappingCollector createIndexedTypeExtendedMappingCollector(
PojoRawTypeModel<E> rawTypeModel, String entityName) {
return typeContextContainerBuilder.addIndexed(rawTypeModel, entityName);
}
@Override
public <E> PojoContainedTypeExtendedMappingCollector createContainedTypeExtendedMappingCollector(
PojoRawTypeModel<E> rawTypeModel, String entityName) {
// This is a placeholder: we don't care about contained types at the moment.
return new InfinispanContainedTypeContext.Builder();
}
@Override
public InfinispanMappingPartialBuildState prepareBuild(PojoMappingDelegate mappingDelegate) {
return new InfinispanMappingPartialBuildState(mappingDelegate, typeContextContainerBuilder.build(),
entityLoader, entityConverter, blockingManager, failureCounter);
}
}
| 2,549
| 46.222222
| 111
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/InfinispanMappingKey.java
|
package org.infinispan.search.mapper.mapping.impl;
import org.hibernate.search.engine.mapper.mapping.building.spi.MappingKey;
import org.infinispan.search.mapper.log.impl.InfinispanEventContextMessages;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.jboss.logging.Messages;
public final class InfinispanMappingKey implements MappingKey<InfinispanMappingPartialBuildState, SearchMapping> {
private static final InfinispanEventContextMessages MESSAGES =
Messages.getBundle(InfinispanEventContextMessages.class);
@Override
public String render() {
return MESSAGES.mapping();
}
}
| 630
| 34.055556
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/search/mapper/mapping/impl/CompositeAnalysisConfigurer.java
|
package org.infinispan.search.mapper.mapping.impl;
import java.util.Collection;
import org.hibernate.search.backend.lucene.analysis.LuceneAnalysisConfigurationContext;
import org.hibernate.search.backend.lucene.analysis.LuceneAnalysisConfigurer;
public class CompositeAnalysisConfigurer implements LuceneAnalysisConfigurer {
private final Collection<LuceneAnalysisConfigurer> children;
public CompositeAnalysisConfigurer(Collection<LuceneAnalysisConfigurer> children) {
this.children = children;
}
@Override
public void configure(LuceneAnalysisConfigurationContext luceneAnalysisConfigurationContext) {
for (LuceneAnalysisConfigurer child : children) {
child.configure(luceneAnalysisConfigurationContext);
}
}
}
| 763
| 32.217391
| 97
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/package-info.java
|
/**
* Query API that lets you perform Ickle queries and look up values in caches.
* You can use the Query API with both embedded and remote caches.
*
* @api.public
*/
package org.infinispan.query;
| 202
| 24.375
| 78
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/Indexer.java
|
package org.infinispan.query;
import java.util.concurrent.CompletionStage;
/**
* Interacts directly with cache indexes.
*
* @since 11.0
*/
public interface Indexer {
/**
* Deletes all indexes for the cache and rebuilds them.
* The indexing operation can take a long time to complete, depending on the size of the cache.
* You should not query caches until the indexing operation is complete because it affects query performance and results.
*/
CompletionStage<Void> run();
/**
* same as {@link #run()} but will only re-index data from the local member.
*/
CompletionStage<Void> runLocal();
/**
* Re-indexes values associated with the provided keys only.
*/
CompletionStage<Void> run(Object... keys);
/**
* Removes all indexes from the cache.
*/
CompletionStage<Void> remove();
/**
* Removes all entities of a particular class from the index of the cache.
*/
CompletionStage<Void> remove(Class<?>... entities);
/**
* @return true if the indexer process was started on this node and has not finished yet.
*/
boolean isRunning();
}
| 1,134
| 24.222222
| 124
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/Search.java
|
package org.infinispan.query;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilterConverter;
import org.infinispan.objectfilter.ObjectFilter;
import org.infinispan.query.api.continuous.ContinuousQuery;
import org.infinispan.query.core.impl.EmbeddedQueryFactory;
import org.infinispan.query.core.impl.continuous.ContinuousQueryImpl;
import org.infinispan.query.core.impl.eventfilter.IckleCacheEventFilterConverter;
import org.infinispan.query.core.impl.eventfilter.IckleFilterAndConverter;
import org.infinispan.query.core.stats.SearchStatistics;
import org.infinispan.query.core.stats.SearchStatisticsSnapshot;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.embedded.impl.ObjectReflectionMatcher;
import org.infinispan.query.dsl.embedded.impl.QueryEngine;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.security.AuthorizationManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.actions.SecurityActions;
/**
* Entry point for performing Infinispan queries.
* Provides the {@link QueryFactory} that you use to build Ickle queries, continuous queries, and event filters for indexed and non-indexed caches.
*
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
* @author anistor@redhat.com
*/
public final class Search {
private Search() {
// prevent instantiation
}
/**
* Creates an event filter from an Ickle query string.
*/
public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult> makeFilter(String queryString) {
return makeFilter(queryString, null);
}
/**
* Creates event filters from Ickle query strings.
*/
public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult> makeFilter(String queryString, Map<String, Object> namedParameters) {
IckleFilterAndConverter<K, V> filterAndConverter = new IckleFilterAndConverter<>(queryString, namedParameters, ObjectReflectionMatcher.class);
return new IckleCacheEventFilterConverter<>(filterAndConverter);
}
/**
* Creates event filters from Ickle query strings.
*/
public static <K, V> CacheEventFilterConverter<K, V, ObjectFilter.FilterResult> makeFilter(Query<?> query) {
return makeFilter(query.getQueryString(), query.getParameters());
}
/**
* Obtains a query factory to build DSL-based Ickle queries.
*/
public static QueryFactory getQueryFactory(Cache<?, ?> cache) {
if (cache == null) {
throw new IllegalArgumentException("The cache parameter cannot be null.");
}
AdvancedCache<?, ?> advancedCache = cache.getAdvancedCache();
if (advancedCache == null) {
throw new IllegalArgumentException("The given cache must expose an AdvancedCache interface.");
}
checkBulkReadPermission(advancedCache);
QueryEngine<?> queryEngine = ComponentRegistryUtils.getEmbeddedQueryEngine(advancedCache);
return new EmbeddedQueryFactory(queryEngine);
}
/**
* Obtains the {@link ContinuousQuery} object for the cache.
*/
public static <K, V> ContinuousQuery<K, V> getContinuousQuery(Cache<K, V> cache) {
return new ContinuousQueryImpl<>(cache);
}
private static <K, V> AdvancedCache<K, V> getAdvancedCache(Cache<K, V> cache) {
AdvancedCache<K, V> advancedCache = Objects.requireNonNull(cache, "The cache parameter cannot be null.").getAdvancedCache();
if (advancedCache == null) {
throw new IllegalArgumentException("The given cache must expose an AdvancedCache interface.");
}
checkBulkReadPermission(advancedCache);
return advancedCache;
}
/**
* @return Obtains the {@link Indexer} instance for the cache.
* @since 11.0
*/
public static <K, V> Indexer getIndexer(Cache<K, V> cache) {
AdvancedCache<K, V> advancedCache = getAdvancedCache(cache);
return ComponentRegistryUtils.getIndexer(advancedCache);
}
private static void checkBulkReadPermission(AdvancedCache<?, ?> cache) {
AuthorizationManager authorizationManager = SecurityActions.getCacheAuthorizationManager(cache);
if (authorizationManager != null) {
authorizationManager.checkPermission(AuthorizationPermission.BULK_READ);
}
}
/**
* Returns search statistics for the local node.
*/
public static <K, V> SearchStatistics getSearchStatistics(Cache<K, V> cache) {
return ComponentRegistryUtils.getSearchStatsRetriever(cache).getSearchStatistics();
}
/**
* Returns aggregated search statistics for all nodes in the cluster.
*/
public static CompletionStage<SearchStatisticsSnapshot> getClusteredSearchStatistics(Cache<?, ?> cache) {
return ComponentRegistryUtils.getSearchStatsRetriever(cache).getDistributedSearchStatistics();
}
}
| 5,079
| 39.967742
| 152
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/Transformer.java
|
package org.infinispan.query;
/**
* Converts objects (cache keys only) to and from their Java types to String representations so that Infinispan can index them.
* You need to convert custom types only.
* Infinispan transforms boxed primitives, java.lang.String, java.util.UUID, and byte arrays internally.
* <p>
* Implementations must be thread-safe! It is recommended they are also stateless.
*
* @author Manik Surtani
* @since 4.0
*/
public interface Transformer {
/**
* Transforms a String into an Object.
*
* @param str cannot be null
* @return the Object that is encoded in the given String
*/
Object fromString(String str);
/**
* Transforms an Object into a String.
*
* @param obj cannot be null
* @return the String representation of the object
*/
String toString(Object obj);
}
| 850
| 26.451613
| 127
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/Transformable.java
|
package org.infinispan.query;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.infinispan.query.impl.DefaultTransformer;
/**
* Annotate objects to convert them to keys that Infinispan can index.
* You need to annotate custom types only.
*
* @author Manik Surtani
* @since 4.0
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transformable {
/**
* The {@link Transformer} to use. Please specify your custom transformer instead of relying on the default one which
* is slow.
*/
Class<? extends Transformer> transformer() default DefaultTransformer.class;
}
| 740
| 26.444444
| 120
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/concurrent/InfinispanIndexingExecutorProvider.java
|
package org.infinispan.query.concurrent;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.hibernate.search.backend.lucene.work.spi.LuceneWorkExecutorProvider;
import org.hibernate.search.engine.common.execution.spi.SimpleScheduledExecutor;
import org.infinispan.factories.AbstractComponentFactory;
import org.infinispan.factories.AutoInstantiableFactory;
import org.infinispan.factories.annotations.DefaultFactoryFor;
import org.infinispan.factories.annotations.Inject;
import org.infinispan.factories.scopes.Scope;
import org.infinispan.factories.scopes.Scopes;
import org.infinispan.util.concurrent.BlockingManager;
@Scope(Scopes.GLOBAL)
@DefaultFactoryFor(classes = LuceneWorkExecutorProvider.class)
public class InfinispanIndexingExecutorProvider extends AbstractComponentFactory implements AutoInstantiableFactory, LuceneWorkExecutorProvider {
@Inject
BlockingManager blockingManager;
@Override
public Object construct(String name) {
return new InfinispanIndexingExecutorProvider();
}
@Override
public SimpleScheduledExecutor writeExecutor(Context context) {
return InfinispanIndexingExecutorProvider.writeExecutor(blockingManager);
}
public static SimpleScheduledExecutor writeExecutor(BlockingManager blockingManager) {
return new InfinispanScheduledExecutor(blockingManager);
}
static final class InfinispanScheduledExecutor implements SimpleScheduledExecutor {
private final BlockingManager blockingManager;
public InfinispanScheduledExecutor(BlockingManager blockingManager) {
this.blockingManager = blockingManager;
}
@Override
public Future<?> submit(Runnable task) {
return blockingManager.runBlocking(task, this).toCompletableFuture();
}
@Override
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
return blockingManager.scheduleRunBlocking(command, delay, unit, this);
}
@Override
public void shutdownNow() {
// The executors lifecycle is handled at global Infinispan level
}
@Override
public boolean isBlocking() {
// If the invoking thread is non-blocking and the blocking pool and its queue are full, then it will throw an exception.
// If the invoking thread is blocking and the blocking pool and its queue are full, then it will run the task immediately in the invoking thread.
// In either case the invocation is not "blocking" but it may not return immediately as it is performing the task.
return false;
}
}
}
| 2,676
| 37.242857
| 154
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/concurrent/InfinispanIndexingFailureHandler.java
|
package org.infinispan.query.concurrent;
import org.hibernate.search.engine.reporting.EntityIndexingFailureContext;
import org.hibernate.search.engine.reporting.FailureContext;
import org.hibernate.search.engine.reporting.FailureHandler;
import org.hibernate.search.engine.reporting.impl.LogFailureHandler;
public class InfinispanIndexingFailureHandler implements FailureHandler {
private final FailureCounter failureCounter = new FailureCounter();
private final FailureHandler baseFailureHandler = new LogFailureHandler();
@Override
public void handle(FailureContext context) {
failureCounter.genericFailures.incrementAndGet();
baseFailureHandler.handle(context);
}
@Override
public void handle(EntityIndexingFailureContext context) {
failureCounter.entityFailures.incrementAndGet();
baseFailureHandler.handle(context);
}
public FailureCounter failureCounter() {
return failureCounter;
}
}
| 957
| 32.034483
| 77
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/concurrent/FailureCounter.java
|
package org.infinispan.query.concurrent;
import java.util.concurrent.atomic.AtomicInteger;
public final class FailureCounter {
final AtomicInteger genericFailures = new AtomicInteger(0);
final AtomicInteger entityFailures = new AtomicInteger(0);
public int genericFailures() {
return genericFailures.get();
}
public int entityFailures() {
return entityFailures.get();
}
}
| 407
| 21.666667
| 62
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/logging/Log.java
|
package org.infinispan.query.logging;
import static org.jboss.logging.Logger.Level.DEBUG;
import static org.jboss.logging.Logger.Level.ERROR;
import static org.jboss.logging.Logger.Level.INFO;
import static org.jboss.logging.Logger.Level.WARN;
import org.hibernate.search.engine.common.EntityReference;
import org.hibernate.search.util.common.SearchException;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.CacheException;
import org.infinispan.objectfilter.ParsingException;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
import jakarta.transaction.Transaction;
//TODO [anistor] query-core and query modules share the id range!
/**
* Log abstraction for the query module. For this module, message ids
* ranging from 14001 to 14500 inclusively have been reserved.
*
* @author Galder Zamarreño
* @author Sanne Grinovero
* @since 5.0
*/
@MessageLogger(projectCode = "ISPN")
//@ValidIdRange(min = 14001, max = 14500)
public interface Log extends org.infinispan.query.core.impl.Log {
Log CONTAINER = Logger.getMessageLogger(Log.class, LOG_ROOT + "CONTAINER");
@Message(value = "The configured entity class %s is not indexable. Please remove it from the indexing configuration.", id = 404)
CacheConfigurationException classNotIndexable(String className);
@LogMessage(level = ERROR)
@Message(value = "Could not locate key class %s", id = 14001)
void keyClassNotFound(String keyClassName, @Cause Exception e);
@LogMessage(level = ERROR)
@Message(value = "Cannot instantiate Transformer class %s", id = 14002)
void couldNotInstantiateTransformerClass(Class<?> transformer, @Cause Exception e);
@LogMessage(level = INFO)
@Message(value = "Registering Query interceptor for cache %s", id = 14003)
void registeringQueryInterceptor(String cacheName);
@LogMessage(level = DEBUG)
@Message(value = "Custom commands backend initialized backing index %s", id = 14004)
void commandsBackendInitialized(String indexName);
// @LogMessage(level = TRACE)
// @Message(value = "Sent list of LuceneWork %s to node %s", id = 14005)
// void workListRemotedTo(Object workList, Address primaryNodeAddress);
//
// @LogMessage(level = WARN)
// @Message(value = "Index named '%1$s' is ignoring configuration option 'directory.type' set '%2$s':" +
// " overridden to use the Infinispan Directory", id = 14008)
// void ignoreDirectoryProviderProperty(String indexName, String directoryOption);
@LogMessage(level = WARN)
@Message(value = "Indexed type '%1$s' is using a default Transformer. This is slow! Register a custom implementation using @Transformable", id = 14009)
void typeIsUsingDefaultTransformer(Class<?> keyClass);
// @Message(value = "An IOException happened where none where expected", id = 14010)
// CacheException unexpectedIOException(@Cause IOException e);
//
// @LogMessage(level = WARN)
// @Message(value = "Some indexing work was lost because of an InterruptedException", id = 14011)
// void interruptedWhileBufferingWork(@Cause InterruptedException e);
//
// @LogMessage(level = DEBUG)
// @Message(value = "Waiting for index lock was successful: '%1$s'", id = 14012)
// void waitingForLockAcquired(boolean waitForAvailabilityInternal);
@Message(value = "Cache named '%1$s' is being shut down. No longer accepting remote commands.", id = 14013)
CacheException cacheIsStoppingNoCommandAllowed(String cacheName);
@LogMessage(level = INFO)
@Message(value = "Reindexed %1$d entities in %2$d ms", id = 14014)
void indexingEntitiesCompleted(long nbrOfEntities, long elapsedMs);
@LogMessage(level = DEBUG)
@Message(value = "%1$d documents indexed in %2$d ms", id = 14015)
void indexingDocumentsCompleted(long doneCount, long elapsedMs);
@LogMessage(level = INFO)
@Message(value = "Purging instances of '%s' from the index", id = 14016)
void purgingIndex(String entityType);
@LogMessage(level = INFO)
@Message(value = "Flushing index '%s'", id = 14017)
void flushingIndex(String entityType);
// @Message(value = "Error executing MassIndexer", id = 14018)
// CacheException errorExecutingMassIndexer(@Cause Throwable cause);
@Message(value = "Cannot run Lucene queries on a cache '%s' that does not have indexing enabled", id = 14019)
IllegalStateException cannotRunLuceneQueriesIfNotIndexed(String cacheName);
// @LogMessage(level = WARN)
// @Message(value = "Autodetected a new indexed entity type in cache %s: %s. Autodetection support will be removed in Infinispan 10.0.", id = 14028)
// void detectedUnknownIndexedEntity(String cacheName, String className);
// @LogMessage(level = WARN)
// @Message(value = "Found undeclared indexable types in cache %s : %s. No indexes were created for these types because autodetection is not enabled for this cache.", id = 14029)
// void detectedUnknownIndexedEntities(String cacheName, String classNames);
// @Message(value = "The type %s is not an indexed entity.", id = 14030)
// IllegalArgumentException notAnIndexedEntityException(String typeName);
@Message(value = "Unable to resume suspended transaction %s", id = 14033)
CacheException unableToResumeSuspendedTx(Transaction transaction, @Cause Throwable cause);
@Message(value = "Unable to suspend transaction", id = 14034)
CacheException unableToSuspendTx(@Cause Throwable cause);
@Message(value = "Prefix, wildcard or regexp queries cannot be fuzzy: %s", id = 14036)
ParsingException getPrefixWildcardOrRegexpQueriesCannotBeFuzzy(String s); //todo [anistor] this should be thrown earlier at parsing time
// @Message(value = "Invalid boolean literal '%s'", id = 14037)
// ParsingException getInvalidBooleanLiteralException(String value);
//
// @Message(value = "infinispan-query.jar module is in the classpath but has not been properly initialised!", id = 14038)
// CacheException queryModuleNotInitialised();
@Message(value = "Queries containing groups or aggregations cannot be converted to an indexed query", id = 14039)
CacheException groupAggregationsNotSupported();
@Message(value = "Unable to define filters, please use filters in the query string instead.", id = 14040)
CacheException filterNotSupportedWithQueryString();
// @Message(value = "Unable to define sort, please use sorting in the query string instead.", id = 14041)
// CacheException sortNotSupportedWithQueryString();
@Message(value = "Cannot find an appropriate Transformer for key type %s. Indexing only works with entries keyed " +
"on Strings, primitives, byte[], UUID, classes that have the @Transformable annotation or classes for which " +
"you have defined a suitable Transformer in the indexing configuration. Alternatively, see " +
"org.infinispan.query.spi.SearchManagerImplementor.registerKeyTransformer.", id = 14043)
CacheException noTransformerForKey(String keyClassName);
@LogMessage(level = ERROR)
@Message(value = "Failed to parse system property %s", id = 14044)
void failedToParseSystemProperty(String propertyName, @Cause Exception e);
// @LogMessage(level = DEBUG)
// @Message(value = "Overriding org.apache.lucene.search.BooleanQuery.setMaxClauseCount to value %d to be able to deserialize a larger BooleanQuery", id = 14045)
// void overridingBooleanQueryMaxClauseCount(int maxClauseCount);
@LogMessage(level = INFO)
@Message(value = "Setting org.apache.lucene.search.BooleanQuery.setMaxClauseCount from system property %s to value %d", id = 14046)
void settingBooleanQueryMaxClauseCount(String sysPropName, int maxClauseCount);
@LogMessage(level = WARN)
@Message(value = "Ignoring system property %s because the value %d is smaller than the current value (%d) of org.apache.lucene.search.BooleanQuery.getMaxClauseCount()", id = 14047)
void ignoringBooleanQueryMaxClauseCount(String sysPropName, int maxClauseCount, int currentMaxClauseCount);
// @Message(value = "Error acquiring MassIndexer Lock", id = 14048)
// CacheException errorAcquiringMassIndexerLock(@Cause Throwable e);
//
// @Message(value = "Error releasing MassIndexer Lock", id = 14049)
// CacheException errorReleasingMassIndexerLock(@Cause Throwable e);
@Message(value = "Interrupted while waiting for completions of some batch indexing operations.", id = 14050)
CacheException interruptedWhileWaitingForRequestCompletion(@Cause Exception cause);
@Message(value = "%1$s entities could not be indexed. See the logs for details. First failure on entity '%2$s': %3$s", id = 14051)
SearchException massIndexingEntityFailures(long finalFailureCount, EntityReference firstFailureEntity, String firstFailureMessage, @Cause Throwable firstFailure);
@Message(value = "Indexing instance of entity '%s' during mass indexing", id = 14052)
String massIndexerIndexingInstance(String entityName);
// @Message(value = "Invalid property key '%1$s`, it's not a string.", id = 14053)
// CacheException invalidPropertyKey(Object propertyKey);
@Message(value = "Trying to execute query `%1$s`, but no type is indexed on cache.", id = 14054)
CacheException noTypeIsIndexed(String ickle);
@Message(value = "Cannot index entry since the search mapping failed to initialize.", id = 14055)
CacheException searchMappingUnavailable();
@LogMessage(level = WARN)
@Message(value = "The indexing engine is restarting, index updates will be skipped for the current data changes.", id = 14059)
void mappingIsRestarting();
@LogMessage(level = INFO)
@Message(value = "We're getting some errors from Hibernate Search or Lucene while we compute the index count/size for statistics."
+ " There is probably a concurrent reindexing ongoing.", id = 14060)
void concurrentReindexingOnGetStatistics(@Cause Throwable cause);
@Message(value = "Failed to load declared indexed class '%s'", id = 14061)
CacheConfigurationException cannotLoadIndexedClass(String name, @Cause Throwable t);
@LogMessage(level = DEBUG)
@Message(value = "Search engine is reloaded before the reindexing.", id = 14062)
void preIndexingReloading();
@LogMessage(level = INFO)
@Message(value = "Reindexing starting.", id = 14063)
void indexingStarting();
// !!!!!! When adding anything new here please check the last used id in org.infinispan.query.core.impl.Log !!!!!!
}
| 10,572
| 50.077295
| 183
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/package-info.java
|
/**
* Mostly internal search related classes. Use with caution!
*
* @api.private
*/
package org.infinispan.query.backend;
| 126
| 17.142857
| 60
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/TransactionHelper.java
|
package org.infinispan.query.backend;
import static org.infinispan.query.logging.Log.CONTAINER;
import jakarta.transaction.Transaction;
import jakarta.transaction.TransactionManager;
/**
* Transaction related helper. Wraps a (possibly {@code null}) {@link TransactionManager} and performs transaction
* suspend and resume on request.
*
* @author gustavonalle
* @since 7.0
*/
public final class TransactionHelper {
private final TransactionManager transactionManager;
public TransactionHelper(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public void resume(Transaction transaction) {
if (transaction != null) {
try {
transactionManager.resume(transaction);
} catch (Exception e) {
throw CONTAINER.unableToResumeSuspendedTx(transaction, e);
}
}
}
public Transaction suspendTxIfExists() {
if (transactionManager == null) {
return null;
}
try {
return transactionManager.suspend();
} catch (Exception e) {
throw CONTAINER.unableToSuspendTx(e);
}
}
}
| 1,150
| 25.159091
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/QueryInterceptor.java
|
package org.infinispan.query.backend;
import static java.util.concurrent.CompletableFuture.allOf;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import org.infinispan.AdvancedCache;
import org.infinispan.commands.FlagAffectedCommand;
import org.infinispan.commands.SegmentSpecificCommand;
import org.infinispan.commands.VisitableCommand;
import org.infinispan.commands.functional.ReadWriteKeyCommand;
import org.infinispan.commands.functional.ReadWriteKeyValueCommand;
import org.infinispan.commands.functional.ReadWriteManyCommand;
import org.infinispan.commands.functional.ReadWriteManyEntriesCommand;
import org.infinispan.commands.functional.WriteOnlyKeyCommand;
import org.infinispan.commands.functional.WriteOnlyKeyValueCommand;
import org.infinispan.commands.functional.WriteOnlyManyCommand;
import org.infinispan.commands.functional.WriteOnlyManyEntriesCommand;
import org.infinispan.commands.write.ClearCommand;
import org.infinispan.commands.write.ComputeCommand;
import org.infinispan.commands.write.ComputeIfAbsentCommand;
import org.infinispan.commands.write.DataWriteCommand;
import org.infinispan.commands.write.IracPutKeyValueCommand;
import org.infinispan.commands.write.PutKeyValueCommand;
import org.infinispan.commands.write.PutMapCommand;
import org.infinispan.commands.write.RemoveCommand;
import org.infinispan.commands.write.ReplaceCommand;
import org.infinispan.commands.write.WriteCommand;
import org.infinispan.commons.util.IntSet;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.entries.MVCCEntry;
import org.infinispan.container.entries.ReadCommittedEntry;
import org.infinispan.context.InvocationContext;
import org.infinispan.context.impl.FlagBitSets;
import org.infinispan.context.impl.TxInvocationContext;
import org.infinispan.distribution.DistributionInfo;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.ch.KeyPartitioner;
import org.infinispan.encoding.DataConversion;
import org.infinispan.factories.annotations.Inject;
import org.infinispan.factories.annotations.Start;
import org.infinispan.factories.annotations.Stop;
import org.infinispan.interceptors.DDAsyncInterceptor;
import org.infinispan.interceptors.InvocationSuccessAction;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.manager.PersistenceManager.StoreChangeListener;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.logging.Log;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.search.mapper.work.SearchIndexer;
import org.infinispan.transaction.xa.GlobalTransaction;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.util.logging.LogFactory;
/**
* This interceptor will be created when the System Property "infinispan.query.indexLocalOnly" is "false"
* <p>
* This type of interceptor will allow the indexing of data even when it comes from other caches within a cluster.
* <p>
* However, if the a cache would not be putting the data locally, the interceptor will not index it.
*
* @author Navin Surtani
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
* @author Marko Luksa
* @author anistor@redhat.com
* @since 4.0
*/
public final class QueryInterceptor extends DDAsyncInterceptor {
private static final Log log = LogFactory.getLog(QueryInterceptor.class, Log.class);
static final Object UNKNOWN = new Object() {
@Override
public String toString() {
return "<UNKNOWN>";
}
};
@Inject
DistributionManager distributionManager;
@Inject
BlockingManager blockingManager;
@Inject
protected KeyPartitioner keyPartitioner;
@Inject
protected PersistenceManager persistenceManager;
private final AtomicBoolean stopping = new AtomicBoolean(false);
private final ConcurrentMap<GlobalTransaction, Map<Object, Object>> txOldValues;
private final DataConversion valueDataConversion;
private final DataConversion keyDataConversion;
private volatile boolean isPersistenceEnabled;
private final InvocationSuccessAction<ClearCommand> processClearCommand = this::processClearCommand;
private final boolean isManualIndexing;
private final AdvancedCache<?, ?> cache;
private final Map<String, Class<?>> indexedClasses;
private SearchMapping searchMapping;
private SegmentListener segmentListener;
private final StoreChangeListener storeChangeListener = pm -> isPersistenceEnabled = pm.isEnabled();
public QueryInterceptor(boolean isManualIndexing, ConcurrentMap<GlobalTransaction, Map<Object, Object>> txOldValues,
AdvancedCache<?, ?> cache, Map<String, Class<?>> indexedClasses) {
this.isManualIndexing = isManualIndexing;
this.txOldValues = txOldValues;
this.valueDataConversion = cache.getValueDataConversion();
this.keyDataConversion = cache.getKeyDataConversion();
this.isPersistenceEnabled = cache.getCacheConfiguration().persistence().usingStores();
this.cache = cache;
this.indexedClasses = Collections.unmodifiableMap(indexedClasses);
}
@Start
protected void start() {
stopping.set(false);
boolean isClustered = cache.getCacheConfiguration().clustering().cacheMode().isClustered();
if (isClustered) {
segmentListener = new SegmentListener(cache, this::purgeIndex, blockingManager);
this.cache.addListener(segmentListener);
}
searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
persistenceManager.addStoreListener(storeChangeListener);
}
@Stop
protected void stop() {
persistenceManager.removeStoreListener(storeChangeListener);
}
public void prepareForStopping() {
if (segmentListener != null) cache.removeListener(segmentListener);
stopping.set(true);
}
private boolean shouldModifyIndexes(FlagAffectedCommand command, InvocationContext ctx, Object key) {
if (isManualIndexing) return false;
if (distributionManager == null || key == null) {
return true;
}
DistributionInfo info = distributionManager.getCacheTopology().getDistribution(key);
// If this is a backup node we should modify the entry in the remote context
return info.isPrimary() || info.isWriteOwner() &&
(ctx.isInTxScope() || !ctx.isOriginLocal() || command != null && command.hasAnyFlag(FlagBitSets.PUT_FOR_STATE_TRANSFER));
}
public BlockingManager getBlockingManager() {
return blockingManager;
}
private Object handleDataWriteCommand(InvocationContext ctx, DataWriteCommand command) {
if (command.hasAnyFlag(FlagBitSets.SKIP_INDEXING)) {
return invokeNext(ctx, command);
}
// Make sure the searchMapping is ready to accept requests before allowing the invocation to proceed further
if (searchMapping.isClose()) {
throw log.searchMappingUnavailable();
}
return invokeNextThenApply(ctx, command, (rCtx, cmd, rv) -> {
if (!cmd.isSuccessful()) {
return rv;
}
boolean unreliablePrevious = unreliablePreviousValue(cmd);
if (rCtx.isInTxScope()) {
Map<Object, Object> oldValues = getOldValuesMap((TxInvocationContext<?>) rCtx);
registerOldValue(rCtx, cmd.getKey(), unreliablePrevious, oldValues);
} else {
return delayedValue(indexIfNeeded(rCtx, cmd, unreliablePrevious, cmd.getKey()), rv);
}
return rv;
});
}
private Object handleManyWriteCommand(InvocationContext ctx, WriteCommand command) {
if (command.hasAnyFlag(FlagBitSets.SKIP_INDEXING)) {
return invokeNext(ctx, command);
}
return invokeNextThenApply(ctx, command, (rCtx, cmd, rv) -> {
if (!cmd.isSuccessful()) {
return rv;
}
boolean unreliablePrevious = unreliablePreviousValue(cmd);
if (rCtx.isInTxScope()) {
Map<Object, Object> oldValues = getOldValuesMap((TxInvocationContext<?>) rCtx);
for (Object key : cmd.getAffectedKeys()) {
registerOldValue(rCtx, key, unreliablePrevious, oldValues);
}
return rv;
} else {
return delayedValue(allOf(cmd.getAffectedKeys().stream().map(key -> indexIfNeeded(rCtx, cmd, unreliablePrevious, key)).toArray(CompletableFuture[]::new)), rv);
}
});
}
private void registerOldValue(InvocationContext ctx, Object key, boolean unreliablePrevious, Map<Object, Object> oldValues) {
CacheEntry<?, ?> entryTx = ctx.lookupEntry(key);
if (entryTx != null && (entryTx.getValue() != null || !unreliablePrevious)) {
ReadCommittedEntry<?, ?> mvccEntry = (ReadCommittedEntry<?, ?>) entryTx;
oldValues.putIfAbsent(key, mvccEntry.getOldValue());
}
}
private Map<Object, Object> getOldValuesMap(TxInvocationContext<?> ctx) {
return txOldValues.computeIfAbsent(ctx.getGlobalTransaction(), gid -> {
ctx.getCacheTransaction().addListener(() -> txOldValues.remove(gid));
return new HashMap<>();
});
}
private CompletableFuture<?> indexIfNeeded(InvocationContext rCtx, WriteCommand cmd, boolean unreliablePrevious, Object key) {
CacheEntry<?, ?> entry = rCtx.lookupEntry(key);
boolean isStale = false;
Object old = null;
if (entry instanceof MVCCEntry) {
ReadCommittedEntry<?, ?> mvccEntry = (ReadCommittedEntry<?, ?>) entry;
isStale = !mvccEntry.isCommitted();
old = unreliablePrevious ? UNKNOWN : mvccEntry.getOldValue();
}
if (entry != null && entry.isChanged() && !isStale) {
if (log.isTraceEnabled()) {
log.tracef("Try indexing command '%s',key='%s', oldValue='%s', stale='false'", cmd, key, old);
}
return processChange(rCtx, cmd, key, old, entry.getValue());
} else {
if (log.isTraceEnabled()) {
log.tracef("Skipping indexing for command '%s',key='%s', oldValue='%s', stale='%s'", cmd, key, old, isStale);
}
}
return CompletableFutures.completedNull();
}
private boolean unreliablePreviousValue(WriteCommand command) {
// alternative approach would be changing the flag and forcing load type in an interceptor before EWI
return isPersistenceEnabled && (command.loadType() == VisitableCommand.LoadType.DONT_LOAD
|| command.hasAnyFlag(FlagBitSets.SKIP_CACHE_LOAD));
}
@Override
public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitIracPutKeyValueCommand(InvocationContext ctx, IracPutKeyValueCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitRemoveCommand(InvocationContext ctx, RemoveCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitReplaceCommand(InvocationContext ctx, ReplaceCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitComputeCommand(InvocationContext ctx, ComputeCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitComputeIfAbsentCommand(InvocationContext ctx, ComputeIfAbsentCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitPutMapCommand(InvocationContext ctx, PutMapCommand command) {
return handleManyWriteCommand(ctx, command);
}
@Override
public Object visitClearCommand(InvocationContext ctx, ClearCommand command) {
return invokeNextThenAccept(ctx, command, processClearCommand);
}
@Override
public Object visitReadWriteKeyCommand(InvocationContext ctx, ReadWriteKeyCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitWriteOnlyKeyCommand(InvocationContext ctx, WriteOnlyKeyCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitReadWriteKeyValueCommand(InvocationContext ctx, ReadWriteKeyValueCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitWriteOnlyManyEntriesCommand(InvocationContext ctx, WriteOnlyManyEntriesCommand command) {
return handleManyWriteCommand(ctx, command);
}
@Override
public Object visitWriteOnlyKeyValueCommand(InvocationContext ctx, WriteOnlyKeyValueCommand command) {
return handleDataWriteCommand(ctx, command);
}
@Override
public Object visitWriteOnlyManyCommand(InvocationContext ctx, WriteOnlyManyCommand command) {
return handleManyWriteCommand(ctx, command);
}
@Override
public Object visitReadWriteManyCommand(InvocationContext ctx, ReadWriteManyCommand command) {
return handleManyWriteCommand(ctx, command);
}
@Override
public Object visitReadWriteManyEntriesCommand(InvocationContext ctx, ReadWriteManyEntriesCommand command) {
return handleManyWriteCommand(ctx, command);
}
/**
* Remove all entries from all known indexes
*/
public void purgeAllIndexes() {
if (searchMapping == null) {
return;
}
searchMapping.scopeAll().workspace().purge();
}
public void purgeIndex(Class<?> entityType) {
if (searchMapping == null) {
return;
}
searchMapping.scope(entityType).workspace().purge();
}
/**
* Removes from the index the entries corresponding to the supplied segments, if the index is local.
*/
void purgeIndex(IntSet segments) {
if (segments == null || segments.isEmpty() || searchMapping == null) {
return;
}
Set<String> routingKeys = segments.intStream().boxed().map(Objects::toString).collect(Collectors.toSet());
searchMapping.scopeAll().workspace().purge(routingKeys);
}
/**
* Remove entries from all indexes by key.
*/
CompletableFuture<?> removeFromIndexes(Object key, int segment) {
return getSearchIndexer().purge(key, String.valueOf(segment));
}
// Method that will be called when data needs to be removed from Lucene.
private CompletableFuture<?> removeFromIndexes(Object value, Object key, int segment) {
return getSearchIndexer().delete(key, String.valueOf(segment), value);
}
private CompletableFuture<?> updateIndexes(boolean usingSkipIndexCleanupFlag, Object value, Object key, int segment) {
// Note: it's generally unsafe to assume there is no previous entry to cleanup: always use UPDATE
// unless the specific flag is allowing this.
if (usingSkipIndexCleanupFlag) {
return getSearchIndexer().add(key, String.valueOf(segment), value);
} else {
return getSearchIndexer().addOrUpdate(key, String.valueOf(segment), value);
}
}
/**
* The indexed classes.
*
* @deprecated since 11
*/
@Deprecated
public Map<String, Class<?>> indexedEntities() {
return indexedClasses;
}
private SearchIndexer getSearchIndexer() {
return searchMapping.getSearchIndexer();
}
private Object extractValue(Object storedValue) {
return valueDataConversion.extractIndexable(storedValue);
}
private Object extractKey(Object storedKey) {
return keyDataConversion.extractIndexable(storedKey);
}
CompletableFuture<?> processChange(InvocationContext ctx, FlagAffectedCommand command, Object storedKey, Object storedOldValue, Object storedNewValue) {
if (searchMapping.isRestarting()) {
log.mappingIsRestarting();
return CompletableFutures.completedNull();
}
int segment = SegmentSpecificCommand.extractSegment(command, storedKey, keyPartitioner);
Object key = extractKey(storedKey);
Object oldValue = storedOldValue == UNKNOWN ? UNKNOWN : extractValue(storedOldValue);
Object newValue = extractValue(storedNewValue);
boolean skipIndexCleanup = command != null && command.hasAnyFlag(FlagBitSets.SKIP_INDEX_CLEANUP);
CompletableFuture<?> operation = CompletableFutures.completedNull();
if (!skipIndexCleanup) {
if (oldValue == UNKNOWN) {
if (shouldModifyIndexes(command, ctx, storedKey)) {
operation = removeFromIndexes(key, segment);
}
} else if (isPotentiallyIndexedType(oldValue) && (newValue == null || replacedWithADifferentEntity(newValue, oldValue))
&& shouldModifyIndexes(command, ctx, storedKey)) {
operation = removeFromIndexes(oldValue, key, segment);
} else if (log.isTraceEnabled()) {
log.tracef("Index cleanup not needed for %s -> %s", oldValue, newValue);
}
} else if (log.isTraceEnabled()) {
log.tracef("Skipped index cleanup for command %s", command);
}
if (isPotentiallyIndexedType(newValue)) {
if (shouldModifyIndexes(command, ctx, storedKey)) {
// We don't need to wait for a possible removeFromIndexes operation,
// since if it exists, the oldValue is UNKNOWN or replacedWithADifferentEntity is true,
// which implies that the delete and the add operations are related to different indexes
operation = CompletableFuture.allOf(operation, updateIndexes(skipIndexCleanup, newValue, key, segment));
} else {
if (log.isTraceEnabled()) {
log.tracef("Not modifying index for %s (%s)", storedKey, command);
}
}
} else if (log.isTraceEnabled()) {
log.tracef("Update not needed for %s", newValue);
}
return operation;
}
private boolean replacedWithADifferentEntity(Object value, Object previousValue) {
return value != null && previousValue != null && value.getClass() != previousValue.getClass();
}
private void processClearCommand(InvocationContext ctx, ClearCommand command, Object rv) {
if (shouldModifyIndexes(command, ctx, null)) {
purgeAllIndexes();
}
}
public boolean isStopping() {
return stopping.get();
}
/**
* @param value An entity.
* @return {@code true} if there is a chance that this entity is of an indexed types.
* For protobuf entities which are not yet deserialized,
* this returns {@code true} even though we don't know the exact type until the entity is deserialized.
* The {@link org.infinispan.search.mapper.mapping.EntityConverter entity converter}
* that takes care of deserialization will take care of cancelling indexing
* if it turns out the actual type of the entity is not one that should be indexed.
*/
private boolean isPotentiallyIndexedType(Object value) {
if (searchMapping == null) {
return false;
}
Class<?> convertedType = searchMapping.toConvertedEntityJavaClass(value);
return searchMapping.allIndexedEntityJavaClasses().contains(convertedType);
}
}
| 19,461
| 39.715481
| 171
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/SegmentListener.java
|
package org.infinispan.query.backend;
import java.util.concurrent.CompletionStage;
import java.util.function.Consumer;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.IntSet;
import org.infinispan.commons.util.IntSets;
import org.infinispan.distribution.LocalizedCacheTopology;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.TopologyChanged;
import org.infinispan.notifications.cachelistener.event.TopologyChangedEvent;
import org.infinispan.remoting.transport.Address;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.commons.util.concurrent.CompletableFutures;
/**
* SegmentListener will detect segments that were lost for this node due to topology changes so they can be removed
* from the local indexes.
*
* @since 11.0
*/
@Listener(observation = Listener.Observation.POST)
@SuppressWarnings("unused")
final class SegmentListener {
private final AdvancedCache<?, ?> cache;
private final Consumer<IntSet> segmentDeleted;
private final Address address;
private final BlockingManager blockingManager;
SegmentListener(AdvancedCache<?, ?> cache, Consumer<IntSet> segmentsDeleted, BlockingManager blockingManager) {
this.cache = cache;
this.segmentDeleted = segmentsDeleted;
this.address = cache.getRpcManager().getAddress();
this.blockingManager = blockingManager;
}
@TopologyChanged
public CompletionStage<Void> topologyChanged(TopologyChangedEvent<?, ?> event) {
if (event.isPre()) return CompletableFutures.completedNull();
ConsistentHash newWriteCh = event.getWriteConsistentHashAtEnd();
LocalizedCacheTopology cacheTopology = cache.getDistributionManager().getCacheTopology();
boolean isMember = cacheTopology.getMembers().contains(address);
if (!isMember) return CompletableFutures.completedNull();
int numSegments = newWriteCh.getNumSegments();
IntSet removedSegments = IntSets.mutableEmptySet(numSegments);
IntSet newSegments = IntSets.from(newWriteCh.getSegmentsForOwner(address));
for (int i = 0; i < numSegments; ++i) {
if (!newSegments.contains(i)) {
removedSegments.set(i);
}
}
if (removedSegments.isEmpty()) {
return CompletableFutures.completedNull();
}
return blockingManager.runBlocking(() -> segmentDeleted.accept(removedSegments), this);
}
}
| 2,512
| 35.955882
| 115
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/TxQueryInterceptor.java
|
package org.infinispan.query.backend;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentMap;
import org.infinispan.commands.VisitableCommand;
import org.infinispan.commands.tx.CommitCommand;
import org.infinispan.commands.tx.PrepareCommand;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.context.InvocationContext;
import org.infinispan.context.impl.FlagBitSets;
import org.infinispan.context.impl.TxInvocationContext;
import org.infinispan.interceptors.DDAsyncInterceptor;
import org.infinispan.interceptors.InvocationStage;
import org.infinispan.interceptors.InvocationSuccessFunction;
import org.infinispan.transaction.impl.AbstractCacheTransaction;
import org.infinispan.transaction.xa.GlobalTransaction;
import org.infinispan.commons.util.concurrent.CompletableFutures;
public final class TxQueryInterceptor extends DDAsyncInterceptor {
private final ConcurrentMap<GlobalTransaction, Map<Object, Object>> txOldValues;
// Storing direct reference from one interceptor to another is antipattern, but extracting helper
// wouldn't help much.
private final QueryInterceptor queryInterceptor;
private final InvocationSuccessFunction<VisitableCommand> commitModificationsToIndex = this::commitModificationsToIndexFuture;
public TxQueryInterceptor(ConcurrentMap<GlobalTransaction, Map<Object, Object>> txOldValues, QueryInterceptor queryInterceptor) {
this.txOldValues = txOldValues;
this.queryInterceptor = queryInterceptor;
}
@Override
public Object visitPrepareCommand(TxInvocationContext ctx, PrepareCommand command) {
if (command.isOnePhaseCommit()) {
return invokeNextThenApply(ctx, command, commitModificationsToIndex);
} else {
return invokeNext(ctx, command);
}
}
@Override
public Object visitCommitCommand(TxInvocationContext ctx, CommitCommand command) {
return invokeNextThenApply(ctx, command, commitModificationsToIndex);
}
private InvocationStage commitModificationsToIndexFuture(InvocationContext ctx, VisitableCommand cmd, Object rv) {
TxInvocationContext txCtx = (TxInvocationContext) ctx;
Map<Object, Object> removed = txOldValues.remove(txCtx.getGlobalTransaction());
final Map<Object, Object> oldValues = removed == null ? Collections.emptyMap() : removed;
AbstractCacheTransaction transaction = txCtx.getCacheTransaction();
return asyncValue(CompletableFuture.allOf(transaction.getAllModifications().stream()
.filter(mod -> !mod.hasAnyFlag(FlagBitSets.SKIP_INDEXING))
.flatMap(mod -> mod.getAffectedKeys().stream())
.map(key -> {
CacheEntry<?, ?> entry = txCtx.lookupEntry(key);
if (entry != null) {
Object oldValue = oldValues.getOrDefault(key, QueryInterceptor.UNKNOWN);
return queryInterceptor.processChange(ctx, null, key, oldValue, entry.getValue());
}
return CompletableFutures.completedNull();
})
.toArray(CompletableFuture[]::new)));
}
}
| 3,176
| 43.746479
| 132
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java
|
package org.infinispan.query.backend;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.util.Base64;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.util.Util;
import org.infinispan.query.Transformable;
import org.infinispan.query.Transformer;
import org.infinispan.query.impl.DefaultTransformer;
/**
* This transforms arbitrary keys to a String which can be used by Lucene as a document identifier, and vice versa.
* <p>
* There are 2 approaches to doing so; one for simple keys: Java primitives (and their object wrappers), byte[], Strings
* and UUID, and one for custom, user-defined types that could be used as keys.
* <p>
* For simple keys, users don't need to do anything, these keys are automatically transformed by this class.
* <p>
* For user-defined keys, three options are supported. Types annotated with @Transformable, and declaring an appropriate
* {@link org.infinispan.query.Transformer} implementation, types for which a {@link org.infinispan.query.Transformer}
* has been explicitly registered through KeyTransformationHandler.registerTransformer() or through the indexing configuration
* ({@link org.infinispan.configuration.cache.IndexingConfigurationBuilder#addKeyTransformer}).
*
* @author Manik Surtani
* @author Marko Luksa
* @see org.infinispan.query.Transformable
* @see org.infinispan.query.Transformer
* @since 4.0
*/
public final class KeyTransformationHandler {
private final Map<Class<?>, Class<? extends Transformer>> transformerTypes = new ConcurrentHashMap<>();
private final ClassLoader classLoader;
/**
* Constructs a KeyTransformationHandler for an indexed Cache.
*
* @param classLoader the classloader of the cache that owns this KeyTransformationHandler or {@code null} if the
* thread context classloader is to be used (acceptable for testing only!)
*/
public KeyTransformationHandler(ClassLoader classLoader) {
this.classLoader = classLoader;
}
/**
* Converts a Lucene document id from string form back to the original object.
*
* @param s the string form of the key
* @return the key object
*/
public Object stringToKey(String s) {
char type = s.charAt(0);
switch (type) {
case 'S':
// this is a String, NOT a Short. For Short see case 'X'.
return s.substring(2);
case 'I':
// This is an Integer
return Integer.valueOf(s.substring(2));
case 'Y':
// This is a BYTE
return Byte.valueOf(s.substring(2));
case 'L':
// This is a Long
return Long.valueOf(s.substring(2));
case 'X':
// This is a SHORT
return Short.valueOf(s.substring(2));
case 'D':
// This is a Double
return Double.valueOf(s.substring(2));
case 'F':
// This is a Float
return Float.valueOf(s.substring(2));
case 'B':
// This is a Boolean, NOT a Byte. For Byte see case 'Y'.
return Boolean.valueOf(s.substring(2));
case 'C':
// This is a Character
return Character.valueOf(s.charAt(2));
case 'U':
// This is a java.util.UUID
return UUID.fromString(s.substring(2));
case 'A':
// This is an array of bytes encoded as a Base64 string
return Base64.getDecoder().decode(s.substring(2));
case 'T':
// this is a custom Transformable or a type with a registered Transformer
int indexOfSecondDelimiter = s.indexOf(':', 2);
String keyClassName = s.substring(2, indexOfSecondDelimiter);
String keyAsString = s.substring(indexOfSecondDelimiter + 1);
Transformer t = getTransformer(keyClassName);
if (t != null) {
return t.fromString(keyAsString);
} else {
throw CONTAINER.noTransformerForKey(keyClassName);
}
}
throw new CacheException("Unknown key type metadata: " + type);
}
private Transformer getTransformer(String keyClassName) {
Class<?> keyClass;
try {
keyClass = Util.loadClassStrict(keyClassName, classLoader);
} catch (ClassNotFoundException e) {
CONTAINER.keyClassNotFound(keyClassName, e);
return null;
}
return getTransformer(keyClass);
}
/**
* Stringify a key so Lucene can use it as document id.
*
* @param key the key
* @return a string form of the key
*/
public String keyToString(Object key) {
// This string should be in the format of:
// "<TYPE>:<KEY>" for internally supported types or "T:<KEY_CLASS>:<KEY>" for custom types
// e.g.:
// "S:my string key"
// "I:75"
// "D:5.34"
// "B:f"
// "T:com.myorg.MyType:STRING_GENERATED_BY_TRANSFORMER_FOR_MY_TYPE"
// First going to check if the key is a primitive or a String. Otherwise, check if it's a transformable.
// If none of those conditions are satisfied, we'll throw a CacheException.
// Using 'X' for Shorts and 'Y' for Bytes because 'S' is used for Strings and 'B' is being used for Booleans.
if (key instanceof byte[])
return "A:" + Base64.getEncoder().encodeToString((byte[]) key); //todo [anistor] need to profile Base64 versus simple hex encoding of the raw bytes
if (key instanceof String)
return "S:" + key;
else if (key instanceof Integer)
return "I:" + key;
else if (key instanceof Boolean)
return "B:" + key;
else if (key instanceof Long)
return "L:" + key;
else if (key instanceof Float)
return "F:" + key;
else if (key instanceof Double)
return "D:" + key;
else if (key instanceof Short)
return "X:" + key;
else if (key instanceof Byte)
return "Y:" + key;
else if (key instanceof Character)
return "C:" + key;
else if (key instanceof UUID)
return "U:" + key;
else {
Transformer t = getTransformer(key.getClass());
if (t != null) {
return "T:" + key.getClass().getName() + ":" + t.toString(key);
} else {
throw CONTAINER.noTransformerForKey(key.getClass().getName());
}
}
}
/**
* Retrieves a {@link org.infinispan.query.Transformer} instance for this key. If the key is not {@link
* org.infinispan.query.Transformable} and no transformer has been registered for the key's class, null is returned.
*
* @param keyClass key class to analyze
* @return a Transformer for this key, or null if the key type is not properly annotated.
*/
private Transformer getTransformer(Class<?> keyClass) {
Class<? extends Transformer> transformerClass = getTransformerClass(keyClass);
if (transformerClass != null) {
try {
return transformerClass.newInstance();
} catch (Exception e) {
CONTAINER.couldNotInstantiateTransformerClass(transformerClass, e);
}
}
return null;
}
private Class<? extends Transformer> getTransformerClass(Class<?> keyClass) {
Class<? extends Transformer> transformerClass = transformerTypes.get(keyClass);
if (transformerClass == null) {
Transformable transformableAnnotation = keyClass.getAnnotation(Transformable.class);
transformerClass = transformableAnnotation != null ? transformableAnnotation.transformer() : null;
if (transformerClass != null) {
if (transformerClass == DefaultTransformer.class) {
CONTAINER.typeIsUsingDefaultTransformer(keyClass);
}
registerTransformer(keyClass, transformerClass);
}
}
return transformerClass;
}
/**
* Registers a {@link org.infinispan.query.Transformer} for the supplied key class.
*
* @param keyClass the key class for which the supplied transformerClass should be used
* @param transformerClass the transformer class to use for the supplied key class
*/
public void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass) {
transformerTypes.put(keyClass, transformerClass);
}
}
| 8,492
| 38.502326
| 157
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/package-info.java
|
/**
* Query DSL implementation internals.
*
* @api.private
*/
package org.infinispan.query.dsl.embedded.impl;
| 114
| 15.428571
| 47
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/ObjectReflectionMatcher.java
|
package org.infinispan.query.dsl.embedded.impl;
import org.infinispan.AdvancedCache;
import org.infinispan.objectfilter.impl.MetadataAdapter;
import org.infinispan.objectfilter.impl.ReflectionMatcher;
import org.infinispan.objectfilter.impl.syntax.parser.EntityNameResolver;
import org.infinispan.objectfilter.impl.util.ReflectionHelper;
import org.infinispan.search.mapper.mapping.SearchMapping;
/**
* Like ReflectionMatcher but also able to use Hibernate Search metadata if available.
*
* @author anistor@redhat.com
* @since 10.1
*/
public final class ObjectReflectionMatcher extends ReflectionMatcher {
private final AdvancedCache<?, ?> cache;
public static ObjectReflectionMatcher create(AdvancedCache<?, ?> cache, EntityNameResolver<Class<?>> entityNameResolv,
SearchMapping searchMapping) {
return searchMapping == null ? new ObjectReflectionMatcher(cache, entityNameResolv) :
new ObjectReflectionMatcher(cache, new HibernateSearchPropertyHelper(searchMapping, entityNameResolv));
}
private ObjectReflectionMatcher(AdvancedCache<?, ?> cache, HibernateSearchPropertyHelper hibernateSearchPropertyHelper) {
super(hibernateSearchPropertyHelper);
this.cache = cache;
}
private ObjectReflectionMatcher(AdvancedCache<?, ?> cache, EntityNameResolver<Class<?>> entityNameResolver) {
super(entityNameResolver);
this.cache = cache;
}
@Override
protected MetadataAdapter<Class<?>, ReflectionHelper.PropertyAccessor, String> createMetadataAdapter(Class<?> clazz) {
return new ReflectionMetadataProjectableAdapter(super.createMetadataAdapter(clazz), cache);
}
}
| 1,693
| 40.317073
| 124
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/ReflectionMetadataProjectableAdapter.java
|
package org.infinispan.query.dsl.embedded.impl;
import org.infinispan.AdvancedCache;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.metadata.Metadata;
import org.infinispan.objectfilter.impl.MetadataAdapter;
import org.infinispan.objectfilter.impl.util.ReflectionHelper;
public class ReflectionMetadataProjectableAdapter extends MetadataProjectableAdapter<Class<?>, ReflectionHelper.PropertyAccessor, String> {
public ReflectionMetadataProjectableAdapter(MetadataAdapter<Class<?>, ReflectionHelper.PropertyAccessor, String> baseAdapter, AdvancedCache<?, ?> cache) {
super(baseAdapter, cache);
}
@Override
public Object projection(CacheEntry<?, ?> cacheEntry, String attribute) {
if (HibernateSearchPropertyHelper.VALUE.equals(attribute)) {
return cacheEntry.getValue();
}
Metadata metadata = cacheEntry.getMetadata();
if (HibernateSearchPropertyHelper.VERSION.equals(attribute)) {
return metadata.version();
}
return null;
}
}
| 1,034
| 35.964286
| 157
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/EmbeddedLuceneQuery.java
|
package org.infinispan.query.dsl.embedded.impl;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.query.core.impl.MappingIterator;
import org.infinispan.query.core.impl.QueryResultImpl;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.dsl.impl.BaseQuery;
import org.infinispan.query.impl.IndexedQuery;
/**
* A query implementation based on Lucene. No aggregations are present in the query.
*
* @author anistor@redhat.com
* @since 6.0
*/
final class EmbeddedLuceneQuery<TypeMetadata, T> extends BaseQuery<T> {
private final QueryEngine<TypeMetadata> queryEngine;
/**
* Apply a postprocessing transformation to the query result (only when we have projections).
*/
private final QueryEngine.RowProcessor rowProcessor;
/**
* The parsed Ickle query.
*/
private final IckleParsingResult<TypeMetadata> parsingResult;
/**
* An Infinispan Cache query that wraps an actual Lucene query object. This is built lazily when the query is
* executed first time.
*/
private IndexedQuery<T> indexedQuery;
/**
* An Infinispan Cache query to use for {@link #list()} and {@link #iterator()},
* that wraps an actual Lucene query object.
* This is built lazily when {@link #list()} or {@link #iterator()} is executed first time.
* In general more efficient than {@link #indexedQuery}, since we don't need to return the hit count.
*/
private IndexedQuery<T> indexedListQuery;
EmbeddedLuceneQuery(QueryEngine<TypeMetadata> queryEngine, QueryFactory queryFactory,
Map<String, Object> namedParameters, IckleParsingResult<TypeMetadata> parsingResult,
String[] projection, QueryEngine.RowProcessor rowProcessor,
long startOffset, int maxResults, boolean local) {
super(queryFactory, parsingResult.getQueryString(), namedParameters, projection, startOffset, maxResults, local);
if (rowProcessor != null && (projection == null || projection.length == 0)) {
throw new IllegalArgumentException("A RowProcessor can only be specified with projections");
}
this.queryEngine = queryEngine;
this.rowProcessor = rowProcessor;
this.parsingResult = parsingResult;
}
@Override
public void resetQuery() {
indexedQuery = null;
indexedListQuery = null;
}
@Override
public List<T> list() {
IndexedQuery<?> indexedQuery = getOrCreateIndexedQuery(false);
QueryResult<?> result = indexedQuery.execute();
List<Object> collect = result.list().stream().map(this::convertResult).collect(Collectors.toList());
return (List<T>) collect;
}
@Override
public QueryResult<T> execute() {
IndexedQuery<?> indexedQuery = getOrCreateIndexedQuery(true);
QueryResult<?> result = indexedQuery.execute();
List<Object> collect = result.list().stream().map(this::convertResult).collect(Collectors.toList());
return new QueryResultImpl<>(result.count(), (List<T>) collect);
}
@Override
public int executeStatement() {
IndexedQuery<T> indexedQuery = getOrCreateIndexedQuery(false);
return indexedQuery.executeStatement();
}
@Override
public CloseableIterator<T> iterator() {
return new MappingIterator(getOrCreateIndexedQuery(true).iterator(), this::convertResult);
}
@Override
public <K> CloseableIterator<Map.Entry<K, T>> entryIterator() {
return new MappingIterator(getOrCreateIndexedQuery(true).entryIterator(), null);
}
@Override
public int getResultSize() {
return getOrCreateIndexedQuery(true).getResultSize();
}
@Override
public String toString() {
return "EmbeddedLuceneQuery{queryString=" + queryString +
", namedParameters=" + namedParameters +
", startOffset=" + startOffset +
", maxResults=" + maxResults +
", timeout=" + timeout +
'}';
}
private IndexedQuery<T> getOrCreateIndexedQuery(boolean withHitCount) {
if (withHitCount) {
if (indexedQuery == null) {
indexedQuery = createQuery(true);
}
return indexedQuery;
} else {
if (indexedListQuery == null) {
indexedListQuery = createQuery(false);
}
return indexedListQuery;
}
}
private IndexedQuery<T> createQuery(boolean withHitCount) {
validateNamedParameters();
IndexedQuery<T> result = queryEngine.buildLuceneQuery(parsingResult, namedParameters, startOffset, maxResults, isLocal());
if (withHitCount) {
if (hitCountAccuracy != null) {
result = result.hitCountAccuracy(hitCountAccuracy);
}
} else {
result.hitCountAccuracy(1); // lower the hit count accuracy
}
if (timeout > 0) {
result.timeout(timeout, TimeUnit.NANOSECONDS);
}
return result;
}
private Object convertResult(Object result) {
if (projection == null) return result;
Object[] array;
if (result instanceof Object[]) {
array = (Object[]) result;
} else if (result instanceof List) {
// Hibernate Search 6 uses list to wrap multiple item projection
List<?> castedRow = (List<?>) result;
array = castedRow.toArray(new Object[0]);
} else {
// Hibernate Search 6 does not wrap single item projection
array = new Object[]{result};
}
return rowProcessor == null ? array : rowProcessor.apply(array);
}
}
| 5,803
| 33.343195
| 128
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/SearchQueryMaker.java
|
package org.infinispan.query.dsl.embedded.impl;
import static org.infinispan.query.dsl.embedded.impl.HibernateSearchPropertyHelper.KEY;
import static org.infinispan.query.dsl.embedded.impl.HibernateSearchPropertyHelper.VALUE;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.io.IOException;
import java.io.StringReader;
import java.util.Map;
import java.util.Optional;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
import org.hibernate.search.backend.lucene.LuceneBackend;
import org.hibernate.search.backend.lucene.LuceneExtension;
import org.hibernate.search.backend.lucene.search.predicate.dsl.LuceneSearchPredicateFactory;
import org.hibernate.search.engine.backend.common.spi.FieldPaths;
import org.hibernate.search.engine.backend.metamodel.IndexFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldDescriptor;
import org.hibernate.search.engine.search.predicate.SearchPredicate;
import org.hibernate.search.engine.search.predicate.dsl.BooleanPredicateClausesStep;
import org.hibernate.search.engine.search.predicate.dsl.ExistsPredicateOptionsStep;
import org.hibernate.search.engine.search.predicate.dsl.MatchPredicateOptionsStep;
import org.hibernate.search.engine.search.predicate.dsl.PhrasePredicateOptionsStep;
import org.hibernate.search.engine.search.predicate.dsl.PredicateFinalStep;
import org.hibernate.search.engine.search.predicate.dsl.PredicateScoreStep;
import org.hibernate.search.engine.search.predicate.dsl.RangePredicateFieldMoreStep;
import org.hibernate.search.engine.search.predicate.dsl.RegexpQueryFlag;
import org.hibernate.search.engine.search.predicate.dsl.SimpleQueryFlag;
import org.hibernate.search.engine.search.projection.SearchProjection;
import org.hibernate.search.engine.search.projection.dsl.FieldProjectionValueStep;
import org.hibernate.search.engine.search.projection.dsl.SearchProjectionFactory;
import org.hibernate.search.engine.search.sort.SearchSort;
import org.hibernate.search.engine.search.sort.dsl.CompositeSortComponentsStep;
import org.hibernate.search.engine.search.sort.dsl.FieldSortOptionsStep;
import org.hibernate.search.engine.search.sort.dsl.SearchSortFactory;
import org.hibernate.search.util.common.data.RangeBoundInclusion;
import org.infinispan.objectfilter.SortField;
import org.infinispan.objectfilter.impl.ql.PropertyPath;
import org.infinispan.objectfilter.impl.syntax.AggregationExpr;
import org.infinispan.objectfilter.impl.syntax.AndExpr;
import org.infinispan.objectfilter.impl.syntax.BetweenExpr;
import org.infinispan.objectfilter.impl.syntax.BooleanExpr;
import org.infinispan.objectfilter.impl.syntax.ComparisonExpr;
import org.infinispan.objectfilter.impl.syntax.ConstantBooleanExpr;
import org.infinispan.objectfilter.impl.syntax.ConstantValueExpr;
import org.infinispan.objectfilter.impl.syntax.FullTextBoostExpr;
import org.infinispan.objectfilter.impl.syntax.FullTextOccurExpr;
import org.infinispan.objectfilter.impl.syntax.FullTextRangeExpr;
import org.infinispan.objectfilter.impl.syntax.FullTextRegexpExpr;
import org.infinispan.objectfilter.impl.syntax.FullTextTermExpr;
import org.infinispan.objectfilter.impl.syntax.IsNullExpr;
import org.infinispan.objectfilter.impl.syntax.LikeExpr;
import org.infinispan.objectfilter.impl.syntax.NotExpr;
import org.infinispan.objectfilter.impl.syntax.OrExpr;
import org.infinispan.objectfilter.impl.syntax.PropertyValueExpr;
import org.infinispan.objectfilter.impl.syntax.Visitor;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.objectfilter.impl.syntax.parser.ObjectPropertyHelper;
import org.infinispan.query.logging.Log;
import org.hibernate.search.engine.common.EntityReference;
import org.infinispan.search.mapper.mapping.SearchIndexedEntity;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.session.SearchSession;
import org.jboss.logging.Logger;
/**
* An *Expr {@link Visitor} that transforms a {@link IckleParsingResult} into a {@link SearchQueryParsingResult}.
* <p>
* NOTE: This is not stateless, not threadsafe, so it can only be used for a single transformation at a time.
*
* @author anistor@redhat.com
* @author Fabio Massimo Ercoli
* @since 9.0
*/
public final class SearchQueryMaker<TypeMetadata> implements Visitor<PredicateFinalStep, PredicateFinalStep> {
private static final Log log = Logger.getMessageLogger(Log.class, SearchQueryMaker.class.getName());
private static final char LUCENE_SINGLE_CHARACTER_WILDCARD = '?';
private static final char LUCENE_MULTIPLE_CHARACTERS_WILDCARD = '*';
private static final char LUCENE_WILDCARD_ESCAPE_CHARACTER = '\\';
private final SearchMapping searchMapping;
private final ObjectPropertyHelper<TypeMetadata> propertyHelper;
private final int hitCountAccuracy;
private Map<String, Object> namedParameters;
private LuceneSearchPredicateFactory predicateFactory;
private SearchIndexedEntity indexedEntity;
SearchQueryMaker(SearchMapping searchMapping, ObjectPropertyHelper<TypeMetadata> propertyHelper, int hitCountAccuracy) {
this.searchMapping = searchMapping;
this.propertyHelper = propertyHelper;
this.hitCountAccuracy = hitCountAccuracy;
}
public SearchQueryParsingResult transform(IckleParsingResult<TypeMetadata> parsingResult, Map<String, Object> namedParameters,
Class<?> targetedType, String targetedTypeName) {
if (searchMapping == null) {
throw log.noTypeIsIndexed(parsingResult.getQueryString());
}
this.namedParameters = namedParameters;
SearchSession querySession = searchMapping.getMappingSession();
SearchScope<?> scope = targetedTypeName == null ? querySession.scope(targetedType) :
querySession.scope(targetedType, targetedTypeName);
predicateFactory = scope.predicate().extension(LuceneExtension.get());
indexedEntity = targetedTypeName == null ? searchMapping.indexedEntity(targetedType) :
searchMapping.indexedEntity(targetedTypeName);
SearchPredicate predicate = makePredicate(parsingResult.getWhereClause()).toPredicate();
SearchProjectionInfo projection = makeProjection(parsingResult.getTargetEntityMetadata(), scope.projection(), parsingResult.getProjections(),
parsingResult.getProjectedTypes());
SearchSort sort = makeSort(scope.sort(), parsingResult.getSortFields());
return new SearchQueryParsingResult(targetedType, targetedTypeName, projection, predicate, sort, hitCountAccuracy);
}
private SearchProjectionInfo makeProjection(TypeMetadata typeMetadata, SearchProjectionFactory<EntityReference, ?> projectionFactory,
String[] projections, Class<?>[] projectedTypes) {
if (projections == null || projections.length == 0) {
return SearchProjectionInfo.entity(projectionFactory);
}
if (projections.length == 1) {
if (VALUE.equals(projections[0])) {
return SearchProjectionInfo.entity(projectionFactory);
}
if (KEY.equals(projections[0])) {
return SearchProjectionInfo.entityReference(projectionFactory);
}
boolean isRepeatedProperty = propertyHelper.isRepeatedProperty(typeMetadata, FieldPaths.split(projections[0]));
if (isRepeatedProperty) {
return SearchProjectionInfo.multiField(projectionFactory, projections[0], projectedTypes[0]);
} else {
return SearchProjectionInfo.field(projectionFactory, projections[0], projectedTypes[0]);
}
}
SearchProjection<?>[] searchProjections = new SearchProjection<?>[projections.length];
for (int i = 0; i < projections.length; i++) {
if (VALUE.equals(projections[i])) {
searchProjections[i] = projectionFactory.entity().toProjection();
} else if (KEY.equals(projections[i])) {
searchProjections[i] = projectionFactory.entityReference().toProjection();
} else {
boolean isMultiField = propertyHelper.isRepeatedProperty(typeMetadata, FieldPaths.split(projections[i]));
FieldProjectionValueStep<?, ?> projectionStep = projectionFactory.field(projections[i], projectedTypes[i]);
searchProjections[i] = isMultiField ? projectionStep.multi().toProjection() : projectionStep.toProjection();
}
}
return SearchProjectionInfo.composite(projectionFactory, searchProjections);
}
private SearchSort makeSort(SearchSortFactory sortFactory, SortField[] sortFields) {
if (sortFields == null || sortFields.length == 0) {
return sortFactory.score().toSort();
}
if (sortFields.length == 1) {
return makeSort(sortFactory, sortFields[0]);
}
CompositeSortComponentsStep<?> composite = sortFactory.composite();
for (SortField sortField : sortFields) {
composite.add(makeSort(sortFactory, sortField));
}
return composite.toSort();
}
private SearchSort makeSort(SearchSortFactory sortFactory, SortField sortField) {
FieldSortOptionsStep<?, ?> optionsStep = sortFactory.field(sortField.getPath().asStringPathWithoutAlias());
if (sortField.isAscending()) {
optionsStep.asc();
} else {
optionsStep.desc();
}
return optionsStep.toSort();
}
private PredicateFinalStep makePredicate(BooleanExpr expr) {
return expr == null ? predicateFactory.matchAll() : expr.acceptVisitor(this);
}
@Override
public PredicateFinalStep visit(FullTextOccurExpr fullTextOccurExpr) {
PredicateFinalStep childPredicate = fullTextOccurExpr.getChild().acceptVisitor(this);
switch (fullTextOccurExpr.getOccur()) {
case SHOULD:
return predicateFactory.bool().should(childPredicate);
case MUST:
case FILTER:
return predicateFactory.bool().must(childPredicate);
case MUST_NOT:
return predicateFactory.bool().mustNot(childPredicate);
}
throw new IllegalArgumentException("Unknown boolean occur clause: " + fullTextOccurExpr.getOccur());
}
@Override
public PredicateFinalStep visit(FullTextBoostExpr fullTextBoostExpr) {
BooleanExpr child = fullTextBoostExpr.getChild();
float boost = fullTextBoostExpr.getBoost();
if (child instanceof FullTextRegexpExpr) {
FullTextRegexpExpr fullTextRegexpExpr = (FullTextRegexpExpr) child;
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) fullTextRegexpExpr.getChild();
return predicateFactory.regexp().field(propertyValueExpr.getPropertyPath().asStringPath())
.matching(fullTextRegexpExpr.getRegexp())
.flags(RegexpQueryFlag.COMPLEMENT, RegexpQueryFlag.INTERVAL,
RegexpQueryFlag.INTERSECTION, RegexpQueryFlag.ANY_STRING)
.boost(boost);
}
PredicateFinalStep childPredicate = child.acceptVisitor(this);
if (childPredicate instanceof PredicateScoreStep) {
((PredicateScoreStep) childPredicate).boost(boost);
}
return childPredicate;
}
private boolean isMultiTermText(PropertyPath<?> propertyPath, String text) {
Analyzer analyzer = getAnalyzer(propertyPath);
if (analyzer == null) {
analyzer = new WhitespaceAnalyzer();
}
int terms = 0;
try (TokenStream tokenStream = analyzer.tokenStream(propertyPath.asStringPathWithoutAlias(), new StringReader(text))) {
PositionIncrementAttribute posIncAtt = tokenStream.addAttribute(PositionIncrementAttribute.class);
tokenStream.reset();
while (tokenStream.incrementToken()) {
if (posIncAtt.getPositionIncrement() > 0) {
if (++terms > 1) {
break;
}
}
}
tokenStream.end();
} catch (IOException e) {
// Highly unlikely to happen when reading from a StringReader.
log.error(e);
}
return terms > 1;
}
private Analyzer getAnalyzer(PropertyPath<?> propertyPath) {
Optional<IndexFieldDescriptor> indexFieldDescriptor =
indexedEntity.indexManager().descriptor().field(propertyPath.asStringPath());
if (!indexFieldDescriptor.isPresent()) {
return null;
}
IndexFieldDescriptor fieldDescriptor = indexFieldDescriptor.get();
if (fieldDescriptor.isObjectField()) {
return null;
}
IndexValueFieldDescriptor valueField = fieldDescriptor.toValueField();
Optional<String> analyzerName = valueField.type().analyzerName();
if (!analyzerName.isPresent()) {
return null;
}
LuceneBackend luceneBackend = indexedEntity.indexManager().backend().unwrap(LuceneBackend.class);
Optional<? extends Analyzer> analyzer = luceneBackend.analyzer(analyzerName.get());
if (!analyzer.isPresent()) {
return null;
}
return analyzer.get();
}
@Override
public PredicateFinalStep visit(FullTextTermExpr fullTextTermExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) fullTextTermExpr.getChild();
String text = fullTextTermExpr.getTerm(namedParameters);
String absoluteFieldPath = propertyValueExpr.getPropertyPath().asStringPath();
int asteriskPos = text.indexOf(LUCENE_MULTIPLE_CHARACTERS_WILDCARD);
int questionPos = text.indexOf(LUCENE_SINGLE_CHARACTER_WILDCARD);
if (asteriskPos == -1 && questionPos == -1) {
if (isMultiTermText(propertyValueExpr.getPropertyPath(), text)) {
PhrasePredicateOptionsStep<?> result = predicateFactory.phrase().field(absoluteFieldPath).matching(text);
if (fullTextTermExpr.getFuzzySlop() != null) {
// slop 4 phrase
result.slop(fullTextTermExpr.getFuzzySlop());
}
return result;
} else {
MatchPredicateOptionsStep<?> result = predicateFactory.match().field(absoluteFieldPath).matching(text);
if (fullTextTermExpr.getFuzzySlop() != null) {
// fuzzy 4 match
result.fuzzy(fullTextTermExpr.getFuzzySlop());
}
return result;
}
} else {
if (fullTextTermExpr.getFuzzySlop() != null) {
throw CONTAINER.getPrefixWildcardOrRegexpQueriesCannotBeFuzzy(fullTextTermExpr.toQueryString());
}
if (questionPos == -1 && asteriskPos == text.length() - 1) {
return predicateFactory.simpleQueryString()
.field(absoluteFieldPath).matching(text)
.flags(SimpleQueryFlag.PREFIX);
}
// wildcard query
return predicateFactory.wildcard()
.field(absoluteFieldPath).matching(text);
}
}
@Override
public PredicateFinalStep visit(FullTextRegexpExpr fullTextRegexpExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) fullTextRegexpExpr.getChild();
return predicateFactory.regexp()
.field(propertyValueExpr.getPropertyPath().asStringPath())
.matching(fullTextRegexpExpr.getRegexp());
}
@Override
public PredicateFinalStep visit(FullTextRangeExpr fullTextRangeExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) fullTextRangeExpr.getChild();
String absoluteFieldPath = propertyValueExpr.getPropertyPath().asStringPath();
Object lower = fullTextRangeExpr.getLower();
Object upper = fullTextRangeExpr.getUpper();
boolean includeLower = fullTextRangeExpr.isIncludeLower();
boolean includeUpper = fullTextRangeExpr.isIncludeUpper();
if (lower == null && upper == null) {
return predicateFactory.exists().field(absoluteFieldPath);
}
RangePredicateFieldMoreStep<?, ?> range = predicateFactory.range().field(absoluteFieldPath);
return range.between(
lower, includeLower ? RangeBoundInclusion.INCLUDED : RangeBoundInclusion.EXCLUDED,
upper, includeUpper ? RangeBoundInclusion.INCLUDED : RangeBoundInclusion.EXCLUDED);
}
@Override
public PredicateFinalStep visit(NotExpr notExpr) {
BooleanExpr childExpr = notExpr.getChild();
// not is null => exists
// instead of not ( not ( exists ) )
if (childExpr instanceof IsNullExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) ((IsNullExpr) childExpr).getChild();
return predicateFactory.exists().field(propertyValueExpr.getPropertyPath().asStringPath());
}
PredicateFinalStep childPredicate = childExpr.acceptVisitor(this);
return predicateFactory.bool().mustNot(childPredicate);
}
@Override
public PredicateFinalStep visit(OrExpr orExpr) {
BooleanPredicateClausesStep<?> bool = predicateFactory.bool();
for (BooleanExpr c : orExpr.getChildren()) {
PredicateFinalStep clause = c.acceptVisitor(this);
bool.should(clause);
}
return bool;
}
@Override
public PredicateFinalStep visit(AndExpr andExpr) {
BooleanPredicateClausesStep<?> bool = predicateFactory.bool();
for (BooleanExpr c : andExpr.getChildren()) {
PredicateFinalStep clause = c.acceptVisitor(this);
bool.must(clause);
}
return bool;
}
@Override
public PredicateFinalStep visit(IsNullExpr isNullExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) isNullExpr.getChild();
ExistsPredicateOptionsStep<?> exists = predicateFactory.exists().field(propertyValueExpr.getPropertyPath().asStringPath());
return predicateFactory.bool().mustNot(exists);
}
@Override
public PredicateFinalStep visit(ComparisonExpr comparisonExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) comparisonExpr.getLeftChild();
ConstantValueExpr constantValueExpr = (ConstantValueExpr) comparisonExpr.getRightChild();
Comparable value = constantValueExpr.getConstantValueAs(propertyValueExpr.getPrimitiveType(), namedParameters);
String path = propertyValueExpr.getPropertyPath().asStringPath();
switch (comparisonExpr.getComparisonType()) {
case NOT_EQUAL:
return predicateFactory.bool().mustNot(c -> c.match().field(path).matching(value));
case EQUAL:
return predicateFactory.match().field(path).matching(value);
case LESS:
return predicateFactory.range().field(path).lessThan(value);
case LESS_OR_EQUAL:
return predicateFactory.range().field(path).atMost(value);
case GREATER:
return predicateFactory.range().field(path).greaterThan(value);
case GREATER_OR_EQUAL:
return predicateFactory.range().field(path).atLeast(value);
default:
throw new IllegalStateException("Unexpected comparison type: " + comparisonExpr.getComparisonType());
}
}
@Override
public PredicateFinalStep visit(BetweenExpr betweenExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) betweenExpr.getLeftChild();
String path = propertyValueExpr.getPropertyPath().asStringPath();
ConstantValueExpr fromValueExpr = (ConstantValueExpr) betweenExpr.getFromChild();
ConstantValueExpr toValueExpr = (ConstantValueExpr) betweenExpr.getToChild();
Comparable fromValue = fromValueExpr.getConstantValueAs(propertyValueExpr.getPrimitiveType(), namedParameters);
Comparable toValue = toValueExpr.getConstantValueAs(propertyValueExpr.getPrimitiveType(), namedParameters);
return predicateFactory.range().field(path).between(fromValue, toValue);
}
@Override
public PredicateFinalStep visit(LikeExpr likeExpr) {
PropertyValueExpr propertyValueExpr = (PropertyValueExpr) likeExpr.getChild();
StringBuilder lucenePattern = new StringBuilder(likeExpr.getPattern(namedParameters));
// transform 'Like' pattern into Lucene wildcard pattern
boolean isEscaped = false;
for (int i = 0; i < lucenePattern.length(); i++) {
char c = lucenePattern.charAt(i);
if (!isEscaped && c == likeExpr.getEscapeChar()) {
isEscaped = true;
lucenePattern.deleteCharAt(i);
} else {
if (isEscaped) {
isEscaped = false;
} else {
if (c == LikeExpr.MULTIPLE_CHARACTERS_WILDCARD) {
lucenePattern.setCharAt(i, LUCENE_MULTIPLE_CHARACTERS_WILDCARD);
continue;
} else if (c == LikeExpr.SINGLE_CHARACTER_WILDCARD) {
lucenePattern.setCharAt(i, LUCENE_SINGLE_CHARACTER_WILDCARD);
continue;
}
}
if (c == LUCENE_SINGLE_CHARACTER_WILDCARD || c == LUCENE_MULTIPLE_CHARACTERS_WILDCARD) {
lucenePattern.insert(i, LUCENE_WILDCARD_ESCAPE_CHARACTER);
i++;
}
}
}
String path = propertyValueExpr.getPropertyPath().asStringPath();
return predicateFactory.wildcard().field(path).matching(lucenePattern.toString());
}
@Override
public PredicateFinalStep visit(ConstantBooleanExpr constantBooleanExpr) {
return constantBooleanExpr.getValue() ? predicateFactory.matchAll() :
predicateFactory.bool().mustNot(predicateFactory.matchAll());
}
@Override
public PredicateFinalStep visit(ConstantValueExpr constantValueExpr) {
throw new IllegalStateException("This node type should not be visited");
}
@Override
public PredicateFinalStep visit(PropertyValueExpr propertyValueExpr) {
throw new IllegalStateException("This node type should not be visited");
}
@Override
public PredicateFinalStep visit(AggregationExpr aggregationExpr) {
throw new IllegalStateException("This node type should not be visited");
}
}
| 22,213
| 44.802062
| 147
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/SearchQueryBuilder.java
|
package org.infinispan.query.dsl.embedded.impl;
import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.apache.lucene.search.Sort;
import org.hibernate.search.backend.lucene.LuceneExtension;
import org.hibernate.search.backend.lucene.search.query.LuceneSearchQuery;
import org.hibernate.search.backend.lucene.search.query.dsl.LuceneSearchQueryOptionsStep;
import org.hibernate.search.engine.backend.common.DocumentReference;
import org.hibernate.search.engine.common.EntityReference;
import org.hibernate.search.engine.search.predicate.SearchPredicate;
import org.hibernate.search.engine.search.projection.SearchProjection;
import org.hibernate.search.engine.search.projection.dsl.SearchProjectionFactory;
import org.hibernate.search.engine.search.sort.SearchSort;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.session.SearchSession;
/**
* Mutable builder for {@link LuceneSearchQuery}.
*
* @author Fabio Massimo Ercoli
*/
public final class SearchQueryBuilder {
private final SearchSession querySession;
private final SearchScope<?> scope;
private final SearchProjectionInfo projectionInfo;
private final SearchPredicate predicate;
private final SearchSort sort;
// target segment collection may mutate
private Collection<String> routingKeys = Collections.emptySet();
private int hitCountAccuracy;
private Long timeout;
private TimeUnit timeUnit;
public SearchQueryBuilder(SearchSession querySession, SearchScope<?> scope, SearchProjectionInfo projectionInfo,
SearchPredicate predicate, SearchSort sort, int hitCountAccuracy) {
this.querySession = querySession;
this.scope = scope;
this.projectionInfo = projectionInfo;
this.predicate = predicate;
this.sort = sort;
this.hitCountAccuracy = hitCountAccuracy;
}
public LuceneSearchQuery<?> build() {
return build(projectionInfo.getProjection());
}
public LuceneSearchQuery<Object> ids() {
return build(scope.projection().id().toProjection());
}
public LuceneSearchQuery<List<Object>> keyAndEntity() {
SearchProjectionFactory<EntityReference, ?> projectionFactory = scope.projection();
SearchProjection<?>[] searchProjections = new SearchProjection<?>[]{
projectionFactory.entityReference().toProjection(),
projectionFactory.entity().toProjection()
};
return build((SearchProjection<List<Object>>) SearchProjectionInfo.composite(projectionFactory, searchProjections).getProjection());
}
public LuceneSearchQuery<DocumentReference> documentReference() {
return build(scope.projection().documentReference().toProjection());
}
public void routeOnSegments(BitSet segments) {
routingKeys = segments.stream()
.mapToObj(String::valueOf)
.collect(Collectors.toList());
}
public void noRouting() {
routingKeys = Collections.emptySet();
}
/**
* Indicates if this query 'projects' just the entity and nothing else.
*/
public boolean isEntityProjection() {
return projectionInfo.isEntityProjection();
}
public Sort getLuceneSort() {
return ids().luceneSort();
}
private <T> LuceneSearchQuery<T> build(SearchProjection<T> searchProjection) {
LuceneSearchQueryOptionsStep<T, ?> queryOptionsStep = querySession.search(scope)
.extension(LuceneExtension.get())
.select(searchProjection)
.where(predicate)
.sort(sort)
.routing(routingKeys);
if (timeout != null && timeUnit != null) {
queryOptionsStep = queryOptionsStep.failAfter(timeout, timeUnit);
}
queryOptionsStep = queryOptionsStep.totalHitCountThreshold(hitCountAccuracy);
return queryOptionsStep.toQuery();
}
public void hitCountAccuracy(int hitCountAccuracy) {
this.hitCountAccuracy = hitCountAccuracy;
}
public void failAfter(long timeout, TimeUnit timeUnit) {
this.timeout = timeout;
this.timeUnit = timeUnit;
}
}
| 4,219
| 34.166667
| 138
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/SearchProjectionInfo.java
|
package org.infinispan.query.dsl.embedded.impl;
import org.hibernate.search.engine.common.EntityReference;
import org.hibernate.search.engine.search.projection.SearchProjection;
import org.hibernate.search.engine.search.projection.dsl.SearchProjectionFactory;
final class SearchProjectionInfo {
static SearchProjectionInfo entity(SearchProjectionFactory<EntityReference, ?> factory) {
return new SearchProjectionInfo(factory.entity().toProjection(), true);
}
static SearchProjectionInfo entityReference(SearchProjectionFactory<EntityReference, ?> factory) {
return new SearchProjectionInfo(factory.entityReference().toProjection(), false);
}
static SearchProjectionInfo field(SearchProjectionFactory<EntityReference, ?> factory,
String absoluteFieldPath, Class<?> type) {
return new SearchProjectionInfo(factory.field(absoluteFieldPath, type).toProjection(), false);
}
static SearchProjectionInfo multiField(SearchProjectionFactory<EntityReference, ?> factory,
String absoluteFieldPath, Class<?> type) {
return new SearchProjectionInfo(factory.field(absoluteFieldPath, type).multi().toProjection(), false);
}
static SearchProjectionInfo composite(SearchProjectionFactory<EntityReference, ?> factory,
SearchProjection<?>[] children) {
return new SearchProjectionInfo(factory.composite(children).toProjection(), false);
}
private final SearchProjection<?> searchProjection;
private final boolean isEntityProjection;
private SearchProjectionInfo(SearchProjection<?> searchProjection, boolean isEntityProjection) {
this.searchProjection = searchProjection;
this.isEntityProjection = isEntityProjection;
}
public SearchProjection<?> getProjection() {
return searchProjection;
}
public boolean isEntityProjection() {
return isEntityProjection;
}
}
| 1,976
| 40.1875
| 108
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/HibernateSearchPropertyHelper.java
|
package org.infinispan.query.dsl.embedded.impl;
import java.text.ParseException;
import java.util.Date;
import java.util.Optional;
import org.apache.lucene.document.DateTools;
import org.hibernate.search.engine.backend.metamodel.IndexDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldDescriptor;
import org.hibernate.search.engine.backend.metamodel.IndexValueFieldTypeDescriptor;
import org.infinispan.container.versioning.EntryVersion;
import org.infinispan.objectfilter.ParsingException;
import org.infinispan.objectfilter.impl.syntax.IndexedFieldProvider;
import org.infinispan.objectfilter.impl.syntax.parser.EntityNameResolver;
import org.infinispan.objectfilter.impl.syntax.parser.ReflectionPropertyHelper;
import org.infinispan.objectfilter.impl.syntax.parser.projection.CacheValuePropertyPath;
import org.infinispan.objectfilter.impl.syntax.parser.projection.VersionPropertyPath;
import org.infinispan.objectfilter.impl.util.StringHelper;
import org.infinispan.search.mapper.mapping.SearchIndexedEntity;
import org.infinispan.search.mapper.mapping.SearchMapping;
public class HibernateSearchPropertyHelper extends ReflectionPropertyHelper {
public static final String KEY = "__ISPN_Key";
public static final String VALUE = CacheValuePropertyPath.VALUE_PROPERTY_NAME;
public static final String VERSION = VersionPropertyPath.VERSION_PROPERTY_NAME;
private final SearchMapping searchMapping;
public HibernateSearchPropertyHelper(SearchMapping searchMapping, EntityNameResolver<Class<?>> entityNameResolver) {
super(entityNameResolver);
this.searchMapping = searchMapping;
}
@Override
public Object convertToPropertyType(Class<?> entityType, String[] propertyPath, String value) {
IndexValueFieldDescriptor fieldDescriptor = getValueFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor == null) {
return super.convertToPropertyType(entityType, propertyPath, value);
}
Class<?> type = fieldDescriptor.type().dslArgumentClass();
if (!(Date.class.equals(type))) {
return super.convertToPropertyType(entityType, propertyPath, value);
}
try {
return DateTools.stringToDate(value);
} catch (ParseException e) {
throw new ParsingException(e);
}
}
@Override
public Class<?> getPrimitivePropertyType(Class<?> entityType, String[] propertyPath) {
if (propertyPath.length == 1 && propertyPath[0].equals(VERSION)) {
return EntryVersion.class;
}
IndexValueFieldDescriptor fieldDescriptor = getValueFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor == null) {
return super.getPrimitivePropertyType(entityType, propertyPath);
}
Class<?> type = fieldDescriptor.type().dslArgumentClass();
if (type.isEnum()) {
return type;
}
return primitives.get(type);
}
@Override
public boolean isRepeatedProperty(Class<?> entityType, String[] propertyPath) {
IndexFieldDescriptor fieldDescriptor = getFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor == null) {
return super.isRepeatedProperty(entityType, propertyPath);
}
return fieldDescriptor.multiValuedInRoot();
}
@Override
public boolean hasEmbeddedProperty(Class<?> entityType, String[] propertyPath) {
IndexFieldDescriptor fieldDescriptor = getFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor == null) {
return super.hasEmbeddedProperty(entityType, propertyPath);
}
return fieldDescriptor.isObjectField();
}
@Override
public boolean hasProperty(Class<?> entityType, String[] propertyPath) {
IndexFieldDescriptor fieldDescriptor = getFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor != null) {
return true;
}
if (propertyPath.length == 1 && (propertyPath[0].equals(KEY) || propertyPath[0].equals(VALUE) ||
propertyPath[0].equals(VERSION)) ) {
return true;
}
return super.hasProperty(entityType, propertyPath);
}
@Override
public IndexedFieldProvider<Class<?>> getIndexedFieldProvider() {
return entityType -> {
IndexDescriptor indexDescriptor = getIndexDescriptor(entityType);
if (indexDescriptor == null) {
return IndexedFieldProvider.NO_INDEXING;
}
return new SearchFieldIndexingMetadata(indexDescriptor);
};
}
private IndexValueFieldDescriptor getValueFieldDescriptor(Class<?> entityType, String[] propertyPath) {
IndexFieldDescriptor fieldDescriptor = getFieldDescriptor(entityType, propertyPath);
if (fieldDescriptor == null) {
return null;
}
return (fieldDescriptor.isObjectField()) ? null : fieldDescriptor.toValueField();
}
private IndexFieldDescriptor getFieldDescriptor(Class<?> entityType, String[] propertyPath) {
IndexDescriptor indexDescriptor = getIndexDescriptor(entityType);
if (indexDescriptor == null) {
return null;
}
Optional<IndexFieldDescriptor> field = indexDescriptor.field(StringHelper.join(propertyPath));
return field.orElse(null);
}
private IndexDescriptor getIndexDescriptor(Class<?> type) {
SearchIndexedEntity indexedEntity = searchMapping.indexedEntity(type);
if (indexedEntity == null) {
return null;
}
return indexedEntity.indexManager().descriptor();
}
private static class SearchFieldIndexingMetadata implements IndexedFieldProvider.FieldIndexingMetadata {
private final IndexDescriptor indexDescriptor;
public SearchFieldIndexingMetadata(IndexDescriptor indexDescriptor) {
this.indexDescriptor = indexDescriptor;
}
@Override
public boolean isIndexed(String[] propertyPath) {
IndexValueFieldTypeDescriptor field = getField(propertyPath);
return field != null && field.searchable();
}
@Override
public boolean isAnalyzed(String[] propertyPath) {
IndexValueFieldTypeDescriptor field = getField(propertyPath);
return field != null && field.analyzerName().isPresent();
}
@Override
public boolean isProjectable(String[] propertyPath) {
IndexValueFieldTypeDescriptor field = getField(propertyPath);
return field != null && field.projectable();
}
@Override
public boolean isSortable(String[] propertyPath) {
IndexValueFieldTypeDescriptor field = getField(propertyPath);
return field != null && field.sortable();
}
@Override
public Object getNullMarker(String[] propertyPath) {
return null;
}
private IndexValueFieldTypeDescriptor getField(String[] propertyPath) {
Optional<IndexFieldDescriptor> field = indexDescriptor.field(StringHelper.join(propertyPath));
if (!field.isPresent()) {
return null;
}
IndexFieldDescriptor indexFieldDescriptor = field.get();
if (!indexFieldDescriptor.isValueField()) {
return null;
}
return indexFieldDescriptor.toValueField().type();
}
}
}
| 7,317
| 35.773869
| 119
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/QueryEngine.java
|
package org.infinispan.query.dsl.embedded.impl;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import org.infinispan.AdvancedCache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.objectfilter.Matcher;
import org.infinispan.objectfilter.SortField;
import org.infinispan.objectfilter.impl.RowMatcher;
import org.infinispan.objectfilter.impl.aggregation.FieldAccumulator;
import org.infinispan.objectfilter.impl.ql.AggregationFunction;
import org.infinispan.objectfilter.impl.ql.PropertyPath;
import org.infinispan.objectfilter.impl.syntax.AggregationExpr;
import org.infinispan.objectfilter.impl.syntax.AndExpr;
import org.infinispan.objectfilter.impl.syntax.BooleShannonExpansion;
import org.infinispan.objectfilter.impl.syntax.BooleanExpr;
import org.infinispan.objectfilter.impl.syntax.ComparisonExpr;
import org.infinispan.objectfilter.impl.syntax.ConstantBooleanExpr;
import org.infinispan.objectfilter.impl.syntax.ConstantValueExpr;
import org.infinispan.objectfilter.impl.syntax.ExprVisitor;
import org.infinispan.objectfilter.impl.syntax.FullTextVisitor;
import org.infinispan.objectfilter.impl.syntax.IndexedFieldProvider;
import org.infinispan.objectfilter.impl.syntax.IsNullExpr;
import org.infinispan.objectfilter.impl.syntax.LikeExpr;
import org.infinispan.objectfilter.impl.syntax.NotExpr;
import org.infinispan.objectfilter.impl.syntax.OrExpr;
import org.infinispan.objectfilter.impl.syntax.PropertyValueExpr;
import org.infinispan.objectfilter.impl.syntax.SyntaxTreePrinter;
import org.infinispan.objectfilter.impl.syntax.ValueExpr;
import org.infinispan.objectfilter.impl.syntax.parser.AggregationPropertyPath;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.objectfilter.impl.syntax.parser.ObjectPropertyHelper;
import org.infinispan.objectfilter.impl.syntax.parser.RowPropertyHelper;
import org.infinispan.query.clustered.DistributedIndexedQueryImpl;
import org.infinispan.query.core.impl.AggregatingQuery;
import org.infinispan.query.core.impl.EmbeddedQuery;
import org.infinispan.query.core.impl.EmptyResultQuery;
import org.infinispan.query.core.impl.HybridQuery;
import org.infinispan.query.core.impl.MetadataHybridQuery;
import org.infinispan.query.dsl.Query;
import org.infinispan.query.dsl.QueryFactory;
import org.infinispan.query.dsl.impl.BaseQuery;
import org.infinispan.query.dsl.impl.QueryStringCreator;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.impl.IndexedQuery;
import org.infinispan.query.impl.IndexedQueryImpl;
import org.infinispan.query.impl.QueryDefinition;
import org.infinispan.query.logging.Log;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.util.function.SerializableFunction;
import org.infinispan.util.logging.LogFactory;
/**
* Adds indexing capability to the light (index-less) QueryEngine from query-core module.
*
* @author anistor@redhat.com
* @since 7.2
*/
public class QueryEngine<TypeMetadata> extends org.infinispan.query.core.impl.QueryEngine<TypeMetadata> {
private static final Log log = LogFactory.getLog(QueryEngine.class, Log.class);
private static final int MAX_EXPANSION_COFACTORS = 16;
/**
* Is the cache indexed?
*/
protected final boolean isIndexed;
/**
* Optional, lazily. This is {@code null} if the cache is not actually indexed.
*/
private SearchMapping searchMapping;
private static final SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>> queryEngineProvider = c -> c.getComponentRegistry().getComponent(QueryEngine.class);
private final boolean broadcastQuery;
private final int defaultMaxResults;
private final int defaultHitCountAccuracy;
public QueryEngine(AdvancedCache<?, ?> cache, boolean isIndexed) {
this(cache, isIndexed, ObjectReflectionMatcher.class);
}
protected QueryEngine(AdvancedCache<?, ?> cache, boolean isIndexed, Class<? extends Matcher> matcherImplClass) {
super(cache, matcherImplClass);
Configuration configuration = cache.getCacheConfiguration();
CacheMode cacheMode = configuration.clustering().cacheMode();
this.broadcastQuery = cacheMode.isClustered() && !cacheMode.isReplicated();
this.isIndexed = isIndexed;
this.defaultMaxResults = configuration.query().defaultMaxResults();
this.defaultHitCountAccuracy = configuration.query().hitCountAccuracy();
}
protected SearchMapping getSearchMapping() {
if (searchMapping == null) {
searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
}
return searchMapping;
}
public Class<? extends Matcher> getMatcherClass() {
return matcherImplClass;
}
ObjectPropertyHelper<TypeMetadata> getPropertyHelper() {
return propertyHelper;
}
@Override
protected BaseQuery<?> buildQueryWithAggregations(QueryFactory queryFactory, String queryString, Map<String, Object> namedParameters, long startOffset, int maxResults, IckleParsingResult<TypeMetadata> parsingResult, boolean local) {
if (parsingResult.getProjectedPaths() == null) {
throw CONTAINER.groupingAndAggregationQueriesMustUseProjections();
}
LinkedHashMap<PropertyPath, RowPropertyHelper.ColumnMetadata> columns = new LinkedHashMap<>();
if (parsingResult.getGroupBy() != null) {
for (PropertyPath<?> p : parsingResult.getGroupBy()) {
if (p instanceof AggregationPropertyPath) {
throw CONTAINER.cannotHaveAggregationsInGroupByClause(); // should not really be possible because this was validated during parsing
}
// Duplicates in 'group by' are accepted and silently discarded. This behaviour is similar to SQL.
if (!columns.containsKey(p)) {
if (propertyHelper.isRepeatedProperty(parsingResult.getTargetEntityMetadata(), p.asArrayPath())) {
// this constraint will be relaxed later: https://issues.jboss.org/browse/ISPN-6015
throw CONTAINER.multivaluedPropertyCannotBeUsedInGroupBy(p.toString());
}
Class<?> propertyType = propertyHelper.getPrimitivePropertyType(parsingResult.getTargetEntityMetadata(), p.asArrayPath());
int idx = columns.size();
columns.put(p, new RowPropertyHelper.ColumnMetadata(idx, "C" + idx, propertyType));
}
}
}
final int noOfGroupingColumns = columns.size();
for (int i = 0; i < parsingResult.getProjectedPaths().length; i++) {
PropertyPath<?> p = parsingResult.getProjectedPaths()[i];
RowPropertyHelper.ColumnMetadata c = columns.get(p);
if (!(p instanceof AggregationPropertyPath)) {
// this must be an already processed 'group by' field, or else it's an invalid query
if (c == null || c.getColumnIndex() >= noOfGroupingColumns) {
throw CONTAINER.expressionMustBePartOfAggregateFunctionOrShouldBeIncludedInGroupByClause(p.toString());
}
}
if (c == null) {
Class<?> propertyType = FieldAccumulator.getOutputType(((AggregationPropertyPath) p).getAggregationFunction(), parsingResult.getProjectedTypes()[i]);
int idx = columns.size();
columns.put(p, new RowPropertyHelper.ColumnMetadata(idx, "C" + idx, propertyType));
}
}
if (parsingResult.getSortFields() != null) {
for (SortField sortField : parsingResult.getSortFields()) {
PropertyPath<?> p = sortField.getPath();
RowPropertyHelper.ColumnMetadata c = columns.get(p);
if (!(p instanceof AggregationPropertyPath)) {
// this must be an already processed 'group by' field, or else it's an invalid query
if (c == null || c.getColumnIndex() >= noOfGroupingColumns) {
throw CONTAINER.expressionMustBePartOfAggregateFunctionOrShouldBeIncludedInGroupByClause(p.toString());
}
}
if (c == null) {
Class<?> propertyType = propertyHelper.getPrimitivePropertyType(parsingResult.getTargetEntityMetadata(), p.asArrayPath());
int idx = columns.size();
columns.put(p, new RowPropertyHelper.ColumnMetadata(idx, "C" + idx, propertyType));
}
}
}
String havingClause = null;
if (parsingResult.getHavingClause() != null) {
BooleanExpr normalizedHavingClause = booleanFilterNormalizer.normalize(parsingResult.getHavingClause());
if (normalizedHavingClause == ConstantBooleanExpr.FALSE) {
return new EmptyResultQuery<>(queryFactory, cache, queryString, parsingResult.getStatementType(), namedParameters, startOffset, maxResults, queryStatistics);
}
if (normalizedHavingClause != ConstantBooleanExpr.TRUE) {
havingClause = SyntaxTreePrinter.printTree(swapVariables(normalizedHavingClause, parsingResult.getTargetEntityMetadata(),
columns, namedParameters, propertyHelper));
}
}
// validity of query is established at this point, no more checks needed
for (PropertyPath<?> p : columns.keySet()) {
if (propertyHelper.isRepeatedProperty(parsingResult.getTargetEntityMetadata(), p.asArrayPath())) {
return buildQueryWithRepeatedAggregations(queryFactory, queryString, namedParameters, startOffset, maxResults,
parsingResult, havingClause, columns, noOfGroupingColumns, local);
}
}
LinkedHashMap<String, Integer> inColumns = new LinkedHashMap<>();
List<FieldAccumulator> accumulators = new LinkedList<>();
RowPropertyHelper.ColumnMetadata[] _columns = new RowPropertyHelper.ColumnMetadata[columns.size()];
for (PropertyPath<?> p : columns.keySet()) {
RowPropertyHelper.ColumnMetadata c = columns.get(p);
_columns[c.getColumnIndex()] = c;
String asStringPath = p.asStringPath();
Integer inIdx = inColumns.get(asStringPath);
if (inIdx == null) {
inIdx = inColumns.size();
inColumns.put(asStringPath, inIdx);
}
if (p instanceof AggregationPropertyPath) {
FieldAccumulator acc = FieldAccumulator.makeAccumulator(((AggregationPropertyPath) p).getAggregationFunction(), inIdx, c.getColumnIndex(), c.getPropertyType());
accumulators.add(acc);
}
}
StringBuilder firstPhaseQuery = new StringBuilder();
firstPhaseQuery.append("SELECT ");
{
boolean isFirst = true;
for (String p : inColumns.keySet()) {
if (isFirst) {
isFirst = false;
} else {
firstPhaseQuery.append(", ");
}
firstPhaseQuery.append(QueryStringCreator.DEFAULT_ALIAS).append('.').append(p);
}
}
firstPhaseQuery.append(" FROM ").append(parsingResult.getTargetEntityName()).append(' ').append(QueryStringCreator.DEFAULT_ALIAS);
if (parsingResult.getWhereClause() != null) {
// the WHERE clause should not touch aggregated fields
BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause());
if (normalizedWhereClause == ConstantBooleanExpr.FALSE) {
return new EmptyResultQuery<>(queryFactory, cache, queryString, parsingResult.getStatementType(), namedParameters, startOffset, maxResults, queryStatistics);
}
if (normalizedWhereClause != ConstantBooleanExpr.TRUE) {
firstPhaseQuery.append(' ').append(SyntaxTreePrinter.printTree(normalizedWhereClause));
}
}
StringBuilder secondPhaseQuery = new StringBuilder();
secondPhaseQuery.append("SELECT ");
{
for (int i = 0; i < parsingResult.getProjectedPaths().length; i++) {
PropertyPath<?> p = parsingResult.getProjectedPaths()[i];
RowPropertyHelper.ColumnMetadata c = columns.get(p);
if (i != 0) {
secondPhaseQuery.append(", ");
}
secondPhaseQuery.append(c.getColumnName());
}
}
secondPhaseQuery.append(" FROM Row ");
if (havingClause != null) {
secondPhaseQuery.append(' ').append(havingClause);
}
if (parsingResult.getSortFields() != null) {
secondPhaseQuery.append(" ORDER BY ");
boolean isFirst = true;
for (SortField sortField : parsingResult.getSortFields()) {
if (isFirst) {
isFirst = false;
} else {
secondPhaseQuery.append(", ");
}
RowPropertyHelper.ColumnMetadata c = columns.get(sortField.getPath());
secondPhaseQuery.append(c.getColumnName()).append(' ').append(sortField.isAscending() ? "ASC" : "DESC");
}
}
// first phase: gather rows matching the 'where' clause
String firstPhaseQueryStr = firstPhaseQuery.toString();
// TODO ISPN-13986 Improve the efficiency of aggregation deletege them to Search!
BaseQuery<?> baseQuery = buildQueryNoAggregations(queryFactory, firstPhaseQueryStr, namedParameters, -1, Integer.MAX_VALUE, parse(firstPhaseQueryStr), local);
// second phase: grouping, aggregation, 'having' clause filtering, sorting and pagination
String secondPhaseQueryStr = secondPhaseQuery.toString();
return new AggregatingQuery<>(queryFactory, cache, secondPhaseQueryStr, namedParameters,
noOfGroupingColumns, accumulators, false,
getObjectFilter(new RowMatcher(_columns), secondPhaseQueryStr, namedParameters, null),
startOffset, maxResults, baseQuery, queryStatistics, local);
}
/**
* Swaps all occurrences of PropertyPaths in given expression tree (the HAVING clause) with new PropertyPaths
* according to the mapping found in {@code columns} map.
*/
private BooleanExpr swapVariables(BooleanExpr expr, TypeMetadata targetEntityMetadata,
LinkedHashMap<PropertyPath, RowPropertyHelper.ColumnMetadata> columns,
Map<String, Object> namedParameters, ObjectPropertyHelper<TypeMetadata> propertyHelper) {
class PropertyReplacer extends ExprVisitor {
@Override
public BooleanExpr visit(NotExpr notExpr) {
return new NotExpr(notExpr.getChild().acceptVisitor(this));
}
@Override
public BooleanExpr visit(OrExpr orExpr) {
List<BooleanExpr> visitedChildren = new ArrayList<>();
for (BooleanExpr c : orExpr.getChildren()) {
visitedChildren.add(c.acceptVisitor(this));
}
return new OrExpr(visitedChildren);
}
@Override
public BooleanExpr visit(AndExpr andExpr) {
List<BooleanExpr> visitedChildren = new ArrayList<>();
for (BooleanExpr c : andExpr.getChildren()) {
visitedChildren.add(c.acceptVisitor(this));
}
return new AndExpr(visitedChildren);
}
@Override
public BooleanExpr visit(ConstantBooleanExpr constantBooleanExpr) {
return constantBooleanExpr;
}
@Override
public BooleanExpr visit(IsNullExpr isNullExpr) {
return new IsNullExpr(isNullExpr.getChild().acceptVisitor(this));
}
@Override
public BooleanExpr visit(ComparisonExpr comparisonExpr) {
return new ComparisonExpr(comparisonExpr.getLeftChild().acceptVisitor(this), comparisonExpr.getRightChild(), comparisonExpr.getComparisonType());
}
@Override
public BooleanExpr visit(LikeExpr likeExpr) {
return new LikeExpr(likeExpr.getChild().acceptVisitor(this), likeExpr.getPattern(namedParameters));
}
@Override
public ValueExpr visit(ConstantValueExpr constantValueExpr) {
return constantValueExpr;
}
@Override
public ValueExpr visit(PropertyValueExpr propertyValueExpr) {
RowPropertyHelper.ColumnMetadata c = columns.get(propertyValueExpr.getPropertyPath());
if (c == null) {
throw CONTAINER.expressionMustBePartOfAggregateFunctionOrShouldBeIncludedInGroupByClause(propertyValueExpr.toQueryString());
}
return new PropertyValueExpr(c.getColumnName(), propertyValueExpr.isRepeated(), propertyValueExpr.getPrimitiveType());
}
@Override
public ValueExpr visit(AggregationExpr aggregationExpr) {
RowPropertyHelper.ColumnMetadata c = columns.get(aggregationExpr.getPropertyPath());
if (c == null) {
Class<?> propertyType = propertyHelper.getPrimitivePropertyType(targetEntityMetadata, aggregationExpr.getPropertyPath().asArrayPath());
propertyType = FieldAccumulator.getOutputType(aggregationExpr.getAggregationType(), propertyType);
int idx = columns.size();
c = new RowPropertyHelper.ColumnMetadata(idx, "C" + idx, propertyType);
columns.put(aggregationExpr.getPropertyPath(), c);
return new PropertyValueExpr(c.getColumnName(), aggregationExpr.isRepeated(), propertyType);
}
return new PropertyValueExpr(c.getColumnName(), aggregationExpr.isRepeated(), aggregationExpr.getPrimitiveType());
}
}
return expr.acceptVisitor(new PropertyReplacer());
}
private BaseQuery<?> buildQueryWithRepeatedAggregations(QueryFactory queryFactory, String queryString, Map<String, Object> namedParameters, long startOffset, int maxResults,
IckleParsingResult<TypeMetadata> parsingResult, String havingClause,
LinkedHashMap<PropertyPath, RowPropertyHelper.ColumnMetadata> columns, int noOfGroupingColumns, boolean local) {
// these types of aggregations can only be computed in memory
StringBuilder firstPhaseQuery = new StringBuilder();
firstPhaseQuery.append("FROM ").append(parsingResult.getTargetEntityName()).append(' ').append(QueryStringCreator.DEFAULT_ALIAS);
if (parsingResult.getWhereClause() != null) {
// the WHERE clause should not touch aggregated fields
BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause());
if (normalizedWhereClause == ConstantBooleanExpr.FALSE) {
return new EmptyResultQuery<>(queryFactory, cache, queryString, parsingResult.getStatementType(), namedParameters, startOffset, maxResults, queryStatistics);
}
if (normalizedWhereClause != ConstantBooleanExpr.TRUE) {
firstPhaseQuery.append(' ').append(SyntaxTreePrinter.printTree(normalizedWhereClause));
}
}
String firstPhaseQueryStr = firstPhaseQuery.toString();
BaseQuery<?> baseQuery = buildQueryNoAggregations(queryFactory, firstPhaseQueryStr, namedParameters, -1, -1, parse(firstPhaseQueryStr), local);
List<FieldAccumulator> secondPhaseAccumulators = new LinkedList<>();
List<FieldAccumulator> thirdPhaseAccumulators = new LinkedList<>();
RowPropertyHelper.ColumnMetadata[] _columns = new RowPropertyHelper.ColumnMetadata[columns.size()];
StringBuilder secondPhaseQuery = new StringBuilder();
secondPhaseQuery.append("SELECT ");
for (PropertyPath<?> p : columns.keySet()) {
RowPropertyHelper.ColumnMetadata c = columns.get(p);
if (c.getColumnIndex() > 0) {
secondPhaseQuery.append(", ");
}
// only multi-valued fields need to be accumulated in this phase; for the others the accumulator is null
if (p instanceof AggregationPropertyPath) {
FieldAccumulator acc = FieldAccumulator.makeAccumulator(((AggregationPropertyPath) p).getAggregationFunction(), c.getColumnIndex(), c.getColumnIndex(), c.getPropertyType());
if (propertyHelper.isRepeatedProperty(parsingResult.getTargetEntityMetadata(), p.asArrayPath())) {
secondPhaseAccumulators.add(acc);
if (((AggregationPropertyPath) p).getAggregationFunction() == AggregationFunction.COUNT) {
c = new RowPropertyHelper.ColumnMetadata(c.getColumnIndex(), c.getColumnName(), Long.class);
acc = FieldAccumulator.makeAccumulator(AggregationFunction.SUM, c.getColumnIndex(), c.getColumnIndex(), Long.class);
}
} else {
secondPhaseAccumulators.add(null);
}
thirdPhaseAccumulators.add(acc);
} else {
secondPhaseAccumulators.add(null);
}
secondPhaseQuery.append(QueryStringCreator.DEFAULT_ALIAS).append('.').append(p.asStringPath());
_columns[c.getColumnIndex()] = c;
}
secondPhaseQuery.append(" FROM ").append(parsingResult.getTargetEntityName()).append(' ').append(QueryStringCreator.DEFAULT_ALIAS);
String secondPhaseQueryStr = secondPhaseQuery.toString();
HybridQuery<?, ?> projectingAggregatingQuery = new HybridQuery<>(queryFactory, cache,
secondPhaseQueryStr, parsingResult.getStatementType(), namedParameters,
getObjectFilter(matcher, secondPhaseQueryStr, namedParameters, secondPhaseAccumulators),
startOffset, maxResults, baseQuery, queryStatistics, local);
StringBuilder thirdPhaseQuery = new StringBuilder();
thirdPhaseQuery.append("SELECT ");
for (int i = 0; i < parsingResult.getProjectedPaths().length; i++) {
PropertyPath<?> p = parsingResult.getProjectedPaths()[i];
RowPropertyHelper.ColumnMetadata c = columns.get(p);
if (i != 0) {
thirdPhaseQuery.append(", ");
}
thirdPhaseQuery.append(c.getColumnName());
}
thirdPhaseQuery.append(" FROM Row ");
if (havingClause != null) {
thirdPhaseQuery.append(' ').append(havingClause);
}
if (parsingResult.getSortFields() != null) {
thirdPhaseQuery.append(" ORDER BY ");
boolean isFirst = true;
for (SortField sortField : parsingResult.getSortFields()) {
if (isFirst) {
isFirst = false;
} else {
thirdPhaseQuery.append(", ");
}
RowPropertyHelper.ColumnMetadata c = columns.get(sortField.getPath());
thirdPhaseQuery.append(c.getColumnName()).append(' ').append(sortField.isAscending() ? "ASC" : "DESC");
}
}
String thirdPhaseQueryStr = thirdPhaseQuery.toString();
return new AggregatingQuery<>(queryFactory, cache, thirdPhaseQueryStr, namedParameters,
noOfGroupingColumns, thirdPhaseAccumulators, true,
getObjectFilter(new RowMatcher(_columns), thirdPhaseQueryStr, namedParameters, null),
startOffset, maxResults, projectingAggregatingQuery, queryStatistics, local);
}
@Override
protected BaseQuery<?> buildQueryNoAggregations(QueryFactory queryFactory, String queryString, Map<String, Object> namedParameters,
long startOffset, int maxResults, IckleParsingResult<TypeMetadata> parsingResult, boolean local) {
if (parsingResult.hasGroupingOrAggregations()) {
throw CONTAINER.queryMustNotUseGroupingOrAggregation(); // may happen only due to internal programming error
}
if (!isIndexed && parsingResult.getWhereClause() != null) {
boolean isFullTextQuery = parsingResult.getWhereClause().acceptVisitor(FullTextVisitor.INSTANCE);
if (isFullTextQuery) {
throw new IllegalStateException("The cache must be indexed in order to use full-text queries.");
}
}
if (parsingResult.getSortFields() != null) {
for (SortField sortField : parsingResult.getSortFields()) {
PropertyPath<?> p = sortField.getPath();
if (propertyHelper.isRepeatedProperty(parsingResult.getTargetEntityMetadata(), p.asArrayPath())) {
throw CONTAINER.multivaluedPropertyCannotBeUsedInOrderBy(p.toString());
}
}
}
if (parsingResult.getProjectedPaths() != null) {
for (PropertyPath<?> p : parsingResult.getProjectedPaths()) {
if (propertyHelper.isRepeatedProperty(parsingResult.getTargetEntityMetadata(), p.asArrayPath())) {
throw CONTAINER.multivaluedPropertyCannotBeProjected(p.asStringPath());
}
}
}
BooleanExpr normalizedWhereClause = booleanFilterNormalizer.normalize(parsingResult.getWhereClause());
if (normalizedWhereClause == ConstantBooleanExpr.FALSE) {
// the query is a contradiction, there are no matches
return new EmptyResultQuery<>(queryFactory, cache, queryString, parsingResult.getStatementType(), namedParameters, startOffset, maxResults, queryStatistics);
}
if (!isIndexed) {
return new EmbeddedQuery<>(this, queryFactory, cache, queryString, parsingResult.getStatementType(),
namedParameters, parsingResult.getProjections(), startOffset, maxResults, defaultMaxResults,
queryStatistics, local);
}
IndexedFieldProvider.FieldIndexingMetadata fieldIndexingMetadata = propertyHelper.getIndexedFieldProvider().get(parsingResult.getTargetEntityMetadata());
boolean allProjectionsAreStored = true;
LinkedHashMap<PropertyPath, List<Integer>> projectionsMap = null;
if (parsingResult.getProjectedPaths() != null) {
projectionsMap = new LinkedHashMap<>();
for (int i = 0; i < parsingResult.getProjectedPaths().length; i++) {
PropertyPath<?> p = parsingResult.getProjectedPaths()[i];
List<Integer> idx = projectionsMap.get(p);
if (idx == null) {
idx = new ArrayList<>();
projectionsMap.put(p, idx);
if (!fieldIndexingMetadata.isProjectable(p.asArrayPath())) {
allProjectionsAreStored = false;
}
}
idx.add(i);
}
}
boolean allSortFieldsAreStored = true;
SortField[] sortFields = parsingResult.getSortFields();
if (sortFields != null) {
// deduplicate sort fields
LinkedHashMap<String, SortField> sortFieldMap = new LinkedHashMap<>();
for (SortField sf : sortFields) {
PropertyPath<?> p = sf.getPath();
String asStringPath = p.asStringPath();
if (!sortFieldMap.containsKey(asStringPath)) {
sortFieldMap.put(asStringPath, sf);
if (!fieldIndexingMetadata.isSortable(p.asArrayPath())) {
allSortFieldsAreStored = false;
}
}
}
sortFields = sortFieldMap.values().toArray(new SortField[sortFieldMap.size()]);
}
//todo [anistor] do not allow hybrid queries with fulltext. exception, allow a fully indexed query followed by in-memory aggregation. the aggregated or 'having' field should not be analyzed
//todo [anistor] do we allow aggregation in fulltext queries?
//todo [anistor] do not allow hybrid fulltext queries. all 'where' fields must be indexed. all projections must be stored.
BooleShannonExpansion bse = new BooleShannonExpansion(MAX_EXPANSION_COFACTORS, fieldIndexingMetadata);
BooleanExpr expansion = bse.expand(normalizedWhereClause);
if (expansion == normalizedWhereClause) { // identity comparison is intended here!
// all involved fields are indexed, so go the Lucene way
if (allSortFieldsAreStored) {
if (allProjectionsAreStored) {
// all projections are stored, so we can execute the query entirely against the index, and we can also sort using the index
RowProcessor rowProcessor = null;
if (parsingResult.getProjectedPaths() != null) {
if (projectionsMap.size() != parsingResult.getProjectedPaths().length) {
// but some projections are duplicated and Hibernate Serach does not allow duplicate projections ...
final Class<?>[] projectedTypes = new Class<?>[projectionsMap.size()];
final Object[] deduplicatedProjectedNullMarkers = parsingResult.getProjectedNullMarkers() != null ? new Object[projectedTypes.length] : null;
final int[] map = new int[parsingResult.getProjectedPaths().length];
int j = 0;
for (List<Integer> idx : projectionsMap.values()) {
int i = idx.get(0);
projectedTypes[j] = parsingResult.getProjectedTypes()[i];
if (deduplicatedProjectedNullMarkers != null) {
deduplicatedProjectedNullMarkers[j] = parsingResult.getProjectedNullMarkers()[i];
}
for (int k : idx) {
map[k] = j;
}
j++;
}
RowProcessor projectionProcessor = makeProjectionProcessor(projectedTypes, deduplicatedProjectedNullMarkers);
rowProcessor = inRow -> {
if (projectionProcessor != null) {
inRow = projectionProcessor.apply(inRow);
}
Object[] outRow = new Object[map.length];
for (int i = 0; i < map.length; i++) {
outRow[i] = inRow[map[i]];
}
return outRow;
};
PropertyPath[] deduplicatedProjection = projectionsMap.keySet().toArray(new PropertyPath[projectionsMap.size()]);
IckleParsingResult<TypeMetadata> fpr = makeFilterParsingResult(parsingResult, normalizedWhereClause, deduplicatedProjection, projectedTypes, deduplicatedProjectedNullMarkers, sortFields);
return new EmbeddedLuceneQuery<>(this, queryFactory, namedParameters, fpr, parsingResult.getProjections(), rowProcessor, startOffset, maxResults, local);
} else {
// happy case: no projections are duplicated
rowProcessor = makeProjectionProcessor(parsingResult.getProjectedTypes(), parsingResult.getProjectedNullMarkers());
}
}
return new EmbeddedLuceneQuery<>(this, queryFactory, namedParameters, parsingResult, parsingResult.getProjections(), rowProcessor, startOffset, maxResults, local);
} else {
IckleParsingResult<TypeMetadata> fpr = makeFilterParsingResult(parsingResult, normalizedWhereClause, null, null, null, sortFields);
Query<?> indexQuery = new EmbeddedLuceneQuery<>(this, queryFactory, namedParameters, fpr, null, null, startOffset, maxResults, local);
String projectionQueryStr = SyntaxTreePrinter.printTree(parsingResult.getTargetEntityName(), parsingResult.getProjectedPaths(), null, null);
return new MetadataHybridQuery<>(queryFactory, cache, projectionQueryStr, parsingResult.getStatementType(), null, getObjectFilter(matcher, projectionQueryStr, null, null), startOffset, maxResults, indexQuery, queryStatistics, local);
}
} else {
// projections may be stored but some sort fields are not so we need to query the index and then execute in-memory sorting and projecting in a second phase
IckleParsingResult<TypeMetadata> fpr = makeFilterParsingResult(parsingResult, normalizedWhereClause, null, null, null, null);
Query<?> indexQuery = new EmbeddedLuceneQuery<>(this, queryFactory, namedParameters, fpr, null, null, -1, -1, local);
String projectionQueryStr = SyntaxTreePrinter.printTree(parsingResult.getTargetEntityName(), parsingResult.getProjectedPaths(), null, sortFields);
return new MetadataHybridQuery<>(queryFactory, cache, projectionQueryStr, parsingResult.getStatementType(), null, getObjectFilter(matcher, projectionQueryStr, null, null), startOffset, maxResults, indexQuery, queryStatistics, local);
}
}
if (expansion == ConstantBooleanExpr.TRUE) {
// expansion leads to a full non-indexed query or the expansion is too long/complex
return new EmbeddedQuery<>(this, queryFactory, cache, queryString, parsingResult.getStatementType(),
namedParameters, parsingResult.getProjections(), startOffset, maxResults, defaultMaxResults,
queryStatistics, local);
}
// some fields are indexed, run a hybrid query
IckleParsingResult<TypeMetadata> fpr = makeFilterParsingResult(parsingResult, expansion, null, null, null, null);
Query<?> expandedQuery = new EmbeddedLuceneQuery<>(this, queryFactory, namedParameters, fpr, null, null, -1, -1, local);
return new MetadataHybridQuery<>(queryFactory, cache, queryString, parsingResult.getStatementType(), namedParameters, getObjectFilter(matcher, queryString, namedParameters, null), startOffset, maxResults, expandedQuery, queryStatistics, local);
}
/**
* Make a new FilterParsingResult after normalizing the query. This FilterParsingResult is not supposed to have
* grouping/aggregation.
*/
private IckleParsingResult<TypeMetadata> makeFilterParsingResult(IckleParsingResult<TypeMetadata> parsingResult, BooleanExpr normalizedWhereClause,
PropertyPath[] projection, Class<?>[] projectedTypes, Object[] projectedNullMarkers,
SortField[] sortFields) {
String queryString = SyntaxTreePrinter.printTree(parsingResult.getTargetEntityName(), projection, normalizedWhereClause, sortFields);
return new IckleParsingResult<>(queryString, parsingResult.getStatementType(), parsingResult.getParameterNames(),
normalizedWhereClause, null,
parsingResult.getTargetEntityName(), parsingResult.getTargetEntityMetadata(),
projection, projectedTypes, projectedNullMarkers, null, sortFields);
}
/**
* Apply some post-processing to the result when we have projections.
*/
protected RowProcessor makeProjectionProcessor(Class<?>[] projectedTypes, Object[] projectedNullMarkers) {
// In embedded mode Hibernate Search is a real blessing as it does all the work for us already. Nothing to be done here.
return null;
}
public SearchQueryBuilder buildSearchQuery(String queryString, Map<String, Object> namedParameters) {
if (log.isDebugEnabled()) {
log.debugf("Building Lucene query for Ickle query: %s", queryString);
}
if (!isIndexed) {
throw CONTAINER.cannotRunLuceneQueriesIfNotIndexed(cache.getName());
}
IckleParsingResult<TypeMetadata> parsingResult = parse(queryString);
if (parsingResult.hasGroupingOrAggregations()) {
throw CONTAINER.groupAggregationsNotSupported();
}
return transformParsingResult(parsingResult, namedParameters);
}
public <E> IndexedQuery<E> buildLuceneQuery(IckleParsingResult<TypeMetadata> parsingResult,
Map<String, Object> namedParameters, long startOffset, int maxResults, boolean local) {
if (log.isDebugEnabled()) {
log.debugf("Building Lucene query for Ickle query: %s", parsingResult.getQueryString());
}
if (!isIndexed) {
throw CONTAINER.cannotRunLuceneQueriesIfNotIndexed(cache.getName());
}
SearchQueryBuilder searchQuery = transformParsingResult(parsingResult, namedParameters);
IndexedQuery<?> cacheQuery = makeCacheQuery(parsingResult, searchQuery, namedParameters, local);
if (startOffset >= 0) {
cacheQuery = cacheQuery.firstResult((int) startOffset);
}
if (maxResults >= 0) {
cacheQuery = cacheQuery.maxResults(maxResults);
}
return (IndexedQuery<E>) cacheQuery;
}
public SearchQueryBuilder transformParsingResult(IckleParsingResult<TypeMetadata> parsingResult, Map<String, Object> namedParameters) {
SearchQueryParsingResult searchParsingResult;
if (queryCache != null && parsingResult.getParameterNames().isEmpty()) {
searchParsingResult = queryCache.get(cache.getName(), parsingResult.getQueryString(), null, SearchQueryParsingResult.class,
(q, a) -> transformToSearchQueryParsingResult(parsingResult, namedParameters));
} else {
searchParsingResult = transformToSearchQueryParsingResult(parsingResult, namedParameters);
}
return searchParsingResult.builder(getSearchMapping().getMappingSession());
}
private SearchQueryParsingResult transformToSearchQueryParsingResult(IckleParsingResult<TypeMetadata> parsingResult, Map<String, Object> namedParameters) {
SearchQueryMaker<TypeMetadata> queryMaker = new SearchQueryMaker<>(getSearchMapping(), propertyHelper, defaultHitCountAccuracy);
return queryMaker.transform(parsingResult, namedParameters, getTargetedClass(parsingResult), getTargetedNamedType(parsingResult));
}
@Override
public IckleParsingResult<TypeMetadata> parse(String queryString) {
return super.parse(queryString); // TODO [anistor] public just for org/infinispan/query/dsl/embedded/impl/EmbeddedQueryEngineTest.java
}
protected Class<?> getTargetedClass(IckleParsingResult<?> parsingResult) {
return (Class<?>) parsingResult.getTargetEntityMetadata();
}
protected String getTargetedNamedType(IckleParsingResult<?> parsingResult) {
// used by RemoteQueryEngine
return null;
}
protected IndexedQuery<?> makeCacheQuery(IckleParsingResult<TypeMetadata> ickleParsingResult,
SearchQueryBuilder searchQuery, Map<String, Object> namedParameters, boolean local) {
if (!isIndexed) {
throw CONTAINER.cannotRunLuceneQueriesIfNotIndexed(cache.getName());
}
String queryString = ickleParsingResult.getQueryString();
if (broadcastQuery && !local) {
QueryDefinition queryDefinition = new QueryDefinition(queryString, ickleParsingResult.getStatementType(),
getQueryEngineProvider(), defaultMaxResults);
queryDefinition.setNamedParameters(namedParameters);
return new DistributedIndexedQueryImpl<>(queryDefinition, cache, queryStatistics, defaultMaxResults);
}
return new IndexedQueryImpl<>(queryString, ickleParsingResult.getStatementType(), searchQuery, cache,
queryStatistics, defaultMaxResults);
}
protected SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>> getQueryEngineProvider() {
return queryEngineProvider;
}
/**
* A result processor that processes projections (rows). The input row is never {@code null}.
* <p>
* Applies some data conversion to some elements of the row. The input row can be modified in-place or a new one (of
* equal or different size) can be created and returned. Some of the possible processing are type conversions and the
* processing of null markers.
*/
@FunctionalInterface
protected interface RowProcessor extends Function<Object[], Object[]> {
}
}
| 39,858
| 52.430295
| 250
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/MetadataProjectableAdapter.java
|
package org.infinispan.query.dsl.embedded.impl;
import java.util.List;
import org.infinispan.AdvancedCache;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.objectfilter.impl.MetadataAdapter;
import org.infinispan.objectfilter.impl.predicateindex.MetadataProjectable;
abstract public class MetadataProjectableAdapter<TypeMetadata, AttributeMetadata, AttributeId extends Comparable<AttributeId>>
implements MetadataAdapter<TypeMetadata, AttributeMetadata, AttributeId>,
MetadataProjectable<AttributeId> {
private final MetadataAdapter<TypeMetadata, AttributeMetadata, AttributeId> baseAdapter;
private final AdvancedCache<?, ?> cache;
public MetadataProjectableAdapter(MetadataAdapter<TypeMetadata, AttributeMetadata, AttributeId> baseAdapter,
AdvancedCache<?, ?> cache) {
this.baseAdapter = baseAdapter;
this.cache = cache;
}
@Override
public String getTypeName() {
return baseAdapter.getTypeName();
}
@Override
public TypeMetadata getTypeMetadata() {
return baseAdapter.getTypeMetadata();
}
@Override
public List<AttributeId> mapPropertyNamePathToFieldIdPath(String[] path) {
return baseAdapter.mapPropertyNamePathToFieldIdPath(path);
}
@Override
public AttributeMetadata makeChildAttributeMetadata(AttributeMetadata parentAttributeMetadata, AttributeId attribute) {
return baseAdapter.makeChildAttributeMetadata(parentAttributeMetadata, attribute);
}
@Override
public boolean isComparableProperty(AttributeMetadata propertyAccessor) {
return baseAdapter.isComparableProperty(propertyAccessor);
}
@Override
public Object projection(Object key, AttributeId attribute) {
CacheEntry<?, ?> cacheEntry = cache.getCacheEntry(key);
if (cacheEntry == null) {
return null;
}
return projection(cacheEntry, attribute);
}
public abstract Object projection(CacheEntry<?, ?> cacheEntry, AttributeId attribute);
}
| 2,031
| 32.866667
| 126
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/dsl/embedded/impl/SearchQueryParsingResult.java
|
package org.infinispan.query.dsl.embedded.impl;
import java.util.Map;
import org.hibernate.search.engine.search.predicate.SearchPredicate;
import org.hibernate.search.engine.search.query.SearchQuery;
import org.hibernate.search.engine.search.sort.SearchSort;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.search.mapper.scope.SearchScope;
import org.infinispan.search.mapper.session.SearchSession;
/**
* Result of {@link SearchQueryMaker#transform(IckleParsingResult, Map, Class, String)}.
* Unlike a {@link SearchQuery} the instances can be cached and reuse later from different threads.
*
* @author Fabio Massimo Ercoli
*/
public final class SearchQueryParsingResult {
private final Class<?> targetedType;
private final String targetedTypeName;
private final SearchProjectionInfo projectionInfo;
private final SearchPredicate predicate;
private final SearchSort sort;
private final int hitCountAccuracy;
public SearchQueryParsingResult(Class<?> targetedType, String targetedTypeName, SearchProjectionInfo projectionInfo,
SearchPredicate predicate, SearchSort sort, int hitCountAccuracy) {
this.targetedType = targetedType;
this.targetedTypeName = targetedTypeName;
this.projectionInfo = projectionInfo;
this.predicate = predicate;
this.sort = sort;
this.hitCountAccuracy = hitCountAccuracy;
}
public SearchQueryBuilder builder(SearchSession querySession) {
SearchScope<?> scope = getScope(querySession);
return new SearchQueryBuilder(querySession, scope, projectionInfo, predicate, sort, hitCountAccuracy);
}
private SearchScope<?> getScope(SearchSession querySession) {
return targetedTypeName == null ? querySession.scope(targetedType) :
querySession.scope(targetedType, targetedTypeName);
}
}
| 1,896
| 39.361702
| 119
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/package-info.java
|
/**
* @api.private
*/
package org.infinispan.query.clustered;
| 64
| 12
| 39
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/ClusteredQueryInvoker.java
|
package org.infinispan.query.clustered;
import static org.infinispan.commons.util.concurrent.CompletableFutures.await;
import static org.infinispan.commons.util.concurrent.CompletableFutures.sequence;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
import java.util.stream.Collectors;
import org.apache.lucene.search.TimeLimitingCollector.TimeExceededException;
import org.hibernate.search.util.common.SearchException;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.Util;
import org.infinispan.query.SearchTimeoutException;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.remoting.rpc.RpcManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.remoting.transport.impl.SingleResponseCollector;
/**
* Invoke a ClusteredQueryCommand on the cluster, including on own node.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @author Sanne Grinovero <sanne@infinispan.org> (C) 2011 Red Hat Inc.
* @since 5.1
*/
final class ClusteredQueryInvoker {
private final RpcManager rpcManager;
private final LocalQueryStatistics queryStatistics;
private final AdvancedCache<?, ?> cache;
private final Address myAddress;
private final QueryPartitioner partitioner;
ClusteredQueryInvoker(AdvancedCache<?, ?> cache, LocalQueryStatistics queryStatistics) {
this.cache = cache;
this.rpcManager = cache.getRpcManager();
this.queryStatistics = queryStatistics;
this.myAddress = rpcManager.getAddress();
this.partitioner = new QueryPartitioner(cache);
}
/**
* Broadcast this ClusteredQueryOperation to all cluster nodes. Each node will query a specific number of segments,
* with the local mode having preference to process as much segments as possible. The remainder segments will be
* processed by the respective primary owners.
*
* @param operation The {@link ClusteredQueryOperation} to perform cluster wide.
* @return the responses
*/
List<QueryResponse> broadcast(ClusteredQueryOperation operation) {
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
Map<Address, BitSet> split = partitioner.split();
SegmentsClusteredQueryCommand localCommand = new SegmentsClusteredQueryCommand(cache.getName(), operation, split.get(myAddress));
// invoke on own node
CompletionStage<QueryResponse> localResponse = localInvoke(localCommand);
List<CompletableFuture<QueryResponse>> futureRemoteResponses = split.entrySet().stream()
.filter(e -> !e.getKey().equals(myAddress)).map(e -> {
Address address = e.getKey();
BitSet segments = e.getValue();
SegmentsClusteredQueryCommand cmd = new SegmentsClusteredQueryCommand(cache.getName(), operation, segments);
return rpcManager.invokeCommand(address, cmd, SingleResponseCollector.validOnly(),
rpcManager.getSyncRpcOptions()).toCompletableFuture();
}).map(a -> a.thenApply(r -> (QueryResponse) r.getResponseValue())).collect(Collectors.toList());
List<QueryResponse> results = new ArrayList<>();
try {
results.add(await(localResponse.toCompletableFuture()));
results.addAll(await(sequence(futureRemoteResponses)));
if (queryStatistics.isEnabled()) {
String queryString = operation.getQueryDefinition().getQueryString();
queryStatistics.distributedIndexedQueryExecuted(queryString, System.nanoTime() - start);
}
} catch (InterruptedException e) {
throw new SearchException("Interrupted while searching locally", e);
} catch (ExecutionException e) {
Throwable rootCause = Util.getRootCause(e);
if (rootCause instanceof org.hibernate.search.util.common.SearchTimeoutException ||
rootCause instanceof TimeExceededException) {
throw new SearchTimeoutException("Query exceeded timeout");
}
throw new SearchException("Exception while searching locally", e);
}
return results;
}
private CompletionStage<QueryResponse> localInvoke(SegmentsClusteredQueryCommand cmd) {
return cmd.perform(cache);
}
}
| 4,462
| 44.540816
| 135
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/DistributedIterator.java
|
package org.infinispan.query.clustered;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NoSuchElementException;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.Sort;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.TopFieldDocs;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.encoding.DataConversion;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.remoting.transport.Address;
/**
* Iterates on the results of a distributed query returning the values. Subclasses can customize this by overriding the
* {@link #decorate} method.
*
* @param <T> The return type of the iterator
* @author Israel Lacerra <israeldl@gmail.com>
* @author <a href="mailto:mluksa@redhat.com">Marko Luksa</a>
* @author Sanne Grinovero
* @since 5.1
*/
class DistributedIterator<T> implements CloseableIterator<T> {
private final AdvancedCache<?, ?> cache;
private final DataConversion keyDataConversion;
private int currentIndex = -1;
// todo [anistor] seems we are ignoring fetchSize https://issues.jboss.org/browse/ISPN-9506
private final int fetchSize;
private final int resultSize;
private final int maxResults;
private final int firstResult;
private final NodeTopDocs[] partialResults;
private final int[] partialPositionNext;
private final TopDocs mergedResults;
private final LocalQueryStatistics queryStatistics;
DistributedIterator(LocalQueryStatistics queryStatistics, Sort sort, int fetchSize, int resultSize, int maxResults,
int firstResult, Map<Address, NodeTopDocs> topDocsResponses, AdvancedCache<?, ?> cache) {
this.queryStatistics = queryStatistics;
this.fetchSize = fetchSize;
this.resultSize = resultSize;
this.maxResults = maxResults;
this.firstResult = firstResult;
this.cache = cache;
this.keyDataConversion = cache.getKeyDataConversion();
final int parallels = topDocsResponses.size();
this.partialResults = new NodeTopDocs[parallels];
boolean isFieldDocs = expectTopFieldDocs(topDocsResponses);
TopDocs[] partialTopDocs = isFieldDocs ? new TopFieldDocs[parallels] : new TopDocs[parallels];
this.partialPositionNext = new int[parallels];
int i = 0;
for (Entry<Address, NodeTopDocs> entry : topDocsResponses.entrySet()) {
partialResults[i] = entry.getValue();
partialTopDocs[i] = partialResults[i].topDocs;
i++;
}
if (isFieldDocs) {
mergedResults = TopDocs.merge(sort, firstResult, maxResults, (TopFieldDocs[]) partialTopDocs, true);
} else {
mergedResults = TopDocs.merge(firstResult, maxResults, partialTopDocs, true);
}
}
private boolean expectTopFieldDocs(Map<Address, NodeTopDocs> topDocsResponses) {
Iterator<NodeTopDocs> it = topDocsResponses.values().iterator();
if (it.hasNext()) {
return it.next().topDocs instanceof TopFieldDocs;
}
return false;
}
@Override
public void close() {
// Nothing to do
}
@Override
public final T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
currentIndex++;
ScoreDoc scoreDoc = mergedResults.scoreDocs[currentIndex];
int index = scoreDoc.shardIndex;
NodeTopDocs nodeTopDocs = partialResults[index];
if (partialPositionNext[index] == 0) {
int docId = scoreDoc.doc;
ScoreDoc[] scoreDocs = nodeTopDocs.topDocs.scoreDocs;
for (int i = 0; i < scoreDocs.length; i++) {
if (scoreDocs[i].doc == docId) {
partialPositionNext[index] = i;
break;
}
}
}
int pos = partialPositionNext[index]++;
Object[] keys = nodeTopDocs.keys;
if (keys == null || keys.length == 0) {
return (T) nodeTopDocs.projections[pos];
}
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
Object key = keyDataConversion.fromStorage(keys[pos]);
T value = (T) cache.get(key);
if (queryStatistics.isEnabled()) queryStatistics.entityLoaded(System.nanoTime() - start);
return decorate(key, value);
}
/**
* Extension point for subclasses.
*/
protected T decorate(Object key, Object value) {
return (T) value;
}
@Override
public final boolean hasNext() {
int nextIndex = currentIndex + 1;
return firstResult + nextIndex < resultSize && nextIndex < maxResults;
}
}
| 4,656
| 32.992701
| 119
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/DistributedEntryIterator.java
|
package org.infinispan.query.clustered;
import java.util.Map;
import org.apache.lucene.search.Sort;
import org.infinispan.AdvancedCache;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.remoting.transport.Address;
/**
* Iterates on the results of a distributed query returning the whole cache entry, both key and value.
*
* @author anistor@redhat.com
* @since 13.0
*/
class DistributedEntryIterator<K, V> extends DistributedIterator<Map.Entry<K, V>> {
DistributedEntryIterator(LocalQueryStatistics queryStatistics, Sort sort, int fetchSize, int resultSize,
int maxResults, int firstResult, Map<Address, NodeTopDocs> topDocsResponses,
AdvancedCache<?, ?> cache) {
super(queryStatistics, sort, fetchSize, resultSize, maxResults, firstResult, topDocsResponses, cache);
}
@Override
protected Map.Entry<K, V> decorate(Object key, Object value) {
return new Map.Entry<K, V>() {
@Override
public K getKey() {
return (K) key;
}
@Override
public V getValue() {
return (V) value;
}
@Override
public V setValue(V value) {
throw new UnsupportedOperationException("Entry is immutable");
}
};
}
}
| 1,341
| 28.822222
| 108
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/DistributedIndexedQueryImpl.java
|
package org.infinispan.query.clustered;
import static java.util.Spliterators.spliteratorUnknownSize;
import static java.util.stream.StreamSupport.stream;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.hibernate.search.util.common.SearchException;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.query.SearchTimeoutException;
import org.infinispan.query.core.impl.QueryResultImpl;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.dsl.TotalHitCount;
import org.infinispan.query.impl.IndexedQuery;
import org.infinispan.query.impl.IndexedQueryImpl;
import org.infinispan.query.impl.QueryDefinition;
import org.infinispan.remoting.transport.Address;
/**
* An extension of IndexedQueryImpl used for distributed queries.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
public final class DistributedIndexedQueryImpl<E> extends IndexedQueryImpl<E> {
private Integer resultSize;
private boolean countIsExact = true;
private final ClusteredQueryInvoker invoker;
private int maxResults;
private int firstResult = 0;
public DistributedIndexedQueryImpl(QueryDefinition queryDefinition, AdvancedCache<?, ?> cache,
LocalQueryStatistics queryStatistics, int defaultMaxResults) {
super(queryDefinition, cache, queryStatistics);
this.invoker = new ClusteredQueryInvoker(cache, queryStatistics);
this.maxResults = defaultMaxResults;
}
@Override
public IndexedQuery<E> maxResults(int maxResults) {
this.maxResults = maxResults;
return super.maxResults(maxResults);
}
@Override
public IndexedQuery<E> firstResult(int firstResult) {
this.firstResult = firstResult;
return super.firstResult(firstResult);
}
@Override
public int getResultSize() {
partitionHandlingSupport.checkCacheAvailable();
if (resultSize == null || !countIsExact) {
List<QueryResponse> responses = invoker.broadcast(ClusteredQueryOperation.getResultSize(queryDefinition));
int accumulator = 0;
for (QueryResponse response : responses) {
accumulator += response.getResultSize();
}
resultSize = accumulator;
}
return resultSize;
}
@Override
public CloseableIterator<E> iterator() throws SearchException {
partitionHandlingSupport.checkCacheAvailable();
queryDefinition.setMaxResults(getNodeMaxResults());
ClusteredQueryOperation command = ClusteredQueryOperation.createEagerIterator(queryDefinition);
Map<Address, NodeTopDocs> topDocsResponses = broadcastQuery(command);
return new DistributedIterator<>(queryStatistics, queryDefinition.getSearchQueryBuilder().getLuceneSort(),
maxResults, resultSize, maxResults,
firstResult, topDocsResponses, cache);
}
@Override
public <K> CloseableIterator<Map.Entry<K, E>> entryIterator() {
partitionHandlingSupport.checkCacheAvailable();
queryDefinition.setMaxResults(getNodeMaxResults());
ClusteredQueryOperation command = ClusteredQueryOperation.createEagerIterator(queryDefinition);
Map<Address, NodeTopDocs> topDocsResponses = broadcastQuery(command);
// sanity check: if query has projections other than the entity itself throw an exception
if (!queryDefinition.getSearchQueryBuilder().isEntityProjection()) {
throw CONTAINER.entryIteratorDoesNotAllowProjections();
}
return new DistributedEntryIterator<>(queryStatistics, queryDefinition.getSearchQueryBuilder().getLuceneSort(),
maxResults, resultSize, maxResults, firstResult, topDocsResponses, cache);
}
// number of results of each node of cluster
private int getNodeMaxResults() {
return maxResults + firstResult;
}
private Map<Address, NodeTopDocs> broadcastQuery(ClusteredQueryOperation command) {
Map<Address, NodeTopDocs> topDocsResponses = new HashMap<>();
int resultSize = 0;
List<QueryResponse> responses = invoker.broadcast(command);
for (QueryResponse queryResponse : responses) {
if (queryResponse.getNodeTopDocs().topDocs != null) {
topDocsResponses.put(queryResponse.getNodeTopDocs().address, queryResponse.getNodeTopDocs());
}
if (!queryResponse.countIsExact()) {
countIsExact = false;
}
resultSize += queryResponse.getResultSize();
}
this.resultSize = resultSize;
return topDocsResponses;
}
@Override
public QueryResult<?> execute() {
if (queryDefinition.getStatementType() != IckleParsingResult.StatementType.SELECT) {
return new QueryResultImpl<E>(executeStatement(), Collections.emptyList());
}
try {
partitionHandlingSupport.checkCacheAvailable();
List<E> hits = stream(spliteratorUnknownSize(iterator(), 0), false)
.filter(Objects::nonNull).collect(Collectors.toList());
return new QueryResultImpl<>(new TotalHitCount(resultSize, countIsExact), hits);
} catch (org.hibernate.search.util.common.SearchTimeoutException timeoutException) {
throw new SearchTimeoutException();
}
}
@Override
public int executeStatement() {
// at the moment the only supported statement is DELETE
if (queryDefinition.getStatementType() != IckleParsingResult.StatementType.DELETE) {
throw CONTAINER.unsupportedStatement();
}
if (queryDefinition.getFirstResult() != 0 || queryDefinition.isCustomMaxResults()) {
throw CONTAINER.deleteStatementsCannotUsePaging();
}
try {
partitionHandlingSupport.checkCacheAvailable();
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
List<QueryResponse> responses = invoker.broadcast(ClusteredQueryOperation.delete(queryDefinition));
int count = 0;
for (QueryResponse response : responses) {
count += response.getResultSize();
}
if (queryStatistics.isEnabled()) recordQuery(System.nanoTime() - start);
return count;
} catch (org.hibernate.search.util.common.SearchTimeoutException timeoutException) {
throw new SearchTimeoutException();
}
}
private void recordQuery(long nanos) {
queryStatistics.distributedIndexedQueryExecuted(queryDefinition.getQueryString(), nanos);
}
@Override
public IndexedQuery<E> timeout(long timeout, TimeUnit timeUnit) {
queryDefinition.setTimeout(timeout, timeUnit);
return this;
}
}
| 6,998
| 36.031746
| 117
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/QueryResponse.java
|
package org.infinispan.query.clustered;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
/**
* The response for a {@link ClusteredQueryOperation}.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
public final class QueryResponse {
private final NodeTopDocs nodeTopDocs;
private final int resultSize;
private final boolean countIsExact;
public QueryResponse(int resultSize) {
this.resultSize = resultSize;
countIsExact = true; // count from CQGetResultSize is always exact
nodeTopDocs = null;
}
public QueryResponse(NodeTopDocs nodeTopDocs) {
this.resultSize = nodeTopDocs.totalHitCount;
this.countIsExact = nodeTopDocs.countIsExact;
this.nodeTopDocs = nodeTopDocs;
}
public NodeTopDocs getNodeTopDocs() {
return nodeTopDocs;
}
public int getResultSize() {
return resultSize;
}
public boolean countIsExact() {
return countIsExact;
}
public static final class Externalizer implements AdvancedExternalizer<QueryResponse> {
@Override
public Set<Class<? extends QueryResponse>> getTypeClasses() {
return Collections.singleton(QueryResponse.class);
}
@Override
public Integer getId() {
return ExternalizerIds.CLUSTERED_QUERY_COMMAND_RESPONSE;
}
@Override
public void writeObject(ObjectOutput output, QueryResponse queryResponse) throws IOException {
output.writeObject(queryResponse.nodeTopDocs);
if (queryResponse.nodeTopDocs == null) {
output.writeInt(queryResponse.resultSize);
}
}
@Override
public QueryResponse readObject(ObjectInput input) throws IOException, ClassNotFoundException {
NodeTopDocs nodeTopDocs = (NodeTopDocs) input.readObject();
if (nodeTopDocs != null) {
return new QueryResponse(nodeTopDocs);
}
return new QueryResponse(input.readInt());
}
}
}
| 2,191
| 27.102564
| 101
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/QueryPartitioner.java
|
package org.infinispan.query.clustered;
import java.util.BitSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.IntConsumer;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.IntSet;
import org.infinispan.configuration.cache.ClusteringConfiguration;
import org.infinispan.distribution.LocalizedCacheTopology;
import org.infinispan.remoting.rpc.RpcManager;
import org.infinispan.remoting.transport.Address;
/**
* Partition segments across cluster members to satisfy a query
*
* @since 10.1
*/
final class QueryPartitioner {
private final AdvancedCache<?, ?> cache;
private final int numSegments;
public QueryPartitioner(AdvancedCache<?, ?> cache) {
this.cache = cache;
ClusteringConfiguration clustering = cache.getCacheConfiguration().clustering();
this.numSegments = clustering.hash().numSegments();
}
public Map<Address, BitSet> split() {
RpcManager rpcManager = cache.getRpcManager();
List<Address> members = rpcManager.getMembers();
Address localAddress = rpcManager.getAddress();
LocalizedCacheTopology cacheTopology = cache.getDistributionManager().getCacheTopology();
BitSet bitSet = new BitSet();
Map<Address, BitSet> segmentsPerMember = new LinkedHashMap<>(members.size());
IntSet localSegments = cacheTopology.getLocalReadSegments();
localSegments.forEach((IntConsumer) bitSet::set);
segmentsPerMember.put(localAddress, bitSet);
for (int s = 0; s < numSegments; s++) {
if (!bitSet.get(s)) {
Address primary = cacheTopology.getSegmentDistribution(s).primary();
segmentsPerMember.computeIfAbsent(primary, address -> new BitSet()).set(s);
}
}
return segmentsPerMember;
}
}
| 1,818
| 34.666667
| 95
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/SegmentsClusteredQueryCommand.java
|
package org.infinispan.query.clustered;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.BitSet;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commands.remote.BaseRpcCommand;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.query.impl.ModuleCommandIds;
import org.infinispan.util.ByteString;
/**
* @since 10.1
*/
public class SegmentsClusteredQueryCommand extends BaseRpcCommand {
public static final byte COMMAND_ID = ModuleCommandIds.SEGMENT_CLUSTERED_QUERY;
private ClusteredQueryOperation clusteredQueryOperation;
private BitSet segments;
public SegmentsClusteredQueryCommand(ByteString cacheName) {
super(cacheName);
}
public SegmentsClusteredQueryCommand(String cacheName, ClusteredQueryOperation clusteredQueryOperation, BitSet segments) {
super(ByteString.fromString(cacheName));
this.clusteredQueryOperation = clusteredQueryOperation;
this.segments = segments;
}
public void setSegments(BitSet segments) {
this.segments = segments;
}
public BitSet getSegments() {
return segments;
}
public CompletionStage<QueryResponse> perform(Cache<?, ?> cache) {
return clusteredQueryOperation.perform(cache, segments);
}
@Override
public byte getCommandId() {
return COMMAND_ID;
}
@Override
public boolean isReturnValueExpected() {
return true;
}
@Override
public void writeTo(ObjectOutput output) throws IOException {
output.writeObject(clusteredQueryOperation);
byte[] bytes = segments.toByteArray();
int length = bytes.length;
output.write(length);
if (length > 0) {
output.write(bytes);
}
}
@Override
public CompletableFuture<?> invokeAsync(ComponentRegistry componentRegistry) {
AdvancedCache<?, ?> cache = componentRegistry.getCache().wired();
return perform(cache).toCompletableFuture();
}
@Override
public void readFrom(ObjectInput input) throws IOException, ClassNotFoundException {
this.clusteredQueryOperation = (ClusteredQueryOperation) input.readObject();
int len = input.readUnsignedByte();
BitSet bitSet = null;
if (len > 0) {
byte[] b = new byte[len];
input.readFully(b);
bitSet = BitSet.valueOf(b);
}
this.segments = bitSet;
}
@Override
public boolean canBlock() {
return true;
}
}
| 2,600
| 26.09375
| 125
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/NodeTopDocs.java
|
package org.infinispan.query.clustered;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.apache.lucene.search.TopDocs;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
import org.infinispan.remoting.transport.Address;
/**
* A TopDocs with an array with keys of each result.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
public final class NodeTopDocs {
public final Address address;
public final TopDocs topDocs;
public int totalHitCount;
public boolean countIsExact;
public final Object[] keys;
public final Object[] projections;
public NodeTopDocs(Address address, TopDocs topDocs, int totalHitCount, boolean countIsExact, Object[] keys,
Object[] projections) {
this.address = address;
this.topDocs = topDocs;
this.totalHitCount = totalHitCount;
this.countIsExact = countIsExact;
this.keys = keys;
this.projections = projections;
}
public static final class Externalizer extends AbstractExternalizer<NodeTopDocs> {
@Override
public Set<Class<? extends NodeTopDocs>> getTypeClasses() {
return Collections.singleton(NodeTopDocs.class);
}
@Override
public Integer getId() {
return ExternalizerIds.CLUSTERED_QUERY_TOPDOCS;
}
@Override
public NodeTopDocs readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Address address = (Address) input.readObject();
int keysNumber = UnsignedNumeric.readUnsignedInt(input);
Object[] keys = new Object[keysNumber];
for (int i = 0; i < keysNumber; i++) {
keys[i] = input.readObject();
}
int projectionsNumber = UnsignedNumeric.readUnsignedInt(input);
Object[] projections = new Object[projectionsNumber];
for (int i = 0; i < projectionsNumber; i++) {
projections[i] = input.readObject();
}
TopDocs innerTopDocs = (TopDocs) input.readObject();
int totalHitCount = input.readInt();
boolean countIsExact = input.readBoolean();
return new NodeTopDocs(address, innerTopDocs, totalHitCount, countIsExact, keys, projections);
}
@Override
public void writeObject(ObjectOutput output, NodeTopDocs topDocs) throws IOException {
output.writeObject(topDocs.address);
Object[] keys = topDocs.keys;
int size = keys == null ? 0 : keys.length;
UnsignedNumeric.writeUnsignedInt(output, size);
for (int i = 0; i < size; i++) {
output.writeObject(keys[i]);
}
Object[] projections = topDocs.projections;
int projectionSize = projections == null ? 0 : projections.length;
UnsignedNumeric.writeUnsignedInt(output, projectionSize);
for (int i = 0; i < projectionSize; i++) {
output.writeObject(projections[i]);
}
output.writeObject(topDocs.topDocs);
output.writeInt(topDocs.totalHitCount);
output.writeBoolean(topDocs.countIsExact);
}
}
}
| 3,305
| 34.934783
| 111
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/ClusteredQueryOperation.java
|
package org.infinispan.query.clustered;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.BitSet;
import java.util.Collections;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletionStage;
import org.infinispan.Cache;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.query.clustered.commandworkers.CQCommandType;
import org.infinispan.query.impl.QueryDefinition;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
/**
* @since 10.1
*/
public final class ClusteredQueryOperation {
private final CQCommandType commandType;
private final QueryDefinition queryDefinition;
// identifies the query
private UUID queryId;
// for retrieve keys on a lazy query
private int docIndex = 0;
private ClusteredQueryOperation(CQCommandType commandType, QueryDefinition queryDefinition) {
this.commandType = commandType;
this.queryDefinition = queryDefinition;
}
public QueryDefinition getQueryDefinition() {
return queryDefinition;
}
static ClusteredQueryOperation getResultSize(QueryDefinition queryDefinition) {
return new ClusteredQueryOperation(CQCommandType.GET_RESULT_SIZE, queryDefinition);
}
static ClusteredQueryOperation delete(QueryDefinition queryDefinition) {
return new ClusteredQueryOperation(CQCommandType.DELETE, queryDefinition);
}
static ClusteredQueryOperation createEagerIterator(QueryDefinition queryDefinition) {
return new ClusteredQueryOperation(CQCommandType.CREATE_EAGER_ITERATOR, queryDefinition);
}
public CompletionStage<QueryResponse> perform(Cache<?, ?> cache, BitSet segments) {
return commandType.perform(cache.getAdvancedCache(), queryDefinition, queryId, docIndex, segments);
}
public static final class Externalizer implements AdvancedExternalizer<ClusteredQueryOperation> {
@Override
public Set<Class<? extends ClusteredQueryOperation>> getTypeClasses() {
return Collections.singleton(ClusteredQueryOperation.class);
}
@Override
public Integer getId() {
return ExternalizerIds.CLUSTERED_QUERY_OPERATION;
}
@Override
public void writeObject(ObjectOutput output, ClusteredQueryOperation object) throws IOException {
MarshallUtil.marshallEnum(object.commandType, output);
output.writeObject(object.queryDefinition);
MarshallUtil.marshallUUID(object.queryId, output, true);
output.writeInt(object.docIndex);
}
@Override
public ClusteredQueryOperation readObject(ObjectInput input) throws IOException, ClassNotFoundException {
CQCommandType commandType = MarshallUtil.unmarshallEnum(input, CQCommandType::valueOf);
QueryDefinition queryDefinition = (QueryDefinition) input.readObject();
UUID queryId = MarshallUtil.unmarshallUUID(input, true);
int docIndex = input.readInt();
ClusteredQueryOperation clusteredQueryOperation = new ClusteredQueryOperation(commandType, queryDefinition);
clusteredQueryOperation.queryId = queryId;
clusteredQueryOperation.docIndex = docIndex;
return clusteredQueryOperation;
}
}
}
| 3,328
| 35.184783
| 117
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/package-info.java
|
/**
* @api.private
*/
package org.infinispan.query.clustered.commandworkers;
| 79
| 15
| 54
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/CQGetResultSize.java
|
package org.infinispan.query.clustered.commandworkers;
import java.util.BitSet;
import java.util.concurrent.CompletionStage;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
/**
* Get the result size of this query on current node
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
final class CQGetResultSize extends CQWorker {
@Override
CompletionStage<QueryResponse> perform(BitSet segments) {
SearchQueryBuilder query = queryDefinition.getSearchQueryBuilder();
setFilter(segments);
return blockingManager.supplyBlocking(() -> query.build().fetchTotalHitCount(), this)
.thenApply(hitCount -> new QueryResponse(Math.toIntExact(hitCount)));
}
}
| 782
| 30.32
| 91
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/CQCommandType.java
|
package org.infinispan.query.clustered.commandworkers;
import java.util.BitSet;
import java.util.UUID;
import java.util.concurrent.CompletionStage;
import java.util.function.Supplier;
import org.infinispan.AdvancedCache;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.impl.QueryDefinition;
/**
* Types of CQWorker. Each type defines a different behavior for a ClusteredQueryCommand. The {@link #perform} method is
* delegated to a CQWorker. This enum is more efficient to serialize than an actual CQWorker.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @author anistor@redhat.com
* @since 5.1
*/
public enum CQCommandType {
//TODO [ISPN-12182] Add support for scrolling
CREATE_EAGER_ITERATOR(CQCreateEagerQuery::new),
GET_RESULT_SIZE(CQGetResultSize::new),
DELETE(CQDelete::new);
private static final CQCommandType[] CACHED_VALUES = values();
public static CQCommandType valueOf(int ordinal) {
return CACHED_VALUES[ordinal];
}
private final Supplier<CQWorker> workerSupplier;
CQCommandType(Supplier<CQWorker> workerSupplier) {
this.workerSupplier = workerSupplier;
}
public CompletionStage<QueryResponse> perform(AdvancedCache<?, ?> cache, QueryDefinition queryDefinition,
UUID queryId, int docIndex, BitSet segments) {
CQWorker worker = workerSupplier.get();
worker.initialize(cache.withStorageMediaType(), queryDefinition, queryId, docIndex);
return worker.perform(segments);
}
}
| 1,557
| 32.869565
| 120
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/CQCreateEagerQuery.java
|
package org.infinispan.query.clustered.commandworkers;
import java.util.BitSet;
import java.util.List;
import java.util.concurrent.CompletionStage;
import org.hibernate.search.backend.lucene.search.query.LuceneSearchResult;
import org.hibernate.search.engine.search.query.SearchResultTotal;
import org.infinispan.query.clustered.NodeTopDocs;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
/**
* Returns the results of a node to create an eager distributed iterator.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
final class CQCreateEagerQuery extends CQWorker {
@Override
CompletionStage<QueryResponse> perform(BitSet segments) {
SearchQueryBuilder query = queryDefinition.getSearchQueryBuilder();
setFilter(segments);
CompletionStage<NodeTopDocs> nodeTopDocs = query.isEntityProjection() ? collectKeys(query) : collectProjections(query);
return nodeTopDocs.thenApply(QueryResponse::new);
}
private LuceneSearchResult<?> fetchHits(SearchQueryBuilder query) {
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
LuceneSearchResult<?> result = query.build().fetch(queryDefinition.getMaxResults());
if (queryStatistics.isEnabled())
queryStatistics.localIndexedQueryExecuted(queryDefinition.getQueryString(), System.nanoTime() - start);
return result;
}
public LuceneSearchResult<Object> fetchIds(SearchQueryBuilder query) {
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
LuceneSearchResult<Object> result = query.ids().fetch(queryDefinition.getMaxResults());
if (queryStatistics.isEnabled()) {
queryStatistics.localIndexedQueryExecuted(queryDefinition.getQueryString(), System.nanoTime() - start);
}
return result;
}
private CompletionStage<NodeTopDocs> collectKeys(SearchQueryBuilder query) {
return blockingManager.supplyBlocking(() -> fetchIds(query), "CQCreateEagerQuery#collectKeys")
.thenApply(queryResult -> {
SearchResultTotal total = queryResult.total();
int hitCount = Math.toIntExact(total.hitCountLowerBound());
boolean countIsExact = total.isHitCountExact();
Object[] keys = queryResult.hits().stream()
.toArray(Object[]::new);
return new NodeTopDocs(cache.getRpcManager().getAddress(), queryResult.topDocs(), hitCount, countIsExact,
keys, null);
});
}
private CompletionStage<NodeTopDocs> collectProjections(SearchQueryBuilder query) {
return blockingManager.supplyBlocking(() -> fetchHits(query), "CQCreateEagerQuery#collectProjections")
.thenApply(queryResult -> {
SearchResultTotal total = queryResult.total();
int hitCount = Math.toIntExact(total.hitCountLowerBound());
boolean countIsExact = total.isHitCountExact();
List<?> hits = queryResult.hits();
Object[] projections = hits.toArray(new Object[0]);
return new NodeTopDocs(cache.getRpcManager().getAddress(), queryResult.topDocs(), hitCount, countIsExact,
null, projections);
});
}
}
| 3,322
| 40.024691
| 125
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/CQWorker.java
|
package org.infinispan.query.clustered.commandworkers;
import java.util.BitSet;
import java.util.UUID;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.query.backend.QueryInterceptor;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.impl.QueryDefinition;
import org.infinispan.util.concurrent.BlockingManager;
/**
* Add specific behavior for ClusteredQueryCommand. Each ClusteredQueryCommandType links to a CQWorker
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
abstract class CQWorker {
protected AdvancedCache<?, ?> cache;
// the query
protected QueryDefinition queryDefinition;
protected UUID queryId;
protected int docIndex;
protected BlockingManager blockingManager;
protected LocalQueryStatistics queryStatistics;
void initialize(AdvancedCache<?, ?> cache, QueryDefinition queryDefinition, UUID queryId, int docIndex) {
this.cache = cache;
QueryInterceptor queryInterceptor = ComponentRegistryUtils.getQueryInterceptor(cache);
this.queryStatistics = ComponentRegistryUtils.getLocalQueryStatistics(cache);
if (queryDefinition != null) {
this.queryDefinition = queryDefinition;
this.queryDefinition.initialize(cache);
}
this.blockingManager = queryInterceptor.getBlockingManager();
this.queryId = queryId;
this.docIndex = docIndex;
}
abstract CompletionStage<QueryResponse> perform(BitSet segments);
void setFilter(BitSet segments) {
SearchQueryBuilder searchQuery = queryDefinition.getSearchQueryBuilder();
if (segments.cardinality() != cache.getCacheConfiguration().clustering().hash().numSegments()) {
searchQuery.routeOnSegments(segments);
} else {
searchQuery.noRouting();
}
}
}
| 2,045
| 34.894737
| 108
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/clustered/commandworkers/CQDelete.java
|
package org.infinispan.query.clustered.commandworkers;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.util.BitSet;
import java.util.concurrent.CompletionStage;
import org.hibernate.search.backend.lucene.search.query.LuceneSearchResult;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
/**
* Deletes the matching results on current node.
*
* @author anistor@redhat.com
* @since 13.0
*/
final class CQDelete extends CQWorker {
@Override
CompletionStage<QueryResponse> perform(BitSet segments) {
setFilter(segments);
// Must never apply any kind of limits to a DELETE! Limits are just for paging a SELECT.
if (queryDefinition.getFirstResult() != 0 || queryDefinition.isCustomMaxResults()) {
throw CONTAINER.deleteStatementsCannotUsePaging();
}
SearchQueryBuilder query = queryDefinition.getSearchQueryBuilder();
return blockingManager.supplyBlocking(() -> fetchIds(query), this)
.thenApply(queryResult -> queryResult.hits().stream().map(id -> cache.remove(id) != null ? 1 : 0).reduce(0, Integer::sum))
.thenApply(QueryResponse::new);
}
public LuceneSearchResult<Object> fetchIds(SearchQueryBuilder query) {
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
LuceneSearchResult<Object> result = query.ids().fetch(queryDefinition.getMaxResults());
if (queryStatistics.isEnabled()) {
queryStatistics.localIndexedQueryExecuted(queryDefinition.getQueryString(), System.nanoTime() - start);
}
return result;
}
}
| 1,649
| 34.869565
| 134
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/QueryModuleCommandExtensions.java
|
package org.infinispan.query.impl;
import org.infinispan.commands.module.ModuleCommandExtensions;
import org.infinispan.commands.module.ModuleCommandFactory;
import org.kohsuke.MetaInfServices;
@MetaInfServices
public final class QueryModuleCommandExtensions implements ModuleCommandExtensions {
@Override
public ModuleCommandFactory getModuleCommandFactory() {
return new CommandFactory();
}
}
| 413
| 26.6
| 84
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/package-info.java
|
/**
* Query module internals.
*/
package org.infinispan.query.impl;
| 70
| 13.2
| 34
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/PersistenceContextInitializer.java
|
package org.infinispan.query.impl;
import org.infinispan.commons.marshall.ProtoStreamTypeIds;
import org.infinispan.marshall.persistence.impl.PersistenceMarshallerImpl;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
/**
* Interface used to initialise the {@link PersistenceMarshallerImpl}'s {@link org.infinispan.protostream.SerializationContext}
* using the specified Pojos, Marshaller implementations and provided .proto schemas.
*
* @author Ryan Emerson
* @since 10.0
*/
@AutoProtoSchemaBuilder(
includeClasses = PersistenceContextInitializer.KnownClassKey.class,
schemaFileName = "persistence.query.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.query",
service = false
)
interface PersistenceContextInitializer extends SerializationContextInitializer {
//TODO [anistor] remove this !
@ProtoTypeId(ProtoStreamTypeIds.QUERY_LOWER_BOUND)
public static final class KnownClassKey {
@ProtoField(number = 1)
public final String cacheName;
@ProtoField(number = 2)
public final String className;
@ProtoFactory
public KnownClassKey(String cacheName, String className) {
this.cacheName = cacheName;
this.className = className;
}
}
}
| 1,553
| 34.318182
| 127
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/IndexedQuery.java
|
package org.infinispan.query.impl;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.query.dsl.QueryResult;
/**
* A query that uses indexing.
*
* @since 11.0
*/
public interface IndexedQuery<E> {
/**
* @return the results of a search as a list.
*/
default List<E> list() {
return (List<E>) execute().list();
}
/**
* Sets the index of the first result, skipping the previous ones. Used for pagination.
*
* @param index of the first result
* @throws IllegalArgumentException if the index given is less than zero.
*/
IndexedQuery<E> firstResult(int index);
/**
* Sets the maximum number of results to return from the query. Used for pagination.
*
* @param maxResults the maximum number of results to return.
*/
IndexedQuery<E> maxResults(int maxResults);
/**
* Limit the required accuracy of the hit count for the indexed queries to an upper-bound.
* Setting the hit-count-accuracy could improve the performance of queries targeting large data sets.
*
* @param hitCountAccuracy The value to apply
* @return <code>this</code>, for method chaining
*/
IndexedQuery<E> hitCountAccuracy(int hitCountAccuracy);
CloseableIterator<E> iterator();
/**
* Returns the matching entries (both key and value).
* <p>
* <b>NOTE:</b> The query must not contain any projections or an exception will be thrown.
*/
<K> CloseableIterator<Map.Entry<K, E>> entryIterator();
/**
* Executes an Ickle statement returning results (query aka. SELECT). If the statement happens to be a DELETE it
* redirects it to {@link #executeStatement()}.
* <p>
* <b>NOTE:</b> Paging params (firstResult/maxResults) are honoured for SELECT and dissalowed for DELETE.
*/
QueryResult<?> execute();
/**
* Executes an Ickle statement not returning any results (ie. DELETE).
* <p>
* <b>NOTE:</b> Paging params (firstResult/maxResults) are NOT allowed.
*
* @return the number of affected entries
*/
int executeStatement();
int getResultSize();
/**
* Set the timeout for this query. If the query hasn't finished processing before the timeout,
* an exception will be thrown.
*
* @param timeout the timeout duration
* @param timeUnit the time unit of the timeout parameter
*/
IndexedQuery<E> timeout(long timeout, TimeUnit timeUnit);
}
| 2,522
| 28.682353
| 115
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/ModuleCommandIds.java
|
package org.infinispan.query.impl;
/**
* The Query module is using custom RPC commands; to make sure the used command ids
* are unique all numbers are defined here, and should stay in the range 100-119
* which is the reserved range for this module.
*
* @author Sanne Grinovero <sanne@infinispan.org> (C) 2011 Red Hat Inc.
*/
public interface ModuleCommandIds {
byte UPDATE_INDEX = 102;
byte UPDATE_INDEX_STREAM = 103;
byte SEGMENT_CLUSTERED_QUERY = 105;
}
| 481
| 25.777778
| 83
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/EntityLoader.java
|
package org.infinispan.query.impl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.hibernate.search.engine.common.timing.Deadline;
import org.hibernate.search.mapper.pojo.loading.spi.PojoSelectionEntityLoader;
import org.infinispan.AdvancedCache;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
/**
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
* @author Marko Luksa
* @since 5.0
*/
public final class EntityLoader<E> implements PojoSelectionEntityLoader<E> {
private final AdvancedCache<?, E> cache;
private final LocalQueryStatistics queryStatistics;
public EntityLoader(AdvancedCache<?, E> cache, LocalQueryStatistics queryStatistics) {
this.cache = cache;
this.queryStatistics = queryStatistics;
}
@Override
public List<E> loadBlocking(List<?> identifiers, Deadline deadline) {
if (identifiers.isEmpty()) return Collections.emptyList();
int entitiesSize = identifiers.size();
LinkedHashSet<Object> keys = new LinkedHashSet<>(entitiesSize);
for (Object identifier : identifiers) {
keys.add(cache.getKeyDataConversion().fromStorage(identifier));
}
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
// getAll instead of multiple gets to get all the results in the same call
Map<?, E> values = cache.getAll(keys);
if (queryStatistics.isEnabled()) queryStatistics.entityLoaded(System.nanoTime() - start);
ArrayList<E> result = new ArrayList<>(entitiesSize);
for (Object key : keys) {
// if the entity was present at indexing time and
// it is not present anymore now at searching time,
// we will add a null here
result.add(values.get(key));
}
return result;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
EntityLoader<?> that = (EntityLoader<?>) o;
return Objects.equals(cache, that.cache) && Objects.equals(queryStatistics, that.queryStatistics);
}
@Override
public int hashCode() {
return Objects.hash(cache, queryStatistics);
}
}
| 2,329
| 31.816901
| 104
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/QueryDefinition.java
|
package org.infinispan.query.impl;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.hibernate.search.engine.search.query.SearchQuery;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.query.dsl.embedded.impl.QueryEngine;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
import org.infinispan.util.function.SerializableFunction;
/**
* Wraps the query to be executed in a cache represented either as an Ickle query String or as a {@link SearchQuery}
* together with parameters and pagination and sort information.
*
* @since 9.2
*/
public final class QueryDefinition {
private final SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>> queryEngineProvider;
private final String queryString;
private final IckleParsingResult.StatementType statementType;
private SearchQueryBuilder searchQueryBuilder;
private int maxResults;
private int firstResult = 0;
private int hitCountAccuracy = -1;
private long timeout = -1;
private final Map<String, Object> namedParameters = new HashMap<>();
private final int originalMaxResults;
public QueryDefinition(String queryString, IckleParsingResult.StatementType statementType,
SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>> queryEngineProvider,
int originalMaxResults) {
if (queryString == null) {
throw new IllegalArgumentException("queryString cannot be null");
}
if (statementType == null) {
throw new IllegalArgumentException("statementType cannot be null");
}
if (queryEngineProvider == null) {
throw new IllegalArgumentException("queryEngineProvider cannot be null");
}
this.queryString = queryString;
this.statementType = statementType;
this.queryEngineProvider = queryEngineProvider;
this.maxResults = originalMaxResults;
this.originalMaxResults = originalMaxResults;
}
public QueryDefinition(String queryString, IckleParsingResult.StatementType statementType,
SearchQueryBuilder searchQueryBuilder, int originalMaxResults) {
if (queryString == null) {
throw new IllegalArgumentException("queryString cannot be null");
}
if (statementType == null) {
throw new IllegalArgumentException("statementType cannot be null");
}
if (searchQueryBuilder == null) {
throw new IllegalArgumentException("searchQueryBuilder cannot be null");
}
this.searchQueryBuilder = searchQueryBuilder;
this.queryString = queryString;
this.statementType = statementType;
this.queryEngineProvider = null;
this.maxResults = originalMaxResults;
this.originalMaxResults = originalMaxResults;
}
public String getQueryString() {
return queryString;
}
public IckleParsingResult.StatementType getStatementType() {
return statementType;
}
private QueryEngine<?> getQueryEngine(AdvancedCache<?, ?> cache) {
if (queryEngineProvider == null) {
throw new IllegalStateException("No query engine provider specified");
}
QueryEngine<?> queryEngine = queryEngineProvider.apply(cache);
if (queryEngine == null) {
throw new IllegalStateException("The query engine provider could not locate a suitable query engine");
}
return queryEngine;
}
public void initialize(AdvancedCache<?, ?> cache) {
if (searchQueryBuilder == null) {
QueryEngine<?> queryEngine = getQueryEngine(cache);
searchQueryBuilder = queryEngine.buildSearchQuery(queryString, namedParameters);
if (hitCountAccuracy != -1) {
searchQueryBuilder.hitCountAccuracy(hitCountAccuracy);
}
if (timeout > 0) {
searchQueryBuilder.failAfter(timeout, TimeUnit.NANOSECONDS);
}
}
}
public SearchQueryBuilder getSearchQueryBuilder() {
if (searchQueryBuilder == null) {
throw new IllegalStateException("The QueryDefinition has not been initialized, make sure to call initialize(...) first");
}
return searchQueryBuilder;
}
public boolean isCustomMaxResults() {
return maxResults != originalMaxResults;
}
public int getMaxResults() {
return maxResults == -1 ? Integer.MAX_VALUE - getFirstResult() : maxResults;
}
public void setMaxResults(int maxResults) {
this.maxResults = maxResults;
}
public void setHitCountAccuracy(int hitCountAccuracy) {
this.hitCountAccuracy = hitCountAccuracy;
if (this.hitCountAccuracy != -1 && searchQueryBuilder != null) {
searchQueryBuilder.hitCountAccuracy(hitCountAccuracy);
}
}
public void setNamedParameters(Map<String, Object> params) {
if (params == null) {
namedParameters.clear();
} else {
namedParameters.putAll(params);
}
}
public void setTimeout(long timeout, TimeUnit timeUnit) {
this.timeout = timeUnit.toNanos(timeout);
if (this.timeout > 0 && searchQueryBuilder != null) {
searchQueryBuilder.failAfter(this.timeout, TimeUnit.NANOSECONDS);
}
}
public Map<String, Object> getNamedParameters() {
return namedParameters;
}
public int getFirstResult() {
return firstResult;
}
public void setFirstResult(int firstResult) {
this.firstResult = firstResult;
}
public void failAfter(long timeout, TimeUnit timeUnit) {
getSearchQueryBuilder().failAfter(timeout, timeUnit);
}
public static final class Externalizer implements AdvancedExternalizer<QueryDefinition> {
@Override
public Set<Class<? extends QueryDefinition>> getTypeClasses() {
return Collections.singleton(QueryDefinition.class);
}
@Override
public Integer getId() {
return ExternalizerIds.QUERY_DEFINITION;
}
@Override
public void writeObject(ObjectOutput output, QueryDefinition queryDefinition) throws IOException {
output.writeUTF(queryDefinition.queryString);
output.writeByte(queryDefinition.statementType.ordinal());
output.writeObject(queryDefinition.queryEngineProvider);
output.writeInt(queryDefinition.firstResult);
output.writeInt(queryDefinition.maxResults);
output.writeInt(queryDefinition.hitCountAccuracy);
output.writeLong(queryDefinition.timeout);
Map<String, Object> namedParameters = queryDefinition.namedParameters;
int paramSize = namedParameters.size();
output.writeShort(paramSize);
if (paramSize != 0) {
for (Map.Entry<String, Object> param : namedParameters.entrySet()) {
output.writeUTF(param.getKey());
output.writeObject(param.getValue());
}
}
}
@Override
public QueryDefinition readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String queryString = input.readUTF();
IckleParsingResult.StatementType statementType = IckleParsingResult.StatementType.valueOf(input.readByte());
SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>> engineProvider =
(SerializableFunction<AdvancedCache<?, ?>, QueryEngine<?>>) input.readObject();
int firstResult = input.readInt();
int maxResults = input.readInt();
int hitCountAccuracy = input.readInt();
// maxResults becomes the originalMaxResults of the distributed cloned queries
QueryDefinition queryDefinition = new QueryDefinition(queryString, statementType, engineProvider, maxResults);
queryDefinition.setHitCountAccuracy(hitCountAccuracy);
queryDefinition.setFirstResult(firstResult);
queryDefinition.timeout = input.readLong();
short paramSize = input.readShort();
if (paramSize != 0) {
Map<String, Object> params = new HashMap<>(paramSize);
for (int i = 0; i < paramSize; i++) {
String key = input.readUTF();
Object value = input.readObject();
params.put(key, value);
}
queryDefinition.setNamedParameters(params);
}
return queryDefinition;
}
}
}
| 8,665
| 36.515152
| 130
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/ScrollerIteratorAdaptor.java
|
package org.infinispan.query.impl;
import java.util.List;
import java.util.NoSuchElementException;
import org.hibernate.search.engine.search.query.SearchScroll;
import org.hibernate.search.engine.search.query.SearchScrollResult;
import org.infinispan.commons.util.CloseableIterator;
/**
* Adaptor to use a link {@link SearchScroll} as an iterator.
*
* @since 12.0
*/
public class ScrollerIteratorAdaptor<E> implements CloseableIterator<E> {
private final SearchScroll<E> scroll;
private SearchScrollResult<E> scrollResult;
private List<E> chunk;
private int cursor = 0;
public ScrollerIteratorAdaptor(SearchScroll<E> scroll) {
this.scroll = scroll;
this.scrollResult = scroll.next();
this.chunk = scrollResult.hits();
}
@Override
public boolean hasNext() {
tryFetchMore();
return scrollResult.hasHits();
}
@Override
public E next() {
if (hasNext()) {
return chunk.get(cursor++);
}
throw new NoSuchElementException();
}
private void tryFetchMore() {
if (cursor == chunk.size()) {
scrollResult = scroll.next();
chunk = scrollResult.hits();
cursor = 0;
}
}
@Override
public void close() {
scroll.close();
}
}
| 1,271
| 22.555556
| 73
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/IndexedQueryImpl.java
|
package org.infinispan.query.impl;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import static org.infinispan.query.logging.Log.CONTAINER;
import org.hibernate.search.backend.lucene.search.query.LuceneSearchQuery;
import org.hibernate.search.engine.search.query.SearchQuery;
import org.hibernate.search.engine.search.query.SearchResult;
import org.hibernate.search.util.common.SearchException;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.objectfilter.impl.syntax.parser.IckleParsingResult;
import org.infinispan.query.SearchTimeoutException;
import org.infinispan.query.core.impl.MappingIterator;
import org.infinispan.query.core.impl.PartitionHandlingSupport;
import org.infinispan.query.core.impl.QueryResultImpl;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.query.dsl.QueryResult;
import org.infinispan.query.dsl.TotalHitCount;
import org.infinispan.query.dsl.embedded.impl.SearchQueryBuilder;
import org.hibernate.search.engine.common.EntityReference;
/**
* Lucene based indexed query implementation.
*
* @author Navin Surtani
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
* @author Marko Luksa
*/
public class IndexedQueryImpl<E> implements IndexedQuery<E> {
private static final int SCROLL_CHUNK = 100;
protected final AdvancedCache<?, ?> cache;
protected final PartitionHandlingSupport partitionHandlingSupport;
protected final QueryDefinition queryDefinition;
protected final LocalQueryStatistics queryStatistics;
public IndexedQueryImpl(QueryDefinition queryDefinition, AdvancedCache<?, ?> cache, LocalQueryStatistics queryStatistics) {
this.queryDefinition = queryDefinition;
this.cache = cache;
this.partitionHandlingSupport = new PartitionHandlingSupport(cache);
this.queryStatistics = queryStatistics;
}
/**
* Create a IndexedQueryImpl based on a SearchQuery.
*/
public IndexedQueryImpl(String queryString, IckleParsingResult.StatementType statementType,
SearchQueryBuilder searchQuery, AdvancedCache<?, ?> cache,
LocalQueryStatistics queryStatistics, int defaultMaxResults) {
this(new QueryDefinition(queryString, statementType, searchQuery, defaultMaxResults), cache, queryStatistics);
}
/**
* @return The result size of the query.
*/
@Override
public int getResultSize() {
partitionHandlingSupport.checkCacheAvailable();
LuceneSearchQuery<?> searchQuery = queryDefinition.getSearchQueryBuilder().build();
return Math.toIntExact(searchQuery.fetchTotalHitCount());
}
/**
* Sets the result of the given integer value to the first result.
*
* @param firstResult index to be set.
* @throws IllegalArgumentException if the index given is less than zero.
*/
@Override
public IndexedQuery<E> firstResult(int firstResult) {
queryDefinition.setFirstResult(firstResult);
return this;
}
@Override
public IndexedQuery<E> maxResults(int maxResults) {
queryDefinition.setMaxResults(maxResults);
return this;
}
@Override
public IndexedQuery<E> hitCountAccuracy(int hitCountAccuracy) {
queryDefinition.setHitCountAccuracy(hitCountAccuracy);
return this;
}
private void recordQuery(long nanos) {
queryStatistics.localIndexedQueryExecuted(queryDefinition.getQueryString(), nanos);
}
@Override
public CloseableIterator<E> iterator() throws SearchException {
partitionHandlingSupport.checkCacheAvailable();
long start = queryStatistics.isEnabled() ? System.nanoTime(): 0;
SearchQuery<?> searchQuery = queryDefinition.getSearchQueryBuilder().build();
MappingIterator<?, Object> iterator = new MappingIterator<>(iterator(searchQuery))
.skip(queryDefinition.getFirstResult())
.limit(queryDefinition.getMaxResults());
if (queryStatistics.isEnabled()) recordQuery(System.nanoTime() - start);
return (CloseableIterator<E>) iterator;
}
@Override
public <K> CloseableIterator<Map.Entry<K, E>> entryIterator() {
partitionHandlingSupport.checkCacheAvailable();
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
SearchQueryBuilder searchQueryBuilder = queryDefinition.getSearchQueryBuilder();
// sanity check: if query has projections other than the entity itself throw an exception
if (!searchQueryBuilder.isEntityProjection()) {
throw CONTAINER.entryIteratorDoesNotAllowProjections();
}
SearchQuery<List<Object>> searchQuery = searchQueryBuilder.keyAndEntity();
MappingIterator<List<Object>, Map.Entry<K, E>> iterator = new MappingIterator<>(iterator(searchQuery), this::mapToEntry);
iterator.skip(queryDefinition.getFirstResult())
.limit(queryDefinition.getMaxResults());
if (queryStatistics.isEnabled()) recordQuery(System.nanoTime() - start);
return iterator;
}
private <K, V> Map.Entry<K, V> mapToEntry(List<Object> projection) {
return new Map.Entry<K, V>() {
@Override
public K getKey() {
// todo [anistor] should also apply keyDataConversion.fromStorage() maybe ?
return (K) ((EntityReference) projection.get(0)).id();
}
@Override
public V getValue() {
return (V) projection.get(1);
}
@Override
public V setValue(V value) {
throw new UnsupportedOperationException("Entry is immutable");
}
};
}
@Override
public QueryResult<?> execute() {
if (queryDefinition.getStatementType() != IckleParsingResult.StatementType.SELECT) {
return new QueryResultImpl<E>(executeStatement(), Collections.emptyList());
}
try {
partitionHandlingSupport.checkCacheAvailable();
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
SearchQueryBuilder searchQueryBuilder = queryDefinition.getSearchQueryBuilder();
SearchQuery<E> searchQuery = (SearchQuery<E>) searchQueryBuilder.build();
SearchResult<E> searchResult = searchQuery.fetch(queryDefinition.getFirstResult(), queryDefinition.getMaxResults());
if (queryStatistics.isEnabled()) recordQuery(System.nanoTime() - start);
return new QueryResultImpl<>(
// the hit count cannot exceed the cache size
new TotalHitCount((int) searchResult.total().hitCountLowerBound(), searchResult.total().isHitCountExact()),
searchResult.hits());
} catch (org.hibernate.search.util.common.SearchTimeoutException timeoutException) {
throw new SearchTimeoutException();
}
}
@Override
public int executeStatement() {
// at the moment the only supported statement is DELETE
if (queryDefinition.getStatementType() != IckleParsingResult.StatementType.DELETE) {
throw CONTAINER.unsupportedStatement();
}
if (queryDefinition.getFirstResult() != 0 || queryDefinition.isCustomMaxResults()) {
throw CONTAINER.deleteStatementsCannotUsePaging();
}
try {
partitionHandlingSupport.checkCacheAvailable();
long start = queryStatistics.isEnabled() ? System.nanoTime() : 0;
SearchQueryBuilder searchQueryBuilder = queryDefinition.getSearchQueryBuilder();
LuceneSearchQuery<Object> searchQuery = searchQueryBuilder.ids();
List<Object> hits = searchQuery.fetchAllHits();
int count = 0;
for (Object id : hits) {
Object removed = cache.remove(id);
if (removed != null) {
count++;
}
}
if (queryStatistics.isEnabled()) recordQuery(System.nanoTime() - start);
return count;
} catch (org.hibernate.search.util.common.SearchTimeoutException timeoutException) {
throw new SearchTimeoutException();
}
}
private <T> CloseableIterator<T> iterator(SearchQuery<T> searchQuery) {
try {
return new ScrollerIteratorAdaptor<>(searchQuery.scroll(SCROLL_CHUNK));
} catch (org.hibernate.search.util.common.SearchTimeoutException timeoutException) {
throw new SearchTimeoutException();
}
}
@Override
public IndexedQuery<E> timeout(long timeout, TimeUnit timeUnit) {
queryDefinition.failAfter(timeout, timeUnit);
return this;
}
}
| 8,601
| 36.4
| 127
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/IndexStartupRunner.java
|
package org.infinispan.query.impl;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.IndexStartupMode;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.query.Indexer;
import org.infinispan.search.mapper.mapping.SearchMapping;
public final class IndexStartupRunner {
public static void run(SearchMapping mapping, Indexer indexer, Configuration configuration) {
IndexStartupMode startupMode = computeFinalMode(configuration);
if (IndexStartupMode.PURGE.equals(startupMode)) {
mapping.scopeAll().workspace().purge();
} else if (IndexStartupMode.REINDEX.equals(startupMode)) {
indexer.runLocal();
}
}
private IndexStartupRunner() {
}
private static IndexStartupMode computeFinalMode(Configuration configuration) {
IndexStartupMode startupMode = configuration.indexing().startupMode();
if (!IndexStartupMode.AUTO.equals(startupMode)) {
return startupMode;
}
boolean dataIsVolatile = configuration.persistence().stores().stream()
.allMatch(StoreConfiguration::purgeOnStartup);
boolean indexesAreVolatile = IndexStorage.LOCAL_HEAP.equals(configuration.indexing().storage());
if (dataIsVolatile && !indexesAreVolatile) {
return IndexStartupMode.PURGE;
}
if (!dataIsVolatile && indexesAreVolatile) {
return IndexStartupMode.REINDEX;
}
// if both (data and indexes) are volatile or not volatile they should be already aligned
return IndexStartupMode.NONE;
}
}
| 1,665
| 34.446809
| 102
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/KeyTransformationHandlerIdentifierBridge.java
|
package org.infinispan.query.impl;
import org.hibernate.search.engine.environment.bean.BeanReference;
import org.hibernate.search.mapper.pojo.bridge.IdentifierBridge;
import org.hibernate.search.mapper.pojo.bridge.runtime.IdentifierBridgeFromDocumentIdentifierContext;
import org.hibernate.search.mapper.pojo.bridge.runtime.IdentifierBridgeToDocumentIdentifierContext;
import org.infinispan.query.backend.KeyTransformationHandler;
/**
* An {@link IdentifierBridge} to map cache keys to the document identifiers.
*
* @author Fabio Massimo Ercoli
*/
public class KeyTransformationHandlerIdentifierBridge implements IdentifierBridge<Object> {
public static BeanReference<? extends IdentifierBridge<Object>> createReference(
KeyTransformationHandler keyTransformationHandler) {
return BeanReference.ofInstance(new KeyTransformationHandlerIdentifierBridge(keyTransformationHandler));
}
private final KeyTransformationHandler keyTransformationHandler;
private KeyTransformationHandlerIdentifierBridge(KeyTransformationHandler keyTransformationHandler) {
this.keyTransformationHandler = keyTransformationHandler;
}
@Override
public String toDocumentIdentifier(Object propertyValue, IdentifierBridgeToDocumentIdentifierContext context) {
return keyTransformationHandler.keyToString(propertyValue);
}
@Override
public Object fromDocumentIdentifier(String documentIdentifier, IdentifierBridgeFromDocumentIdentifierContext context) {
return keyTransformationHandler.stringToKey(documentIdentifier);
}
}
| 1,569
| 41.432432
| 123
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/CommandFactory.java
|
package org.infinispan.query.impl;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.commands.ReplicableCommand;
import org.infinispan.commands.module.ModuleCommandFactory;
import org.infinispan.commands.remote.CacheRpcCommand;
import org.infinispan.query.clustered.SegmentsClusteredQueryCommand;
import org.infinispan.util.ByteString;
/**
* Remote commands factory implementation.
*
* @author Israel Lacerra <israeldl@gmail.com>
* @since 5.1
*/
final class CommandFactory implements ModuleCommandFactory {
@Override
public Map<Byte, Class<? extends ReplicableCommand>> getModuleCommands() {
Map<Byte, Class<? extends ReplicableCommand>> map = new HashMap<>(4);
map.put(SegmentsClusteredQueryCommand.COMMAND_ID, SegmentsClusteredQueryCommand.class);
return map;
}
@Override
public ReplicableCommand fromStream(byte commandId) {
// Should never be called because this factory only provides cache specific replicable commands.
return null;
}
@Override
public CacheRpcCommand fromStream(byte commandId, ByteString cacheName) {
CacheRpcCommand c;
switch (commandId) {
case SegmentsClusteredQueryCommand.COMMAND_ID:
c = new SegmentsClusteredQueryCommand(cacheName);
break;
default:
throw new IllegalArgumentException("Not registered to handle command id " + commandId);
}
return c;
}
}
| 1,453
| 30.608696
| 102
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/LifecycleManager.java
|
package org.infinispan.query.impl;
import static org.infinispan.query.impl.config.SearchPropertyExtractor.extractProperties;
import static org.infinispan.query.logging.Log.CONTAINER;
import java.lang.invoke.MethodHandles;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.management.ObjectName;
import org.apache.lucene.search.BooleanQuery;
import org.hibernate.search.backend.lucene.work.spi.LuceneWorkExecutorProvider;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.util.AggregatedClassLoader;
import org.infinispan.commons.util.ServiceFinder;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.IndexShardingConfiguration;
import org.infinispan.configuration.cache.IndexingConfiguration;
import org.infinispan.configuration.cache.IndexingMode;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.encoding.impl.StorageConfigurationManager;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.factories.annotations.InfinispanModule;
import org.infinispan.factories.impl.BasicComponentRegistry;
import org.infinispan.factories.impl.ComponentRef;
import org.infinispan.interceptors.AsyncInterceptorChain;
import org.infinispan.interceptors.impl.EntryWrappingInterceptor;
import org.infinispan.jmx.CacheJmxRegistration;
import org.infinispan.lifecycle.ModuleLifecycle;
import org.infinispan.marshall.protostream.impl.SerializationContextRegistry;
import org.infinispan.metrics.impl.CacheMetricsRegistration;
import org.infinispan.objectfilter.impl.syntax.parser.ReflectionEntityNamesResolver;
import org.infinispan.query.Indexer;
import org.infinispan.query.Search;
import org.infinispan.query.Transformer;
import org.infinispan.query.backend.KeyTransformationHandler;
import org.infinispan.query.backend.QueryInterceptor;
import org.infinispan.query.backend.TxQueryInterceptor;
import org.infinispan.query.clustered.ClusteredQueryOperation;
import org.infinispan.query.clustered.NodeTopDocs;
import org.infinispan.query.clustered.QueryResponse;
import org.infinispan.query.core.impl.QueryCache;
import org.infinispan.query.core.stats.IndexStatistics;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.query.dsl.embedded.impl.ObjectReflectionMatcher;
import org.infinispan.query.dsl.embedded.impl.QueryEngine;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
import org.infinispan.query.impl.externalizers.LuceneBytesRefExternalizer;
import org.infinispan.query.impl.externalizers.LuceneFieldDocExternalizer;
import org.infinispan.query.impl.externalizers.LuceneScoreDocExternalizer;
import org.infinispan.query.impl.externalizers.LuceneSortExternalizer;
import org.infinispan.query.impl.externalizers.LuceneSortFieldExternalizer;
import org.infinispan.query.impl.externalizers.LuceneTopDocsExternalizer;
import org.infinispan.query.impl.externalizers.LuceneTopFieldDocsExternalizer;
import org.infinispan.query.impl.externalizers.LuceneTotalHitsExternalizer;
import org.infinispan.query.impl.externalizers.PojoRawTypeIdentifierExternalizer;
import org.infinispan.query.impl.massindex.DistributedExecutorMassIndexer;
import org.infinispan.query.impl.massindex.IndexWorker;
import org.infinispan.query.stats.impl.LocalIndexStatistics;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.registry.InternalCacheRegistry.Flag;
import org.infinispan.search.mapper.mapping.ProgrammaticSearchMappingProvider;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.search.mapper.mapping.SearchMappingBuilder;
import org.infinispan.search.mapper.mapping.SearchMappingCommonBuilding;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.transaction.xa.GlobalTransaction;
import org.infinispan.util.concurrent.BlockingManager;
/**
* Lifecycle of the Query module: initializes the Hibernate Search engine and shuts it down at cache stop. Each cache
* manager has its own instance of this class during its lifetime.
*
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2011 Red Hat Inc.
*/
@InfinispanModule(name = "query", requiredModules = {"core", "query-core", "clustered-lock"}, optionalModules = "lucene-directory")
public class LifecycleManager implements ModuleLifecycle {
/**
* Optional integer system property that sets value of {@link BooleanQuery#setMaxClauseCount}.
*/
public static final String MAX_BOOLEAN_CLAUSES_SYS_PROP = "infinispan.query.lucene.max-boolean-clauses";
private volatile boolean remoteQueryEnabled = false;
/**
* Registers the Search interceptor in the cache before it gets started
*/
@Override
public void cacheStarting(ComponentRegistry cr, Configuration cfg, String cacheName) {
InternalCacheRegistry icr = cr.getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class);
StorageConfigurationManager scm = cr.getComponent(StorageConfigurationManager.class);
LocalQueryStatistics queryStatistics = cr.getComponent(LocalQueryStatistics.class);
if (!icr.isInternalCache(cacheName) || icr.internalCacheHasFlag(cacheName, Flag.QUERYABLE)) {
AdvancedCache<?, ?> cache = cr.getComponent(Cache.class).getAdvancedCache();
SecurityActions.addCacheDependency(cache.getCacheManager(), cacheName, QueryCache.QUERY_CACHE_NAME);
ClassLoader aggregatedClassLoader = makeAggregatedClassLoader(cr.getGlobalComponentRegistry().getGlobalConfiguration().classLoader());
boolean isIndexed = cfg.indexing().enabled();
SearchMapping searchMapping = null;
if (isIndexed) {
Map<String, Class<?>> indexedClasses;
if (!scm.getValueStorageMediaType().match(MediaType.APPLICATION_PROTOSTREAM) || !remoteQueryEnabled) {
indexedClasses = makeIndexedClassesMap(cache);
} else {
indexedClasses = Collections.emptyMap();
}
KeyTransformationHandler keyTransformationHandler = new KeyTransformationHandler(aggregatedClassLoader);
cr.registerComponent(keyTransformationHandler, KeyTransformationHandler.class);
for (Map.Entry<Class<?>, Class<?>> kt : cfg.indexing().keyTransformers().entrySet()) {
keyTransformationHandler.registerTransformer(kt.getKey(), (Class<? extends Transformer>) kt.getValue());
}
searchMapping = createSearchMapping(queryStatistics, cfg.indexing(), indexedClasses, cr, cache,
keyTransformationHandler, aggregatedClassLoader);
createQueryInterceptorIfNeeded(cr, cfg, cache, indexedClasses);
Indexer massIndexer = new DistributedExecutorMassIndexer(cache);
cr.registerComponent(massIndexer, Indexer.class);
if (searchMapping != null) {
BasicComponentRegistry bcr = cr.getComponent(BasicComponentRegistry.class);
bcr.replaceComponent(IndexStatistics.class.getName(), new LocalIndexStatistics(), true);
bcr.rewire();
IndexStartupRunner.run(searchMapping, massIndexer, cfg);
}
}
cr.registerComponent(ObjectReflectionMatcher.create(cache,
new ReflectionEntityNamesResolver(aggregatedClassLoader), searchMapping),
ObjectReflectionMatcher.class);
cr.registerComponent(new QueryEngine<>(cache, isIndexed), QueryEngine.class);
}
}
public void enableRemoteQuery() {
remoteQueryEnabled = true;
}
private Map<String, Class<?>> makeIndexedClassesMap(AdvancedCache<?, ?> cache) {
Configuration cacheConfiguration = cache.getCacheConfiguration();
Map<String, Class<?>> entities = new HashMap<>();
// Try to resolve the indexed type names to class names.
for (String entityName : cacheConfiguration.indexing().indexedEntityTypes()) {
// include classes declared in indexing config
try {
entities.put(entityName, Util.loadClass(entityName, cache.getClassLoader()));
} catch (Exception e) {
throw CONTAINER.cannotLoadIndexedClass(entityName, e);
}
}
return entities;
}
private void createQueryInterceptorIfNeeded(ComponentRegistry cr, Configuration cfg, AdvancedCache<?, ?> cache,
Map<String, Class<?>> indexedClasses) {
CONTAINER.registeringQueryInterceptor(cache.getName());
BasicComponentRegistry bcr = cr.getComponent(BasicComponentRegistry.class);
ComponentRef<QueryInterceptor> queryInterceptorRef = bcr.getComponent(QueryInterceptor.class);
if (queryInterceptorRef != null) {
// could be already present when two caches share a config
return;
}
ConcurrentMap<GlobalTransaction, Map<Object, Object>> txOldValues = new ConcurrentHashMap<>();
boolean manualIndexing = cfg.indexing().indexingMode().equals(IndexingMode.MANUAL);
QueryInterceptor queryInterceptor = new QueryInterceptor(manualIndexing, txOldValues, cache, indexedClasses);
AsyncInterceptorChain ic = bcr.getComponent(AsyncInterceptorChain.class).wired();
EntryWrappingInterceptor wrappingInterceptor = ic.findInterceptorExtending(EntryWrappingInterceptor.class);
ic.addInterceptorBefore(queryInterceptor, wrappingInterceptor.getClass());
bcr.registerComponent(QueryInterceptor.class, queryInterceptor, true);
bcr.addDynamicDependency(AsyncInterceptorChain.class.getName(), QueryInterceptor.class.getName());
if (cfg.transaction().transactionMode().isTransactional()) {
TxQueryInterceptor txQueryInterceptor = new TxQueryInterceptor(txOldValues, queryInterceptor);
ic.addInterceptorBefore(txQueryInterceptor, wrappingInterceptor.getClass());
bcr.registerComponent(TxQueryInterceptor.class, txQueryInterceptor, true);
bcr.addDynamicDependency(AsyncInterceptorChain.class.getName(), TxQueryInterceptor.class.getName());
}
}
@Override
public void cacheStarted(ComponentRegistry cr, String cacheName) {
Configuration configuration = cr.getComponent(Configuration.class);
StorageConfigurationManager scm = cr.getComponent(StorageConfigurationManager.class);
IndexingConfiguration indexingConfiguration = configuration.indexing();
if (!indexingConfiguration.enabled()) {
if (verifyChainContainsQueryInterceptor(cr)) {
throw new IllegalStateException("It was NOT expected to find the Query interceptor registered in the InterceptorChain as indexing was disabled, but it was found");
}
return;
}
if (!verifyChainContainsQueryInterceptor(cr)) {
throw new IllegalStateException("It was expected to find the Query interceptor registered in the InterceptorChain but it wasn't found");
}
SearchMapping searchMapping = cr.getComponent(SearchMapping.class);
if (searchMapping != null && !scm.getValueStorageMediaType().match(MediaType.APPLICATION_PROTOSTREAM)) {
checkIndexableClasses(searchMapping, indexingConfiguration.indexedEntityTypes(), cr.getGlobalComponentRegistry().getGlobalConfiguration().classLoader());
}
AdvancedCache<?, ?> cache = cr.getComponent(Cache.class).getAdvancedCache();
Indexer massIndexer = ComponentRegistryUtils.getIndexer(cache);
InfinispanQueryStatisticsInfo stats = new InfinispanQueryStatisticsInfo(Search.getSearchStatistics(cache), SecurityActions.getCacheComponentRegistry(cache).getComponent(Authorizer.class));
cr.registerComponent(stats, InfinispanQueryStatisticsInfo.class);
registerQueryMBeans(cr, massIndexer, stats);
registerMetrics(cr, stats);
}
private void registerMetrics(ComponentRegistry cr, InfinispanQueryStatisticsInfo stats) {
CacheMetricsRegistration cacheMetricsRegistration = cr.getComponent(CacheMetricsRegistration.class);
if (cacheMetricsRegistration.metricsEnabled()) {
cacheMetricsRegistration.registerMetrics(stats, "query", "statistics");
}
}
/**
* Check that the indexable classes declared by the user are really indexable by looking at the presence of Hibernate
* Search index bindings.
*/
private void checkIndexableClasses(SearchMapping searchMapping, Set<String> indexedEntities, ClassLoader classLoader) {
if (indexedEntities.isEmpty()) {
return;
}
for (String entityName : indexedEntities) {
Class<?> indexedClass = Util.loadClass(entityName, classLoader);
if (searchMapping.indexedEntity(indexedClass) == null) {
throw CONTAINER.classNotIndexable(entityName);
}
}
}
/**
* Register query statistics and mass-indexer MBeans for a cache.
*/
private void registerQueryMBeans(ComponentRegistry cr, Indexer massIndexer, InfinispanQueryStatisticsInfo stats) {
GlobalConfiguration globalConfig = cr.getGlobalComponentRegistry().getGlobalConfiguration();
if (globalConfig.jmx().enabled()) {
Cache<?, ?> cache = cr.getComponent(Cache.class);
String queryGroupName = getQueryGroupName(globalConfig.cacheManagerName(), cache.getName());
CacheJmxRegistration jmxRegistration = cr.getComponent(CacheJmxRegistration.class);
try {
jmxRegistration.registerMBean(stats, queryGroupName);
} catch (Exception e) {
throw new CacheException("Unable to register query statistics MBean", e);
}
try {
jmxRegistration.registerMBean(massIndexer, queryGroupName);
} catch (Exception e) {
throw new CacheException("Unable to register MassIndexer MBean", e);
}
}
}
private String getQueryGroupName(String cacheManagerName, String cacheName) {
return "type=Query,manager=" + ObjectName.quote(cacheManagerName) + ",cache=" + ObjectName.quote(cacheName);
}
private boolean verifyChainContainsQueryInterceptor(ComponentRegistry cr) {
AsyncInterceptorChain interceptorChain = cr.getComponent(AsyncInterceptorChain.class);
return interceptorChain != null && interceptorChain.containsInterceptorType(QueryInterceptor.class, true);
}
private SearchMapping createSearchMapping(LocalQueryStatistics queryStatistics,
IndexingConfiguration indexingConfiguration,
Map<String, Class<?>> indexedClasses, ComponentRegistry cr,
AdvancedCache<?, ?> cache,
KeyTransformationHandler keyTransformationHandler,
ClassLoader aggregatedClassLoader) {
SearchMapping searchMapping = cr.getComponent(SearchMapping.class);
if (searchMapping != null && !searchMapping.isClose()) {
// a paranoid check against an unlikely failure
throw new IllegalStateException("SearchIntegrator already initialized!");
}
GlobalConfiguration globalConfiguration = cr.getGlobalComponentRegistry().getGlobalConfiguration();
// load ProgrammaticSearchMappingProviders from classpath
Collection<ProgrammaticSearchMappingProvider> mappingProviders =
ServiceFinder.load(ProgrammaticSearchMappingProvider.class, aggregatedClassLoader);
BlockingManager blockingManager = cr.getGlobalComponentRegistry().getComponent(BlockingManager.class);
LuceneWorkExecutorProvider luceneWorkExecutorProvider =
cr.getGlobalComponentRegistry().getComponent(LuceneWorkExecutorProvider.class);
Integer numberOfShards = 1;
IndexShardingConfiguration sharding = indexingConfiguration.sharding();
if (sharding != null) {
numberOfShards = sharding.getShards();
}
SearchMappingCommonBuilding commonBuilding = new SearchMappingCommonBuilding(
KeyTransformationHandlerIdentifierBridge.createReference(keyTransformationHandler),
extractProperties(globalConfiguration, cache.getName(), indexingConfiguration, aggregatedClassLoader),
aggregatedClassLoader, mappingProviders, blockingManager, luceneWorkExecutorProvider,
numberOfShards);
Set<Class<?>> types = new HashSet<>(indexedClasses.values());
if (!types.isEmpty()) {
// use the common builder to create the mapping now
SearchMappingBuilder builder = commonBuilding.builder(SearchMappingBuilder.introspector(MethodHandles.lookup()));
builder.setEntityLoader(new EntityLoader<>(cache, queryStatistics));
builder.addEntityTypes(types);
searchMapping = builder.build(Optional.empty());
cr.registerComponent(searchMapping, SearchMapping.class);
}
if (searchMapping == null) {
// register the common builder to create the mapping at a later time
cr.registerComponent(commonBuilding, SearchMappingCommonBuilding.class);
}
return searchMapping;
}
/**
* Create a class loader that delegates loading to an ordered set of class loaders.
*
* @param globalClassLoader the cache manager's global ClassLoader from GlobalConfiguration
* @return the aggregated ClassLoader
*/
private ClassLoader makeAggregatedClassLoader(ClassLoader globalClassLoader) {
// use an ordered set to deduplicate them
Set<ClassLoader> classLoaders = new LinkedHashSet<>(6);
// add the cache manager's CL
if (globalClassLoader != null) {
classLoaders.add(globalClassLoader);
}
// add Infinispan's CL
classLoaders.add(AggregatedClassLoader.class.getClassLoader());
// add this module's CL
classLoaders.add(getClass().getClassLoader());
// add the TCCL
try {
ClassLoader tccl = Thread.currentThread().getContextClassLoader();
if (tccl != null) {
classLoaders.add(tccl);
}
} catch (Exception e) {
// ignored
}
// add the system CL
try {
ClassLoader syscl = ClassLoader.getSystemClassLoader();
if (syscl != null) {
classLoaders.add(syscl);
}
} catch (Exception e) {
// ignored
}
return new AggregatedClassLoader(classLoaders);
}
@Override
public void cacheStopping(ComponentRegistry cr, String cacheName) {
QueryInterceptor queryInterceptor = cr.getComponent(QueryInterceptor.class);
if (queryInterceptor != null) {
queryInterceptor.prepareForStopping();
}
SearchMapping searchMapping = cr.getComponent(SearchMapping.class);
if (searchMapping != null) {
searchMapping.close();
}
}
@Override
public void cacheStopped(ComponentRegistry cr, String cacheName) {
QueryCache queryCache = cr.getComponent(QueryCache.class);
if (queryCache != null) {
InternalCacheRegistry icr = cr.getGlobalComponentRegistry().getComponent(InternalCacheRegistry.class);
if (!icr.isInternalCache(cacheName) || icr.internalCacheHasFlag(cacheName, Flag.QUERYABLE)) {
queryCache.clear(cacheName);
}
}
}
@Override
public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration globalCfg) {
SerializationContextRegistry ctxRegistry = gcr.getComponent(SerializationContextRegistry.class);
ctxRegistry.addContextInitializer(SerializationContextRegistry.MarshallerType.PERSISTENCE, new PersistenceContextInitializerImpl());
Map<Integer, AdvancedExternalizer<?>> externalizerMap = globalCfg.serialization().advancedExternalizers();
externalizerMap.put(ExternalizerIds.LUCENE_SORT, new LuceneSortExternalizer());
externalizerMap.put(ExternalizerIds.LUCENE_SORT_FIELD, new LuceneSortFieldExternalizer());
externalizerMap.put(ExternalizerIds.CLUSTERED_QUERY_TOPDOCS, new NodeTopDocs.Externalizer());
externalizerMap.put(ExternalizerIds.LUCENE_TOPDOCS, new LuceneTopDocsExternalizer());
externalizerMap.put(ExternalizerIds.LUCENE_FIELD_SCORE_DOC, new LuceneFieldDocExternalizer());
externalizerMap.put(ExternalizerIds.LUCENE_SCORE_DOC, new LuceneScoreDocExternalizer());
externalizerMap.put(ExternalizerIds.LUCENE_TOPFIELDDOCS, new LuceneTopFieldDocsExternalizer());
externalizerMap.put(ExternalizerIds.INDEX_WORKER, new IndexWorker.Externalizer());
externalizerMap.put(ExternalizerIds.LUCENE_BYTES_REF, new LuceneBytesRefExternalizer());
externalizerMap.put(ExternalizerIds.QUERY_DEFINITION, new QueryDefinition.Externalizer());
externalizerMap.put(ExternalizerIds.CLUSTERED_QUERY_COMMAND_RESPONSE, new QueryResponse.Externalizer());
externalizerMap.put(ExternalizerIds.CLUSTERED_QUERY_OPERATION, new ClusteredQueryOperation.Externalizer());
externalizerMap.put(ExternalizerIds.POJO_TYPE_IDENTIFIER, new PojoRawTypeIdentifierExternalizer());
externalizerMap.put(ExternalizerIds.LUCENE_TOTAL_HITS, new LuceneTotalHitsExternalizer());
}
@Override
public void cacheManagerStarted(GlobalComponentRegistry gcr) {
setMaxBooleanClauses();
}
private void setMaxBooleanClauses() {
Integer maxClauseCount = Integer.getInteger(MAX_BOOLEAN_CLAUSES_SYS_PROP);
if (maxClauseCount != null) {
int currentMaxClauseCount = BooleanQuery.getMaxClauseCount();
if (maxClauseCount > currentMaxClauseCount) {
CONTAINER.settingBooleanQueryMaxClauseCount(MAX_BOOLEAN_CLAUSES_SYS_PROP, maxClauseCount);
BooleanQuery.setMaxClauseCount(maxClauseCount);
} else {
CONTAINER.ignoringBooleanQueryMaxClauseCount(MAX_BOOLEAN_CLAUSES_SYS_PROP, maxClauseCount, currentMaxClauseCount);
}
}
}
}
| 22,457
| 48.796009
| 194
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/DefaultTransformer.java
|
package org.infinispan.query.impl;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.query.Transformer;
/**
* WARNING, slow as a senile dog, uses Java Serialization and base64 encoding to get a String representation of an
* Object. It is highly recommended that you provide your own implementation of {@link
* org.infinispan.query.Transformer}.
*
* @author Navin Surtani
* @author anistor@redhat.com
*/
public final class DefaultTransformer implements Transformer {
private static final Log log = LogFactory.getLog(DefaultTransformer.class);
@Override
public Object fromString(String str) {
byte[] objBytes = Base64.getDecoder().decode(str);
try {
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(objBytes));
return ois.readObject();
} catch (IOException | ClassNotFoundException e) {
log.error("Error while decoding object", e);
throw new CacheException(e);
}
}
@Override
public String toString(Object obj) {
if (obj instanceof Serializable) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(Base64.getEncoder().wrap(baos));
oos.writeObject(obj);
oos.close();
byte[] base64encoded = baos.toByteArray();
return new String(base64encoded, StandardCharsets.UTF_8);
} catch (IOException e) {
log.error("Error while encoding object", e);
throw new CacheException(e);
}
} else {
throw new IllegalArgumentException("Expected " + obj.getClass() + " to be Serializable!");
}
}
}
| 2,079
| 33.666667
| 114
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/InfinispanQueryStatisticsInfo.java
|
package org.infinispan.query.impl;
import org.hibernate.search.engine.Version;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.jmx.annotations.MBean;
import org.infinispan.jmx.annotations.ManagedAttribute;
import org.infinispan.jmx.annotations.ManagedOperation;
import org.infinispan.query.core.stats.IndexInfo;
import org.infinispan.query.core.stats.IndexStatistics;
import org.infinispan.query.core.stats.QueryStatistics;
import org.infinispan.query.core.stats.SearchStatistics;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.util.concurrent.CompletionStages;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;
/**
* This MBean exposes the query statistics from the Hibernate Search's SearchIntegrator Statistics object via
* delegation. The Statistics object is transient during search factory in-flight reconfiguration so the instance
* returned by getStatistics() cannot be registered directly as an MBean.
*
* @author anistor@redhat.com
* @since 6.1
*/
@MBean(objectName = "Statistics", description = "Statistics for index based query")
public final class InfinispanQueryStatisticsInfo {
private final QueryStatistics queryStatistics;
private final IndexStatistics indexStatistics;
private final Authorizer authorizer;
InfinispanQueryStatisticsInfo(SearchStatistics searchStatistics, Authorizer authorizer) {
this.queryStatistics = searchStatistics.getQueryStatistics();
this.indexStatistics = searchStatistics.getIndexStatistics();
this.authorizer = authorizer;
}
@ManagedOperation
public void clear() {
authorizer.checkPermission(AuthorizationPermission.ADMIN);
queryStatistics.clear();
}
@ManagedAttribute
public long getSearchQueryExecutionCount() {
return queryStatistics.getLocalIndexedQueryCount();
}
@ManagedAttribute
public long getSearchQueryTotalTime() {
return queryStatistics.getLocalIndexedQueryTotalTime();
}
@ManagedAttribute
public long getSearchQueryExecutionMaxTime() {
return queryStatistics.getLocalIndexedQueryMaxTime();
}
@ManagedAttribute
public long getSearchQueryExecutionAvgTime() {
return ((Double) queryStatistics.getLocalIndexedQueryAvgTime()).longValue();
}
@ManagedAttribute
public String getSearchQueryExecutionMaxTimeQueryString() {
String query = queryStatistics.getSlowestLocalIndexedQuery();
return query == null ? "" : query;
}
@ManagedAttribute
public long getObjectLoadingTotalTime() {
return queryStatistics.getLoadCount();
}
@ManagedAttribute
public long getObjectLoadingExecutionMaxTime() {
return queryStatistics.getLoadTotalTime();
}
@ManagedAttribute
public long getObjectLoadingExecutionAvgTime() {
return ((Double) queryStatistics.getLoadAvgTime()).longValue();
}
@ManagedAttribute
public long getObjectsLoadedCount() {
return queryStatistics.getLoadCount();
}
@ManagedAttribute
public boolean isStatisticsEnabled() {
return queryStatistics.isEnabled();
}
@ManagedAttribute
public String getSearchVersion() {
return Version.versionString();
}
@ManagedAttribute
public Set<String> getIndexedClassNames() {
return blockingIndexInfos().keySet();
}
@ManagedOperation
public int getNumberOfIndexedEntities(String entity) {
return find(blockingIndexInfos(), entity).map(IndexInfo::count).orElse(0L).intValue();
}
private Optional<IndexInfo> find(Map<String, IndexInfo> indexInfos, String entity) {
return indexInfos.entrySet().stream().filter(e -> e.getKey().equals(entity))
.map(Map.Entry::getValue).findFirst();
}
@ManagedOperation
public Map<String, Integer> indexedEntitiesCount() {
return blockingIndexInfos().entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, e -> (int) e.getValue().count()));
}
@ManagedOperation
public long getIndexSize(String indexName) {
return find(blockingIndexInfos(), indexName).map(IndexInfo::size).orElse(0L);
}
@ManagedOperation
public Map<String, Long> indexSizes() {
return blockingIndexInfos().entrySet().stream()
.collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().size()));
}
public Json getLegacyQueryStatistics() {
return Json.object()
.set("search_query_execution_count", getSearchQueryExecutionCount())
.set("search_query_total_time", getSearchQueryTotalTime())
.set("search_query_execution_max_time", getSearchQueryExecutionMaxTime())
.set("search_query_execution_avg_time", getSearchQueryExecutionAvgTime())
.set("object_loading_total_time", getObjectLoadingTotalTime())
.set("object_loading_execution_max_time", getObjectLoadingExecutionMaxTime())
.set("object_loading_execution_avg_time", getObjectLoadingExecutionAvgTime())
.set("objects_loaded_count", getObjectsLoadedCount())
.set("search_query_execution_max_time_query_string", getSearchQueryExecutionMaxTimeQueryString());
}
public CompletionStage<Json> computeLegacyIndexStatistics() {
return indexStatistics.computeIndexInfos().thenApply(indexInfos -> {
Map<String, Long> counts = indexInfos.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().count()));
Map<String, Long> sizes = indexInfos.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().size()));
return Json.object()
.set("indexed_class_names", Json.make(indexInfos.keySet()))
.set("indexed_entities_count", Json.make(counts))
.set("index_sizes", Json.make(sizes))
.set("reindexing", indexStatistics.reindexing());
});
}
private Map<String, IndexInfo> blockingIndexInfos() {
return CompletionStages.join(indexStatistics.computeIndexInfos());
}
}
| 6,175
| 35.982036
| 139
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/ComponentRegistryUtils.java
|
package org.infinispan.query.impl;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.distribution.ch.KeyPartitioner;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.query.Indexer;
import org.infinispan.query.backend.KeyTransformationHandler;
import org.infinispan.query.backend.QueryInterceptor;
import org.infinispan.query.core.impl.QueryCache;
import org.infinispan.query.core.stats.impl.LocalQueryStatistics;
import org.infinispan.query.core.stats.impl.SearchStatsRetriever;
import org.infinispan.query.dsl.embedded.impl.QueryEngine;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.security.actions.SecurityActions;
/**
* Lookup methods for various internal components of search module.
*
* @author Marko Luksa
* @author Galder Zamarreño
*/
public final class ComponentRegistryUtils {
private ComponentRegistryUtils() {
}
private static <T> T getRequiredComponent(Cache<?, ?> cache, Class<T> clazz) {
ComponentRegistry componentRegistry = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache());
T component = componentRegistry.getComponent(clazz, clazz.getName());
if (component == null) {
throw new IllegalStateException(clazz.getName() + " not found in component registry");
}
return component;
}
private static void ensureIndexed(Cache<?, ?> cache) {
Configuration cfg = SecurityActions.getCacheConfiguration(cache.getAdvancedCache());
if (!cfg.indexing().enabled()) {
throw new IllegalStateException("Indexing was not enabled on cache " + cache.getName());
}
}
public static SearchMapping getSearchMapping(Cache<?, ?> cache) {
ComponentRegistry componentRegistry = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache());
return componentRegistry.getComponent(SearchMapping.class, SearchMapping.class.getName());
}
public static KeyPartitioner getKeyPartitioner(Cache<?, ?> cache) {
return getRequiredComponent(cache, KeyPartitioner.class);
}
public static QueryInterceptor getQueryInterceptor(Cache<?, ?> cache) {
ensureIndexed(cache);
return getRequiredComponent(cache, QueryInterceptor.class);
}
public static LocalQueryStatistics getLocalQueryStatistics(Cache<?, ?> cache) {
return SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache()).getComponent(LocalQueryStatistics.class);
}
public static SearchStatsRetriever getSearchStatsRetriever(Cache<?, ?> cache) {
return SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache()).getComponent(SearchStatsRetriever.class);
}
public static KeyTransformationHandler getKeyTransformationHandler(Cache<?, ?> cache) {
ensureIndexed(cache);
return getRequiredComponent(cache, KeyTransformationHandler.class);
}
public static QueryEngine<Class<?>> getEmbeddedQueryEngine(Cache<?, ?> cache) {
return getRequiredComponent(cache, QueryEngine.class);
}
public static TimeService getTimeService(Cache<?, ?> cache) {
return getRequiredComponent(cache, TimeService.class);
}
/**
* Returns the optional QueryCache.
*/
public static QueryCache getQueryCache(Cache<?, ?> cache) {
return SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache()).getComponent(QueryCache.class);
}
public static Indexer getIndexer(AdvancedCache<?, ?> cache) {
ensureIndexed(cache);
return getRequiredComponent(cache, Indexer.class);
}
public static InfinispanQueryStatisticsInfo getQueryStatistics(AdvancedCache<?, ?> cache) {
return getRequiredComponent(cache, InfinispanQueryStatisticsInfo.class);
}
}
| 3,855
| 38.752577
| 122
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/config/SearchPropertyExtractor.java
|
package org.infinispan.query.impl.config;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import org.hibernate.search.backend.lucene.analysis.LuceneAnalysisConfigurer;
import org.infinispan.commons.util.ServiceFinder;
import org.infinispan.configuration.cache.IndexMergeConfiguration;
import org.infinispan.configuration.cache.IndexReaderConfiguration;
import org.infinispan.configuration.cache.IndexShardingConfiguration;
import org.infinispan.configuration.cache.IndexStorage;
import org.infinispan.configuration.cache.IndexWriterConfiguration;
import org.infinispan.configuration.cache.IndexingConfiguration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalStateConfiguration;
import org.infinispan.search.mapper.mapping.impl.CompositeAnalysisConfigurer;
/**
* Extracts Hibernate Search native configuration properties from a {@link IndexingConfiguration}.
*
* @since 12.0
*/
public class SearchPropertyExtractor {
private static final String BACKEND_PREFIX = "hibernate.search.backend.";
private static final String DIRECTORY_ROOT_KEY = BACKEND_PREFIX + "directory.root";
private static final String DIRECTORY_PROVIDER_KEY = BACKEND_PREFIX + "directory.type";
private static final String LOCAL_HEAP_DIRECTORY_PROVIDER = "local-heap";
private static final String FS_PROVIDER = "local-filesystem";
private static final String REFRESH_INTERVAL_KEY = "hibernate.search.backend.io.refresh_interval";
private static final String IO_PREFIX = "hibernate.search.backend.io.";
private static final String COMMIT_INTERVAL_KEY = IO_PREFIX + "commit_interval";
private static final String RAM_BUFFER_KEY = IO_PREFIX + "writer.ram_buffer_size";
private static final String MAX_BUFFER_DOCS_KEY = IO_PREFIX + "writer.max_buffered_docs";
private static final String LOW_LEVEL_TRACE_KEY = IO_PREFIX + "writer.infostream";
private static final String QUEUE_COUNT_KEY = BACKEND_PREFIX + "indexing.queue_count";
private static final String QUEUE_SIZE_KEY = BACKEND_PREFIX + "indexing.queue_size";
private static final String THREAD_POOL_KEY = BACKEND_PREFIX + "thread_pool.size";
private static final String KEY_PREFIX = "hibernate.search.backend.io.merge";
private static final String MAX_DOCS_KEY = KEY_PREFIX + ".max_docs";
private static final String FACTOR_KEY = KEY_PREFIX + ".factor";
private static final String MIN_SIZE_KEY = KEY_PREFIX + ".min_size";
private static final String MAX_SIZE_KEY = KEY_PREFIX + ".max_size";
private static final String MAX_FORCED_SIZE_KEY = KEY_PREFIX + ".max_forced_size";
private static final String CALIBRATE_BY_DELETES_KEY = KEY_PREFIX + ".calibrate_by_deletes";
private static final String ANALYSIS_CONFIGURER_PROPERTY_NAME = "analysis.configurer";
public static Map<String, Object> extractProperties(GlobalConfiguration globalConfiguration,
String cacheName,
IndexingConfiguration configuration,
ClassLoader aggregatedClassLoader) {
Map<String, Object> props = new LinkedHashMap<>();
// load LuceneAnalysisDefinitionProvider from classpath
Collection<LuceneAnalysisConfigurer> analyzerDefProviders = ServiceFinder.load(LuceneAnalysisConfigurer.class, aggregatedClassLoader);
if (analyzerDefProviders.size() == 1) {
props.put(ANALYSIS_CONFIGURER_PROPERTY_NAME, analyzerDefProviders.iterator().next());
} else if (!analyzerDefProviders.isEmpty()) {
props.put(ANALYSIS_CONFIGURER_PROPERTY_NAME, new CompositeAnalysisConfigurer(analyzerDefProviders));
}
if (!configuration.enabled()) {
return Collections.unmodifiableMap(props);
}
IndexStorage storage = configuration.storage();
if (storage.equals(IndexStorage.LOCAL_HEAP)) {
props.put(DIRECTORY_PROVIDER_KEY, LOCAL_HEAP_DIRECTORY_PROVIDER);
} else {
props.put(DIRECTORY_PROVIDER_KEY, FS_PROVIDER);
Path location = getIndexLocation(globalConfiguration, configuration.path(), cacheName);
props.put(DIRECTORY_ROOT_KEY, location.toFile().getPath());
}
IndexReaderConfiguration readerConfiguration = configuration.reader();
long refreshInterval = readerConfiguration.getRefreshInterval();
if (refreshInterval != 0) {
props.put(REFRESH_INTERVAL_KEY, refreshInterval);
}
IndexWriterConfiguration writerConfiguration = configuration.writer();
Integer commitInterval = writerConfiguration.getCommitInterval();
if (commitInterval != null) {
props.put(COMMIT_INTERVAL_KEY, commitInterval);
}
Integer threadPoolSize = writerConfiguration.getThreadPoolSize();
if (threadPoolSize != null) {
props.put(THREAD_POOL_KEY, threadPoolSize);
}
Integer queueCount = writerConfiguration.getQueueCount();
if (queueCount != null) {
props.put(QUEUE_COUNT_KEY, queueCount);
}
Integer queueSize = writerConfiguration.getQueueSize();
if (queueSize != null) {
props.put(QUEUE_SIZE_KEY, queueSize);
}
Integer ramBufferSize = writerConfiguration.getRamBufferSize();
if (ramBufferSize != null) {
props.put(RAM_BUFFER_KEY, ramBufferSize);
}
Integer maxBufferedDocs = writerConfiguration.getMaxBufferedEntries();
if (maxBufferedDocs != null) {
props.put(MAX_BUFFER_DOCS_KEY, maxBufferedDocs);
}
Boolean lowLevelTrace = writerConfiguration.isLowLevelTrace();
if (lowLevelTrace) {
props.put(LOW_LEVEL_TRACE_KEY, true);
}
IndexMergeConfiguration mergeConfiguration = writerConfiguration.merge();
Integer maxDocs = mergeConfiguration.maxEntries();
if (maxDocs != null) {
props.put(MAX_DOCS_KEY, maxDocs);
}
Integer minSize = mergeConfiguration.minSize();
if (minSize != null) {
props.put(MIN_SIZE_KEY, minSize);
}
Integer maxSize = mergeConfiguration.maxSize();
if (maxSize != null) {
props.put(MAX_SIZE_KEY, maxSize);
}
Integer factor = mergeConfiguration.factor();
if (factor != null) {
props.put(FACTOR_KEY, factor);
}
Integer maxForcedSize = mergeConfiguration.maxForcedSize();
if (maxForcedSize != null) {
props.put(MAX_FORCED_SIZE_KEY, maxForcedSize);
}
Boolean calibrateByDeletes = mergeConfiguration.calibrateByDeletes();
if (calibrateByDeletes != null) {
props.put(CALIBRATE_BY_DELETES_KEY, calibrateByDeletes);
}
IndexShardingConfiguration sharding = configuration.sharding();
if (sharding != null) {
Integer numberOfShards = sharding.getShards();
if (numberOfShards > 1) {
props.put("sharding.strategy", "hash"); // the only strategy supported at the moment
props.put("sharding.number_of_shards", numberOfShards);
}
}
return Collections.unmodifiableMap(props);
}
public static Path getIndexLocation(GlobalConfiguration globalConfiguration, String location, String cacheName) {
GlobalStateConfiguration globalState = globalConfiguration.globalState();
Path persistentLocation = Paths.get(globalState.persistentLocation());
if (location == null) return persistentLocation.resolve(cacheName);
Path path = Paths.get(location);
return path.isAbsolute() ? path : persistentLocation.resolve(path);
}
}
| 7,731
| 45.02381
| 140
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/MassIndexerProgressState.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.CompletableFuture;
import org.hibernate.search.util.common.impl.Futures;
import org.infinispan.query.logging.Log;
import org.infinispan.util.logging.LogFactory;
public class MassIndexerProgressState {
private static final Log LOG = LogFactory.getLog(IndexUpdater.class, Log.class);
private final MassIndexerProgressNotifier notifier;
private CompletableFuture<?> lastFuture = CompletableFuture.completedFuture( null );
public MassIndexerProgressState(MassIndexerProgressNotifier notifier) {
this.notifier = notifier;
}
public void addItem(Object key, Object value, CompletableFuture<?> future) {
// This is what HS5 currently does, but introduce chunking could be a good idea.
lastFuture = future.whenComplete((result, exception) -> {
if (exception != null) {
notifier.notifyEntityIndexingFailure(value.getClass(), key, exception);
} else {
notifier.notifyDocumentsAdded(1);
}
}).thenCombine(lastFuture, (ignored1, ignored2) -> null);
}
public void waitForAsyncCompletion() {
try {
Futures.unwrappedExceptionGet(lastFuture);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw LOG.interruptedWhileWaitingForRequestCompletion(e);
}
}
}
| 1,390
| 32.119048
| 87
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/MassIndexerProgressNotifier.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.LongAdder;
import org.hibernate.search.engine.reporting.EntityIndexingFailureContext;
import org.hibernate.search.engine.reporting.FailureHandler;
import org.hibernate.search.util.common.SearchException;
import org.infinispan.commons.time.TimeService;
import org.infinispan.query.logging.Log;
import org.hibernate.search.engine.common.EntityReference;
import org.infinispan.search.mapper.common.impl.EntityReferenceImpl;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.util.logging.LogFactory;
class MassIndexerProgressNotifier {
private static final Log log = LogFactory.getLog(MassIndexerProgressNotifier.class, Log.class);
private final MassIndexerProgressMonitor monitor;
private final SearchMapping searchMapping;
private final AtomicReference<RecordedEntityIndexingFailure> entityIndexingFirstFailure = new AtomicReference<>(null);
private final LongAdder entityIndexingFailureCount = new LongAdder();
private FailureHandler failureHandler;
MassIndexerProgressNotifier(SearchMapping searchMapping, TimeService timeService) {
this.monitor = new MassIndexerProgressMonitor(timeService);
this.searchMapping = searchMapping;
}
void notifyPreIndexingReloading() {
monitor.preIndexingReloading();
}
void notifyIndexingStarting() {
monitor.indexingStarting();
}
void notifyDocumentsAdded(int size) {
monitor.documentsAdded(size);
}
void notifyIndexingCompletedSuccessfully() {
monitor.indexingCompleted();
SearchException entityIndexingException = createEntityIndexingExceptionOrNull();
if (entityIndexingException != null) {
throw entityIndexingException;
}
}
<T> void notifyEntityIndexingFailure(Class<T> type, Object id, Throwable throwable) {
RecordedEntityIndexingFailure recordedFailure = new RecordedEntityIndexingFailure(throwable);
entityIndexingFirstFailure.compareAndSet(null, recordedFailure);
entityIndexingFailureCount.increment();
EntityIndexingFailureContext.Builder contextBuilder = EntityIndexingFailureContext.builder();
contextBuilder.throwable(throwable);
contextBuilder.failingOperation(log.massIndexerIndexingInstance(type.getSimpleName()));
EntityReference entityReference = EntityReferenceImpl.withDefaultName(type, id);
contextBuilder.entityReference(entityReference);
recordedFailure.entityReference = entityReference;
if (failureHandler == null) {
failureHandler = searchMapping.getFailureHandler();
}
failureHandler.handle(contextBuilder.build());
}
private SearchException createEntityIndexingExceptionOrNull() {
RecordedEntityIndexingFailure firstFailure = entityIndexingFirstFailure.get();
if (firstFailure == null) {
return null;
}
return log.massIndexingEntityFailures(entityIndexingFailureCount.longValue(), firstFailure.entityReference, firstFailure.throwable.getMessage(), firstFailure.throwable);
}
private static class RecordedEntityIndexingFailure {
private Throwable throwable;
private EntityReference entityReference;
RecordedEntityIndexingFailure(Throwable throwable) {
this.throwable = throwable;
}
}
}
| 3,407
| 36.866667
| 175
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/MassIndexerAlreadyStartedException.java
|
package org.infinispan.query.impl.massindex;
/**
* @since 10.1
*/
public class MassIndexerAlreadyStartedException extends IllegalStateException {
}
| 151
| 18
| 79
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/IndexLock.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.CompletionStage;
/**
* The lock used to prevent multiple executions of the MassIndexer concurrently.
*
* @since 10.1
*/
interface IndexLock {
/**
* Tries to acquire a lock to execute the MassIndexer, without waiting.
*
* @return true if the lock was acquired, or false if it was already acquired.
*/
CompletionStage<Boolean> lock();
/**
* Unlock the MassIndexer.
*/
CompletionStage<Void> unlock();
}
| 517
| 20.583333
| 81
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/MassIndexerLockFactory.java
|
package org.infinispan.query.impl.massindex;
import org.infinispan.Cache;
/**
* @since 10.1
*/
class MassIndexerLockFactory {
private MassIndexerLockFactory() {
}
static IndexLock buildLock(Cache<?, ?> cache) {
if (cache.getCacheConfiguration().clustering().cacheMode().isClustered())
return new DistributedIndexerLock(cache);
return new LocalIndexerLock();
}
}
| 400
| 21.277778
| 79
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/DistributedIndexerLock.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.CompletionStage;
import org.infinispan.Cache;
import org.infinispan.lock.EmbeddedClusteredLockManagerFactory;
import org.infinispan.lock.api.ClusteredLock;
import org.infinispan.lock.api.ClusteredLockManager;
/**
* A cluster-wide lock to prevent multiple instances of the {@link org.infinispan.query.Indexer} to run concurrently.
*
* @since 10.1
*/
final class DistributedIndexerLock implements IndexLock {
private final String lockName;
private volatile ClusteredLock clusteredLock;
private final Cache<?, ?> cache;
DistributedIndexerLock(Cache<?, ?> cache) {
this.cache = cache;
this.lockName = String.format("massIndexer-%s", cache.getName());
}
@Override
public CompletionStage<Boolean> lock() {
return getLock().tryLock();
}
@Override
public CompletionStage<Void> unlock() {
return getLock().unlock();
}
private ClusteredLock getLock() {
if (clusteredLock == null) {
synchronized (this) {
if (clusteredLock == null) {
ClusteredLockManager clusteredLockManager = EmbeddedClusteredLockManagerFactory.from(cache.getCacheManager());
boolean isDefined = clusteredLockManager.isDefined(lockName);
if (!isDefined) {
clusteredLockManager.defineLock(lockName);
}
clusteredLock = clusteredLockManager.get(lockName);
}
}
}
return clusteredLock;
}
}
| 1,543
| 29.27451
| 125
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/IndexWorker.java
|
package org.infinispan.query.impl.massindex;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Stream;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.context.Flag;
import org.infinispan.distribution.ch.KeyPartitioner;
import org.infinispan.encoding.DataConversion;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.impl.externalizers.ExternalizerIds;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
/**
* Mass indexer task.
*
* @author gustavonalle
* @since 7.1
*/
public final class IndexWorker implements Function<EmbeddedCacheManager, Void> {
private final String cacheName;
private final Collection<Class<?>> indexedTypes;
private final boolean skipIndex;
private final Set<Object> keys;
IndexWorker(String cacheName, Collection<Class<?>> indexedTypes, boolean skipIndex, Set<Object> keys) {
this.cacheName = cacheName;
this.indexedTypes = indexedTypes;
this.skipIndex = skipIndex;
this.keys = keys;
}
@Override
public Void apply(EmbeddedCacheManager embeddedCacheManager) {
AdvancedCache<Object, Object> cache = SecurityActions.getUnwrappedCache(embeddedCacheManager.getCache(cacheName)).getAdvancedCache();
DataConversion valueDataConversion = cache.getValueDataConversion();
AdvancedCache<Object, Object> reindexCache = cache.withStorageMediaType();
SearchMapping searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
TimeService timeService = ComponentRegistryUtils.getTimeService(cache);
MassIndexerProgressNotifier notifier = new MassIndexerProgressNotifier(searchMapping, timeService);
IndexUpdater indexUpdater = new IndexUpdater(searchMapping);
KeyPartitioner keyPartitioner = ComponentRegistryUtils.getKeyPartitioner(cache);
if (keys == null || keys.size() == 0) {
preIndex(cache, indexUpdater, notifier);
MassIndexerProgressState progressState = new MassIndexerProgressState(notifier);
if (!skipIndex) {
try (Stream<CacheEntry<Object, Object>> stream = reindexCache.getAdvancedCache().withFlags(Flag.CACHE_MODE_LOCAL)
.cacheEntrySet().stream()) {
stream.forEach(entry -> {
Object key = entry.getKey();
Object value = valueDataConversion.extractIndexable(entry.getValue());
int segment = keyPartitioner.getSegment(key);
if (value != null && indexedTypes.contains(indexUpdater.toConvertedEntityJavaClass(value))) {
progressState.addItem(key, value,
indexUpdater.updateIndex(key, value, segment));
}
});
}
}
postIndex(indexUpdater, progressState, notifier);
} else {
DataConversion keyDataConversion = cache.getKeyDataConversion();
Set<Class<?>> classSet = new HashSet<>(keys.size());
AggregateCompletionStage<Void> updates = CompletionStages.aggregateCompletionStage();
for (Object key : keys) {
Object storedKey = keyDataConversion.toStorage(key);
Object unwrappedKey = keyDataConversion.extractIndexable(storedKey);
Object value = cache.get(key);
if (value != null) {
updates.dependsOn(indexUpdater.updateIndex(unwrappedKey, value, keyPartitioner.getSegment(storedKey)));
classSet.add(value.getClass());
}
}
if (!classSet.isEmpty()) {
CompletableFutures.uncheckedAwait(updates.freeze().toCompletableFuture());
indexUpdater.flush(classSet);
indexUpdater.refresh(classSet);
}
}
return null;
}
private void preIndex(AdvancedCache<Object, Object> cache, IndexUpdater indexUpdater, MassIndexerProgressNotifier notifier) {
indexUpdater.purge(indexedTypes);
notifier.notifyPreIndexingReloading();
ComponentRegistryUtils.getSearchMapping(cache).reload();
notifier.notifyIndexingStarting();
}
private void postIndex(IndexUpdater indexUpdater, MassIndexerProgressState progressState, MassIndexerProgressNotifier notifier) {
progressState.waitForAsyncCompletion();
indexUpdater.flush(indexedTypes);
indexUpdater.refresh(indexedTypes);
notifier.notifyIndexingCompletedSuccessfully();
}
public static final class Externalizer extends AbstractExternalizer<IndexWorker> {
@Override
public Set<Class<? extends IndexWorker>> getTypeClasses() {
return Collections.singleton(IndexWorker.class);
}
@Override
public void writeObject(ObjectOutput output, IndexWorker worker) throws IOException {
output.writeObject(worker.cacheName);
if (worker.indexedTypes == null) {
output.writeInt(0);
} else {
output.writeInt(worker.indexedTypes.size());
for (Class<?> entityType : worker.indexedTypes)
output.writeObject(entityType);
}
output.writeBoolean(worker.skipIndex);
output.writeObject(worker.keys);
}
@Override
public IndexWorker readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String cacheName = (String) input.readObject();
int typesSize = input.readInt();
Set<Class<?>> types = new HashSet<>(typesSize);
for (int i = 0; i < typesSize; i++) {
types.add((Class<?>) input.readObject());
}
boolean skipIndex = input.readBoolean();
Set<Object> keys = (Set<Object>) input.readObject();
return new IndexWorker(cacheName, types, skipIndex, keys);
}
@Override
public Integer getId() {
return ExternalizerIds.INDEX_WORKER;
}
}
}
| 6,503
| 39.397516
| 139
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/LocalIndexerLock.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Semaphore;
import org.infinispan.commons.util.concurrent.CompletableFutures;
/**
* A lock to prevent multiple {@link org.infinispan.query.Indexer} in non-clustered environments.
* @since 10.1
*/
final class LocalIndexerLock implements IndexLock {
private final Semaphore lock = new Semaphore(1);
@Override
public CompletionStage<Boolean> lock() {
return CompletableFutures.booleanStage(lock.tryAcquire());
}
@Override
public CompletionStage<Void> unlock() {
lock.release();
return CompletableFutures.completedNull();
}
}
| 687
| 24.481481
| 97
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/MassIndexerProgressMonitor.java
|
package org.infinispan.query.impl.massindex;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import org.infinispan.commons.time.TimeService;
import org.infinispan.query.logging.Log;
import org.infinispan.util.logging.LogFactory;
/**
* @author Sanne Grinovero <sanne@hibernate.org> (C) 2012 Red Hat Inc.
*/
public class MassIndexerProgressMonitor {
private static final Log log = LogFactory.getLog(MassIndexerProgressMonitor.class, Log.class);
private final AtomicLong documentsDoneCounter = new AtomicLong();
private volatile long startTime;
private final int logAfterNumberOfDocuments;
private final TimeService timeService;
/**
* Logs progress of indexing job every 1000 documents written.
*/
public MassIndexerProgressMonitor(TimeService timeService) {
this(1000, timeService);
}
/**
* Logs progress of indexing job every <code>logAfterNumberOfDocuments</code>
* documents written.
*
* @param logAfterNumberOfDocuments
* log each time the specified number of documents has been added
*/
public MassIndexerProgressMonitor(int logAfterNumberOfDocuments, TimeService timeService) {
this.logAfterNumberOfDocuments = logAfterNumberOfDocuments;
this.timeService = timeService;
}
public void documentsAdded(long increment) {
long current = documentsDoneCounter.addAndGet(increment);
if (current == increment) {
startTime = timeService.time();
}
if (current % getStatusMessagePeriod() == 0) {
printStatusMessage(startTime, current);
}
}
public void preIndexingReloading() {
log.preIndexingReloading();
}
public void indexingStarting() {
log.indexingStarting();
}
public void indexingCompleted() {
log.indexingEntitiesCompleted(documentsDoneCounter.get(),
timeService.timeDuration(startTime, TimeUnit.MILLISECONDS));
}
protected int getStatusMessagePeriod() {
return logAfterNumberOfDocuments;
}
protected void printStatusMessage(long startTime, long doneCount) {
log.indexingDocumentsCompleted(doneCount, timeService.timeDuration(startTime, TimeUnit.MILLISECONDS));
}
}
| 2,242
| 30.152778
| 108
|
java
|
null |
infinispan-main/query/src/main/java/org/infinispan/query/impl/massindex/IndexUpdater.java
|
package org.infinispan.query.impl.massindex;
import java.util.Collection;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import org.infinispan.AdvancedCache;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.logging.Log;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.util.logging.LogFactory;
import net.jcip.annotations.NotThreadSafe;
/**
* Handle batch updates to an index.
*
* @author gustavonalle
* @since 7.1
*/
@NotThreadSafe
public class IndexUpdater {
private static final Log LOG = LogFactory.getLog(IndexUpdater.class, Log.class);
private static final Collection<Class<?>> PROTO_CLASSES = Set.of(new Class[]{byte[].class});
private final AdvancedCache<?, ?> cache;
private SearchMapping searchMapping;
public IndexUpdater(AdvancedCache<?, ?> cache) {
this.cache = cache;
}
public IndexUpdater(SearchMapping searchMapping) {
this.cache = null;
this.searchMapping = searchMapping;
}
public void flush(Collection<Class<?>> javaClasses) {
if (javaClasses.isEmpty()) {
return;
}
LOG.flushingIndex(getEntityTypes(javaClasses));
getSearchMapping().scope(javaClasses).workspace().flush();
}
public void refresh(Collection<Class<?>> javaClasses) {
if (javaClasses.isEmpty()) {
return;
}
LOG.flushingIndex(getEntityTypes(javaClasses));
getSearchMapping().scope(javaClasses).workspace().refresh();
}
public void purge(Collection<Class<?>> javaClasses) {
if (javaClasses.isEmpty()) {
return;
}
LOG.purgingIndex(getEntityTypes(javaClasses));
getSearchMapping().scope(javaClasses).workspace().purge();
}
public Collection<Class<?>> allJavaClasses() {
return getSearchMapping().allIndexedEntityJavaClasses();
}
public Class<?> toConvertedEntityJavaClass(Object value) {
return getSearchMapping().toConvertedEntityJavaClass(value);
}
public CompletableFuture<?> updateIndex(Object key, Object value, int segment) {
if (value == null || Thread.currentThread().isInterrupted()) {
return CompletableFuture.completedFuture(null);
}
return getSearchMapping().getSearchIndexer().addOrUpdate(key, String.valueOf(segment), value);
}
private String getEntityTypes(Collection<Class<?>> javaClasses) {
if (PROTO_CLASSES.equals(javaClasses)) {
return getSearchMapping().allIndexedEntityNames().toString();
}
return javaClasses.toString();
}
private SearchMapping getSearchMapping() {
if (searchMapping == null) {
searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
}
return searchMapping;
}
}
| 2,788
| 27.171717
| 100
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.