use of org.neo4j.kernel.impl.api.index.IndexProxy in project neo4j by neo4j.
the class FulltextIndexConsistencyCheckIT method mustDiscoverNodeInStoreMissingFromIndex.
@Test
void mustDiscoverNodeInStoreMissingFromIndex() throws Exception {
GraphDatabaseService db = createDatabase();
try (Transaction tx = db.beginTx()) {
tx.execute(format(NODE_CREATE, "nodes", asStrList("Label"), asStrList("prop"))).close();
tx.commit();
}
IndexDescriptor indexDescriptor;
long nodeId;
try (Transaction tx = db.beginTx()) {
tx.schema().awaitIndexesOnline(2, TimeUnit.MINUTES);
indexDescriptor = getFulltextIndexDescriptor(tx.schema().getIndexes());
Node node = tx.createNode(Label.label("Label"));
node.setProperty("prop", "value");
nodeId = node.getId();
tx.commit();
}
IndexingService indexes = getIndexingService(db);
IndexProxy indexProxy = indexes.getIndexProxy(indexDescriptor);
try (IndexUpdater updater = indexProxy.newUpdater(IndexUpdateMode.ONLINE, NULL)) {
updater.process(IndexEntryUpdate.remove(nodeId, indexDescriptor, Values.stringValue("value")));
}
managementService.shutdown();
ConsistencyCheckService.Result result = checkConsistency();
assertFalse(result.isSuccessful());
}
use of org.neo4j.kernel.impl.api.index.IndexProxy in project neo4j by neo4j.
the class IndexConfigMigrationIT method getIndexConfig.
private static Map<String, Value> getIndexConfig(GraphDatabaseAPI db, Transaction tx, String indexName) throws IndexNotFoundKernelException {
IndexingService indexingService = getIndexingService(db);
IndexDescriptor indexReference = schemaRead(tx).indexGetForName(indexName);
IndexProxy indexProxy = indexingService.getIndexProxy(indexReference);
return indexProxy.indexConfig();
}
use of org.neo4j.kernel.impl.api.index.IndexProxy in project neo4j by neo4j.
the class IndexConfigMigrationIT method getIndexConfig.
@SuppressWarnings("SameParameterValue")
private static Map<String, Value> getIndexConfig(GraphDatabaseAPI db, Transaction tx, Label label) throws IndexNotFoundKernelException {
IndexDefinitionImpl indexDefinition = (IndexDefinitionImpl) single(tx.schema().getIndexes(label));
IndexDescriptor index = indexDefinition.getIndexReference();
IndexingService indexingService = getIndexingService(db);
IndexProxy indexProxy = indexingService.getIndexProxy(index);
return indexProxy.indexConfig();
}
use of org.neo4j.kernel.impl.api.index.IndexProxy in project neo4j by neo4j.
the class RelationshipTypeIndexIT method assertContainIds.
private void assertContainIds(List<Long> expectedIds) throws IndexNotFoundKernelException {
int relationshipTypeId = getRelationshipTypeId();
IndexProxy indexProxy = getIndexProxy();
List<Long> actualIds = new ArrayList<>();
try (TokenIndexReader reader = indexProxy.newTokenReader()) {
SimpleEntityTokenClient tokenClient = new SimpleEntityTokenClient();
reader.query(tokenClient, unconstrained(), new TokenPredicate(relationshipTypeId), CursorContext.NULL);
while (tokenClient.next()) {
actualIds.add(tokenClient.reference);
}
}
expectedIds.sort(Long::compareTo);
actualIds.sort(Long::compareTo);
assertThat(actualIds).as("contains expected relationships").isEqualTo(expectedIds);
}
use of org.neo4j.kernel.impl.api.index.IndexProxy in project neo4j by neo4j.
the class ConstraintIndexCreator method createUniquenessConstraintIndex.
/**
* You MUST hold a label write lock before you call this method.
* However the label write lock is temporarily released while populating the index backing the constraint.
* It goes a little like this:
* <ol>
* <li>Prerequisite: Getting here means that there's an open schema transaction which has acquired the
* LABEL WRITE lock.</li>
* <li>Index schema rule which is backing the constraint is created in a nested mini-transaction
* which doesn't acquire any locking, merely adds tx state and commits so that the index rule is applied
* to the store, which triggers the index population</li>
* <li>Release the LABEL WRITE lock</li>
* <li>Await index population to complete</li>
* <li>Acquire the LABEL WRITE lock (effectively blocking concurrent transactions changing
* data related to this constraint, and it so happens, most other transactions as well) and verify
* the uniqueness of the built index</li>
* <li>Leave this method, knowing that the uniqueness constraint rule will be added to tx state
* and this tx committed, which will create the uniqueness constraint</li>
* </ol>
*/
public IndexDescriptor createUniquenessConstraintIndex(KernelTransactionImplementation transaction, IndexBackedConstraintDescriptor constraint, IndexPrototype prototype) throws TransactionFailureException, CreateConstraintFailureException, UniquePropertyValueValidationException, AlreadyConstrainedException {
String constraintString = constraint.userDescription(transaction.tokenRead());
log.info("Starting constraint creation: %s.", constraintString);
IndexDescriptor index;
SchemaRead schemaRead = transaction.schemaRead();
try {
index = checkAndCreateConstraintIndex(schemaRead, transaction.tokenRead(), constraint, prototype);
} catch (AlreadyConstrainedException e) {
throw e;
} catch (KernelException e) {
throw new CreateConstraintFailureException(constraint, e);
}
boolean success = false;
boolean reacquiredLabelLock = false;
Client locks = transaction.lockClient();
ResourceType keyType = constraint.schema().keyType();
long[] lockingKeys = constraint.schema().lockingKeys();
try {
locks.acquireShared(transaction.lockTracer(), keyType, lockingKeys);
IndexProxy proxy = indexingService.getIndexProxy(index);
// Release the LABEL WRITE lock during index population.
// At this point the integrity of the constraint to be created was checked
// while holding the lock and the index rule backing the soon-to-be-created constraint
// has been created. Now it's just the population left, which can take a long time
locks.releaseExclusive(keyType, lockingKeys);
awaitConstraintIndexPopulation(constraint, proxy, transaction);
log.info("Constraint %s populated, starting verification.", constraintString);
// Index population was successful, but at this point we don't know if the uniqueness constraint holds.
// Acquire LABEL WRITE lock and verify the constraints here in this user transaction
// and if everything checks out then it will be held until after the constraint has been
// created and activated.
locks.acquireExclusive(transaction.lockTracer(), keyType, lockingKeys);
reacquiredLabelLock = true;
try (NodePropertyAccessor propertyAccessor = new DefaultNodePropertyAccessor(transaction.newStorageReader(), transaction.cursorContext(), transaction.memoryTracker())) {
indexingService.getIndexProxy(index).verifyDeferredConstraints(propertyAccessor);
}
log.info("Constraint %s verified.", constraintString);
success = true;
return index;
} catch (IndexNotFoundKernelException e) {
String indexString = index.userDescription(transaction.tokenRead());
throw new TransactionFailureException(format("Index (%s) that we just created does not exist.", indexString), e);
} catch (IndexEntryConflictException e) {
throw new UniquePropertyValueValidationException(constraint, VERIFICATION, e, transaction.tokenRead());
} catch (InterruptedException | IOException e) {
throw new CreateConstraintFailureException(constraint, e);
} finally {
if (!success) {
if (!reacquiredLabelLock) {
locks.acquireExclusive(transaction.lockTracer(), keyType, lockingKeys);
}
if (indexStillExists(schemaRead, index)) {
dropUniquenessConstraintIndex(index);
}
}
}
}
Aggregations