org.neo4j.kernel.impl.index.schema.TokenIndexProvider Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* 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,
StorageEngineIndexingBehaviour indexingBehaviour) {
if (databaseIndexContext.readOnlyChecker.isReadOnly()) {
throw new UnsupportedOperationException("Can't create populator for read only index");
}
return new WorkSyncedIndexPopulator(new TokenIndexPopulator(
databaseIndexContext, indexFiles(descriptor), descriptor, openOptions, indexingBehaviour));
}
@Override
public IndexAccessor getOnlineAccessor(
IndexDescriptor descriptor,
IndexSamplingConfig samplingConfig,
TokenNameLookup tokenNameLookup,
ImmutableSet openOptions,
boolean readOnly,
StorageEngineIndexingBehaviour indexingBehaviour) {
return new TokenIndexAccessor(
databaseIndexContext,
indexFiles(descriptor),
descriptor,
recoveryCleanupWorkCollector,
openOptions,
readOnly,
indexingBehaviour);
}
@Override
public String getPopulationFailure(
IndexDescriptor descriptor, CursorContext cursorContext, ImmutableSet openOptions) {
try {
String failureMessage = TokenIndexes.readFailureMessage(
databaseIndexContext.pageCache,
storeFile(descriptor),
databaseIndexContext.databaseName,
cursorContext,
openOptions);
return defaultIfEmpty(failureMessage, StringUtils.EMPTY);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public InternalIndexState getInitialState(
IndexDescriptor descriptor, CursorContext cursorContext, ImmutableSet openOptions) {
try {
return TokenIndexes.readState(
databaseIndexContext.pageCache,
storeFile(descriptor),
databaseIndexContext.databaseName,
cursorContext,
openOptions);
} catch (MetadataMismatchException | IOException e) {
monitor.failedToOpenIndex(descriptor, "Requesting re-population.", e);
return InternalIndexState.POPULATING;
}
}
@Override
public StoreMigrationParticipant storeMigrationParticipant(
FileSystemAbstraction fs,
PageCache pageCache,
PageCacheTracer pageCacheTracer,
StorageEngineFactory storageEngineFactory,
CursorContextFactory contextFactory) {
return new TokenIndexMigrator(
"Token indexes",
fs,
pageCache,
pageCacheTracer,
storageEngineFactory,
databaseLayout,
this::storeFile,
contextFactory);
}
@Override
public IndexDescriptor completeConfiguration(
IndexDescriptor index, StorageEngineIndexingBehaviour indexingBehaviour) {
if (index.getCapability().equals(IndexCapability.NO_CAPABILITY)) {
boolean hasOrdering = !(index.schema().entityType().equals(EntityType.RELATIONSHIP)
&& indexingBehaviour.useNodeIdsInRelationshipTokenIndex());
index = index.withIndexCapability(capability(hasOrdering));
}
return index;
}
@Override
public void validatePrototype(IndexPrototype prototype) {
IndexType indexType = prototype.getIndexType();
if (indexType != IndexType.LOOKUP) {
throw new IllegalArgumentException("The '" + getProviderDescriptor().name()
+ "' index provider does not support " + indexType + " indexes: " + prototype);
}
if (!prototype.schema().isAnyTokenSchemaDescriptor()) {
throw new IllegalArgumentException("The " + prototype.schema()
+ " index schema is not an any-token index schema, which it is required to be for the '"
+ getProviderDescriptor().name() + "' index provider to be able to create an index.");
}
if (!prototype.getIndexProvider().equals(DESCRIPTOR)) {
throw new IllegalArgumentException("The '" + getProviderDescriptor().name()
+ "' index provider does not support " + prototype.getIndexProvider() + " indexes: " + prototype);
}
if (prototype.isUnique()) {
throw new IllegalArgumentException("The '" + getProviderDescriptor().name()
+ "' index provider does not support uniqueness indexes: " + prototype);
}
}
@Override
public IndexType getIndexType() {
return IndexType.LOOKUP;
}
private Path storeFile(SchemaRule schemaRule) {
IndexFiles indexFiles = indexFiles(schemaRule);
return indexFiles.getStoreFile();
}
private IndexFiles indexFiles(SchemaRule schemaRule) {
return indexFiles(schemaRule, databaseIndexContext.fileSystem, directoryStructure());
}
public static IndexFiles indexFiles(
SchemaRule schemaRule, FileSystemAbstraction fileSystem, IndexDirectoryStructure indexDirectoryStructure) {
return new IndexFiles(fileSystem, indexDirectoryStructure, schemaRule.getId());
}
public static IndexCapability capability(boolean supportsOrder) {
return new TokenIndexCapability(supportsOrder);
}
private static class TokenIndexCapability implements IndexCapability {
private final boolean supportsOrdering;
private TokenIndexCapability(boolean supportsOrdering) {
this.supportsOrdering = supportsOrdering;
}
@Override
public boolean supportsOrdering() {
return supportsOrdering;
}
@Override
public boolean supportsReturningValues() {
return true;
}
@Override
public boolean areValueCategoriesAccepted(ValueCategory... valueCategories) {
Preconditions.requireNonEmpty(valueCategories);
Preconditions.requireNoNullElements(valueCategories);
return false;
}
@Override
public boolean isQuerySupported(IndexQueryType queryType, ValueCategory valueCategory) {
return queryType == IndexQueryType.TOKEN_LOOKUP && valueCategory == ValueCategory.NO_CATEGORY;
}
@Override
public double getCostMultiplier(IndexQueryType... queryTypes) {
return COST_MULTIPLIER_STANDARD;
}
@Override
public boolean supportPartitionedScan(IndexQuery... queries) {
Preconditions.requireNonEmpty(queries);
Preconditions.requireNoNullElements(queries);
return queries.length == 1 && queries[0].type() == IndexQueryType.TOKEN_LOOKUP;
}
}
}