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);
     }