@Override public Void doWork( CommandState state ) { state.index.delete(); return null; } }
public void removeNodeIndex( String indexName ) { if ( !graphDb.index().existsForNodes( indexName ) ) { throw new NotFoundException( "No node index named '" + indexName + "'." ); } graphDb.index().forNodes( indexName ).delete(); }
@Deprecated @Description( "Remove an explicit index - YIELD type,name,config" ) @Procedure( name = "db.index.explicit.drop", mode = WRITE, deprecatedBy = EXPLICIT_INDEX_DEPRECATION ) public Stream<ExplicitIndexInfo> manualIndexDrop( @Name( "indexName" ) String explicitIndexName ) { IndexManager mgr = graphDatabaseAPI.index(); List<ExplicitIndexInfo> results = new ArrayList<>( 2 ); if ( mgr.existsForNodes( explicitIndexName ) ) { Index<Node> index = mgr.forNodes( explicitIndexName ); results.add( new ExplicitIndexInfo( "NODE", explicitIndexName, mgr.getConfiguration( index ) ) ); index.delete(); } if ( mgr.existsForRelationships( explicitIndexName ) ) { RelationshipIndex index = mgr.forRelationships( explicitIndexName ); results.add( new ExplicitIndexInfo( "RELATIONSHIP", explicitIndexName, mgr.getConfiguration( index ) ) ); index.delete(); } return results.stream(); }
@Test( expected = IllegalStateException.class ) public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex3() { restartTx(); index.delete(); index.query( key, "own" ); }
@Test public void deleteInOneTxShouldNotAffectTheOther() throws Exception { index.delete(); WorkThread firstTx = createWorker( "Single" ); firstTx.beginTransaction(); firstTx.createNodeAndIndexBy( key, "another value" ); firstTx.commit(); }
@Test public void shouldNotBeDeletedWhenDeletionRolledBack() { restartTx(); index.delete(); rollbackTx(); beginTx(); try ( IndexHits<Node> indexHits = index.get( key, value ) ) { //empty } }
@Test( expected = IllegalStateException.class ) public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex4() { restartTx(); index.delete(); Index<Node> newIndex = graphDb.index().forNodes( INDEX_NAME ); newIndex.query( key, "own" ); }
@Test public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex() { restartTx(); index.delete(); restartTx(); try { index.query( key, "own" ); fail( "Should fail" ); } catch ( NotFoundException e ) { assertThat( e.getMessage(), containsString( "doesn't exist" ) ); } }
@Test public void shouldThrowIllegalStateForActionsAfterDeletedOnIndex2() { restartTx(); index.delete(); restartTx(); try { index.add( node, key, value ); fail(); } catch ( NotFoundException e ) { assertThat( e.getMessage(), containsString( "doesn't exist" ) ); } }
@Before public void createInitialData() { beginTx(); index = graphDb.index().forNodes( INDEX_NAME ); index.delete(); restartTx(); index = graphDb.index().forNodes( INDEX_NAME ); key = "key"; value = "my own value"; node = graphDb.createNode(); index.add( node, key, value ); workers = new ArrayList<>(); }
@Test public void shouldBeAbleToDeleteAndRecreateIndex() { restartTx(); assertContains( index.query( key, "own" ) ); index.delete(); restartTx(); Index<Node> recreatedIndex = graphDb.index().forNodes( INDEX_NAME, LuceneIndexImplementation.FULLTEXT_CONFIG ); assertNull( recreatedIndex.get( key, value ).getSingle() ); recreatedIndex.add( node, key, value ); restartTx(); assertContains( recreatedIndex.query( key, "own" ), node ); recreatedIndex.delete(); }
@Test public void canDeleteIndexEvenIfEntitiesAreFoundToBeAbandonedInTheSameTx() { // create and index a node Index<Node> nodeIndex = graphDb.index().forNodes( "index" ); Node node = graphDb.createNode(); nodeIndex.add( node, "key", "value" ); // make sure to commit the creation of the entry restartTx(); // delete the node to abandon the index entry node.delete(); restartTx(); // iterate over all nodes indexed with the key to discover abandoned for ( Node ignore : nodeIndex.get( "key", "value" ) ) { } nodeIndex.delete(); restartTx(); }
private void makeSureAdditionsCanBeRemoved( boolean restartTx ) { Index<Node> index = nodeIndex( LuceneIndexImplementation.EXACT_CONFIG ); String key = "name"; String value = "Mattias"; assertNull( index.get( key, value ).getSingle() ); Node node = graphDb.createNode(); index.add( node, key, value ); if ( restartTx ) { restartTx(); } assertEquals( node, index.get( key, value ).getSingle() ); index.remove( node, key, value ); assertNull( index.get( key, value ).getSingle() ); restartTx(); assertNull( index.get( key, value ).getSingle() ); node.delete(); index.delete(); }
@Test public void removalOfRelationshipIndexDoesNotInfluenceNodeIndexWithSameName() { String indexName = "index"; createNodeExplicitIndexWithSingleNode( db, indexName ); createRelationshipExplicitIndexWithSingleRelationship( db, indexName ); try ( Transaction tx = db.beginTx() ) { Node node = db.createNode(); Index<Node> nodeIndex = db.index().forNodes( indexName ); nodeIndex.add( node, "key", "otherValue" ); Index<Relationship> relationshipIndex = db.index().forRelationships( indexName ); relationshipIndex.delete(); tx.success(); } try ( Transaction tx = db.beginTx() ) { assertFalse( db.index().existsForRelationships( indexName ) ); Index<Node> nodeIndex = db.index().forNodes( indexName ); assertEquals( 2, sizeOf( nodeIndex ) ); tx.success(); } }
@Test public void removalOfNodeIndexDoesNotInfluenceRelationshipIndexWithSameName() { String indexName = "index"; createNodeExplicitIndexWithSingleNode( db, indexName ); createRelationshipExplicitIndexWithSingleRelationship( db, indexName ); try ( Transaction tx = db.beginTx() ) { Relationship relationship = db.createNode().createRelationshipTo( db.createNode(), TYPE ); Index<Relationship> relationshipIndex = db.index().forRelationships( indexName ); relationshipIndex.add( relationship, "key", "otherValue" ); Index<Node> nodeIndex = db.index().forNodes( indexName ); nodeIndex.delete(); tx.success(); } try ( Transaction tx = db.beginTx() ) { assertFalse( db.index().existsForNodes( indexName ) ); Index<Relationship> relationshipIndex = db.index().forRelationships( indexName ); assertEquals( 2, sizeOf( relationshipIndex ) ); tx.success(); } }
@SuppressWarnings( "unchecked" ) private <T extends PropertyContainer> void makeSureAdditionsCanBeRead( Index<T> index, EntityCreator<T> entityCreator ) { String key = "name"; String value = "Mattias"; assertThat( index.get( key, value ).getSingle(), is( nullValue() ) ); assertThat( index.get( key, value ), emptyIterable() ); assertThat( index.query( key, "*" ), emptyIterable() ); T entity1 = entityCreator.create(); T entity2 = entityCreator.create(); index.add( entity1, key, value ); for ( int i = 0; i < 2; i++ ) { assertThat( index.get( key, value ), Contains.contains( entity1 ) ); assertThat( index.query( key, "*" ), Contains.contains( entity1 ) ); assertThat( index.get( key, value ), Contains.contains( entity1 ) ); restartTx(); } index.add( entity2, key, value ); assertThat( index.get( key, value ), Contains.contains( entity1, entity2 ) ); restartTx(); assertThat( index.get( key, value ), Contains.contains( entity1, entity2 ) ); index.delete(); }
@SuppressWarnings( "unchecked" ) private <T extends PropertyContainer> void doSomeRandomTestingWithFulltextIndex( Index<T> index, EntityCreator<T> creator ) { T entity1 = creator.create(); T entity2 = creator.create(); String key = "name"; index.add( entity1, key, "The quick brown fox" ); index.add( entity2, key, "brown fox jumped over" ); for ( int i = 0; i < 2; i++ ) { assertThat( index.get( key, "The quick brown fox" ), Contains.contains( entity1 ) ); assertThat( index.get( key, "brown fox jumped over" ), Contains.contains( entity2 ) ); assertThat( index.query( key, "quick" ), Contains.contains( entity1 ) ); assertThat( index.query( key, "brown" ), Contains.contains( entity1, entity2 ) ); assertThat( index.query( key, "quick OR jumped" ), Contains.contains( entity1, entity2 ) ); assertThat( index.query( key, "brown AND fox" ), Contains.contains( entity1, entity2 ) ); restartTx(); } index.delete(); }
@Test public void makeSureCompositeQueriesCanBeAsked() { Index<Node> index = nodeIndex( LuceneIndexImplementation.EXACT_CONFIG ); Node neo = graphDb.createNode(); Node trinity = graphDb.createNode(); index.add( neo, "username", "neo@matrix" ); index.add( neo, "sex", "male" ); index.add( trinity, "username", "trinity@matrix" ); index.add( trinity, "sex", "female" ); for ( int i = 0; i < 2; i++ ) { assertThat( index.query( "username:*@matrix AND sex:male" ), Contains.contains( neo ) ); assertThat( index.query( new QueryContext( "username:*@matrix sex:male" ).defaultOperator( Operator.AND ) ), Contains .contains( neo ) ); assertThat( index.query( "username:*@matrix OR sex:male" ), Contains.contains( neo, trinity ) ); assertThat( index.query( new QueryContext( "username:*@matrix sex:male" ).defaultOperator( Operator.OR ) ), Contains .contains( neo, trinity ) ); restartTx(); } index.delete(); }
@Test public void testSortByRelevance() { Index<Node> index = nodeIndex( LuceneIndexImplementation.EXACT_CONFIG ); Node node1 = graphDb.createNode(); Node node2 = graphDb.createNode(); Node node3 = graphDb.createNode(); index.add( node1, "name", "something" ); index.add( node2, "name", "something" ); index.add( node2, "foo", "yes" ); index.add( node3, "name", "something" ); index.add( node3, "foo", "yes" ); index.add( node3, "bar", "yes" ); restartTx(); IndexHits<Node> hits = index.query( new QueryContext( "+name:something foo:yes bar:yes" ).sort( Sort.RELEVANCE ) ); assertEquals( node3, hits.next() ); assertEquals( node2, hits.next() ); assertEquals( node1, hits.next() ); assertFalse( hits.hasNext() ); index.delete(); node1.delete(); node2.delete(); node3.delete(); }
@Test public void makeSureWildcardQueriesCanBeAsked() { Index<Node> index = nodeIndex( LuceneIndexImplementation.EXACT_CONFIG ); String key = "name"; String value1 = "neo4j"; String value2 = "nescafe"; Node node1 = graphDb.createNode(); Node node2 = graphDb.createNode(); index.add( node1, key, value1 ); index.add( node2, key, value2 ); for ( int i = 0; i < 2; i++ ) { assertThat( index.query( key, "neo*" ), Contains.contains( node1 ) ); assertThat( index.query( key, "n?o4j" ), Contains.contains( node1 ) ); assertThat( index.query( key, "ne*" ), Contains.contains( node1, node2 ) ); assertThat( index.query( key + ":neo4j" ), Contains.contains( node1 ) ); assertThat( index.query( key + ":neo*" ), Contains.contains( node1 ) ); assertThat( index.query( key + ":n?o4j" ), Contains.contains( node1 ) ); assertThat( index.query( key + ":ne*" ), Contains.contains( node1, node2 ) ); restartTx(); } index.delete(); }