From beee53e161f19a117d8d2b0a88ae5246eb0719a3 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    |   5 +
 .../store/cassandra/CassandraSessionPool.java |   4 +
 .../store/cassandra/CassandraStore.java       |  68 ++++++++----
 .../store/cassandra/CassandraTable.java       |  17 ++-
 .../java/com/baidu/hugegraph/HugeGraph.java   |  41 ++++++-
 .../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 |  35 ++++--
 .../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 +
 .../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  |  36 ++++++
 .../tinkerpop/TestGraphProvider.java          |  63 ++++++-----
 37 files changed, 645 insertions(+), 253 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 8c1f2e3c9e..989b5b1e9b 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
@@ -36,13 +36,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.util.Log;
 import com.codahale.metrics.annotation.Timed;
@@ -127,27 +124,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 d8fb44e20d..931a8e860b 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
@@ -168,6 +168,11 @@ public void clearBackend() {
         this.hugegraph.clearBackend();
     }
 
+    public void truncateBackend() {
+        this.verifyPermission(ROLE_ADMIN);
+        this.hugegraph.truncateBackend();
+    }
+
     public void restoring(boolean restoring) {
         this.verifyPermission(ROLE_ADMIN);
         this.hugegraph.restoring(restoring);
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 669f52be1d..42dce44a45 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/HugeGraph.java b/hugegraph-core/src/main/java/com/baidu/hugegraph/HugeGraph.java
index 816e3cce4e..81204cf28d 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;
@@ -96,8 +97,8 @@ public class HugeGraph implements Graph {
     }
 
     private final String name;
-    private boolean closed;
-    private boolean restoring;
+    private volatile boolean closed;
+    private volatile boolean restoring;
 
     private final HugeConfig configuration;
 
@@ -187,7 +188,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();
@@ -196,6 +197,8 @@ public void initBackend() {
     }
 
     public void clearBackend() {
+        this.waitUntilAllTasksCompleted();
+
         this.loadSchemaStore().open(this.configuration);
         this.loadSystemStore().open(this.configuration);
         this.loadGraphStore().open(this.configuration);
@@ -208,7 +211,28 @@ public void clearBackend() {
         }
     }
 
+    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) {
@@ -219,6 +243,7 @@ private SchemaTransaction openSchemaTransaction() throws HugeException {
     }
 
     private GraphTransaction openGraphTransaction() throws HugeException {
+        this.checkGraphNotClosed();
         try {
             return new CachedGraphTransaction(this, this.loadGraphStore());
         } catch (BackendException e) {
@@ -235,12 +260,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);
     }
@@ -251,6 +280,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.
@@ -259,6 +289,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 074a1c61e6..49b1f2dc71 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
@@ -46,4 +46,8 @@ public Id nextId(HugeType type) {
         }
         return IdGenerator.of(counter.incrementAndGet());
     }
+
+    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 b875027aa2..a56b687706 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 e5e47369af..f9c9d53c99 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
@@ -45,6 +45,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 d1d921b9c3..65ac487f70 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;
@@ -86,6 +87,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;
@@ -167,33 +172,41 @@ 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);
+        }
+        this.counter.reset();
+
+        LOG.debug("Store cleared: {}", this.store);
+    }
+
+    @Override
+    public void truncate() {
+        for (InMemoryDBTable table : this.tables()) {
             table.clear(null);
         }
+        this.counter.reset();
+
+        LOG.debug("Store truncated: {}", this.store);
     }
 
     @Override
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 67a661bb31..be5567bf95 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
@@ -727,7 +727,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/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 019cf9dc4c..ee8126e7c9 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
@@ -58,7 +58,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 39d8042d49..95181f0a0d 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
@@ -57,7 +57,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 c076de9592..17fca90d9b 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 8db4972e2f..02e59837a7 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 1c8f6c843e..3c742cae70 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
@@ -217,7 +217,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 5fab742c0c..94fcc7ac60 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 d78fddfe5c..20c2cf9310 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 610dd61336..17de8539e9 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
@@ -152,16 +152,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
@@ -177,7 +177,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";
 
@@ -186,7 +195,7 @@ public SearchIndex(String database) {
         }
     }
 
-    public static class RangeIndex extends RocksDBTable {
+    public static class RangeIndex extends IndexTable {
 
         public static final String TABLE = "ri";
 
@@ -247,16 +256,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..263aaaf700 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", "scylladb");
+
     private static volatile int id = 666;
 
     private HugeGraph 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;
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..d754595687 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
@@ -63,15 +63,18 @@ public class TestGraphProvider extends AbstractGraphProvider {
     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";
@@ -160,10 +163,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('@');
 
@@ -187,7 +190,7 @@ public Map<String, Object> getBaseConfiguration(
         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);
 
@@ -217,42 +220,40 @@ private static boolean ioTest(Class<?> clazz) {
     @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);
+        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);
 
-        TestGraph 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));
+        Class<?> testClass = (Class<?>) config.getProperty(TEST_CLASS);
+        String testMethod = 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.AUTOMATIC, 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(ioTest(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);
         }
 
+        LOG.debug("Open graph '{}' for test '{}'", graphName, testMethod);
         return testGraph;
     }
 
@@ -268,17 +269,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 all data
+        Class<?> testClass = (Class<?>) config.getProperty(TEST_CLASS);
+        testGraph.clearAll(testClass.getCanonicalName());
 
-        // Clear variables (would not clear when clearing schema)
-        testGraph.clearVariables();
-        graph.tx().commit();
+        LOG.debug("Clear graph '{}'", graphName);
     }
 
     public void clearBackends() {
@@ -308,8 +316,7 @@ 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);