Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.neo4j.kernel.api.impl.fulltext.FulltextIndexProvider Maven / Gradle / Ivy
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see openOptions) {
return defaultIfEmpty(getIndexStorage(descriptor.getId()).getStoredIndexFailure(), StringUtils.EMPTY);
}
@Override
public InternalIndexState getInitialState(
IndexDescriptor index, CursorContext cursorContext, ImmutableSet openOptions) {
PartitionedIndexStorage indexStorage = getIndexStorage(index.getId());
String failure = indexStorage.getStoredIndexFailure();
if (failure != null) {
return InternalIndexState.FAILED;
}
// Verify that the index configuration is still valid.
// For instance, that it doesn't refer to an analyzer that has since been removed.
try {
validateIndexRef(index);
} catch (Exception e) {
try {
indexStorage.storeIndexFailure(Exceptions.stringify(e));
} catch (IOException ex) {
ex.addSuppressed(e);
log.warn("Failed to persist index failure. Index failure added as suppressed exception.", ex);
}
return InternalIndexState.FAILED;
}
try {
return AbstractLuceneIndexProvider.indexIsOnline(indexStorage, index, config)
? InternalIndexState.ONLINE
: InternalIndexState.POPULATING;
} catch (IOException e) {
return InternalIndexState.POPULATING;
}
}
@Override
public MinimalIndexAccessor getMinimalIndexAccessor(IndexDescriptor descriptor, boolean forRebuildDuringRecovery) {
PartitionedIndexStorage indexStorage = getIndexStorage(descriptor.getId());
var index = new MinimalDatabaseIndex<>(indexStorage, descriptor, config);
log.debug("Creating dropper for fulltext schema index: %s", descriptor);
return new LuceneMinimalIndexAccessor<>(descriptor, index, isReadOnly());
}
private boolean isReadOnly() {
return readOnlyChecker.isReadOnly();
}
@Override
public IndexPopulator getPopulator(
IndexDescriptor descriptor,
IndexSamplingConfig samplingConfig,
ByteBufferFactory bufferFactory,
MemoryTracker memoryTracker,
TokenNameLookup tokenNameLookup,
ImmutableSet openOptions,
StorageEngineIndexingBehaviour indexingBehaviour) {
if (isReadOnly()) {
throw new UnsupportedOperationException("Can't create populator for read only index");
}
try {
PartitionedIndexStorage indexStorage = getIndexStorage(descriptor.getId());
Analyzer analyzer = FulltextIndexAnalyzerLoader.INSTANCE.createAnalyzer(descriptor, tokenNameLookup);
String[] propertyNames = createPropertyNames(descriptor, tokenNameLookup);
DatabaseIndex fulltextIndex = FulltextIndexBuilder.create(
descriptor,
config,
readOnlyChecker,
tokenHolders.propertyKeyTokens(),
analyzer,
propertyNames)
.withFileSystem(fileSystem)
.withIndexStorage(indexStorage)
.withPopulatingMode(true)
.build();
log.debug("Creating populator for fulltext schema index: %s", descriptor);
return new FulltextIndexPopulator(descriptor, fulltextIndex, propertyNames, UPDATE_IGNORE_STRATEGY);
} catch (Exception e) {
PartitionedIndexStorage indexStorage = getIndexStorage(descriptor.getId());
var index = new MinimalDatabaseIndex(indexStorage, descriptor, config);
log.debug("Creating failed index populator for fulltext schema index: %s", descriptor, e);
return new FailedFulltextIndexPopulator(descriptor, index, e);
}
}
@Override
public IndexAccessor getOnlineAccessor(
IndexDescriptor index,
IndexSamplingConfig samplingConfig,
TokenNameLookup tokenNameLookup,
ImmutableSet openOptions,
boolean readOnly,
StorageEngineIndexingBehaviour indexingBehaviour)
throws IOException {
PartitionedIndexStorage indexStorage = getIndexStorage(index.getId());
Analyzer analyzer = FulltextIndexAnalyzerLoader.INSTANCE.createAnalyzer(index, tokenHolders);
String[] propertyNames = createPropertyNames(index, tokenHolders);
FulltextIndexBuilder fulltextIndexBuilder = FulltextIndexBuilder.create(
index, config, readOnlyChecker, tokenHolders.propertyKeyTokens(), analyzer, propertyNames)
.withFileSystem(fileSystem)
.withIndexStorage(indexStorage)
.withPopulatingMode(false);
if (isEventuallyConsistent(index)) {
fulltextIndexBuilder = fulltextIndexBuilder.withIndexUpdateSink(indexUpdateSink);
}
if (readOnly) {
fulltextIndexBuilder = fulltextIndexBuilder.permanentlyReadOnly();
}
DatabaseIndex fulltextIndex = fulltextIndexBuilder.build();
fulltextIndex.open();
FulltextIndexAccessor accessor = new FulltextIndexAccessor(
indexUpdateSink, fulltextIndex, index, propertyNames, UPDATE_IGNORE_STRATEGY, config, scheduler);
log.debug("Created online accessor for fulltext schema index %s: %s", index, accessor);
return accessor;
}
@Override
public StoreMigrationParticipant storeMigrationParticipant(
final FileSystemAbstraction fs,
PageCache pageCache,
PageCacheTracer pageCacheTracer,
StorageEngineFactory storageEngineFactory,
CursorContextFactory contextFactory) {
return new SchemaIndexMigrator(
"Fulltext indexes",
fs,
pageCache,
pageCacheTracer,
this.directoryStructure(),
storageEngineFactory,
contextFactory);
}
@Override
public IndexPrototype validatePrototype(IndexPrototype prototype) {
validateIndexRef(prototype);
return prototype;
}
@Override
public IndexType getIndexType() {
return IndexType.FULLTEXT;
}
private void validateIndexRef(IndexRef ref) {
String providerName = getProviderDescriptor().name();
if (ref.getIndexType() != IndexType.FULLTEXT) {
throw new IllegalArgumentException(
"The '" + providerName + "' index provider only supports FULLTEXT index types: " + ref);
}
if (!ref.schema().isSchemaDescriptorType(FulltextSchemaDescriptor.class)) {
throw new IllegalArgumentException("The " + ref.schema() + " index schema is not a full-text index schema, "
+ "which it is required to be for the '" + providerName
+ "' index provider to be able to create an index.");
}
Value value = ref.getIndexConfig().get(ANALYZER);
if (value != null) {
if (value.valueGroup() == ValueGroup.TEXT) {
String analyzerName = ((TextValue) value).stringValue();
Optional analyzerProvider = listAvailableAnalyzers()
.filter(analyzer -> analyzer.getName().equals(analyzerName))
.findFirst();
if (analyzerProvider.isPresent()) {
// Verify that the analyzer provider works.
Analyzer analyzer = analyzerProvider.get().createAnalyzer();
Objects.requireNonNull(analyzer, "The '" + analyzerName + "' analyzer returned a 'null' analyzer.");
} else {
throw new IllegalArgumentException("No such full-text analyzer: '" + analyzerName + "'.");
}
} else {
throw new IllegalArgumentException(
"Wrong index setting value type for fulltext analyzer: '" + value + "'.");
}
}
TokenHolder propertyKeyTokens = tokenHolders.propertyKeyTokens();
for (int propertyId : ref.schema().getPropertyIds()) {
try {
NamedToken token = propertyKeyTokens.getTokenById(propertyId);
if (token.name().equals(LuceneFulltextDocumentStructure.FIELD_ENTITY_ID)) {
throw new IllegalArgumentException(
"Unable to index the property, the name is reserved for internal use "
+ LuceneFulltextDocumentStructure.FIELD_ENTITY_ID);
}
} catch (TokenNotFoundException e) {
throw new IllegalArgumentException(
"Schema references non-existing property key token id: " + propertyId + ".", e);
}
}
}
private IndexConfig addMissingDefaultIndexConfig(IndexConfig indexConfig) {
indexConfig = indexConfig.withIfAbsent(ANALYZER, Values.stringValue(defaultAnalyzerName));
indexConfig = indexConfig.withIfAbsent(
FulltextIndexSettingsKeys.EVENTUALLY_CONSISTENT,
Values.booleanValue(defaultEventuallyConsistentSetting));
return indexConfig;
}
public void awaitRefresh() {
indexUpdateSink.awaitUpdateApplication();
}
public Stream listAvailableAnalyzers() {
return Services.loadAll(AnalyzerProvider.class).stream();
}
}
