diff --git a/.gitignore b/.gitignore
index 8068abf..2e8d1ec 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,11 @@
+*.db
+dbs
 .DS_Store
 target
 *.iws
 *.iml
 *.ipr
 .idea
-
+dependency-reduced-pom.xml
+.shell_history
+neo4j.conf
diff --git a/api/pom.xml b/api/pom.xml
new file mode 100644
index 0000000..fd42edf
--- /dev/null
+++ b/api/pom.xml
@@ -0,0 +1,16 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-api</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-api</name>
+</project>
diff --git a/api/src/main/java/org/neo4j/tool/api/NodeInfo.java b/api/src/main/java/org/neo4j/tool/api/NodeInfo.java
new file mode 100644
index 0000000..b944c5f
--- /dev/null
+++ b/api/src/main/java/org/neo4j/tool/api/NodeInfo.java
@@ -0,0 +1,17 @@
+package org.neo4j.tool.api;
+
+import java.util.Map;
+
+/**
+* @author mh
+* @since 10.06.14
+*/
+public class NodeInfo {
+    public long id;
+    public Map<String,Object> data;
+    public String[] labels;
+
+    public NodeInfo(long id) {
+        this.id = id;
+    }
+}
diff --git a/api/src/main/java/org/neo4j/tool/api/RelInfo.java b/api/src/main/java/org/neo4j/tool/api/RelInfo.java
new file mode 100644
index 0000000..07a62a1
--- /dev/null
+++ b/api/src/main/java/org/neo4j/tool/api/RelInfo.java
@@ -0,0 +1,23 @@
+package org.neo4j.tool.api;
+
+import java.util.Map;
+
+/**
+* @author mh
+* @since 10.06.14
+*/
+public class RelInfo {
+    public long id = -1;
+    public long from;
+    public long to;
+    public Map<String,Object> data;
+    public String type;
+
+    public RelInfo(long id) {
+        this.id = id;
+    }
+
+    public String toString() {
+        return from + "-[:" + type + "]" + "->" + to;
+    }
+}
diff --git a/api/src/main/java/org/neo4j/tool/api/StoreHandler.java b/api/src/main/java/org/neo4j/tool/api/StoreHandler.java
new file mode 100644
index 0000000..64eff5b
--- /dev/null
+++ b/api/src/main/java/org/neo4j/tool/api/StoreHandler.java
@@ -0,0 +1,13 @@
+package org.neo4j.tool.api;
+
+import java.io.IOException;
+
+/**
+* @author mh
+* @since 10.06.14
+*/
+public interface StoreHandler {
+    void init(String dir, String pageCache) throws IOException;
+    void shutdown();
+    void flush();
+}
diff --git a/api/src/main/java/org/neo4j/tool/api/StoreReader.java b/api/src/main/java/org/neo4j/tool/api/StoreReader.java
new file mode 100644
index 0000000..888ba09
--- /dev/null
+++ b/api/src/main/java/org/neo4j/tool/api/StoreReader.java
@@ -0,0 +1,13 @@
+package org.neo4j.tool.api;
+
+/**
+* @author mh
+* @since 10.06.14
+*/
+public interface StoreReader extends StoreHandler {
+    NodeInfo readNode(long id);
+    RelInfo readRel(long id);
+    boolean nodeExists(long node);
+    long highestNodeId();
+    long highestRelId();
+}
diff --git a/api/src/main/java/org/neo4j/tool/api/StoreWriter.java b/api/src/main/java/org/neo4j/tool/api/StoreWriter.java
new file mode 100644
index 0000000..c56a0f5
--- /dev/null
+++ b/api/src/main/java/org/neo4j/tool/api/StoreWriter.java
@@ -0,0 +1,10 @@
+package org.neo4j.tool.api;
+
+/**
+* @author mh
+* @since 10.06.14
+*/
+public interface StoreWriter extends StoreHandler {
+    void createNode(NodeInfo node);
+    void createRelationship(RelInfo rel);
+}
diff --git a/copy-store.sh b/copy-store.sh
new file mode 100755
index 0000000..60ce18a
--- /dev/null
+++ b/copy-store.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+EDITION=${1-community}
+shift
+SRC=${1%%:*}
+SVER=${1##*:}
+DST=${2%%:*}
+DVER=${2##*:}
+SKIP_RELS=$3
+SKIP_PROPS=$4
+SKIP_LABELS=$5
+DELETE_NODES=$6
+KEEP_NODE_IDS=$7
+HEAP=4G
+CACHE=2G
+CACHE_SRC=1G
+#$CACHE
+echo "Usage: copy-store.sh [community|enterprise] source.db:version target.db:version [RELS,TO,SKIP] [props,to,skip] [Labels,To,Skip] [Labels,To,Delete,Nodes]"
+
+if [[ "$EDITION" != "enterprise" && "$EDITION" != "community" ]]
+then
+    echo "ATTENTION: The parameter '$EDITION' you passed in for the edition is neither 'community' nor 'enterprise'. Aborting."
+    exit
+fi
+if [[ "$SRC" = "" || "$DST" = "" ]]
+then
+    echo "ATTENTION: Source '$SRC' or target '$DST' not provided. Aborting."
+    exit
+fi
+
+if [[ ! -d $SRC ]]
+then
+    echo "ATTENTION: Source '$SRC' is not a directory. Aborting."
+    exit
+fi
+
+if [[ -d $DST ]]
+then
+    echo "ATTENTION: Target '$DST' already exists. Aborting."
+    exit
+fi
+
+echo "Using: Heap $HEAP Pagecache $CACHE Edition '$EDITION' from '$SRC' (version $SVER) to '$DST' (version $DVER) skipping labels: '$SKIP_LABELS', removing nodes with labels: '$DELETE_NODES' rels: '$SKIP_RELS' props '$SKIP_PROPS' Keeping Node Ids: $KEEP_NODE_IDS"
+echo
+echo "Please note that you will need this memory ($CACHE + $CACHE_SRC + $HEAP) as it opens 2 databases one for reading and one for writing."
+# heap config
+
+echo "Building binary packages (jars) for all versions"
+mvn install -P${EDITION} 2>&1 | grep -v '\[\(INFO\|WARNING\)\]'
+
+pushd `pwd`
+
+cd runner
+
+export MAVEN_OPTS="-Xmx$HEAP -Xms$HEAP -XX:+UseG1GC"
+mvn exec:java -P${EDITION} -e -Dexec.mainClass="org.neo4j.tool.StoreCopy" -Ddbms.pagecache.memory=$CACHE -Ddbms.pagecache.memory.source=$CACHE_SRC \
+      -Dexec.args="$SRC:$SVER $DST:$DVER $SKIP_RELS $SKIP_PROPS $SKIP_LABELS $DELETE_NODES $KEEP_NODE_IDS"
+popd
diff --git a/neo4j22/pom.xml b/neo4j22/pom.xml
new file mode 100644
index 0000000..ae39aba
--- /dev/null
+++ b/neo4j22/pom.xml
@@ -0,0 +1,71 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-impl-2.2</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-impl-2.2</name>
+
+    <properties>
+        <neo4j.version>2.2.10</neo4j.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-lucene-index</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>3.2.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <filters>
+                        <filter>
+                            <artifact>*:*</artifact>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
new file mode 100644
index 0000000..3c3b7a5
--- /dev/null
+++ b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
@@ -0,0 +1,96 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.DynamicLabel;
+import org.neo4j.graphdb.DynamicRelationshipType;
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.helpers.collection.MapUtil;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreHandler;
+import org.neo4j.unsafe.batchinsert.*;
+
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchHandlerImpl implements StoreHandler {
+
+    static Label[] NO_LABELS = new Label[0];
+    public static final String[] NO_LABELS_NAMES = new String[0];
+    private Runnable flusher;
+
+    protected String[] toLabelStrings(long id) {
+        Iterator<Label> labels = batchInserter.getNodeLabels(id).iterator();
+        if (labels == null || !labels.hasNext()) return NO_LABELS_NAMES;
+        String[] result = new String[50];
+        int i = 0;
+        while (labels.hasNext()) {
+            Label next = labels.next();
+            result[i++] = next.name();
+        }
+        return Arrays.copyOf(result, i);
+    }
+
+    public Label[] labels(NodeInfo node) {
+        if (node.labels == null || node.labels.length == 0) return NO_LABELS;
+        Label[] result = new Label[node.labels.length];
+        for (int i = 0; i < result.length; i++) { // todo cache
+            result[i] = DynamicLabel.label(node.labels[i]);
+        }
+        return result;
+    }
+
+    public RelationshipType type(RelInfo rel) {
+        return DynamicRelationshipType.withName(rel.type);
+    }
+
+    protected BatchInserter batchInserter;
+    protected String dir;
+
+    @Override
+    public void init(String dir, String pageCache) throws IOException {
+        this.dir = dir;
+        batchInserter = BatchInserters.inserter(dir, MapUtil.stringMap("dbms.pagecache.memory", pageCache));
+        flusher = getFlusher(batchInserter);
+    }
+
+    @Override
+    public void flush() {
+        flusher.run();
+    }
+
+    @Override
+    public void shutdown() {
+        batchInserter.shutdown();
+    }
+
+    private static Runnable getFlusher(final BatchInserter db) {
+        try {
+            Field field = BatchInserterImpl.class.getDeclaredField("recordAccess");
+            field.setAccessible(true);
+            final DirectRecordAccessSet recordAccessSet = (DirectRecordAccessSet) field.get(db);
+            final Field cacheField = DirectRecordAccess.class.getDeclaredField("batch");
+            cacheField.setAccessible(true);
+            return new Runnable() {
+                @Override public void run() {
+                    try {
+                        ((Map) cacheField.get(recordAccessSet.getNodeRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getRelRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getPropertyRecords())).clear();
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException("Error clearing cache "+cacheField,e);
+                    }
+                }
+            };
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            throw new RuntimeException("Error accessing cache field ", e);
+        }
+    }
+}
diff --git a/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
new file mode 100644
index 0000000..0c93cac
--- /dev/null
+++ b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
@@ -0,0 +1,51 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.kernel.impl.store.NodeStore;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreReader;
+import org.neo4j.unsafe.batchinsert.BatchRelationship;
+
+import java.io.File;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchReaderImpl extends StoreBatchHandlerImpl implements StoreReader {
+
+
+    @Override
+    public NodeInfo readNode(long id) {
+        NodeInfo node = new NodeInfo(id);
+        node.data = batchInserter.getNodeProperties(id);
+        node.labels = toLabelStrings(id);
+        return node;
+    }
+
+    @Override
+    public RelInfo readRel(long id) {
+        RelInfo rel = new RelInfo(id);
+        rel.data = batchInserter.getRelationshipProperties(id);
+        BatchRelationship batchRelationship = batchInserter.getRelationshipById(id);
+        rel.from = batchRelationship.getStartNode();
+        rel.to = batchRelationship.getEndNode();
+        rel.type = batchRelationship.getType().name();
+        return rel;
+    }
+
+    @Override
+    public boolean nodeExists(long node) {
+        return batchInserter.nodeExists(node);
+    }
+
+    @Override
+    public long highestNodeId() {
+        return new File(dir, "neostore.nodestore.db").length() /  NodeStore.RECORD_SIZE;
+    }
+
+    @Override
+    public long highestRelId() {
+        return new File(dir, "neostore.relationshipstore.db").length() / NodeStore.RECORD_SIZE;
+    }
+}
diff --git a/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
new file mode 100644
index 0000000..c5e3540
--- /dev/null
+++ b/neo4j22/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
@@ -0,0 +1,30 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.DynamicLabel;
+import org.neo4j.graphdb.DynamicRelationshipType;
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreWriter;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchWriterImpl extends StoreBatchHandlerImpl implements StoreWriter {
+
+    @Override
+    public void createNode(NodeInfo node) {
+        if (node.id == -1) {
+            node.id = batchInserter.createNode(node.data, labels(node));
+        } else {
+            batchInserter.createNode(node.id, node.data, labels(node));
+        }
+    }
+
+    @Override
+    public void createRelationship(RelInfo rel) {
+        batchInserter.createRelationship(rel.from, rel.to, type(rel), rel.data);
+    }
+}
diff --git a/neo4j23/pom.xml b/neo4j23/pom.xml
new file mode 100644
index 0000000..c189d65
--- /dev/null
+++ b/neo4j23/pom.xml
@@ -0,0 +1,85 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-impl-2.3</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-impl-2.3</name>
+
+    <properties>
+        <neo4j.version>2.3.11</neo4j.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-lucene-index</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>3.2.0</version>
+        </dependency>
+    </dependencies>
+    <profiles>
+        <profile>
+            <id>enterprise</id>
+            <dependencies>
+                <dependency>
+                    <groupId>org.neo4j</groupId>
+                    <artifactId>neo4j-enterprise-kernel</artifactId>
+                    <version>${neo4j.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+        <profile>
+            <id>community</id>
+        </profile>
+    </profiles>
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <filters>
+                        <filter>
+                            <artifact>*:*</artifact>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
new file mode 100644
index 0000000..ee5f7c4
--- /dev/null
+++ b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
@@ -0,0 +1,97 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.DynamicLabel;
+import org.neo4j.graphdb.DynamicRelationshipType;
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.helpers.collection.MapUtil;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreHandler;
+import org.neo4j.unsafe.batchinsert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchHandlerImpl implements StoreHandler {
+
+    static Label[] NO_LABELS = new Label[0];
+    public static final String[] NO_LABELS_NAMES = new String[0];
+    private Runnable flusher;
+
+    protected String[] toLabelStrings(long id) {
+        Iterator<Label> labels = batchInserter.getNodeLabels(id).iterator();
+        if (labels == null || !labels.hasNext()) return NO_LABELS_NAMES;
+        String[] result = new String[50];
+        int i = 0;
+        while (labels.hasNext()) {
+            Label next = labels.next();
+            result[i++] = next.name();
+        }
+        return Arrays.copyOf(result, i);
+    }
+
+    public Label[] labels(NodeInfo node) {
+        if (node.labels == null || node.labels.length == 0) return NO_LABELS;
+        Label[] result = new Label[node.labels.length];
+        for (int i = 0; i < result.length; i++) { // todo cache
+            result[i] = DynamicLabel.label(node.labels[i]);
+        }
+        return result;
+    }
+
+    public RelationshipType type(RelInfo rel) {
+        return DynamicRelationshipType.withName(rel.type);
+    }
+
+    protected BatchInserter batchInserter;
+    protected String dir;
+
+    @Override
+    public void init(String dir, String pageCache) throws IOException {
+        this.dir = dir;
+        batchInserter = BatchInserters.inserter(new File(dir), MapUtil.stringMap("dbms.pagecache.memory", pageCache));
+        flusher = getFlusher(batchInserter);
+    }
+
+    @Override
+    public void flush() {
+        flusher.run();
+    }
+
+    @Override
+    public void shutdown() {
+        batchInserter.shutdown();
+    }
+
+    private static Runnable getFlusher(final BatchInserter db) {
+        try {
+            Field field = BatchInserterImpl.class.getDeclaredField("recordAccess");
+            field.setAccessible(true);
+            final DirectRecordAccessSet recordAccessSet = (DirectRecordAccessSet) field.get(db);
+            final Field cacheField = DirectRecordAccess.class.getDeclaredField("batch");
+            cacheField.setAccessible(true);
+            return new Runnable() {
+                @Override public void run() {
+                    try {
+                        ((Map) cacheField.get(recordAccessSet.getNodeRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getRelRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getPropertyRecords())).clear();
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException("Error clearing cache "+cacheField,e);
+                    }
+                }
+            };
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            throw new RuntimeException("Error accessing cache field ", e);
+        }
+    }
+}
diff --git a/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
new file mode 100644
index 0000000..0c93cac
--- /dev/null
+++ b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
@@ -0,0 +1,51 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.kernel.impl.store.NodeStore;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreReader;
+import org.neo4j.unsafe.batchinsert.BatchRelationship;
+
+import java.io.File;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchReaderImpl extends StoreBatchHandlerImpl implements StoreReader {
+
+
+    @Override
+    public NodeInfo readNode(long id) {
+        NodeInfo node = new NodeInfo(id);
+        node.data = batchInserter.getNodeProperties(id);
+        node.labels = toLabelStrings(id);
+        return node;
+    }
+
+    @Override
+    public RelInfo readRel(long id) {
+        RelInfo rel = new RelInfo(id);
+        rel.data = batchInserter.getRelationshipProperties(id);
+        BatchRelationship batchRelationship = batchInserter.getRelationshipById(id);
+        rel.from = batchRelationship.getStartNode();
+        rel.to = batchRelationship.getEndNode();
+        rel.type = batchRelationship.getType().name();
+        return rel;
+    }
+
+    @Override
+    public boolean nodeExists(long node) {
+        return batchInserter.nodeExists(node);
+    }
+
+    @Override
+    public long highestNodeId() {
+        return new File(dir, "neostore.nodestore.db").length() /  NodeStore.RECORD_SIZE;
+    }
+
+    @Override
+    public long highestRelId() {
+        return new File(dir, "neostore.relationshipstore.db").length() / NodeStore.RECORD_SIZE;
+    }
+}
diff --git a/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
new file mode 100644
index 0000000..c5e3540
--- /dev/null
+++ b/neo4j23/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
@@ -0,0 +1,30 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.DynamicLabel;
+import org.neo4j.graphdb.DynamicRelationshipType;
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreWriter;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchWriterImpl extends StoreBatchHandlerImpl implements StoreWriter {
+
+    @Override
+    public void createNode(NodeInfo node) {
+        if (node.id == -1) {
+            node.id = batchInserter.createNode(node.data, labels(node));
+        } else {
+            batchInserter.createNode(node.id, node.data, labels(node));
+        }
+    }
+
+    @Override
+    public void createRelationship(RelInfo rel) {
+        batchInserter.createRelationship(rel.from, rel.to, type(rel), rel.data);
+    }
+}
diff --git a/neo4j30/pom.xml b/neo4j30/pom.xml
new file mode 100644
index 0000000..a1a0c38
--- /dev/null
+++ b/neo4j30/pom.xml
@@ -0,0 +1,85 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-impl-3.0</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-impl-3.0</name>
+
+    <properties>
+        <neo4j.version>3.0.11</neo4j.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-lucene-index</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>3.2.0</version>
+        </dependency>
+    </dependencies>
+    <profiles>
+        <profile>
+            <id>enterprise</id>
+            <dependencies>
+                <dependency>
+                    <groupId>org.neo4j</groupId>
+                    <artifactId>neo4j-enterprise-kernel</artifactId>
+                    <version>${neo4j.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+        <profile>
+            <id>community</id>
+        </profile>
+    </profiles>
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <filters>
+                        <filter>
+                            <artifact>*:*</artifact>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
new file mode 100644
index 0000000..e17382f
--- /dev/null
+++ b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
@@ -0,0 +1,100 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.helpers.collection.MapUtil;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreHandler;
+import org.neo4j.unsafe.batchinsert.BatchInserter;
+import org.neo4j.unsafe.batchinsert.BatchInserters;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccess;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccessSet;
+import org.neo4j.unsafe.batchinsert.internal.BatchInserterImpl;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchHandlerImpl implements StoreHandler {
+
+    static Label[] NO_LABELS = new Label[0];
+    public static final String[] NO_LABELS_NAMES = new String[0];
+    private Runnable flusher;
+
+    protected String[] toLabelStrings(long id) {
+        Iterator<Label> labels = batchInserter.getNodeLabels(id).iterator();
+        if (labels == null || !labels.hasNext()) return NO_LABELS_NAMES;
+        String[] result = new String[50];
+        int i = 0;
+        while (labels.hasNext()) {
+            Label next = labels.next();
+            result[i++] = next.name();
+        }
+        return Arrays.copyOf(result, i);
+    }
+
+    public Label[] labels(NodeInfo node) {
+        if (node.labels == null || node.labels.length == 0) return NO_LABELS;
+        Label[] result = new Label[node.labels.length];
+        for (int i = 0; i < result.length; i++) { // todo cache
+            result[i] = Label.label(node.labels[i]);
+        }
+        return result;
+    }
+
+    public RelationshipType type(RelInfo rel) {
+        return RelationshipType.withName(rel.type);
+    }
+
+    protected BatchInserter batchInserter;
+    protected String dir;
+
+    @Override
+    public void init(String dir, String pageCache) throws IOException {
+        this.dir = dir;
+        batchInserter = BatchInserters.inserter(new File(dir), MapUtil.stringMap("dbms.memory.pagecache.size", pageCache));
+        flusher = getFlusher(batchInserter);
+    }
+
+    @Override
+    public void flush() {
+        flusher.run();
+    }
+
+    @Override
+    public void shutdown() {
+        batchInserter.shutdown();
+    }
+
+    private static Runnable getFlusher(BatchInserter db) {
+        try {
+            Field field = BatchInserterImpl.class.getDeclaredField("recordAccess");
+            field.setAccessible(true);
+            final DirectRecordAccessSet recordAccessSet = (DirectRecordAccessSet) field.get(db);
+            final Field cacheField = DirectRecordAccess.class.getDeclaredField("batch");
+            cacheField.setAccessible(true);
+            return new Runnable() {
+                @Override public void run() {
+                    try {
+                        ((Map) cacheField.get(recordAccessSet.getNodeRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getRelRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getPropertyRecords())).clear();
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException("Error clearing cache "+cacheField,e);
+                    }
+                }
+            };
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            throw new RuntimeException("Error accessing cache field ", e);
+        }
+    }
+
+}
diff --git a/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
new file mode 100644
index 0000000..11ae5df
--- /dev/null
+++ b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
@@ -0,0 +1,55 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.kernel.impl.store.format.standard.NodeRecordFormat;
+import org.neo4j.kernel.impl.store.format.standard.RelationshipRecordFormat;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreReader;
+import org.neo4j.unsafe.batchinsert.BatchRelationship;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchReaderImpl extends StoreBatchHandlerImpl implements StoreReader {
+
+
+    @Override
+    public NodeInfo readNode(long id) {
+        NodeInfo node = new NodeInfo(id);
+        node.data = batchInserter.getNodeProperties(id);
+        node.labels = toLabelStrings(id);
+        return node;
+    }
+
+    @Override
+    public RelInfo readRel(long id) {
+        RelInfo rel = new RelInfo(id);
+        rel.data = batchInserter.getRelationshipProperties(id);
+        BatchRelationship batchRelationship = batchInserter.getRelationshipById(id);
+        rel.from = batchRelationship.getStartNode();
+        rel.to = batchRelationship.getEndNode();
+        rel.type = batchRelationship.getType().name();
+        return rel;
+    }
+
+    @Override
+    public boolean nodeExists(long node) {
+        return batchInserter.nodeExists(node);
+    }
+
+    @Override
+    public long highestNodeId() {
+        return new File(dir, "neostore.nodestore.db").length() /  NodeRecordFormat.RECORD_SIZE;
+    }
+
+    @Override
+    public long highestRelId() {
+        return new File(dir, "neostore.relationshipstore.db").length() / RelationshipRecordFormat.RECORD_SIZE;
+    }
+}
diff --git a/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
new file mode 100644
index 0000000..681a47a
--- /dev/null
+++ b/neo4j30/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
@@ -0,0 +1,26 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreWriter;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchWriterImpl extends StoreBatchHandlerImpl implements StoreWriter {
+
+    @Override
+    public void createNode(NodeInfo node) {
+        if (node.id == -1) {
+            node.id = batchInserter.createNode(node.data, labels(node));
+        } else {
+            batchInserter.createNode(node.id, node.data, labels(node));
+        }
+    }
+
+    @Override
+    public void createRelationship(RelInfo rel) {
+        batchInserter.createRelationship(rel.from, rel.to, type(rel), rel.data);
+    }
+}
diff --git a/neo4j31/pom.xml b/neo4j31/pom.xml
new file mode 100644
index 0000000..ed5f803
--- /dev/null
+++ b/neo4j31/pom.xml
@@ -0,0 +1,85 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-impl-3.1</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-impl-3.1</name>
+
+    <properties>
+        <neo4j.version>3.1.5</neo4j.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-lucene-index</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>3.2.0</version>
+        </dependency>
+    </dependencies>
+    <profiles>
+        <profile>
+            <id>enterprise</id>
+            <dependencies>
+                <dependency>
+                    <groupId>org.neo4j</groupId>
+                    <artifactId>neo4j-enterprise-kernel</artifactId>
+                    <version>${neo4j.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+        <profile>
+            <id>community</id>
+        </profile>
+    </profiles>
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <filters>
+                        <filter>
+                            <artifact>*:*</artifact>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
new file mode 100644
index 0000000..d27f358
--- /dev/null
+++ b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
@@ -0,0 +1,100 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.helpers.collection.MapUtil;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreHandler;
+import org.neo4j.unsafe.batchinsert.BatchInserter;
+import org.neo4j.unsafe.batchinsert.BatchInserters;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccess;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccessSet;
+import org.neo4j.unsafe.batchinsert.internal.BatchInserterImpl;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchHandlerImpl implements StoreHandler {
+
+    static Label[] NO_LABELS = new Label[0];
+    public static final String[] NO_LABELS_NAMES = new String[0];
+    private Runnable flusher;
+
+    protected String[] toLabelStrings(long id) {
+        Iterator<Label> labels = batchInserter.getNodeLabels(id).iterator();
+        if (labels == null || !labels.hasNext()) return NO_LABELS_NAMES;
+        String[] result = new String[50];
+        int i = 0;
+        while (labels.hasNext()) {
+            Label next = labels.next();
+            result[i++] = next.name();
+        }
+        return Arrays.copyOf(result, i);
+    }
+
+    public Label[] labels(NodeInfo node) {
+        if (node.labels == null || node.labels.length == 0) return NO_LABELS;
+        Label[] result = new Label[node.labels.length];
+        for (int i = 0; i < result.length; i++) { // todo cache
+            result[i] = Label.label(node.labels[i]);
+        }
+        return result;
+    }
+
+    public RelationshipType type(RelInfo rel) {
+        return RelationshipType.withName(rel.type);
+    }
+
+    protected BatchInserter batchInserter;
+    protected String dir;
+
+    @Override
+    public void init(String dir, String pageCache) throws IOException {
+        this.dir = dir;
+        batchInserter = BatchInserters.inserter(new File(dir), MapUtil.stringMap("dbms.memory.pagecache.size", pageCache));
+    }
+
+    @Override
+    public void shutdown() {
+        batchInserter.shutdown();
+        flusher = getFlusher(batchInserter);
+    }
+
+    @Override
+    public void flush() {
+        flusher.run();
+    }
+
+    private static Runnable getFlusher(BatchInserter db) {
+        try {
+            Field field = BatchInserterImpl.class.getDeclaredField("recordAccess");
+            field.setAccessible(true);
+            final DirectRecordAccessSet recordAccessSet = (DirectRecordAccessSet) field.get(db);
+            final Field cacheField = DirectRecordAccess.class.getDeclaredField("batch");
+            cacheField.setAccessible(true);
+            return new Runnable() {
+                @Override public void run() {
+                    try {
+                        ((Map) cacheField.get(recordAccessSet.getNodeRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getRelRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getPropertyRecords())).clear();
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException("Error clearing cache "+cacheField,e);
+                    }
+                }
+            };
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            throw new RuntimeException("Error accessing cache field ", e);
+        }
+    }
+
+}
diff --git a/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
new file mode 100644
index 0000000..11ae5df
--- /dev/null
+++ b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
@@ -0,0 +1,55 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.kernel.impl.store.format.standard.NodeRecordFormat;
+import org.neo4j.kernel.impl.store.format.standard.RelationshipRecordFormat;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreReader;
+import org.neo4j.unsafe.batchinsert.BatchRelationship;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchReaderImpl extends StoreBatchHandlerImpl implements StoreReader {
+
+
+    @Override
+    public NodeInfo readNode(long id) {
+        NodeInfo node = new NodeInfo(id);
+        node.data = batchInserter.getNodeProperties(id);
+        node.labels = toLabelStrings(id);
+        return node;
+    }
+
+    @Override
+    public RelInfo readRel(long id) {
+        RelInfo rel = new RelInfo(id);
+        rel.data = batchInserter.getRelationshipProperties(id);
+        BatchRelationship batchRelationship = batchInserter.getRelationshipById(id);
+        rel.from = batchRelationship.getStartNode();
+        rel.to = batchRelationship.getEndNode();
+        rel.type = batchRelationship.getType().name();
+        return rel;
+    }
+
+    @Override
+    public boolean nodeExists(long node) {
+        return batchInserter.nodeExists(node);
+    }
+
+    @Override
+    public long highestNodeId() {
+        return new File(dir, "neostore.nodestore.db").length() /  NodeRecordFormat.RECORD_SIZE;
+    }
+
+    @Override
+    public long highestRelId() {
+        return new File(dir, "neostore.relationshipstore.db").length() / RelationshipRecordFormat.RECORD_SIZE;
+    }
+}
diff --git a/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
new file mode 100644
index 0000000..681a47a
--- /dev/null
+++ b/neo4j31/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
@@ -0,0 +1,26 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreWriter;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchWriterImpl extends StoreBatchHandlerImpl implements StoreWriter {
+
+    @Override
+    public void createNode(NodeInfo node) {
+        if (node.id == -1) {
+            node.id = batchInserter.createNode(node.data, labels(node));
+        } else {
+            batchInserter.createNode(node.id, node.data, labels(node));
+        }
+    }
+
+    @Override
+    public void createRelationship(RelInfo rel) {
+        batchInserter.createRelationship(rel.from, rel.to, type(rel), rel.data);
+    }
+}
diff --git a/neo4j32/pom.xml b/neo4j32/pom.xml
new file mode 100644
index 0000000..c6ead1a
--- /dev/null
+++ b/neo4j32/pom.xml
@@ -0,0 +1,85 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-impl-3.2</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-impl-3.2</name>
+
+    <properties>
+        <neo4j.version>3.2.3</neo4j.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-kernel</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j</groupId>
+            <artifactId>neo4j-lucene-index</artifactId>
+            <version>${neo4j.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>3.2.0</version>
+        </dependency>
+    </dependencies>
+    <profiles>
+        <profile>
+            <id>enterprise</id>
+            <dependencies>
+                <dependency>
+                    <groupId>org.neo4j</groupId>
+                    <artifactId>neo4j-enterprise-kernel</artifactId>
+                    <version>${neo4j.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+        <profile>
+            <id>community</id>
+        </profile>
+    </profiles>
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.0.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <filters>
+                        <filter>
+                            <artifact>*:*</artifact>
+                            <excludes>
+                                <exclude>META-INF/*.SF</exclude>
+                                <exclude>META-INF/*.DSA</exclude>
+                                <exclude>META-INF/*.RSA</exclude>
+                            </excludes>
+                        </filter>
+                    </filters>
+                    <transformers>
+                        <transformer
+                                implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
+                    </transformers>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
new file mode 100644
index 0000000..9293bb3
--- /dev/null
+++ b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchHandlerImpl.java
@@ -0,0 +1,103 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.graphdb.RelationshipType;
+import org.neo4j.helpers.collection.MapUtil;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreHandler;
+import org.neo4j.unsafe.batchinsert.BatchInserter;
+import org.neo4j.unsafe.batchinsert.BatchInserters;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccess;
+import org.neo4j.unsafe.batchinsert.DirectRecordAccessSet;
+import org.neo4j.unsafe.batchinsert.internal.BatchInserterImpl;
+import org.neo4j.unsafe.batchinsert.internal.FileSystemClosingBatchInserter;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchHandlerImpl implements StoreHandler {
+
+    static Label[] NO_LABELS = new Label[0];
+    public static final String[] NO_LABELS_NAMES = new String[0];
+    private Runnable flusher;
+
+    protected String[] toLabelStrings(long id) {
+        Iterator<Label> labels = batchInserter.getNodeLabels(id).iterator();
+        if (labels == null || !labels.hasNext()) return NO_LABELS_NAMES;
+        String[] result = new String[50];
+        int i = 0;
+        while (labels.hasNext()) {
+            Label next = labels.next();
+            result[i++] = next.name();
+        }
+        return Arrays.copyOf(result, i);
+    }
+
+    public Label[] labels(NodeInfo node) {
+        if (node.labels == null || node.labels.length == 0) return NO_LABELS;
+        Label[] result = new Label[node.labels.length];
+        for (int i = 0; i < result.length; i++) { // todo cache
+            result[i] = Label.label(node.labels[i]);
+        }
+        return result;
+    }
+
+    public RelationshipType type(RelInfo rel) {
+        return RelationshipType.withName(rel.type);
+    }
+
+    protected BatchInserter batchInserter;
+    protected String dir;
+
+    @Override
+    public void init(String dir, String pageCache) throws IOException {
+        this.dir = dir;
+        batchInserter = BatchInserters.inserter(new File(dir), MapUtil.stringMap("dbms.memory.pagecache.size", pageCache));
+        flusher = getFlusher(batchInserter);
+    }
+
+    @Override
+    public void flush() {
+        flusher.run();
+    }
+
+    @Override
+    public void shutdown() {
+        batchInserter.shutdown();
+    }
+
+    private static Runnable getFlusher(BatchInserter db) {
+        try {
+            Field delegate = FileSystemClosingBatchInserter.class.getDeclaredField("delegate");
+            delegate.setAccessible(true);
+            db = (BatchInserter)delegate.get(db);
+            Field field = BatchInserterImpl.class.getDeclaredField("recordAccess");
+            field.setAccessible(true);
+            final DirectRecordAccessSet recordAccessSet = (DirectRecordAccessSet) field.get(db);
+            final Field cacheField = DirectRecordAccess.class.getDeclaredField("batch");
+            cacheField.setAccessible(true);
+            return new Runnable() {
+                @Override public void run() {
+                    try {
+                        ((Map) cacheField.get(recordAccessSet.getNodeRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getRelRecords())).clear();
+                        ((Map) cacheField.get(recordAccessSet.getPropertyRecords())).clear();
+                    } catch (IllegalAccessException e) {
+                        throw new RuntimeException("Error clearing cache "+cacheField,e);
+                    }
+                }
+            };
+        } catch (IllegalAccessException | NoSuchFieldException e) {
+            throw new RuntimeException("Error accessing cache field ", e);
+        }
+    }
+}
diff --git a/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
new file mode 100644
index 0000000..11ae5df
--- /dev/null
+++ b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchReaderImpl.java
@@ -0,0 +1,55 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.graphdb.Label;
+import org.neo4j.kernel.impl.store.format.standard.NodeRecordFormat;
+import org.neo4j.kernel.impl.store.format.standard.RelationshipRecordFormat;
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreReader;
+import org.neo4j.unsafe.batchinsert.BatchRelationship;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Iterator;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchReaderImpl extends StoreBatchHandlerImpl implements StoreReader {
+
+
+    @Override
+    public NodeInfo readNode(long id) {
+        NodeInfo node = new NodeInfo(id);
+        node.data = batchInserter.getNodeProperties(id);
+        node.labels = toLabelStrings(id);
+        return node;
+    }
+
+    @Override
+    public RelInfo readRel(long id) {
+        RelInfo rel = new RelInfo(id);
+        rel.data = batchInserter.getRelationshipProperties(id);
+        BatchRelationship batchRelationship = batchInserter.getRelationshipById(id);
+        rel.from = batchRelationship.getStartNode();
+        rel.to = batchRelationship.getEndNode();
+        rel.type = batchRelationship.getType().name();
+        return rel;
+    }
+
+    @Override
+    public boolean nodeExists(long node) {
+        return batchInserter.nodeExists(node);
+    }
+
+    @Override
+    public long highestNodeId() {
+        return new File(dir, "neostore.nodestore.db").length() /  NodeRecordFormat.RECORD_SIZE;
+    }
+
+    @Override
+    public long highestRelId() {
+        return new File(dir, "neostore.relationshipstore.db").length() / RelationshipRecordFormat.RECORD_SIZE;
+    }
+}
diff --git a/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
new file mode 100644
index 0000000..681a47a
--- /dev/null
+++ b/neo4j32/src/main/java/org/neo4j/tool/impl/StoreBatchWriterImpl.java
@@ -0,0 +1,26 @@
+package org.neo4j.tool.impl;
+
+import org.neo4j.tool.api.NodeInfo;
+import org.neo4j.tool.api.RelInfo;
+import org.neo4j.tool.api.StoreWriter;
+
+/**
+ * @author mh
+ * @since 09.06.14
+ */
+public class StoreBatchWriterImpl extends StoreBatchHandlerImpl implements StoreWriter {
+
+    @Override
+    public void createNode(NodeInfo node) {
+        if (node.id == -1) {
+            node.id = batchInserter.createNode(node.data, labels(node));
+        } else {
+            batchInserter.createNode(node.id, node.data, labels(node));
+        }
+    }
+
+    @Override
+    public void createRelationship(RelInfo rel) {
+        batchInserter.createRelationship(rel.from, rel.to, type(rel), rel.data);
+    }
+}
diff --git a/pom.xml b/pom.xml
index 112b95a..1eed6c6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -2,17 +2,27 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>org.neo4j</groupId>
-    <artifactId>store-util</artifactId>
-    <version>2.0.1</version>
-    <packaging>jar</packaging>
+    <groupId>org.neo4j.util</groupId>
+    <artifactId>store-util-parent</artifactId>
+    <version>3.2.0</version>
+    <packaging>pom</packaging>
 
-    <name>store-util</name>
+    <name>store-util-parent</name>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
+    <modules>
+        <module>api</module>
+        <module>neo4j22</module>
+        <module>neo4j23</module>
+        <module>neo4j30</module>
+        <module>neo4j31</module>
+        <module>neo4j32</module>
+        <module>runner</module>
+    </modules>
+
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
@@ -21,17 +31,25 @@
             <scope>test</scope>
         </dependency>
         <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-kernel</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.neo4j</groupId>
-            <artifactId>neo4j-lucene-index</artifactId>
-            <version>${project.version}</version>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>1.3.2</version>
         </dependency>
     </dependencies>
 
+    <profiles>
+        <profile>
+            <id>enterprise</id>
+        </profile>
+        <profile>
+            <id>community</id>
+            <activation>
+                <activeByDefault>true</activeByDefault>
+            </activation>
+        </profile>
+    </profiles>
+
+
     <build>
         <plugins>
             <plugin>
@@ -39,25 +57,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>2.3.2</version>
                 <configuration>
-                    <source>1.7</source>
-                    <target>1.7</target>
-                    <compilerArgument>-Xlint:all</compilerArgument>
-                    <showWarnings>true</showWarnings>
-                    <showDeprecation>false</showDeprecation>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <artifactId>maven-assembly-plugin</artifactId>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <mainClass>org.neo4j.tool.StoreCopy</mainClass>
-                        </manifest>
-                    </archive>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
+                    <source>1.8</source>
+                    <target>1.8</target>
                 </configuration>
             </plugin>
 
@@ -73,7 +74,7 @@
                     </execution>
                 </executions>
                 <configuration>
-                    <!--<mainClass>org.neo4j.tool.StoreCopy</mainClass>-->
+                    <mainClass>org.neo4j.tool.StoreCopy</mainClass>
                 </configuration>
             </plugin>
         </plugins>
diff --git a/readme.md b/readme.md
index d28ab0b..0c24799 100644
--- a/readme.md
+++ b/readme.md
@@ -1,22 +1,83 @@
-## Tools to copy and compare Neo4j Stores
+## Tool to copy Neo4j Stores
 
-Uses the GraphDatabaseService to read a store and the batch-inserter API to write the target store keeping the node-ids.
-Copies the index-files as is.
-Ignores broken nodes and relationships.
+Uses the BatchInserterImpl to read a store and write the target store keeping the node-ids.
+Copies the manual (legacy) index-files as is, please note it performs no index upgrade!
 
-Also useful to skip no longer wanted properties or relationships with a certain type. Good for store compaction as it
-rewrites the store file reclaiming space that is sitting empty.
+**You will have to recreate any schema indexes too.**
 
-Change the Neo4j version in pom.xml before running. (Currently 1.9.5)
+Ignores broken nodes and relationships and records them in `$targetdb/store-copy.log`
+
+Also useful to skip no longer wanted properties, relationships with a certain type.
+Or of certain labels and even nodes with certain labels.
+
+Good for store compaction and reorganization of relationships and properties as
+it rewrites the store file reclaiming space that is sitting empty.
+
+NOTE: 
+*With Neo4j 3.x there are two different store formats, so you have to provide "enterprise" or "community" as first argument of the call!*
+
+You can now also decide if you want to compact the node-store, then you have to pass "false" as the parameter for keep-node-ids.
+
+Config is read from `neo4j.properties` file in current directory if it exists, but command line options override.
+
+neo4j.properties
+
+```
+source_db_dir=
+target_db_dir=
+
+keep_node_ids=true
+
+properties_to_ignore=
+labels_to_ignore=
+labels_to_delete=
+rel_types_to_ignore=
+
+store_copy_log_dir=
+bad_entries_log_dir=
+```
 
 ### Store Copy
 
-Usage:
+    copy-store.sh [enterprise|community] source.db:version-from target.db:version-to [RELS,TO,SKIP] [props,to,skip] [Labels,To,Skip] [Labels,To,Delete,Nodes] [keep-node-ids:true/false]
+
+The provided script contains these settings for page-cache (note you can configure a different, smaller setting for the source store than the target store).
+
+    dbms.pagecache.memory.source=2G
+    dbms.pagecache.memory=2G
+
+Heap config is in the shell-script, default is:
+
+    export MAVEN_OPTS="-Xmx4G -Xms4G -Xmn1G -XX:+UseG1GC"
+
+**Please adapt the settings as needed for your store.**
+
+**Please note that you will need the memory for (source-page-cache + target-page-cache + 1x heap) as it opens 2 databases one for reading and one for writing.**
+
+### Internally
+
+Note: It calls under the hood:
+
+    # build all the shadow-jars
+    mvn clean install
+
+    cd runner
+
+    mvn compile exec:java -Dexec.mainClass="org.neo4j.tool.StoreCopy" -Penterprise \
+      -Dexec.args="source-dir:version target-dir:version [REL,TYPES,TO,IGNORE] [properties,to,ignore] [Labels,To,Ignore] [Labels,To,Delete,Nodes] [keep-node-ids:true/false]"
+    
+    mvn compile exec:java -Dexec.mainClass="org.neo4j.tool.StoreCopy" \
+      -Dexec.args="/path/to/source:version /path/to/target:version [rel,types,to,ignore] [properties,to,ignore]"
+
+e.g. 
 
     mvn compile exec:java -Dexec.mainClass="org.neo4j.tool.StoreCopy" \
-      -Dexec.args="source-dir target-dir [rel,types,to,ignore] [properties,to,ignore] [labels,to,ignore]"
+      -Dexec.args="/backup/test.db:3.2 /tmp/fixed.db:3.1 :FOO bar"
 
-# Store Compare
+### Currently Supported versions
 
-    mvn compile exec:java -Dexec.mainClass="org.neo4j.tool.StoreComparer" \
-      -Dexec.args="source-dir target-dir [rel,types,to,ignore] [properties,to,ignore]"
+* 3.1.5
+* 3.2.3
+* 3.0.11
+* 2.3.11
+* 2.2.10
diff --git a/runner/pom.xml b/runner/pom.xml
new file mode 100644
index 0000000..00d4b3c
--- /dev/null
+++ b/runner/pom.xml
@@ -0,0 +1,29 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.neo4j.util</groupId>
+        <artifactId>store-util-parent</artifactId>
+        <version>3.2.0</version>
+    </parent>
+
+    <artifactId>store-util-runner</artifactId>
+    <version>3.2.0</version>
+    <packaging>jar</packaging>
+
+    <name>store-util-runner</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.neo4j.util</groupId>
+            <artifactId>store-util-api</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.carrotsearch</groupId>
+            <artifactId>hppc</artifactId>
+            <version>0.7.2</version>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/runner/src/main/java/org/neo4j/tool/StoreCopy.java b/runner/src/main/java/org/neo4j/tool/StoreCopy.java
new file mode 100644
index 0000000..9f512e6
--- /dev/null
+++ b/runner/src/main/java/org/neo4j/tool/StoreCopy.java
@@ -0,0 +1,294 @@
+package org.neo4j.tool;
+
+import com.carrotsearch.hppc.LongLongHashMap;
+import com.carrotsearch.hppc.LongLongMap;
+import com.carrotsearch.hppc.LongLongScatterMap;
+import org.apache.commons.io.FileUtils;
+import org.neo4j.tool.api.*;
+
+import java.io.*;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptySet;
+
+public class StoreCopy {
+
+    private static final File PROP_FILE = new File("neo4j.properties");
+    private static PrintWriter logs;
+
+    public static void main(String[] args) throws Exception {
+        if (args.length < 2) {
+            System.err.println("Usage: StoryCopy source target [rel,types,to,ignore] [properties,to,ignore] [labels,to,ignore] [labels,to,delete]");
+            return;
+        }
+        Properties properties = new Properties();
+        if (PROP_FILE.exists()) properties.load(new FileReader(PROP_FILE));
+        String[] sourceDir = getArgument(args,0,properties,"source_db_dir").split(":");
+        String[] targetDir = getArgument(args,1,properties,"target_db_dir").split(":");
+
+        Set<String> ignoreRelTypes = splitToSet(getArgument(args,2,properties,"rel_types_to_ignore"));
+        Set<String> ignoreProperties = splitToSet(getArgument(args,3,properties,"properties_to_ignore"));
+        Set<String> ignoreLabels = splitToSet(getArgument(args,4,properties,"labels_to_ignore"));
+        Set<String> deleteNodesWithLabels = splitToSet(getArgument(args,5,properties,"labels_to_delete"));
+        String keepNodeIdsParam = getArgument(args, 6, properties, "keep_node_ids");
+        boolean keepNodeIds = !("false".equalsIgnoreCase(keepNodeIdsParam));
+        System.out.printf("Copying from %s version %s to %s version %s ingoring rel-types %s ignoring properties %s ignoring labels %s removing nodes with labels %s keep node ids %s %n", sourceDir[0], sourceDir[1], targetDir[0], targetDir[1], ignoreRelTypes, ignoreProperties,ignoreLabels, deleteNodesWithLabels,keepNodeIds);
+        copyStore(sourceDir[0],sourceDir[1], targetDir[0],targetDir[1], ignoreRelTypes, ignoreProperties,ignoreLabels,deleteNodesWithLabels, keepNodeIds);
+    }
+
+    private static String getArgument(String[] args, int index, Properties properties, String key) {
+        if (args.length > index) return args[index];
+        return properties.getProperty(key);
+    }
+
+    private static Set<String> splitToSet(String value) {
+        if (value == null || value.trim().isEmpty()) return emptySet();
+        return new HashSet<>(asList(value.trim().split(", *")));
+    }
+
+    interface Flusher {
+        void flush();
+    }
+    private static void copyStore(String sourceDir, String fromVersion, String targetDir, String toVersion, Set<String> ignoreRelTypes, Set<String> ignoreProperties, Set<String> ignoreLabels, Set<String> deleteNodesWithLabels, boolean stableNodeIds) throws Exception {
+        final File source = new File(sourceDir);
+        if (!source.exists()) throw new IllegalArgumentException("Source Database does not exist " + source);
+
+        final File target = new File(targetDir);
+        if (target.exists()) {
+            throw new IllegalArgumentException("Target Directory already exists "+target);
+        } else {
+            if (!target.mkdirs()) throw new IOException("Could not create "+targetDir);
+        }
+
+        logs = new PrintWriter(new FileWriter(new File(target, "store-copy.log")));
+
+        String targetPageCache = System.getProperty("dbms.pagecache.memory","1g");
+        String sourcePageCache = System.getProperty("dbms.pagecache.memory.source",targetPageCache);;
+
+        StoreReader sourceDb = null;
+        StoreWriter targetDb = null;
+        try {
+            sourceDb = createInstance("org.neo4j.tool.impl.StoreBatchReaderImpl", fromVersion);
+            sourceDb.init(source.getAbsolutePath(), sourcePageCache);
+            targetDb = createInstance("org.neo4j.tool.impl.StoreBatchWriterImpl", toVersion);
+            targetDb.init(target.getAbsolutePath(), targetPageCache);
+
+            LongLongMap copiedNodeIds = copyNodes(sourceDb, targetDb, ignoreProperties, ignoreLabels, deleteNodesWithLabels, stableNodeIds);
+            copyRelationships(sourceDb, targetDb, ignoreRelTypes, ignoreProperties, copiedNodeIds);
+        } finally {
+            if (targetDb != null) {
+                try {
+                    targetDb.shutdown();
+                } catch (Exception e) {
+                    System.err.println("Error shutting down target database");
+                    e.printStackTrace();
+                }
+            }
+            if (sourceDb != null) {
+                try {
+                    sourceDb.shutdown();
+                } catch (Exception e) {
+                    logs.append(String.format("Noncritical error closing the source database:%n%s", stringify(e)));
+                }
+            }
+        }
+        logs.close();
+        copyIndex(source, target);
+    }
+
+    private static String stringify(Throwable e) {
+        StringBuilder sb = new StringBuilder();
+        do {
+            sb.append(e.getMessage());
+            e = e.getCause();
+        } while (e != null && e != e.getCause());
+        return sb.toString();
+    }
+
+
+    public static <T extends StoreHandler> T createInstance(String name, String version) {
+        try {
+            URLClassLoader classLoader = new URLClassLoader(new URL[] {jar(version).toURL()},StoreCopy.class.getClassLoader());
+            Class<?> targetClass = classLoader.loadClass(name);
+            return (T)targetClass.newInstance();
+        } catch(Exception e) {
+            throw new RuntimeException("Error loading class "+name,e);
+        }
+    }
+
+    private static File jar(String version) {
+        return new File(System.getProperty("user.home"), ".m2/repository/org/neo4j/util/store-util-impl-"+version+"/3.2.0/store-util-impl-"+version+"-3.2.0.jar");
+    }
+
+    private static void copyIndex(File source, File target) throws IOException {
+        final File indexFile = new File(source, "index.db");
+        if (indexFile.exists()) {
+            FileUtils.copyFile(indexFile, new File(target, "index.db"));
+        }
+        final File indexDir = new File(source, "index");
+        if (indexDir.exists()) {
+            FileUtils.copyDirectory(indexDir, new File(target, "index"));
+        }
+    }
+
+    private static void copyRelationships(StoreReader sourceDb, StoreWriter targetDb, Set<String> ignoreRelTypes, Set<String> ignoreProperties, LongLongMap copiedNodeIds) {
+        long time = System.currentTimeMillis();
+        long relId = 0;
+        long notFound = 0;
+        long removed = 0;
+        long highestRelId = sourceDb.highestRelId();
+        while (relId <= highestRelId) {
+            RelInfo rel = null;
+            String type = null;
+            try {
+                rel = sourceDb.readRel(relId);
+                type = rel.type;
+                if (!ignoreRelTypes.contains(type)) {
+                    if (!createRelationship(targetDb, sourceDb, rel, ignoreProperties, copiedNodeIds)) {
+                        removed++;
+                    }
+                } else {
+                    removed++;
+                }
+            } catch (Exception e) {
+                if (notInUse(e)) {
+                    notFound++;
+                } else {
+                    addLog(rel, "copy Relationship: " + relId + "-[:" + type + "]" + "->?", e.getMessage());
+                }
+            }
+            relId++;
+            if (relId % 10_000 == 0) {
+                System.out.print(".");
+            }
+            if (relId % 500_000 == 0) {
+                sourceDb.flush();
+            }
+            if (relId % 1_000_000 == 0) {
+                logs.flush();
+                System.out.printf(" %d / %d (%d%%) unused %d removed %d %d seconds%n", relId, highestRelId, percent(relId,highestRelId), notFound,removed, secondsSince(time));
+            }
+        }
+        time = Math.max(1,(System.currentTimeMillis() - time)/1000);
+        System.out.printf("%n copying of %d relationship records took %d seconds (%d rec/s). Unused Records %d (%d%%) Removed Records %d (%d%%)%n",
+                relId, time, relId/time, notFound, percent(notFound,relId),removed, percent(removed,relId));
+    }
+
+    private static long secondsSince(long time) {
+        return TimeUnit.MILLISECONDS.toSeconds(System.currentTimeMillis()-time);
+    }
+
+    private static boolean notInUse(Exception e) {
+        return e.getClass().getName().endsWith("InvalidRecordException") && e.getMessage().endsWith("not in use");
+    }
+
+    private static int percent(Number part, Number total) {
+        return (int) (100 * part.floatValue() / total.floatValue());
+    }
+
+    private static boolean createRelationship(StoreWriter targetDb, StoreReader sourceDb, RelInfo rel, Set<String> ignoreProperties, LongLongMap copiedNodeIds) {
+        rel.from = copiedNodeIds.get(rel.from);
+        rel.to = copiedNodeIds.get(rel.to);
+        if (rel.from == -1L || rel.to == -1L) return false;
+        try {
+            rel.data = getProperties(rel.data, ignoreProperties);
+            targetDb.createRelationship(rel);
+            return true;
+        } catch (Exception e) {
+            addLog(rel, "create Relationship: " + rel.toString(), e.getMessage());
+            return false;
+        }
+    }
+
+    private static LongLongMap copyNodes(StoreReader sourceDb, StoreWriter targetDb, Set<String> ignoreProperties, Set<String> ignoreLabels, Set<String> deleteNodesWithLabels, boolean stableNodeIds) {
+        LongLongMap copiedNodes = new LongLongHashMap((int)sourceDb.highestNodeId());
+        long time = System.currentTimeMillis();
+        long nodeId = 0;
+        long notFound = 0;
+        long removed = 0;
+        long highestNodeId = sourceDb.highestNodeId();
+        while (nodeId <= highestNodeId) {
+            try {
+                if (sourceDb.nodeExists(nodeId)) {
+                    NodeInfo node = sourceDb.readNode(nodeId);
+                    if (labelInSet(node.labels,deleteNodesWithLabels)) {
+                        removed ++;
+                    } else {
+                        node.data = getProperties(node.data, ignoreProperties);
+                        node.labels = labelsArray(node, ignoreLabels);
+                        if (!stableNodeIds) {
+                            node.id = -1;
+                        }
+                        targetDb.createNode(node);
+                        copiedNodes.put(nodeId,node.id);
+                    }
+                } else {
+                    notFound++;
+                }
+            } catch (Exception e) {
+                if (notInUse(e)) {
+                    notFound++;
+                } else addLog(nodeId, e.getMessage());
+            }
+            nodeId++;
+            if (nodeId % 10_000 == 0) {
+                System.out.print(".");
+            }
+            if (nodeId % 500_000 == 0) {
+                sourceDb.flush();
+            }
+            if (nodeId % 1_000_000 == 0) {
+                logs.flush();
+                System.out.printf(" %d / %d (%d%%) unused %d removed %d seconds %d%n", nodeId, highestNodeId, percent(nodeId,highestNodeId), notFound, removed, secondsSince(time));
+            }
+        }
+        time = Math.max(1,(System.currentTimeMillis() - time)/1000);
+        System.out.printf("%n copying of %d node records took %d seconds (%d rec/s). Unused Records %d (%d%%). Removed Records %d (%d%%).%n",
+                nodeId, time, nodeId/time, notFound, percent(notFound,nodeId),removed, percent(removed,nodeId));
+        return copiedNodes;
+    }
+
+    private static boolean labelInSet(String[] nodeLabels, Set<String> labelSet) {
+        if (labelSet == null || labelSet.isEmpty()) return false;
+        for (String nodeLabel : nodeLabels) {
+            if (labelSet.contains(nodeLabel)) return true;
+        }
+        return false;
+    }
+
+    private static String[] labelsArray(NodeInfo node, Set<String> ignoreLabels) {
+        String[] labels = node.labels;
+        if (labels == null || labels.length == 0 || ignoreLabels.isEmpty()) return node.labels;
+        int idx = 0;
+        for (int i = 0; i < labels.length; i++) {
+            String label = labels[i];
+            if (ignoreLabels.contains(label)) {
+                labels[idx++] = label;
+            }
+        }
+        return idx < labels.length ? Arrays.copyOf(labels, idx) : labels;
+    }
+
+    private static Map<String, Object> getProperties(Map<String, Object> pc, Set<String> ignoreProperties) {
+        if (pc.isEmpty()) return Collections.emptyMap();
+        if (ignoreProperties.isEmpty()) return pc;
+        pc.keySet().removeAll(ignoreProperties);
+        return pc;
+    }
+
+    private static void addLog(RelInfo rel, String property, String message) {
+        logs.append(String.format("%s.%s %s%n", rel, property, message));
+    }
+
+    private static void addLog(long node, String message) {
+        logs.append(String.format("Node: %s %s%n", node, message));
+    }
+
+    private static void addLog(NodeInfo pc, String property, String message) {
+        logs.append(String.format("%s.%s %s%n", pc, property, message));
+    }
+}
diff --git a/src/main/java/org/neo4j/tool/DomainAnalyzer.java b/src/main/java/org/neo4j/tool/DomainAnalyzer.java
deleted file mode 100644
index 1ce7f26..0000000
--- a/src/main/java/org/neo4j/tool/DomainAnalyzer.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.GraphDatabaseService;
-import org.neo4j.graphdb.Node;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.helpers.collection.IteratorUtil;
-import org.neo4j.kernel.EmbeddedGraphDatabase;
-
-import java.util.*;
-
-/**
- * This sample app demonstrates performance issues on Linux with small
- * transactions. The app traverses through a very simple graph with 7 nodes and
- * sets the property v of every traversed node to a random value [0, 100).
- * 
- * On Windows 7 x64 on commodity HW, we get ~1000 traversals per second (= 7000
- * setProperty calls per second). This is ok and is expected.
- * On an Arch-Linux x64 we get up to 2500 traversals/s, which is great.
- * 
- * BUT!
- * On Ubuntu 10.04 Server x64 we get around 30 traversals/s. :-(
- * On Ubuntu 10.10 we get around 50 traversals/s. :-(
- * On CentOS 5.6 we get around 25 traversals/s. :-(
- * 
- * This app can be built and run with maven: mvn compile exec:java
- * 
- * This issue has also been discussed here:
- * http://lists.neo4j.org/pipermail/user/2011-May/008822.html
- */
-public class DomainAnalyzer {
-	private static GraphDatabaseService graphDb;
-
-
-    static class Sample {
-        public final Node node;
-        private int count;
-        private int emptyCount;
-
-        Sample(Node node) {
-            this.node = node;
-            this.count = 1;
-        }
-
-        public void inc() {
-            count++;
-        }
-        public void incEmpty() {
-            emptyCount++;
-        }
-        public String toString() {
-            StringBuilder sb = new StringBuilder("count: ").append(count).append(" empty: ").append(emptyCount).append(" node: ").append(node.getId()).append("\n");
-            for (String property : node.getPropertyKeys()) {
-                final Object value = node.getProperty(property);
-
-                sb.append("\t").append(property).append("\t").append(toString(value)).append("\n");
-            }
-            return sb.toString();
-        }
-
-        private String toString(Object value) {
-            final Class<? extends Object> type = value.getClass();
-            if (type.isArray()) {
-                final Class<?> componentType = type.getComponentType();
-                if (Object.class.isAssignableFrom(componentType)) return Arrays.toString((Object[]) value);
-                if (int.class == componentType) return Arrays.toString((int[])value);
-                if (byte.class == componentType) return Arrays.toString((byte[])value);
-                if (float.class == componentType) return Arrays.toString((float[])value);
-                if (double.class == componentType) return Arrays.toString((double[])value);
-                if (long.class == componentType) return Arrays.toString((long[])value);
-                if (char.class == componentType) return Arrays.toString((char[])value);
-                if (boolean.class == componentType) return Arrays.toString((boolean[])value);
-            }
-            return value.toString();
-        }
-    }
-	public static void main(String[] args) {
-        graphDb = new GraphDatabaseFactory().newEmbeddedDatabase(args[0]);
-
-        long time = System.currentTimeMillis();
-        Map<Set<String>,Sample> statistics = new HashMap<Set<String>, Sample>();
-        int count = 0;
-        for (Node node : graphDb.getAllNodes()) {
-            final HashSet<String> keys = IteratorUtil.addToCollection(node.getPropertyKeys(), new HashSet<String>());
-            Sample sample = statistics.get(keys);
-            if (sample==null) {
-                sample = new Sample(node);
-                statistics.put(keys,sample);
-            } else {
-                sample.inc();
-            }
-            count++;
-            if (count % 100000 == 0) System.out.println("count = " + count + " sample "+sample);
-        }
-        time = System.currentTimeMillis() - time;
-        System.out.println(" count " + count + " took " + time + " types " + statistics.size() + "\n" + statistics);
-		graphDb.shutdown();
-	}
-}
diff --git a/src/main/java/org/neo4j/tool/GraphGenerator.java b/src/main/java/org/neo4j/tool/GraphGenerator.java
deleted file mode 100644
index e54fe11..0000000
--- a/src/main/java/org/neo4j/tool/GraphGenerator.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.GraphDatabaseService;
-import org.neo4j.graphdb.Node;
-import org.neo4j.graphdb.Relationship;
-import org.neo4j.graphdb.Transaction;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.kernel.EmbeddedGraphDatabase;
-
-import java.util.Arrays;
-
-/**
- * @author mh
- * @since 12.08.11
- */
-public class GraphGenerator {
-    public static final int MILLION = 1000 * 1000;
-
-    public static void main(String[] args) {
-        final GraphDatabaseService gdb = new GraphDatabaseFactory().newEmbeddedDatabase("target/data");
-        createDatabase(gdb);
-        gdb.shutdown();
-    }
-    public static void createDatabase(GraphDatabaseService graphdb) {
-        int [] largeArray = new int[5000];
-        Arrays.fill(largeArray, 101);
-        long cpuTime = System.currentTimeMillis();
-        Transaction tx = graphdb.beginTx();
-        try {
-            Node last = null, node = null;
-            for (int i = 0; i < MILLION; i++) {
-                node = graphdb.createNode();
-                if (last != null) {
-                    final Relationship rel = last.createRelationshipTo(node, Rels.values()[i % Rels.size()]);
-                    rel.setProperty("array",largeArray);
-                }
-                last = node;
-                if ((i % 100) == 0) {
-                    System.out.print(".");
-                    if ((i % 10000) == 0) {
-                        tx.success();
-                        tx.finish();
-                        System.out.println(" " + i);
-                        tx = graphdb.beginTx();
-                    }
-                }
-            }
-        } finally {
-            tx.finish();
-        }
-        System.out.println();
-        long delta = (System.currentTimeMillis() - cpuTime);
-        System.out.println("create-db delta = " + delta);
-    }
-}
diff --git a/src/main/java/org/neo4j/tool/PropertyAnalyzer.java b/src/main/java/org/neo4j/tool/PropertyAnalyzer.java
deleted file mode 100644
index abef9ff..0000000
--- a/src/main/java/org/neo4j/tool/PropertyAnalyzer.java
+++ /dev/null
@@ -1,165 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.*;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.helpers.collection.MapUtil;
-import org.neo4j.kernel.EmbeddedGraphDatabase;
-
-import java.lang.reflect.Array;
-import java.util.*;
-
-/**
- * @author mh
- * @since 28.07.11
- */
-public class PropertyAnalyzer {
-    static class PropertyInfo {
-        String name;
-        int count;
-        int emptyCount;
-        Set<String> types=new HashSet<String>();
-        long min, max;
-        int minCount, maxCount;
-        PropertyInfo(String name) {
-            this.name = name;
-        }
-        public void update(PropertyContainer pc) {
-            count++;
-            final Object value = pc.getProperty(name);
-
-            final Class<?> type = value.getClass();
-            types.add(type.getSimpleName());
-            final int size = toSize(value);
-            minCount = Math.min(minCount, size);
-            maxCount = Math.max(maxCount, size);
-            final long length = toNumber(value);
-            min = Math.min(min, length);
-            max = Math.max(max, length);
-            if (isDefaultValue(value)) {
-                emptyCount++;
-            }
-        }
-
-        private long toNumber(Object value) {
-            if (value instanceof Number) {
-                return ((Number)value).longValue();
-            }
-            if (value instanceof String) {
-                return ((String) value).length();
-            }
-            if (value instanceof Boolean && ((Boolean)value)) {
-                return 1;
-            }
-            if (value.getClass().isArray()) {
-                long sum=0;
-                for (int i = Array.getLength(value)-1;i>=0;i--) {
-                    sum += toNumber(Array.get(value,i));
-                }
-                return sum;
-            }
-            return 0;
-        }
-
-        private int toSize(Object value) {
-            if (value.getClass().isArray()) {
-                return Array.getLength(value);
-            }
-            return 1;
-        }
-
-        @Override
-        public String toString() {
-            return ""+name+"	"+ count+"	"+ emptyCount+"	"+ types+"	"+minCount+"	"+maxCount+"	"+min+"	"+max;
-        }
-
-        public int getEmptyCount() {
-            return emptyCount;
-        }
-
-        public int getCount() {
-            return count;
-        }
-    }
-
-    public static Map<String,String> config() {
-        return (Map) MapUtil.map(
-                "neostore.nodestore.db.mapped_memory", "100M",
-                "neostore.relationshipstore.db.mapped_memory", "500M",
-                "neostore.propertystore.db.mapped_memory", "300M",
-                "neostore.propertystore.db.strings.mapped_memory", "1G",
-                "neostore.propertystore.db.arrays.mapped_memory", "300M",
-                "neostore.propertystore.db.index.keys.mapped_memory", "100M",
-                "neostore.propertystore.db.index.mapped_memory", "100M",
-                "allow_store_upgrade","true",
-                "cache_type", "weak"
-        );
-    }
-
-    public static void main(String[] args) {
-        final GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabaseBuilder(args[0]).setConfig(config()).newGraphDatabase();
-        int withoutProps=0, nodes = 0, rels = 0;
-        Map<String,PropertyInfo> props=new HashMap<String, PropertyInfo>();
-        for (Node node : db.getAllNodes()) {
-            nodes ++;
-            withoutProps += analyzeProperties(props, node);
-            for (Relationship relationship : node.getRelationships(Direction.OUTGOING)) {
-               rels ++;
-               withoutProps += analyzeProperties(props, relationship);
-            }
-            if (nodes % 1000 == 0) {
-                System.out.print(".");
-                if (nodes % 100000 == 0)
-                    System.out.println(" "+nodes);
-            }
-        }
-        db.shutdown();
-        outputEmptyCounts(withoutProps, props, nodes, rels);
-    }
-
-    private static int analyzeProperties(Map<String, PropertyInfo> props, PropertyContainer propertyContainer) {
-        boolean hasProps = false;
-        for (String property : propertyContainer.getPropertyKeys()) {
-            hasProps=true;
-            update(props, property,propertyContainer);
-        }
-        return hasProps ? 0 : 1;
-    }
-
-    private static void update(Map<String, PropertyInfo> props, String property, PropertyContainer pc) {
-        PropertyInfo info = props.get(property);
-        if (info==null) {
-            info = new PropertyInfo(property);
-            props.put(property, info);
-        }
-        info.update(pc);
-    }
-
-    private static void outputEmptyCounts(int withoutProps, Map<String, PropertyInfo> props, int nodes, int rels) {
-        System.out.println();
-        int emptyCount=0, allCount = 0;
-        for (PropertyInfo info : props.values()) {
-            emptyCount += info.getEmptyCount();
-            allCount += info.getCount();
-            System.out.println(info);
-        }
-        System.out.printf("%d of %d empty properties %d nodes %d rels pc w/o props %d%n", emptyCount, allCount,nodes,rels,withoutProps);
-    }
-
-    private static boolean isDefaultValue(Object property) {
-        if (property==null) return true;
-        if (property instanceof String) return ((String)property).isEmpty();
-        if (property instanceof Number) return ((Number)property).longValue() == 0 || ((Number)property).doubleValue() == 0.0D;
-        if (property instanceof Character) return (Character) property == 0;
-        if (property instanceof Boolean) return !(Boolean) property;
-        if (property instanceof String[]) return ((String[])property).length==0;
-        if (property instanceof int[]) return ((int[])property).length==0;
-        if (property instanceof long[]) return ((long[])property).length==0;
-        if (property instanceof boolean[]) return ((boolean[])property).length==0;
-        if (property instanceof char[]) return ((char[])property).length==0;
-        if (property instanceof byte[]) return ((byte[])property).length==0;
-        if (property instanceof float[]) return ((float[])property).length==0;
-        if (property instanceof double[]) return ((double[])property).length==0;
-        System.out.println("property = " + property);
-        return false;
-    }
-}
diff --git a/src/main/java/org/neo4j/tool/Rels.java b/src/main/java/org/neo4j/tool/Rels.java
deleted file mode 100644
index aa7c0c4..0000000
--- a/src/main/java/org/neo4j/tool/Rels.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.RelationshipType;
-
-/**
-* @author mh
-* @since 12.08.11
-*/
-enum Rels implements RelationshipType {
-    RATED, USED, SUGGESTED, ACTS_IN;
-
-    public static Rels random() {
-        final int idx = (int) (Math.random() * size());
-        return values()[idx];
-
-    }
-
-    public static int size() {
-        return values().length;
-    }
-}
diff --git a/src/main/java/org/neo4j/tool/SingleRelationshipDeletion.java b/src/main/java/org/neo4j/tool/SingleRelationshipDeletion.java
deleted file mode 100644
index b596b26..0000000
--- a/src/main/java/org/neo4j/tool/SingleRelationshipDeletion.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.neo4j.tool;
-
-/**
- * @author mh
- * @since 12.08.11
- */
-
-import org.neo4j.graphdb.GraphDatabaseService;
-import org.neo4j.graphdb.NotFoundException;
-import org.neo4j.graphdb.Relationship;
-import org.neo4j.graphdb.Transaction;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.kernel.EmbeddedGraphDatabase;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.Random;
-import java.util.Set;
-
-/**
- * @author mh
- * @since 11.08.11
- */
-public class SingleRelationshipDeletion {
-
-    public static final int COUNT = 1000;
-    private static final int ROUNDS = 50;
-
-    public static void main(String[] args) {
-        final File dir = new File("target/data");
-        boolean mustCreate = !dir.exists();
-        final GraphDatabaseService graphdb = new GraphDatabaseFactory().newEmbeddedDatabase(dir.getAbsolutePath());
-        if (mustCreate) GraphGenerator.createDatabase(graphdb);
-
-        for (int round = 0; round < ROUNDS; round++) {
-            long[] relIds = createRelIds(COUNT);
-            int success = 0, fail = 0;
-            long cpuTime = System.currentTimeMillis();
-            final Transaction tx = graphdb.beginTx();
-            try {
-                for (int i = 0; i < COUNT; i++) {
-                    final Relationship rel;
-                    try {
-                        rel = graphdb.getRelationshipById(relIds[i]);
-                    } catch (NotFoundException nfe) {
-                        fail++;
-                        continue;
-                    }
-                    try {
-                        rel.delete();
-                        tx.success();
-                        success++;
-                    } catch (NotFoundException nfe) {
-                        fail++;
-//                    tx.failure();
-                    }
-                }
-            } finally {
-                tx.finish();
-            }
-
-            long delta = (System.currentTimeMillis() - cpuTime);
-            System.out.printf("round %d delete %d relationships time = %d ms, succ %d failed %d%n", round, COUNT, delta, success, fail);
-        }
-        graphdb.shutdown();
-    }
-
-    private static long[] createRelIds(final int count) {
-        Random random = new Random(System.currentTimeMillis());
-        Set<Integer> values = new HashSet<Integer>();
-        do {
-            values.add(random.nextInt(GraphGenerator.MILLION));
-        } while (values.size() < count);
-        final long[] result = new long[count];
-        int i = 0;
-        for (Integer value : values) {
-            result[i++] = value.longValue();
-        }
-        return result;
-    }
-
-}
diff --git a/src/main/java/org/neo4j/tool/StoreComparer.java b/src/main/java/org/neo4j/tool/StoreComparer.java
deleted file mode 100644
index b790ff5..0000000
--- a/src/main/java/org/neo4j/tool/StoreComparer.java
+++ /dev/null
@@ -1,252 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.*;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.helpers.collection.IteratorUtil;
-import org.neo4j.helpers.collection.MapUtil;
-import org.neo4j.kernel.EmbeddedGraphDatabase;
-import org.neo4j.kernel.impl.util.FileUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-
-import static java.util.Arrays.asList;
-import static java.util.Arrays.toString;
-import static java.util.Collections.emptySet;
-
-public class StoreComparer {
-
-    @SuppressWarnings("unchecked")
-    public static Map<String, String> config() {
-        return (Map) MapUtil.map(
-                "neostore.nodestore.db.mapped_memory", "100M",
-                "neostore.relationshipstore.db.mapped_memory", "500M",
-                "neostore.propertystore.db.mapped_memory", "300M",
-                "neostore.propertystore.db.strings.mapped_memory", "1G",
-                "neostore.propertystore.db.arrays.mapped_memory", "300M",
-                "neostore.propertystore.db.index.keys.mapped_memory", "100M",
-                "neostore.propertystore.db.index.mapped_memory", "100M",
-                "cache_type", "weak"
-        );
-    }
-
-    public static void main(String[] args) throws Exception {
-        if (args.length < 2) {
-            System.err.println("Usage: StoreComparer source target [rel,types,to,ignore] [properties,to,ignore]");
-            return;
-        }
-        String sourceDir = args[0];
-        String targetDir = args[1];
-        Set<String> ignoreRelTypes = splitOptionIfExists(args, 2);
-        Set<String> ignoreProperties = splitOptionIfExists(args, 3);
-        System.out.printf("Copying from %s to %s ingoring rel-types %s ignoring properties %s %n", sourceDir, targetDir, ignoreRelTypes, ignoreProperties);
-        compareStore(sourceDir, targetDir, ignoreRelTypes, ignoreProperties);
-    }
-
-    private static Set<String> splitOptionIfExists(String[] args, final int index) {
-        if (args.length <= index) return emptySet();
-        return new HashSet<String>(asList(args[index].toLowerCase().split(",")));
-    }
-
-    private static void compareStore(String sourceDir, String targetDir, Set<String> ignoreRelTypes, Set<String> ignoreProperties) throws Exception {
-        final File target = new File(targetDir);
-        final File source = new File(sourceDir);
-        if (!target.exists()) throw new IllegalArgumentException("Target Directory does not exists " + target);
-        if (!source.exists()) throw new IllegalArgumentException("Source Database does not exist " + source);
-
-        GraphDatabaseService targetDb = new GraphDatabaseFactory().newEmbeddedDatabaseBuilder(target.getAbsolutePath()).setConfig(config()).newGraphDatabase();
-        GraphDatabaseService sourceDb = new GraphDatabaseFactory().newEmbeddedDatabaseBuilder(sourceDir).setConfig(config()).newGraphDatabase();
-
-        compareCounts(sourceDb, targetDb, ignoreRelTypes, ignoreProperties);
-        compareNodes(sourceDb, targetDb, ignoreProperties);
-        compareRelationships(sourceDb, targetDb, ignoreRelTypes, ignoreProperties);
-
-        targetDb.shutdown();
-        sourceDb.shutdown();
-        copyIndex(source, target);
-    }
-
-    private static void compareCounts(GraphDatabaseService sourceDb, GraphDatabaseService targetDb, Set<String> ignoreRelTypes, Set<String> ignoreProperties) {
-        long time = System.currentTimeMillis();
-        final Statistics sourceStatistics = count(sourceDb, ignoreRelTypes, ignoreProperties);
-        final Statistics targetStatistics = count(targetDb, ignoreRelTypes, ignoreProperties);
-        if (!sourceStatistics.equals(targetStatistics)) {
-            System.err.println("Count difference");
-            System.err.println("Source " + sourceStatistics);
-            System.err.println("Target " + targetStatistics);
-        }
-        System.out.println("\n comparing of " + "counts" + " took " + (System.currentTimeMillis() - time) + " ms.");
-    }
-
-    private static Statistics count(GraphDatabaseService db, Set<String> ignoreRelTypes, Set<String> ignoreProperties) {
-        Statistics statistics = new Statistics();
-        int count = 0;
-        for (Node node : db.getAllNodes()) {
-            statistics.nodeCount++;
-            statistics.nodeProperties += countProperties(ignoreProperties, node);
-            for (Relationship rel : node.getRelationships(Direction.OUTGOING)) {
-                if (ignoreRelTypes.contains(rel.getType().name().toLowerCase())) continue;
-                statistics.relationshipCount++;
-                statistics.relationshipPropertyCount += countProperties(ignoreProperties, rel);
-                count++;
-                if (count % 1000 == 0) System.out.print(".");
-                if (count % 100000 == 0) System.out.println(" " + count);
-            }
-        }
-        return statistics;
-    }
-
-    private static int countProperties(Set<String> ignoreProperties, PropertyContainer node) {
-        final Collection<String> keys = IteratorUtil.addToCollection(node.getPropertyKeys(), new HashSet<String>());
-        keys.removeAll(ignoreProperties);
-        return keys.size();
-    }
-
-    private static void copyIndex(File source, File target) throws IOException {
-        final File indexFile = new File(source, "index.db");
-        if (indexFile.exists()) {
-            FileUtils.copyFile(indexFile, new File(target, "index.db"));
-        }
-        final File indexDir = new File(source, "index");
-        if (indexDir.exists()) {
-            FileUtils.copyRecursively(indexDir, new File(target, "index"));
-        }
-    }
-
-
-    private static void compareRelationships(GraphDatabaseService sourceDb, GraphDatabaseService targetDb, Set<String> ignoreRelTypes, Set<String> ignoreProperties) {
-        long time = System.currentTimeMillis();
-        int count = 0;
-        for (Node node : sourceDb.getAllNodes()) {
-            compareProperties(node, targetDb.getNodeById(node.getId()), ignoreProperties);
-            for (Relationship rel : node.getRelationships(Direction.OUTGOING)) {
-                if (ignoreRelTypes.contains(rel.getType().name().toLowerCase())) continue;
-                final Relationship targetRel = getTargetRel(targetDb, node.getId(), rel.getOtherNode(node).getId(), rel.getType());
-                compareProperties(rel, targetRel,ignoreProperties);
-                count++;
-                if (count % 1000 == 0) System.out.print(".");
-                if (count % 100000 == 0) System.out.println(" " + count);
-            }
-        }
-        System.out.println("\n copying of " + count + " relationships took " + (System.currentTimeMillis() - time) + " ms.");
-    }
-
-    private static Relationship getTargetRel(GraphDatabaseService gdb,long startNodeId, long endNodeId, RelationshipType relType) {
-        final Node start = gdb.getNodeById(startNodeId);
-        final Node endNode = gdb.getNodeById(endNodeId);
-        for (Relationship relationship : start.getRelationships(relType, Direction.OUTGOING)) {
-            if (relationship.getOtherNode(start).equals(endNode)) return relationship;
-        }
-        return null;
-    }
-
-    private static void compareProperties(PropertyContainer pc1, PropertyContainer pc2, Set<String> ignoreProperties) {
-        final Collection<String> keys1 = IteratorUtil.addToCollection(pc1.getPropertyKeys(), new HashSet<String>());
-        final Collection<String> keys2 = IteratorUtil.addToCollection(pc2.getPropertyKeys(), new HashSet<String>());
-        keys2.removeAll(ignoreProperties);
-        keys1.removeAll(ignoreProperties);
-        if (!keys1.equals(keys2)) {
-            System.err.println("On " + pc1 + " != " + pc2 + " properties mismatch " + keys1 + " != " + keys2);
-        }
-        for (String prop : keys1) {
-            final Object value1 = pc1.getProperty(prop);
-            final Object value2 = pc2.getProperty(prop);
-            if (!equals(value1, value2)) {
-                System.err.println("On " + pc1 + " != " + pc2 + " property " + prop + " mismatch " + toString(value1) + " != " + toString(value2));
-            }
-        }
-    }
-
-    private static String toString(Object value) {
-        if (value==null) return "null";
-        return value.getClass().isArray() ? Arrays.deepToString((Object[]) value) : value.toString();
-    }
-
-    private static boolean equals(Object value1, Object value2) {
-        if (value1==null && value2==null) return true;
-        if (value1==null || value2==null) return false;
-        final Class<?> type = value1.getClass();
-        if (type.isArray()) {
-            if (type.getComponentType().equals(byte.class)) return Arrays.equals((byte[])value1,(byte[])value2);
-            if (type.getComponentType().equals(char.class)) return Arrays.equals((char[])value1,(char[])value2);
-            if (type.getComponentType().equals(int.class)) return Arrays.equals((int[])value1,(int[])value2);
-            if (type.getComponentType().equals(long.class)) return Arrays.equals((long[])value1,(long[])value2);
-            if (type.getComponentType().equals(float.class)) return Arrays.equals((float[])value1,(float[])value2);
-            if (type.getComponentType().equals(double.class)) return Arrays.equals((double[])value1,(double[])value2);
-            if (type.getComponentType().equals(boolean.class)) return Arrays.equals((boolean[])value1,(boolean[])value2);
-            if (type.getComponentType().equals(String.class)) return Arrays.equals((String[])value1,(String[])value2);
-            return Arrays.equals((Object[])value1,(Object[])value2);
-        }
-        return value1.equals(value2);
-    }
-
-    private static void compareNodes(GraphDatabaseService sourceDb, GraphDatabaseService targetDb, Set<String> ignoreProperties) {
-        long time = System.currentTimeMillis();
-        int count = 0;
-        for (Node node : sourceDb.getAllNodes()) {
-            compareProperties(node, targetDb.getNodeById(node.getId()), ignoreProperties);
-            count++;
-            if (count % 1000 == 0) System.out.print(".");
-            if (count % 100000 == 0) System.out.println(" " + count);
-        }
-
-        System.out.println("\n comparing of " + count + " nodes took " + (System.currentTimeMillis() - time) + " ms.");
-    }
-
-    private static Map<String, Object> getProperties(PropertyContainer pc, Set<String> ignoreProperties) {
-        Map<String, Object> result = new HashMap<String, Object>();
-        for (String property : pc.getPropertyKeys()) {
-            if (ignoreProperties.contains(property.toLowerCase())) continue;
-            result.put(property, pc.getProperty(property));
-        }
-        return result;
-    }
-
-    private static class Statistics {
-        public int nodeCount;
-        public int nodeProperties;
-        public int relationshipCount;
-        public int relationshipPropertyCount;
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-
-            Statistics that = (Statistics) o;
-
-            if (nodeCount != that.nodeCount) {
-                System.err.println("nodes " + nodeCount + " != " + that.nodeCount);
-                return false;
-            }
-            if (nodeProperties != that.nodeProperties) {
-                System.err.println("nodeProperties " + nodeProperties + " != " + that.nodeProperties);
-                return false;
-            }
-            if (relationshipCount != that.relationshipCount) {
-                System.err.println("relationshipCount " + relationshipCount + " != " + that.relationshipCount);
-                return false;
-            }
-            if (relationshipPropertyCount != that.relationshipPropertyCount) {
-                System.err.println("relationshipPropertyCount " + relationshipPropertyCount + " != " + that.relationshipPropertyCount);
-                return false;
-            }
-            return true;
-        }
-
-        @Override
-        public int hashCode() {
-            int result = nodeCount;
-            result = 31 * result + nodeProperties;
-            result = 31 * result + relationshipCount;
-            result = 31 * result + relationshipPropertyCount;
-            return result;
-        }
-
-        @Override
-        public String toString() {
-            return String.format("Statistics{nodes=%d, nodeProperties=%d, relationshipCount=%d, relationshipPropertyCount=%d}", nodeCount, nodeProperties, relationshipCount, relationshipPropertyCount);
-        }
-    }
-}
diff --git a/src/main/java/org/neo4j/tool/StoreCopy.java b/src/main/java/org/neo4j/tool/StoreCopy.java
deleted file mode 100644
index 95fe717..0000000
--- a/src/main/java/org/neo4j/tool/StoreCopy.java
+++ /dev/null
@@ -1,178 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.*;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.helpers.Pair;
-import org.neo4j.helpers.collection.IteratorUtil;
-import org.neo4j.helpers.collection.MapUtil;
-import org.neo4j.kernel.GraphDatabaseAPI;
-import org.neo4j.kernel.impl.core.NodeManager;
-import org.neo4j.kernel.impl.nioneo.store.InvalidRecordException;
-import org.neo4j.kernel.impl.util.FileUtils;
-import org.neo4j.unsafe.batchinsert.BatchInserter;
-import org.neo4j.unsafe.batchinsert.BatchInserters;
-import org.neo4j.unsafe.batchinsert.BatchRelationship;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.util.*;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptySet;
-
-public class StoreCopy {
-
-    private static final Label[] NO_LABELS = new Label[0];
-    private static PrintWriter logs;
-
-    @SuppressWarnings("unchecked")
-    public static Map<String, String> config() {
-        return (Map) MapUtil.map(
-                "neostore.nodestore.db.mapped_memory", "100M",
-                "neostore.relationshipstore.db.mapped_memory", "500M",
-                "neostore.propertystore.db.mapped_memory", "300M",
-                "neostore.propertystore.db.strings.mapped_memory", "1G",
-                "neostore.propertystore.db.arrays.mapped_memory", "300M",
-                "neostore.propertystore.db.index.keys.mapped_memory", "100M",
-                "neostore.propertystore.db.index.mapped_memory", "100M",
-                "cache_type", "weak"
-        );
-    }
-
-    public static void main(String[] args) throws Exception {
-        if (args.length < 2) {
-            System.err.println("Usage: StoryCopy source target [rel,types,to,ignore] [properties,to,ignore]");
-            return;
-        }
-        String sourceDir = args[0];
-        String targetDir = args[1];
-        Set<String> ignoreRelTypes = splitOptionIfExists(args, 2);
-        Set<String> ignoreProperties = splitOptionIfExists(args, 3);
-        Set<String> ignoreLabels = splitOptionIfExists(args, 4);
-        System.out.printf("Copying from %s to %s ingoring rel-types %s ignoring properties %s ignoring labels %s %n", sourceDir, targetDir, ignoreRelTypes, ignoreProperties,ignoreLabels);
-        copyStore(sourceDir, targetDir, ignoreRelTypes, ignoreProperties,ignoreLabels);
-    }
-
-    private static Set<String> splitOptionIfExists(String[] args, final int index) {
-        if (args.length <= index) return emptySet();
-        return new HashSet<String>(asList(args[index].toLowerCase().split(",")));
-    }
-
-    private static void copyStore(String sourceDir, String targetDir, Set<String> ignoreRelTypes, Set<String> ignoreProperties, Set<String> ignoreLabels) throws Exception {
-        final File target = new File(targetDir);
-        final File source = new File(sourceDir);
-        if (target.exists()) {
-            FileUtils.deleteRecursively(target);
-            // throw new IllegalArgumentException("Target Directory already exists "+target);
-        }
-        if (!source.exists()) throw new IllegalArgumentException("Source Database does not exist " + source);
-
-        Pair<Long, Long> highestIds = getHighestNodeId(source);
-        BatchInserter targetDb = BatchInserters.inserter(target.getAbsolutePath(), config());
-        BatchInserter sourceDb = BatchInserters.inserter(source.getAbsolutePath(), config());
-        logs = new PrintWriter(new FileWriter(new File(target, "store-copy.log")));
-
-        copyNodes(sourceDb, targetDb, ignoreProperties, ignoreLabels, highestIds.first());
-        copyRelationships(sourceDb, targetDb, ignoreRelTypes, ignoreProperties, highestIds.other());
-
-        targetDb.shutdown();
-        sourceDb.shutdown();
-        logs.close();
-        copyIndex(source, target);
-    }
-
-    private static Pair<Long, Long> getHighestNodeId(File source) {
-        GraphDatabaseAPI api = (GraphDatabaseAPI) new GraphDatabaseFactory().newEmbeddedDatabase(source.getAbsolutePath());
-        NodeManager nodeManager = api.getDependencyResolver().resolveDependency(NodeManager.class);
-        long highestNodeId = nodeManager.getHighestPossibleIdInUse(Node.class);
-        long highestRelId = nodeManager.getHighestPossibleIdInUse(Relationship.class);
-        api.shutdown();
-        return Pair.of(highestNodeId, highestRelId);
-    }
-
-    private static void copyIndex(File source, File target) throws IOException {
-        final File indexFile = new File(source, "index.db");
-        if (indexFile.exists()) {
-            FileUtils.copyFile(indexFile, new File(target, "index.db"));
-        }
-        final File indexDir = new File(source, "index");
-        if (indexDir.exists()) {
-            FileUtils.copyRecursively(indexDir, new File(target, "index"));
-        }
-    }
-
-    private static void copyRelationships(BatchInserter sourceDb, BatchInserter targetDb, Set<String> ignoreRelTypes, Set<String> ignoreProperties, long highestRelId) {
-        long time = System.currentTimeMillis();
-        long relId = 0;
-        long notFound = 0;
-        while (relId <= highestRelId) {
-            BatchRelationship rel = null;
-            try {
-                rel = sourceDb.getRelationshipById(relId++);
-            } catch (InvalidRecordException nfe) {
-                notFound++;
-                continue;
-            }
-            if (ignoreRelTypes.contains(rel.getType().name().toLowerCase())) continue;
-            createRelationship(targetDb, sourceDb, rel, ignoreProperties);
-            if (relId % 1000 == 0) System.out.print(".");
-            if (relId % 100000 == 0) System.out.println(" " + rel);
-        }
-        System.out.println("\n copying of "+relId+" relationships took "+(System.currentTimeMillis()-time)+" ms. Not found "+notFound);
-    }
-
-    private static void createRelationship(BatchInserter targetDb, BatchInserter sourceDb, BatchRelationship rel, Set<String> ignoreProperties) {
-        long startNodeId = rel.getStartNode();
-        long endNodeId = rel.getEndNode();
-        final RelationshipType type = rel.getType();
-        try {
-            targetDb.createRelationship(startNodeId, endNodeId, type, getProperties(sourceDb.getRelationshipProperties(rel.getId()), ignoreProperties));
-        } catch (InvalidRecordException ire) {
-            addLog(rel, "create Relationship: " + startNodeId + "-[:" + type + "]" + "->" + endNodeId, ire.getMessage());
-        }
-    }
-
-    private static void copyNodes(BatchInserter sourceDb, BatchInserter targetDb, Set<String> ignoreProperties, Set<String> ignoreLabels, long highestNodeId) {
-        long time = System.currentTimeMillis();
-        int node = -1;
-        while (++node <= highestNodeId) {
-            if (!sourceDb.nodeExists(node)) continue;
-            targetDb.createNode(node, getProperties(sourceDb.getNodeProperties(node), ignoreProperties), labelsArray(sourceDb, node,ignoreLabels));
-            if (node % 1000 == 0) System.out.print(".");
-            if (node % 100000 == 0) {
-                logs.flush();
-                System.out.println(" " + node);
-            }
-        }
-        System.out.println("\n copying of " + node + " nodes took " + (System.currentTimeMillis() - time) + " ms.");
-    }
-
-    private static Label[] labelsArray(BatchInserter db, long node, Set<String> ignoreLabels) {
-        Collection<Label> labels = IteratorUtil.asCollection(db.getNodeLabels(node));
-        if (labels.isEmpty()) return NO_LABELS;
-        if (!ignoreLabels.isEmpty()) {
-            for (Iterator<Label> it = labels.iterator(); it.hasNext(); ) {
-                Label label = it.next();
-                if (ignoreLabels.contains(label.name().toLowerCase())) {
-                    it.remove();
-                }
-            }
-        }
-        return labels.toArray(new Label[labels.size()]);
-    }
-
-    private static Map<String, Object> getProperties(Map<String, Object> pc, Set<String> ignoreProperties) {
-        if (!ignoreProperties.isEmpty()) pc.keySet().removeAll(ignoreProperties);
-        return pc;
-    }
-
-    private static void addLog(BatchRelationship rel, String property, String message) {
-        logs.append(String.format("%s.%s %s%n", rel, property, message));
-    }
-
-    private static void addLog(PropertyContainer pc, String property, String message) {
-        logs.append(String.format("%s.%s %s%n", pc, property, message));
-    }
-}
diff --git a/src/main/java/org/neo4j/tool/StoreUpdate.java b/src/main/java/org/neo4j/tool/StoreUpdate.java
deleted file mode 100644
index 93cbee5..0000000
--- a/src/main/java/org/neo4j/tool/StoreUpdate.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package org.neo4j.tool;
-
-import org.neo4j.graphdb.GraphDatabaseService;
-import org.neo4j.graphdb.factory.GraphDatabaseFactory;
-import org.neo4j.helpers.collection.MapUtil;
-
-import java.util.Map;
-
-/**
- * @author mh
- * @since 21.12.11
- */
-public class StoreUpdate {
-    public static Map<String, String> config() {
-        //noinspection unchecked
-        return (Map) MapUtil.map(
-                "neostore.nodestore.db.mapped_memory", "100M",
-                "neostore.relationshipstore.db.mapped_memory", "500M",
-                "neostore.propertystore.db.mapped_memory", "300M",
-                "neostore.propertystore.db.strings.mapped_memory", "1G",
-                "neostore.propertystore.db.arrays.mapped_memory", "300M",
-                "neostore.propertystore.db.index.keys.mapped_memory", "100M",
-                "neostore.propertystore.db.index.mapped_memory", "100M",
-                "allow_store_upgrade", "true",
-                "cache_type", "weak"
-        );
-    }
-
-    public static void main(String[] args) {
-        GraphDatabaseService db = null;
-        try {
-            db = new GraphDatabaseFactory().newEmbeddedDatabaseBuilder("target/data").setConfig(config()).newGraphDatabase();
-        } finally {
-            if (db != null) db.shutdown();
-        }
-    }
-}