From ceac1bb9203c8bc6bd2cd2c7960a13cb85c75fb5 Mon Sep 17 00:00:00 2001
From: Zhangmei Li <lizhangmei@baidu.com>
Date: Sun, 19 Aug 2018 10:40:29 +0800
Subject: [PATCH] speed up tinkerpop test

how to:
1.speed up rocksdb backend by truncating tables
2.don't need to clear if the database is empty
3.don't need to clear variables if it's empty
4.don't need to commit hbase each len-prefix for delete index-label

potential problems:
1.mysql may block if create task vertex-label when truncating table
2.rocksdb may miss CF if create task vertex-label when truncating table
3.hbase may block if truncate hbase with version<2.0

improve #14

Change-Id: I4b2393aea8b0fc63c1886e984a576a1f5808b25c
---
 .../com/baidu/hugegraph/api/GraphsAPI.java    |  25 +--
 .../hugegraph/auth/HugeGraphAuthProxy.java    |   6 +
 .../store/cassandra/CassandraSessionPool.java |   4 +
 .../store/cassandra/CassandraStore.java       |  68 ++++---
 .../store/cassandra/CassandraTable.java       |  17 +-
 .../com/baidu/hugegraph/GremlinGraph.java     |   2 +
 .../java/com/baidu/hugegraph/HugeGraph.java   |  44 ++++-
 .../baidu/hugegraph/backend/LocalCounter.java |   4 +
 .../backend/cache/CachedBackendStore.java     |   5 +
 .../cache/CachedSchemaTransaction.java        |  88 ++++++---
 .../backend/serializer/BinarySerializer.java  |   1 +
 .../store/AbstractBackendStoreProvider.java   |  38 +++-
 .../hugegraph/backend/store/BackendStore.java |   3 +
 .../backend/store/BackendStoreProvider.java   |   4 +
 .../backend/store/memory/InMemoryDBStore.java |  48 +++--
 .../store/memory/InMemoryDBStoreProvider.java |  13 ++
 .../store/memory/InMemoryDBTables.java        |   9 +-
 .../backend/tx/GraphTransaction.java          |   3 +-
 .../baidu/hugegraph/config/CoreOptions.java   |  24 ++-
 .../hugegraph/job/schema/SchemaCallable.java  |   1 +
 .../schema/builder/IndexLabelBuilder.java     |   8 +-
 .../baidu/hugegraph/task/TaskScheduler.java   | 105 ++++++++---
 .../optimize/HugeGraphStepStrategy.java       |   2 +-
 .../optimize/HugeVertexStepStrategy.java      |   2 +-
 .../traversal/optimize/TraversalUtil.java     |  20 +-
 .../java/com/baidu/hugegraph/util/Events.java |   1 +
 .../backend/store/hbase/HbaseSessions.java    |  14 ++
 .../backend/store/hbase/HbaseStore.java       |  22 +++
 .../backend/store/hbase/HbaseTables.java      |   2 +-
 .../backend/store/mysql/MysqlStore.java       |  51 ++---
 .../store/mysql/MysqlStoreProvider.java       |   2 +-
 .../backend/store/mysql/MysqlTable.java       |  35 +++-
 .../backend/store/palo/PaloStore.java         |   2 +-
 .../backend/store/rocksdb/RocksDBStore.java   |  14 +-
 .../backend/store/rocksdb/RocksDBTables.java  |  38 ++--
 .../store/scylladb/ScyllaDBTables.java        |  85 +++++++--
 .../store/scylladb/ScyllaDBTablesWithMV.java  |  16 +-
 .../baidu/hugegraph/tinkerpop/TestGraph.java  |  69 ++++---
 .../tinkerpop/TestGraphProvider.java          | 176 ++++++++++++------
 39 files changed, 762 insertions(+), 309 deletions(-)

diff --git a/hugegraph-api/src/main/java/com/baidu/hugegraph/api/GraphsAPI.java b/hugegraph-api/src/main/java/com/baidu/hugegraph/api/GraphsAPI.java
index 16f15c2923..bd085bfbba 100644
--- a/hugegraph-api/src/main/java/com/baidu/hugegraph/api/GraphsAPI.java
+++ b/hugegraph-api/src/main/java/com/baidu/hugegraph/api/GraphsAPI.java
@@ -37,13 +37,10 @@
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.SecurityContext;
 
-import org.apache.tinkerpop.gremlin.structure.Edge;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
 import org.slf4j.Logger;
 
 import com.baidu.hugegraph.HugeGraph;
 import com.baidu.hugegraph.core.GraphManager;
-import com.baidu.hugegraph.schema.SchemaManager;
 import com.baidu.hugegraph.server.RestServer;
 import com.baidu.hugegraph.type.define.GraphMode;
 import com.baidu.hugegraph.util.E;
@@ -129,27 +126,7 @@ public void clear(@Context GraphManager manager,
             throw new IllegalArgumentException(String.format(
                       "Please take the message: %s", CONFIRM_CLEAR));
         }
-
-        // Clear vertex and edge
-        commit(g, () -> {
-            g.traversal().E().toStream().forEach(Edge::remove);
-            g.traversal().V().toStream().forEach(Vertex::remove);
-        });
-
-        // Schema operation will auto commit
-        SchemaManager schema = g.schema();
-        schema.getIndexLabels().forEach(elem -> {
-            schema.indexLabel(elem.name()).remove();
-        });
-        schema.getEdgeLabels().forEach(elem -> {
-            schema.edgeLabel(elem.name()).remove();
-        });
-        schema.getVertexLabels().forEach(elem -> {
-            schema.vertexLabel(elem.name()).remove();
-        });
-        schema.getPropertyKeys().forEach(elem -> {
-            schema.propertyKey(elem.name()).remove();
-        });
+        g.truncateBackend();
     }
 
     @PUT
diff --git a/hugegraph-api/src/main/java/com/baidu/hugegraph/auth/HugeGraphAuthProxy.java b/hugegraph-api/src/main/java/com/baidu/hugegraph/auth/HugeGraphAuthProxy.java
index 765ed7141d..b7afbe2bf0 100644
--- a/hugegraph-api/src/main/java/com/baidu/hugegraph/auth/HugeGraphAuthProxy.java
+++ b/hugegraph-api/src/main/java/com/baidu/hugegraph/auth/HugeGraphAuthProxy.java
@@ -178,6 +178,12 @@ public void clearBackend() {
         this.hugegraph.clearBackend();
     }
 
+    @Override
+    public void truncateBackend() {
+        this.verifyPermission(ROLE_ADMIN);
+        this.hugegraph.truncateBackend();
+    }
+
     private void verifyPermission() {
         /*
          * The owner role should match the graph name
diff --git a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraSessionPool.java b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraSessionPool.java
index b80c1481a4..5a2d8457de 100644
--- a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraSessionPool.java
+++ b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraSessionPool.java
@@ -222,6 +222,10 @@ public void open() {
             this.session = cluster().connect(keyspace());
         }
 
+        public boolean opened() {
+            return this.session != null;
+        }
+
         @Override
         public boolean closed() {
             if (this.session == null) {
diff --git a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraStore.java b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraStore.java
index 3c8caec96e..0e749614b2 100644
--- a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraStore.java
+++ b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraStore.java
@@ -19,8 +19,11 @@
 
 package com.baidu.hugegraph.backend.store.cassandra;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -84,7 +87,7 @@ public CassandraStore(final BackendStoreProvider provider,
 
     private void registerMetaHandlers() {
         this.registerMetaHandler("metrics", (session, meta, args) -> {
-            CassandraMetrics metrics = new CassandraMetrics(cluster(), conf);
+            CassandraMetrics metrics = new CassandraMetrics(cluster(), this.conf);
             return metrics.getMetrics();
         });
     }
@@ -243,12 +246,25 @@ public BackendFeatures features() {
     @Override
     public void init() {
         this.checkClusterConnected();
-        this.initKeyspace();
 
+        if (this.sessions.session().opened()) {
+            // Session has ever been opened.
+            LOG.warn("Session has ever been opened(exist keyspace '{}' before)",
+                     this.keyspace);
+        } else {
+            // Create keyspace if needed
+            if (!this.existsKeyspace()) {
+                this.initKeyspace();
+            }
+            // Open session explicitly to get the exception when it fails
+            this.sessions.session().open();
+        }
+
+        // Create tables
         this.checkSessionConnected();
         this.initTables();
 
-        LOG.info("Store initialized: {}", this.store);
+        LOG.debug("Store initialized: {}", this.store);
     }
 
     @Override
@@ -261,7 +277,15 @@ public void clear() {
             this.clearKeyspace();
         }
 
-        LOG.info("Store cleared: {}", this.store);
+        LOG.debug("Store cleared: {}", this.store);
+    }
+
+    @Override
+    public void truncate() {
+        this.checkSessionConnected();
+
+        this.truncateTables();
+        LOG.debug("Store truncated: {}", this.store);
     }
 
     @Override
@@ -359,7 +383,8 @@ protected void initKeyspace() {
         replication.putIfAbsent("replication_factor", factor);
 
         Statement stmt = SchemaBuilder.createKeyspace(this.keyspace)
-                         .ifNotExists().with().replication(replication);
+                                      .ifNotExists().with()
+                                      .replication(replication);
 
         // Create keyspace with non-keyspace-session
         LOG.debug("Create keyspace: {}", stmt);
@@ -371,7 +396,6 @@ protected void initKeyspace() {
                 session.close();
             }
         }
-        this.sessions.session().open();
     }
 
     protected void clearKeyspace() {
@@ -395,18 +419,29 @@ protected boolean existsKeyspace() {
 
     protected void initTables() {
         CassandraSessionPool.Session session = this.sessions.session();
-        for (CassandraTable table : this.tables.values()) {
+        for (CassandraTable table : this.tables()) {
             table.init(session);
         }
     }
 
     protected void clearTables() {
         CassandraSessionPool.Session session = this.sessions.session();
-        for (CassandraTable table : this.tables.values()) {
+        for (CassandraTable table : this.tables()) {
             table.clear(session);
         }
     }
 
+    protected void truncateTables() {
+        CassandraSessionPool.Session session = this.sessions.session();
+        for (CassandraTable table : this.tables()) {
+            table.truncate(session);
+        }
+    }
+
+    protected Collection<CassandraTable> tables() {
+        return this.tables.values();
+    }
+
     @Override
     protected final CassandraTable table(HugeType type) {
         assert type != null;
@@ -472,19 +507,10 @@ public CassandraSchemaStore(BackendStoreProvider provider,
         }
 
         @Override
-        protected void initTables() {
-            super.initTables();
-
-            CassandraSessionPool.Session session = super.sessions.session();
-            this.counters.init(session);
-        }
-
-        @Override
-        protected void clearTables() {
-            super.clearTables();
-
-            CassandraSessionPool.Session session = super.sessions.session();
-            this.counters.clear(session);
+        protected Collection<CassandraTable> tables() {
+            List<CassandraTable> tables = new ArrayList<>(super.tables());
+            tables.add(this.counters);
+            return tables;
         }
 
         @Override
diff --git a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraTable.java b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraTable.java
index fe9f010849..db55235042 100644
--- a/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraTable.java
+++ b/hugegraph-cassandra/src/main/java/com/baidu/hugegraph/backend/store/cassandra/CassandraTable.java
@@ -119,13 +119,13 @@ protected List<Select> query2Select(String table, Query query) {
 
         // NOTE: Cassandra does not support query.offset()
         if (query.offset() != 0) {
-            LOG.warn("Query offset is not supported currently " +
-                     "on Cassandra store, it will be ignored");
+            LOG.debug("Query offset is not supported on Cassandra store " +
+                      "currently, it will be replaced by [0, offset + limit)");
         }
 
         // Set limit
         if (query.limit() != Query.NO_LIMIT) {
-            long total = query.limit() + query.offset();
+            long total = query.total();
             String page = query.page();
             if (page == null) {
                 select.limit((int) total);
@@ -550,11 +550,16 @@ protected void createTable(CassandraSessionPool.Session session,
         session.execute(table);
     }
 
-    public void dropTable(CassandraSessionPool.Session session) {
+    protected void dropTable(CassandraSessionPool.Session session) {
         LOG.debug("Drop table: {}", this.table());
         session.execute(SchemaBuilder.dropTable(this.table()).ifExists());
     }
 
+    protected void truncateTable(CassandraSessionPool.Session session) {
+        LOG.debug("Truncate table: {}", this.table());
+        session.execute(QueryBuilder.truncate(this.table()));
+    }
+
     protected void createIndex(CassandraSessionPool.Session session,
                                String indexLabel, HugeKeys column) {
         String indexName = joinTableName(this.table(), indexLabel);
@@ -570,4 +575,8 @@ protected void createIndex(CassandraSessionPool.Session session,
     public void clear(CassandraSessionPool.Session session) {
         this.dropTable(session);
     }
+
+    public void truncate(CassandraSessionPool.Session session) {
+        this.truncateTable(session);
+    }
 }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/GremlinGraph.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/GremlinGraph.java
index 08400ded45..4cbdc63060 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/GremlinGraph.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/GremlinGraph.java
@@ -33,6 +33,8 @@ public interface GremlinGraph extends Graph {
     public SchemaManager schema();
 
     public String backend();
+
     public void initBackend();
     public void clearBackend();
+    public void truncateBackend();
 }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/HugeGraph.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/HugeGraph.java
index 27e806d954..9a9b66fe15 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/HugeGraph.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/HugeGraph.java
@@ -23,6 +23,7 @@
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
@@ -71,7 +72,6 @@
 import com.baidu.hugegraph.util.LockUtil;
 import com.baidu.hugegraph.util.Log;
 import com.baidu.hugegraph.variables.HugeVariables;
-import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.RateLimiter;
 
 /**
@@ -97,9 +97,10 @@ public class HugeGraph implements GremlinGraph {
         LockUtil.init();
     }
 
+    private volatile boolean closed;
+    private volatile GraphMode mode;
+
     private final String name;
-    private boolean closed;
-    private GraphMode mode;
 
     private final HugeConfig configuration;
 
@@ -192,7 +193,7 @@ public void initBackend() {
         this.loadGraphStore().open(this.configuration);
         try {
             this.storeProvider.init();
-            new BackendStoreInfo(this).init();
+            this.initBackendStoreInfo();
         } finally {
             this.loadGraphStore().close();
             this.loadSystemStore().close();
@@ -202,6 +203,8 @@ public void initBackend() {
 
     @Override
     public void clearBackend() {
+        this.waitUntilAllTasksCompleted();
+
         this.loadSchemaStore().open(this.configuration);
         this.loadSystemStore().open(this.configuration);
         this.loadGraphStore().open(this.configuration);
@@ -214,7 +217,29 @@ public void clearBackend() {
         }
     }
 
+    @Override
+    public void truncateBackend() {
+        this.waitUntilAllTasksCompleted();
+
+        this.storeProvider.truncate();
+        this.initBackendStoreInfo();
+    }
+
+    private void waitUntilAllTasksCompleted() {
+        long timeout = this.configuration.get(CoreOptions.TASK_WAIT_TIMEOUT);
+        try {
+            this.taskScheduler().waitUntilAllTasksCompleted(timeout);
+        } catch (TimeoutException e) {
+            throw new HugeException("Failed to wait all tasks to complete", e);
+        }
+    }
+
+    private void initBackendStoreInfo() {
+        new BackendStoreInfo(this).init();
+    }
+
     private SchemaTransaction openSchemaTransaction() throws HugeException {
+        this.checkGraphNotClosed();
         try {
             return new CachedSchemaTransaction(this, this.loadSchemaStore());
         } catch (BackendException e) {
@@ -225,6 +250,7 @@ private SchemaTransaction openSchemaTransaction() throws HugeException {
     }
 
     private GraphTransaction openGraphTransaction() throws HugeException {
+        this.checkGraphNotClosed();
         try {
             return new CachedGraphTransaction(this, this.loadGraphStore());
         } catch (BackendException e) {
@@ -241,12 +267,16 @@ private BackendStoreProvider loadStoreProvider() {
         return BackendProviderFactory.open(backend, this.name);
     }
 
-    private BackendStore loadSchemaStore() {
+    private void checkGraphNotClosed() {
+        E.checkState(!this.closed, "Graph '%s' has been closed", this);
+    }
+
+    public BackendStore loadSchemaStore() {
         String name = this.configuration.get(CoreOptions.STORE_SCHEMA);
         return this.storeProvider.loadSchemaStore(name);
     }
 
-    private BackendStore loadGraphStore() {
+    public BackendStore loadGraphStore() {
         String graph = this.configuration.get(CoreOptions.STORE_GRAPH);
         return this.storeProvider.loadGraphStore(graph);
     }
@@ -257,6 +287,7 @@ public BackendStore loadSystemStore() {
     }
 
     public SchemaTransaction schemaTransaction() {
+        this.checkGraphNotClosed();
         /*
          * NOTE: each schema operation will be auto committed,
          * Don't need to open tinkerpop tx by readWrite() and commit manually.
@@ -265,6 +296,7 @@ public SchemaTransaction schemaTransaction() {
     }
 
     public GraphTransaction graphTransaction() {
+        this.checkGraphNotClosed();
         /*
          * NOTE: graph operations must be committed manually,
          * Maybe users need to auto open tinkerpop tx by readWrite().
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/LocalCounter.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/LocalCounter.java
index 16a7ed32bd..4fb065c851 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/LocalCounter.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/LocalCounter.java
@@ -72,4 +72,8 @@ public synchronized void increaseCounter(HugeType type, long increment) {
         AtomicLong value = new AtomicLong(oldValue + increment);
         this.counters.put(type, value);
     }
+
+    public void reset() {
+        this.counters.clear();
+    }
 }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedBackendStore.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedBackendStore.java
index baad4d8831..38d6d56841 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedBackendStore.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedBackendStore.java
@@ -81,6 +81,11 @@ public void clear() {
         this.store.clear();
     }
 
+    @Override
+    public void truncate() {
+        this.store.truncate();
+    }
+
     @Override
     public void beginTx() {
         this.store.beginTx();
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedSchemaTransaction.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedSchemaTransaction.java
index 00289d6f96..9dc6467487 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedSchemaTransaction.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/cache/CachedSchemaTransaction.java
@@ -22,6 +22,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
@@ -33,16 +34,20 @@
 import com.baidu.hugegraph.config.CoreOptions;
 import com.baidu.hugegraph.config.HugeConfig;
 import com.baidu.hugegraph.event.EventHub;
+import com.baidu.hugegraph.event.EventListener;
 import com.baidu.hugegraph.schema.SchemaElement;
 import com.baidu.hugegraph.type.HugeType;
 import com.baidu.hugegraph.util.Events;
-import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 public class CachedSchemaTransaction extends SchemaTransaction {
 
     private final Cache idCache;
     private final Cache nameCache;
 
+    private EventListener storeEventListener;
+    private EventListener cacheEventListener;
+
     private final Map<HugeType, Boolean> cachedTypes;
 
     public CachedSchemaTransaction(HugeGraph graph, BackendStore store) {
@@ -56,6 +61,15 @@ public CachedSchemaTransaction(HugeGraph graph, BackendStore store) {
         this.listenChanges();
     }
 
+    @Override
+    public void close() {
+        try {
+            super.close();
+        } finally {
+            this.unlistenChanges();
+        }
+    }
+
     private Cache cache(String prefix) {
         HugeConfig conf = super.graph().configuration();
 
@@ -66,47 +80,61 @@ private Cache cache(String prefix) {
     }
 
     private void listenChanges() {
-        // Listen store event: "store.init", "store.clear"
-        List<String> events = ImmutableList.of(Events.STORE_INIT,
-                                               Events.STORE_CLEAR);
-        super.store().provider().listen(event -> {
-            if (events.contains(event.name())) {
-                LOG.info("Clear cache on event '{}'", event.name());
+        // Listen store event: "store.init", "store.clear", ...
+        Set<String> storeEvents = ImmutableSet.of(Events.STORE_INIT,
+                                                  Events.STORE_CLEAR,
+                                                  Events.STORE_TRUNCATE);
+        this.storeEventListener = event -> {
+            if (storeEvents.contains(event.name())) {
+                LOG.debug("Graph {} clear cache on event '{}'",
+                          this.graph(), event.name());
                 this.idCache.clear();
                 this.nameCache.clear();
                 this.cachedTypes.clear();
                 return true;
             }
             return false;
-        });
+        };
+        this.store().provider().listen(this.storeEventListener);
 
         // Listen cache event: "cache"(invalid cache item)
-        EventHub schemaEventHub = super.graph().schemaEventHub();
-        if (!schemaEventHub.containsListener(Events.CACHE)) {
-            schemaEventHub.listen(Events.CACHE, event -> {
-                LOG.debug("Received event: {}", event);
-                event.checkArgs(String.class, Id.class);
-                Object[] args = event.args();
-                if (args[0].equals("invalid")) {
-                    Id id = (Id) args[1];
-                    Object value = this.idCache.get(id);
-                    if (value != null) {
-                        // Invalidate id cache
-                        this.idCache.invalidate(id);
-
-                        // Invalidate name cache
-                        SchemaElement schema = (SchemaElement) value;
-                        Id prefixedName = generateId(schema.type(),
-                                                     schema.name());
-                        this.nameCache.invalidate(prefixedName);
-                    }
-                    return true;
+        this.cacheEventListener = event -> {
+            LOG.debug("Graph {} received cache event: {}",
+                      this.graph(), event);
+            event.checkArgs(String.class, Id.class);
+            Object[] args = event.args();
+            if (args[0].equals("invalid")) {
+                Id id = (Id) args[1];
+                Object value = this.idCache.get(id);
+                if (value != null) {
+                    // Invalidate id cache
+                    this.idCache.invalidate(id);
+
+                    // Invalidate name cache
+                    SchemaElement schema = (SchemaElement) value;
+                    Id prefixedName = generateId(schema.type(),
+                                                 schema.name());
+                    this.nameCache.invalidate(prefixedName);
                 }
-                return false;
-            });
+                return true;
+            }
+            return false;
+        };
+        EventHub schemaEventHub = this.graph().schemaEventHub();
+        if (!schemaEventHub.containsListener(Events.CACHE)) {
+            schemaEventHub.listen(Events.CACHE, this.cacheEventListener);
         }
     }
 
+    private void unlistenChanges() {
+        // Unlisten store event
+        this.store().provider().unlisten(this.storeEventListener);
+
+        // Unlisten cache event
+        EventHub schemaEventHub = this.graph().schemaEventHub();
+        schemaEventHub.unlisten(Events.CACHE, this.cacheEventListener);
+    }
+
     private void resetCachedAllIfReachedCapacity() {
         if (this.idCache.size() >= this.idCache.capacity()) {
             LOG.warn("Schema cache reached capacity({}): {}",
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/serializer/BinarySerializer.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/serializer/BinarySerializer.java
index 1ae95cc02b..fb828d6929 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/serializer/BinarySerializer.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/serializer/BinarySerializer.java
@@ -536,6 +536,7 @@ private BinaryBackendEntry formatILDeletion(HugeIndex index) {
             case SEARCH_INDEX:
                 String idString = id.asString();
                 int idLength = idString.length();
+                // TODO: to improve, use BytesBuffer to generate a mask
                 for (int i = idLength - 1; i < 128; i++) {
                     BytesBuffer buffer = BytesBuffer.allocate(idLength + 1);
                     /*
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/AbstractBackendStoreProvider.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/AbstractBackendStoreProvider.java
index e717daadd8..ab4dc82ea9 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/AbstractBackendStoreProvider.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/AbstractBackendStoreProvider.java
@@ -21,6 +21,7 @@
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Future;
 
 import org.slf4j.Logger;
 
@@ -38,11 +39,20 @@ public abstract class AbstractBackendStoreProvider
 
     private String graph = null;
 
+    private EventHub storeEventHub = new EventHub("store");
+
     protected Map<String, BackendStore> stores = null;
 
-    protected EventHub storeEventHub = new EventHub("store");
+    protected final void notifyAndWaitEvent(String event) {
+        Future<?> future = this.storeEventHub.notify(event, this);
+        try {
+            future.get();
+        } catch (Throwable e) {
+            LOG.warn("Error when waiting for event execution: {}", event, e);
+        }
+    }
 
-    protected void checkOpened() {
+    protected final void checkOpened() {
         E.checkState(this.graph != null && this.stores != null,
                      "The BackendStoreProvider has not been opened");
     }
@@ -56,6 +66,11 @@ public void listen(EventListener listener) {
         this.storeEventHub.listen(EventHub.ANY_EVENT, listener);
     }
 
+    @Override
+    public void unlisten(EventListener listener) {
+        this.storeEventHub.unlisten(EventHub.ANY_EVENT, listener);
+    }
+
     @Override
     public String graph() {
         this.checkOpened();
@@ -85,7 +100,9 @@ public void init() {
         for (BackendStore store : this.stores.values()) {
             store.init();
         }
-        this.storeEventHub.notify(Events.STORE_INIT, this);
+        this.notifyAndWaitEvent(Events.STORE_INIT);
+
+        LOG.info("Graph '{}' has been initialized", this.graph);
     }
 
     @Override
@@ -94,7 +111,20 @@ public void clear() throws BackendException {
         for (BackendStore store : this.stores.values()) {
             store.clear();
         }
-        this.storeEventHub.notify(Events.STORE_CLEAR, this);
+        this.notifyAndWaitEvent(Events.STORE_CLEAR);
+
+        LOG.info("Graph '{}' has been cleared", this.graph);
+    }
+
+    @Override
+    public void truncate() {
+        this.checkOpened();
+        for (BackendStore store : this.stores.values()) {
+            store.truncate();
+        }
+        this.notifyAndWaitEvent(Events.STORE_TRUNCATE);
+
+        LOG.info("Graph '{}' has been truncated", this.graph);
     }
 
     @Override
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStore.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStore.java
index a217158df6..5641c01a3b 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStore.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStore.java
@@ -47,6 +47,9 @@ public interface BackendStore {
     public void init();
     public void clear();
 
+    // Delete all data of database (keep table structure)
+    public void truncate();
+
     // Add/delete data
     public void mutate(BackendMutation mutation);
 
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStoreProvider.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStoreProvider.java
index 52aba0bfbc..c1b6cb1a1a 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStoreProvider.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/BackendStoreProvider.java
@@ -46,5 +46,9 @@ public interface BackendStoreProvider {
 
     public void clear();
 
+    public void truncate();
+
     public void listen(EventListener listener);
+
+    public void unlisten(EventListener listener);
 }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStore.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStore.java
index 54c0149c27..be4eeb7a91 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStore.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStore.java
@@ -19,6 +19,7 @@
 
 package com.baidu.hugegraph.backend.store.memory;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
@@ -84,6 +85,10 @@ protected void registerTableManager(HugeType type, InMemoryDBTable table) {
         this.tables.put(type, table);
     }
 
+    protected Collection<InMemoryDBTable> tables() {
+        return this.tables.values();
+    }
+
     @Override
     protected final InMemoryDBTable table(HugeType type) {
         assert type != null;
@@ -165,33 +170,39 @@ public BackendStoreProvider provider() {
 
     @Override
     public void open(HugeConfig config) {
-        LOG.debug("open()");
-        /*
-         * Memory store need to init some system property,
-         * like task related propertykeys and vertexlabels
-         */
-        this.provider.init();
+        LOG.debug("Store opened: {}", this.store);
     }
 
     @Override
     public void close() throws BackendException {
-        LOG.debug("close()");
+        LOG.debug("Store closed: {}", this.store);
     }
 
     @Override
     public void init() {
-        LOG.info("init()");
-        for (InMemoryDBTable table : this.tables.values()) {
+        for (InMemoryDBTable table : this.tables()) {
             table.init(null);
         }
+
+        LOG.debug("Store initialized: {}", this.store);
     }
 
     @Override
     public void clear() {
-        LOG.info("clear()");
-        for (InMemoryDBTable table : this.tables.values()) {
+        for (InMemoryDBTable table : this.tables()) {
+            table.clear(null);
+        }
+
+        LOG.debug("Store cleared: {}", this.store);
+    }
+
+    @Override
+    public void truncate() {
+        for (InMemoryDBTable table : this.tables()) {
             table.clear(null);
         }
+
+        LOG.debug("Store truncated: {}", this.store);
     }
 
     @Override
@@ -224,12 +235,11 @@ public String toString() {
 
     public static class InMemorySchemaStore extends InMemoryDBStore {
 
-        private final LocalCounter counter;
+        private final LocalCounter counter = new LocalCounter();
 
         public InMemorySchemaStore(BackendStoreProvider provider,
                                    String database, String store) {
             super(provider, database, store);
-            this.counter = new LocalCounter();
 
             registerTableManager(HugeType.VERTEX_LABEL,
                                  new InMemoryDBTable(HugeType.VERTEX_LABEL));
@@ -257,6 +267,18 @@ public void increaseCounter(HugeType type, long increment) {
         public long getCounter(HugeType type) {
             return this.counter.getCounter(type);
         }
+
+        @Override
+        public void clear() {
+            this.counter.reset();
+            super.clear();
+        }
+
+        @Override
+        public void truncate() {
+            this.counter.reset();
+            super.truncate();
+        }
     }
 
     public static class InMemoryGraphStore extends InMemoryDBStore {
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStoreProvider.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStoreProvider.java
index f6cda92ba4..a0363dfa4f 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStoreProvider.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBStoreProvider.java
@@ -26,6 +26,7 @@
 import com.baidu.hugegraph.backend.store.BackendStore;
 import com.baidu.hugegraph.backend.store.memory.InMemoryDBStore.InMemoryGraphStore;
 import com.baidu.hugegraph.backend.store.memory.InMemoryDBStore.InMemorySchemaStore;
+import com.baidu.hugegraph.util.Events;
 
 public class InMemoryDBStoreProvider extends AbstractBackendStoreProvider {
 
@@ -52,6 +53,18 @@ private InMemoryDBStoreProvider(String graph) {
         this.open(graph);
     }
 
+    @Override
+    public void open(String graph) {
+        super.open(graph);
+        /*
+         * Memory store need to init some system property,
+         * like task related property-keys and vertex-labels.
+         * don't notify from store.open() due to task-tx will
+         * call it again and cause dead
+         */
+        this.notifyAndWaitEvent(Events.STORE_INIT);
+    }
+
     @Override
     protected BackendStore newSchemaStore(String store) {
         return new InMemorySchemaStore(this, this.graph(), store);
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBTables.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBTables.java
index 37df581e93..5ebb9ca02e 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBTables.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/store/memory/InMemoryDBTables.java
@@ -345,16 +345,21 @@ private Iterator<BackendEntry> betweenQuery(Id indexLabelId,
                                                     Object keyMin,
                                                     boolean keyMinEq) {
             NavigableMap<Id, BackendEntry> rs = this.store();
-            Map<Id, BackendEntry> results = new HashMap<>();
 
             Id min = HugeIndex.formatIndexId(HugeType.RANGE_INDEX,
                                              indexLabelId, keyMin);
             Id max = HugeIndex.formatIndexId(HugeType.RANGE_INDEX,
                                              indexLabelId, keyMax);
+
+            max = keyMaxEq ? rs.floorKey(max) : rs.lowerKey(max);
+            if (max == null) {
+                return Collections.emptyIterator();
+            }
+
+            Map<Id, BackendEntry> results = new HashMap<>();
             Map.Entry<Id, BackendEntry> entry = keyMinEq ?
                                                 rs.ceilingEntry(min) :
                                                 rs.higherEntry(min);
-            max = keyMaxEq ? rs.floorKey(max) : rs.lowerKey(max);
             while (entry != null) {
                 if (entry.getKey().compareTo(max) > 0) {
                     break;
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/tx/GraphTransaction.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/tx/GraphTransaction.java
index 11f2177032..9c1cddb15e 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/tx/GraphTransaction.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/backend/tx/GraphTransaction.java
@@ -741,7 +741,8 @@ public <V> void removeVertexProperty(HugeVertexProperty<V> prop) {
             return;
         }
         // Check is updating property of added/removed vertex
-        E.checkArgument(!this.addedVertexes.containsKey(vertex.id()),
+        E.checkArgument(!this.addedVertexes.containsKey(vertex.id()) ||
+                        this.updatedVertexes.containsKey(vertex.id()),
                         "Can't remove property '%s' for adding-state vertex",
                         prop.key());
         E.checkArgument(!this.removedVertexes.containsKey(vertex.id()),
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/config/CoreOptions.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/config/CoreOptions.java
index ffe41771b0..1843e3a53f 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/config/CoreOptions.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/config/CoreOptions.java
@@ -103,6 +103,15 @@ public static synchronized CoreOptions instance() {
                     0
             );
 
+    public static final ConfigOption<Long> TASK_WAIT_TIMEOUT =
+            new ConfigOption<>(
+                    "task.wait_timeout",
+                    "Timeout in seconds for waiting for the task to complete," +
+                    "such as when truncating or clearing the backend.",
+                    rangeInt(0L, Long.MAX_VALUE),
+                    10L
+            );
+
     public static final ConfigOption<String> VERTEX_DEFAULT_LABEL =
             new ConfigOption<>(
                     "vertex.default_label",
@@ -157,6 +166,14 @@ public static synchronized CoreOptions instance() {
                     100000
             );
 
+    public static final ConfigOption<Boolean> SCHEMA_SYNC_DELETION =
+            new ConfigOption<>(
+                    "schema.sync_deletion",
+                    "Whether to delete schema synchronously.",
+                    disallowEmpty(),
+                    false
+            );
+
     public static final ConfigOption<Integer> VERTEX_CACHE_CAPACITY =
             new ConfigOption<>(
                     "vertex.cache_capacity",
@@ -248,11 +265,4 @@ public static synchronized CoreOptions instance() {
                     disallowEmpty(),
                     "smart"
             );
-    public static final ConfigOption<Boolean> SCHEMA_SYNC_DELETION =
-            new ConfigOption<>(
-                    "schema.sync_deletion",
-                    "Whether to delete schema synchronously.",
-                    disallowEmpty(),
-                    false
-            );
 }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/job/schema/SchemaCallable.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/job/schema/SchemaCallable.java
index 70e8398afe..03f7ec624c 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/job/schema/SchemaCallable.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/job/schema/SchemaCallable.java
@@ -58,6 +58,7 @@ protected static void removeIndexLabelFromBaseLabel(SchemaTransaction tx,
             assert baseType == HugeType.EDGE_LABEL;
             schemaLabel = tx.getEdgeLabel(baseValue);
         }
+        assert schemaLabel != null;
         schemaLabel.removeIndexLabel(label.id());
         updateSchema(tx, schemaLabel);
     }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/schema/builder/IndexLabelBuilder.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/schema/builder/IndexLabelBuilder.java
index 95b025d2d3..86969c04ab 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/schema/builder/IndexLabelBuilder.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/schema/builder/IndexLabelBuilder.java
@@ -31,6 +31,7 @@
 import com.baidu.hugegraph.backend.id.IdGenerator;
 import com.baidu.hugegraph.backend.tx.GraphTransaction;
 import com.baidu.hugegraph.backend.tx.SchemaTransaction;
+import com.baidu.hugegraph.config.CoreOptions;
 import com.baidu.hugegraph.exception.ExistedException;
 import com.baidu.hugegraph.exception.NotSupportException;
 import com.baidu.hugegraph.schema.EdgeLabel;
@@ -39,7 +40,6 @@
 import com.baidu.hugegraph.schema.SchemaElement;
 import com.baidu.hugegraph.schema.SchemaLabel;
 import com.baidu.hugegraph.schema.VertexLabel;
-import com.baidu.hugegraph.task.TaskScheduler;
 import com.baidu.hugegraph.type.HugeType;
 import com.baidu.hugegraph.type.define.Cardinality;
 import com.baidu.hugegraph.type.define.DataType;
@@ -136,10 +136,10 @@ public IndexLabel create() {
             E.checkNotNull(indexLabel, "index label");
             return indexLabel;
         }
-        TaskScheduler scheduler = this.transaction.graph().taskScheduler();
+        HugeGraph graph = this.transaction.graph();
+        long timeout = graph.configuration().get(CoreOptions.TASK_WAIT_TIMEOUT);
         try {
-            // TODO: read timeout from config file
-            scheduler.waitUntilTaskCompleted(task, 30L);
+            graph.taskScheduler().waitUntilTaskCompleted(task, timeout);
         } catch (TimeoutException e) {
             throw new HugeException(
                       "Failed to wait index-creating task completed", e);
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/task/TaskScheduler.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/task/TaskScheduler.java
index 2be5c46165..60c1edd8ce 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/task/TaskScheduler.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/task/TaskScheduler.java
@@ -23,6 +23,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
@@ -40,6 +41,7 @@
 import com.baidu.hugegraph.backend.query.ConditionQuery;
 import com.baidu.hugegraph.backend.store.BackendStore;
 import com.baidu.hugegraph.backend.tx.GraphTransaction;
+import com.baidu.hugegraph.event.EventListener;
 import com.baidu.hugegraph.exception.NotFoundException;
 import com.baidu.hugegraph.iterator.ExtendableIterator;
 import com.baidu.hugegraph.iterator.MapperIterator;
@@ -56,6 +58,7 @@
 import com.baidu.hugegraph.util.E;
 import com.baidu.hugegraph.util.Events;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
 
 public class TaskScheduler {
 
@@ -63,6 +66,7 @@ public class TaskScheduler {
     private final ExecutorService taskExecutor;
     private final ExecutorService dbExecutor;
 
+    private final EventListener eventListener;
     private final Map<Id, HugeTask<?>> tasks;
 
     private volatile TaskTransaction taskTx;
@@ -84,7 +88,7 @@ public TaskScheduler(HugeGraph graph,
 
         this.taskTx = null;
 
-        this.listenChanges();
+        this.eventListener = this.listenChanges();
     }
 
     public HugeGraph graph() {
@@ -101,7 +105,9 @@ private TaskTransaction tx() {
             synchronized (this) {
                 if (this.taskTx == null) {
                     BackendStore store = this.graph.loadSystemStore();
-                    this.taskTx = new TaskTransaction(this.graph, store);
+                    TaskTransaction tx = new TaskTransaction(this.graph, store);
+                    assert this.taskTx == null; // may be reentrant?
+                    this.taskTx = tx;
                 }
             }
         }
@@ -109,15 +115,34 @@ private TaskTransaction tx() {
         return this.taskTx;
     }
 
-    private void listenChanges() {
-        // Listen store event: "store.init"
-        this.graph.loadSystemStore().provider().listen(event -> {
-            if (Events.STORE_INIT.equals(event.name())) {
-                this.submit(() -> this.tx().initSchema());
+    private EventListener listenChanges() {
+        // Listen store event: "store.init", "store.truncate"
+        Set<String> storeEvents = ImmutableSet.of(Events.STORE_INIT,
+                                                  Events.STORE_TRUNCATE);
+        EventListener eventListener = event -> {
+            /*
+             * Ensure schema cache has been cleared before calling initSchema()
+             * otherwise we would see schema from cache even if store truncated
+             */
+            if (storeEvents.contains(event.name())) {
+                this.call(() -> this.tx().initSchema());
+                // Ensure we receive notify after the cache-schema (trick)
+                this.relistenChanges();
                 return true;
             }
             return false;
-        });
+        };
+        this.graph.loadSystemStore().provider().listen(eventListener);
+        return eventListener;
+    }
+
+    private void unlistenChanges() {
+        this.graph.loadSystemStore().provider().unlisten(this.eventListener);
+    }
+
+    private void relistenChanges() {
+        this.graph.loadSystemStore().provider().unlisten(this.eventListener);
+        this.graph.loadSystemStore().provider().listen(this.eventListener);
     }
 
     public <V> void restoreTasks() {
@@ -167,7 +192,7 @@ protected void remove(Id id) {
 
     public <V> void save(HugeTask<V> task) {
         E.checkArgumentNotNull(task, "Task can't be null");
-        this.submit(() -> {
+        this.call(() -> {
             // Construct vertex from task
             HugeVertex vertex = this.tx().constructVertex(task);
             // Delete the old record if exist
@@ -186,8 +211,9 @@ public <V> void save(HugeTask<V> task) {
     }
 
     public boolean close() {
+        this.unlistenChanges();
         if (!this.dbExecutor.isShutdown()) {
-            this.submit(() -> {
+            this.call(() -> {
                 this.tx().close();
                 this.graph.closeTx();
             });
@@ -216,7 +242,6 @@ public <V> Iterator<HugeTask<V>> tasks(List<Id> ids) {
                 taskIdsNotInMem.add(id);
             }
         }
-        @SuppressWarnings("unchecked")
         ExtendableIterator<HugeTask<V>> iterator;
         if (taskInMem.isEmpty()) {
             iterator = new ExtendableIterator<>();
@@ -228,7 +253,7 @@ public <V> Iterator<HugeTask<V>> tasks(List<Id> ids) {
     }
 
     public <V> HugeTask<V> findTask(Id id) {
-        HugeTask<V> result =  this.submit(() -> {
+        HugeTask<V> result =  this.call(() -> {
             HugeTask<V> task = null;
             Iterator<Vertex> vertices = this.tx().queryVertices(id);
             if (vertices.hasNext()) {
@@ -245,7 +270,7 @@ public <V> HugeTask<V> findTask(Id id) {
 
     public <V> Iterator<HugeTask<V>> findTasks(List<Id> ids) {
         Object[] idArray = ids.toArray(new Id[ids.size()]);
-        return this.submit(() -> {
+        return this.call(() -> {
             Iterator<Vertex> vertices = this.tx().queryVertices(idArray);
             return new MapperIterator<>(vertices, HugeTask::fromVertex);
         });
@@ -276,7 +301,7 @@ public <V> HugeTask<V> deleteTask(Id id) {
                          id, task.status());
             this.remove(id);
         }
-        return this.submit(() -> {
+        return this.call(() -> {
             HugeTask<V> result = null;
             Iterator<Vertex> vertices = this.tx().queryVertices(id);
             if (vertices.hasNext()) {
@@ -312,6 +337,29 @@ public <V> HugeTask<V> waitUntilTaskCompleted(Id id, long seconds)
                   "Task '%s' was not completed in %s seconds", id, seconds));
     }
 
+    public void waitUntilAllTasksCompleted(long seconds)
+                                           throws TimeoutException {
+        long t100ms = seconds * 10L;
+        int taskSize = 0;
+        for (long pass = 0;; pass++) {
+            taskSize = this.pendingTasks();
+            if (taskSize == 0) {
+                return;
+            }
+            if (pass >= t100ms) {
+                break;
+            }
+            try {
+                Thread.sleep(100L);
+            } catch (InterruptedException ignored) {
+                // Ignore InterruptedException
+            }
+        }
+        throw new TimeoutException(String.format(
+                  "There are still %d incomplete tasks after %s seconds",
+                  taskSize, seconds));
+    }
+
     private <V> Iterator<HugeTask<V>> queryTask(String key, Object value,
                                                 long limit) {
         return this.queryTask(ImmutableMap.of(key, value), limit);
@@ -319,7 +367,7 @@ private <V> Iterator<HugeTask<V>> queryTask(String key, Object value,
 
     private <V> Iterator<HugeTask<V>> queryTask(Map<String, Object> conditions,
                                                 long limit) {
-        return this.submit(() -> {
+        return this.call(() -> {
             ConditionQuery query = new ConditionQuery(HugeType.VERTEX);
             VertexLabel vl = this.graph.vertexLabel(TaskTransaction.TASK);
             query.eq(HugeKeys.LABEL, vl.id());
@@ -336,11 +384,12 @@ private <V> Iterator<HugeTask<V>> queryTask(Map<String, Object> conditions,
         });
     }
 
-    private <V> V submit(Runnable runnable) {
-        return this.submit(Executors.callable(runnable, null));
+    private <V> V call(Runnable runnable) {
+        return this.call(Executors.callable(runnable, null));
     }
 
-    private <V> V submit(Callable<V> callable) {
+    private <V> V call(Callable<V> callable) {
+        // Ensure all db operations are executed in dbExecutor thread(s)
         try {
             return this.dbExecutor.submit(callable).get();
         } catch (Exception e) {
@@ -358,6 +407,10 @@ public TaskTransaction(HugeGraph graph, BackendStore store) {
         }
 
         public HugeVertex constructVertex(HugeTask<?> task) {
+            if (this.graph().schemaTransaction().getVertexLabel(TASK) == null) {
+                throw new HugeException("Schema is missing for task(%s) '%s'",
+                                        task.id(), task.name());
+            }
             return this.constructVertex(false, task.asArray());
         }
 
@@ -375,18 +428,16 @@ protected void initSchema() {
                 return;
             }
 
-            SchemaManager schema = graph.schema();
-
             String[] properties = this.initProperties();
 
             // Create vertex label '~task'
-            label = schema.vertexLabel(TASK)
-                          .properties(properties)
-                          .useCustomizeNumberId()
-                          .nullableKeys(P.DESCRIPTION, P.UPDATE,
-                                        P.INPUT, P.RESULT, P.DEPENDENCIES)
-                          .enableLabelIndex(true)
-                          .build();
+            label = graph.schema().vertexLabel(TASK)
+                         .properties(properties)
+                         .useCustomizeNumberId()
+                         .nullableKeys(P.DESCRIPTION, P.UPDATE,
+                                       P.INPUT, P.RESULT, P.DEPENDENCIES)
+                         .enableLabelIndex(true)
+                         .build();
             graph.schemaTransaction().addVertexLabel(label);
 
             // Create index
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeGraphStepStrategy.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeGraphStepStrategy.java
index 398fa1c650..1aea7079fc 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeGraphStepStrategy.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeGraphStepStrategy.java
@@ -60,7 +60,7 @@ public void apply(Traversal.Admin<?, ?> traversal) {
             // TODO: support order-by optimize
             // TraversalUtil.extractOrder(newStep, traversal);
 
-            TraversalUtil.extractRange(newStep, traversal);
+            TraversalUtil.extractRange(newStep, traversal, false);
 
             TraversalUtil.extractCount(newStep, traversal);
         }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeVertexStepStrategy.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeVertexStepStrategy.java
index d0b479aaa2..7bbf579c59 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeVertexStepStrategy.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/HugeVertexStepStrategy.java
@@ -59,7 +59,7 @@ public void apply(final Traversal.Admin<?, ?> traversal) {
             // TODO: support order-by optimize
             // TraversalUtil.extractOrder(newStep, traversal);
 
-            TraversalUtil.extractRange(newStep, traversal);
+            TraversalUtil.extractRange(newStep, traversal, true);
 
             TraversalUtil.extractCount(newStep, traversal);
         }
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/TraversalUtil.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/TraversalUtil.java
index d249f685fa..6765eacb78 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/TraversalUtil.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/traversal/optimize/TraversalUtil.java
@@ -131,16 +131,15 @@ public static void extractOrder(Step<?, ?> newStep,
     }
 
     public static void extractRange(Step<?, ?> newStep,
-                                    Traversal.Admin<?, ?> traversal) {
+                                    Traversal.Admin<?, ?> traversal,
+                                    boolean extractOnlyLimit) {
+        QueryHolder holder = (QueryHolder) newStep;
         Step<?, ?> step = newStep;
         do {
             step = step.getNextStep();
             if (step instanceof RangeGlobalStep) {
-                QueryHolder holder = (QueryHolder) newStep;
                 @SuppressWarnings("unchecked")
                 RangeGlobalStep<Object> range = (RangeGlobalStep<Object>) step;
-                long limit = holder.setRange(range.getLowRange(),
-                                             range.getHighRange());
                 /*
                  * NOTE: keep the step to limit results after query from DB
                  * due to `limit`(in DB) may not be implemented accurately.
@@ -148,9 +147,16 @@ public static void extractRange(Step<?, ?> newStep,
                  */
                 // TraversalHelper.copyLabels(step, newStep, false);
                 // traversal.removeStep(step);
-                Step<Object, Object> newRange = new RangeGlobalStep<>(traversal,
-                                                                      0, limit);
-                TraversalHelper.replaceStep(range, newRange, traversal);
+                if (extractOnlyLimit) {
+                    // May need to retain offset for multiple sub-queries
+                    holder.setRange(0, range.getHighRange());
+                } else {
+                    long limit = holder.setRange(range.getLowRange(),
+                                                 range.getHighRange());
+                    RangeGlobalStep<Object> newRange = new RangeGlobalStep<>(
+                                                       traversal, 0, limit);
+                    TraversalHelper.replaceStep(range, newRange, traversal);
+                }
             }
         } while (step instanceof RangeGlobalStep ||
                  step instanceof IdentityStep ||
diff --git a/hugegraph-core/src/main/java/com/baidu/hugegraph/util/Events.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/util/Events.java
index 4609da83d3..0e594e5fef 100644
--- a/hugegraph-core/src/main/java/com/baidu/hugegraph/util/Events.java
+++ b/hugegraph-core/src/main/java/com/baidu/hugegraph/util/Events.java
@@ -27,4 +27,5 @@ public final class Events {
     public static final String STORE_CLOSE = "store.close";
     public static final String STORE_INIT = "store.init";
     public static final String STORE_CLEAR = "store.clear";
+    public static final String STORE_TRUNCATE = "store.truncate";
 }
diff --git a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseSessions.java b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseSessions.java
index 1cbd884cf0..3f2ff14962 100644
--- a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseSessions.java
+++ b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseSessions.java
@@ -29,6 +29,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.concurrent.Future;
 
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.hbase.HBaseConfiguration;
@@ -172,6 +173,19 @@ public void dropTable(String table) throws IOException {
         }
     }
 
+    public Future<Void> truncateTable(String table) throws IOException {
+        assert this.existsTable(table);
+        TableName tableName = TableName.valueOf(this.namespace, table);
+        try(Admin admin = this.hbase.getAdmin()) {
+            try {
+                admin.disableTable(tableName);
+            } catch (TableNotEnabledException ignored) {
+                // pass
+            }
+            return admin.truncateTableAsync(tableName, false);
+        }
+    }
+
     public long storeSize(String table) throws IOException {
         long total = 0;
         try(Admin admin = this.hbase.getAdmin()) {
diff --git a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseStore.java b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseStore.java
index 0db9184494..6019b4c686 100644
--- a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseStore.java
+++ b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseStore.java
@@ -225,6 +225,8 @@ public void init() {
                           e, table, this.store);
             }
         }
+
+        LOG.debug("Store initialized: {}", this.store);
     }
 
     @Override
@@ -267,6 +269,26 @@ public void clear() {
                           e, this.namespace, this.store);
             }
         }
+
+        LOG.debug("Store cleared: {}", this.store);
+    }
+
+    @Override
+    public void truncate() {
+        this.checkOpened();
+
+        // Truncate tables
+        for (String table : this.tableNames()) {
+            try {
+                this.sessions.truncateTable(table);
+            } catch (IOException e) {
+                throw new BackendException(
+                          "Failed to truncate table '%s' for '%s'",
+                          e, table, this.store);
+            }
+        }
+
+        LOG.debug("Store truncated: {}", this.store);
     }
 
     @Override
diff --git a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseTables.java b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseTables.java
index 7b6fc7d067..06fbc916a2 100644
--- a/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseTables.java
+++ b/hugegraph-hbase/src/main/java/com/baidu/hugegraph/backend/store/hbase/HbaseTables.java
@@ -228,7 +228,7 @@ protected void parseRowColumns(Result row, BackendEntry entry,
         }
     }
 
-    public static class SearchIndex extends SecondaryIndex {
+    public static class SearchIndex extends IndexTable {
 
         public static final String TABLE = "fi";
 
diff --git a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStore.java b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStore.java
index 5884829fb9..2cbd485fb4 100644
--- a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStore.java
+++ b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStore.java
@@ -20,7 +20,10 @@
 package com.baidu.hugegraph.backend.store.mysql;
 
 import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -79,10 +82,6 @@ protected MysqlSessions openSessionPool(HugeConfig config) {
         return new MysqlSessions(config, this.database, this.store);
     }
 
-    public Map<HugeType, MysqlTable> tables() {
-        return this.tables;
-    }
-
     @Override
     public String store() {
         return this.store;
@@ -159,7 +158,7 @@ public void init() {
         this.checkSessionConnected();
         this.initTables();
 
-        LOG.info("Store initialized: {}", this.store);
+        LOG.debug("Store initialized: {}", this.store);
     }
 
     @Override
@@ -173,7 +172,15 @@ public void clear() {
             this.sessions.dropDatabase();
         }
 
-        LOG.info("Store cleared: {}", this.store);
+        LOG.debug("Store cleared: {}", this.store);
+    }
+
+    @Override
+    public void truncate() {
+        this.checkSessionConnected();
+
+        this.truncateTables();
+        LOG.debug("Store truncated: {}", this.store);
     }
 
     @Override
@@ -273,18 +280,29 @@ public String toString() {
 
     protected void initTables() {
         MysqlSessions.Session session = this.sessions.session();
-        for (MysqlTable table : this.tables.values()) {
+        for (MysqlTable table : this.tables()) {
             table.init(session);
         }
     }
 
     protected void clearTables() {
         MysqlSessions.Session session = this.sessions.session();
-        for (MysqlTable table : this.tables.values()) {
+        for (MysqlTable table : this.tables()) {
             table.clear(session);
         }
     }
 
+    protected void truncateTables() {
+        MysqlSessions.Session session = this.sessions.session();
+        for (MysqlTable table : this.tables()) {
+            table.truncate(session);
+        }
+    }
+
+    protected Collection<MysqlTable> tables() {
+        return this.tables.values();
+    }
+
     @Override
     protected final MysqlTable table(HugeType type) {
         assert type != null;
@@ -340,19 +358,10 @@ public MysqlSchemaStore(BackendStoreProvider provider,
         }
 
         @Override
-        protected void initTables() {
-            super.initTables();
-
-            MysqlSessions.Session session = super.sessions.session();
-            this.counters.init(session);
-        }
-
-        @Override
-        protected void clearTables() {
-            super.clearTables();
-
-            MysqlSessions.Session session = super.sessions.session();
-            this.counters.clear(session);
+        protected Collection<MysqlTable> tables() {
+            List<MysqlTable> tables = new ArrayList<>(super.tables());
+            tables.add(this.counters);
+            return tables;
         }
 
         @Override
diff --git a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStoreProvider.java b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStoreProvider.java
index 9a54e156db..ad1c4f9026 100644
--- a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStoreProvider.java
+++ b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlStoreProvider.java
@@ -55,7 +55,7 @@ public void clear() throws BackendException {
         if (itor.hasNext()) {
             itor.next().clear();
         }
-        this.storeEventHub.notify(Events.STORE_CLEAR, this);
+        this.notifyAndWaitEvent(Events.STORE_CLEAR);
     }
 
     @Override
diff --git a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlTable.java b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlTable.java
index 723e5ba30c..b571db93e4 100644
--- a/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlTable.java
+++ b/hugegraph-mysql/src/main/java/com/baidu/hugegraph/backend/store/mysql/MysqlTable.java
@@ -66,8 +66,17 @@ public void init(MysqlSessions.Session session) {
         this.createTable(session, this.tableDefine());
     }
 
-    public void createTable(MysqlSessions.Session session,
-                            TableDefine tableDefine) {
+    @Override
+    public void clear(MysqlSessions.Session session) {
+        this.dropTable(session);
+    }
+
+    public void truncate(MysqlSessions.Session session) {
+        this.truncateTable(session);
+    }
+
+    protected void createTable(MysqlSessions.Session session,
+                               TableDefine tableDefine) {
         StringBuilder sql = new StringBuilder();
         sql.append("CREATE TABLE IF NOT EXISTS ");
         sql.append(this.table()).append(" (");
@@ -100,18 +109,28 @@ public void createTable(MysqlSessions.Session session,
         }
     }
 
-    public void dropTable(MysqlSessions.Session session) {
+    protected void dropTable(MysqlSessions.Session session) {
         LOG.debug("Drop table: {}", this.table());
-        StringBuilder sql = new StringBuilder();
-        sql.append("DROP TABLE IF EXISTS ").append(this.table()).append(";");
+        String sql = String.format("DROP TABLE IF EXISTS %s;", this.table());
         try {
-            session.execute(sql.toString());
+            session.execute(sql);
         } catch (SQLException e) {
             throw new BackendException("Failed to drop table with '%s'",
                                        e, sql);
         }
     }
 
+    protected void truncateTable(MysqlSessions.Session session) {
+        LOG.debug("Truncate table: {}", this.table());
+        String sql = String.format("TRUNCATE TABLE %s;", this.table());
+        try {
+            session.execute(sql);
+        } catch (SQLException e) {
+            throw new BackendException("Failed to truncate table with '%s'",
+                                       e, sql);
+        }
+    }
+
     protected List<HugeKeys> idColumnName() {
         return this.tableDefine().keys();
     }
@@ -528,10 +547,6 @@ protected void appendPartition(StringBuilder delete) {
         // pass
     }
 
-    public void clear(MysqlSessions.Session session) {
-        this.dropTable(session);
-    }
-
     public static String formatKey(HugeKeys key) {
         return key.name();
     }
diff --git a/hugegraph-palo/src/main/java/com/baidu/hugegraph/backend/store/palo/PaloStore.java b/hugegraph-palo/src/main/java/com/baidu/hugegraph/backend/store/palo/PaloStore.java
index 1bee5ec503..04bde0acb3 100644
--- a/hugegraph-palo/src/main/java/com/baidu/hugegraph/backend/store/palo/PaloStore.java
+++ b/hugegraph-palo/src/main/java/com/baidu/hugegraph/backend/store/palo/PaloStore.java
@@ -47,7 +47,7 @@ protected PaloSessions openSessionPool(HugeConfig config) {
     }
 
     private List<String> tableNames() {
-        return this.tables().values().stream().map(BackendTable::table)
+        return this.tables().stream().map(BackendTable::table)
                    .collect(Collectors.toList());
     }
 }
diff --git a/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBStore.java b/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBStore.java
index 64ebd2e9ee..836ac0aa16 100644
--- a/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBStore.java
+++ b/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBStore.java
@@ -312,7 +312,7 @@ public void init() {
             this.createTable(db, table);
         }
 
-        LOG.info("Store initialized: {}", this.store);
+        LOG.debug("Store initialized: {}", this.store);
     }
 
     private void createTable(RocksDBSessions db, String table) {
@@ -339,7 +339,7 @@ public void clear() {
             this.dropTable(db, table);
         }
 
-        LOG.info("Store cleared: {}", this.store);
+        LOG.debug("Store cleared: {}", this.store);
     }
 
     private void dropTable(RocksDBSessions db, String table) {
@@ -356,6 +356,16 @@ private void dropTable(RocksDBSessions db, String table) {
         }
     }
 
+    @Override
+    public void truncate() {
+        this.checkOpened();
+
+        this.clear();
+        this.init();
+
+        LOG.debug("Store truncated: {}", this.store);
+    }
+
     @Override
     public void beginTx() {
         // pass
diff --git a/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBTables.java b/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBTables.java
index 300bb46ade..d7cc2beb6a 100644
--- a/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBTables.java
+++ b/hugegraph-rocksdb/src/main/java/com/baidu/hugegraph/backend/store/rocksdb/RocksDBTables.java
@@ -138,16 +138,16 @@ public static Edge in(String database) {
         }
     }
 
-    public static class SecondaryIndex extends RocksDBTable {
+    public static class IndexTable extends RocksDBTable {
 
-        public static final String TABLE = "si";
-
-        public SecondaryIndex(String database) {
-            this(database, TABLE);
+        public IndexTable(String database, String table) {
+            super(database, table);
         }
 
-        protected SecondaryIndex(String database, String table) {
-            super(database, table);
+        @Override
+        public void eliminate(Session session, BackendEntry entry) {
+            assert entry.columns().size() == 1;
+            super.delete(session, entry);
         }
 
         @Override
@@ -163,7 +163,16 @@ public void delete(Session session, BackendEntry entry) {
         }
     }
 
-    public static class SearchIndex extends SecondaryIndex {
+    public static class SecondaryIndex extends IndexTable {
+
+        public static final String TABLE = "si";
+
+        public SecondaryIndex(String database) {
+            super(database, TABLE);
+        }
+    }
+
+    public static class SearchIndex extends IndexTable {
 
         public static final String TABLE = "fi";
 
@@ -172,7 +181,7 @@ public SearchIndex(String database) {
         }
     }
 
-    public static class RangeIndex extends RocksDBTable {
+    public static class RangeIndex extends IndexTable {
 
         public static final String TABLE = "ri";
 
@@ -233,16 +242,5 @@ protected BackendColumnIterator queryByCond(Session session,
                 return session.scan(this.table(), begin, end, type);
             }
         }
-
-        @Override
-        public void delete(Session session, BackendEntry entry) {
-            /*
-             * Only delete index by label will come here
-             * Regular index delete will call eliminate()
-             */
-            for (BackendEntry.BackendColumn column : entry.columns()) {
-                session.delete(this.table(), column.name);
-            }
-        }
     }
 }
diff --git a/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTables.java b/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTables.java
index 5d72ddcf61..4e1305cb9d 100644
--- a/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTables.java
+++ b/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTables.java
@@ -114,7 +114,8 @@ private static void removeLabelIndex(CassandraSessionPool.Session session,
      * Query data from label index table if just want to query by label
      */
     private static Query queryByLabelIndex(
-            CassandraSessionPool.Session session, String table, Query query) {
+                         CassandraSessionPool.Session session,
+                         String table, Query query) {
         Set<Condition> conditions = query.conditions();
 
         if (!(query instanceof ConditionQuery) || conditions.isEmpty()) {
@@ -145,8 +146,8 @@ private static Query queryByLabelIndex(
     }
 
     private static Set<String> queryByLabelIndex(
-            CassandraSessionPool.Session session, String table, Id label) {
-
+                               CassandraSessionPool.Session session,
+                               String table, Id label) {
         Select select = QueryBuilder.select().from(table);
         select.where(CassandraTable.formatEQ(HugeKeys.LABEL, label.asLong()));
 
@@ -170,22 +171,28 @@ public Vertex(String store) {
             super(store);
         }
 
+        private String indexTable() {
+            return joinTableName(this.table(), CassandraTables.LABEL_INDEX);
+        }
+
         @Override
         protected void createIndex(CassandraSessionPool.Session session,
                                    String indexLabel, HugeKeys column) {
             createIndexTable(session, this.indexTable());
         }
 
-        private String indexTable() {
-            return joinTableName(this.table(), CassandraTables.LABEL_INDEX);
-        }
-
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             session.execute(SchemaBuilder.dropTable(indexTable()).ifExists());
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            session.execute(QueryBuilder.truncate(indexTable()));
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
@@ -218,6 +225,10 @@ public Edge(String store, Directions direction) {
             super(store, direction);
         }
 
+        private String indexTable() {
+            return joinTableName(this.table(), CassandraTables.LABEL_INDEX);
+        }
+
         @Override
         protected void createIndex(CassandraSessionPool.Session session,
                                    String indexLabel, HugeKeys column) {
@@ -225,16 +236,20 @@ protected void createIndex(CassandraSessionPool.Session session,
             createIndexTable(session, this.indexTable());
         }
 
-        private String indexTable() {
-            return joinTableName(this.table(), CassandraTables.LABEL_INDEX);
-        }
-
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             session.execute(SchemaBuilder.dropTable(indexTable()).ifExists());
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            if (this.direction() == Directions.OUT) {
+                session.execute(QueryBuilder.truncate(indexTable()));
+            }
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
@@ -340,6 +355,10 @@ public void dropTable(CassandraSessionPool.Session session) {
             session.execute(SchemaBuilder.dropTable(this.table).ifExists());
         }
 
+        public void truncateTable(CassandraSessionPool.Session session) {
+            session.execute(QueryBuilder.truncate(this.table));
+        }
+
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
             Update update = QueryBuilder.update(this.table);
@@ -398,9 +417,11 @@ public Query query(CassandraSessionPool.Session session, Query query) {
         }
 
         private static Set<Integer> queryByNameIndex(
-                CassandraSessionPool.Session session,
-                String table, String name) {
-
+                                    CassandraSessionPool.Session session,
+                                    String table, String name) {
+            if (name.isEmpty()) {
+                return ImmutableSet.of();
+            }
             Select select = QueryBuilder.select().from(table);
             select.where(CassandraTable.formatEQ(HugeKeys.NAME, name));
 
@@ -430,11 +451,17 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             this.schema.dropTable(session);
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            this.schema.truncateTable(session);
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
@@ -471,11 +498,17 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             this.schema.dropTable(session);
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            this.schema.truncateTable(session);
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
@@ -512,11 +545,17 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             this.schema.dropTable(session);
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            this.schema.truncateTable(session);
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
@@ -553,11 +592,17 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
             this.schema.dropTable(session);
             super.dropTable(session);
         }
 
+        @Override
+        protected void truncateTable(CassandraSessionPool.Session session) {
+            this.schema.truncateTable(session);
+            super.truncateTable(session);
+        }
+
         @Override
         public void insert(CassandraSessionPool.Session session,
                            CassandraBackendEntry.Row entry) {
diff --git a/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTablesWithMV.java b/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTablesWithMV.java
index 30851ee47a..a0371d6697 100644
--- a/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTablesWithMV.java
+++ b/hugegraph-scylladb/src/main/java/com/baidu/hugegraph/backend/store/scylladb/ScyllaDBTablesWithMV.java
@@ -76,12 +76,16 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
+            this.dropIndexTable(session);
+            super.dropTable(session);
+        }
+
+        private void dropIndexTable(CassandraSessionPool.Session session) {
             String cql = String.format(
                          "DROP MATERIALIZED VIEW IF EXISTS %s",
                          MV_LABEL2VERTEX);
             session.execute(cql);
-            super.dropTable(session);
         }
 
         /**
@@ -131,12 +135,16 @@ protected void createIndex(CassandraSessionPool.Session session,
         }
 
         @Override
-        public void dropTable(CassandraSessionPool.Session session) {
+        protected void dropTable(CassandraSessionPool.Session session) {
+            this.dropIndexTable(session);
+            super.dropTable(session);
+        }
+
+        private void dropIndexTable(CassandraSessionPool.Session session) {
             String cql = String.format(
                          "DROP MATERIALIZED VIEW IF EXISTS %s",
                          MV_LABEL2EDGE);
             session.execute(cql);
-            super.dropTable(session);
         }
 
         /**
diff --git a/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraph.java b/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraph.java
index 7bfdfe467a..4663587504 100644
--- a/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraph.java
+++ b/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraph.java
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Set;
 
 import org.apache.commons.configuration.Configuration;
 import org.apache.tinkerpop.gremlin.process.computer.GraphComputer;
@@ -35,9 +36,11 @@
 
 import com.baidu.hugegraph.HugeGraph;
 import com.baidu.hugegraph.io.HugeGraphIoRegistry;
+import com.baidu.hugegraph.schema.PropertyKey;
 import com.baidu.hugegraph.schema.SchemaManager;
 import com.baidu.hugegraph.structure.HugeFeatures;
 import com.baidu.hugegraph.type.define.IdStrategy;
+import com.google.common.collect.ImmutableSet;
 
 @Graph.OptIn("com.baidu.hugegraph.tinkerpop.StructureBasicSuite")
 @Graph.OptIn("com.baidu.hugegraph.tinkerpop.ProcessBasicSuite")
@@ -47,6 +50,9 @@ public class TestGraph implements Graph {
 
     public static final String DEFAULT_VL = "vertex";
 
+    public static final Set<String> TRUNCATE_BACKENDS =
+           ImmutableSet.of("rocksdb", "mysql");
+
     private static volatile int id = 666;
 
     private HugeGraph graph;
@@ -60,7 +66,7 @@ public TestGraph(HugeGraph graph) {
         this.graph = graph;
     }
 
-    public HugeGraph hugeGraph() {
+    public HugeGraph hugegraph() {
         return this.graph;
     }
 
@@ -74,6 +80,32 @@ protected void clearBackend() {
         this.initedBackend = false;
     }
 
+    protected void clearAll(String testClass) {
+        List<PropertyKey> pks = this.graph.schema().getPropertyKeys();
+        if (pks.isEmpty()) {
+            // No need to clear if there is no PKs(that's no schema and data)
+            return;
+        }
+
+        if (TRUNCATE_BACKENDS.contains(this.graph.backend())) {
+            // Delete all data by truncating tables
+            this.truncateBackend();
+        } else {
+            // Clear schema (also include data)
+            this.clearSchema();
+
+            // Clear variables if needed (would not clear when clearing schema)
+            if (testClass.endsWith("VariableAsMapTest")) {
+                this.clearVariables();
+                this.tx().commit();
+            }
+        }
+    }
+
+    protected void truncateBackend() {
+        this.graph.truncateBackend();
+    }
+
     protected void clearSchema() {
         // Clear schema and graph data will be cleared at same time
         SchemaManager schema = this.graph.schema();
@@ -100,6 +132,10 @@ protected void clearVariables() {
         variables.keys().forEach(key -> variables.remove(key));
     }
 
+    protected boolean closed() {
+        return this.graph.closed();
+    }
+
     @Override
     public Vertex addVertex(Object... keyValues) {
         boolean needRedefineSchema = false;
@@ -114,10 +150,6 @@ public Vertex addVertex(Object... keyValues) {
 
             if (keyValues[i].equals(T.id)) {
                 hasId = true;
-                if (!this.isLastIdCustomized) {
-                    needRedefineSchema = true;
-                    idStrategy = IdStrategy.CUSTOMIZE_STRING;
-                }
             }
 
             if (keyValues[i].equals(T.label) &&
@@ -225,16 +257,16 @@ public boolean initedBackend() {
         return this.initedBackend;
     }
 
-    public void autoPerson(Boolean autoPerson) {
+    public void autoPerson(boolean autoPerson) {
         this.autoPerson = autoPerson;
     }
 
-    public void ioTest(Boolean ioTest) {
+    public void ioTest(boolean ioTest) {
         this.ioTest = ioTest;
     }
 
-    public void isLastIdCustomized(boolean isLastIdCustomized) {
-        this.isLastIdCustomized = isLastIdCustomized;
+    public boolean ioTest() {
+        return this.ioTest;
     }
 
     private boolean needAddIdToLoadGraph() {
@@ -311,7 +343,7 @@ public void initPropertyKey(String key, String type) {
 
     }
 
-    public void initGratefulSchema() {
+    public void initGratefulSchema(IdStrategy idStrategy) {
         SchemaManager schema = this.graph.schema();
 
         schema.propertyKey("id").asInt().ifNotExist().create();
@@ -320,9 +352,6 @@ public void initGratefulSchema() {
         schema.propertyKey("songType").asText().ifNotExist().create();
         schema.propertyKey("performances").asInt().ifNotExist().create();
 
-        IdStrategy idStrategy = this.graph.name().endsWith("standard") ?
-                                IdStrategy.AUTOMATIC :
-                                IdStrategy.CUSTOMIZE_STRING;
         switch (idStrategy) {
             case AUTOMATIC:
                 schema.vertexLabel("song")
@@ -371,7 +400,7 @@ public void initGratefulSchema() {
               .range().ifNotExist().create();
     }
 
-    public void initModernSchema() {
+    public void initModernSchema(IdStrategy idStrategy) {
         SchemaManager schema = this.graph.schema();
 
         schema.propertyKey("weight").asDouble().ifNotExist().create();
@@ -388,10 +417,6 @@ public void initModernSchema() {
         schema.propertyKey("ripple").ifNotExist().create();
         schema.propertyKey("lop").ifNotExist().create();
 
-
-        IdStrategy idStrategy = this.graph.name().endsWith("standard") ?
-                                IdStrategy.AUTOMATIC :
-                                IdStrategy.CUSTOMIZE_STRING;
         switch (idStrategy) {
             case AUTOMATIC:
                 schema.vertexLabel("person")
@@ -491,7 +516,7 @@ public void initModernSchema() {
               .ifNotExist().create();
     }
 
-    public void initClassicSchema() {
+    public void initClassicSchema(IdStrategy idStrategy) {
         SchemaManager schema = this.graph.schema();
 
         schema.propertyKey("id").asInt().ifNotExist().create();
@@ -500,9 +525,6 @@ public void initClassicSchema() {
         schema.propertyKey("lang").ifNotExist().create();
         schema.propertyKey("age").asInt().ifNotExist().create();
 
-        IdStrategy idStrategy = this.graph.name().endsWith("standard") ?
-                                IdStrategy.AUTOMATIC :
-                                IdStrategy.CUSTOMIZE_STRING;
         switch (idStrategy) {
             case AUTOMATIC:
                 schema.vertexLabel("vertex")
@@ -601,7 +623,6 @@ private void initBasicPropertyKey() {
         schema.propertyKey("blah").asDouble().ifNotExist().create();
         schema.propertyKey("bloop").asInt().ifNotExist().create();
 
-
         if (this.ioTest) {
             schema.propertyKey("weight").asFloat().ifNotExist().create();
         } else {
@@ -614,6 +635,7 @@ private void initBasicVertexLabelV(IdStrategy idStrategy,
         SchemaManager schema = this.graph.schema();
         switch (idStrategy) {
             case CUSTOMIZE_STRING:
+                this.isLastIdCustomized = true;
                 schema.vertexLabel(defaultVL)
                       .properties("__id", "oid", "name", "state", "status",
                                   "some", "that", "any", "this", "lang", "b",
@@ -638,6 +660,7 @@ private void initBasicVertexLabelV(IdStrategy idStrategy,
                       .useCustomizeStringId().ifNotExist().create();
                 break;
             case AUTOMATIC:
+                this.isLastIdCustomized = false;
                 schema.vertexLabel(defaultVL)
                       .properties("__id", "oid", "name", "state", "status",
                                   "some", "that", "any", "this", "lang", "b",
diff --git a/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraphProvider.java b/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraphProvider.java
index 99595e3e14..033bb09975 100644
--- a/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraphProvider.java
+++ b/hugegraph-test/src/main/java/com/baidu/hugegraph/tinkerpop/TestGraphProvider.java
@@ -19,10 +19,12 @@
 
 package com.baidu.hugegraph.tinkerpop;
 
+
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
+import java.lang.reflect.Method;
 import java.net.URL;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -33,11 +35,14 @@
 import org.apache.commons.configuration.ConfigurationException;
 import org.apache.commons.configuration.PropertiesConfiguration;
 import org.apache.tinkerpop.gremlin.AbstractGraphProvider;
+import org.apache.tinkerpop.gremlin.FeatureRequirement;
+import org.apache.tinkerpop.gremlin.FeatureRequirements;
 import org.apache.tinkerpop.gremlin.LoadGraphWith;
 import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
 import org.apache.tinkerpop.gremlin.process.traversal.strategy.optimization.LazyBarrierStrategy;
 import org.apache.tinkerpop.gremlin.structure.Element;
 import org.apache.tinkerpop.gremlin.structure.Graph;
+import org.apache.tinkerpop.gremlin.structure.Graph.Features.VertexPropertyFeatures;
 import org.apache.tinkerpop.gremlin.structure.Transaction;
 import org.junit.Assert;
 import org.junit.Assume;
@@ -60,18 +65,30 @@ public class TestGraphProvider extends AbstractGraphProvider {
 
     private static final Logger LOG = Log.logger(TestGraphProvider.class);
 
+    @SuppressWarnings("rawtypes")
+    private static final Set<Class> IMPLEMENTATIONS = ImmutableSet.of(
+            HugeEdge.class,
+            HugeElement.class,
+            HugeGraph.class,
+            HugeProperty.class,
+            HugeVertex.class,
+            HugeVertexProperty.class);
+
     private static final String CONF_PATH = "hugegraph.properties";
     private static final String FILTER = "test.tinkerpop.filter";
     private static final String DEFAULT_FILTER = "methods.filter";
+
     private static final String TEST_CLASS = "testClass";
     private static final String TEST_METHOD = "testMethod";
+
     private static final String LOAD_GRAPH = "loadGraph";
-    private static final String AKEY = "aKey";
     private static final String STANDARD = "standard";
     private static final String REGULAR_LOAD = "regularLoad";
+
     private static final String GREMLIN_GRAPH_KEY = "gremlin.graph";
     private static final String GREMLIN_GRAPH_VALUE =
             "com.baidu.hugegraph.tinkerpop.TestGraphFactory";
+
     private static final String AKEY_CLASS_PREFIX =
             "org.apache.tinkerpop.gremlin.structure." +
             "PropertyTest.PropertyFeatureSupportTest";
@@ -80,6 +97,16 @@ public class TestGraphProvider extends AbstractGraphProvider {
     private static final String IO_TEST_PREFIX =
             "org.apache.tinkerpop.gremlin.structure.io.IoTest";
 
+    private static final String EXPECT_CUSTOMIZED_ID = "expectCustomizedId";
+    private static final Set<String> CUSTOMIZED_ID_METHODS = ImmutableSet.of(
+            "shouldReadWriteSelfLoopingEdges",
+            "shouldEvaluateConnectivityPatterns");
+
+    private static final Set<String> ID_TYPES = ImmutableSet.of(
+            VertexPropertyFeatures.FEATURE_USER_SUPPLIED_IDS,
+            VertexPropertyFeatures.FEATURE_NUMERIC_IDS,
+            VertexPropertyFeatures.FEATURE_STRING_IDS);
+
     private Map<String, String> blackMethods = new HashMap<>();
     private Map<String, TestGraph> graphs = new HashMap<>();
     private final String suite;
@@ -91,7 +118,7 @@ public TestGraphProvider(String suite) throws IOException {
     }
 
     private void initBlackList() throws IOException {
-        String filter = (String) getConf().getProperty(FILTER);
+        String filter = getConf().getString(FILTER);
         if (filter == null || filter.isEmpty()) {
             filter = DEFAULT_FILTER;
         }
@@ -129,16 +156,7 @@ private void initBlackList() throws IOException {
         }
     }
 
-    @SuppressWarnings("rawtypes")
-    private static final Set<Class> IMPLEMENTATIONS = ImmutableSet.of(
-            HugeEdge.class,
-            HugeElement.class,
-            HugeGraph.class,
-            HugeProperty.class,
-            HugeVertex.class,
-            HugeVertexProperty.class);
-
-    public PropertiesConfiguration getConf() {
+    private static PropertiesConfiguration getConf() {
         String confFile = TestGraphProvider.class.getClassLoader()
                                            .getResource(CONF_PATH).getPath();
         File file = new File(confFile);
@@ -160,10 +178,10 @@ public PropertiesConfiguration getConf() {
     @Override
     public Map<String, Object> getBaseConfiguration(
                                String graphName,
-                               Class<?> test, String testMethod,
+                               Class<?> testClass, String testMethod,
                                LoadGraphWith.GraphData graphData) {
         // Check if test in blackList
-        String testFullName = test.getCanonicalName() + "." + testMethod;
+        String testFullName = testClass.getCanonicalName() + "." + testMethod;
         int index = testFullName.indexOf('@') == -1 ?
                     testFullName.length() : testFullName.indexOf('@');
 
@@ -182,18 +200,40 @@ public Map<String, Object> getBaseConfiguration(
             String key = keys.next();
             confMap.put(key, config.getProperty(key));
         }
-        String storePrefix = (String) config.getProperty(
-                                      CoreOptions.STORE.name());
+        String storePrefix = config.getString(CoreOptions.STORE.name());
         confMap.put(CoreOptions.STORE.name(),
                     storePrefix + "_" + this.suite + "_" + graphName);
         confMap.put(GREMLIN_GRAPH_KEY, GREMLIN_GRAPH_VALUE);
-        confMap.put(TEST_CLASS, test);
+        confMap.put(TEST_CLASS, testClass);
         confMap.put(TEST_METHOD, testMethod);
         confMap.put(LOAD_GRAPH, graphData);
+        confMap.put(EXPECT_CUSTOMIZED_ID, customizedId(testClass, testMethod));
 
         return confMap;
     }
 
+    private static boolean customizedId(Class<?> test, String testMethod) {
+        Method method;
+        try {
+            method = test.getDeclaredMethod(testMethod);
+        } catch (NoSuchMethodException ignored) {
+            return false;
+        }
+        FeatureRequirements features =
+                            method.getAnnotation(FeatureRequirements.class);
+        if (features == null) {
+            return false;
+        }
+        for (FeatureRequirement feature : features.value()) {
+            if (feature.featureClass() == Graph.Features.VertexFeatures.class &&
+                ID_TYPES.contains(feature.feature())) {
+                // Expect CUSTOMIZED_ID if want to pass id to create vertex
+                return true;
+            }
+        }
+        return false;
+    }
+
     private static String getAKeyType(Class<?> clazz, String method) {
         if (clazz.getCanonicalName().startsWith(AKEY_CLASS_PREFIX)) {
             return method.substring(method.indexOf('[') + 9,
@@ -210,55 +250,72 @@ private static String getIoType(Class<?> clazz, String method) {
         return null;
     }
 
-    private static boolean ioTest(Class<?> clazz) {
+    private static boolean isIoTest(Class<?> clazz) {
         return clazz.getCanonicalName().startsWith(IO_TEST_PREFIX);
     }
 
+    private static IdStrategy idStrategy(Configuration config) {
+        Class<?> testClass = (Class<?>) config.getProperty(TEST_CLASS);
+        String testMethod = config.getString(TEST_METHOD);
+
+        // Set id strategy
+        IdStrategy idStrategy = IdStrategy.AUTOMATIC;
+        if (config.getBoolean(EXPECT_CUSTOMIZED_ID) || isIoTest(testClass) ||
+            CUSTOMIZED_ID_METHODS.contains(testMethod)) {
+            /*
+             * Use CUSTOMIZED_ID if the following case are met:
+             *  1.Expect CUSTOMIZED_ID for some specific features
+             *  2.IoTest, it will copy vertex from IO or other graph
+             *  3.Some tests that need to pass vertex id manually
+             */
+            idStrategy = IdStrategy.CUSTOMIZE_STRING;
+        }
+        return idStrategy;
+    }
+
+    private TestGraph newTestGraph(final Configuration config) {
+        TestGraph testGraph = ((TestGraph) super.openTestGraph(config));
+        testGraph.initBackend();
+        return testGraph;
+    }
+
     @Override
     public Graph openTestGraph(final Configuration config) {
         String graphName = config.getString(CoreOptions.STORE.name());
-        if (!this.graphs.containsKey(graphName)) {
-            TestGraph testGraph = this.newTestGraph(config);
-            this.graphs.putIfAbsent(graphName, testGraph);
-        }
+        Class<?> testClass = (Class<?>) config.getProperty(TEST_CLASS);
+        String testMethod = config.getString(TEST_METHOD);
 
         TestGraph testGraph = this.graphs.get(graphName);
+        if (testGraph == null) {
+            this.graphs.putIfAbsent(graphName, this.newTestGraph(config));
+        } else if (testGraph.closed()) {
+            this.graphs.put(graphName, this.newTestGraph(config));
+        }
+        testGraph = this.graphs.get(graphName);
+
         // Ensure tx clean
         testGraph.tx().rollback();
 
         // Define property key 'aKey' based on specified type in test name
-        String aKeyType = getAKeyType(
-                          (Class<?>) config.getProperty(TEST_CLASS),
-                          config.getString(TEST_METHOD));
+        String aKeyType = getAKeyType(testClass, testMethod);
         if (aKeyType != null) {
-            testGraph.initPropertyKey(AKEY, aKeyType);
+            testGraph.initPropertyKey("aKey", aKeyType);
         }
 
-        String ioType = getIoType((Class<?>) config.getProperty(TEST_CLASS),
-                                  config.getString(TEST_METHOD));
-
         // Basic schema is initiated by default once a graph is open
-        testGraph.initBasicSchema(IdStrategy.AUTOMATIC,
-                                  TestGraph.DEFAULT_VL);
+        testGraph.initBasicSchema(idStrategy(config), TestGraph.DEFAULT_VL);
         testGraph.tx().commit();
 
-        testGraph.isLastIdCustomized(false);
-        testGraph.loadedGraph(ioType);
+        testGraph.loadedGraph(getIoType(testClass, testMethod));
         testGraph.autoPerson(false);
-        testGraph.ioTest(ioTest((Class<?>) config.getProperty(TEST_CLASS)));
+        testGraph.ioTest(isIoTest(testClass));
 
         Object loadGraph = config.getProperty(LOAD_GRAPH);
         if (loadGraph != null && !graphName.endsWith(STANDARD)) {
-            this.loadGraphData(testGraph,
-                               (LoadGraphWith.GraphData) loadGraph);
+            this.loadGraphData(testGraph, (LoadGraphWith.GraphData) loadGraph);
         }
 
-        return testGraph;
-    }
-
-    private TestGraph newTestGraph(final Configuration config) {
-        TestGraph testGraph = ((TestGraph) super.openTestGraph(config));
-        testGraph.initBackend();
+        LOG.debug("Open graph '{}' for test '{}'", graphName, testMethod);
         return testGraph;
     }
 
@@ -268,17 +325,24 @@ public void clear(Graph graph, Configuration config) throws Exception {
         if (testGraph == null || !testGraph.initedBackend()) {
             return;
         }
+        String graphName = config.getString(CoreOptions.STORE.name());
+        if (testGraph.closed()) {
+            this.graphs.remove(graphName);
+            return;
+        }
 
         // Reset consumers
         graph.tx().onReadWrite(Transaction.READ_WRITE_BEHAVIOR.AUTO);
         graph.tx().onClose(Transaction.CLOSE_BEHAVIOR.ROLLBACK);
 
-        // Clear schema (also include data)
-        testGraph.clearSchema();
+        // Ensure tx clean
+        graph.tx().rollback();
 
-        // Clear variables (would not clear when clearing schema)
-        testGraph.clearVariables();
-        graph.tx().commit();
+        // Clear all data
+        Class<?> testClass = (Class<?>) config.getProperty(TEST_CLASS);
+        testGraph.clearAll(testClass.getCanonicalName());
+
+        LOG.debug("Clear graph '{}'", graphName);
     }
 
     public void clearBackends() {
@@ -298,7 +362,7 @@ public void loadGraphData(final Graph graph,
             return;
         }
 
-        loadGraphData(graph, loadGraphWith.value());
+        this.loadGraphData(graph, loadGraphWith.value());
 
         super.loadGraphData(graph, loadGraphWith, testClass, testName);
     }
@@ -308,22 +372,26 @@ public void loadGraphData(final Graph graph,
         TestGraph testGraph = (TestGraph) graph;
 
         // Clear basic schema initiated in openTestGraph
-        testGraph.clearSchema();
-        testGraph.tx().commit();
+        testGraph.clearAll("");
 
         if (testGraph.loadedGraph() == null) {
             testGraph.loadedGraph(REGULAR_LOAD);
         }
 
+        boolean standard = testGraph.hugegraph().name().endsWith(STANDARD);
+        IdStrategy idStrategy = standard && !testGraph.ioTest() ?
+                                IdStrategy.AUTOMATIC :
+                                IdStrategy.CUSTOMIZE_STRING;
+
         switch (loadGraphWith) {
             case GRATEFUL:
-                testGraph.initGratefulSchema();
+                testGraph.initGratefulSchema(idStrategy);
                 break;
             case MODERN:
-                testGraph.initModernSchema();
+                testGraph.initModernSchema(idStrategy);
                 break;
             case CLASSIC:
-                testGraph.initClassicSchema();
+                testGraph.initClassicSchema(idStrategy);
                 break;
             case CREW:
                 break;
@@ -345,7 +413,7 @@ public Set<Class> getImplementations() {
     @SuppressWarnings("unchecked")
     @Override
     public GraphTraversalSource traversal(Graph graph) {
-        HugeGraph hugegraph = ((TestGraph) graph).hugeGraph();
+        HugeGraph hugegraph = ((TestGraph) graph).hugegraph();
         return hugegraph.traversal()
                         .withoutStrategies(LazyBarrierStrategy.class);
     }