@Override public Map<String,Object> getNodeProperties( long nodeId ) { return delegate.getNodeProperties( nodeId ); }
private Map<String,Object> getNodeProperties( BatchInserter inserter, long nodeId ) { return inserter.getNodeProperties( nodeId ); }
private void setAndGet( BatchInserter inserter, Object value ) { long nodeId = inserter.createNode( map( "key", value ) ); Object readValue = inserter.getNodeProperties( nodeId ).get( "key" ); if ( readValue.getClass().isArray() ) { assertTrue( Arrays.equals( (int[])value, (int[])readValue ) ); } else { assertEquals( value, readValue ); } }
@Test public void replaceWithBiggerPropertySpillsOverIntoNewPropertyRecord() { // GIVEN BatchInserter batchInserter = globalInserter; Map<String, Object> props = new HashMap<>(); props.put( "name", "One" ); props.put( "count", 1 ); props.put( "tags", new String[] { "one", "two" } ); long id = batchInserter.createNode( props ); batchInserter.setNodeProperty( id, "name", "NewOne" ); // WHEN batchInserter.setNodeProperty( id, "count", "something" ); // THEN assertEquals( "something", batchInserter.getNodeProperties( id ).get( "count" ) ); }
@Test public void propertiesCanBeReSetUsingBatchInserter2() { // GIVEN BatchInserter batchInserter = globalInserter; long id = batchInserter.createNode( new HashMap<>() ); // WHEN batchInserter.setNodeProperty( id, "test", "looooooooooong test" ); batchInserter.setNodeProperty( id, "test", "small test" ); // THEN assertEquals( "small test", batchInserter.getNodeProperties( id ).get( "test" ) ); }
@Test public void propertiesCanBeReSetUsingBatchInserter() { // GIVEN BatchInserter batchInserter = globalInserter; Map<String, Object> props = new HashMap<>(); props.put( "name", "One" ); props.put( "count", 1 ); props.put( "tags", new String[] { "one", "two" } ); props.put( "something", "something" ); long nodeId = batchInserter.createNode( props ); batchInserter.setNodeProperty( nodeId, "name", "NewOne" ); batchInserter.removeNodeProperty( nodeId, "count" ); batchInserter.removeNodeProperty( nodeId, "something" ); // WHEN setting new properties batchInserter.setNodeProperty( nodeId, "name", "YetAnotherOne" ); batchInserter.setNodeProperty( nodeId, "additional", "something" ); // THEN there should be no problems doing so assertEquals( "YetAnotherOne", batchInserter.getNodeProperties( nodeId ).get( "name" ) ); assertEquals("something", batchInserter.getNodeProperties( nodeId ).get( "additional" ) ); }
@Test public void shouldUpdateStringArrayPropertiesOnNodesUsingBatchInserter1() { // Given BatchInserter inserter = globalInserter; String[] array1 = { "1" }; String[] array2 = { "a" }; long id1 = inserter.createNode(map("array", array1)); long id2 = inserter.createNode( map() ); // When inserter.getNodeProperties( id1 ).get( "array" ); inserter.setNodeProperty( id1, "array", array1 ); inserter.setNodeProperty( id2, "array", array2 ); inserter.getNodeProperties( id1 ).get( "array" ); inserter.setNodeProperty( id1, "array", array1 ); inserter.setNodeProperty( id2, "array", array2 ); // Then assertThat( inserter.getNodeProperties( id1 ).get( "array" ), equalTo( array1 ) ); }
@Test public void shouldBeAbleToRemoveDynamicProperty() { // Only triggered if assertions are enabled // GIVEN BatchInserter batchInserter = globalInserter; String key = "tags"; long nodeId = batchInserter.createNode( MapUtil.map( key, new String[] { "one", "two", "three" } ) ); // WHEN batchInserter.removeNodeProperty( nodeId, key ); // THEN assertFalse( batchInserter.getNodeProperties( nodeId ).containsKey( key ) ); }
@Test public void givenBatchInserterWhenArrayPropertyUpdated4TimesThenShouldNotFail() throws IOException { BatchInserter batchInserter = BatchInserters.inserter( testDirectory.databaseDir(), fileSystemRule.get() ); long nodeId = batchInserter.createNode( Collections.emptyMap() ); for ( int i = 0; i < 4; i++ ) { batchInserter.setNodeProperty( nodeId, "array", new byte[]{2, 3, 98, 1, 43, 50, 3, 33, 51, 55, 116, 16, 23, 56, 9, -10, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1} ); } batchInserter.getNodeProperties( nodeId ); //fails here batchInserter.shutdown(); } }
@Override public Map<String,Object> getNodeProperties( long nodeId ) { return delegate.getNodeProperties( nodeId ); }
/** * {@inheritDoc} */ @Override public Iterable<Object> getPropertyValues() { return batchInserter.getNodeProperties(id).values(); }
/** * {@inheritDoc} */ @Override public Iterable<String> getPropertyKeys() { return batchInserter.getNodeProperties(id).keySet(); }
@Override public <T> Optional<T> getNodeProperty(long node, String property, Class<T> type) { Map<String, Object> propertyMap; synchronized (graphLock) { propertyMap = inserter.getNodeProperties(node); } if (propertyMap.containsKey(property)) { return Optional.<T> of(type.cast(propertyMap.get(property))); } else { return Optional.empty(); } }
private static long firstNode(BatchInserter sourceDb, long highestNodeId) { long node = -1; while (++node <= highestNodeId) { if (sourceDb.nodeExists(node) && !sourceDb.getNodeProperties(node).isEmpty()) return node; } return -1; }
@Override public <T> Collection<T> getNodeProperties(long node, String property, Class<T> type) { Map<String, Object> propertyMap; synchronized (graphLock) { propertyMap = inserter.getNodeProperties(node); } if (propertyMap.containsKey(property)) { return GraphUtil.getPropertiesAsSet(propertyMap.get(property), type); } else { return emptyList(); } }
public Map<String, Object> getPropertyMap() { return this.graph.getRawGraph().getNodeProperties(this.id); }
public Map<String, Object> getPropertyMap() { return this.graph.getRawGraph().getNodeProperties(this.id); }
private static void flushCache(BatchInserter sourceDb, long node) { Map<String, Object> nodeProperties = sourceDb.getNodeProperties(node); Iterator<Map.Entry<String, Object>> iterator = nodeProperties.entrySet().iterator(); if (iterator.hasNext()) { Map.Entry<String, Object> firstProp = iterator.next(); sourceDb.nodeHasProperty(node,firstProp.getKey()); sourceDb.setNodeProperty(node, firstProp.getKey(), firstProp.getValue()); // force flush System.out.print(" flush"); } }
void index() { logger.info("Starting indexing"); List<Long> ids = newArrayList(idMap.values()); //TODO: Evaluate the performance of using a BTreeMap instead of sorting here. Collections.sort(ids); for (long id: ids) { Map<String, Object> properties = inserter.getNodeProperties(id); Map<String, Object> indexProperties = collectIndexProperties(properties); if (!indexProperties.isEmpty()) { nodeIndex.add(id, indexProperties); } } logger.info("Finished indexing"); }
/** * {@inheritDoc} */ @Override public Object getProperty(String key) { if (!hasProperty(key)) { throw new NotFoundException(); } return batchInserter.getNodeProperties(id).get(key); }