Unnamed: 0
int64 0
6.7k
| func
stringlengths 12
89.6k
| target
bool 2
classes | project
stringlengths 45
151
|
|---|---|---|---|
1,300
|
private static class Worker extends OtherThreadExecutor<State>
{
public Worker( String name, State initialState )
{
super( name, initialState );
}
public boolean hasProperty( final String key ) throws Exception
{
return execute( new WorkerCommand<State, Boolean>()
{
@Override
public Boolean doWork( State state )
{
return state.properties.hasProperty( key );
}
} );
}
public void commitTx() throws Exception
{
execute( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.tx.success();
state.tx.finish();
return null;
}
} );
}
void beginTx() throws Exception
{
execute( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.tx = state.db.beginTx();
return null;
}
} );
}
Future<Void> setProperty( final String key, final Object value ) throws Exception
{
return executeDontWait( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.properties.setProperty( key, value );
return null;
}
} );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestGraphProperties.java
|
1,301
|
private static class State
{
private final GraphDatabaseAPI db;
private final PropertyContainer properties;
private Transaction tx;
State( GraphDatabaseAPI db )
{
this.db = db;
this.properties = getGraphProperties( db );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestGraphProperties.java
|
1,302
|
public class TestGraphProperties
{
@Rule public EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
private TestGraphDatabaseFactory factory;
@Before
public void before() throws Exception
{
factory = new TestGraphDatabaseFactory().setFileSystem( fs.get() );
}
@Test
public void basicProperties() throws Exception
{
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
PropertyContainer graphProperties = properties( db );
assertThat( graphProperties, inTx( db, not( hasProperty( "test" ) ) ) );
Transaction tx = db.beginTx();
graphProperties.setProperty( "test", "yo" );
assertEquals( "yo", graphProperties.getProperty( "test" ) );
tx.success();
tx.finish();
assertThat( graphProperties, inTx( db, hasProperty( "test" ).withValue( "yo" ) ) );
tx = db.beginTx();
assertNull( graphProperties.removeProperty( "something non existent" ) );
assertEquals( "yo", graphProperties.removeProperty( "test" ) );
assertNull( graphProperties.getProperty( "test", null ) );
graphProperties.setProperty( "other", 10 );
assertEquals( 10, graphProperties.getProperty( "other" ) );
graphProperties.setProperty( "new", "third" );
tx.success();
tx.finish();
assertThat( graphProperties, inTx( db, not( hasProperty( "test" ) ) ) );
assertThat( graphProperties, inTx( db, hasProperty( "other" ).withValue( 10 ) ) );
assertThat( getPropertyKeys( db, graphProperties ), containsOnly( "other", "new" ) );
tx = db.beginTx();
graphProperties.setProperty( "rollback", true );
assertEquals( true, graphProperties.getProperty( "rollback" ) );
tx.finish();
assertThat( graphProperties, inTx( db, not( hasProperty( "rollback" ) ) ) );
db.shutdown();
}
@Test
public void setManyGraphProperties() throws Exception
{
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
Transaction tx = db.beginTx();
Object[] values = new Object[]{10, "A string value", new float[]{1234.567F, 7654.321F},
"A rather longer string which wouldn't fit inlined #!)(&¤"};
int count = 200;
for ( int i = 0; i < count; i++ )
{
properties( db ).setProperty( "key" + i, values[i % values.length] );
}
tx.success();
tx.finish();
for ( int i = 0; i < count; i++ )
{
assertThat( properties( db ), inTx( db, hasProperty( "key" + i ).withValue( values[i % values.length] ) ) );
}
nodeManager( db ).clearCache();
for ( int i = 0; i < count; i++ )
{
assertThat( properties( db ), inTx( db, hasProperty( "key" + i ).withValue( values[i % values.length] ) ) );
}
db.shutdown();
}
private static NodeManager nodeManager( GraphDatabaseAPI db )
{
return db.getDependencyResolver().resolveDependency( NodeManager.class );
}
@Test
public void setBigArrayGraphProperty() throws Exception
{
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
long[] array = new long[1000];
for ( int i = 0; i < 10; i++ )
{
array[array.length / 10 * i] = i;
}
String key = "big long array";
Transaction tx = db.beginTx();
properties( db ).setProperty( key, array );
assertThat( properties( db ), hasProperty( key ).withValue( array ) );
tx.success();
tx.finish();
assertThat( properties( db ), inTx( db, hasProperty( key ).withValue( array ) ) );
nodeManager( db ).clearCache();
assertThat( properties( db ), inTx( db, hasProperty( key ).withValue( array ) ) );
db.shutdown();
}
private PropertyContainer properties( GraphDatabaseAPI db )
{
return nodeManager( db ).getGraphProperties();
}
@Test
public void firstRecordOtherThanZeroIfNotFirst() throws Exception
{
String storeDir = forTest( getClass()).cleanDirectory( "zero" ).getAbsolutePath();
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase( storeDir );
Transaction tx = db.beginTx();
Node node = db.createNode();
node.setProperty( "name", "Yo" );
tx.success();
tx.finish();
db.shutdown();
db = (GraphDatabaseAPI) factory.newImpermanentDatabase( storeDir );
tx = db.beginTx();
nodeManager( db ).getGraphProperties().setProperty( "test", "something" );
tx.success();
tx.finish();
db.shutdown();
NeoStore neoStore = new StoreFactory( new Config( Collections.<String, String>emptyMap(),
GraphDatabaseSettings.class ),
new DefaultIdGeneratorFactory(), new DefaultWindowPoolFactory(), fs.get(), StringLogger.DEV_NULL,
null ).newNeoStore( new File( storeDir, NeoStore.DEFAULT_NAME ) );
long prop = neoStore.getGraphNextProp();
assertTrue( prop != 0 );
neoStore.close();
}
@Test
public void graphPropertiesAreLockedPerTx() throws Exception
{
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
Worker worker1 = new Worker( "W1", new State( db ) );
Worker worker2 = new Worker( "W2", new State( db ) );
PropertyContainer properties = getGraphProperties( db );
worker1.beginTx();
worker2.beginTx();
String key1 = "name";
String value1 = "Value 1";
String key2 = "some other property";
String value2 = "Value 2";
String key3 = "say";
String value3 = "hello";
worker1.setProperty( key1, value1 ).get();
assertThat( properties, inTx( db, not( hasProperty( key1 ) ) ) );
assertFalse( worker2.hasProperty( key1 ) );
Future<Void> blockedSetProperty = worker2.setProperty( key2, value2 );
assertThat( properties, inTx( db, not( hasProperty( key1 ) ) ) );
assertThat( properties, inTx( db, not( hasProperty( key2 ) ) ) );
worker1.setProperty( key3, value3 ).get();
assertFalse( blockedSetProperty.isDone() );
assertThat( properties, inTx( db, not( hasProperty( key1 ) ) ) );
assertThat( properties, inTx( db, not( hasProperty( key2 ) ) ) );
assertThat( properties, inTx( db, not( hasProperty( key3 ) ) ) );
worker1.commitTx();
assertThat( properties, inTx( db, hasProperty( key1 ) ) );
assertThat( properties, inTx( db, not( hasProperty( key2 ) ) ) );
assertThat( properties, inTx( db, hasProperty( key3 ) ) );
blockedSetProperty.get();
assertTrue( blockedSetProperty.isDone() );
worker2.commitTx();
assertThat( properties, inTx( db, hasProperty( key1 ).withValue( value1 ) ) );
assertThat( properties, inTx( db, hasProperty( key2 ).withValue( value2 ) ) );
assertThat( properties, inTx( db, hasProperty( key3 ).withValue( value3 ) ) );
worker1.close();
worker2.close();
db.shutdown();
}
@Test
public void upgradeDoesntAccidentallyAssignPropertyChainZero() throws Exception
{
EphemeralFileSystemAbstraction fileSystem = new EphemeralFileSystemAbstraction();
TestGraphDatabaseFactory factory = new TestGraphDatabaseFactory().setFileSystem( fileSystem );
String storeDir = new File( "test" ).getAbsolutePath();
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase( storeDir );
Transaction tx = db.beginTx();
Node node = db.createNode();
node.setProperty( "name", "Something" );
tx.success();
tx.finish();
db.shutdown();
truncateNeoStoreTo5Records( fileSystem, storeDir );
db = (GraphDatabaseAPI) factory.newImpermanentDatabase( storeDir );
PropertyContainer properties = nodeManager( db ).getGraphProperties();
assertThat( getPropertyKeys( db, properties ), isEmpty() );
tx = db.beginTx();
properties.setProperty( "a property", "a value" );
tx.success();
tx.finish();
nodeManager( db ).clearCache();
assertThat( properties, inTx( db, hasProperty( "a property" ).withValue( "a value" ) ) );
db.shutdown();
db = (GraphDatabaseAPI) factory.newImpermanentDatabase( storeDir );
properties = nodeManager( db ).getGraphProperties();
assertThat( properties, inTx( db, hasProperty( "a property" ).withValue( "a value" ) ) );
db.shutdown();
fileSystem.shutdown();
}
private void truncateNeoStoreTo5Records( FileSystemAbstraction fileSystem, String storeDir ) throws IOException
{
// Remove the last record, next startup will look like as if we're upgrading an old store
File neoStoreFile = new File( storeDir, NeoStore.DEFAULT_NAME );
StoreChannel channel = fileSystem.open( neoStoreFile, "rw" );
channel.position( NeoStore.RECORD_SIZE * 7/*position of "next prop"*/ );
int trail = (int) (channel.size() - channel.position());
ByteBuffer trailBuffer = null;
if ( trail > 0 )
{
trailBuffer = ByteBuffer.allocate( trail );
channel.read( trailBuffer );
trailBuffer.flip();
}
channel.position( NeoStore.RECORD_SIZE * 5 );
if ( trail > 0 )
{
channel.write( trailBuffer );
}
channel.truncate( channel.position() );
}
@Test
public void twoUncleanInARow() throws Exception
{
String storeDir = "dir";
EphemeralFileSystemAbstraction snapshot = produceUncleanStore( fs.get(), storeDir );
snapshot = produceUncleanStore( snapshot, storeDir );
snapshot = produceUncleanStore( snapshot, storeDir );
GraphDatabaseAPI db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().setFileSystem( snapshot ).newImpermanentDatabase( storeDir );
assertThat( nodeManager( db ).getGraphProperties(), inTx( db, hasProperty( "prop" ).withValue( "Some value" ) ) );
db.shutdown();
}
@Test
public void testEquals()
{
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
GraphProperties graphProperties = nodeManager( db ).getGraphProperties();
Transaction tx = db.beginTx();
try
{
graphProperties.setProperty( "test", "test" );
tx.success();
}
finally
{
tx.finish();
}
assertEquals( graphProperties, nodeManager( db ).getGraphProperties() );
db.shutdown();
db = (GraphDatabaseAPI) factory.newImpermanentDatabase();
assertFalse( graphProperties.equals( nodeManager( db ).getGraphProperties() ) );
}
private static class State
{
private final GraphDatabaseAPI db;
private final PropertyContainer properties;
private Transaction tx;
State( GraphDatabaseAPI db )
{
this.db = db;
this.properties = getGraphProperties( db );
}
}
private static GraphProperties getGraphProperties( GraphDatabaseAPI db )
{
return nodeManager( db ).getGraphProperties();
}
private static class Worker extends OtherThreadExecutor<State>
{
public Worker( String name, State initialState )
{
super( name, initialState );
}
public boolean hasProperty( final String key ) throws Exception
{
return execute( new WorkerCommand<State, Boolean>()
{
@Override
public Boolean doWork( State state )
{
return state.properties.hasProperty( key );
}
} );
}
public void commitTx() throws Exception
{
execute( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.tx.success();
state.tx.finish();
return null;
}
} );
}
void beginTx() throws Exception
{
execute( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.tx = state.db.beginTx();
return null;
}
} );
}
Future<Void> setProperty( final String key, final Object value ) throws Exception
{
return executeDontWait( new WorkerCommand<State, Void>()
{
@Override
public Void doWork( State state )
{
state.properties.setProperty( key, value );
return null;
}
} );
}
}
private EphemeralFileSystemAbstraction produceUncleanStore( EphemeralFileSystemAbstraction fileSystem,
String storeDir )
{
GraphDatabaseService db = new TestGraphDatabaseFactory().setFileSystem( fileSystem ).newImpermanentDatabase( storeDir );
Transaction tx = db.beginTx();
Node node = db.createNode();
node.setProperty( "name", "Something" );
nodeManager( ((GraphDatabaseAPI)db) ).getGraphProperties().setProperty( "prop", "Some value" );
tx.success();
tx.finish();
EphemeralFileSystemAbstraction snapshot = fileSystem.snapshot();
db.shutdown();
return snapshot;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestGraphProperties.java
|
1,303
|
public class TestDynamicStore
{
public static IdGeneratorFactory ID_GENERATOR_FACTORY =
new DefaultIdGeneratorFactory();
public static WindowPoolFactory WINDOW_POOL_FACTORY =
new DefaultWindowPoolFactory();
@Rule public EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
private File path()
{
String path = "dynamicstore";
File file = new File( path );
fs.get().mkdirs( file );
return file;
}
private File file( String name )
{
return new File( path(), name);
}
private File dynamicStoreFile()
{
return file( "testDynamicStore.db" );
}
private File dynamicStoreIdFile()
{
return file( "testDynamicStore.db.id" );
}
@Test
public void testCreateStore()
{
try
{
try
{
createEmptyStore( null, 1 );
fail( "Null fileName should throw exception" );
}
catch ( IllegalArgumentException e )
{ // good
}
try
{
createEmptyStore( dynamicStoreFile(), 0 );
fail( "Illegal blocksize should throw exception" );
}
catch ( IllegalArgumentException e )
{ // good
}
createEmptyStore( dynamicStoreFile(), 15 );
try
{
createEmptyStore( dynamicStoreFile(), 15 );
fail( "Creating existing store should throw exception" );
}
catch ( IllegalStateException e )
{ // good
}
}
finally
{
deleteBothFiles();
}
}
private void createEmptyStore( File fileName, int blockSize )
{
new StoreFactory( config(), ID_GENERATOR_FACTORY, new DefaultWindowPoolFactory(), fs.get(),
StringLogger.DEV_NULL, null ).createDynamicArrayStore( fileName, blockSize );
}
private DynamicArrayStore newStore()
{
return new DynamicArrayStore( dynamicStoreFile(), config(), IdType.ARRAY_BLOCK, ID_GENERATOR_FACTORY,
WINDOW_POOL_FACTORY, fs.get(), StringLogger.DEV_NULL );
}
private void deleteBothFiles()
{
File file = dynamicStoreFile();
if ( file.exists() )
{
assertTrue( file.delete() );
}
file = dynamicStoreIdFile();
if ( file.exists() )
{
assertTrue( file.delete() );
}
}
@Test
public void testStickyStore() throws IOException
{
try
{
createEmptyStore( dynamicStoreFile(), 30 );
StoreChannel fileChannel = fs.get().open( dynamicStoreFile(), "rw" );
fileChannel.truncate( fileChannel.size() - 2 );
fileChannel.close();
DynamicArrayStore store = newStore();
store.makeStoreOk();
store.close();
}
finally
{
deleteBothFiles();
}
}
private Config config()
{
return new Config( MapUtil.stringMap(
"neo_store", dynamicStoreFile().getPath(),
"store_dir", path().getPath() ), GraphDatabaseSettings.class );
}
@Test
public void testClose()
{
try
{
createEmptyStore( dynamicStoreFile(), 30 );
DynamicArrayStore store = newStore();
Collection<DynamicRecord> records = store.allocateRecordsFromBytes( new byte[10] );
long blockId = first( records ).getId();
for ( DynamicRecord record : records )
{
store.updateRecord( record );
}
store.close();
/*
* try { store.allocateRecords( blockId, new byte[10] ); fail(
* "Closed store should throw exception" ); } catch (
* RuntimeException e ) { // good }
*/
try
{
store.getArrayFor( store.getRecords( blockId ) );
fail( "Closed store should throw exception" );
}
catch ( RuntimeException e )
{ // good
}
try
{
store.getLightRecords( 0 );
fail( "Closed store should throw exception" );
}
catch ( RuntimeException e )
{ // good
}
}
finally
{
deleteBothFiles();
}
}
@Test
public void testStoreGetCharsFromString()
{
try
{
final String STR = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
createEmptyStore( dynamicStoreFile(), 30 );
DynamicArrayStore store = newStore();
char[] chars = new char[STR.length()];
STR.getChars( 0, STR.length(), chars, 0 );
Collection<DynamicRecord> records = store.allocateRecords( chars );
for ( DynamicRecord record : records )
{
store.updateRecord( record );
}
// assertEquals( STR, new String( store.getChars( blockId ) ) );
store.close();
}
finally
{
deleteBothFiles();
}
}
@Test
public void testRandomTest()
{
Random random = new Random( System.currentTimeMillis() );
createEmptyStore( dynamicStoreFile(), 30 );
DynamicArrayStore store = newStore();
ArrayList<Long> idsTaken = new ArrayList<Long>();
Map<Long, byte[]> byteData = new HashMap<Long, byte[]>();
float deleteIndex = 0.2f;
float closeIndex = 0.1f;
int currentCount = 0;
int maxCount = 128;
Set<Long> set = new HashSet<Long>();
try
{
while ( currentCount < maxCount )
{
float rIndex = random.nextFloat();
if ( rIndex < deleteIndex && currentCount > 0 )
{
long blockId = idsTaken.remove(
random.nextInt( currentCount ) );
store.getLightRecords( blockId );
byte[] bytes = (byte[]) store.getArrayFor( store.getRecords( blockId ) );
validateData( bytes, byteData.remove( blockId ) );
Collection<DynamicRecord> records = store
.getLightRecords( blockId );
for ( DynamicRecord record : records )
{
record.setInUse( false );
store.updateRecord( record );
set.remove( record.getId() );
}
currentCount--;
}
else
{
byte bytes[] = createRandomBytes( random );
Collection<DynamicRecord> records = store.allocateRecords( bytes );
for ( DynamicRecord record : records )
{
assert !set.contains( record.getId() );
store.updateRecord( record );
set.add( record.getId() );
}
long blockId = first( records ).getId();
idsTaken.add( blockId );
byteData.put( blockId, bytes );
currentCount++;
}
if ( rIndex > (1.0f - closeIndex) || rIndex < closeIndex )
{
store.close();
store = newStore();
}
}
}
finally
{
store.close();
deleteBothFiles();
}
}
// private static class ByteStore extends AbstractDynamicStore
// {
// // store version, each store ends with this string (byte encoded)
// private static final String VERSION = "DynamicTestVersion v0.1";
//
// public ByteStore( String fileName, IdGeneratorFactory idGenerator, String storeDir )
// {
// super( fileName, MapUtil.map( "neo_store", fileName,
// IdGeneratorFactory.class, idGenerator, "store_dir", storeDir ), IdType.ARRAY_BLOCK );
// }
//
// public String getTypeDescriptor()
// {
// return VERSION;
// }
//
// public static ByteStore createStore( String fileName, int blockSize, String storeDir )
// {
// createEmptyStore( fileName, blockSize, VERSION, ID_GENERATOR_FACTORY,
// IdType.ARRAY_BLOCK );
// return new ByteStore( fileName, ID_GENERATOR_FACTORY, storeDir );
// }
//
// public byte[] getBytes( long blockId )
// {
// return null;
//// return get( blockId );
// }
//
// // public char[] getChars( int blockId ) throws IOException
// // {
// // return getAsChar( blockId );
// // }
//
//// public void flush()
//// {
//// }
// }
private byte[] createBytes( int length )
{
return new byte[length];
}
private byte[] createRandomBytes( Random r )
{
return new byte[r.nextInt( 1024 )];
}
private void validateData( byte data1[], byte data2[] )
{
assertEquals( data1.length, data2.length );
for ( int i = 0; i < data1.length; i++ )
{
assertEquals( data1[i], data2[i] );
}
}
private long create( DynamicArrayStore store, Object arrayToStore )
{
Collection<DynamicRecord> records = store.allocateRecords( arrayToStore );
for ( DynamicRecord record : records )
{
store.updateRecord( record );
}
return first( records ).getId();
}
@Test
public void testAddDeleteSequenceEmptyNumberArray()
{
createEmptyStore( dynamicStoreFile(), 30 );
DynamicArrayStore store = newStore();
try
{
byte[] emptyToWrite = createBytes( 0 );
long blockId = create( store, emptyToWrite );
store.getLightRecords( blockId );
byte[] bytes = (byte[]) store.getArrayFor( store.getRecords( blockId ) );
assertEquals( 0, bytes.length );
Collection<DynamicRecord> records = store.getLightRecords( blockId );
for ( DynamicRecord record : records )
{
record.setInUse( false );
store.updateRecord( record );
}
}
finally
{
store.close();
deleteBothFiles();
}
}
@Test
public void testAddDeleteSequenceEmptyStringArray()
{
createEmptyStore( dynamicStoreFile(), 30 );
DynamicArrayStore store = newStore();
try
{
long blockId = create( store, new String[0] );
store.getLightRecords( blockId );
String[] readBack = (String[]) store.getArrayFor( store.getRecords( blockId ) );
assertEquals( 0, readBack.length );
Collection<DynamicRecord> records = store.getLightRecords( blockId );
for ( DynamicRecord record : records )
{
record.setInUse( false );
store.updateRecord( record );
}
}
finally
{
store.close();
deleteBothFiles();
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestDynamicStore.java
|
1,304
|
public class TestBrokenStoreRecovery
{
private void trimFileToSize( File theFile, int toSize )
throws IOException
{
FileChannel theChannel = new RandomAccessFile( theFile, "rw" ).getChannel();
theChannel.truncate( toSize );
theChannel.force( false );
theChannel.close();
}
/**
* Creates a store with a truncated property store file that remains like
* that during recovery by truncating the logical log as well. Id
* regeneration should proceed without exceptions, even though the last
* property record is incomplete.
*
* @throws Exception
*/
@Test
public void testTruncatedPropertyStore() throws Exception
{
File storeDir = TargetDirectory.forTest(
TestBrokenStoreRecovery.class ).cleanDirectory( "propertyStore"
);
Process process = Runtime.getRuntime().exec(
new String[]{
"java", "-cp",
System.getProperty( "java.class.path" ),
ProduceUncleanStore.class.getName(),
storeDir.getAbsolutePath()
} );
assertEquals(
0,
new ProcessStreamHandler( process, true ).waitForResult() );
trimFileToSize( new File( storeDir, "neostore.propertystore.db" ), 42 );
File log = new File( storeDir, "nioneo_logical.log.1" );
trimFileToSize( log, 78 );
new GraphDatabaseFactory().newEmbeddedDatabase( storeDir.getAbsolutePath() ).shutdown();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestBrokenStoreRecovery.java
|
1,305
|
public class TestArrayStore
{
private File dir;
private DynamicArrayStore arrayStore;
@Before
public void before() throws Exception
{
dir = TargetDirectory.forTest( getClass() ).cleanDirectory( "db" );
Map<String, String> configParams = MapUtil.stringMap();
Config config = new Config( configParams );
DefaultIdGeneratorFactory idGeneratorFactory = new DefaultIdGeneratorFactory();
DefaultFileSystemAbstraction fs = new DefaultFileSystemAbstraction();
StoreFactory factory = new StoreFactory( config,
idGeneratorFactory, new DefaultWindowPoolFactory(), fs, StringLogger.DEV_NULL, new DefaultTxHook() );
File fileName = new File( dir, "arraystore" );
factory.createDynamicArrayStore( fileName, 120 );
arrayStore = new DynamicArrayStore( fileName, config, IdType.ARRAY_BLOCK, idGeneratorFactory,
new DefaultWindowPoolFactory(), fs, StringLogger.DEV_NULL );
}
@After
public void after() throws Exception
{
if ( arrayStore != null )
arrayStore.close();
}
@Test
public void intArrayPropertiesShouldBeBitPacked() throws Exception
{
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new int[] { 1, 2, 3, 4, 5, 6, 7 }, PropertyType.INT, 3, 1 );
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new int[] { 1, 2, 3, 4, 5, 6, 7, 8 }, PropertyType.INT, 4, 1 );
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new int[] { 1000, 10000, 13000 }, PropertyType.INT, 14, 2 );
}
@Test
public void longArrayPropertiesShouldBeBitPacked() throws Exception
{
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new long[] { 1, 2, 3, 4, 5, 6, 7 }, PropertyType.LONG, 3, 1 );
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new long[] { 1, 2, 3, 4, 5, 6, 7, 8 }, PropertyType.LONG, 4, 1 );
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new long[] { 1000, 10000, 13000, 15000000000L }, PropertyType.LONG, 34, 2 );
}
@Test
public void byteArrayPropertiesShouldNotBeBitPacked() throws Exception
{
/* Byte arrays are always stored unpacked. For two reasons:
* - They are very unlikely to gain anything from bit packing
* - byte[] are often used for storing big arrays and the bigger the long
* any bit analysis would take. For both writing and reading */
assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( new byte[] { 1, 2, 3, 4, 5 }, PropertyType.BYTE, Byte.SIZE, 1 );
}
@Test
public void stringArrayGetsStoredAsUtf8() throws Exception
{
String[] array = new String[] { "first", "second" };
Collection<DynamicRecord> records = arrayStore.allocateRecords( array );
Pair<byte[], byte[]> loaded = loadArray( records );
assertStringHeader( loaded.first(), array.length );
ByteBuffer buffer = ByteBuffer.wrap( loaded.other() );
for ( String item : array )
{
byte[] expectedData = UTF8.encode( item );
assertEquals( expectedData.length, buffer.getInt() );
byte[] loadedItem = new byte[expectedData.length];
buffer.get( loadedItem );
assertTrue( Arrays.equals( expectedData, loadedItem ) );
}
}
private void assertStringHeader( byte[] header, int itemCount )
{
assertEquals( PropertyType.STRING.byteValue(), header[0] );
assertEquals( itemCount, ByteBuffer.wrap( header, 1, 4 ).getInt() );
}
private void assertBitPackedArrayGetsCorrectlySerializedAndDeserialized( Object array, PropertyType type,
int expectedBitsUsedPerItem, int expectedRecordCount )
{
Collection<DynamicRecord> records = storeArray( array );
Pair<byte[], byte[]> asBytes = loadArray( records );
assertArrayHeader( asBytes.first(), type, expectedBitsUsedPerItem );
Bits bits = Bits.bitsFromBytes( asBytes.other() );
int length = Array.getLength( array );
for ( int i = 0; i < length; i++ )
assertEquals( ((Number)Array.get( array, i )).longValue(), bits.getLong( expectedBitsUsedPerItem ) );
}
private void assertArrayHeader( byte[] header, PropertyType type, int bitsPerItem )
{
assertEquals( type.byteValue(), header[0] );
assertEquals( bitsPerItem, header[2] );
}
private Collection<DynamicRecord> storeArray( Object array )
{
Collection<DynamicRecord> records = arrayStore.allocateRecords( array );
for ( DynamicRecord record : records )
arrayStore.updateRecord( record );
return records;
}
private Pair<byte[], byte[]> loadArray( Collection<DynamicRecord> records )
{
return arrayStore.readFullByteArray( records, PropertyType.ARRAY );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_TestArrayStore.java
|
1,306
|
public class StoreVersionTest
{
@Test
public void allStoresShouldHaveTheCurrentVersionIdentifier() throws IOException
{
File outputDir = new File( "target/var/" + StoreVersionTest.class.getSimpleName() );
fs.get().mkdirs( outputDir );
File storeFileName = new File( outputDir, NeoStore.DEFAULT_NAME );
Map<String, String> config = new HashMap<String, String>();
config.put( GraphDatabaseSettings.store_dir.name(), outputDir.getPath());
config.put( "neo_store", storeFileName.getPath() );
StoreFactory sf = new StoreFactory( new Config( config, GraphDatabaseSettings.class ),
new DefaultIdGeneratorFactory(), new DefaultWindowPoolFactory(), fs.get(), StringLogger.DEV_NULL,
null );
NeoStore neoStore = sf.createNeoStore( storeFileName );
CommonAbstractStore[] stores = {
neoStore.getNodeStore(),
neoStore.getRelationshipStore(),
neoStore.getRelationshipTypeStore(),
neoStore.getPropertyStore(),
neoStore.getPropertyStore().getPropertyKeyTokenStore()
};
for ( CommonAbstractStore store : stores )
{
assertThat( store.getTypeAndVersionDescriptor(), containsString( CommonAbstractStore.ALL_STORES_VERSION ) );
}
neoStore.close();
}
@Test
@Ignore
public void shouldFailToCreateAStoreContainingOldVersionNumber() throws IOException
{
File outputDir = new File( "target/var/" + StoreVersionTest.class.getSimpleName() );
assertTrue( outputDir.mkdirs() );
URL legacyStoreResource = StoreMigrator.class.getResource( "legacystore/exampledb/neostore.nodestore.db" );
File workingFile = new File( outputDir, "neostore.nodestore.db" );
FileUtils.copyFile( new File( legacyStoreResource.getFile() ), workingFile );
Config config = new Config( new HashMap<String, String>(), GraphDatabaseSettings.class );
try
{
new NodeStore( workingFile, config, new DefaultIdGeneratorFactory(),
new DefaultWindowPoolFactory(), fs.get(), StringLogger.DEV_NULL, null );
fail( "Should have thrown exception" );
}
catch ( NotCurrentStoreVersionException e )
{
//expected
}
}
@Test
public void neoStoreHasCorrectStoreVersionField() throws IOException
{
File outputDir = new File( "target/var/"
+ StoreVersionTest.class.getSimpleName()
+ "test2" );
fs.get().mkdirs( outputDir );
File storeFileName = new File( outputDir, NeoStore.DEFAULT_NAME );
Map<String, String> config = new HashMap<String, String>();
config.put( GraphDatabaseSettings.store_dir.name(), outputDir.getPath() );
config.put( "neo_store", storeFileName.getPath() );
StoreFactory sf = new StoreFactory( new Config( config, GraphDatabaseSettings.class ),
new DefaultIdGeneratorFactory(), new DefaultWindowPoolFactory(), fs.get(), StringLogger.DEV_NULL,
null );
NeoStore neoStore = sf.createNeoStore( storeFileName );
// The first checks the instance method, the other the public one
assertEquals( CommonAbstractStore.ALL_STORES_VERSION,
NeoStore.versionLongToString( neoStore.getStoreVersion() ) );
assertEquals( CommonAbstractStore.ALL_STORES_VERSION,
NeoStore.versionLongToString( NeoStore.getStoreVersion( fs.get(), storeFileName ) ) );
}
@Test
public void testProperEncodingDecodingOfVersionString()
{
String[] toTest = new String[]{"123", "foo", "0.9.9", "v0.A.0",
"bar", "chris", "1234567"};
for ( String string : toTest )
{
assertEquals(
string,
NeoStore.versionLongToString( NeoStore.versionStringToLong( string ) ) );
}
}
@Rule public EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_StoreVersionTest.java
|
1,307
|
public class StoreNotFoundException extends StoreFailureException
{
public StoreNotFoundException( String msg )
{
super( msg );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreNotFoundException.java
|
1,308
|
public final class StoreId
{
private static final Random r = new SecureRandom();
private final long creationTime;
private final long randomId;
private final long storeVersion;
public StoreId()
{
this(
System.currentTimeMillis(),
r.nextLong(),
NeoStore.versionStringToLong( CommonAbstractStore.ALL_STORES_VERSION ) );
}
public StoreId( long creationTime, long randomId, long storeVersion )
{
this.creationTime = creationTime;
this.randomId = randomId;
this.storeVersion = storeVersion;
}
public long getCreationTime()
{
return creationTime;
}
public long getRandomId()
{
return randomId;
}
public long getStoreVersion()
{
return storeVersion;
}
@Override
public boolean equals( Object obj )
{
if ( obj instanceof StoreId )
{
StoreId that = (StoreId) obj;
return that.creationTime == this.creationTime && that.randomId == this.randomId && that.storeVersion == this.storeVersion;
}
return false;
}
@Override
public int hashCode()
{
return (int) (( creationTime ^ randomId ) ^ storeVersion);
}
public byte[] serialize()
{
return ByteBuffer.wrap( new byte[8+8+8] ).putLong( creationTime ).putLong( randomId ).putLong(storeVersion).array();
}
@Override
public String toString()
{
return "StoreId[time:" + creationTime + ", id:" + randomId + ", store version: " + storeVersion + "]";
}
public static StoreId deserialize( byte[] data )
{
assert data.length == 8+8+8 : "unexpected data";
ByteBuffer buffer = ByteBuffer.wrap( data );
return deserialize( buffer );
}
public static StoreId deserialize( ByteBuffer buffer )
{
long creationTime = buffer.getLong();
long randomId = buffer.getLong();
long storeVersion = buffer.getLong();
return new StoreId( creationTime, randomId, storeVersion );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreId.java
|
1,309
|
LONG( PropertyType.LONG, 64, Long.class , long.class)
{
public int getRequiredBits( long value )
{
long mask = 1L << maxBits - 1;
for ( int i = maxBits; i > 0; i--, mask >>= 1 )
{
if ( (mask & value) != 0 )
{
return i;
}
}
return 1;
}
@Override
int getRequiredBits( Object array, int arrayLength )
{
int highest = 1;
if ( isPrimitive( array ) )
{
for ( long value : (long[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
} else
{
for ( long value : (Long[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
}
return highest;
}
@Override
void writeAll( Object array, int length, int requiredBits, Bits result )
{
if ( isPrimitive( array ) )
{
for ( long value : (long[]) array )
{
result.put( value, requiredBits );
}
} else
{
for ( long value : (Long[]) array )
{
result.put( value, requiredBits );
}
}
}
@Override
Object createArray( int length, Bits bits, int requiredBits )
{
if ( length == 0 )
{
return EMPTY_LONG_ARRAY;
}
final long[] result = new long[length];
for ( int i = 0; i < length; i++ )
{
result[i] = bits.getLong( requiredBits );
}
return result;
}
@Override
public Object createEmptyArray()
{
return EMPTY_LONG_ARRAY;
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_ShortArray.java
|
1,310
|
public class StoreFileChannel implements StoreChannel
{
private final FileChannel channel;
public StoreFileChannel( FileChannel channel )
{
this.channel = channel;
}
public StoreFileChannel( StoreFileChannel channel )
{
this.channel = channel.channel;
}
@Override
public long write( ByteBuffer[] srcs ) throws IOException
{
return channel.write( srcs );
}
@Override
public int write( ByteBuffer src, long position ) throws IOException
{
return channel.write( src, position );
}
@Override
public MappedByteBuffer map( FileChannel.MapMode mode, long position, long size ) throws IOException
{
return channel.map( mode, position, size );
}
@Override
public long write( ByteBuffer[] srcs, int offset, int length ) throws IOException
{
return channel.write( srcs, offset, length );
}
@Override
public StoreFileChannel truncate( long size ) throws IOException
{
channel.truncate( size );
return this;
}
@Override
public StoreFileChannel position( long newPosition ) throws IOException
{
channel.position( newPosition );
return this;
}
@Override
public int read( ByteBuffer dst, long position ) throws IOException
{
return channel.read( dst, position );
}
@Override
public void force( boolean metaData ) throws IOException
{
channel.force( metaData );
}
@Override
public int read( ByteBuffer dst ) throws IOException
{
return channel.read( dst );
}
@Override
public long read( ByteBuffer[] dsts, int offset, int length ) throws IOException
{
return channel.read( dsts, offset, length );
}
@Override
public long position() throws IOException
{
return channel.position();
}
@Override
public FileLock tryLock() throws IOException
{
return channel.tryLock();
}
@Override
public boolean isOpen()
{
return channel.isOpen();
}
@Override
public long read( ByteBuffer[] dsts ) throws IOException
{
return channel.read( dsts );
}
@Override
public int write( ByteBuffer src ) throws IOException
{
return channel.write( src );
}
@Override
public void close() throws IOException
{
channel.close();
}
@Override
public long size() throws IOException
{
return channel.size();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreFileChannel.java
|
1,311
|
public abstract class StoreFailureException extends RuntimeException
{
public StoreFailureException( String msg )
{
super( msg );
}
public StoreFailureException( Throwable cause )
{
super( cause );
}
public StoreFailureException( String msg, Throwable cause )
{
super( msg, cause );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreFailureException.java
|
1,312
|
public static abstract class Configuration
{
public static final Setting<Integer> string_block_size = GraphDatabaseSettings.string_block_size;
public static final Setting<Integer> array_block_size = GraphDatabaseSettings.array_block_size;
public static final Setting<Integer> label_block_size = GraphDatabaseSettings.label_block_size;
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreFactory.java
|
1,313
|
public class StoreFactory
{
public static abstract class Configuration
{
public static final Setting<Integer> string_block_size = GraphDatabaseSettings.string_block_size;
public static final Setting<Integer> array_block_size = GraphDatabaseSettings.array_block_size;
public static final Setting<Integer> label_block_size = GraphDatabaseSettings.label_block_size;
}
private final Config config;
private final IdGeneratorFactory idGeneratorFactory;
private final WindowPoolFactory windowPoolFactory;
private final FileSystemAbstraction fileSystemAbstraction;
private final StringLogger stringLogger;
private final RemoteTxHook txHook;
public static final String LABELS_PART = ".labels";
public static final String NAMES_PART = ".names";
public static final String INDEX_PART = ".index";
public static final String KEYS_PART = ".keys";
public static final String ARRAYS_PART = ".arrays";
public static final String STRINGS_PART = ".strings";
public static final String NODE_STORE_NAME = ".nodestore.db";
public static final String NODE_LABELS_STORE_NAME = NODE_STORE_NAME + LABELS_PART;
public static final String PROPERTY_STORE_NAME = ".propertystore.db";
public static final String PROPERTY_KEY_TOKEN_STORE_NAME = PROPERTY_STORE_NAME + INDEX_PART;
public static final String PROPERTY_KEY_TOKEN_NAMES_STORE_NAME = PROPERTY_STORE_NAME + INDEX_PART + KEYS_PART;
public static final String PROPERTY_STRINGS_STORE_NAME = PROPERTY_STORE_NAME + STRINGS_PART;
public static final String PROPERTY_ARRAYS_STORE_NAME = PROPERTY_STORE_NAME + ARRAYS_PART;
public static final String RELATIONSHIP_STORE_NAME = ".relationshipstore.db";
public static final String RELATIONSHIP_TYPE_TOKEN_STORE_NAME = ".relationshiptypestore.db";
public static final String RELATIONSHIP_TYPE_TOKEN_NAMES_STORE_NAME = RELATIONSHIP_TYPE_TOKEN_STORE_NAME + NAMES_PART;
public static final String LABEL_TOKEN_STORE_NAME = ".labeltokenstore.db";
public static final String LABEL_TOKEN_NAMES_STORE_NAME = LABEL_TOKEN_STORE_NAME + NAMES_PART;
public static final String SCHEMA_STORE_NAME = ".schemastore.db";
public StoreFactory( Config config, IdGeneratorFactory idGeneratorFactory, WindowPoolFactory windowPoolFactory,
FileSystemAbstraction fileSystemAbstraction, StringLogger stringLogger, RemoteTxHook txHook )
{
this.config = config;
this.idGeneratorFactory = idGeneratorFactory;
this.windowPoolFactory = windowPoolFactory;
this.fileSystemAbstraction = fileSystemAbstraction;
this.stringLogger = stringLogger;
this.txHook = txHook;
}
public boolean ensureStoreExists() throws IOException
{
boolean readOnly = config.get( GraphDatabaseSettings.read_only );
File store = config.get( GraphDatabaseSettings.neo_store );
boolean created = false;
if ( !readOnly && !fileSystemAbstraction.fileExists( store ))
{
stringLogger.info( "Creating new db @ " + store );
fileSystemAbstraction.mkdirs( store.getParentFile() );
createNeoStore( store ).close();
created = true;
}
return created;
}
public NeoStore newNeoStore(File fileName)
{
try
{
return attemptNewNeoStore( fileName );
}
catch ( NotCurrentStoreVersionException e )
{
tryToUpgradeStores( fileName );
return attemptNewNeoStore( fileName );
}
catch ( StoreNotFoundException e )
{
tryToUpgradeStores( fileName );
return attemptNewNeoStore( fileName );
}
}
NeoStore attemptNewNeoStore( File fileName )
{
return new NeoStore( fileName, config, idGeneratorFactory, windowPoolFactory, fileSystemAbstraction,
stringLogger, txHook,
newRelationshipTypeTokenStore( new File( fileName.getPath() + RELATIONSHIP_TYPE_TOKEN_STORE_NAME ) ),
newLabelTokenStore( new File( fileName.getPath() + LABEL_TOKEN_STORE_NAME ) ),
newPropertyStore(new File( fileName.getPath() + PROPERTY_STORE_NAME)),
newRelationshipStore(new File( fileName.getPath() + RELATIONSHIP_STORE_NAME)),
newNodeStore(new File( fileName.getPath() + NODE_STORE_NAME)),
// We don't need any particular upgrade when we add the schema store
newSchemaStore(new File( fileName.getPath() + SCHEMA_STORE_NAME)));
}
private void tryToUpgradeStores( File fileName )
{
new StoreUpgrader(config, new ConfigMapUpgradeConfiguration(config),
new UpgradableDatabase( new StoreVersionCheck( fileSystemAbstraction ) ),
new StoreMigrator( new VisibleMigrationProgressMonitor( stringLogger, System.out ) ),
new DatabaseFiles( fileSystemAbstraction ),
idGeneratorFactory, fileSystemAbstraction ).attemptUpgrade( fileName );
}
public SchemaStore newSchemaStore( File file )
{
return new SchemaStore( file, config, IdType.SCHEMA, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger );
}
private DynamicStringStore newDynamicStringStore(File fileName, IdType nameIdType)
{
return new DynamicStringStore( fileName, config, nameIdType, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger);
}
private RelationshipTypeTokenStore newRelationshipTypeTokenStore( File baseFileName )
{
DynamicStringStore nameStore = newDynamicStringStore( new File( baseFileName.getPath() + NAMES_PART), IdType.RELATIONSHIP_TYPE_TOKEN_NAME );
return new RelationshipTypeTokenStore( baseFileName, config, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger, nameStore );
}
public PropertyStore newPropertyStore( File baseFileName )
{
DynamicStringStore stringPropertyStore = newDynamicStringStore(
new File( baseFileName.getPath() + STRINGS_PART ), IdType.STRING_BLOCK );
PropertyKeyTokenStore propertyKeyTokenStore = newPropertyKeyTokenStore(
new File( baseFileName.getPath() + INDEX_PART ) );
DynamicArrayStore arrayPropertyStore = newDynamicArrayStore( new File( baseFileName.getPath() + ARRAYS_PART ) );
return new PropertyStore( baseFileName, config, idGeneratorFactory, windowPoolFactory, fileSystemAbstraction,
stringLogger, stringPropertyStore, propertyKeyTokenStore, arrayPropertyStore );
}
public PropertyKeyTokenStore newPropertyKeyTokenStore( File baseFileName )
{
DynamicStringStore nameStore = newDynamicStringStore( new File( baseFileName.getPath() + KEYS_PART ),
IdType.PROPERTY_KEY_TOKEN_NAME );
return new PropertyKeyTokenStore( baseFileName, config, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger, nameStore );
}
private LabelTokenStore newLabelTokenStore( File baseFileName )
{
DynamicStringStore nameStore = newDynamicStringStore(new File( baseFileName.getPath() + NAMES_PART ),
IdType.LABEL_TOKEN_NAME );
return new LabelTokenStore( baseFileName, config, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger, nameStore );
}
private RelationshipStore newRelationshipStore(File baseFileName)
{
return new RelationshipStore( baseFileName, config, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger);
}
public DynamicArrayStore newDynamicArrayStore(File baseFileName)
{
return new DynamicArrayStore( baseFileName, config, IdType.ARRAY_BLOCK, idGeneratorFactory, windowPoolFactory,
fileSystemAbstraction, stringLogger);
}
public NodeStore newNodeStore(File baseFileName)
{
File labelsFileName = new File( baseFileName.getPath() + LABELS_PART );
DynamicArrayStore dynamicLabelStore = new DynamicArrayStore( labelsFileName,
config, IdType.NODE_LABELS, idGeneratorFactory, windowPoolFactory, fileSystemAbstraction, stringLogger);
return new NodeStore( baseFileName, config, idGeneratorFactory, windowPoolFactory, fileSystemAbstraction,
stringLogger, dynamicLabelStore );
}
public NeoStore createNeoStore(File fileName)
{
return createNeoStore( fileName, new StoreId() );
}
public NeoStore createNeoStore(File fileName, StoreId storeId)
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( NeoStore.TYPE_DESCRIPTOR ) );
createNodeStore(new File( fileName.getPath() + NODE_STORE_NAME));
createRelationshipStore(new File( fileName.getPath() + RELATIONSHIP_STORE_NAME));
createPropertyStore(new File( fileName.getPath() + PROPERTY_STORE_NAME));
createRelationshipTypeStore(new File( fileName.getPath() + RELATIONSHIP_TYPE_TOKEN_STORE_NAME ));
createLabelTokenStore( new File( fileName.getPath() + LABEL_TOKEN_STORE_NAME ) );
createSchemaStore(new File( fileName.getPath() + SCHEMA_STORE_NAME));
NeoStore neoStore = newNeoStore( fileName );
/*
* created time | random long | backup version | tx id | store version | next prop
*/
for ( int i = 0; i < 6; i++ )
{
neoStore.nextId();
}
neoStore.setCreationTime( storeId.getCreationTime() );
neoStore.setRandomNumber( storeId.getRandomId() );
neoStore.setVersion( 0 );
neoStore.setLastCommittedTx( 1 );
neoStore.setStoreVersion( storeId.getStoreVersion() );
neoStore.setGraphNextProp( -1 );
return neoStore;
}
/**
* Creates a new node store contained in <CODE>fileName</CODE> If filename
* is <CODE>null</CODE> or the file already exists an
* <CODE>IOException</CODE> is thrown.
*
* @param fileName
* File name of the new node store
*/
public void createNodeStore( File fileName )
{
createNodeLabelsStore( new File( fileName.getPath() + LABELS_PART ) );
createEmptyStore( fileName, buildTypeDescriptorAndVersion( NodeStore.TYPE_DESCRIPTOR ) );
}
private void createNodeLabelsStore( File fileName )
{
int labelStoreBlockSize = config.get( Configuration.label_block_size );
createEmptyDynamicStore( fileName, labelStoreBlockSize,
DynamicArrayStore.VERSION, IdType.NODE_LABELS );
}
/**
* Creates a new relationship store contained in <CODE>fileName</CODE> If
* filename is <CODE>null</CODE> or the file already exists an <CODE>IOException</CODE>
* is thrown.
*
* @param fileName
* File name of the new relationship store
*/
private void createRelationshipStore( File fileName)
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( RelationshipStore.TYPE_DESCRIPTOR ) );
}
/**
* Creates a new property store contained in <CODE>fileName</CODE> If
* filename is <CODE>null</CODE> or the file already exists an
* <CODE>IOException</CODE> is thrown.
*
* @param fileName
* File name of the new property store
*/
public void createPropertyStore( File fileName )
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( PropertyStore.TYPE_DESCRIPTOR ));
int stringStoreBlockSize = config.get( Configuration.string_block_size );
int arrayStoreBlockSize = config.get( Configuration.array_block_size );
createDynamicStringStore(new File( fileName.getPath() + STRINGS_PART), stringStoreBlockSize, IdType.STRING_BLOCK);
createPropertyKeyTokenStore( new File( fileName.getPath() + INDEX_PART ) );
createDynamicArrayStore( new File( fileName.getPath() + ARRAYS_PART ), arrayStoreBlockSize );
}
/**
* Creates a new relationship type store contained in <CODE>fileName</CODE>
* If filename is <CODE>null</CODE> or the file already exists an
* <CODE>IOException</CODE> is thrown.
*
* @param fileName
* File name of the new relationship type store
*/
private void createRelationshipTypeStore( File fileName )
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( RelationshipTypeTokenStore.TYPE_DESCRIPTOR ));
createDynamicStringStore( new File( fileName.getPath() + NAMES_PART), TokenStore.NAME_STORE_BLOCK_SIZE, IdType.RELATIONSHIP_TYPE_TOKEN_NAME );
RelationshipTypeTokenStore store = newRelationshipTypeTokenStore( fileName );
store.close();
}
private void createLabelTokenStore( File fileName )
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( LabelTokenStore.TYPE_DESCRIPTOR ));
createDynamicStringStore( new File( fileName.getPath() + NAMES_PART), TokenStore.NAME_STORE_BLOCK_SIZE, IdType.LABEL_TOKEN_NAME );
LabelTokenStore store = newLabelTokenStore( fileName );
store.close();
}
private void createDynamicStringStore( File fileName, int blockSize, IdType idType )
{
createEmptyDynamicStore(fileName, blockSize, DynamicStringStore.VERSION, idType);
}
private void createPropertyKeyTokenStore( File fileName )
{
createEmptyStore( fileName, buildTypeDescriptorAndVersion( PropertyKeyTokenStore.TYPE_DESCRIPTOR ));
createDynamicStringStore(new File( fileName.getPath() + KEYS_PART), TokenStore.NAME_STORE_BLOCK_SIZE, IdType.PROPERTY_KEY_TOKEN_NAME );
}
public void createDynamicArrayStore( File fileName, int blockSize)
{
createEmptyDynamicStore(fileName, blockSize, DynamicArrayStore.VERSION, IdType.ARRAY_BLOCK);
}
public void createSchemaStore( File fileName )
{
createEmptyDynamicStore( fileName, SchemaStore.BLOCK_SIZE, SchemaStore.VERSION, IdType.SCHEMA );
}
/**
* Creates a new empty store. A factory method returning an implementation
* should make use of this method to initialize an empty store. Block size
* must be greater than zero. Not that the first block will be marked as
* reserved (contains info about the block size). There will be an overhead
* for each block of <CODE>AbstractDynamicStore.BLOCK_HEADER_SIZE</CODE>
* bytes.
* <p>
* This method will create a empty store with descriptor returned by the
* {@link CommonAbstractStore#getTypeDescriptor()}. The internal id generator used by
* this store will also be created.
*
* @param fileName
* The file name of the store that will be created
* @param baseBlockSize
* The number of bytes for each block
* @param typeAndVersionDescriptor
* The type and version descriptor that identifies this store
*/
public void createEmptyDynamicStore( File fileName, int baseBlockSize,
String typeAndVersionDescriptor, IdType idType)
{
int blockSize = baseBlockSize;
// sanity checks
if ( fileName == null )
{
throw new IllegalArgumentException( "Null filename" );
}
if ( fileSystemAbstraction.fileExists( fileName ) )
{
throw new IllegalStateException( "Can't create store[" + fileName
+ "], file already exists" );
}
if ( blockSize < 1 )
{
throw new IllegalArgumentException( "Illegal block size["
+ blockSize + "]" );
}
if ( blockSize > 0xFFFF )
{
throw new IllegalArgumentException( "Illegal block size[" + blockSize + "], limit is 65535" );
}
blockSize += AbstractDynamicStore.BLOCK_HEADER_SIZE;
// write the header
try
{
StoreChannel channel = fileSystemAbstraction.create(fileName);
int endHeaderSize = blockSize
+ UTF8.encode( typeAndVersionDescriptor ).length;
ByteBuffer buffer = ByteBuffer.allocate( endHeaderSize );
buffer.putInt( blockSize );
buffer.position( endHeaderSize - typeAndVersionDescriptor.length() );
buffer.put( UTF8.encode( typeAndVersionDescriptor ) ).flip();
channel.write( buffer );
channel.force( false );
channel.close();
}
catch ( IOException e )
{
throw new UnderlyingStorageException( "Unable to create store "
+ fileName, e );
}
idGeneratorFactory.create( fileSystemAbstraction, new File( fileName.getPath() + ".id"), 0 );
// TODO highestIdInUse = 0 works now, but not when slave can create store files.
IdGenerator idGenerator = idGeneratorFactory.open(fileSystemAbstraction, new File( fileName.getPath() + ".id"),
idType.getGrabSize(), idType, 0 );
idGenerator.nextId(); // reserve first for blockSize
idGenerator.close();
}
public void createEmptyStore( File fileName, String typeAndVersionDescriptor)
{
// sanity checks
if ( fileName == null )
{
throw new IllegalArgumentException( "Null filename" );
}
if ( fileSystemAbstraction.fileExists( fileName ) )
{
throw new IllegalStateException( "Can't create store[" + fileName
+ "], file already exists" );
}
// write the header
try
{
StoreChannel channel = fileSystemAbstraction.create(fileName);
int endHeaderSize = UTF8.encode(typeAndVersionDescriptor).length;
ByteBuffer buffer = ByteBuffer.allocate( endHeaderSize );
buffer.put( UTF8.encode( typeAndVersionDescriptor ) ).flip();
channel.write( buffer );
channel.force( false );
channel.close();
}
catch ( IOException e )
{
throw new UnderlyingStorageException( "Unable to create store "
+ fileName, e );
}
idGeneratorFactory.create( fileSystemAbstraction, new File( fileName.getPath() + ".id"), 0 );
}
public String buildTypeDescriptorAndVersion( String typeDescriptor )
{
return typeDescriptor + " " + CommonAbstractStore.ALL_STORES_VERSION;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreFactory.java
|
1,314
|
return new DelegatingRecordStore<DynamicRecord>( store ) {
@Override
public <FAILURE extends Exception> void accept( Processor<FAILURE> processor, DynamicRecord record)
throws FAILURE
{
processor.processLabelArrayWithOwner( this, record );
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreAccess.java
|
1,315
|
public class StoreAccess
{
// Top level stores
private final RecordStore<DynamicRecord> schemaStore;
private final RecordStore<NodeRecord> nodeStore;
private final RecordStore<RelationshipRecord> relStore;
private final RecordStore<RelationshipTypeTokenRecord> relationshipTypeTokenStore;
private final RecordStore<LabelTokenRecord> labelTokenStore;
private final RecordStore<DynamicRecord> nodeDynamicLabelStore;
private final RecordStore<PropertyRecord> propStore;
// Transitive stores
private final RecordStore<DynamicRecord> stringStore, arrayStore;
private final RecordStore<PropertyKeyTokenRecord> propertyKeyTokenStore;
private final RecordStore<DynamicRecord> relationshipTypeNameStore;
private final RecordStore<DynamicRecord> labelNameStore;
private final RecordStore<DynamicRecord> propertyKeyNameStore;
// internal state
private boolean closeable;
private NeoStore neoStore;
public StoreAccess( GraphDatabaseAPI graphdb )
{
this( getNeoStoreFrom( graphdb ) );
}
@SuppressWarnings( "deprecation" )
private static NeoStore getNeoStoreFrom( GraphDatabaseAPI graphdb )
{
return graphdb.getDependencyResolver().resolveDependency( XaDataSourceManager.class ).getNeoStoreDataSource().getNeoStore();
}
public StoreAccess( NeoStore store )
{
this( store.getSchemaStore(), store.getNodeStore(), store.getRelationshipStore(), store.getPropertyStore(),
store.getRelationshipTypeStore(), store.getLabelTokenStore() );
this.neoStore = store;
}
public StoreAccess( SchemaStore schemaStore, NodeStore nodeStore, RelationshipStore relStore, PropertyStore propStore,
RelationshipTypeTokenStore typeStore, LabelTokenStore labelTokenStore )
{
this.schemaStore = wrapStore( schemaStore );
this.nodeStore = wrapStore( nodeStore );
this.relStore = wrapStore( relStore );
this.propStore = wrapStore( propStore );
this.stringStore = wrapStore( propStore.getStringStore() );
this.arrayStore = wrapStore( propStore.getArrayStore() );
this.relationshipTypeTokenStore = wrapStore( typeStore );
this.labelTokenStore = wrapStore( labelTokenStore );
this.nodeDynamicLabelStore = wrapStore( wrapNodeDynamicLabelStore( nodeStore.getDynamicLabelStore() ) );
this.propertyKeyTokenStore = wrapStore( propStore.getPropertyKeyTokenStore() );
this.relationshipTypeNameStore = wrapStore( typeStore.getNameStore() );
this.labelNameStore = wrapStore( labelTokenStore.getNameStore() );
this.propertyKeyNameStore = wrapStore( propStore.getPropertyKeyTokenStore().getNameStore() );
}
public StoreAccess( String path )
{
this( path, defaultParams() );
}
public StoreAccess( FileSystemAbstraction fileSystem, String path )
{
this( fileSystem, path, defaultParams() );
}
public StoreAccess( String path, Map<String, String> params )
{
this( new DefaultFileSystemAbstraction(), path, params );
}
public StoreAccess( FileSystemAbstraction fileSystem, String path, Map<String, String> params )
{
this( new StoreFactory( new Config( requiredParams( params, path ) ),
new DefaultIdGeneratorFactory(),
new DefaultWindowPoolFactory(),
fileSystem, StringLogger.DEV_NULL,
new DefaultTxHook() ).attemptNewNeoStore( new File( path, "neostore" ) ) );
this.closeable = true;
}
private static Map<String, String> requiredParams( Map<String, String> params, String path )
{
params = new HashMap<>( params );
params.put( "neo_store", new File( path, "neostore" ).getPath() );
return params;
}
public NeoStore getRawNeoStore()
{
return neoStore;
}
public RecordStore<DynamicRecord> getSchemaStore()
{
return schemaStore;
}
public RecordStore<NodeRecord> getNodeStore()
{
return nodeStore;
}
public RecordStore<RelationshipRecord> getRelationshipStore()
{
return relStore;
}
public RecordStore<PropertyRecord> getPropertyStore()
{
return propStore;
}
public RecordStore<DynamicRecord> getStringStore()
{
return stringStore;
}
public RecordStore<DynamicRecord> getArrayStore()
{
return arrayStore;
}
public RecordStore<RelationshipTypeTokenRecord> getRelationshipTypeTokenStore()
{
return relationshipTypeTokenStore;
}
public RecordStore<LabelTokenRecord> getLabelTokenStore()
{
return labelTokenStore;
}
public RecordStore<DynamicRecord> getNodeDynamicLabelStore()
{
return nodeDynamicLabelStore;
}
public RecordStore<PropertyKeyTokenRecord> getPropertyKeyTokenStore()
{
return propertyKeyTokenStore;
}
public RecordStore<DynamicRecord> getRelationshipTypeNameStore()
{
return relationshipTypeNameStore;
}
public RecordStore<DynamicRecord> getLabelNameStore()
{
return labelNameStore;
}
public RecordStore<DynamicRecord> getPropertyKeyNameStore()
{
return propertyKeyNameStore;
}
public final <F extends Exception, P extends RecordStore.Processor<F>> P applyToAll( P processor ) throws F
{
for ( RecordStore<?> store : allStores() )
{
apply( processor, store );
}
return processor;
}
protected RecordStore<?>[] allStores()
{
if ( propStore == null )
{
// for when the property store isn't available (e.g. because the contained data in very sensitive)
return new RecordStore<?>[]{ // no property stores
nodeStore, relStore,
relationshipTypeTokenStore, relationshipTypeNameStore,
labelTokenStore, labelNameStore, nodeDynamicLabelStore
};
}
return new RecordStore<?>[]{
schemaStore, nodeStore, relStore, propStore, stringStore, arrayStore,
relationshipTypeTokenStore, propertyKeyTokenStore, labelTokenStore,
relationshipTypeNameStore, propertyKeyNameStore, labelNameStore,
nodeDynamicLabelStore
};
}
private static RecordStore<DynamicRecord> wrapNodeDynamicLabelStore( RecordStore<DynamicRecord> store ) {
return new DelegatingRecordStore<DynamicRecord>( store ) {
@Override
public <FAILURE extends Exception> void accept( Processor<FAILURE> processor, DynamicRecord record)
throws FAILURE
{
processor.processLabelArrayWithOwner( this, record );
}
};
}
protected <R extends AbstractBaseRecord> RecordStore<R> wrapStore( RecordStore<R> store )
{
return store;
}
@SuppressWarnings("unchecked")
protected <FAILURE extends Exception> void apply( RecordStore.Processor<FAILURE> processor, RecordStore<?> store )
throws FAILURE
{
processor.applyFiltered( store, RecordStore.IN_USE );
}
private static Map<String, String> defaultParams()
{
Map<String, String> params = new HashMap<>();
params.put( GraphDatabaseSettings.nodestore_mapped_memory_size.name(), "20M" );
params.put( GraphDatabaseSettings.nodestore_propertystore_mapped_memory_size.name(), "90M" );
params.put( GraphDatabaseSettings.nodestore_propertystore_index_mapped_memory_size.name(), "1M" );
params.put( GraphDatabaseSettings.nodestore_propertystore_index_keys_mapped_memory_size.name(), "1M" );
params.put( GraphDatabaseSettings.strings_mapped_memory_size.name(), "130M" );
params.put( GraphDatabaseSettings.arrays_mapped_memory_size.name(), "130M" );
params.put( GraphDatabaseSettings.relationshipstore_mapped_memory_size.name(), "100M" );
// if on windows, default no memory mapping
if ( osIsWindows() )
{
params.put( GraphDatabaseSettings.use_memory_mapped_buffers.name(), "false" );
}
params.put( GraphDatabaseSettings.rebuild_idgenerators_fast.name(), Settings.TRUE );
return params;
}
public synchronized void close()
{
if ( closeable )
{
closeable = false;
neoStore.close();
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_StoreAccess.java
|
1,316
|
DOUBLE( PropertyType.DOUBLE, 64, Double.class, double.class )
{
int getRequiredBits( double value )
{
long v = Double.doubleToLongBits( value );
long mask = 1L << maxBits - 1;
for ( int i = maxBits; i > 0; i--, mask >>= 1 )
{
if ( (mask & v) != 0 )
{
return i;
}
}
return 1;
}
@Override
int getRequiredBits( Object array, int arrayLength )
{
int highest = 1;
if ( isPrimitive( array ) )
{
for ( double value : (double[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
} else
{
for ( double value : (Double[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
}
return highest;
}
@Override
void writeAll( Object array, int length, int requiredBits, Bits result )
{
if ( isPrimitive( array ) )
{
for ( double value : (double[]) array )
{
result.put( Double.doubleToLongBits( value ), requiredBits );
}
} else
{
for ( double value : (Double[]) array )
{
result.put( Double.doubleToLongBits( value ), requiredBits );
}
}
}
@Override
Object createArray( int length, Bits bits, int requiredBits )
{
if ( length == 0 )
{
return EMPTY_DOUBLE_ARRAY;
}
final double[] result = new double[length];
for ( int i = 0; i < length; i++ )
{
result[i] = Double.longBitsToDouble( bits.getLong( requiredBits ) );
}
return result;
}
@Override
public Object createEmptyArray()
{
return EMPTY_DOUBLE_ARRAY;
}
};
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_ShortArray.java
|
1,317
|
FLOAT( PropertyType.FLOAT, 32, Float.class ,float.class)
{
int getRequiredBits( float value )
{
int v = Float.floatToIntBits( value );
long mask = 1L << maxBits - 1;
for ( int i = maxBits; i > 0; i--, mask >>= 1 )
{
if ( (mask & v) != 0 )
{
return i;
}
}
return 1;
}
@Override
int getRequiredBits( Object array, int arrayLength )
{
int highest = 1;
if ( isPrimitive( array ) )
{
for ( float value : (float[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
} else
{
for ( float value : (Float[]) array )
{
highest = Math.max( getRequiredBits( value ), highest );
}
}
return highest;
}
@Override
void writeAll( Object array, int length, int requiredBits, Bits result )
{
if ( isPrimitive( array ) )
{
for ( float value : (float[]) array )
{
result.put( Float.floatToIntBits( value ), requiredBits );
}
} else
{
for ( float value : (Float[]) array )
{
result.put( Float.floatToIntBits( value ), requiredBits );
}
}
}
@Override
Object createArray( int length, Bits bits, int requiredBits )
{
if ( length == 0 )
{
return EMPTY_FLOAT_ARRAY;
}
final float[] result = new float[length];
for ( int i = 0; i < length; i++ )
{
result[i] = Float.intBitsToFloat( bits.getInt( requiredBits ) );
}
return result;
}
@Override
public Object createEmptyArray()
{
return EMPTY_FLOAT_ARRAY;
}
},
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_ShortArray.java
|
1,318
|
public class IdRange
{
private final long[] defragIds;
private final long rangeStart;
private final int rangeLength;
public IdRange( long[] defragIds, long rangeStart, int rangeLength )
{
this.defragIds = defragIds;
this.rangeStart = rangeStart;
this.rangeLength = rangeLength;
}
public long[] getDefragIds()
{
return defragIds;
}
public long getRangeStart()
{
return rangeStart;
}
public int getRangeLength()
{
return rangeLength;
}
@Override
public String toString()
{
return "IdRange[" + rangeStart + "-" + (rangeStart+rangeLength-1) + ", defrag " + Arrays.toString( defragIds ) + "]";
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_nioneo_store_IdRange.java
|
1,319
|
private static class FileSystem extends EphemeralFileSystemAbstraction
{
void disposeAndAssertNoOpenFiles() throws Exception
{
//Collection<String> open = openFiles();
//assertTrue( "Open files: " + open, open.isEmpty() );
assertNoOpenFiles();
super.shutdown();
}
@Override
public void shutdown()
{
// no-op, it's pretty odd to have EphemeralFileSystemAbstraction implement Lifecycle by default
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_IdGeneratorRebuildFailureEmulationTest.java
|
1,320
|
@RunWith(SubProcessTestRunner.class)
@ForeignBreakpoints(@ForeignBreakpoints.BreakpointDef(
type = "org.neo4j.kernel.impl.nioneo.store.IdGeneratorImpl", method = "setHighId"))
public static final class FailureDuringRebuild extends IdGeneratorRebuildFailureEmulationTest
{
@Override
protected void emulateFailureOnRebuildOf( NeoStore neostore )
{
// emulate a failure (Id capacity exceeded) during rebuild by breakpoints in this method:
neostore.makeStoreOk();
fail( "makeStoreOk should have thrown UnderlyingStorageException" );
}
@BreakpointHandler("performTest")
public static void bootstrapTest( @BreakpointHandler("setHighId") BreakPoint setHighId )
{
setHighId.enable();
}
@SuppressWarnings("boxing")
@BreakpointHandler("setHighId")
public static void on_setHighId( DebugInterface di, BreakPoint setHighId )
{
if ( setHighId.invocationCount() > 1
|| RelationshipTypeTokenStore.class.getName().equals( di.thread().getStackTrace()
[2].getClassName() ) )
{
setHighId.disable();
// emulate a failure in recovery by changing the id parameter to setHighId(id) to an invalid value,
// causing an exception to be thrown.
di.setLocalVariable( "id", -1 );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_nioneo_store_IdGeneratorRebuildFailureEmulationTest.java
|
1,321
|
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
if ( ((DummyKernelEventHandler) other).resource == RESOURCE2 )
{
return ExecutionOrder.AFTER;
}
return ExecutionOrder.DOESNT_MATTER;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,322
|
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,323
|
public class TestKernelEvents
{
private static final String PATH = "target/var/neodb";
private static final Object RESOURCE1 = new Object();
private static final Object RESOURCE2 = new Object();
@BeforeClass
public static void doBefore()
{
deleteFileOrDirectory( PATH );
}
@Test
public void testRegisterUnregisterHandlers()
{
GraphDatabaseService graphDb = new TestGraphDatabaseFactory().newImpermanentDatabase();
KernelEventHandler handler1 = new DummyKernelEventHandler( RESOURCE1 )
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
};
KernelEventHandler handler2 = new DummyKernelEventHandler( RESOURCE2 )
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
};
try
{
graphDb.unregisterKernelEventHandler( handler1 );
fail( "Shouldn't be able to do unregister on a "
+ "unregistered handler" );
}
catch ( IllegalStateException e )
{ /* Good */
}
assertTrue( handler1 == graphDb.registerKernelEventHandler(
handler1 ) );
assertTrue( handler1 == graphDb.registerKernelEventHandler(
handler1 ) );
assertTrue( handler1 == graphDb.unregisterKernelEventHandler(
handler1 ) );
try
{
graphDb.unregisterKernelEventHandler( handler1 );
fail( "Shouldn't be able to do unregister on a "
+ "unregistered handler" );
}
catch ( IllegalStateException e )
{ /* Good */
}
assertTrue( handler1 == graphDb.registerKernelEventHandler(
handler1 ) );
assertTrue( handler2 == graphDb.registerKernelEventHandler(
handler2 ) );
assertTrue( handler1 == graphDb.unregisterKernelEventHandler(
handler1 ) );
assertTrue( handler2 == graphDb.unregisterKernelEventHandler(
handler2 ) );
graphDb.shutdown();
}
@Test
public void testShutdownEvents()
{
GraphDatabaseService graphDb = new TestGraphDatabaseFactory().newImpermanentDatabase();
DummyKernelEventHandler handler1 = new DummyKernelEventHandler( RESOURCE1 )
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
if ( ((DummyKernelEventHandler) other).resource == RESOURCE2 )
{
return ExecutionOrder.AFTER;
}
return ExecutionOrder.DOESNT_MATTER;
}
};
DummyKernelEventHandler handler2 = new DummyKernelEventHandler( RESOURCE1 )
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
if ( ((DummyKernelEventHandler) other).resource == RESOURCE1 )
{
return ExecutionOrder.BEFORE;
}
return ExecutionOrder.DOESNT_MATTER;
}
};
graphDb.registerKernelEventHandler( handler1 );
graphDb.registerKernelEventHandler( handler2 );
graphDb.shutdown();
assertEquals( Integer.valueOf( 0 ), handler2.beforeShutdown );
assertEquals( Integer.valueOf( 1 ), handler1.beforeShutdown );
}
private static abstract class DummyKernelEventHandler implements KernelEventHandler
{
private static int counter;
private Integer beforeShutdown, kernelPanic;
private final Object resource;
DummyKernelEventHandler( Object resource )
{
this.resource = resource;
}
@Override
public void beforeShutdown()
{
beforeShutdown = counter++;
}
@Override
public Object getResource()
{
return this.resource;
}
@Override
public void kernelPanic( ErrorState error )
{
kernelPanic = counter++;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,324
|
class PropertyEntryImpl<T extends PropertyContainer> implements PropertyEntry<T>
{
private final T entity;
private final String key;
private final Object value;
private final Object valueBeforeTx;
PropertyEntryImpl( T entity, String key, Object value, Object valueBeforeTx )
{
this.entity = entity;
this.key = key;
this.value = value;
this.valueBeforeTx = valueBeforeTx;
}
@Override
public T entity()
{
return this.entity;
}
@Override
public String key()
{
return this.key;
}
@Override
public Object value()
{
return this.value;
}
@Override
public Object previouslyCommitedValue()
{
return this.valueBeforeTx;
}
void compareToAssigned( PropertyEntry<T> entry )
{
basicCompareTo( entry );
assertEqualsMaybeNull( entry.value(), value() );
}
void compareToRemoved( PropertyEntry<T> entry )
{
basicCompareTo( entry );
try
{
entry.value();
fail( "Should throw IllegalStateException" );
}
catch ( IllegalStateException e )
{
// OK
}
assertNull( value() );
}
void basicCompareTo( PropertyEntry<T> entry )
{
assertEquals( entry.entity(), entity() );
assertEquals( entry.key(), key() );
assertEqualsMaybeNull( entry.previouslyCommitedValue(), previouslyCommitedValue() );
}
@Override
public String toString()
{
return "PropertyEntry[entity=" + entity + ", key=" + key + ", value=" + value + ", valueBeforeTx="
+ valueBeforeTx + "]";
}
public static void assertEqualsMaybeNull( Object o1, Object o2 )
{
if ( o1 == null )
{
assertTrue( o1 == o2 );
}
else
{
assertEquals( o1, o2 );
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_PropertyEntryImpl.java
|
1,325
|
private static class IllBehavingXaResource implements XaResource
{
public byte[] getBranchId()
{
return UTF8.encode( "554342" );
}
public void commit( Xid xid, boolean onePhase ) throws XAException
{
throw new XAException();
}
public void end( Xid xid, int flags ) throws XAException
{
}
public void forget( Xid xid ) throws XAException
{
}
public int getTransactionTimeout() throws XAException
{
return 0;
}
public boolean isSameRM( XAResource xaResource ) throws XAException
{
if ( xaResource instanceof IllBehavingXaResource )
{
return true;
}
return false;
}
public int prepare( Xid xid ) throws XAException
{
return XAResource.XA_OK;
}
public Xid[] recover( int flag ) throws XAException
{
return new XidImpl[0];
}
public void rollback( Xid xid ) throws XAException
{
throw new RuntimeException( "I am a noob" );
}
public boolean setTransactionTimeout( int seconds ) throws XAException
{
return false;
}
public void start( Xid xid, int flags ) throws XAException
{
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_IllBehavingXaDataSource.java
|
1,326
|
private static class IllBehavingXaConnection implements XaConnection
{
IllBehavingXaResource illBehavingXaResource = new IllBehavingXaResource();
public void destroy()
{
}
public XAResource getXaResource()
{
return illBehavingXaResource;
}
@Override
public boolean enlistResource( Transaction javaxTx )
throws SystemException, RollbackException
{
return javaxTx.enlistResource( new IllBehavingXaResource() );
}
@Override
public boolean delistResource( Transaction tx, int tmsuccess )
throws IllegalStateException, SystemException
{
return tx.delistResource( illBehavingXaResource, tmsuccess );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_IllBehavingXaDataSource.java
|
1,327
|
public class IllBehavingXaDataSource extends XaDataSource
{
IllBehavingXaDataSource(byte[] branchId, String name) throws InstantiationException
{
super( branchId, name );
}
@Override
public void init()
{
}
@Override
public void start()
{
}
@Override
public void stop()
{
}
@Override
public void shutdown()
{
}
@Override
public XaConnection getXaConnection()
{
return new IllBehavingXaConnection();
}
private static class IllBehavingXaConnection implements XaConnection
{
IllBehavingXaResource illBehavingXaResource = new IllBehavingXaResource();
public void destroy()
{
}
public XAResource getXaResource()
{
return illBehavingXaResource;
}
@Override
public boolean enlistResource( Transaction javaxTx )
throws SystemException, RollbackException
{
return javaxTx.enlistResource( new IllBehavingXaResource() );
}
@Override
public boolean delistResource( Transaction tx, int tmsuccess )
throws IllegalStateException, SystemException
{
return tx.delistResource( illBehavingXaResource, tmsuccess );
}
}
private static class IllBehavingXaResource implements XaResource
{
public byte[] getBranchId()
{
return UTF8.encode( "554342" );
}
public void commit( Xid xid, boolean onePhase ) throws XAException
{
throw new XAException();
}
public void end( Xid xid, int flags ) throws XAException
{
}
public void forget( Xid xid ) throws XAException
{
}
public int getTransactionTimeout() throws XAException
{
return 0;
}
public boolean isSameRM( XAResource xaResource ) throws XAException
{
if ( xaResource instanceof IllBehavingXaResource )
{
return true;
}
return false;
}
public int prepare( Xid xid ) throws XAException
{
return XAResource.XA_OK;
}
public Xid[] recover( int flag ) throws XAException
{
return new XidImpl[0];
}
public void rollback( Xid xid ) throws XAException
{
throw new RuntimeException( "I am a noob" );
}
public boolean setTransactionTimeout( int seconds ) throws XAException
{
return false;
}
public void start( Xid xid, int flags ) throws XAException
{
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_IllBehavingXaDataSource.java
|
1,328
|
class ExpectedTransactionData
{
final Set<Node> expectedCreatedNodes = new HashSet<Node>();
final Set<Relationship> expectedCreatedRelationships = new HashSet<Relationship>();
final Set<Node> expectedDeletedNodes = new HashSet<Node>();
final Set<Relationship> expectedDeletedRelationships = new HashSet<Relationship>();
final Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedAssignedNodeProperties =
new HashMap<Node, Map<String, PropertyEntryImpl<Node>>>();
final Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedAssignedRelationshipProperties =
new HashMap<Relationship, Map<String, PropertyEntryImpl<Relationship>>>();
final Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedRemovedNodeProperties =
new HashMap<Node, Map<String, PropertyEntryImpl<Node>>>();
final Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedRemovedRelationshipProperties =
new HashMap<Relationship, Map<String, PropertyEntryImpl<Relationship>>>();
void assignedProperty( Node node, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedAssignedNodeProperties, node, key, value, valueBeforeTx );
}
void assignedProperty( Relationship rel, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedAssignedRelationshipProperties, rel, key, value, valueBeforeTx );
}
void removedProperty( Node node, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedRemovedNodeProperties, node, key, value, valueBeforeTx );
}
void removedProperty( Relationship rel, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedRemovedRelationshipProperties, rel, key, value, valueBeforeTx );
}
<T extends PropertyContainer> void putInMap( Map<T, Map<String, PropertyEntryImpl<T>>> map,
T entity, String key, Object value, Object valueBeforeTx )
{
Map<String, PropertyEntryImpl<T>> innerMap = map.get( entity );
if ( innerMap == null )
{
innerMap = new HashMap<String, PropertyEntryImpl<T>>();
map.put( entity, innerMap );
}
innerMap.put( key, new PropertyEntryImpl<T>( entity, key, value, valueBeforeTx ) );
}
void compareTo( TransactionData data )
{
Set<Node> expectedCreatedNodes = new HashSet<Node>( this.expectedCreatedNodes );
Set<Relationship> expectedCreatedRelationships = new HashSet<Relationship>( this.expectedCreatedRelationships );
Set<Node> expectedDeletedNodes = new HashSet<Node>( this.expectedDeletedNodes );
Set<Relationship> expectedDeletedRelationships = new HashSet<Relationship>( this.expectedDeletedRelationships );
Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedAssignedNodeProperties =
clone( this.expectedAssignedNodeProperties );
Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedAssignedRelationshipProperties =
clone( this.expectedAssignedRelationshipProperties );
Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedRemovedNodeProperties =
clone( this.expectedRemovedNodeProperties );
Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedRemovedRelationshipProperties =
clone( this.expectedRemovedRelationshipProperties );
for ( Node node : data.createdNodes() )
{
assertTrue( expectedCreatedNodes.remove( node ) );
assertFalse( data.isDeleted( node ) );
}
assertTrue( "Expected some created nodes that weren't seen: " + expectedCreatedNodes,
expectedCreatedNodes.isEmpty() );
for ( Relationship rel : data.createdRelationships() )
{
assertTrue( expectedCreatedRelationships.remove( rel ) );
assertFalse( data.isDeleted( rel ) );
}
assertTrue( expectedCreatedRelationships.isEmpty() );
for ( Node node : data.deletedNodes() )
{
assertTrue( "Unexpected deleted node " + node, expectedDeletedNodes.remove( node ) );
assertTrue( data.isDeleted( node ) );
}
assertTrue( expectedDeletedNodes.isEmpty() );
for ( Relationship rel : data.deletedRelationships() )
{
assertTrue( expectedDeletedRelationships.remove( rel ) );
assertTrue( data.isDeleted( rel ) );
}
assertTrue( expectedDeletedRelationships.isEmpty() );
for ( PropertyEntry<Node> entry : data.assignedNodeProperties() )
{
checkAssigned( expectedAssignedNodeProperties, entry );
assertFalse( data.isDeleted( entry.entity() ) );
}
assertTrue( "Expected node properties not encountered " + expectedAssignedNodeProperties,
expectedAssignedNodeProperties.isEmpty() );
for ( PropertyEntry<Relationship> entry : data.assignedRelationshipProperties() )
{
checkAssigned( expectedAssignedRelationshipProperties, entry );
assertFalse( data.isDeleted( entry.entity() ) );
}
assertTrue( expectedAssignedRelationshipProperties.isEmpty() );
for ( PropertyEntry<Node> entry : data.removedNodeProperties() )
{
checkRemoved( expectedRemovedNodeProperties, entry );
}
assertTrue( expectedRemovedNodeProperties.isEmpty() );
for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() )
{
checkRemoved( expectedRemovedRelationshipProperties, entry );
}
assertTrue( expectedRemovedRelationshipProperties.isEmpty() );
}
private <KEY extends PropertyContainer> Map<KEY, Map<String, PropertyEntryImpl<KEY>>> clone(
Map<KEY, Map<String, PropertyEntryImpl<KEY>>> map )
{
Map<KEY, Map<String, PropertyEntryImpl<KEY>>> result = new HashMap<>();
for ( KEY key : map.keySet() )
{
result.put( key, new HashMap<>( map.get( key ) ) );
}
return result;
}
<T extends PropertyContainer> void checkAssigned(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
fetchExpectedPropertyEntry( map, entry ).compareToAssigned( entry );
}
<T extends PropertyContainer> void checkRemoved(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
fetchExpectedPropertyEntry( map, entry ).compareToRemoved( entry );
}
<T extends PropertyContainer> PropertyEntryImpl<T> fetchExpectedPropertyEntry(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
Map<String, PropertyEntryImpl<T>> innerMap = map.get( entry.entity() );
assertNotNull( innerMap );
PropertyEntryImpl<T> expectedEntry = innerMap.remove( entry.key() );
assertNotNull( "Unexpacted property entry " + entry, expectedEntry );
if ( innerMap.isEmpty() )
{
map.remove( entry.entity() );
}
return expectedEntry;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_ExpectedTransactionData.java
|
1,329
|
private static class GDBSchemaActions implements InternalSchemaActions
{
private final ThreadToStatementContextBridge ctxProvider;
public GDBSchemaActions( ThreadToStatementContextBridge ctxProvider )
{
this.ctxProvider = ctxProvider;
}
@Override
public IndexDefinition createIndexDefinition( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
try
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
statement.schemaWriteOperations().indexCreate( labelId, propertyKeyId );
return new IndexDefinitionImpl( this, label, propertyKey, false );
}
catch ( AlreadyIndexedException e )
{
throw new ConstraintViolationException(
format( "There already exists an index for label '%s' on property '%s'.",
label.name(), propertyKey ), e );
}
catch ( AlreadyConstrainedException e )
{
throw new ConstraintViolationException( format(
"Label '%s' and property '%s' have a unique constraint defined on them, so an index is " +
"already created that matches this.", label.name(), propertyKey ), e );
}
catch ( AddIndexFailureException e )
{
throw new ConstraintViolationException(
e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) ), e );
}
catch ( IllegalTokenNameException e )
{
throw new IllegalArgumentException( e );
}
catch ( TooManyLabelsException e )
{
throw new IllegalStateException( e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
}
@Override
public void dropIndexDefinitions( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
int labelId = statement.readOperations().labelGetForName( label.name() );
int propertyKeyId = statement.readOperations().propertyKeyGetForName( propertyKey );
if ( labelId != KeyReadOperations.NO_SUCH_LABEL && propertyKeyId != KeyReadOperations
.NO_SUCH_PROPERTY_KEY )
{
statement.schemaWriteOperations().indexDrop( statement.readOperations().indexesGetForLabelAndPropertyKey( labelId, propertyKeyId ) );
}
}
catch ( SchemaRuleNotFoundException | DropIndexFailureException e )
{
throw new ConstraintViolationException( String.format(
"Unable to drop index on label `%s` for property %s.", label.name(), propertyKey ), e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public ConstraintDefinition createPropertyUniquenessConstraint( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
try
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
statement.schemaWriteOperations().uniquenessConstraintCreate( labelId, propertyKeyId );
return new PropertyUniqueConstraintDefinition( this, label, propertyKey );
}
catch ( AlreadyConstrainedException e )
{
throw new ConstraintViolationException( format(
"Label '%s' and property '%s' have a unique constraint defined on them.",
label.name(), propertyKey ), e );
}
catch ( CreateConstraintFailureException e )
{
throw new ConstraintViolationException(
e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) ), e );
}
catch ( AlreadyIndexedException e )
{
throw new ConstraintViolationException(
format( "There already exists an index for label '%s' on property '%s'. " +
"A constraint cannot be created until the index has been dropped.",
label.name(), propertyKey ), e );
}
catch ( IllegalTokenNameException e )
{
throw new IllegalArgumentException( e );
}
catch ( TooManyLabelsException e )
{
throw new IllegalStateException( e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new InvalidTransactionTypeException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
}
@Override
public void dropPropertyUniquenessConstraint( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
UniquenessConstraint constraint = new UniquenessConstraint( labelId, propertyKeyId );
statement.schemaWriteOperations().constraintDrop( constraint );
}
catch ( IllegalTokenNameException | TooManyLabelsException | DropConstraintFailureException e )
{
throw new ThisShouldNotHappenError( "Mattias", "Unable to drop property unique constraint", e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public String getUserMessage( KernelException e )
{
try ( Statement statement = ctxProvider.instance() )
{
return e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) );
}
}
@Override
public void assertInTransaction()
{
ctxProvider.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_SchemaImpl.java
|
1,330
|
{
@Override
public ConstraintDefinition apply( UniquenessConstraint constraint )
{
int labelId = constraint.label();
try
{
Label label = label( readOperations.labelGetName( labelId ) );
return new PropertyUniqueConstraintDefinition( actions, label,
readOperations.propertyKeyGetName( constraint.propertyKeyId() ) );
}
catch ( PropertyKeyIdNotFoundKernelException e )
{
throw new ThisShouldNotHappenError( "Mattias", "Couldn't find property name for " +
constraint.propertyKeyId(), e );
}
catch ( LabelNotFoundKernelException e )
{
throw new ThisShouldNotHappenError( "Stefan",
"Couldn't find label name for label id " +
labelId, e );
}
}
}, constraints );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_SchemaImpl.java
|
1,331
|
{
@Override
public IndexDefinition apply( IndexDescriptor rule )
{
try
{
Label label = label( statement.labelGetName( rule.getLabelId() ) );
String propertyKey = statement.propertyKeyGetName( rule.getPropertyKeyId() );
return new IndexDefinitionImpl( actions, label, propertyKey, constraintIndex );
}
catch ( LabelNotFoundKernelException | PropertyKeyIdNotFoundKernelException e )
{
throw new RuntimeException( e );
}
}
}, indexes ), definitions );
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_SchemaImpl.java
|
1,332
|
public class SchemaImpl implements Schema
{
private final ThreadToStatementContextBridge statementContextProvider;
private final InternalSchemaActions actions;
public SchemaImpl( ThreadToStatementContextBridge statementContextProvider )
{
this.statementContextProvider = statementContextProvider;
this.actions = new GDBSchemaActions( statementContextProvider );
}
@Override
public IndexCreator indexFor( Label label )
{
assertInTransaction();
return new IndexCreatorImpl( actions, label );
}
@Override
public Iterable<IndexDefinition> getIndexes( final Label label )
{
assertInTransaction();
try ( Statement statement = statementContextProvider.instance() )
{
List<IndexDefinition> definitions = new ArrayList<>();
int labelId = statement.readOperations().labelGetForName( label.name() );
if ( labelId == KeyReadOperations.NO_SUCH_LABEL )
{
return emptyList();
}
addDefinitions( definitions, statement.readOperations(), statement.readOperations().indexesGetForLabel( labelId ), false );
addDefinitions( definitions, statement.readOperations(), statement.readOperations().uniqueIndexesGetForLabel( labelId ), true );
return definitions;
}
}
@Override
public Iterable<IndexDefinition> getIndexes()
{
assertInTransaction();
try ( Statement statement = statementContextProvider.instance() )
{
List<IndexDefinition> definitions = new ArrayList<>();
addDefinitions( definitions, statement.readOperations(), statement.readOperations().indexesGetAll(), false );
addDefinitions( definitions, statement.readOperations(), statement.readOperations().uniqueIndexesGetAll(), true );
return definitions;
}
}
private void addDefinitions( List<IndexDefinition> definitions, final ReadOperations statement,
Iterator<IndexDescriptor> indexes, final boolean constraintIndex )
{
addToCollection( map( new Function<IndexDescriptor, IndexDefinition>()
{
@Override
public IndexDefinition apply( IndexDescriptor rule )
{
try
{
Label label = label( statement.labelGetName( rule.getLabelId() ) );
String propertyKey = statement.propertyKeyGetName( rule.getPropertyKeyId() );
return new IndexDefinitionImpl( actions, label, propertyKey, constraintIndex );
}
catch ( LabelNotFoundKernelException | PropertyKeyIdNotFoundKernelException e )
{
throw new RuntimeException( e );
}
}
}, indexes ), definitions );
}
@Override
public void awaitIndexOnline( IndexDefinition index, long duration, TimeUnit unit )
{
assertInTransaction();
long timeout = System.currentTimeMillis() + unit.toMillis( duration );
do
{
IndexState state = getIndexState( index );
switch ( state )
{
case ONLINE:
return;
case FAILED:
throw new IllegalStateException( "Index entered a FAILED state. Please see database logs." );
default:
try
{
Thread.sleep( 100 );
}
catch ( InterruptedException e )
{ // What to do?
}
break;
}
} while ( System.currentTimeMillis() < timeout );
throw new IllegalStateException( "Expected index to come online within a reasonable time." );
}
@Override
public void awaitIndexesOnline( long duration, TimeUnit unit )
{
assertInTransaction();
long millisLeft = TimeUnit.MILLISECONDS.convert( duration, unit );
Collection<IndexDefinition> onlineIndexes = new ArrayList<>();
for ( Iterator<IndexDefinition> iter = getIndexes().iterator(); iter.hasNext(); )
{
if ( millisLeft < 0 )
{
throw new IllegalStateException( "Expected all indexes to come online within a reasonable time."
+ "Indexes brought online: " + onlineIndexes
+ ". Indexes not guaranteed to be online: " + asCollection( iter ) );
}
IndexDefinition index = iter.next();
long millisBefore = System.currentTimeMillis();
awaitIndexOnline( index, millisLeft, TimeUnit.MILLISECONDS );
millisLeft -= System.currentTimeMillis() - millisBefore;
onlineIndexes.add( index );
}
}
@Override
public IndexState getIndexState( final IndexDefinition index )
{
assertInTransaction();
String propertyKey = single( index.getPropertyKeys() );
try ( Statement statement = statementContextProvider.instance() )
{
int labelId = statement.readOperations().labelGetForName( index.getLabel().name() );
int propertyKeyId = statement.readOperations().propertyKeyGetForName( propertyKey );
if ( labelId == KeyReadOperations.NO_SUCH_LABEL )
{
throw new NotFoundException( format( "Label %s not found", index.getLabel().name() ) );
}
if ( propertyKeyId == KeyReadOperations.NO_SUCH_PROPERTY_KEY )
{
throw new NotFoundException( format( "Property key %s not found", propertyKey ) );
}
IndexDescriptor descriptor = statement.readOperations().indexesGetForLabelAndPropertyKey( labelId, propertyKeyId );
InternalIndexState indexState = statement.readOperations().indexGetState( descriptor );
switch ( indexState )
{
case POPULATING:
return POPULATING;
case ONLINE:
return ONLINE;
case FAILED:
return FAILED;
default:
throw new IllegalArgumentException( String.format( "Illegal index state %s", indexState ) );
}
}
catch ( SchemaRuleNotFoundException | IndexNotFoundKernelException e )
{
throw new NotFoundException( format( "No index for label %s on property %s",
index.getLabel().name(), propertyKey ) );
}
}
@Override
public String getIndexFailure( IndexDefinition index )
{
assertInTransaction();
String propertyKey = single( index.getPropertyKeys() );
try ( Statement statement = statementContextProvider.instance() )
{
int labelId = statement.readOperations().labelGetForName( index.getLabel().name() );
int propertyKeyId = statement.readOperations().propertyKeyGetForName( propertyKey );
if ( labelId == KeyReadOperations.NO_SUCH_LABEL )
{
throw new NotFoundException( format( "Label %s not found", index.getLabel().name() ) );
}
if ( propertyKeyId == KeyReadOperations.NO_SUCH_PROPERTY_KEY )
{
throw new NotFoundException( format( "Property key %s not found", propertyKey ) );
}
IndexDescriptor indexId = statement.readOperations().indexesGetForLabelAndPropertyKey( labelId, propertyKeyId );
return statement.readOperations().indexGetFailure( indexId );
}
catch ( SchemaRuleNotFoundException | IndexNotFoundKernelException e )
{
throw new NotFoundException( format( "No index for label %s on property %s",
index.getLabel().name(), propertyKey ) );
}
}
@Override
public ConstraintCreator constraintFor( Label label )
{
assertInTransaction();
return new BaseConstraintCreator( actions, label );
}
@Override
public Iterable<ConstraintDefinition> getConstraints()
{
assertInTransaction();
try ( Statement statement = statementContextProvider.instance() )
{
Iterator<UniquenessConstraint> constraints = statement.readOperations().constraintsGetAll();
return asConstraintDefinitions( statement.readOperations(), constraints );
}
}
@Override
public Iterable<ConstraintDefinition> getConstraints( final Label label )
{
assertInTransaction();
try ( Statement statement = statementContextProvider.instance() )
{
int labelId = statement.readOperations().labelGetForName( label.name() );
if ( labelId == KeyReadOperations.NO_SUCH_LABEL )
{
return emptyList();
}
Iterator<UniquenessConstraint> constraints = statement.readOperations().constraintsGetForLabel( labelId );
return asConstraintDefinitions( statement.readOperations(), constraints );
}
}
private Iterable<ConstraintDefinition> asConstraintDefinitions(
final ReadOperations readOperations, Iterator<UniquenessConstraint> constraints )
{
Iterator<ConstraintDefinition> definitions =
map( new Function<UniquenessConstraint, ConstraintDefinition>()
{
@Override
public ConstraintDefinition apply( UniquenessConstraint constraint )
{
int labelId = constraint.label();
try
{
Label label = label( readOperations.labelGetName( labelId ) );
return new PropertyUniqueConstraintDefinition( actions, label,
readOperations.propertyKeyGetName( constraint.propertyKeyId() ) );
}
catch ( PropertyKeyIdNotFoundKernelException e )
{
throw new ThisShouldNotHappenError( "Mattias", "Couldn't find property name for " +
constraint.propertyKeyId(), e );
}
catch ( LabelNotFoundKernelException e )
{
throw new ThisShouldNotHappenError( "Stefan",
"Couldn't find label name for label id " +
labelId, e );
}
}
}, constraints );
// Intentionally iterator over it so that we can close the statement context within this method
return asCollection( definitions );
}
private static class GDBSchemaActions implements InternalSchemaActions
{
private final ThreadToStatementContextBridge ctxProvider;
public GDBSchemaActions( ThreadToStatementContextBridge ctxProvider )
{
this.ctxProvider = ctxProvider;
}
@Override
public IndexDefinition createIndexDefinition( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
try
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
statement.schemaWriteOperations().indexCreate( labelId, propertyKeyId );
return new IndexDefinitionImpl( this, label, propertyKey, false );
}
catch ( AlreadyIndexedException e )
{
throw new ConstraintViolationException(
format( "There already exists an index for label '%s' on property '%s'.",
label.name(), propertyKey ), e );
}
catch ( AlreadyConstrainedException e )
{
throw new ConstraintViolationException( format(
"Label '%s' and property '%s' have a unique constraint defined on them, so an index is " +
"already created that matches this.", label.name(), propertyKey ), e );
}
catch ( AddIndexFailureException e )
{
throw new ConstraintViolationException(
e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) ), e );
}
catch ( IllegalTokenNameException e )
{
throw new IllegalArgumentException( e );
}
catch ( TooManyLabelsException e )
{
throw new IllegalStateException( e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
}
@Override
public void dropIndexDefinitions( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
int labelId = statement.readOperations().labelGetForName( label.name() );
int propertyKeyId = statement.readOperations().propertyKeyGetForName( propertyKey );
if ( labelId != KeyReadOperations.NO_SUCH_LABEL && propertyKeyId != KeyReadOperations
.NO_SUCH_PROPERTY_KEY )
{
statement.schemaWriteOperations().indexDrop( statement.readOperations().indexesGetForLabelAndPropertyKey( labelId, propertyKeyId ) );
}
}
catch ( SchemaRuleNotFoundException | DropIndexFailureException e )
{
throw new ConstraintViolationException( String.format(
"Unable to drop index on label `%s` for property %s.", label.name(), propertyKey ), e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public ConstraintDefinition createPropertyUniquenessConstraint( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
try
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
statement.schemaWriteOperations().uniquenessConstraintCreate( labelId, propertyKeyId );
return new PropertyUniqueConstraintDefinition( this, label, propertyKey );
}
catch ( AlreadyConstrainedException e )
{
throw new ConstraintViolationException( format(
"Label '%s' and property '%s' have a unique constraint defined on them.",
label.name(), propertyKey ), e );
}
catch ( CreateConstraintFailureException e )
{
throw new ConstraintViolationException(
e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) ), e );
}
catch ( AlreadyIndexedException e )
{
throw new ConstraintViolationException(
format( "There already exists an index for label '%s' on property '%s'. " +
"A constraint cannot be created until the index has been dropped.",
label.name(), propertyKey ), e );
}
catch ( IllegalTokenNameException e )
{
throw new IllegalArgumentException( e );
}
catch ( TooManyLabelsException e )
{
throw new IllegalStateException( e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new InvalidTransactionTypeException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
}
@Override
public void dropPropertyUniquenessConstraint( Label label, String propertyKey )
{
try ( Statement statement = ctxProvider.instance() )
{
int labelId = statement.schemaWriteOperations().labelGetOrCreateForName( label.name() );
int propertyKeyId = statement.schemaWriteOperations().propertyKeyGetOrCreateForName( propertyKey );
UniquenessConstraint constraint = new UniquenessConstraint( labelId, propertyKeyId );
statement.schemaWriteOperations().constraintDrop( constraint );
}
catch ( IllegalTokenNameException | TooManyLabelsException | DropConstraintFailureException e )
{
throw new ThisShouldNotHappenError( "Mattias", "Unable to drop property unique constraint", e );
}
catch ( InvalidTransactionTypeKernelException e )
{
throw new ConstraintViolationException( e.getMessage(), e );
}
catch ( ReadOnlyDatabaseKernelException e )
{
throw new ReadOnlyDbException();
}
}
@Override
public String getUserMessage( KernelException e )
{
try ( Statement statement = ctxProvider.instance() )
{
return e.getUserMessage( new StatementTokenNameLookup( statement.readOperations() ) );
}
}
@Override
public void assertInTransaction()
{
ctxProvider.assertInTransaction();
}
}
private void assertInTransaction()
{
statementContextProvider.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_SchemaImpl.java
|
1,333
|
public class PropertyUniqueConstraintDefinition implements ConstraintDefinition
{
private final InternalSchemaActions actions;
private final Label label;
private final String propertyKey;
public PropertyUniqueConstraintDefinition( InternalSchemaActions actions, Label label, String propertyKey )
{
this.actions = actions;
this.label = label;
this.propertyKey = propertyKey;
}
@Override
public void drop()
{
assertInTransaction();
actions.dropPropertyUniquenessConstraint( label, propertyKey );
}
@Override
public Iterable<String> getPropertyKeys()
{
assertInTransaction();
return singletonList( propertyKey );
}
@Override
public Label getLabel()
{
assertInTransaction();
return label;
}
@Override
public ConstraintType getConstraintType()
{
assertInTransaction();
return ConstraintType.UNIQUENESS;
}
@Override
public boolean isConstraintType( ConstraintType type )
{
assertInTransaction();
return getConstraintType().equals( type );
}
@Override
public boolean equals( Object o )
{
if ( this == o )
{
return true;
}
if ( o == null || getClass() != o.getClass() )
{
return false;
}
PropertyUniqueConstraintDefinition that = (PropertyUniqueConstraintDefinition) o;
if ( !actions.equals( that.actions ) )
{
return false;
}
if ( !label.equals( that.label ) )
{
return false;
}
if ( !propertyKey.equals( that.propertyKey ) )
{
return false;
}
return true;
}
@Override
public int hashCode()
{
int result = actions.hashCode();
result = 31 * result + label.name().hashCode();
result = 31 * result + propertyKey.hashCode();
return result;
}
@Override
public String toString()
{
// using label name as a good identifier name
return String.format( "%s.%s IS UNIQUE", label.name().toLowerCase(), propertyKey );
}
private final void assertInTransaction()
{
actions.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_PropertyUniqueConstraintDefinition.java
|
1,334
|
public class PropertyUniqueConstraintCreator extends BaseConstraintCreator
{
// Only single property key supported a.t.m.
protected final String propertyKey;
PropertyUniqueConstraintCreator( InternalSchemaActions internalCreator, Label label, String propertyKeyOrNull )
{
super( internalCreator, label );
this.propertyKey = propertyKeyOrNull;
}
@Override
public final ConstraintCreator assertPropertyIsUnique( String propertyKey )
{
throw new UnsupportedOperationException( "You can only create one unique constraint at a time." );
}
@Override
public final ConstraintDefinition create()
{
assertInTransaction();
try
{
return actions.createPropertyUniquenessConstraint( label, propertyKey );
}
catch ( KernelException e )
{
String userMessage = actions.getUserMessage( e );
throw new ConstraintViolationException( userMessage, e );
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_PropertyUniqueConstraintCreator.java
|
1,335
|
public class IndexDefinitionImpl implements IndexDefinition
{
private final InternalSchemaActions actions;
private final Label label;
private final String propertyKey;
private final boolean constraintIndex;
public IndexDefinitionImpl( InternalSchemaActions actions, Label label, String propertyKey,
boolean constraintIndex )
{
this.actions = actions;
this.label = label;
this.propertyKey = propertyKey;
this.constraintIndex = constraintIndex;
assertInTransaction();
}
@Override
public Label getLabel()
{
assertInTransaction();
return label;
}
@Override
public Iterable<String> getPropertyKeys()
{
assertInTransaction();
return asList( propertyKey );
}
@Override
public void drop()
{
// expected to call assertInTransaction()
if ( this.isConstraintIndex() )
{
throw new IllegalStateException( "Constraint indexes cannot be dropped directly, " +
"instead drop the owning uniqueness constraint." );
}
actions.dropIndexDefinitions( label, propertyKey );
}
@Override
public boolean isConstraintIndex()
{
assertInTransaction();
return constraintIndex;
}
@Override
public int hashCode()
{
final int prime = 31;
int result = 1;
result = prime * result + label.name().hashCode();
result = prime * result + propertyKey.hashCode();
return result;
}
@Override
public boolean equals( Object obj )
{
if ( this == obj )
{
return true;
}
if ( obj == null )
{
return false;
}
if ( getClass() != obj.getClass() )
{
return false;
}
IndexDefinitionImpl other = (IndexDefinitionImpl) obj;
return label.name().equals( other.label.name() ) && propertyKey.equals( other.propertyKey );
}
@Override
public String toString()
{
return "IndexDefinition[label:" + label + ", on:" + propertyKey + "]";
}
protected void assertInTransaction()
{
actions.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_IndexDefinitionImpl.java
|
1,336
|
public class IndexCreatorImpl implements IndexCreator
{
private final Collection<String> propertyKeys;
private final Label label;
private final InternalSchemaActions actions;
public IndexCreatorImpl( InternalSchemaActions actions, Label label )
{
this( actions, label, new ArrayList<String>() );
}
private IndexCreatorImpl( InternalSchemaActions actions, Label label, Collection<String> propertyKeys )
{
this.actions = actions;
this.label = label;
this.propertyKeys = propertyKeys;
assertInTransaction();
}
@Override
public IndexCreator on( String propertyKey )
{
assertInTransaction();
if ( !propertyKeys.isEmpty() )
throw new UnsupportedOperationException(
"Compound indexes are not yet supported, only one property per index is allowed." );
return
new IndexCreatorImpl( actions, label,
addToCollection( asList( propertyKey ), new ArrayList<>( propertyKeys ) ) );
}
@Override
public IndexDefinition create() throws ConstraintViolationException
{
assertInTransaction();
if ( propertyKeys.isEmpty() )
throw new ConstraintViolationException( "An index needs at least one property key to index" );
return actions.createIndexDefinition( label, single( propertyKeys ) );
}
protected void assertInTransaction()
{
actions.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_IndexCreatorImpl.java
|
1,337
|
public class BaseConstraintCreator implements ConstraintCreator
{
protected final InternalSchemaActions actions;
protected final Label label;
public BaseConstraintCreator( InternalSchemaActions actions, Label label )
{
this.actions = actions;
this.label = label;
assertInTransaction();
}
@Override
public ConstraintCreator assertPropertyIsUnique( String propertyKey )
{
return new PropertyUniqueConstraintCreator( actions, label, propertyKey );
}
@Override
public ConstraintDefinition create()
{
assertInTransaction();
throw new IllegalStateException( "No constraint assertions specified" );
}
protected final void assertInTransaction()
{
actions.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_schema_BaseConstraintCreator.java
|
1,338
|
static class RelationshipReadOnlyIndexToIndexAdapter extends
ReadOnlyIndexToIndexAdapter<Relationship> implements
RelationshipIndex
{
private final ReadableRelationshipIndex delegate;
public RelationshipReadOnlyIndexToIndexAdapter(
ReadableRelationshipIndex delegate )
{
super( delegate );
this.delegate = delegate;
}
@Override
public IndexHits<Relationship> get( String key, Object valueOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
return delegate.get( key,
valueOrNull, startNodeOrNull,
endNodeOrNull );
}
@Override
public IndexHits<Relationship> query( String key,
Object queryOrQueryObjectOrNull, Node startNodeOrNull,
Node endNodeOrNull )
{
return delegate.query( key,
queryOrQueryObjectOrNull,
startNodeOrNull, endNodeOrNull );
}
@Override
public IndexHits<Relationship> query( Object queryOrQueryObjectOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
return delegate.query(
queryOrQueryObjectOrNull, startNodeOrNull,
endNodeOrNull );
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_RelationshipAutoIndexerImpl.java
|
1,339
|
public static abstract class Configuration
{
public static final Setting<Boolean> relationship_auto_indexing = GraphDatabaseSettings
.relationship_auto_indexing;
public static final Setting<String> relationship_keys_indexable = GraphDatabaseSettings
.relationship_keys_indexable;
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_RelationshipAutoIndexerImpl.java
|
1,340
|
public class RelationshipAutoIndexerImpl extends AbstractAutoIndexerImpl<Relationship>
implements RelationshipAutoIndexer
{
public static abstract class Configuration
{
public static final Setting<Boolean> relationship_auto_indexing = GraphDatabaseSettings
.relationship_auto_indexing;
public static final Setting<String> relationship_keys_indexable = GraphDatabaseSettings
.relationship_keys_indexable;
}
static final String RELATIONSHIP_AUTO_INDEX = "relationship_auto_index";
private Config config;
private IndexManagerImpl indexManager;
private NodeManager nodeManager;
public RelationshipAutoIndexerImpl( Config config, IndexManagerImpl indexManager, NodeManager nodeManager )
{
super();
this.config = config;
this.indexManager = indexManager;
this.nodeManager = nodeManager;
}
@Override
public void init()
throws Throwable
{
}
@Override
public void start()
{
setEnabled( config.get( Configuration.relationship_auto_indexing ) );
propertyKeysToInclude.addAll( parseConfigList( config.get( Configuration.relationship_keys_indexable ) ) );
}
@Override
public void stop()
throws Throwable
{
}
@Override
public void shutdown()
throws Throwable
{
}
@Override
protected RelationshipIndex getIndexInternal()
{
return indexManager.getOrCreateRelationshipIndex(
RELATIONSHIP_AUTO_INDEX, null );
}
@Override
public ReadableRelationshipIndex getAutoIndex()
{
return getIndexInternal();
}
@Override
public void setEnabled( boolean enabled )
{
super.setEnabled( enabled );
if ( enabled )
{
nodeManager.addRelationshipPropertyTracker(
this );
}
else
{
nodeManager.removeRelationshipPropertyTracker(
this );
}
}
static class RelationshipReadOnlyIndexToIndexAdapter extends
ReadOnlyIndexToIndexAdapter<Relationship> implements
RelationshipIndex
{
private final ReadableRelationshipIndex delegate;
public RelationshipReadOnlyIndexToIndexAdapter(
ReadableRelationshipIndex delegate )
{
super( delegate );
this.delegate = delegate;
}
@Override
public IndexHits<Relationship> get( String key, Object valueOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
return delegate.get( key,
valueOrNull, startNodeOrNull,
endNodeOrNull );
}
@Override
public IndexHits<Relationship> query( String key,
Object queryOrQueryObjectOrNull, Node startNodeOrNull,
Node endNodeOrNull )
{
return delegate.query( key,
queryOrQueryObjectOrNull,
startNodeOrNull, endNodeOrNull );
}
@Override
public IndexHits<Relationship> query( Object queryOrQueryObjectOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
return delegate.query(
queryOrQueryObjectOrNull, startNodeOrNull,
endNodeOrNull );
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_RelationshipAutoIndexerImpl.java
|
1,341
|
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,342
|
{
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
if ( ((DummyKernelEventHandler) other).resource == RESOURCE1 )
{
return ExecutionOrder.BEFORE;
}
return ExecutionOrder.DOESNT_MATTER;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,343
|
public class DummyIndexExtensionFactory extends
KernelExtensionFactory<DummyIndexExtensionFactory.Dependencies> implements IndexImplementation, Lifecycle
{
static final String IDENTIFIER = "test-dummy-neo-index";
private InternalAbstractGraphDatabase db;
private IndexProviders indexProviders;
public DummyIndexExtensionFactory()
{
super( IDENTIFIER );
}
public interface Dependencies
{
InternalAbstractGraphDatabase getDatabase();
IndexProviders getIndexProviders();
}
@Override
public Lifecycle newKernelExtension( Dependencies dependencies ) throws Throwable
{
db = dependencies.getDatabase();
indexProviders = dependencies.getIndexProviders();
return this;
}
@Override
public void init() throws Throwable
{
}
@Override
public void start() throws Throwable
{
indexProviders.registerIndexProvider( IDENTIFIER, this );
}
@Override
public void stop() throws Throwable
{
indexProviders.unregisterIndexProvider( IDENTIFIER );
}
@Override
public void shutdown() throws Throwable
{
}
@Override
public String getDataSourceName()
{
return NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME;
}
@Override
public Index<Node> nodeIndex( String indexName, Map<String, String> config )
{
return new DummyNodeIndex( indexName, db );
}
@Override
public RelationshipIndex relationshipIndex( String indexName, Map<String, String> config )
{
return new DummyRelationshipIndex( indexName, db );
}
@Override
public Map<String, String> fillInDefaults( Map<String, String> config )
{
return config;
}
@Override
public boolean configMatches( Map<String, String> storedConfig, Map<String, String> config )
{
return true;
}
private abstract class DummyIndex<T extends PropertyContainer> implements Index<T>
{
private final String name;
private final InternalAbstractGraphDatabase db;
public DummyIndex( String name, InternalAbstractGraphDatabase db )
{
this.name = name;
this.db = db;
}
@Override
public String getName()
{
return name;
}
@Override
public IndexHits<T> get( String key, Object value )
{
return new IteratorIndexHits<>( Collections.<T>emptyList() );
}
@Override
public IndexHits<T> query( String key, Object queryOrQueryObject )
{
throw new UnsupportedOperationException();
}
@Override
public IndexHits<T> query( Object queryOrQueryObject )
{
throw new UnsupportedOperationException();
}
@Override
public boolean isWriteable()
{
return false;
}
@Override
public GraphDatabaseService getGraphDatabase()
{
return null;
}
@Override
public void add( T entity, String key, Object value )
{
throw new UnsupportedOperationException();
}
@Override
public void remove( T entity, String key, Object value )
{
throw new UnsupportedOperationException();
}
@Override
public void remove( T entity, String key )
{
throw new UnsupportedOperationException();
}
@Override
public void remove( T entity )
{
throw new UnsupportedOperationException();
}
@Override
public void delete()
{
throw new UnsupportedOperationException();
}
@Override
public T putIfAbsent( T entity, String key, Object value )
{
throw new UnsupportedOperationException();
}
}
private class DummyNodeIndex extends DummyIndex<Node>
{
public DummyNodeIndex( String name, InternalAbstractGraphDatabase db )
{
super( name, db );
}
@Override
public Class<Node> getEntityType()
{
return Node.class;
}
}
private class DummyRelationshipIndex extends DummyIndex<Relationship> implements RelationshipIndex
{
public DummyRelationshipIndex( String name, InternalAbstractGraphDatabase db )
{
super( name, db );
}
@Override
public Class<Relationship> getEntityType()
{
return Relationship.class;
}
@Override
public IndexHits<Relationship> get( String key, Object valueOrNull, Node startNodeOrNull,
Node endNodeOrNull )
{
throw new UnsupportedOperationException();
}
@Override
public IndexHits<Relationship> query( String key, Object queryOrQueryObjectOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
throw new UnsupportedOperationException();
}
@Override
public IndexHits<Relationship> query( Object queryOrQueryObjectOrNull,
Node startNodeOrNull, Node endNodeOrNull )
{
throw new UnsupportedOperationException();
}
}
private static class IteratorIndexHits<T> implements IndexHits<T>
{
private final List<T> list;
private final Iterator<T> iterator;
IteratorIndexHits( List<T> list )
{
this.list = list;
this.iterator = list.iterator();
}
@Override
public boolean hasNext()
{
return iterator.hasNext();
}
@Override
public T next()
{
return iterator.next();
}
@Override
public void remove()
{
iterator.remove();
}
@Override
public IndexHits<T> iterator()
{
return this;
}
@Override
public int size()
{
return list.size();
}
@Override
public void close()
{
}
@Override
public T getSingle()
{
return IteratorUtil.singleOrNull( (Iterator<T>) this );
}
@Override
public float currentScore()
{
return Float.NaN;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_index_DummyIndexExtensionFactory.java
|
1,344
|
private static abstract class DummyKernelEventHandler implements KernelEventHandler
{
private static int counter;
private Integer beforeShutdown, kernelPanic;
private final Object resource;
DummyKernelEventHandler( Object resource )
{
this.resource = resource;
}
@Override
public void beforeShutdown()
{
beforeShutdown = counter++;
}
@Override
public Object getResource()
{
return this.resource;
}
@Override
public void kernelPanic( ErrorState error )
{
kernelPanic = counter++;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelEvents.java
|
1,345
|
public static class DummyConnection extends XaConnectionHelpImpl implements IndexXaConnection
{
private final XAResource resource;
public DummyConnection( XaResourceManager xaRm, byte[] branchId )
{
super( xaRm );
resource = new DummyResource( "some identifier", xaRm, branchId );
}
@Override
public void createIndex( Class<? extends PropertyContainer> entityType, String indexName,
Map<String, String> config )
{
}
@Override
public XAResource getXaResource()
{
return resource;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_index_DummyIndexDataSource.java
|
1,346
|
public class DummyIndexDataSource extends LogBackedXaDataSource
{
public DummyIndexDataSource( byte[] branchId, String name )
{
super( branchId, name );
}
@Override
public XaConnection getXaConnection()
{
return null;
}
@Override
public void init()
{
}
@Override
public void start()
{
}
@Override
public void stop()
{
}
@Override
public void shutdown()
{
}
public static class DummyConnection extends XaConnectionHelpImpl implements IndexXaConnection
{
private final XAResource resource;
public DummyConnection( XaResourceManager xaRm, byte[] branchId )
{
super( xaRm );
resource = new DummyResource( "some identifier", xaRm, branchId );
}
@Override
public void createIndex( Class<? extends PropertyContainer> entityType, String indexName,
Map<String, String> config )
{
}
@Override
public XAResource getXaResource()
{
return resource;
}
}
private static class DummyResource extends XaResourceHelpImpl
{
private final Object identifier;
DummyResource( Object identifier, XaResourceManager xaRm,
byte[] branchId )
{
super( xaRm, branchId );
this.identifier = identifier;
}
@Override
public boolean isSameRM( XAResource xares )
{
if ( xares instanceof DummyResource )
{
return identifier.equals(
((DummyResource) xares).identifier );
}
return false;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_index_DummyIndexDataSource.java
|
1,347
|
public class VerifyingTransactionEventHandler implements
TransactionEventHandler<Object>
{
private final ExpectedTransactionData expectedData;
private boolean hasBeenCalled;
private Throwable failure;
public VerifyingTransactionEventHandler( ExpectedTransactionData expectedData )
{
this.expectedData = expectedData;
}
@Override
public void afterCommit( TransactionData data, Object state )
{
verify( data );
}
@Override
public void afterRollback( TransactionData data, Object state )
{
}
@Override
public Object beforeCommit( TransactionData data ) throws Exception
{
return verify( data );
}
private Object verify( TransactionData data )
{
// TODO Hmm, makes me think... should we really call transaction event handlers
// for these relationship type / property index transactions?
if ( count( data.createdNodes() ) == 0 )
{
return null;
}
try
{
this.expectedData.compareTo( data );
this.hasBeenCalled = true;
return null;
}
catch ( Exception e )
{
failure = e;
throw e;
}
}
boolean hasBeenCalled()
{
return this.hasBeenCalled;
}
Throwable failure()
{
return this.failure;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_VerifyingTransactionEventHandler.java
|
1,348
|
class TransactionDataSortOf
{
final Set<Node> expectedCreatedNodes = new HashSet<Node>();
final Set<Relationship> expectedCreatedRelationships = new HashSet<Relationship>();
final Set<Node> expectedDeletedNodes = new HashSet<Node>();
final Set<Relationship> expectedDeletedRelationships = new HashSet<Relationship>();
final Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedAssignedNodeProperties =
new HashMap<Node, Map<String, PropertyEntryImpl<Node>>>();
final Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedAssignedRelationshipProperties =
new HashMap<Relationship, Map<String, PropertyEntryImpl<Relationship>>>();
final Map<Node, Map<String, PropertyEntryImpl<Node>>> expectedRemovedNodeProperties =
new HashMap<Node, Map<String, PropertyEntryImpl<Node>>>();
final Map<Relationship, Map<String, PropertyEntryImpl<Relationship>>> expectedRemovedRelationshipProperties =
new HashMap<Relationship, Map<String, PropertyEntryImpl<Relationship>>>();
void assignedProperty( Node node, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedAssignedNodeProperties, node, key, value, valueBeforeTx );
}
void assignedProperty( Relationship rel, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedAssignedRelationshipProperties, rel, key, value, valueBeforeTx );
}
void removedProperty( Node node, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedRemovedNodeProperties, node, key, value, valueBeforeTx );
}
void removedProperty( Relationship rel, String key, Object value, Object valueBeforeTx )
{
putInMap( this.expectedRemovedRelationshipProperties, rel, key, value, valueBeforeTx );
}
<T extends PropertyContainer> void putInMap( Map<T, Map<String, PropertyEntryImpl<T>>> map,
T entity, String key, Object value, Object valueBeforeTx )
{
Map<String, PropertyEntryImpl<T>> innerMap = map.get( entity );
if ( innerMap == null )
{
innerMap = new HashMap<String, PropertyEntryImpl<T>>();
map.put( entity, innerMap );
}
innerMap.put( key, new PropertyEntryImpl<T>( entity, key, value, valueBeforeTx ) );
}
void compareTo( TransactionData data )
{
for ( Node node : data.createdNodes() )
{
assertTrue( expectedCreatedNodes.remove( node ) );
}
assertTrue( expectedCreatedNodes.isEmpty() );
for ( Relationship rel : data.createdRelationships() )
{
assertTrue( expectedCreatedRelationships.remove( rel ) );
}
assertTrue( expectedCreatedRelationships.isEmpty() );
for ( Node node : data.deletedNodes() )
{
assertTrue( expectedDeletedNodes.remove( node ) );
}
assertTrue( expectedDeletedNodes.isEmpty() );
for ( Relationship rel : data.deletedRelationships() )
{
assertTrue( expectedDeletedRelationships.remove( rel ) );
}
assertTrue( expectedDeletedRelationships.isEmpty() );
for ( PropertyEntry<Node> entry : data.assignedNodeProperties() )
{
checkAssigned( expectedAssignedNodeProperties, entry );
}
assertTrue( expectedAssignedNodeProperties.isEmpty() );
for ( PropertyEntry<Relationship> entry : data.assignedRelationshipProperties() )
{
checkAssigned( expectedAssignedRelationshipProperties, entry );
}
assertTrue( expectedAssignedRelationshipProperties.isEmpty() );
for ( PropertyEntry<Node> entry : data.removedNodeProperties() )
{
checkRemoved( expectedRemovedNodeProperties, entry );
}
assertTrue( expectedRemovedNodeProperties.isEmpty() );
for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() )
{
checkRemoved( expectedRemovedRelationshipProperties, entry );
}
assertTrue( expectedRemovedRelationshipProperties.isEmpty() );
}
<T extends PropertyContainer> void checkAssigned(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
fetchExpectedPropertyEntry( map, entry ).compareToAssigned( entry );
}
<T extends PropertyContainer> void checkRemoved(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
fetchExpectedPropertyEntry( map, entry ).compareToRemoved( entry );
}
<T extends PropertyContainer> PropertyEntryImpl<T> fetchExpectedPropertyEntry(
Map<T, Map<String, PropertyEntryImpl<T>>> map, PropertyEntry<T> entry )
{
Map<String, PropertyEntryImpl<T>> innerMap = map.get( entry.entity() );
assertNotNull( innerMap );
PropertyEntryImpl<T> expectedEntry = innerMap.remove( entry.key() );
assertNotNull( expectedEntry );
if ( innerMap.isEmpty() )
{
map.remove( entry.entity() );
}
return expectedEntry;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TransactionDataSortOf.java
|
1,349
|
private static class MyTxEventHandler implements TransactionEventHandler<Object>
{
Map<String,Object> nodeProps = new HashMap<>();
Map<String,Object> relProps = new HashMap<>();
@Override
public void afterCommit( TransactionData data, Object state )
{
for ( PropertyEntry<Node> entry : data.removedNodeProperties() )
{
String key = entry.key();
Object value = entry.previouslyCommitedValue();
nodeProps.put( key, value );
}
for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() )
{
relProps.put( entry.key(), entry.previouslyCommitedValue() );
}
}
@Override
public void afterRollback( TransactionData data, Object state )
{
}
@Override
public Object beforeCommit( TransactionData data )
throws Exception
{
return null;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,350
|
private static class FailingEventHandler<T> implements TransactionEventHandler<T>
{
private final TransactionEventHandler<T> source;
private final boolean willFail;
public FailingEventHandler( TransactionEventHandler<T> source, boolean willFail )
{
this.source = source;
this.willFail = willFail;
}
@Override
public void afterCommit( TransactionData data, T state )
{
source.afterCommit( data, state );
}
@Override
public void afterRollback( TransactionData data, T state )
{
source.afterRollback( data, state );
}
@Override
public T beforeCommit( TransactionData data ) throws Exception
{
if ( willFail )
{
throw new Exception( "Just failing commit, that's all" );
}
return source.beforeCommit( data );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,351
|
private static class ExceptionThrowingEventHandler implements TransactionEventHandler<Object>
{
private final Exception beforeCommitException;
private final Exception afterCommitException;
private final Exception afterRollbackException;
public ExceptionThrowingEventHandler(Exception beforeCommitException,
Exception afterCommitException, Exception afterRollbackException) {
super();
this.beforeCommitException = beforeCommitException;
this.afterCommitException = afterCommitException;
this.afterRollbackException = afterRollbackException;
}
@Override
public Object beforeCommit(TransactionData data) throws Exception
{
if(beforeCommitException != null)
{
throw beforeCommitException;
}
return null;
}
@Override
public void afterCommit(TransactionData data, Object state)
{
if(afterCommitException != null)
{
throw new RuntimeException(afterCommitException);
}
}
@Override
public void afterRollback(TransactionData data, Object state)
{
if(afterRollbackException != null)
{
throw new RuntimeException(afterRollbackException);
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,352
|
private static class DummyTransactionEventHandler<T> implements
TransactionEventHandler<T>
{
private final T object;
private TransactionData receivedTransactionData;
private T receivedState;
private int counter;
private Integer beforeCommit, afterCommit, afterRollback;
public DummyTransactionEventHandler( T object )
{
this.object = object;
}
@Override
public void afterCommit( TransactionData data, T state )
{
assertNotNull( data );
this.receivedState = state;
this.afterCommit = counter++;
}
@Override
public void afterRollback( TransactionData data, T state )
{
assertNotNull( data );
this.receivedState = state;
this.afterRollback = counter++;
}
@Override
public T beforeCommit( TransactionData data ) throws Exception
{
assertNotNull( data );
this.receivedTransactionData = data;
this.beforeCommit = counter++;
if ( this.beforeCommit == 2 )
{
new Exception( "blabla" ).printStackTrace();
}
return object;
}
void reset()
{
receivedTransactionData = null;
receivedState = null;
counter = 0;
beforeCommit = null;
afterCommit = null;
afterRollback = null;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,353
|
{
@Override
protected void configure( GraphDatabaseBuilder builder )
{
builder.setConfig( cache_type, "none" );
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,354
|
class MyFancyException extends Exception
{
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,355
|
{
@Override
public Void beforeCommit( TransactionData data ) throws Exception
{
Node modifiedNode = data.assignedNodeProperties().iterator().next().entity();
assertEquals( node, modifiedNode );
modifiedNode.setProperty( key, value2 );
return null;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,356
|
public class TestTransactionEvents
{
@Test
public void testRegisterUnregisterHandlers()
{
Object value1 = 10;
Object value2 = 3.5D;
DummyTransactionEventHandler<Integer> handler1 = new DummyTransactionEventHandler<>( (Integer) value1 );
DummyTransactionEventHandler<Double> handler2 = new DummyTransactionEventHandler<>( (Double) value2 );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
try
{
db.unregisterTransactionEventHandler( handler1 );
fail( "Shouldn't be able to do unregister on a unregistered handler" );
}
catch ( IllegalStateException e )
{ /* Good */
}
assertTrue( handler1 == db.registerTransactionEventHandler( handler1 ) );
assertTrue( handler1 == db.registerTransactionEventHandler( handler1 ) );
assertTrue( handler1 == db.unregisterTransactionEventHandler( handler1 ) );
try
{
db.unregisterTransactionEventHandler( handler1 );
fail( "Shouldn't be able to do unregister on a unregistered handler" );
}
catch ( IllegalStateException e )
{ /* Good */
}
assertTrue( handler1 == db.registerTransactionEventHandler(
handler1 ) );
assertTrue( handler2 == db.registerTransactionEventHandler(
handler2 ) );
assertTrue( handler1 == db.unregisterTransactionEventHandler(
handler1 ) );
assertTrue( handler2 == db.unregisterTransactionEventHandler(
handler2 ) );
db.registerTransactionEventHandler( handler1 );
try ( Transaction tx = db.beginTx() )
{
db.createNode().delete();
tx.success();
}
assertNotNull( handler1.beforeCommit );
assertNotNull( handler1.afterCommit );
assertNull( handler1.afterRollback );
assertEquals( value1, handler1.receivedState );
assertNotNull( handler1.receivedTransactionData );
db.unregisterTransactionEventHandler( handler1 );
}
@Test
public void makeSureHandlersCantBeRegisteredTwice()
{
DummyTransactionEventHandler<Object> handler = new DummyTransactionEventHandler<>( null );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler( handler );
db.registerTransactionEventHandler( handler );
try ( Transaction tx = db.beginTx() )
{
db.createNode().delete();
tx.success();
}
assertEquals( Integer.valueOf( 0 ), handler.beforeCommit );
assertEquals( Integer.valueOf( 1 ), handler.afterCommit );
assertNull( handler.afterRollback );
db.unregisterTransactionEventHandler( handler );
}
@Test
public void shouldGetCorrectTransactionDataUponCommit()
{
// Create new data, nothing modified, just added/created
ExpectedTransactionData expectedData = new ExpectedTransactionData();
VerifyingTransactionEventHandler handler = new VerifyingTransactionEventHandler( expectedData );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler( handler );
Node node1 = null, node2, node3 = null;
Relationship rel1 = null, rel2 = null;
try
{
try ( Transaction tx = db.beginTx() )
{
node1 = db.createNode();
expectedData.expectedCreatedNodes.add( node1 );
node2 = db.createNode();
expectedData.expectedCreatedNodes.add( node2 );
rel1 = node1.createRelationshipTo( node2, RelTypes.TXEVENT );
expectedData.expectedCreatedRelationships.add( rel1 );
node1.setProperty( "name", "Mattias" );
expectedData.assignedProperty( node1, "name", "Mattias", null );
node1.setProperty( "last name", "Persson" );
expectedData.assignedProperty( node1, "last name", "Persson", null );
node1.setProperty( "counter", 10 );
expectedData.assignedProperty( node1, "counter", 10, null );
rel1.setProperty( "description", "A description" );
expectedData.assignedProperty( rel1, "description",
"A description", null );
rel1.setProperty( "number", 4.5D );
expectedData.assignedProperty( rel1, "number", 4.5D, null );
node3 = db.createNode();
expectedData.expectedCreatedNodes.add( node3 );
rel2 = node3.createRelationshipTo( node2, RelTypes.TXEVENT );
expectedData.expectedCreatedRelationships.add( rel2 );
node3.setProperty( "name", "Node 3" );
expectedData.assignedProperty( node3, "name", "Node 3", null );
tx.success();
}
assertTrue( "Should have been invoked", handler.hasBeenCalled() );
if ( handler.failure() != null )
{
throw new RuntimeException( handler.failure() );
}
}
finally
{
db.unregisterTransactionEventHandler( handler );
}
// Use the above data and modify it, change properties, delete stuff
expectedData = new ExpectedTransactionData();
handler = new VerifyingTransactionEventHandler( expectedData );
db.registerTransactionEventHandler( handler );
try
{
try ( Transaction tx = db.beginTx() )
{
Node newNode = db.createNode();
expectedData.expectedCreatedNodes.add( newNode );
Node tempNode = db.createNode();
Relationship tempRel = tempNode.createRelationshipTo( node1,
RelTypes.TXEVENT );
tempNode.setProperty( "something", "Some value" );
tempRel.setProperty( "someproperty", 101010 );
tempNode.removeProperty( "nothing" );
node3.setProperty( "test", "hello" );
node3.setProperty( "name", "No name" );
node3.delete();
expectedData.expectedDeletedNodes.add( node3 );
expectedData.removedProperty( node3, "name", null, "Node 3" );
node1.setProperty( "new name", "A name" );
node1.setProperty( "new name", "A better name" );
expectedData.assignedProperty( node1, "new name", "A better name",
null );
node1.setProperty( "name", "Nothing" );
node1.setProperty( "name", "Mattias Persson" );
expectedData.assignedProperty( node1, "name", "Mattias Persson",
"Mattias" );
node1.removeProperty( "counter" );
expectedData.removedProperty( node1, "counter", null, 10 );
node1.removeProperty( "last name" );
node1.setProperty( "last name", "Hi" );
expectedData.assignedProperty( node1, "last name", "Hi", "Persson" );
rel2.delete();
expectedData.expectedDeletedRelationships.add( rel2 );
rel1.removeProperty( "number" );
expectedData.removedProperty( rel1, "number", null, 4.5D );
rel1.setProperty( "description", "Ignored" );
rel1.setProperty( "description", "New" );
expectedData.assignedProperty( rel1, "description", "New",
"A description" );
tempRel.delete();
tempNode.delete();
tx.success();
}
assertTrue( "Should have been invoked", handler.hasBeenCalled() );
if ( handler.failure() != null )
{
throw new RuntimeException( handler.failure() );
}
}
finally
{
db.unregisterTransactionEventHandler( handler );
}
}
@Test
public void makeSureBeforeAfterAreCalledCorrectly()
{
List<TransactionEventHandler<Object>> handlers = new ArrayList<>();
handlers.add( new FailingEventHandler<>( new DummyTransactionEventHandler<>( null ), false ) );
handlers.add( new FailingEventHandler<>( new DummyTransactionEventHandler<>( null ), false ) );
handlers.add( new FailingEventHandler<>( new DummyTransactionEventHandler<>( null ), true ) );
handlers.add( new FailingEventHandler<>( new DummyTransactionEventHandler<>( null ), false ) );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
for ( TransactionEventHandler<Object> handler : handlers )
{
db.registerTransactionEventHandler( handler );
}
try
{
Transaction tx = db.beginTx();
try
{
db.createNode().delete();
tx.success();
tx.close();
fail( "Should fail commit" );
}
catch ( TransactionFailureException e )
{ // OK
}
verifyHandlerCalls( handlers, false );
db.unregisterTransactionEventHandler( handlers.remove( 2 ) );
for ( TransactionEventHandler<Object> handler : handlers )
{
((DummyTransactionEventHandler<Object>) ((FailingEventHandler<Object>)handler).source).reset();
}
try ( Transaction transaction = db.beginTx() )
{
db.createNode().delete();
transaction.success();
}
verifyHandlerCalls( handlers, true );
}
finally
{
for ( TransactionEventHandler<Object> handler : handlers )
{
db.unregisterTransactionEventHandler( handler );
}
}
}
@Test
public void shouldBeAbleToAccessExceptionThrownInEventHook()
{
class MyFancyException extends Exception
{
}
ExceptionThrowingEventHandler handler = new ExceptionThrowingEventHandler( new MyFancyException(), null, null );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler( handler );
try
{
Transaction tx = db.beginTx();
try
{
db.createNode().delete();
tx.success();
tx.close();
fail( "Should fail commit" );
}
catch ( TransactionFailureException e )
{
Throwable currentEx = e;
do
{
currentEx = currentEx.getCause();
if ( currentEx instanceof MyFancyException )
{
return;
}
}
while ( currentEx.getCause() != null );
fail("Expected to find the exception thrown in the event hook as the cause of transaction failure.");
}
}
finally
{
db.unregisterTransactionEventHandler( handler );
}
}
@Test
public void deleteNodeRelTriggerPropertyRemoveEvents()
{
GraphDatabaseService db = dbRule.getGraphDatabaseService();
Node node1;
Node node2;
Relationship rel;
try ( Transaction tx = db.beginTx() )
{
node1 = db.createNode();
node2 = db.createNode();
rel = node1.createRelationshipTo( node2, RelTypes.TXEVENT );
node1.setProperty( "test1", "stringvalue" );
node1.setProperty( "test2", 1l );
rel.setProperty( "test1", "stringvalue" );
rel.setProperty( "test2", 1l );
rel.setProperty( "test3", new int[] { 1, 2, 3 } );
tx.success();
}
MyTxEventHandler handler = new MyTxEventHandler();
db.registerTransactionEventHandler( handler );
try ( Transaction tx = db.beginTx() )
{
GraphDatabaseAPI dbApi = dbRule.getGraphDatabaseAPI();
dbApi.getDependencyResolver().resolveDependency( NodeManager.class ).clearCache();
rel.delete();
node1.delete();
node2.delete();
dbApi.getDependencyResolver().resolveDependency( NodeManager.class ).clearCache();
tx.success();
}
assertEquals( "stringvalue", handler.nodeProps.get( "test1" ) );
assertEquals( "stringvalue", handler.relProps.get( "test1" ) );
assertEquals( 1l , handler.nodeProps.get( "test2" ) );
assertEquals( 1l , handler.relProps.get( "test2" ) );
int[] intArray = (int[]) handler.relProps.get( "test3" );
assertEquals( 3, intArray.length );
assertEquals( 1, intArray[0] );
assertEquals( 2, intArray[1] );
assertEquals( 3, intArray[2] );
}
private static class MyTxEventHandler implements TransactionEventHandler<Object>
{
Map<String,Object> nodeProps = new HashMap<>();
Map<String,Object> relProps = new HashMap<>();
@Override
public void afterCommit( TransactionData data, Object state )
{
for ( PropertyEntry<Node> entry : data.removedNodeProperties() )
{
String key = entry.key();
Object value = entry.previouslyCommitedValue();
nodeProps.put( key, value );
}
for ( PropertyEntry<Relationship> entry : data.removedRelationshipProperties() )
{
relProps.put( entry.key(), entry.previouslyCommitedValue() );
}
}
@Override
public void afterRollback( TransactionData data, Object state )
{
}
@Override
public Object beforeCommit( TransactionData data )
throws Exception
{
return null;
}
}
private void verifyHandlerCalls(
List<TransactionEventHandler<Object>> handlers, boolean txSuccess )
{
for ( TransactionEventHandler<Object> handler : handlers )
{
DummyTransactionEventHandler<Object> realHandler =
(DummyTransactionEventHandler<Object>) ((FailingEventHandler<Object>) handler).source;
if ( txSuccess )
{
assertEquals( Integer.valueOf( 0 ), realHandler.beforeCommit );
assertEquals( Integer.valueOf( 1 ), realHandler.afterCommit );
}
else
{
if ( realHandler.counter > 0 )
{
assertEquals( Integer.valueOf( 0 ),
realHandler.beforeCommit );
assertEquals( Integer.valueOf( 1 ),
realHandler.afterRollback );
}
}
}
}
private static enum RelTypes implements RelationshipType
{
TXEVENT
}
private static class FailingEventHandler<T> implements TransactionEventHandler<T>
{
private final TransactionEventHandler<T> source;
private final boolean willFail;
public FailingEventHandler( TransactionEventHandler<T> source, boolean willFail )
{
this.source = source;
this.willFail = willFail;
}
@Override
public void afterCommit( TransactionData data, T state )
{
source.afterCommit( data, state );
}
@Override
public void afterRollback( TransactionData data, T state )
{
source.afterRollback( data, state );
}
@Override
public T beforeCommit( TransactionData data ) throws Exception
{
if ( willFail )
{
throw new Exception( "Just failing commit, that's all" );
}
return source.beforeCommit( data );
}
}
private static class ExceptionThrowingEventHandler implements TransactionEventHandler<Object>
{
private final Exception beforeCommitException;
private final Exception afterCommitException;
private final Exception afterRollbackException;
public ExceptionThrowingEventHandler(Exception beforeCommitException,
Exception afterCommitException, Exception afterRollbackException) {
super();
this.beforeCommitException = beforeCommitException;
this.afterCommitException = afterCommitException;
this.afterRollbackException = afterRollbackException;
}
@Override
public Object beforeCommit(TransactionData data) throws Exception
{
if(beforeCommitException != null)
{
throw beforeCommitException;
}
return null;
}
@Override
public void afterCommit(TransactionData data, Object state)
{
if(afterCommitException != null)
{
throw new RuntimeException(afterCommitException);
}
}
@Override
public void afterRollback(TransactionData data, Object state)
{
if(afterRollbackException != null)
{
throw new RuntimeException(afterRollbackException);
}
}
}
private static class DummyTransactionEventHandler<T> implements
TransactionEventHandler<T>
{
private final T object;
private TransactionData receivedTransactionData;
private T receivedState;
private int counter;
private Integer beforeCommit, afterCommit, afterRollback;
public DummyTransactionEventHandler( T object )
{
this.object = object;
}
@Override
public void afterCommit( TransactionData data, T state )
{
assertNotNull( data );
this.receivedState = state;
this.afterCommit = counter++;
}
@Override
public void afterRollback( TransactionData data, T state )
{
assertNotNull( data );
this.receivedState = state;
this.afterRollback = counter++;
}
@Override
public T beforeCommit( TransactionData data ) throws Exception
{
assertNotNull( data );
this.receivedTransactionData = data;
this.beforeCommit = counter++;
if ( this.beforeCommit == 2 )
{
new Exception( "blabla" ).printStackTrace();
}
return object;
}
void reset()
{
receivedTransactionData = null;
receivedState = null;
counter = 0;
beforeCommit = null;
afterCommit = null;
afterRollback = null;
}
}
@Test
public void makeSureHandlerIsntCalledWhenTxRolledBack()
{
DummyTransactionEventHandler<Integer> handler =
new DummyTransactionEventHandler<Integer>( 10 );
GraphDatabaseService db = dbRule.getGraphDatabaseService();
db.registerTransactionEventHandler( handler );
try
{
try ( Transaction tx = db.beginTx() )
{
db.createNode().delete();
}
assertNull( handler.beforeCommit );
assertNull( handler.afterCommit );
assertNull( handler.afterRollback );
}
finally
{
db.unregisterTransactionEventHandler( handler );
}
}
@Test
public void modifiedPropertyCanByFurtherModifiedInBeforeCommit() throws Exception
{
// Given
// -- create node and set property on it in one transaction
GraphDatabaseService db = dbRule.getGraphDatabaseService();
final String key = "key";
final Object value1 = "the old value";
final Object value2 = "the new value";
final Node node;
try ( Transaction tx = db.beginTx() )
{
node = db.createNode();
node.setProperty( key, "initial value" );
tx.success();
}
// -- register a tx handler which will override a property
TransactionEventHandler<Void> handler = new TransactionEventHandler.Adapter<Void>()
{
@Override
public Void beforeCommit( TransactionData data ) throws Exception
{
Node modifiedNode = data.assignedNodeProperties().iterator().next().entity();
assertEquals( node, modifiedNode );
modifiedNode.setProperty( key, value2 );
return null;
}
};
db.registerTransactionEventHandler( handler );
try ( Transaction tx = db.beginTx() )
{
// When
node.setProperty( key, value1 );
tx.success();
}
// Then
assertThat(node, inTx(db, hasProperty(key).withValue(value2)));
db.unregisterTransactionEventHandler( handler );
}
public static final @ClassRule DatabaseRule dbRule = new ImpermanentDatabaseRule()
{
@Override
protected void configure( GraphDatabaseBuilder builder )
{
builder.setConfig( cache_type, "none" );
}
};
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestTransactionEvents.java
|
1,357
|
private static class Panic implements KernelEventHandler
{
volatile boolean panic = false;
@Override
public void beforeShutdown()
{
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
panic = true;
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return null;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,358
|
private static class BreakageException extends RuntimeException
{
public BreakageException()
{
super( "Breaking" );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,359
|
{
private void breakStuff()
{
throw new BreakageException();
}
@Override
public void visitRelationship( RelationshipRecord record )
{
breakStuff();
}
@Override
public void visitProperty( PropertyRecord record )
{
breakStuff();
}
@Override
public void visitRelationshipTypeToken( RelationshipTypeTokenRecord record )
{
breakStuff();
}
@Override
public void visitLabelToken( LabelTokenRecord record )
{
breakStuff();
}
@Override
public void visitPropertyKeyToken( PropertyKeyTokenRecord record )
{
breakStuff();
}
@Override
public void visitNode( NodeRecord record )
{
breakStuff();
}
@Override
public void visitNeoStore( NeoStoreRecord record )
{
breakStuff();
}
@Override
public void visitSchemaRule( Collection<DynamicRecord> records )
{
breakStuff();
}
@Override
public void setStartEntry( Start entry )
{
breakStuff();
}
@Override
public void setCommitEntry( Commit entry )
{
breakStuff();
}
@Override
public void complete()
{
breakStuff();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,360
|
{
@Override
public TransactionInterceptor create( TransactionInterceptor next, XaDataSource ds, String options,
DependencyResolver dependencyResolver )
{
throw new AssertionError( "I don't think this is needed" );
}
@Override
public TransactionInterceptor create( XaDataSource ds, String options, DependencyResolver dependencyResolver )
{
return interceptorThatBreaksStuff();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,361
|
{
@Override
public Void call() throws Exception
{
db.beginTx();
return null;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,362
|
{
@Override
public Void call() throws Exception
{
ds.applyCommittedTransaction( 2, simpleTransaction() );
return null;
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,363
|
public class TestKernelPanic
{
@Test( timeout = 10000 )
public void panicTest() throws Exception
{
BufferingLogger logger = new BufferingLogger();
GraphDatabaseService graphDb = new TestGraphDatabaseFactory().setLogging(
new SingleLoggingService( logger ) ).newImpermanentDatabase();
XaDataSourceManager xaDs =
((GraphDatabaseAPI)graphDb).getDependencyResolver().resolveDependency( XaDataSourceManager.class );
IllBehavingXaDataSource adversarialDataSource =
new IllBehavingXaDataSource(UTF8.encode( "554342" ), "adversarialDataSource");
xaDs.registerDataSource( adversarialDataSource );
Panic panic = new Panic();
graphDb.registerKernelEventHandler( panic );
org.neo4j.graphdb.Transaction gdbTx = graphDb.beginTx();
TransactionManager txMgr = ((GraphDatabaseAPI)graphDb).getDependencyResolver()
.resolveDependency( TransactionManager.class );
Transaction tx = txMgr.getTransaction();
graphDb.createNode();
adversarialDataSource.getXaConnection().enlistResource( tx );
try
{
gdbTx.success();
gdbTx.finish();
fail( "Should fail" );
}
catch ( Exception t )
{
// It's okay, we expected this.
// Now just wait until we observe the kernel panicking:
//noinspection StatementWithEmptyBody
while ( !panic.panic );
}
finally
{
graphDb.unregisterKernelEventHandler( panic );
}
try
{
assertTrue( panic.panic );
assertThat("Log didn't contain expected string",
logger.toString(), containsString("at org.neo4j.kernel.impl.event.TestKernelPanic.panicTest"));
}
finally
{
graphDb.shutdown();
}
}
@Test
public void shouldPanicOnApplyTransactionFailure() throws Exception
{
// GIVEN
TestGraphDatabaseFactory factory = new TestGraphDatabaseFactory();
factory.setTransactionInterceptorProviders( asList( interceptorProviderThatBreaksStuff() ) );
GraphDatabaseAPI db = (GraphDatabaseAPI) factory.newImpermanentDatabaseBuilder()
.setConfig( GraphDatabaseSettings.intercept_deserialized_transactions.name(), TRUE.toString() )
.setConfig( TransactionInterceptorProvider.class.getSimpleName() + ".breaker", TRUE.toString() )
.newGraphDatabase();
XaDataSourceManager dsManager = db.getDependencyResolver().resolveDependency( XaDataSourceManager.class );
XaDataSource ds = dsManager.getXaDataSource( NeoStoreXaDataSource.DEFAULT_DATA_SOURCE_NAME );
// WHEN
try
{
ds.applyCommittedTransaction( 2, simpleTransaction() );
fail( "Should have failed" );
}
catch ( BreakageException e )
{ // Good
}
// THEN
assertNotOk( beginTransaction( db ) );
assertNotOk( applyTransaction( ds ) );
}
private void assertNotOk( Callable<Void> callable )
{
try
{
callable.call();
fail( "Should have failed saying that tm not OK");
}
catch ( Exception e )
{ // Good
assertTrue( someExceptionContainsMessage( e, "Kernel has encountered some problem" ) );
}
}
private boolean someExceptionContainsMessage( Throwable e, String string )
{
while ( e != null )
{
if ( e.getMessage().contains( string ) )
{
return true;
}
e = e.getCause();
}
return false;
}
private Callable<Void> applyTransaction( final XaDataSource ds )
{
return new Callable<Void>()
{
@Override
public Void call() throws Exception
{
ds.applyCommittedTransaction( 2, simpleTransaction() );
return null;
}
};
}
private Callable<Void> beginTransaction( final GraphDatabaseService db )
{
return new Callable<Void>()
{
@Override
public Void call() throws Exception
{
db.beginTx();
return null;
}
};
}
public final @Rule EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
private ReadableByteChannel simpleTransaction() throws IOException
{
InMemoryLogBuffer buffer = new InMemoryLogBuffer();
TransactionWriter writer = new TransactionWriter( buffer, 1, -1 );
writer.start( -1, -1, 0 );
writer.add( new NodeRecord( 0, Record.NO_NEXT_RELATIONSHIP.intValue(), Record.NO_NEXT_PROPERTY.intValue() ),
new NodeRecord( 0, Record.NO_NEXT_RELATIONSHIP.intValue(), Record.NO_NEXT_PROPERTY.intValue() ) );
writer.commit( false, 2 );
writer.done();
return buffer;
}
private TransactionInterceptorProvider interceptorProviderThatBreaksStuff()
{
return new TransactionInterceptorProvider( "breaker" )
{
@Override
public TransactionInterceptor create( TransactionInterceptor next, XaDataSource ds, String options,
DependencyResolver dependencyResolver )
{
throw new AssertionError( "I don't think this is needed" );
}
@Override
public TransactionInterceptor create( XaDataSource ds, String options, DependencyResolver dependencyResolver )
{
return interceptorThatBreaksStuff();
}
};
}
private TransactionInterceptor interceptorThatBreaksStuff()
{
return new TransactionInterceptor()
{
private void breakStuff()
{
throw new BreakageException();
}
@Override
public void visitRelationship( RelationshipRecord record )
{
breakStuff();
}
@Override
public void visitProperty( PropertyRecord record )
{
breakStuff();
}
@Override
public void visitRelationshipTypeToken( RelationshipTypeTokenRecord record )
{
breakStuff();
}
@Override
public void visitLabelToken( LabelTokenRecord record )
{
breakStuff();
}
@Override
public void visitPropertyKeyToken( PropertyKeyTokenRecord record )
{
breakStuff();
}
@Override
public void visitNode( NodeRecord record )
{
breakStuff();
}
@Override
public void visitNeoStore( NeoStoreRecord record )
{
breakStuff();
}
@Override
public void visitSchemaRule( Collection<DynamicRecord> records )
{
breakStuff();
}
@Override
public void setStartEntry( Start entry )
{
breakStuff();
}
@Override
public void setCommitEntry( Commit entry )
{
breakStuff();
}
@Override
public void complete()
{
breakStuff();
}
};
}
private static class BreakageException extends RuntimeException
{
public BreakageException()
{
super( "Breaking" );
}
}
private static class Panic implements KernelEventHandler
{
volatile boolean panic = false;
@Override
public void beforeShutdown()
{
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
panic = true;
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return null;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_event_TestKernelPanic.java
|
1,364
|
public static abstract class Configuration
{
public static final Setting<Boolean> node_auto_indexing = GraphDatabaseSettings.node_auto_indexing;
public static final Setting<String> node_keys_indexable = GraphDatabaseSettings.node_keys_indexable;
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_NodeAutoIndexerImpl.java
|
1,365
|
public class NodeAutoIndexerImpl extends AbstractAutoIndexerImpl<Node>
{
public static abstract class Configuration
{
public static final Setting<Boolean> node_auto_indexing = GraphDatabaseSettings.node_auto_indexing;
public static final Setting<String> node_keys_indexable = GraphDatabaseSettings.node_keys_indexable;
}
static final String NODE_AUTO_INDEX = "node_auto_index";
private Config config;
private IndexManagerImpl indexManager;
private NodeManager nodeManager;
public NodeAutoIndexerImpl( Config config, IndexManagerImpl indexManager, NodeManager nodeManager )
{
super();
this.config = config;
this.indexManager = indexManager;
this.nodeManager = nodeManager;
}
@Override
public void init()
throws Throwable
{
}
@Override
public void start()
{
setEnabled( config.get( Configuration.node_auto_indexing ) );
propertyKeysToInclude.addAll( parseConfigList( config.get( Configuration.node_keys_indexable ) ) );
}
@Override
public void stop()
throws Throwable
{
}
@Override
public void shutdown()
throws Throwable
{
}
@Override
protected Index<Node> getIndexInternal()
{
return indexManager.getOrCreateNodeIndex(
NODE_AUTO_INDEX, null );
}
@Override
public void setEnabled( boolean enabled )
{
super.setEnabled( enabled );
if ( enabled )
{
nodeManager.addNodePropertyTracker(
this );
}
else
{
nodeManager.removeNodePropertyTracker(
this );
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_NodeAutoIndexerImpl.java
|
1,366
|
private class IndexCreatorJob implements Callable
{
private final String indexName;
private final Map<String, String> config;
private final Class<? extends PropertyContainer> cls;
IndexCreatorJob( Class<? extends PropertyContainer> cls, String indexName,
Map<String, String> config )
{
this.cls = cls;
this.indexName = indexName;
this.config = config;
}
@Override
public Object call()
throws Exception
{
String provider = config.get( PROVIDER );
String dataSourceName = getIndexProvider( provider ).getDataSourceName();
try ( Transaction tx = graphDatabaseAPI.tx().begin() )
{
XaDataSource dataSource = xaDataSourceManager.getXaDataSource( dataSourceName );
IndexXaConnection connection = (IndexXaConnection) dataSource.getXaConnection();
javax.transaction.Transaction javaxTx = txManager.getTransaction();
connection.enlistResource( javaxTx );
connection.createIndex( cls, indexName, config );
tx.success();
}
return null;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_IndexManagerImpl.java
|
1,367
|
public class IndexManagerImpl implements IndexManager, IndexProviders
{
private final IndexStore indexStore;
private final Map<String, IndexImplementation> indexProviders = new HashMap<String, IndexImplementation>();
private NodeAutoIndexerImpl nodeAutoIndexer;
private RelationshipAutoIndexerImpl relAutoIndexer;
private final Config config;
private final XaDataSourceManager xaDataSourceManager;
private final AbstractTransactionManager txManager;
private final GraphDatabaseAPI graphDatabaseAPI;
public IndexManagerImpl( Config config, IndexStore indexStore,
XaDataSourceManager xaDataSourceManager, AbstractTransactionManager txManager,
GraphDatabaseAPI graphDatabaseAPI
)
{
this.graphDatabaseAPI = graphDatabaseAPI;
this.config = config;
this.xaDataSourceManager = xaDataSourceManager;
this.txManager = txManager;
this.indexStore = indexStore;
}
private IndexImplementation getIndexProvider( String provider )
{
if ( provider == null )
{
throw new IllegalArgumentException( "No 'provider' given in configuration map" );
}
synchronized ( this.indexProviders )
{
IndexImplementation result = this.indexProviders.get( provider );
if ( result != null )
{
return result;
}
throw new IllegalArgumentException( "No index provider '" + provider +
"' found. Maybe the intended provider (or one more of its dependencies) " +
"aren't on the classpath or it failed to load." );
}
}
@Override
public void registerIndexProvider( String name, IndexImplementation provider )
{
this.indexProviders.put( name, provider );
}
@Override
public boolean unregisterIndexProvider( String name )
{
return this.indexProviders.remove( name ) != null;
}
private Pair<Map<String, String>, Boolean/*true=needs to be set*/> findIndexConfig( Class<? extends
PropertyContainer> cls,
String indexName, Map<String,
String> suppliedConfig, Map<?, ?> dbConfig )
{
// Check stored config (has this index been created previously?)
Map<String, String> storedConfig = indexStore.get( cls, indexName );
if ( storedConfig != null && suppliedConfig == null )
{
// Fill in "provider" if not already filled in, backwards compatibility issue
Map<String, String> newConfig = injectDefaultProviderIfMissing( indexName, dbConfig, storedConfig );
if ( newConfig != storedConfig )
{
indexStore.set( cls, indexName, newConfig );
}
return Pair.of( newConfig, Boolean.FALSE );
}
Map<String, String> configToUse = suppliedConfig;
// Check db config properties for provider
String provider = null;
IndexImplementation indexProvider = null;
if ( configToUse == null )
{
provider = getDefaultProvider( indexName, dbConfig );
configToUse = MapUtil.stringMap( PROVIDER, provider );
}
else
{
provider = configToUse.get( PROVIDER );
provider = provider == null ? getDefaultProvider( indexName, dbConfig ) : provider;
}
indexProvider = getIndexProvider( provider );
configToUse = indexProvider.fillInDefaults( configToUse );
configToUse = injectDefaultProviderIfMissing( indexName, dbConfig, configToUse );
// Do they match (stored vs. supplied)?
if ( storedConfig != null )
{
assertConfigMatches( indexProvider, indexName, storedConfig, suppliedConfig );
// Fill in "provider" if not already filled in, backwards compatibility issue
Map<String, String> newConfig = injectDefaultProviderIfMissing( indexName, dbConfig, storedConfig );
if ( newConfig != storedConfig )
{
indexStore.set( cls, indexName, newConfig );
}
configToUse = newConfig;
}
boolean needsToBeSet = !indexStore.has( cls, indexName );
return Pair.of( Collections.unmodifiableMap( configToUse ), needsToBeSet );
}
private void assertConfigMatches( IndexImplementation indexProvider, String indexName,
Map<String, String> storedConfig, Map<String, String> suppliedConfig )
{
if ( suppliedConfig != null && !indexProvider.configMatches( storedConfig, suppliedConfig ) )
{
throw new IllegalArgumentException( "Supplied index configuration:\n" +
suppliedConfig + "\ndoesn't match stored config in a valid way:\n" + storedConfig +
"\nfor '" + indexName + "'" );
}
}
private Map<String, String> injectDefaultProviderIfMissing( String indexName, Map<?, ?> dbConfig,
Map<String, String> config )
{
String provider = config.get( PROVIDER );
if ( provider == null )
{
config = new HashMap<String, String>( config );
config.put( PROVIDER, getDefaultProvider( indexName, dbConfig ) );
}
return config;
}
private String getDefaultProvider( String indexName, Map<?, ?> dbConfig )
{
String provider = null;
if ( dbConfig != null )
{
provider = (String) dbConfig.get( "index." + indexName );
if ( provider == null )
{
provider = (String) dbConfig.get( "index" );
}
}
// 4. Default to lucene
if ( provider == null )
{
provider = "lucene";
}
return provider;
}
private Pair<Map<String, String>, /*was it created now?*/Boolean> getOrCreateIndexConfig(
Class<? extends PropertyContainer> cls, String indexName, Map<String, String> suppliedConfig )
{
Pair<Map<String, String>, Boolean> result = findIndexConfig( cls,
indexName, suppliedConfig, config.getParams() );
boolean createdNow = false;
if ( result.other() )
{ // Ok, we need to create this config
synchronized ( this )
{ // Were we the first ones to get here?
Map<String, String> existing = indexStore.get( cls, indexName );
if ( existing != null )
{
// No, someone else made it before us, cool
assertConfigMatches( getIndexProvider( existing.get( PROVIDER ) ), indexName,
existing, result.first() );
return Pair.of( result.first(), false );
}
// We were the first one here, let's create this config
ExecutorService executorService = Executors.newSingleThreadExecutor();
try
{
executorService.submit( new IndexCreatorJob( cls, indexName, result.first() ) ).get();
indexStore.set( cls, indexName, result.first() );
createdNow = true;
}
catch ( ExecutionException ex )
{
throw new TransactionFailureException( "Index creation failed for " + indexName +
", " + result.first(), ex.getCause() );
}
catch ( InterruptedException ex )
{
Thread.interrupted();
}
finally
{
executorService.shutdownNow();
}
}
}
return Pair.of( result.first(), createdNow );
}
private class IndexCreatorJob implements Callable
{
private final String indexName;
private final Map<String, String> config;
private final Class<? extends PropertyContainer> cls;
IndexCreatorJob( Class<? extends PropertyContainer> cls, String indexName,
Map<String, String> config )
{
this.cls = cls;
this.indexName = indexName;
this.config = config;
}
@Override
public Object call()
throws Exception
{
String provider = config.get( PROVIDER );
String dataSourceName = getIndexProvider( provider ).getDataSourceName();
try ( Transaction tx = graphDatabaseAPI.tx().begin() )
{
XaDataSource dataSource = xaDataSourceManager.getXaDataSource( dataSourceName );
IndexXaConnection connection = (IndexXaConnection) dataSource.getXaConnection();
javax.transaction.Transaction javaxTx = txManager.getTransaction();
connection.enlistResource( javaxTx );
connection.createIndex( cls, indexName, config );
tx.success();
}
return null;
}
}
@Override
public boolean existsForNodes( String indexName )
{
assertInTransaction();
return indexStore.get( Node.class, indexName ) != null;
}
@Override
public Index<Node> forNodes( String indexName )
{
return forNodes( indexName, null );
}
@Override
public Index<Node> forNodes( String indexName,
Map<String, String> customConfiguration )
{
assertInTransaction();
Index<Node> toReturn = getOrCreateNodeIndex( indexName,
customConfiguration );
if ( NodeAutoIndexerImpl.NODE_AUTO_INDEX.equals( indexName ) )
{
toReturn = new AbstractAutoIndexerImpl.ReadOnlyIndexToIndexAdapter<Node>( toReturn );
}
return toReturn;
}
Index<Node> getOrCreateNodeIndex(
String indexName, Map<String, String> customConfiguration )
{
Pair<Map<String, String>, Boolean> config = getOrCreateIndexConfig( Node.class,
indexName, customConfiguration );
try
{
return getIndexProvider( config.first().get( PROVIDER ) ).nodeIndex( indexName,
config.first() );
}
catch ( RuntimeException e )
{
if ( config.other() )
{
indexStore.remove( Node.class, indexName );
}
throw e;
}
}
RelationshipIndex getOrCreateRelationshipIndex( String indexName,
Map<String, String> customConfiguration )
{
Pair<Map<String, String>, Boolean> config = getOrCreateIndexConfig(
Relationship.class, indexName, customConfiguration );
try
{
return getIndexProvider( config.first().get( PROVIDER ) ).relationshipIndex(
indexName, config.first() );
}
catch ( RuntimeException e )
{
if ( config.other() )
{
indexStore.remove( Relationship.class, indexName );
}
throw e;
}
}
@Override
public String[] nodeIndexNames()
{
assertInTransaction();
return indexStore.getNames( Node.class );
}
@Override
public boolean existsForRelationships( String indexName )
{
assertInTransaction();
return indexStore.get( Relationship.class, indexName ) != null;
}
@Override
public RelationshipIndex forRelationships( String indexName )
{
return forRelationships( indexName, null );
}
@Override
public RelationshipIndex forRelationships( String indexName,
Map<String, String> customConfiguration )
{
assertInTransaction();
RelationshipIndex toReturn = getOrCreateRelationshipIndex( indexName,
customConfiguration );
if ( RelationshipAutoIndexerImpl.RELATIONSHIP_AUTO_INDEX.equals( indexName ) )
{
toReturn = new RelationshipAutoIndexerImpl.RelationshipReadOnlyIndexToIndexAdapter(
toReturn );
}
return toReturn;
}
@Override
public String[] relationshipIndexNames()
{
assertInTransaction();
return indexStore.getNames( Relationship.class );
}
@Override
public Map<String, String> getConfiguration( Index<? extends PropertyContainer> index )
{
Map<String, String> config = indexStore.get( index.getEntityType(), index.getName() );
if ( config == null )
{
throw new NotFoundException( "No " + index.getEntityType().getSimpleName() +
" index '" + index.getName() + "' found" );
}
return config;
}
@Override
public String setConfiguration( Index<? extends PropertyContainer> index, String key, String value )
{
assertLegalConfigKey( key );
Map<String, String> config = getMutableConfig( index );
String oldValue = config.put( key, value );
indexStore.set( index.getEntityType(), index.getName(), config );
return oldValue;
}
private void assertLegalConfigKey( String key )
{
if ( key.equals( PROVIDER ) )
{
throw new IllegalArgumentException( "'" + key + "' cannot be modified" );
}
}
private Map<String, String> getMutableConfig( Index<? extends PropertyContainer> index )
{
return new HashMap<String, String>( getConfiguration( index ) );
}
@Override
public String removeConfiguration( Index<? extends PropertyContainer> index, String key )
{
assertLegalConfigKey( key );
Map<String, String> config = getMutableConfig( index );
String value = config.remove( key );
if ( value != null )
{
indexStore.set( index.getEntityType(), index.getName(), config );
}
return value;
}
// TODO These setters/getters stick. Why are these indexers exposed!?
public void setNodeAutoIndexer( NodeAutoIndexerImpl nodeAutoIndexer )
{
this.nodeAutoIndexer = nodeAutoIndexer;
}
public void setRelAutoIndexer( RelationshipAutoIndexerImpl relAutoIndexer )
{
this.relAutoIndexer = relAutoIndexer;
}
@Override
public AutoIndexer<Node> getNodeAutoIndexer()
{
return nodeAutoIndexer;
}
@Override
public RelationshipAutoIndexer getRelationshipAutoIndexer()
{
return relAutoIndexer;
}
private void assertInTransaction()
{
txManager.assertInTransaction();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_IndexManagerImpl.java
|
1,368
|
public class TestShutdownSequence
{
private GraphDatabaseService graphDb;
@Before
public void createGraphDb()
{
graphDb = new TestGraphDatabaseFactory().newImpermanentDatabase();
}
@Test
public void canInvokeShutdownMultipleTimes()
{
graphDb.shutdown();
graphDb.shutdown();
}
public @Test
void eventHandlersAreOnlyInvokedOnceDuringShutdown()
{
final AtomicInteger counter = new AtomicInteger();
graphDb.registerKernelEventHandler( new KernelEventHandler()
{
@Override
public void beforeShutdown()
{
counter.incrementAndGet();
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
// do nothing
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
} );
graphDb.shutdown();
graphDb.shutdown();
assertEquals( 1, counter.get() );
}
public @Test
void canRemoveFilesAndReinvokeShutdown()
{
graphDb.shutdown();
AbstractNeo4jTestCase.deleteFileOrDirectory( new File(
getStorePath( "shutdown" ) ) );
graphDb.shutdown();
}
public @Test
void canInvokeShutdownFromShutdownHandler()
{
graphDb.registerKernelEventHandler( new KernelEventHandler()
{
@Override
public void beforeShutdown()
{
graphDb.shutdown();
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
// do nothing
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
} );
graphDb.shutdown();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestShutdownSequence.java
|
1,369
|
public class TestShortStringProperties extends TestShortString
{
@ClassRule
public static DatabaseRule graphdb = new ImpermanentDatabaseRule();
@Rule
public GraphTransactionRule tx = new GraphTransactionRule( graphdb );
public void commit()
{
tx.success();
graphdb.clearCache();
}
public void newTx()
{
tx.success();
tx.begin();
}
private static final String LONG_STRING = "this is a really long string, believe me!";
@Test
public void canAddMultipleShortStringsToTheSameNode() throws Exception
{
long recordCount = dynamicRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty( "key", "value" );
node.setProperty( "reverse", "esrever" );
commit();
assertEquals( recordCount, dynamicRecordsInUse() );
assertThat( node, inTx( graphdb.getGraphDatabaseService(), hasProperty( "key" ).withValue( "value" ) ) );
assertThat( node, inTx( graphdb.getGraphDatabaseService(), hasProperty( "reverse" ).withValue( "esrever" ) ) );
}
@Test
public void canAddShortStringToRelationship() throws Exception
{
long recordCount = dynamicRecordsInUse();
GraphDatabaseService db = graphdb.getGraphDatabaseService();
Relationship rel = db.createNode().createRelationshipTo( db.createNode(), withName( "REL_TYPE" ) );
rel.setProperty( "type", "dimsedut" );
commit();
assertEquals( recordCount, dynamicRecordsInUse() );
assertThat( rel, inTx( db, hasProperty( "type" ).withValue( "dimsedut" ) ) );
}
@Test
public void canUpdateShortStringInplace() throws Exception
{
try
{
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty( "key", "value" );
newTx();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertEquals( "value", node.getProperty( "key" ) );
node.setProperty( "key", "other" );
commit();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertThat( node, inTx( graphdb.getGraphDatabaseService(), hasProperty( "key" ).withValue( "other" ) ) );
}
catch ( Exception e )
{
e.printStackTrace();
throw e;
}
}
@Test
public void canReplaceLongStringWithShortString() throws Exception
{
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty( "key", LONG_STRING );
newTx();
assertEquals( recordCount + 1, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertEquals( LONG_STRING, node.getProperty( "key" ) );
node.setProperty( "key", "value" );
commit();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertThat( node, inTx( graphdb.getGraphDatabaseService(), hasProperty( "key" ).withValue( "value" ) ) );
}
@Test
public void canReplaceShortStringWithLongString() throws Exception
{
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty( "key", "value" );
newTx();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertEquals( "value", node.getProperty( "key" ) );
node.setProperty( "key", LONG_STRING );
commit();
assertEquals( recordCount + 1, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertThat( node, inTx( graphdb.getGraphDatabaseService(), hasProperty( "key" ).withValue( LONG_STRING ) ) );
}
@Test
public void canRemoveShortStringProperty() throws Exception
{
long recordCount = dynamicRecordsInUse();
long propCount = propertyRecordsInUse();
GraphDatabaseService db = graphdb.getGraphDatabaseService();
Node node = db.createNode();
node.setProperty( "key", "value" );
newTx();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount + 1, propertyRecordsInUse() );
assertEquals( "value", node.getProperty( "key" ) );
node.removeProperty( "key" );
commit();
assertEquals( recordCount, dynamicRecordsInUse() );
assertEquals( propCount, propertyRecordsInUse() );
assertThat( node, inTx( db, not( hasProperty( "key" ) ) ) );
}
// === reuse the test cases from the encoding ===
@Override
protected void assertCanEncode( String string )
{
encode( string, true );
}
private void encode( String string, boolean isShort )
{
long recordCount = dynamicRecordsInUse();
Node node = graphdb.getGraphDatabaseService().createNode();
node.setProperty( "key", string );
newTx();
if ( isShort )
{
assertEquals( recordCount, dynamicRecordsInUse() );
}
else
{
assertTrue( recordCount < dynamicRecordsInUse() );
}
graphdb.clearCache();
assertEquals( string, node.getProperty( "key" ) );
}
// === Here be (reflection) dragons ===
private static Field storeField;
static
{
try
{
storeField = PropertyStore.class.getDeclaredField( "stringPropertyStore" );
storeField.setAccessible( true );
}
catch ( Exception e )
{
throw new RuntimeException( e );
}
}
private long propertyRecordsInUse()
{
return propertyStore().getNumberOfIdsInUse();
}
private long dynamicRecordsInUse()
{
try
{
return ( (AbstractDynamicStore) storeField.get( propertyStore() ) ).getNumberOfIdsInUse();
}
catch ( Exception e )
{
throw new RuntimeException( e );
}
}
private PropertyStore propertyStore()
{
XaDataSourceManager dsMgr = graphdb.getGraphDatabaseAPI().getDependencyResolver()
.resolveDependency( XaDataSourceManager.class );
return dsMgr.getNeoStoreDataSource().getXaConnection().getPropertyStore();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestShortStringProperties.java
|
1,370
|
public class TestRelationshipGrabSize
{
private static final int GRAB_SIZE = 10;
private static GraphDatabaseAPI db;
private Transaction tx;
@BeforeClass
public static void doBefore() throws Exception
{
db = (GraphDatabaseAPI) new TestGraphDatabaseFactory()
.newImpermanentDatabaseBuilder()
.setConfig( GraphDatabaseSettings.relationship_grab_size, valueOf( GRAB_SIZE ) )
.newGraphDatabase();
}
@AfterClass
public static void doAfter() throws Exception
{
db.shutdown();
}
private void beginTx()
{
tx = db.beginTx();
}
private void finishTx( boolean success )
{
if ( success ) tx.success();
tx.close();
}
private void clearCache()
{
nodeManager().clearCache();
}
private NodeManager nodeManager()
{
return db.getDependencyResolver().resolveDependency( NodeManager.class );
}
@Test
public void deleteRelationshipFromNotFullyLoadedNode() throws Exception
{
beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
Node node3 = db.createNode();
RelationshipType type1 = DynamicRelationshipType.withName( "type1" );
RelationshipType type2 = DynamicRelationshipType.withName( "type2" );
// This will the last relationship in the chain
node1.createRelationshipTo( node3, type1 );
Collection<Relationship> type2Relationships = new HashSet<Relationship>();
// Create exactly grabSize relationships and store them in a set
for ( int i = 0; i < GRAB_SIZE; i++ )
{
type2Relationships.add( node1.createRelationshipTo( node2, type2 ) );
}
finishTx( true );
nodeManager().clearCache();
/*
* Here node1 has grabSize+1 relationships. The first grabSize to be loaded will be
* the type2 ones to node2 and the one remaining will be the type1 to node3.
*/
beginTx();
node1 = db.getNodeById( node1.getId() );
node2 = db.getNodeById( node2.getId() );
node3 = db.getNodeById( node3.getId() );
// Will load <grabsize> relationships, not all, and not relationships of
// type1 since it's the last one (the 11'th) in the chain.
node1.getRelationships().iterator().next();
// Delete the non-grabbed (from node1 POV) relationship
node3.getRelationships().iterator().next().delete();
// Just making sure
assertFalse( node3.getRelationships().iterator().hasNext() );
/*
* Now all Relationships left on node1 should be of type2
* This also checks that deletes on relationships are visible in the same tx.
*/
assertEquals( type2Relationships, addToCollection( node1.getRelationships(), new HashSet<Relationship>() ) );
finishTx( true );
beginTx();
assertEquals( type2Relationships, addToCollection( node1.getRelationships(), new HashSet<Relationship>() ) );
finishTx( false );
}
@Test
public void commitToNotFullyLoadedNode() throws Exception
{
beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
RelationshipType type = DynamicRelationshipType.withName( "type" );
for ( int i = 0; i < GRAB_SIZE + 2; i++ )
{
node1.createRelationshipTo( node2, type );
}
tx.success();
tx.finish();
nodeManager().clearCache();
tx = db.beginTx();
node1.getRelationships().iterator().next().delete();
node1.setProperty( "foo", "bar" );
int relCount = 0;
for ( Relationship rel : node2.getRelationships() )
{
relCount++;
}
assertEquals( relCount, GRAB_SIZE + 1 );
relCount = 0;
for (Relationship rel : node1.getRelationships())
{
relCount++;
}
assertEquals( relCount, GRAB_SIZE + 1 );
assertEquals( "bar", node1.getProperty( "foo" ) );
tx.success();
tx.finish();
}
@Test
public void createRelationshipAfterClearedCache()
{
// Assumes relationship grab size 100
beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
int expectedCount = 0;
for ( int i = 0; i < 150; i++ )
{
node1.createRelationshipTo( node2, TEST );
expectedCount++;
}
finishTx( true );
beginTx();
clearCache();
for ( int i = 0; i < 50; i++ )
{
node1.createRelationshipTo( node2, TEST );
expectedCount++;
}
assertEquals( expectedCount, count( node1.getRelationships() ) );
finishTx( true );
beginTx();
assertEquals( expectedCount, count( node1.getRelationships() ) );
finishTx( false );
}
@Test
public void grabSizeWithTwoTypesDeleteAndCount()
{
beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
int count = 0;
RelationshipType type1 = DynamicRelationshipType.withName( "type" );
RelationshipType type2 = DynamicRelationshipType.withName( "bar" );
// Create more than one grab size
for ( int i = 0; i < 12; i++ )
{
node1.createRelationshipTo( node2, type1 );
count++;
}
for ( int i = 0; i < 11; i++ )
{
node1.createRelationshipTo( node2, type2 );
count++;
}
tx.success();
tx.finish();
clearCacheAndCreateDeleteCount( db, node1, node2, type1, type2, count );
clearCacheAndCreateDeleteCount( db, node1, node2, type2, type1, count );
clearCacheAndCreateDeleteCount( db, node1, node2, type1, type1, count );
clearCacheAndCreateDeleteCount( db, node1, node2, type2, type2, count );
}
private void clearCacheAndCreateDeleteCount( GraphDatabaseAPI db, Node node1, Node node2,
RelationshipType createType, RelationshipType deleteType, int expectedCount )
{
Transaction tx = db.beginTx();
db.getDependencyResolver().resolveDependency( NodeManager.class ).clearCache();
node1.createRelationshipTo( node2, createType );
Relationship rel1 = node1.getRelationships( deleteType ).iterator().next();
rel1.delete();
assertEquals( expectedCount, count( node1.getRelationships() ) );
assertEquals( expectedCount, count( node2.getRelationships() ) );
tx.success();
tx.finish();
tx = db.beginTx();
assertEquals( expectedCount, count( node1.getRelationships() ) );
assertEquals( expectedCount, count( node2.getRelationships() ) );
tx.finish();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationshipGrabSize.java
|
1,371
|
{
@Override
public void run()
{
waitForPrepare();
// Get the first batch into the cache - relChainPosition points to theOneAfterTheGap
Transaction transaction = db.beginTx();
first.getRelationships().iterator().next();
transaction.finish();
readDone();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationshipConcurrentDeleteAndLoadCachePoisoning.java
|
1,372
|
{
@Override
public void run()
{
Transaction tx = db.beginTx();
theOneAfterTheGap.delete();
tx.success();
tx.finish();
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationshipConcurrentDeleteAndLoadCachePoisoning.java
|
1,373
|
{
@Override
protected void configure( GraphDatabaseBuilder builder )
{
builder.setConfig( GraphDatabaseSettings.relationship_grab_size, "" + RelationshipGrabSize );
}
};
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationshipConcurrentDeleteAndLoadCachePoisoning.java
|
1,374
|
@ForeignBreakpoints( {
@ForeignBreakpoints.BreakpointDef( type = "org.neo4j.kernel.impl.nioneo.xa.NeoStoreTransaction",
method = "doPrepare", on = BreakPoint.Event.EXIT ) } )
@RunWith( SubProcessTestRunner.class )
public class TestRelationshipConcurrentDeleteAndLoadCachePoisoning
{
private static final int RelationshipGrabSize = 2;
@Rule
public EmbeddedDatabaseRule database = new EmbeddedDatabaseRule()
{
@Override
protected void configure( GraphDatabaseBuilder builder )
{
builder.setConfig( GraphDatabaseSettings.relationship_grab_size, "" + RelationshipGrabSize );
}
};
public static final TargetDirectory targetDir =
TargetDirectory.forTest( TestRelationshipConcurrentDeleteAndLoadCachePoisoning.class );
private static DebuggedThread committer;
private static DebuggedThread reader;
@Test
@EnabledBreakpoints( {"doPrepare", "waitForPrepare", "readDone"} )
public void theTest() throws Exception
{
final GraphDatabaseAPI db = database.getGraphDatabaseAPI();
Transaction tx = db.beginTx();
final Node first = db.createNode();
final Relationship theOneAfterTheGap =
first.createRelationshipTo( db.createNode(), DynamicRelationshipType.withName( "AC" ) );
// The gap
for ( int i = 0; i < RelationshipGrabSize; i++)
{
first.createRelationshipTo( db.createNode(), DynamicRelationshipType.withName( "AC" ) );
}
tx.success();
tx.finish();
// This is required, otherwise relChainPosition is never consulted, everything will already be in mem.
db.getDependencyResolver().resolveDependency( NodeManager.class ).clearCache();
Runnable writer = new Runnable()
{
@Override
public void run()
{
Transaction tx = db.beginTx();
theOneAfterTheGap.delete();
tx.success();
tx.finish();
}
};
Runnable reader = new Runnable()
{
@Override
public void run()
{
waitForPrepare();
// Get the first batch into the cache - relChainPosition points to theOneAfterTheGap
Transaction transaction = db.beginTx();
first.getRelationships().iterator().next();
transaction.finish();
readDone();
}
};
Thread writerThread = new Thread( writer );
Thread readerThread = new Thread( reader );
// Start order matters - suspend the reader first, then start the writes.
readerThread.start();
writerThread.start();
dumpAndFailIfNotDeadWithin( readerThread, 1, MINUTES );
dumpAndFailIfNotDeadWithin( writerThread, 1, MINUTES );
// This should pass without any problems.
Transaction transaction = db.beginTx();
int count = count( first.getRelationships() );
assertEquals( "Should have read relationships created minus one", RelationshipGrabSize, count );
transaction.finish();
}
private void dumpAndFailIfNotDeadWithin( Thread thread, int duration, TimeUnit unit ) throws Exception
{
thread.join( MILLISECONDS.convert( duration, unit ) );
if ( thread.isAlive() )
{
File dumpDirectory = targetDir.cleanDirectory( "dump" );
dumpVmInfo( dumpDirectory );
new DumpProcessInformation( new SystemOutLogging(), dumpDirectory ).doThreadDump(
stringContains( SubProcess.class.getSimpleName() ) );
fail( "Test didn't complete within a reasonable time, dumping process information to " + dumpDirectory );
}
}
@BreakpointHandler( "doPrepare" )
public static void onDoPrepare( BreakPoint self, DebugInterface di )
{
if ( self.invocationCount() < 3 )
{
// One for the rel type, one for the setup
return;
}
self.disable();
committer = di.thread();
committer.suspend( RESUME_THREAD );
reader.resume();
}
@BreakpointTrigger("waitForPrepare")
public void waitForPrepare()
{
}
@BreakpointHandler( "waitForPrepare" )
public static void onWaitForPrepare( BreakPoint self, DebugInterface di )
{
self.disable();
reader = di.thread();
reader.suspend( RESUME_THREAD );
}
@BreakpointTrigger("readDone")
public void readDone()
{
}
@BreakpointHandler( "readDone" )
public static void onReadDone( BreakPoint self, DebugInterface di )
{
self.disable();
committer.resume();
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationshipConcurrentDeleteAndLoadCachePoisoning.java
|
1,375
|
{
public String name()
{
return MyRelTypes.TEST.name();
}
} ) );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationship.java
|
1,376
|
public class TestRelationship extends AbstractNeo4jTestCase
{
private String key1 = "key1";
private String key2 = "key2";
private String key3 = "key3";
@Test
public void testSimple()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST );
rel1.delete();
newTransaction();
assertTrue( node1.getRelationships().iterator().hasNext() );
assertTrue( node2.getRelationships().iterator().hasNext() );
assertTrue( node1.getRelationships(
MyRelTypes.TEST ).iterator().hasNext() );
assertTrue( node2.getRelationships(
MyRelTypes.TEST ).iterator().hasNext() );
assertTrue( node1.getRelationships(
MyRelTypes.TEST, Direction.OUTGOING ).iterator().hasNext() );
assertTrue( node2.getRelationships(
MyRelTypes.TEST, Direction.INCOMING ).iterator().hasNext() );
}
@Test
public void testSimple2()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
for ( int i = 0; i < 3; i++ )
{
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
}
allGetRelationshipMethods( node1, Direction.OUTGOING );
allGetRelationshipMethods( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods( node1, Direction.OUTGOING );
allGetRelationshipMethods( node2, Direction.INCOMING );
node1.getRelationships( MyRelTypes.TEST,
Direction.OUTGOING ).iterator().next().delete();
node1.getRelationships( MyRelTypes.TEST_TRAVERSAL,
Direction.OUTGOING ).iterator().next().delete();
node1.getRelationships( MyRelTypes.TEST2,
Direction.OUTGOING ).iterator().next().delete();
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
allGetRelationshipMethods( node1, Direction.OUTGOING );
allGetRelationshipMethods( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods( node1, Direction.OUTGOING );
allGetRelationshipMethods( node2, Direction.INCOMING );
for ( Relationship rel : node1.getRelationships() )
{
rel.delete();
}
node1.delete();
node2.delete();
}
@Test
public void testSimple3()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
for ( int i = 0; i < 1; i++ )
{
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
}
allGetRelationshipMethods2( node1, Direction.OUTGOING );
allGetRelationshipMethods2( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods2( node1, Direction.OUTGOING );
allGetRelationshipMethods2( node2, Direction.INCOMING );
node1.getRelationships( MyRelTypes.TEST,
Direction.OUTGOING ).iterator().next().delete();
node1.getRelationships( MyRelTypes.TEST_TRAVERSAL,
Direction.OUTGOING ).iterator().next().delete();
node1.getRelationships( MyRelTypes.TEST2,
Direction.OUTGOING ).iterator().next().delete();
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
allGetRelationshipMethods2( node1, Direction.OUTGOING );
allGetRelationshipMethods2( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods2( node1, Direction.OUTGOING );
allGetRelationshipMethods2( node2, Direction.INCOMING );
for ( Relationship rel : node1.getRelationships() )
{
rel.delete();
}
node1.delete();
node2.delete();
}
@Test
public void testSimple4()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
for ( int i = 0; i < 2; i++ )
{
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
}
allGetRelationshipMethods3( node1, Direction.OUTGOING );
allGetRelationshipMethods3( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods3( node1, Direction.OUTGOING );
allGetRelationshipMethods3( node2, Direction.INCOMING );
node1.getRelationships( MyRelTypes.TEST,
Direction.OUTGOING ).iterator().next().delete();
int count = 0;
for ( Relationship rel : node1.getRelationships( MyRelTypes.TEST_TRAVERSAL,
Direction.OUTGOING ) )
{
if ( count == 1 )
{
rel.delete();
}
count++;
}
node1.getRelationships( MyRelTypes.TEST2,
Direction.OUTGOING ).iterator().next().delete();
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.createRelationshipTo( node2, MyRelTypes.TEST_TRAVERSAL );
node1.createRelationshipTo( node2, MyRelTypes.TEST2 );
allGetRelationshipMethods3( node1, Direction.OUTGOING );
allGetRelationshipMethods3( node2, Direction.INCOMING );
newTransaction();
allGetRelationshipMethods3( node1, Direction.OUTGOING );
allGetRelationshipMethods3( node2, Direction.INCOMING );
for ( Relationship rel : node1.getRelationships() )
{
rel.delete();
}
node1.delete();
node2.delete();
}
private void allGetRelationshipMethods( Node node, Direction dir )
{
countRelationships( 9, node.getRelationships() );
countRelationships( 9, node.getRelationships( dir ) );
countRelationships( 9, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 6, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2 ) );
countRelationships( 6, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 6, node.getRelationships( MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST2 ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST, dir ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST2, dir ) );
countRelationships( 3, node.getRelationships(
MyRelTypes.TEST_TRAVERSAL, dir ) );
}
private void allGetRelationshipMethods2( Node node, Direction dir )
{
countRelationships( 3, node.getRelationships() );
countRelationships( 3, node.getRelationships( dir ) );
countRelationships( 3, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2 ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 1, node.getRelationships( MyRelTypes.TEST ) );
countRelationships( 1, node.getRelationships( MyRelTypes.TEST2 ) );
countRelationships( 1, node.getRelationships( MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 1, node.getRelationships( MyRelTypes.TEST, dir ) );
countRelationships( 1, node.getRelationships( MyRelTypes.TEST2, dir ) );
countRelationships( 1, node.getRelationships(
MyRelTypes.TEST_TRAVERSAL, dir ) );
}
private void allGetRelationshipMethods3( Node node, Direction dir )
{
countRelationships( 6, node.getRelationships() );
countRelationships( 6, node.getRelationships( dir ) );
countRelationships( 6, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 4, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST2 ) );
countRelationships( 4, node.getRelationships( MyRelTypes.TEST, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 4, node.getRelationships( MyRelTypes.TEST2, MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST2 ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST_TRAVERSAL ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST, dir ) );
countRelationships( 2, node.getRelationships( MyRelTypes.TEST2, dir ) );
countRelationships( 2, node.getRelationships(
MyRelTypes.TEST_TRAVERSAL, dir ) );
}
private void countRelationships( int expectedCount, Iterable<Relationship> rels )
{
int count = 0;
for ( Relationship ignored : rels )
{
count++;
}
assertEquals( expectedCount, count );
}
@Test
public void testRelationshipCreateAndDelete()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship relationship = node1.createRelationshipTo( node2,
MyRelTypes.TEST );
Relationship relArray1[] = getRelationshipArray( node1
.getRelationships() );
Relationship relArray2[] = getRelationshipArray( node2
.getRelationships() );
assertEquals( 1, relArray1.length );
assertEquals( relationship, relArray1[0] );
assertEquals( 1, relArray2.length );
assertEquals( relationship, relArray2[0] );
relArray1 = getRelationshipArray( node1
.getRelationships( MyRelTypes.TEST ) );
assertEquals( 1, relArray1.length );
assertEquals( relationship, relArray1[0] );
relArray2 = getRelationshipArray( node2
.getRelationships( MyRelTypes.TEST ) );
assertEquals( 1, relArray2.length );
assertEquals( relationship, relArray2[0] );
relArray1 = getRelationshipArray( node1.getRelationships(
MyRelTypes.TEST, Direction.OUTGOING ) );
assertEquals( 1, relArray1.length );
relArray2 = getRelationshipArray( node2.getRelationships(
MyRelTypes.TEST, Direction.INCOMING ) );
assertEquals( 1, relArray2.length );
relArray1 = getRelationshipArray( node1.getRelationships(
MyRelTypes.TEST, Direction.INCOMING ) );
assertEquals( 0, relArray1.length );
relArray2 = getRelationshipArray( node2.getRelationships(
MyRelTypes.TEST, Direction.OUTGOING ) );
assertEquals( 0, relArray2.length );
relationship.delete();
node2.delete();
node1.delete();
}
private Relationship[] getRelationshipArray(
Iterable<Relationship> relsIterable )
{
ArrayList<Relationship> relList = new ArrayList<>();
for ( Relationship rel : relsIterable )
{
relList.add( rel );
}
return relList.toArray( new Relationship[relList.size()] );
}
@Test
public void testDeleteWithRelationship()
{
// do some evil stuff
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
node1.createRelationshipTo( node2, MyRelTypes.TEST );
node1.delete();
node2.delete();
try
{
getTransaction().success();
//noinspection deprecation
getTransaction().finish();
fail( "deleting node with relationship should not commit." );
}
catch ( Exception e )
{
// good
}
setTransaction( getGraphDb().beginTx() );
}
@Test
public void testDeletedRelationship()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship relationship = node1.createRelationshipTo( node2,
MyRelTypes.TEST );
relationship.delete();
try
{
relationship.setProperty( "key1", new Integer( 1 ) );
fail( "Adding property to deleted rel should throw exception." );
}
catch ( Exception e )
{ // good
}
node1.delete();
node2.delete();
}
@Test
public void testRelationshipAddProperty()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
Relationship rel2 = node2.createRelationshipTo( node1, MyRelTypes.TEST );
try
{
rel1.setProperty( null, null );
fail( "Null argument should result in exception." );
}
catch ( IllegalArgumentException e )
{
}
Integer int1 = new Integer( 1 );
Integer int2 = new Integer( 2 );
String string1 = new String( "1" );
String string2 = new String( "2" );
// add property
rel1.setProperty( key1, int1 );
rel2.setProperty( key1, string1 );
rel1.setProperty( key2, string2 );
rel2.setProperty( key2, int2 );
assertTrue( rel1.hasProperty( key1 ) );
assertTrue( rel2.hasProperty( key1 ) );
assertTrue( rel1.hasProperty( key2 ) );
assertTrue( rel2.hasProperty( key2 ) );
assertTrue( !rel1.hasProperty( key3 ) );
assertTrue( !rel2.hasProperty( key3 ) );
assertEquals( int1, rel1.getProperty( key1 ) );
assertEquals( string1, rel2.getProperty( key1 ) );
assertEquals( string2, rel1.getProperty( key2 ) );
assertEquals( int2, rel2.getProperty( key2 ) );
getTransaction().failure();
}
@Test
public void testRelationshipRemoveProperty()
{
Integer int1 = new Integer( 1 );
Integer int2 = new Integer( 2 );
String string1 = new String( "1" );
String string2 = new String( "2" );
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
Relationship rel2 = node2.createRelationshipTo( node1, MyRelTypes.TEST );
// verify that we can rely on PL to reomve non existing properties
try
{
if ( rel1.removeProperty( key1 ) != null )
{
fail( "Remove of non existing property should return null" );
}
}
catch ( NotFoundException e )
{
}
try
{
rel1.removeProperty( null );
fail( "Remove null property should throw exception." );
}
catch ( IllegalArgumentException e )
{
}
rel1.setProperty( key1, int1 );
rel2.setProperty( key1, string1 );
rel1.setProperty( key2, string2 );
rel2.setProperty( key2, int2 );
try
{
rel1.removeProperty( null );
fail( "Null argument should result in exception." );
}
catch ( IllegalArgumentException e )
{
}
// test remove property
assertEquals( int1, rel1.removeProperty( key1 ) );
assertEquals( string1, rel2.removeProperty( key1 ) );
// test remove of non exsisting property
try
{
if ( rel2.removeProperty( key1 ) != null )
{
fail( "Remove of non existing property should return null" );
}
}
catch ( NotFoundException e )
{
// have to set rollback only here
getTransaction().failure();
}
rel1.delete();
rel2.delete();
node1.delete();
node2.delete();
}
@Test
public void testRelationshipChangeProperty()
{
Integer int1 = new Integer( 1 );
Integer int2 = new Integer( 2 );
String string1 = new String( "1" );
String string2 = new String( "2" );
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
Relationship rel2 = node2.createRelationshipTo( node1, MyRelTypes.TEST );
rel1.setProperty( key1, int1 );
rel2.setProperty( key1, string1 );
rel1.setProperty( key2, string2 );
rel2.setProperty( key2, int2 );
try
{
rel1.setProperty( null, null );
fail( "Null argument should result in exception." );
}
catch ( IllegalArgumentException e )
{
}
catch ( NotFoundException e )
{
fail( "wrong exception" );
}
// test type change of exsisting property
// cannot test this for now because of exceptions in PL
rel2.setProperty( key1, int1 );
rel1.delete();
rel2.delete();
node2.delete();
node1.delete();
}
@Test
public void testRelationshipChangeProperty2()
{
Integer int1 = new Integer( 1 );
Integer int2 = new Integer( 2 );
String string1 = new String( "1" );
String string2 = new String( "2" );
Boolean bool1 = new Boolean( true );
Boolean bool2 = new Boolean( false );
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
rel1.setProperty( key1, int1 );
rel1.setProperty( key1, int2 );
assertEquals( int2, rel1.getProperty( key1 ) );
rel1.removeProperty( key1 );
rel1.setProperty( key1, string1 );
rel1.setProperty( key1, string2 );
assertEquals( string2, rel1.getProperty( key1 ) );
rel1.removeProperty( key1 );
rel1.setProperty( key1, bool1 );
rel1.setProperty( key1, bool2 );
assertEquals( bool2, rel1.getProperty( key1 ) );
rel1.removeProperty( key1 );
rel1.delete();
node2.delete();
node1.delete();
}
@Test
public void testRelGetProperties()
{
Integer int1 = new Integer( 1 );
Integer int2 = new Integer( 2 );
String string = new String( "3" );
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
try
{
rel1.getProperty( key1 );
fail( "get non existing property din't throw exception" );
}
catch ( NotFoundException e )
{
}
try
{
rel1.getProperty( null );
fail( "get of null key din't throw exception" );
}
catch ( IllegalArgumentException e )
{
}
assertTrue( !rel1.hasProperty( key1 ) );
assertTrue( !rel1.hasProperty( null ) );
rel1.setProperty( key1, int1 );
rel1.setProperty( key2, int2 );
rel1.setProperty( key3, string );
assertTrue( rel1.hasProperty( key1 ) );
assertTrue( rel1.hasProperty( key2 ) );
assertTrue( rel1.hasProperty( key3 ) );
try
{
rel1.removeProperty( key3 );
}
catch ( NotFoundException e )
{
fail( "Remove of property failed." );
}
assertTrue( !rel1.hasProperty( key3 ) );
assertTrue( !rel1.hasProperty( null ) );
rel1.delete();
node2.delete();
node1.delete();
}
@Test
public void testDirectedRelationship()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel2 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
Relationship rel3 = node2.createRelationshipTo( node1, MyRelTypes.TEST );
Node[] nodes = rel2.getNodes();
assertEquals( 2, nodes.length );
assertTrue( nodes[0].equals( node1 ) && nodes[1].equals( node2 ) );
nodes = rel3.getNodes();
assertEquals( 2, nodes.length );
assertTrue( nodes[0].equals( node2 ) && nodes[1].equals( node1 ) );
assertEquals( node1, rel2.getStartNode() );
assertEquals( node2, rel2.getEndNode() );
assertEquals( node2, rel3.getStartNode() );
assertEquals( node1, rel3.getEndNode() );
Relationship relArray[] = getRelationshipArray( node1.getRelationships(
MyRelTypes.TEST, Direction.OUTGOING ) );
assertEquals( 1, relArray.length );
assertEquals( rel2, relArray[0] );
relArray = getRelationshipArray( node1.getRelationships(
MyRelTypes.TEST, Direction.INCOMING ) );
assertEquals( 1, relArray.length );
assertEquals( rel3, relArray[0] );
relArray = getRelationshipArray( node2.getRelationships(
MyRelTypes.TEST, Direction.OUTGOING ) );
assertEquals( 1, relArray.length );
assertEquals( rel3, relArray[0] );
relArray = getRelationshipArray( node2.getRelationships(
MyRelTypes.TEST, Direction.INCOMING ) );
assertEquals( 1, relArray.length );
assertEquals( rel2, relArray[0] );
rel2.delete();
rel3.delete();
node1.delete();
node2.delete();
}
@Test
public void testRollbackDeleteRelationship()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel1 = node1.createRelationshipTo( node2, MyRelTypes.TEST );
newTransaction();
node1.delete();
rel1.delete();
getTransaction().failure();
//noinspection deprecation
getTransaction().finish();
setTransaction( getGraphDb().beginTx() );
node1.delete();
node2.delete();
rel1.delete();
}
@Test
public void testCreateRelationshipWithCommitts()// throws NotFoundException
{
Node n1 = getGraphDb().createNode();
newTransaction();
clearCache();
n1 = getGraphDb().getNodeById( n1.getId() );
Node n2 = getGraphDb().createNode();
n1.createRelationshipTo( n2, MyRelTypes.TEST );
newTransaction();
Relationship[] relArray = getRelationshipArray( n1.getRelationships() );
assertEquals( 1, relArray.length );
relArray = getRelationshipArray( n1.getRelationships() );
relArray[0].delete();
n1.delete();
n2.delete();
}
@Test
public void testAddPropertyThenDelete()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo( node2, MyRelTypes.TEST );
rel.setProperty( "test", "test" );
newTransaction();
rel.setProperty( "test2", "test2" );
rel.delete();
node1.delete();
node2.delete();
newTransaction();
}
@Test
public void testRelationshipIsType()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo( node2, MyRelTypes.TEST );
assertTrue( rel.isType( MyRelTypes.TEST ) );
assertTrue( rel.isType( new RelationshipType()
{
public String name()
{
return MyRelTypes.TEST.name();
}
} ) );
assertFalse( rel.isType( MyRelTypes.TEST_TRAVERSAL ) );
rel.delete();
node1.delete();
node2.delete();
}
@Test
public void testChangeProperty()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo( node2, MyRelTypes.TEST );
rel.setProperty( "test", "test1" );
newTransaction();
rel.setProperty( "test", "test2" );
rel.removeProperty( "test" );
rel.setProperty( "test", "test3" );
assertEquals( "test3", rel.getProperty( "test" ) );
rel.removeProperty( "test" );
rel.setProperty( "test", "test4" );
newTransaction();
assertEquals( "test4", rel.getProperty( "test" ) );
}
@Test
public void testChangeProperty2()
{
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
Relationship rel = node1.createRelationshipTo( node2, MyRelTypes.TEST );
rel.setProperty( "test", "test1" );
newTransaction();
rel.removeProperty( "test" );
rel.setProperty( "test", "test3" );
assertEquals( "test3", rel.getProperty( "test" ) );
newTransaction();
assertEquals( "test3", rel.getProperty( "test" ) );
rel.removeProperty( "test" );
rel.setProperty( "test", "test4" );
newTransaction();
assertEquals( "test4", rel.getProperty( "test" ) );
}
@Test
public void makeSureLazyLoadingRelationshipsWorksEvenIfOtherIteratorAlsoLoadsInTheSameIteration() throws IOException
{
int num_edges = 100;
Node hub;
/* create 256 nodes */
GraphDatabaseService graphDB = getGraphDb();
Node[] nodes = new Node[256];
for ( int num_nodes = 0; num_nodes < nodes.length; num_nodes += 1 )
{
nodes[num_nodes] = graphDB.createNode();
}
newTransaction();
/* create random outgoing relationships from node 5 */
hub = nodes[4];
int nextID = 7;
DynamicRelationshipType outtie = DynamicRelationshipType.withName( "outtie" );
DynamicRelationshipType innie = DynamicRelationshipType.withName( "innie" );
for ( int k = 0; k < num_edges; k += 1 )
{
Node neighbor = nodes[nextID];
nextID += 7;
nextID &= 255;
if ( nextID == 0 ) nextID = 1;
hub.createRelationshipTo( neighbor, outtie );
}
newTransaction();
/* create random incoming relationships to node 5 */
for ( int k = 0; k < num_edges; k += 1 )
{
Node neighbor = nodes[nextID];
nextID += 7;
nextID &= 255;
if ( nextID == 0 ) nextID = 1;
neighbor.createRelationshipTo( hub, innie );
}
commit();
clearCache();
newTransaction();
hub = graphDB.getNodeById( hub.getId() );
int count = 0;
for ( @SuppressWarnings( "unused" )
Relationship r1 : hub.getRelationships() )
{
count += count( hub.getRelationships() );
}
assertEquals( 40000, count );
count = 0;
for ( @SuppressWarnings( "unused" )
Relationship r1 : hub.getRelationships() )
{
count += count( hub.getRelationships() );
}
assertEquals( 40000, count );
commit();
}
@Test
public void createRelationshipAfterClearedCache()
{
// Assumes relationship grab size 100
Node node1 = getGraphDb().createNode();
Node node2 = getGraphDb().createNode();
int expectedCount = 0;
for ( int i = 0; i < 150; i++ )
{
node1.createRelationshipTo( node2, TEST );
expectedCount++;
}
newTransaction();
getNodeManager().clearCache();
for ( int i = 0; i < 50; i++ )
{
node1.createRelationshipTo( node2, TEST );
expectedCount++;
}
assertEquals( expectedCount, count( node1.getRelationships() ) );
newTransaction();
assertEquals( expectedCount, count( node1.getRelationships() ) );
}
@Test
public void deleteRelsWithCommitInMiddle() throws Exception
{
Node node = getGraphDb().createNode();
Node otherNode = getGraphDb().createNode();
RelationshipType[] types = new RelationshipType[] {withName( "r1" ), withName( "r2" ), withName( "r3" ), withName( "r4" )};
int count = 30; // 30*4 > 100 (rel grabSize)
for ( int i = 0; i < types.length*count; i++ )
{
node.createRelationshipTo( otherNode, types[i%types.length] );
}
newTransaction();
clearCache();
int delCount = 0;
int loopCount = 0;
while ( delCount < count )
{
loopCount++;
for ( Relationship rel : node.getRelationships( types[1] ) )
{
rel.delete();
if ( ++delCount == count/2 ) newTransaction();
}
}
assertEquals( 1, loopCount );
assertEquals( count, delCount );
}
@Test
public void getAllRelationships() throws Exception
{
Set<Relationship> existingRelationships = addToCollection( at( getGraphDb() ).getAllRelationships(), new HashSet<Relationship>() );
Set<Relationship> createdRelationships = new HashSet<>();
Node node = getGraphDb().createNode();
for ( int i = 0; i < 100; i++ )
{
createdRelationships.add( node.createRelationshipTo( getGraphDb().createNode(), MyRelTypes.TEST ) );
}
newTransaction();
Set<Relationship> allRelationships = new HashSet<>();
allRelationships.addAll( existingRelationships );
allRelationships.addAll( createdRelationships );
int count = 0;
for ( Relationship rel : at( getGraphDb() ).getAllRelationships() )
{
assertTrue( allRelationships.contains( rel ) );
count++;
}
assertEquals( allRelationships.size(), count );
}
@Test
public void createAndClearCacheBeforeCommit()
{
Node node = getGraphDb().createNode();
clearCache();
node.createRelationshipTo( getGraphDb().createNode(), TEST );
clearCache();
assertEquals( 1, IteratorUtil.count( node.getRelationships() ) );
}
@Test
public void setPropertyAndClearCacheBeforeCommit() throws Exception
{
Node node = getGraphDb().createNode();
clearCache();
node.setProperty( "name", "Test" );
clearCache();
assertEquals( "Test", node.getProperty( "name" ) );
}
@Test
public void shouldNotGetTheSameRelationshipMoreThanOnceWhenAskingForTheSameTypeMultipleTimes() throws Exception
{
// given
Node node = getGraphDb().createNode();
node.createRelationshipTo( getGraphDb().createNode(), withName( "FOO" ) );
// when
int relationships = count( node.getRelationships( withName( "FOO" ), withName( "FOO" ) ) );
// then
assertEquals( 1, relationships );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelationship.java
|
1,377
|
public class TestRelIdArray
{
@Test
public void testBasic() throws Exception
{
RelIdArray array = new RelIdArray( 0 );
array.add( 1, OUTGOING );
array.add( 2, OUTGOING );
array.add( 3, INCOMING );
// Iterate OUTGOING
RelIdIterator itr = array.iterator( OUTGOING );
assertTrue( itr.hasNext() );
assertTrue( itr.hasNext() );
assertEquals( 1L, itr.next() );
assertTrue( itr.hasNext() );
assertEquals( 2L, itr.next() );
assertFalse( itr.hasNext() );
assertFalse( itr.hasNext() );
// Iterate INCOMING
itr = array.iterator( INCOMING );
assertTrue( itr.hasNext() );
assertEquals( 3L, itr.next() );
assertFalse( itr.hasNext() );
// Iterate BOTH
itr = array.iterator( BOTH );
assertTrue( itr.hasNext() );
assertTrue( itr.hasNext() );
assertEquals( 1L, itr.next() );
assertTrue( itr.hasNext() );
assertEquals( 2L, itr.next() );
assertTrue( itr.hasNext() );
assertEquals( 3L, itr.next() );
assertFalse( itr.hasNext() );
assertFalse( itr.hasNext() );
}
@Test
public void testWithAddRemove() throws Exception
{
RelIdArray source = new RelIdArray( 0 );
source.add( 1, OUTGOING );
source.add( 2, OUTGOING );
source.add( 3, INCOMING );
source.add( 4, INCOMING );
RelIdArray add = new RelIdArray( 0 );
add.add( 5, OUTGOING );
add.add( 6, OUTGOING );
add.add( 7, OUTGOING );
Collection<Long> remove = new HashSet<>();
remove.add( 2L );
remove.add( 6L );
List<Long> allIds = asList( RelIdArray.from( source, add, remove ) );
Collections.sort( allIds );
assertEquals( Arrays.asList( 1L, 3L, 4L, 5L, 7L ), allIds );
}
@Test
public void testDifferentBlocks() throws Exception
{
RelIdArray array = new RelIdArray( 0 );
long justUnderIntMax = (long) Math.pow( 2, 32 )-3;
array.add( justUnderIntMax, OUTGOING );
array.add( justUnderIntMax+1, OUTGOING );
long justOverIntMax = (long) Math.pow( 2, 32 )+3;
array.add( justOverIntMax, OUTGOING );
array.add( justOverIntMax+1, OUTGOING );
long aBitOverIntMax = (long) Math.pow( 2, 33 );
array.add( aBitOverIntMax, OUTGOING );
array.add( aBitOverIntMax+1, OUTGOING );
long verySmall = 1000;
array.add( verySmall, OUTGOING );
array.add( verySmall+1, OUTGOING );
Collection<Long> allIds = new HashSet<Long>( asList( array ) );
assertEquals( new HashSet<>( Arrays.asList(
justUnderIntMax, justUnderIntMax+1,
justOverIntMax, justOverIntMax+1,
aBitOverIntMax, aBitOverIntMax+1,
verySmall, verySmall+1 ) ), allIds );
}
@Test
public void testAddDifferentBlocks() throws Exception
{
RelIdArray array1 = new RelIdArray( 0 );
array1.add( 0, OUTGOING );
array1.add( 1, OUTGOING );
RelIdArray array2 = new RelIdArray( 0 );
long justOverIntMax = (long) Math.pow( 2, 32 )+3;
array2.add( justOverIntMax, OUTGOING );
array2.add( justOverIntMax+1, OUTGOING );
RelIdArray all = new RelIdArray( 0 );
all.addAll( array1 );
all.addAll( array2 );
assertEquals( new HashSet<>( Arrays.asList(
0L, 1L, justOverIntMax, justOverIntMax+1 ) ), new HashSet<>( asList( all ) ) );
}
@Test
public void iterateThroughMultipleHighBitsSignaturesWhereIdsAreAdded() throws Exception
{
// GIVEN
RelIdArray ids = new RelIdArray( 0 );
ids.add( 0, OUTGOING );
ids.add( 0x1FFFFFFFFL, OUTGOING );
RelIdIterator iterator = ids.iterator( OUTGOING );
// WHEN -- depleting the current iterator
assertEquals( asSet( 0L, 0x1FFFFFFFFL ), deplete( iterator ) );
// and adding one more id of the first "high bits" kind
ids.add( 1, OUTGOING );
// THEN
assertEquals( "Should see the added id after depleting two IdBlocks", asSet( 1L ), deplete( iterator ) );
}
@Test
public void shouldAcceptAddsAfterAddAllInSameDirection() throws Exception
{
RelIdArray arrayTo = RelIdArray.empty( 1 );
RelIdArray arrayFrom = RelIdArray.empty( 1 );
arrayFrom.add( 1, DirectionWrapper.INCOMING );
arrayTo.addAll( arrayFrom );
arrayTo.add( 2, DirectionWrapper.INCOMING );
}
private Set<Long> deplete( RelIdIterator iterator )
{
HashSet<Long> set = new HashSet<>();
while ( iterator.hasNext() )
set.add( iterator.next() );
return set;
}
private List<Long> asList( RelIdArray ids )
{
List<Long> result = new ArrayList<>();
for ( RelIdIterator iterator = ids.iterator( DirectionWrapper.BOTH ); iterator.hasNext(); )
{
result.add( iterator.next() );
}
return result;
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRelIdArray.java
|
1,378
|
public class TestReadOnlyNeo4j
{
private static final String PATH = "read-only";
public final @Rule EphemeralFileSystemRule fs = new EphemeralFileSystemRule();
@Test
public void testSimple()
{
DbRepresentation someData = createSomeData();
GraphDatabaseService readGraphDb = new TestGraphDatabaseFactory().setFileSystem( fs.get() )
.newImpermanentDatabaseBuilder( PATH )
.setConfig( GraphDatabaseSettings.read_only, Settings.TRUE )
.newGraphDatabase();
assertEquals( someData, DbRepresentation.of( readGraphDb ) );
Transaction tx = readGraphDb.beginTx();
try
{
readGraphDb.createNode();
fail( "expected exception" );
}
catch ( ReadOnlyDbException e )
{
// good
}
try
{
readGraphDb.createNode();
fail( "expected exception" );
}
catch ( ReadOnlyDbException e )
{
// good
}
tx.finish();
readGraphDb.shutdown();
}
private DbRepresentation createSomeData()
{
DynamicRelationshipType type = withName( "KNOWS" );
GraphDatabaseService db = new TestGraphDatabaseFactory().setFileSystem( fs.get() ).newImpermanentDatabase( PATH );
Transaction tx = db.beginTx();
@SuppressWarnings("deprecation")
Node prevNode = db.createNode();
for ( int i = 0; i < 100; i++ )
{
Node node = db.createNode();
Relationship rel = prevNode.createRelationshipTo( node, type );
node.setProperty( "someKey" + i%10, i%15 );
rel.setProperty( "since", System.currentTimeMillis() );
}
tx.success();
tx.finish();
DbRepresentation result = DbRepresentation.of( db );
db.shutdown();
return result;
}
@Test
public void testReadOnlyOperationsAndNoTransaction()
{
GraphDatabaseService db = new TestGraphDatabaseFactory().setFileSystem( fs.get() ).newImpermanentDatabase(
PATH );
Transaction tx = db.beginTx();
Node node1 = db.createNode();
Node node2 = db.createNode();
Relationship rel = node1.createRelationshipTo( node2, withName( "TEST" ) );
node1.setProperty( "key1", "value1" );
rel.setProperty( "key1", "value1" );
tx.success();
tx.finish();
// make sure write operations still throw exception
try
{
db.createNode();
fail( "Write operation and no transaction should throw exception" );
}
catch ( NotInTransactionException e )
{ // good
}
try
{
node1.createRelationshipTo( node2, withName( "TEST2" ) );
fail( "Write operation and no transaction should throw exception" );
}
catch ( NotInTransactionException e )
{ // good
}
try
{
node1.setProperty( "key1", "value2" );
fail( "Write operation and no transaction should throw exception" );
}
catch ( NotInTransactionException e )
{ // good
}
try
{
rel.removeProperty( "key1" );
fail( "Write operation and no transaction should throw exception" );
}
catch ( NotInTransactionException e )
{ // good
}
// clear caches and try reads
nodeManager( db ).clearCache();
Transaction transaction = db.beginTx();
assertEquals( node1, db.getNodeById( node1.getId() ) );
assertEquals( node2, db.getNodeById( node2.getId() ) );
assertEquals( rel, db.getRelationshipById( rel.getId() ) );
nodeManager( db ).clearCache();
assertThat( node1, inTx( db, hasProperty( "key1" ).withValue( "value1" ) ) );
Relationship loadedRel = node1.getSingleRelationship(
DynamicRelationshipType.withName( "TEST" ), Direction.OUTGOING );
assertEquals( rel, loadedRel );
assertThat(loadedRel, inTx(db, hasProperty( "key1" ).withValue( "value1" )));
transaction.finish();
db.shutdown();
}
private NodeManager nodeManager( GraphDatabaseService db )
{
return ((GraphDatabaseAPI)db).getDependencyResolver().resolveDependency( NodeManager.class );
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestReadOnlyNeo4j.java
|
1,379
|
{
@Override
public void run()
{
root.removeProperty( "tx" );
}
} ) );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,380
|
{
@Override
public void run()
{
root.setProperty( "e", 5 );
writerSetUp.countDown();
await( waitChainSetUp );
root.setProperty( "tx", "writer" );
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,381
|
{
@Override
public void run()
{
root.setProperty( "tx", "main" );
root.setProperty( "a", 1 );
root.setProperty( "b", 2 );
root.setProperty( "c", 3 );
root.setProperty( "d", 4 );
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,382
|
{
@Override
public Node call() throws Exception
{
return graphdb.createNode();
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,383
|
{
@Override
public void run()
{
// populate the NodeImpl object to make sure that we don't go to disk after acquiring lock
precondition.set( "original".equals( original.getProperty( "key" ) ) );
// this prevents false positives in awaitWaitingState( offender )
readyToBlockOnLock.countDown();
// this will block on the lock since there are two other threads ahead of us
original.removeProperty( "key" );
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,384
|
{
@Override
public void run()
{
try
{
tx( new Runnable()
{
@Override
public void run()
{
// populate the NodeImpl object to make sure that we don't go to disk after acquiring lock
precondition.set( "original".equals( original.getProperty( "key" ) ) );
// this prevents false positives in awaitWaitingState( offender )
readyToBlockOnLock.countDown();
// this will block on the lock since there are two other threads ahead of us
original.removeProperty( "key" );
}
} );
}
finally
{
done.countDown();
}
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,385
|
{
@Override
public void run()
{
original.removeProperty( "not existing" ); // block to make sure that we wait until "remover" is done
root.setProperty( "key", "root" ); // reuse property record with same key for different node
}
} ) );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,386
|
{
@Override
public void run()
{ // remove the property then wait until the entire wait chain is set up
original.removeProperty( "key" );
removerSetUp.countDown();
await( waitChainSetUp );
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestRaceOnMultipleNodeImpl.java
|
1,387
|
{
@Override
public void beforeShutdown()
{
counter.incrementAndGet();
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
// do nothing
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestShutdownSequence.java
|
1,388
|
{
@Override
public void beforeShutdown()
{
graphDb.shutdown();
}
@Override
public Object getResource()
{
return null;
}
@Override
public void kernelPanic( ErrorState error )
{
// do nothing
}
@Override
public ExecutionOrder orderComparedTo( KernelEventHandler other )
{
return ExecutionOrder.DOESNT_MATTER;
}
} );
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestShutdownSequence.java
|
1,389
|
public class TestTxSuspendResume
{
@Test
public void testMultipleTxSameThread() throws Exception
{
GraphDatabaseAPI graphdb = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newImpermanentDatabase();
TransactionManager tm = graphdb.getDependencyResolver().resolveDependency( TransactionManager.class );
tm.begin();
Node refNode = graphdb.createNode();
tm.commit();
tm.begin();
Transaction tx1 = tm.suspend();
tm.begin();
refNode.setProperty( "test2", "test" );
Transaction tx2 = tm.suspend();
tm.resume( tx1 );
CommitThread thread = new CommitThread( tm, tx2, Thread.currentThread() );
thread.start();
// would wait for ever since tx2 has write lock but now we have other
// thread thread that will commit tx2
refNode.removeProperty( "test2" );
assertTrue( thread.success() );
tm.commit();
graphdb.shutdown();
}
private static class CommitThread extends Thread
{
private final TransactionManager tm;
private final Transaction tx;
private boolean success = false;
private final Thread main;
CommitThread( TransactionManager tm, Transaction tx, Thread main )
{
this.tm = tm;
this.tx = tx;
this.main = main;
}
@Override
public synchronized void run()
{
try
{
while ( main.getState() != Thread.State.WAITING ) Thread.sleep( 1 );
tm.resume( tx );
tm.getTransaction().commit();
success = true;
}
catch ( Throwable t )
{
t.printStackTrace();
}
}
synchronized boolean success()
{
return success;
}
}
}
| false
|
community_kernel_src_test_java_org_neo4j_kernel_impl_core_TestTxSuspendResume.java
|
1,390
|
static class CowEntityElement
{
protected long id;
protected boolean deleted;
protected ArrayMap<Integer, DefinedProperty> propertyAddMap;
protected ArrayMap<Integer, DefinedProperty> propertyRemoveMap;
CowEntityElement( long id )
{
this.id = id;
}
public long getId()
{
return id;
}
public ArrayMap<Integer, DefinedProperty> getPropertyAddMap( boolean create )
{
assertNotDeleted();
if ( propertyAddMap == null && create )
{
propertyAddMap = new ArrayMap<>();
}
return propertyAddMap;
}
private void assertNotDeleted()
{
if ( isDeleted() )
{
throw new IllegalStateException( this + " has been deleted in this tx" );
}
}
public boolean isDeleted()
{
return deleted;
}
public void setDeleted()
{
deleted = true;
}
public ArrayMap<Integer, DefinedProperty> getPropertyRemoveMap( boolean create )
{
if ( propertyRemoveMap == null && create )
{
propertyRemoveMap = new ArrayMap<>();
}
return propertyRemoveMap;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,391
|
static class ReadOnlyIndexToIndexAdapter<T extends PropertyContainer>
implements Index<T>
{
private final ReadableIndex<T> delegate;
public ReadOnlyIndexToIndexAdapter( ReadableIndex<T> delegate )
{
this.delegate = delegate;
}
@Override
public String getName()
{
return delegate.getName();
}
@Override
public Class<T> getEntityType()
{
return delegate.getEntityType();
}
@Override
public IndexHits<T> get( String key, Object value )
{
return delegate.get( key, value );
}
@Override
public IndexHits<T> query( String key, Object queryOrQueryObject )
{
return delegate.query( key, queryOrQueryObject );
}
@Override
public IndexHits<T> query( Object queryOrQueryObject )
{
return delegate.query( queryOrQueryObject );
}
private UnsupportedOperationException readOnlyIndex()
{
return new UnsupportedOperationException( "read only index" );
}
@Override
public void add( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public T putIfAbsent( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity, String key )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity )
{
throw readOnlyIndex();
}
@Override
public void delete()
{
throw readOnlyIndex();
}
@Override
public boolean isWriteable()
{
return false;
}
@Override
public GraphDatabaseService getGraphDatabase()
{
return delegate.getGraphDatabase();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_AbstractAutoIndexerImpl.java
|
1,392
|
private static class IndexWrapper<K extends PropertyContainer> implements
ReadableIndex<K>
{
private final Index<K> delegate;
IndexWrapper( Index<K> delegate )
{
this.delegate = delegate;
}
@Override
public String getName()
{
return delegate.getName();
}
@Override
public Class<K> getEntityType()
{
return delegate.getEntityType();
}
@Override
public IndexHits<K> get( String key, Object value )
{
return delegate.get( key, value );
}
@Override
public IndexHits<K> query( String key, Object queryOrQueryObject )
{
return delegate.query( key, queryOrQueryObject );
}
@Override
public IndexHits<K> query( Object queryOrQueryObject )
{
return delegate.query( queryOrQueryObject );
}
@Override
public boolean isWriteable()
{
return false;
}
@Override
public GraphDatabaseService getGraphDatabase()
{
return delegate.getGraphDatabase();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_AbstractAutoIndexerImpl.java
|
1,393
|
abstract class AbstractAutoIndexerImpl<T extends PropertyContainer> implements
PropertyTracker<T>, AutoIndexer<T>, Lifecycle
{
protected final Set<String> propertyKeysToInclude = new HashSet<String>();
private volatile boolean enabled;
public AbstractAutoIndexerImpl( )
{
}
public void propertyAdded( T primitive, String propertyName,
Object propertyValue )
{
if ( propertyKeysToInclude.contains( propertyName ) )
{
getIndexInternal().add( primitive, propertyName, propertyValue );
}
}
public void propertyChanged( T primitive, String propertyName,
Object oldValue, Object newValue )
{
if ( oldValue != null )
{
getIndexInternal().remove( primitive, propertyName, oldValue );
}
if ( propertyKeysToInclude.contains( propertyName ) )
{
getIndexInternal().add( primitive, propertyName, newValue );
}
}
public void propertyRemoved( T primitive, String propertyName,
Object propertyValue )
{
getIndexInternal().remove( primitive, propertyName );
}
@Override
public ReadableIndex<T> getAutoIndex()
{
return new IndexWrapper<T>( getIndexInternal() );
}
public void setEnabled( boolean enabled )
{
this.enabled = enabled;
}
@Override
public boolean isEnabled()
{
return enabled;
}
@Override
public void startAutoIndexingProperty( String propName )
{
propertyKeysToInclude.add(propName);
}
@Override
public void stopAutoIndexingProperty( String propName )
{
propertyKeysToInclude.remove( propName );
}
@Override
public Set<String> getAutoIndexedProperties()
{
return Collections.unmodifiableSet( propertyKeysToInclude );
}
/**
* Returns the actual index used by the auto indexer. This is not supposed
* to
* leak unprotected to the outside world.
*
* @return The Index used by this AutoIndexer
*/
protected abstract Index<T> getIndexInternal();
protected Set<String> parseConfigList(String list)
{
if ( list == null )
{
return Collections.emptySet();
}
Set<String> toReturn = new HashSet<String>();
StringTokenizer tokenizer = new StringTokenizer(list, "," );
String currentToken;
while ( tokenizer.hasMoreTokens() )
{
currentToken = tokenizer.nextToken();
if ( ( currentToken = currentToken.trim() ).length() > 0 )
{
toReturn.add( currentToken );
}
}
return toReturn;
}
/**
* Simple implementation of the AutoIndex interface, as a wrapper around a
* normal Index that exposes the read-only operations.
*
* @param <K> The type of database primitive this index holds
*/
private static class IndexWrapper<K extends PropertyContainer> implements
ReadableIndex<K>
{
private final Index<K> delegate;
IndexWrapper( Index<K> delegate )
{
this.delegate = delegate;
}
@Override
public String getName()
{
return delegate.getName();
}
@Override
public Class<K> getEntityType()
{
return delegate.getEntityType();
}
@Override
public IndexHits<K> get( String key, Object value )
{
return delegate.get( key, value );
}
@Override
public IndexHits<K> query( String key, Object queryOrQueryObject )
{
return delegate.query( key, queryOrQueryObject );
}
@Override
public IndexHits<K> query( Object queryOrQueryObject )
{
return delegate.query( queryOrQueryObject );
}
@Override
public boolean isWriteable()
{
return false;
}
@Override
public GraphDatabaseService getGraphDatabase()
{
return delegate.getGraphDatabase();
}
}
/**
* A simple wrapper that makes a read only index into a read-write
* index with the unsupported operations throwing
* UnsupportedOperationException
* Useful primarily for returning the actually read-write but
* publicly read-only auto indexes from the get by name methods of the index
* manager.
*/
static class ReadOnlyIndexToIndexAdapter<T extends PropertyContainer>
implements Index<T>
{
private final ReadableIndex<T> delegate;
public ReadOnlyIndexToIndexAdapter( ReadableIndex<T> delegate )
{
this.delegate = delegate;
}
@Override
public String getName()
{
return delegate.getName();
}
@Override
public Class<T> getEntityType()
{
return delegate.getEntityType();
}
@Override
public IndexHits<T> get( String key, Object value )
{
return delegate.get( key, value );
}
@Override
public IndexHits<T> query( String key, Object queryOrQueryObject )
{
return delegate.query( key, queryOrQueryObject );
}
@Override
public IndexHits<T> query( Object queryOrQueryObject )
{
return delegate.query( queryOrQueryObject );
}
private UnsupportedOperationException readOnlyIndex()
{
return new UnsupportedOperationException( "read only index" );
}
@Override
public void add( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public T putIfAbsent( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity, String key, Object value )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity, String key )
{
throw readOnlyIndex();
}
@Override
public void remove( T entity )
{
throw readOnlyIndex();
}
@Override
public void delete()
{
throw readOnlyIndex();
}
@Override
public boolean isWriteable()
{
return false;
}
@Override
public GraphDatabaseService getGraphDatabase()
{
return delegate.getGraphDatabase();
}
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_coreapi_AbstractAutoIndexerImpl.java
|
1,394
|
private class ReadOnlyTxReleaser implements Synchronization
{
@Override
public void beforeCompletion()
{
}
@Override
public void afterCompletion( int status )
{
releaseLocks();
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,395
|
public static class PrimitiveElement
{
PrimitiveElement()
{
}
private final ArrayMap<Long,CowNodeElement> nodes = new ArrayMap<>();
private final ArrayMap<Long,CowRelElement> relationships = new ArrayMap<>();
private final Set<Long> createdNodes = new HashSet<>();
private final Set<Long> createdRelationships = new HashSet<>();
private CowGraphElement graph;
public CowNodeElement nodeElement( long id, boolean create )
{
CowNodeElement result = nodes.get( id );
if ( result == null && create )
{
result = new CowNodeElement( id );
nodes.put( id, result );
}
return result;
}
public CowRelElement relationshipElement( long id, boolean create )
{
CowRelElement result = relationships.get( id );
if ( result == null && create )
{
result = new CowRelElement( id );
relationships.put( id, result );
}
return result;
}
public CowGraphElement graphElement( boolean create )
{
if ( graph == null && create )
{
graph = new CowGraphElement();
}
return graph;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,396
|
public static class CowRelElement extends CowEntityElement
{
CowRelElement( long id )
{
super( id );
}
@Override
public String toString()
{
return "Relationship[" + id + "]";
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,397
|
public static class CowNodeElement extends CowEntityElement
{
CowNodeElement( long id )
{
super( id );
}
private long firstRel = Record.NO_NEXT_RELATIONSHIP.intValue();
private long firstProp = Record.NO_NEXT_PROPERTY.intValue();
private ArrayMap<Integer, RelIdArray> relationshipAddMap;
private ArrayMap<Integer, Collection<Long>> relationshipRemoveMap;
public ArrayMap<Integer, RelIdArray> getRelationshipAddMap( boolean create )
{
if ( relationshipAddMap == null && create )
{
relationshipAddMap = new ArrayMap<>();
}
return relationshipAddMap;
}
public RelIdArray getRelationshipAddMap( int type, boolean create )
{
ArrayMap<Integer, RelIdArray> map = getRelationshipAddMap( create );
if ( map == null )
{
return null;
}
RelIdArray result = map.get( type );
if ( result == null && create )
{
result = new RelIdArrayWithLoops( type );
map.put( type, result );
}
return result;
}
public ArrayMap<Integer, Collection<Long>> getRelationshipRemoveMap( boolean create )
{
if ( relationshipRemoveMap == null && create )
{
relationshipRemoveMap = new ArrayMap<>();
}
return relationshipRemoveMap;
}
public Collection<Long> getRelationshipRemoveMap( int type, boolean create )
{
ArrayMap<Integer, Collection<Long>> map = getRelationshipRemoveMap( create );
if ( map == null )
{
return null;
}
Collection<Long> result = map.get( type );
if ( result == null && create )
{
result = new HashSet<>();
map.put( type, result );
}
return result;
}
@Override
public String toString()
{
return "Node[" + id + "]";
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,398
|
public static class CowGraphElement extends CowEntityElement
{
CowGraphElement()
{
super( -1 );
}
@Override
public String toString()
{
return "Graph";
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
1,399
|
public class WritableTransactionState implements TransactionState
{
// Dependencies
private final LockManager lockManager;
private final NodeManager nodeManager;
private final StringLogger log;
private final Transaction tx;
private final RemoteTxHook txHook;
private final TxIdGenerator txIdGenerator;
// State
private List<LockElement> lockElements;
private PrimitiveElement primitiveElement;
private ResourceHolder neoStoreTransaction;
private boolean isRemotelyInitialized = false;
public static class PrimitiveElement
{
PrimitiveElement()
{
}
private final ArrayMap<Long,CowNodeElement> nodes = new ArrayMap<>();
private final ArrayMap<Long,CowRelElement> relationships = new ArrayMap<>();
private final Set<Long> createdNodes = new HashSet<>();
private final Set<Long> createdRelationships = new HashSet<>();
private CowGraphElement graph;
public CowNodeElement nodeElement( long id, boolean create )
{
CowNodeElement result = nodes.get( id );
if ( result == null && create )
{
result = new CowNodeElement( id );
nodes.put( id, result );
}
return result;
}
public CowRelElement relationshipElement( long id, boolean create )
{
CowRelElement result = relationships.get( id );
if ( result == null && create )
{
result = new CowRelElement( id );
relationships.put( id, result );
}
return result;
}
public CowGraphElement graphElement( boolean create )
{
if ( graph == null && create )
{
graph = new CowGraphElement();
}
return graph;
}
}
static class CowEntityElement
{
protected long id;
protected boolean deleted;
protected ArrayMap<Integer, DefinedProperty> propertyAddMap;
protected ArrayMap<Integer, DefinedProperty> propertyRemoveMap;
CowEntityElement( long id )
{
this.id = id;
}
public long getId()
{
return id;
}
public ArrayMap<Integer, DefinedProperty> getPropertyAddMap( boolean create )
{
assertNotDeleted();
if ( propertyAddMap == null && create )
{
propertyAddMap = new ArrayMap<>();
}
return propertyAddMap;
}
private void assertNotDeleted()
{
if ( isDeleted() )
{
throw new IllegalStateException( this + " has been deleted in this tx" );
}
}
public boolean isDeleted()
{
return deleted;
}
public void setDeleted()
{
deleted = true;
}
public ArrayMap<Integer, DefinedProperty> getPropertyRemoveMap( boolean create )
{
if ( propertyRemoveMap == null && create )
{
propertyRemoveMap = new ArrayMap<>();
}
return propertyRemoveMap;
}
}
public static class CowNodeElement extends CowEntityElement
{
CowNodeElement( long id )
{
super( id );
}
private long firstRel = Record.NO_NEXT_RELATIONSHIP.intValue();
private long firstProp = Record.NO_NEXT_PROPERTY.intValue();
private ArrayMap<Integer, RelIdArray> relationshipAddMap;
private ArrayMap<Integer, Collection<Long>> relationshipRemoveMap;
public ArrayMap<Integer, RelIdArray> getRelationshipAddMap( boolean create )
{
if ( relationshipAddMap == null && create )
{
relationshipAddMap = new ArrayMap<>();
}
return relationshipAddMap;
}
public RelIdArray getRelationshipAddMap( int type, boolean create )
{
ArrayMap<Integer, RelIdArray> map = getRelationshipAddMap( create );
if ( map == null )
{
return null;
}
RelIdArray result = map.get( type );
if ( result == null && create )
{
result = new RelIdArrayWithLoops( type );
map.put( type, result );
}
return result;
}
public ArrayMap<Integer, Collection<Long>> getRelationshipRemoveMap( boolean create )
{
if ( relationshipRemoveMap == null && create )
{
relationshipRemoveMap = new ArrayMap<>();
}
return relationshipRemoveMap;
}
public Collection<Long> getRelationshipRemoveMap( int type, boolean create )
{
ArrayMap<Integer, Collection<Long>> map = getRelationshipRemoveMap( create );
if ( map == null )
{
return null;
}
Collection<Long> result = map.get( type );
if ( result == null && create )
{
result = new HashSet<>();
map.put( type, result );
}
return result;
}
@Override
public String toString()
{
return "Node[" + id + "]";
}
}
public static class CowRelElement extends CowEntityElement
{
CowRelElement( long id )
{
super( id );
}
@Override
public String toString()
{
return "Relationship[" + id + "]";
}
}
public static class CowGraphElement extends CowEntityElement
{
CowGraphElement()
{
super( -1 );
}
@Override
public String toString()
{
return "Graph";
}
}
public WritableTransactionState( LockManager lockManager,
NodeManager nodeManager, Logging logging, Transaction tx, RemoteTxHook txHook, TxIdGenerator txIdGenerator )
{
this.lockManager = lockManager;
this.nodeManager = nodeManager;
this.tx = tx;
this.txHook = txHook;
this.txIdGenerator = txIdGenerator;
this.log = logging.getMessagesLog( getClass() );
}
@Override
public LockElement acquireWriteLock( Object resource )
{
lockManager.getWriteLock( resource, tx );
LockElement lock = new LockElement( resource, tx, LockType.WRITE, lockManager );
addLockToTransaction( lock );
return lock;
}
@Override
public LockElement acquireReadLock( Object resource )
{
lockManager.getReadLock( resource, tx );
LockElement lock = new LockElement( resource, tx, LockType.READ, lockManager );
addLockToTransaction( lock );
return lock;
}
private void addLockToTransaction( LockElement lock )
{
boolean firstLock = false;
if ( lockElements == null )
{
lockElements = new ArrayList<>();
firstLock = true;
}
lockElements.add( lock );
if ( firstLock )
{
try
{
tx.registerSynchronization( new ReadOnlyTxReleaser() );
}
catch ( Exception e )
{
throw new TransactionFailureException(
"Failed to register lock release synchronization hook", e );
}
}
}
@Override
public ArrayMap<Integer, Collection<Long>> getCowRelationshipRemoveMap( NodeImpl node )
{
if ( primitiveElement != null )
{
ArrayMap<Long, CowNodeElement> cowElements =
primitiveElement.nodes;
CowNodeElement element = cowElements.get( node.getId() );
if ( element != null )
{
return element.relationshipRemoveMap;
}
}
return null;
}
@Override
public Collection<Long> getOrCreateCowRelationshipRemoveMap( NodeImpl node, int type )
{
return getPrimitiveElement( true ).nodeElement( node.getId(), true ).getRelationshipRemoveMap( type, true );
}
@Override
public void setFirstIds( long nodeId, long firstRel, long firstProp )
{
CowNodeElement nodeElement = getPrimitiveElement( true ).nodeElement( nodeId, true );
nodeElement.firstRel = firstRel;
nodeElement.firstProp = firstProp;
}
@Override
public ArrayMap<Integer, RelIdArray> getCowRelationshipAddMap( NodeImpl node )
{
PrimitiveElement primitiveElement = getPrimitiveElement( false );
if ( primitiveElement == null )
{
return null;
}
CowNodeElement element = primitiveElement.nodeElement( node.getId(), false );
return element != null ? element.relationshipAddMap : null;
}
@Override
public RelIdArray getOrCreateCowRelationshipAddMap( NodeImpl node, int type )
{
return getPrimitiveElement( true ).nodeElement( node.getId(), true ).getRelationshipAddMap( type, true );
}
@Override
public void commit()
{
releaseLocks();
}
@Override
public void commitCows()
{
applyTransactionStateToCache( Status.STATUS_COMMITTED );
}
@Override
public void rollback()
{
try
{
applyTransactionStateToCache( Status.STATUS_ROLLEDBACK );
}
finally
{
releaseLocks();
}
}
@Override
public boolean hasLocks()
{
return lockElements != null && !lockElements.isEmpty();
}
private void releaseLocks()
{
if ( lockElements != null )
{
Collection<LockElement> releaseFailures = null;
Exception releaseException = null;
for ( LockElement lockElement : lockElements )
{
try
{
lockElement.releaseIfAcquired();
}
catch ( Exception e )
{
releaseException = e;
if ( releaseFailures == null )
{
releaseFailures = new ArrayList<>();
}
releaseFailures.add( lockElement );
}
}
if ( releaseException != null )
{
log.warn( "Unable to release locks: " + releaseFailures + ". Example of exception:" +
releaseException );
}
}
}
private void applyTransactionStateToCache( int param )
{
if ( primitiveElement == null )
{
return;
}
ArrayMap<Long, CowNodeElement> cowNodeElements = primitiveElement.nodes;
Set<Entry<Long, CowNodeElement>> nodeEntrySet =
cowNodeElements.entrySet();
for ( Entry<Long, CowNodeElement> entry : nodeEntrySet )
{
NodeImpl node = nodeManager.getNodeIfCached( entry.getKey() );
if ( node != null )
{
CowNodeElement nodeElement = entry.getValue();
if ( param == Status.STATUS_COMMITTED )
{
node.commitRelationshipMaps( nodeElement.relationshipAddMap, nodeElement.relationshipRemoveMap );
node.commitPropertyMaps( nodeElement.propertyAddMap,
nodeElement.propertyRemoveMap, nodeElement.firstProp );
}
else if ( param != Status.STATUS_ROLLEDBACK )
{
throw new TransactionFailureException(
"Unknown transaction status: " + param );
}
int sizeAfter = node.sizeOfObjectInBytesIncludingOverhead();
nodeManager.updateCacheSize( node, sizeAfter );
}
}
ArrayMap<Long, CowRelElement> cowRelElements = primitiveElement.relationships;
Set<Entry<Long, CowRelElement>> relEntrySet =
cowRelElements.entrySet();
for ( Entry<Long, CowRelElement> entry : relEntrySet )
{
RelationshipImpl rel = nodeManager.getRelIfCached( entry.getKey() );
if ( rel != null )
{
CowRelElement relElement = entry.getValue();
if ( param == Status.STATUS_COMMITTED )
{
rel.commitPropertyMaps( relElement.propertyAddMap,
relElement.propertyRemoveMap, Record.NO_NEXT_PROPERTY.intValue() );
}
else if ( param != Status.STATUS_ROLLEDBACK )
{
throw new TransactionFailureException(
"Unknown transaction status: " + param );
}
int sizeAfter = rel.sizeOfObjectInBytesIncludingOverhead();
nodeManager.updateCacheSize( rel, sizeAfter );
}
}
if ( primitiveElement.graph != null && param == Status.STATUS_COMMITTED )
{
nodeManager.getGraphProperties().commitPropertyMaps( primitiveElement.graph.getPropertyAddMap( false ),
primitiveElement.graph.getPropertyRemoveMap( false ), Record.NO_NEXT_PROPERTY.intValue()
);
}
}
@Override
public ArrayMap<Integer,DefinedProperty> getCowPropertyRemoveMap( Primitive primitive )
{
if ( primitiveElement == null )
{
return null;
}
CowEntityElement element = primitive.getEntityElement( primitiveElement, false );
return element != null ? element.getPropertyRemoveMap( false ) : null;
}
@Override
public ArrayMap<Integer, DefinedProperty> getCowPropertyAddMap( Primitive primitive )
{
if ( primitiveElement == null )
{
return null;
}
CowEntityElement element = primitive.getEntityElement( primitiveElement, false );
return element != null ? element.getPropertyAddMap( false ) : null;
}
private PrimitiveElement getPrimitiveElement( boolean create )
{
if ( primitiveElement == null && create )
{
primitiveElement = new PrimitiveElement();
}
return primitiveElement;
}
@Override
public ArrayMap<Integer, DefinedProperty> getOrCreateCowPropertyAddMap( Primitive primitive )
{
return primitive.getEntityElement( getPrimitiveElement( true ), true ).getPropertyAddMap( true );
}
@Override
public ArrayMap<Integer, DefinedProperty> getOrCreateCowPropertyRemoveMap( Primitive primitive )
{
return primitive.getEntityElement( getPrimitiveElement( true ), true ).getPropertyRemoveMap( true );
}
@Override
public void createNode( long id )
{
getPrimitiveElement( true ).createdNodes.add( id );
}
@Override
public void createRelationship( long id )
{
getPrimitiveElement( true ).createdRelationships.add( id );
}
@Override
public void deleteNode( long id )
{
PrimitiveElement element = getPrimitiveElement( true );
element.nodeElement( id, true ).setDeleted();
}
@Override
public void deleteRelationship( long id )
{
PrimitiveElement element = getPrimitiveElement( true );
element.relationshipElement( id, true ).setDeleted();
}
@Override
public TransactionData getTransactionData()
{
TransactionDataImpl result = new TransactionDataImpl();
populateCreatedNodes( primitiveElement, result );
if ( primitiveElement == null )
{
return result;
}
populateNodeRelEvent( primitiveElement, result );
populateRelationshipPropertyEvents( primitiveElement, result );
return result;
}
private void populateRelationshipPropertyEvents( PrimitiveElement element,
TransactionDataImpl result )
{
for ( long relId : element.relationships.keySet() )
{
CowRelElement relElement = element.relationships.get( relId );
RelationshipProxy rel = nodeManager.newRelationshipProxyById( relId );
RelationshipImpl relImpl = nodeManager.getRelationshipForProxy( relId );
if ( relElement.isDeleted() )
{
if ( primitiveElement.createdRelationships.contains( relId ) )
{
continue;
}
// note: this is done in node populate data
// result.deleted( rel );
}
if ( relElement.propertyAddMap != null && !relElement.isDeleted() )
{
for ( DefinedProperty data : relElement.propertyAddMap.values() )
{
String key = nodeManager.getKeyForProperty( data );
Object oldValue = relImpl.getCommittedPropertyValue( nodeManager, key );
Object newValue = data.value();
result.assignedProperty( rel, key, newValue, oldValue );
}
}
if ( relElement.propertyRemoveMap != null )
{
for ( DefinedProperty data : relElement.propertyRemoveMap.values() )
{
String key = nodeManager.getKeyForProperty( data );
Object oldValue = data.value();
if ( oldValue != null && !relElement.isDeleted() )
{
relImpl.getCommittedPropertyValue( nodeManager, key );
}
result.removedProperty( rel, key, oldValue );
}
}
}
}
private void populateNodeRelEvent( PrimitiveElement element,
TransactionDataImpl result )
{
for ( long nodeId : element.nodes.keySet() )
{
CowNodeElement nodeElement = element.nodes.get( nodeId );
NodeProxy node = nodeManager.newNodeProxyById( nodeId );
NodeImpl nodeImpl = nodeManager.getNodeForProxy( nodeId, null );
if ( nodeElement.isDeleted() )
{
if ( primitiveElement.createdNodes.contains( nodeId ) )
{
continue;
}
result.deleted( node );
}
if ( nodeElement.relationshipAddMap != null && !nodeElement.isDeleted() )
{
for ( Integer type : nodeElement.relationshipAddMap.keySet() )
{
RelIdArray createdRels = nodeElement.relationshipAddMap.get( type );
populateNodeRelEvent( element, result, nodeId, createdRels );
}
}
if ( nodeElement.relationshipRemoveMap != null )
{
for ( Integer type : nodeElement.relationshipRemoveMap.keySet() )
{
Collection<Long> deletedRels = nodeElement.relationshipRemoveMap.get( type );
for ( long relId : deletedRels )
{
if ( primitiveElement.createdRelationships.contains( relId ) )
{
continue;
}
RelationshipProxy rel = nodeManager.newRelationshipProxyById( relId );
if ( rel.getStartNode().getId() == nodeId )
{
result.deleted( nodeManager.newRelationshipProxyById( relId ) );
}
}
}
}
if ( nodeElement.propertyAddMap != null && !nodeElement.isDeleted() )
{
for ( DefinedProperty data : nodeElement.propertyAddMap.values() )
{
String key = nodeManager.getKeyForProperty( data );
Object oldValue = nodeImpl.getCommittedPropertyValue( nodeManager, key );
Object newValue = data.value();
result.assignedProperty( node, key, newValue, oldValue );
}
}
if ( nodeElement.propertyRemoveMap != null )
{
for ( DefinedProperty data : nodeElement.propertyRemoveMap.values() )
{
String key = nodeManager.getKeyForProperty( data );
Object oldValue = data.value();
if ( oldValue == null && !nodeElement.isDeleted() )
{
nodeImpl.getCommittedPropertyValue( nodeManager, key );
}
result.removedProperty( node, key, oldValue );
}
}
}
}
private void populateNodeRelEvent( PrimitiveElement element, TransactionDataImpl result,
long nodeId, RelIdArray createdRels )
{
for ( RelIdIterator iterator = createdRels.iterator( DirectionWrapper.BOTH ); iterator.hasNext(); )
{
long relId = iterator.next();
CowRelElement relElement = element.relationships.get( relId );
if ( relElement != null && relElement.isDeleted() )
{
continue;
}
RelationshipProxy rel = nodeManager.newRelationshipProxyById( relId );
if ( rel.getStartNode().getId() == nodeId )
{
result.created( nodeManager.newRelationshipProxyById( relId ) );
}
}
}
private void populateCreatedNodes( PrimitiveElement element,
TransactionDataImpl result )
{
for ( Long nodeId : getCreatedNodes() )
{
if ( element != null )
{
CowNodeElement nodeElement = element.nodes.get( nodeId );
if ( nodeElement != null && nodeElement.isDeleted() )
{
continue;
}
}
result.created( nodeManager.newNodeProxyById( nodeId ) );
}
}
@Override
public Set<Long> getCreatedNodes()
{
return primitiveElement != null ? primitiveElement.createdNodes : Collections.<Long>emptySet();
}
@Override
public Set<Long> getCreatedRelationships()
{
return primitiveElement != null ? primitiveElement.createdRelationships : Collections.<Long>emptySet();
}
@Override
public Iterable<CowNodeElement> getChangedNodes()
{
if ( primitiveElement == null )
{
return Iterables.empty();
}
return primitiveElement.nodes.values();
}
@Override
public boolean nodeIsDeleted( long nodeId )
{
if ( primitiveElement == null )
{
return false;
}
CowNodeElement nodeElement = primitiveElement.nodeElement( nodeId, false );
return nodeElement != null && nodeElement.isDeleted();
}
@Override
public boolean relationshipIsDeleted( long relationshipId )
{
if ( primitiveElement == null )
{
return false;
}
CowRelElement relationshipElement = primitiveElement.relationshipElement( relationshipId, false );
return relationshipElement != null && relationshipElement.isDeleted();
}
@Override
public boolean hasChanges()
{
return primitiveElement != null || lockElements != null;
}
private class ReadOnlyTxReleaser implements Synchronization
{
@Override
public void beforeCompletion()
{
}
@Override
public void afterCompletion( int status )
{
releaseLocks();
}
}
@Override
public RemoteTxHook getTxHook()
{
return txHook;
}
@Override
public TxIdGenerator getTxIdGenerator()
{
return txIdGenerator;
}
@Override
public boolean isRemotelyInitialized()
{
return isRemotelyInitialized;
}
@Override
public void markAsRemotelyInitialized()
{
isRemotelyInitialized = true;
}
@Override
public ResourceHolder getNeoStoreTransaction()
{
return neoStoreTransaction;
}
@Override
public void setNeoStoreTransaction( ResourceHolder neoStoreTransaction )
{
this.neoStoreTransaction = neoStoreTransaction;
}
}
| false
|
community_kernel_src_main_java_org_neo4j_kernel_impl_core_WritableTransactionState.java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.