Merge pull request #519 from clevertension/master

Support H2 storage modules at Collector Side

apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/cpu/dao/CpuMetricH2DAO.java

@@ -18,10 +18,44 @@
 
 package org.skywalking.apm.collector.agentjvm.worker.cpu.dao;
 
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO {
+public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(CpuMetricH2DAO.class);
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(CpuMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0));
+        source.put(CpuMetricTable.COLUMN_USAGE_PERCENT, data.getDataDouble(0));
+        source.put(CpuMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+
+        logger.debug("prepare cpu metric batch insert, id: {}", data.getDataString(0));
+        String sql = SqlBuilder.buildBatchInsertSql(CpuMetricTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/gc/dao/GCMetricH2DAO.java

@@ -18,10 +18,42 @@
 
 package org.skywalking.apm.collector.agentjvm.worker.gc.dao;
 
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO {
+public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(GCMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0));
+        source.put(GCMetricTable.COLUMN_PHRASE, data.getDataInteger(1));
+        source.put(GCMetricTable.COLUMN_COUNT, data.getDataLong(0));
+        source.put(GCMetricTable.COLUMN_TIME, data.getDataLong(1));
+        source.put(GCMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(2));
+
+        String sql = SqlBuilder.buildBatchInsertSql(GCMetricTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/heartbeat/dao/InstanceHeartBeatH2DAO.java

@@ -18,10 +18,62 @@
 
 package org.skywalking.apm.collector.agentjvm.worker.heartbeat.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.framework.UnexpectedException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.register.InstanceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO {
+public class InstanceHeartBeatH2DAO extends H2DAO implements IInstanceHeartBeatDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(InstanceHeartBeatEsDAO.class);
+    private static final String GET_INSTANCE_HEARTBEAT_SQL = "select * from {0} where {1} = ?";
+    @Override public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_INSTANCE_HEARTBEAT_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID);
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(InstanceTable.COLUMN_INSTANCE_ID));
+                data.setDataLong(0, rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        throw new UnexpectedException("There is no need to merge stream data with database data.");
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, data.getDataLong(0));
+        String sql = SqlBuilder.buildBatchUpdateSql(InstanceTable.TABLE, source.keySet(), InstanceTable.COLUMN_APPLICATION_ID);
+        entity.setSql(sql);
+        List<Object> params = new ArrayList<>(source.values());
+        params.add(data.getDataString(0));
+        entity.setParams(params.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memory/dao/MemoryMetricH2DAO.java

@@ -18,10 +18,44 @@
 
 package org.skywalking.apm.collector.agentjvm.worker.memory.dao;
 
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO {
+public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(MemoryMetricTable.COLUMN_APPLICATION_INSTANCE_ID, data.getDataInteger(0));
+        source.put(MemoryMetricTable.COLUMN_IS_HEAP, data.getDataBoolean(0));
+        source.put(MemoryMetricTable.COLUMN_INIT, data.getDataLong(0));
+        source.put(MemoryMetricTable.COLUMN_MAX, data.getDataLong(1));
+        source.put(MemoryMetricTable.COLUMN_USED, data.getDataLong(2));
+        source.put(MemoryMetricTable.COLUMN_COMMITTED, data.getDataLong(3));
+        source.put(MemoryMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4));
+
+        String sql = SqlBuilder.buildBatchInsertSql(MemoryMetricTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentjvm/src/main/java/org/skywalking/apm/collector/agentjvm/worker/memorypool/dao/MemoryPoolMetricH2DAO.java

@@ -18,10 +18,44 @@
 
 package org.skywalking.apm.collector.agentjvm.worker.memorypool.dao;
 
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO {
+public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(MemoryPoolMetricTable.COLUMN_INSTANCE_ID, data.getDataInteger(0));
+        source.put(MemoryPoolMetricTable.COLUMN_POOL_TYPE, data.getDataInteger(1));
+        source.put(MemoryPoolMetricTable.COLUMN_INIT, data.getDataLong(0));
+        source.put(MemoryPoolMetricTable.COLUMN_MAX, data.getDataLong(1));
+        source.put(MemoryPoolMetricTable.COLUMN_USED, data.getDataLong(2));
+        source.put(MemoryPoolMetricTable.COLUMN_COMMITTED, data.getDataLong(3));
+        source.put(MemoryPoolMetricTable.COLUMN_TIME_BUCKET, data.getDataLong(4));
+
+        String sql = SqlBuilder.buildBatchInsertSql(MemoryPoolMetricTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/application/dao/ApplicationH2DAO.java

@@ -18,29 +18,51 @@
 
 package org.skywalking.apm.collector.agentregister.worker.application.dao;
 
+
 import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.storage.define.register.ApplicationDataDefine;
+import org.skywalking.apm.collector.storage.define.register.ApplicationTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class ApplicationH2DAO extends H2DAO implements IApplicationDAO {
+    private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class);
+    private static final String INSERT_APPLICATION_SQL = "insert into {0}({1}, {2}) values(?, ?)";
+    @Override
+    public int getApplicationId(String applicationCode) {
+        logger.info("get the application id with application code = {}", applicationCode);
+        String sql = "select " + ApplicationTable.COLUMN_APPLICATION_ID + " from " +
+                ApplicationTable.TABLE + " where " + ApplicationTable.COLUMN_APPLICATION_CODE + "='" + applicationCode + "'";
 
-    @Override public int getApplicationId(String applicationCode) {
-        H2Client client = getClient();
-        return 100;
+        return getIntValueBySQL(sql);
     }
 
-    @Override public int getMaxApplicationId() {
-        return 0;
+    @Override
+    public int getMaxApplicationId() {
+        return getMaxId(ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID);
     }
 
-    @Override public int getMinApplicationId() {
-        return 0;
+    @Override
+    public int getMinApplicationId() {
+        return getMinId(ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID);
     }
 
-    @Override public void save(ApplicationDataDefine.Application application) {
-
+    @Override
+    public void save(ApplicationDataDefine.Application application) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(INSERT_APPLICATION_SQL, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID,
+                ApplicationTable.COLUMN_APPLICATION_CODE);
+        Object[] params = new Object[] {application.getApplicationId(), application.getApplicationCode()};
+        try {
+            client.execute(sql, params);
+        } catch (H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
     }
 }

apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/instance/dao/InstanceH2DAO.java

@@ -18,34 +18,94 @@
 
 package org.skywalking.apm.collector.agentregister.worker.instance.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine;
+import org.skywalking.apm.collector.storage.define.register.InstanceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class InstanceH2DAO extends H2DAO implements IInstanceDAO {
+    private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class);
+    private static final String GET_INSTANCE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ?";
+    private static final String GET_APPLICATION_ID_SQL = "select {0} from {1} where {2} = ?";
+    private static final String UPDATE_HEARTBEAT_TIME_SQL = "updatte {0} set {1} = ? where {2} = ?";
     @Override public int getInstanceId(int applicationId, String agentUUID) {
+        logger.info("get the application id with application id = {}, agentUUID = {}", applicationId, agentUUID);
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_INSTANCE_ID_SQL, InstanceTable.COLUMN_INSTANCE_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID,
+                InstanceTable.COLUMN_AGENT_UUID);
+        Object[] params = new Object[]{applicationId, agentUUID};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getInt(InstanceTable.COLUMN_INSTANCE_ID);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 
     @Override public int getMaxInstanceId() {
-        return 0;
+        return getMaxId(InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID);
     }
 
     @Override public int getMinInstanceId() {
-        return 0;
+        return getMinId(InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID);
     }
 
     @Override public void save(InstanceDataDefine.Instance instance) {
-
+        H2Client client = getClient();
+        Map<String, Object> source = new HashMap<>();
+        source.put(InstanceTable.COLUMN_INSTANCE_ID, instance.getInstanceId());
+        source.put(InstanceTable.COLUMN_APPLICATION_ID, instance.getApplicationId());
+        source.put(InstanceTable.COLUMN_AGENT_UUID, instance.getAgentUUID());
+        source.put(InstanceTable.COLUMN_REGISTER_TIME, instance.getRegisterTime());
+        source.put(InstanceTable.COLUMN_HEARTBEAT_TIME, instance.getHeartBeatTime());
+        source.put(InstanceTable.COLUMN_OS_INFO, instance.getOsInfo());
+        String sql = SqlBuilder.buildBatchInsertSql(InstanceTable.TABLE, source.keySet());
+        Object[] params = source.values().toArray(new Object[0]);
+        try {
+            client.execute(sql, params);
+        } catch (H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
     }
 
     @Override public void updateHeartbeatTime(int instanceId, long heartbeatTime) {
-
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(UPDATE_HEARTBEAT_TIME_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME,
+                InstanceTable.COLUMN_INSTANCE_ID);
+        Object[] params = new Object[] {heartbeatTime, instanceId};
+        try {
+            client.execute(sql, params);
+        } catch (H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
     }
 
     @Override public int getApplicationId(int applicationInstanceId) {
+        logger.info("get the application id with application id = {}", applicationInstanceId);
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_APPLICATION_ID_SQL, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID);
+        Object[] params = new Object[]{applicationInstanceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getInt(InstanceTable.COLUMN_APPLICATION_ID);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 }

apm-collector/apm-collector-agentregister/src/main/java/org/skywalking/apm/collector/agentregister/worker/servicename/dao/ServiceNameH2DAO.java

@@ -18,31 +18,87 @@
 
 package org.skywalking.apm.collector.agentregister.worker.servicename.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
 import org.skywalking.apm.collector.storage.define.register.ServiceNameDataDefine;
+import org.skywalking.apm.collector.storage.define.register.ServiceNameTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO {
+    private final Logger logger = LoggerFactory.getLogger(ServiceNameH2DAO.class);
+    private static final String GET_SERVICE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ? limit 1";
+    private static final String GET_SERVICE_NAME_SQL = "select {0} from {1} where {2} = ?";
 
-    @Override public int getServiceId(int applicationId, String serviceName) {
+    @Override
+    public int getServiceId(int applicationId, String serviceName) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID,
+                ServiceNameTable.TABLE, ServiceNameTable.COLUMN_APPLICATION_ID, ServiceNameTable.COLUMN_SERVICE_NAME);
+        Object[] params = new Object[]{applicationId, serviceName};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getInt(ServiceNameTable.COLUMN_SERVICE_ID);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 
-    @Override public int getMaxServiceId() {
-        return 0;
+    @Override
+    public int getMaxServiceId() {
+        return getMaxId(ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID);
     }
 
-    @Override public int getMinServiceId() {
-        return 0;
+    @Override
+    public int getMinServiceId() {
+        return getMinId(ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID);
     }
 
-    @Override public String getServiceName(int serviceId) {
-        return null;
+
+    @Override
+    public String getServiceName(int serviceId) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SERVICE_NAME_SQL, ServiceNameTable.COLUMN_SERVICE_NAME,
+                ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID);
+        Object[] params = new Object[]{serviceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getString(ServiceNameTable.COLUMN_SERVICE_NAME);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return Const.EMPTY_STRING;
     }
 
-    @Override public void save(ServiceNameDataDefine.ServiceName serviceName) {
+    @Override
+    public void save(ServiceNameDataDefine.ServiceName serviceName) {
+        logger.debug("save service name register info, application id: {}, service name: {}", serviceName.getApplicationId(), serviceName.getServiceName());
+        H2Client client = getClient();
+        Map<String, Object> source = new HashMap();
+        source.put(ServiceNameTable.COLUMN_SERVICE_ID, serviceName.getServiceId());
+        source.put(ServiceNameTable.COLUMN_APPLICATION_ID, serviceName.getApplicationId());
+        source.put(ServiceNameTable.COLUMN_SERVICE_NAME, serviceName.getServiceName());
 
+        String sql = SqlBuilder.buildBatchInsertSql(ServiceNameTable.TABLE, source.keySet());
+        Object[] params = source.values().toArray(new Object[0]);
+        try {
+            client.execute(sql, params);
+        } catch (H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
     }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/global/dao/GlobalTraceH2DAO.java

@@ -18,10 +18,45 @@
 
 package org.skywalking.apm.collector.agentstream.worker.global.dao;
 
+import org.skywalking.apm.collector.core.framework.UnexpectedException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO {
+public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class);
+    @Override public Data get(String id, DataDefine dataDefine) {
+        throw new UnexpectedException("There is no need to merge stream data with database data.");
+    }
+
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        throw new UnexpectedException("There is no need to merge stream data with database data.");
+    }
+
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(GlobalTraceTable.COLUMN_SEGMENT_ID, data.getDataString(1));
+        source.put(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, data.getDataString(2));
+        source.put(GlobalTraceTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        logger.debug("global trace source: {}", source.toString());
+
+        String sql = SqlBuilder.buildBatchInsertSql(GlobalTraceTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/instance/performance/dao/InstPerformanceH2DAO.java

@@ -18,11 +18,78 @@
 
 package org.skywalking.apm.collector.agentstream.worker.instance.performance.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.instance.InstPerformanceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO {
-
+public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class);
+    private static final String GET_SQL = "select * from {0} where {1} = ?";
+    @Override public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SQL, InstPerformanceTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(InstPerformanceTable.COLUMN_APPLICATION_ID));
+                data.setDataInteger(1, rs.getInt(InstPerformanceTable.COLUMN_INSTANCE_ID));
+                data.setDataInteger(2, rs.getInt(InstPerformanceTable.COLUMN_CALLS));
+                data.setDataLong(0, rs.getLong(InstPerformanceTable.COLUMN_COST_TOTAL));
+                data.setDataLong(1, rs.getLong(InstPerformanceTable.COLUMN_TIME_BUCKET));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(InstPerformanceTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(InstPerformanceTable.COLUMN_INSTANCE_ID, data.getDataInteger(1));
+        source.put(InstPerformanceTable.COLUMN_CALLS, data.getDataInteger(2));
+        source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0));
+        source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1));
+        String sql = SqlBuilder.buildBatchInsertSql(InstPerformanceTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put(InstPerformanceTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(InstPerformanceTable.COLUMN_INSTANCE_ID, data.getDataInteger(1));
+        source.put(InstPerformanceTable.COLUMN_CALLS, data.getDataInteger(2));
+        source.put(InstPerformanceTable.COLUMN_COST_TOTAL, data.getDataLong(0));
+        source.put(InstPerformanceTable.COLUMN_TIME_BUCKET, data.getDataLong(1));
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(InstPerformanceTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/component/dao/NodeComponentH2DAO.java

@@ -18,11 +18,86 @@
 
 package org.skywalking.apm.collector.agentstream.worker.node.component.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.node.NodeComponentTable;
+import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO {
+public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class);
+    private static final String GET_SQL = "select * from {0} where {1} = ?";
+
+    @Override
+    public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SQL, ServiceReferenceTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(NodeComponentTable.COLUMN_COMPONENT_ID));
+                data.setDataString(1, rs.getString(NodeComponentTable.COLUMN_COMPONENT_NAME));
+                data.setDataInteger(1, rs.getInt(NodeComponentTable.COLUMN_PEER_ID));
+                data.setDataString(2, rs.getString(NodeComponentTable.COLUMN_PEER));
+                data.setDataLong(0, rs.getLong(NodeComponentTable.COLUMN_TIME_BUCKET));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+
+    @Override
+    public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(NodeComponentTable.COLUMN_COMPONENT_ID, data.getDataInteger(0));
+        source.put(NodeComponentTable.COLUMN_COMPONENT_NAME, data.getDataString(1));
+        source.put(NodeComponentTable.COLUMN_PEER_ID, data.getDataInteger(1));
+        source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2));
+        source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+
+        String sql = SqlBuilder.buildBatchInsertSql(NodeComponentTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
 
+    @Override
+    public H2SqlEntity prepareBatchUpdate(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put(NodeComponentTable.COLUMN_COMPONENT_ID, data.getDataInteger(0));
+        source.put(NodeComponentTable.COLUMN_COMPONENT_NAME, data.getDataString(1));
+        source.put(NodeComponentTable.COLUMN_PEER_ID, data.getDataInteger(1));
+        source.put(NodeComponentTable.COLUMN_PEER, data.getDataString(2));
+        source.put(NodeComponentTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(NodeComponentTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/node/mapping/dao/NodeMappingH2DAO.java

@@ -18,10 +18,77 @@
 
 package org.skywalking.apm.collector.agentstream.worker.node.mapping.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.agentstream.worker.node.component.dao.NodeComponentH2DAO;
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.node.NodeMappingTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO {
+public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class);
+    private static final String GET_SQL = "select * from {0} where {1} = ?";
+    @Override public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SQL, NodeMappingTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(NodeMappingTable.COLUMN_APPLICATION_ID));
+                data.setDataInteger(1, rs.getInt(NodeMappingTable.COLUMN_ADDRESS_ID));
+                data.setDataString(1, rs.getString(NodeMappingTable.COLUMN_ADDRESS));
+                data.setDataLong(0, rs.getLong(NodeMappingTable.COLUMN_TIME_BUCKET));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(NodeMappingTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(NodeMappingTable.COLUMN_ADDRESS_ID, data.getDataInteger(1));
+        source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1));
+        source.put(NodeMappingTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        String sql = SqlBuilder.buildBatchInsertSql(NodeMappingTable.TABLE, source.keySet());
+        entity.setSql(sql);
+
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put(NodeMappingTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(NodeMappingTable.COLUMN_ADDRESS_ID, data.getDataInteger(1));
+        source.put(NodeMappingTable.COLUMN_ADDRESS, data.getDataString(1));
+        source.put(NodeMappingTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(NodeMappingTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/dao/NodeReferenceH2DAO.java

@@ -18,10 +18,94 @@
 
 package org.skywalking.apm.collector.agentstream.worker.noderef.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.noderef.NodeReferenceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO {
+public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class);
+    private static final String GET_SQL = "select * from {0} where {1} = ?";
+    @Override public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SQL, NodeReferenceTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID));
+                data.setDataInteger(1, rs.getInt(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID));
+                data.setDataString(1, rs.getString(NodeReferenceTable.COLUMN_BEHIND_PEER));
+                data.setDataInteger(2, rs.getInt(NodeReferenceTable.COLUMN_S1_LTE));
+                data.setDataInteger(3, rs.getInt(NodeReferenceTable.COLUMN_S3_LTE));
+                data.setDataInteger(4, rs.getInt(NodeReferenceTable.COLUMN_S5_LTE));
+                data.setDataInteger(5, rs.getInt(NodeReferenceTable.COLUMN_S5_GT));
+                data.setDataInteger(6, rs.getInt(NodeReferenceTable.COLUMN_SUMMARY));
+                data.setDataInteger(7, rs.getInt(NodeReferenceTable.COLUMN_ERROR));
+                data.setDataLong(0, rs.getLong(NodeReferenceTable.COLUMN_TIME_BUCKET));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, data.getDataInteger(0));
+        source.put(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, data.getDataInteger(1));
+        source.put(NodeReferenceTable.COLUMN_BEHIND_PEER, data.getDataString(1));
+        source.put(NodeReferenceTable.COLUMN_S1_LTE, data.getDataInteger(2));
+        source.put(NodeReferenceTable.COLUMN_S3_LTE, data.getDataInteger(3));
+        source.put(NodeReferenceTable.COLUMN_S5_LTE, data.getDataInteger(4));
+        source.put(NodeReferenceTable.COLUMN_S5_GT, data.getDataInteger(5));
+        source.put(NodeReferenceTable.COLUMN_SUMMARY, data.getDataInteger(6));
+        source.put(NodeReferenceTable.COLUMN_ERROR, data.getDataInteger(7));
+        source.put(NodeReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        String sql = SqlBuilder.buildBatchInsertSql(NodeReferenceTable.TABLE, source.keySet());
+        entity.setSql(sql);
+
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, data.getDataInteger(0));
+        source.put(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, data.getDataInteger(1));
+        source.put(NodeReferenceTable.COLUMN_BEHIND_PEER, data.getDataString(1));
+        source.put(NodeReferenceTable.COLUMN_S1_LTE, data.getDataInteger(2));
+        source.put(NodeReferenceTable.COLUMN_S3_LTE, data.getDataInteger(3));
+        source.put(NodeReferenceTable.COLUMN_S5_LTE, data.getDataInteger(4));
+        source.put(NodeReferenceTable.COLUMN_S5_GT, data.getDataInteger(5));
+        source.put(NodeReferenceTable.COLUMN_SUMMARY, data.getDataInteger(6));
+        source.put(NodeReferenceTable.COLUMN_ERROR, data.getDataInteger(7));
+        source.put(NodeReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(0));
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(NodeReferenceTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/noderef/define/NodeReferenceH2TableDefine.java

@@ -32,6 +32,7 @@ public class NodeReferenceH2TableDefine extends H2TableDefine {
     }
 
     @Override public void initialize() {
+        addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_ID, H2ColumnDefine.Type.Varchar.name()));
         addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, H2ColumnDefine.Type.Int.name()));
         addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, H2ColumnDefine.Type.Int.name()));
         addColumn(new H2ColumnDefine(NodeReferenceTable.COLUMN_BEHIND_PEER, H2ColumnDefine.Type.Varchar.name()));

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/cost/dao/SegmentCostH2DAO.java

@@ -18,11 +18,48 @@
 
 package org.skywalking.apm.collector.agentstream.worker.segment.cost.dao;
 
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.segment.SegmentCostTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO {
+public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class);
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        logger.debug("segment cost prepareBatchInsert, id: {}", data.getDataString(0));
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(SegmentCostTable.COLUMN_SEGMENT_ID, data.getDataString(1));
+        source.put(SegmentCostTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(SegmentCostTable.COLUMN_SERVICE_NAME, data.getDataString(2));
+        source.put(SegmentCostTable.COLUMN_COST, data.getDataLong(0));
+        source.put(SegmentCostTable.COLUMN_START_TIME, data.getDataLong(1));
+        source.put(SegmentCostTable.COLUMN_END_TIME, data.getDataLong(2));
+        source.put(SegmentCostTable.COLUMN_IS_ERROR, data.getDataBoolean(0));
+        source.put(SegmentCostTable.COLUMN_TIME_BUCKET, data.getDataLong(3));
+        logger.debug("segment cost source: {}", source.toString());
 
+        String sql = SqlBuilder.buildBatchInsertSql(SegmentCostTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/segment/origin/dao/SegmentH2DAO.java

@@ -18,10 +18,42 @@
 
 package org.skywalking.apm.collector.agentstream.worker.segment.origin.dao;
 
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.agentstream.worker.segment.cost.dao.SegmentCostH2DAO;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.segment.SegmentTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class SegmentH2DAO extends H2DAO implements ISegmentDAO {
+public class SegmentH2DAO extends H2DAO implements ISegmentDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class);
+    @Override public Data get(String id, DataDefine dataDefine) {
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        Map<String, Object> source = new HashMap<>();
+        H2SqlEntity entity = new H2SqlEntity();
+        source.put("id", data.getDataString(0));
+        source.put(SegmentTable.COLUMN_DATA_BINARY, Base64.getEncoder().encode(data.getDataBytes(0)));
+        logger.debug("segment source: {}", source.toString());
+
+        String sql = SqlBuilder.buildBatchInsertSql(SegmentTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        return null;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/service/entry/dao/ServiceEntryH2DAO.java

@@ -18,10 +18,78 @@
 
 package org.skywalking.apm.collector.agentstream.worker.service.entry.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.stream.Data;
+import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.service.ServiceEntryTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO {
+public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(ServiceEntryH2DAO.class);
+    private static final String GET_SERIVCE_ENTRY_SQL = "select * from {0} where {1} = ?";
+    @Override public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(ServiceEntryTable.TABLE, "id");
+        Object[] params = new Object[] {id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID));
+                data.setDataInteger(1, rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID));
+                data.setDataString(1, rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME));
+                data.setDataLong(0, rs.getLong(ServiceEntryTable.COLUMN_REGISTER_TIME));
+                data.setDataLong(1, rs.getLong(ServiceEntryTable.COLUMN_NEWEST_TIME));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+    @Override public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1));
+        source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1));
+        source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0));
+        source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1));
+        String sql = SqlBuilder.buildBatchInsertSql(ServiceEntryTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
+    }
+    @Override public H2SqlEntity prepareBatchUpdate(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put(ServiceEntryTable.COLUMN_APPLICATION_ID, data.getDataInteger(0));
+        source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(1));
+        source.put(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1));
+        source.put(ServiceEntryTable.COLUMN_REGISTER_TIME, data.getDataLong(0));
+        source.put(ServiceEntryTable.COLUMN_NEWEST_TIME, data.getDataLong(1));
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(ServiceEntryTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
+    }
 }

apm-collector/apm-collector-agentstream/src/main/java/org/skywalking/apm/collector/agentstream/worker/serviceref/dao/ServiceReferenceH2DAO.java

@@ -18,25 +18,112 @@
 
 package org.skywalking.apm.collector.agentstream.worker.serviceref.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.core.stream.Data;
 import org.skywalking.apm.collector.storage.define.DataDefine;
+import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
 import org.skywalking.apm.collector.stream.worker.impl.dao.IPersistenceDAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
-public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO<String, String> {
-
-    @Override public Data get(String id, DataDefine dataDefine) {
+public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO, IPersistenceDAO<H2SqlEntity, H2SqlEntity> {
+    private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class);
+    private static final String GET_SQL = "select * from {0} where {1} = ?";
+    @Override
+    public Data get(String id, DataDefine dataDefine) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SQL, ServiceReferenceTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Data data = dataDefine.build(id);
+                data.setDataInteger(0, rs.getInt(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID));
+                data.setDataString(1, rs.getString(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME));
+                data.setDataInteger(1, rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID));
+                data.setDataString(2, rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME));
+                data.setDataInteger(2, rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID));
+                data.setDataString(3, rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME));
+                data.setDataLong(0, rs.getLong(ServiceReferenceTable.COLUMN_S1_LTE));
+                data.setDataLong(1, rs.getLong(ServiceReferenceTable.COLUMN_S3_LTE));
+                data.setDataLong(2, rs.getLong(ServiceReferenceTable.COLUMN_S5_LTE));
+                data.setDataLong(3, rs.getLong(ServiceReferenceTable.COLUMN_S5_GT));
+                data.setDataLong(4, rs.getLong(ServiceReferenceTable.COLUMN_SUMMARY));
+                data.setDataLong(5, rs.getLong(ServiceReferenceTable.COLUMN_ERROR));
+                data.setDataLong(6, rs.getLong(ServiceReferenceTable.COLUMN_COST_SUMMARY));
+                data.setDataLong(7, rs.getLong(ServiceReferenceTable.COLUMN_TIME_BUCKET));
+                return data;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return null;
     }
 
-    @Override public String prepareBatchInsert(Data data) {
-        return null;
+    @Override
+    public H2SqlEntity prepareBatchInsert(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put("id", data.getDataString(0));
+        source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0));
+        source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1));
+        source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, data.getDataInteger(1));
+        source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, data.getDataString(2));
+        source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, data.getDataInteger(2));
+        source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, data.getDataString(3));
+        source.put(ServiceReferenceTable.COLUMN_S1_LTE, data.getDataLong(0));
+        source.put(ServiceReferenceTable.COLUMN_S3_LTE, data.getDataLong(1));
+        source.put(ServiceReferenceTable.COLUMN_S5_LTE, data.getDataLong(2));
+        source.put(ServiceReferenceTable.COLUMN_S5_GT, data.getDataLong(3));
+        source.put(ServiceReferenceTable.COLUMN_SUMMARY, data.getDataLong(4));
+        source.put(ServiceReferenceTable.COLUMN_ERROR, data.getDataLong(5));
+        source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6));
+        source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7));
+
+        String sql = SqlBuilder.buildBatchInsertSql(ServiceReferenceTable.TABLE, source.keySet());
+        entity.setSql(sql);
+        entity.setParams(source.values().toArray(new Object[0]));
+        return entity;
     }
 
-    @Override public String prepareBatchUpdate(Data data) {
-        return null;
+    @Override
+    public H2SqlEntity prepareBatchUpdate(Data data) {
+        H2SqlEntity entity = new H2SqlEntity();
+        Map<String, Object> source = new HashMap<>();
+        source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, data.getDataInteger(0));
+        source.put(ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME, data.getDataString(1));
+        source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, data.getDataInteger(1));
+        source.put(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, data.getDataString(2));
+        source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID, data.getDataInteger(2));
+        source.put(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME, data.getDataString(3));
+        source.put(ServiceReferenceTable.COLUMN_S1_LTE, data.getDataLong(0));
+        source.put(ServiceReferenceTable.COLUMN_S3_LTE, data.getDataLong(1));
+        source.put(ServiceReferenceTable.COLUMN_S5_LTE, data.getDataLong(2));
+        source.put(ServiceReferenceTable.COLUMN_S5_GT, data.getDataLong(3));
+        source.put(ServiceReferenceTable.COLUMN_SUMMARY, data.getDataLong(4));
+        source.put(ServiceReferenceTable.COLUMN_ERROR, data.getDataLong(5));
+        source.put(ServiceReferenceTable.COLUMN_COST_SUMMARY, data.getDataLong(6));
+        source.put(ServiceReferenceTable.COLUMN_TIME_BUCKET, data.getDataLong(7));
+
+        String id = data.getDataString(0);
+        String sql = SqlBuilder.buildBatchUpdateSql(ServiceReferenceTable.TABLE, source.keySet(), "id");
+        entity.setSql(sql);
+        List<Object> values = new ArrayList<>(source.values());
+        values.add(id);
+        entity.setParams(values.toArray(new Object[0]));
+        return entity;
     }
 }

apm-collector/apm-collector-boot/src/main/resources/application.yml

@@ -31,3 +31,9 @@ storage:
     cluster_nodes: localhost:9300
     index_shards_number: 2
     index_replicas_number: 0
+# uncomment to enable h2 storage
+#storage:
+#    h2:
+#      url: jdbc:h2:~/collector
+#      user_name: sa
+#      password: sa
\ No newline at end of file

apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/h2/H2Client.java

@@ -18,11 +18,10 @@
 
 package org.skywalking.apm.collector.client.h2;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
+import java.sql.*;
+
+import org.h2.jdbcx.JdbcConnectionPool;
+import org.h2.util.IOUtils;
 import org.skywalking.apm.collector.core.client.Client;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -34,25 +33,47 @@ public class H2Client implements Client {
 
     private final Logger logger = LoggerFactory.getLogger(H2Client.class);
 
+    private JdbcConnectionPool cp;
     private Connection conn;
+    private String url;
+    private String userName;
+    private String password;
+
+    public H2Client() {
+        this.url = "jdbc:h2:mem:collector";
+        this.userName = "";
+        this.password = "";
+    }
+
+    public H2Client(String url, String userName, String password) {
+        this.url = url;
+        this.userName = userName;
+        this.password = password;
+    }
 
     @Override public void initialize() throws H2ClientException {
         try {
-            Class.forName("org.h2.Driver");
-            conn = DriverManager.getConnection("jdbc:h2:mem:collector");
-        } catch (ClassNotFoundException | SQLException e) {
+            cp = JdbcConnectionPool.
+                    create(this.url, this.userName, this.password);
+            conn = cp.getConnection();
+        } catch (Exception e) {
             throw new H2ClientException(e.getMessage(), e);
         }
     }
 
     @Override public void shutdown() {
+        if (cp != null) {
+            cp.dispose();
+        }
+        IOUtils.closeSilently(conn);
+    }
 
+    public Connection getConnection() throws H2ClientException {
+        return conn;
     }
 
     public void execute(String sql) throws H2ClientException {
-        Statement statement = null;
-        try {
-            statement = conn.createStatement();
+        try (Statement statement = getConnection().createStatement()) {
             statement.execute(sql);
             statement.closeOnCompletion();
         } catch (SQLException e) {
@@ -60,17 +81,40 @@ public class H2Client implements Client {
         }
     }
 
-    public void executeQuery(String sql) throws H2ClientException {
-        Statement statement = null;
+    public ResultSet executeQuery(String sql, Object[] params) throws H2ClientException {
+        logger.debug("execute query with result: {}", sql);
+        ResultSet rs;
+        PreparedStatement statement;
         try {
-            statement = conn.createStatement();
-            ResultSet rs = statement.executeQuery(sql);
-            while (rs.next()) {
-                logger.debug(rs.getString("ADDRESS") + "," + rs.getString("DATA"));
+            statement = getConnection().prepareStatement(sql);
+            if (params != null) {
+                for (int i = 0; i < params.length; i++) {
+                    statement.setObject(i + 1, params[i]);
+                }
             }
+            rs = statement.executeQuery();
             statement.closeOnCompletion();
         } catch (SQLException e) {
             throw new H2ClientException(e.getMessage(), e);
         }
+        return rs;
+    }
+
+    public boolean execute(String sql, Object[] params) throws H2ClientException {
+        logger.debug("execute insert/update/delete: {}", sql);
+        boolean flag;
+        Connection conn = getConnection();
+        try (PreparedStatement statement = conn.prepareStatement(sql)) {
+            conn.setAutoCommit(true);
+            if (params != null) {
+                for (int i = 0; i < params.length; i++) {
+                    statement.setObject(i + 1, params[i]);
+                }
+            }
+            flag = statement.execute();
+        } catch (SQLException e) {
+            throw new H2ClientException(e.getMessage(), e);
+        }
+        return flag;
     }
 }

apm-collector/apm-collector-client/src/main/java/org/skywalking/apm/collector/client/zookeeper/ZookeeperClient.java

@@ -78,6 +78,14 @@ public class ZookeeperClient implements Client {
         }
     }
 
+    public void delete(final String path, int version) throws ZookeeperClientException {
+        try {
+            zk.delete(path, version);
+        } catch (KeeperException | InterruptedException e) {
+            throw new ZookeeperClientException(e.getMessage(), e);
+        }
+    }
+
     public byte[] getData(String path, boolean watch, Stat stat) throws ZookeeperClientException {
         try {
             return zk.getData(path, watch, stat);

apm-collector/apm-collector-cluster/src/main/java/org/skywalking/apm/collector/cluster/zookeeper/ClusterZKDataMonitor.java

@@ -115,9 +115,15 @@ public class ClusterZKDataMonitor implements DataMonitor, Watcher {
             client.getChildren(next.getKey(), true);
             String serverPath = next.getKey() + "/" + value.getHostPort();
 
-            if (client.exists(serverPath, false) == null) {
+            Stat stat = client.exists(serverPath, false);
+            if (stat != null) {
+                client.delete(serverPath, stat.getVersion());
+            }
+            stat = client.exists(serverPath, false);
+            if (stat == null) {
                 setData(serverPath, contextPath);
             } else {
+                client.delete(serverPath, stat.getVersion());
                 throw new ClusterNodeExistException("current address: " + value.getHostPort() + " has been registered, check the host and port configuration or wait a moment.");
             }
         }

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/define/segment/SegmentCostDataDefine.java

@@ -28,7 +28,7 @@ import org.skywalking.apm.collector.storage.define.AttributeType;
 import org.skywalking.apm.collector.storage.define.DataDefine;
 
 /**
- * @author pengys5
+ * @author pengys5H
  */
 public class SegmentCostDataDefine extends DataDefine {
 

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/SqlBuilder.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.storage.h2;
+
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.Set;
+
+public class SqlBuilder {
+    public static final String buildSql(String sql, Object ... args) {
+        return MessageFormat.format(sql, args);
+    }
+
+    public static final String buildSql(String sql, List<Object> args) {
+        MessageFormat messageFormat = new MessageFormat(sql);
+        return messageFormat.format(args.toArray(new Object[0]));
+    }
+
+    public static final String buildBatchInsertSql(String tableName, Set<String> columnNames) {
+        StringBuilder sb = new StringBuilder("insert into ");
+        sb.append(tableName).append("(");
+        columnNames.forEach((columnName) -> {
+            sb.append(columnName).append(",");
+        });
+        sb.delete(sb.length() - 1, sb.length());
+        sb.append(") values(");
+        for (int i = 0; i < columnNames.size(); i++) {
+            sb.append("?,");
+        }
+        sb.delete(sb.length() - 1, sb.length());
+        sb.append(")");
+        return sb.toString();
+    }
+
+    public static final String buildBatchUpdateSql(String tableName, Set<String> columnNames, String whereClauseName) {
+        StringBuilder sb = new StringBuilder("update ");
+        sb.append(tableName).append(" set ");
+        columnNames.forEach((columnName) -> {
+            sb.append(columnName).append("=?,");
+        });
+        sb.delete(sb.length() - 1, sb.length());
+        sb.append(" where ").append(whereClauseName).append("=?");
+        return sb.toString();
+    }
+}

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2Config.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.storage.h2;
+
+/**
+ * @author clevertension
+ */
+public class StorageH2Config {
+    public static String URL;
+    public static String USER_NAME;
+    public static String PASSWORD;
+}

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ConfigParser.java

@@ -21,12 +21,25 @@ package org.skywalking.apm.collector.storage.h2;
 import java.util.Map;
 import org.skywalking.apm.collector.core.config.ConfigParseException;
 import org.skywalking.apm.collector.core.module.ModuleConfigParser;
+import org.skywalking.apm.collector.core.util.ObjectUtils;
+import org.skywalking.apm.collector.core.util.StringUtils;
 
 /**
  * @author pengys5
  */
 public class StorageH2ConfigParser implements ModuleConfigParser {
-
+    private static final String URL = "url";
+    public static final String USER_NAME = "user_name";
+    public static final String PASSWORD = "password";
     @Override public void parse(Map config) throws ConfigParseException {
+        if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(URL))) {
+            StorageH2Config.URL = (String)config.get(URL);
+        }
+        if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(USER_NAME))) {
+            StorageH2Config.USER_NAME = (String)config.get(USER_NAME);
+        }
+        if (ObjectUtils.isNotEmpty(config) && StringUtils.isNotEmpty(config.get(PASSWORD))) {
+            StorageH2Config.PASSWORD = (String)config.get(PASSWORD);
+        }
     }
 }

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/StorageH2ModuleDefine.java

@@ -51,7 +51,7 @@ public class StorageH2ModuleDefine extends StorageModuleDefine {
     }
 
     @Override protected Client createClient() {
-        return new H2Client();
+        return new H2Client(StorageH2Config.URL, StorageH2Config.USER_NAME, StorageH2Config.PASSWORD);
     }
 
     @Override public StorageInstaller storageInstaller() {

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/BatchH2DAO.java

@@ -18,15 +18,69 @@
 
 package org.skywalking.apm.collector.storage.h2.dao;
 
-import java.util.List;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.storage.dao.IBatchDAO;
+import org.skywalking.apm.collector.storage.h2.define.H2SqlEntity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 /**
  * @author pengys5
  */
 public class BatchH2DAO extends H2DAO implements IBatchDAO {
+    private final Logger logger = LoggerFactory.getLogger(BatchH2DAO.class);
 
-    @Override public void batchPersistence(List<?> batchCollection) {
+    @Override
+    public void batchPersistence(List<?> batchCollection) {
+        if (batchCollection != null && batchCollection.size() > 0) {
+            logger.debug("the batch collection size is {}", batchCollection.size());
+            Connection conn = null;
+            final Map<String, PreparedStatement> batchSqls = new HashMap<>();
+            try {
+                conn = getClient().getConnection();
+                conn.setAutoCommit(true);
+                PreparedStatement ps;
+                for (Object entity : batchCollection) {
+                    H2SqlEntity e = getH2SqlEntity(entity);
+                    String sql = e.getSql();
+                    if (batchSqls.containsKey(sql)) {
+                        ps = batchSqls.get(sql);
+                    } else {
+                        ps = conn.prepareStatement(sql);
+                        batchSqls.put(sql, ps);
+                    }
+
+                    Object[] params = e.getParams();
+                    if (params != null) {
+                        logger.debug("the sql is {}, params size is {}", e.getSql(), params.length);
+                        for (int i = 0; i < params.length; i++) {
+                            ps.setObject(i + 1, params[i]);
+                        }
+                    }
+                    ps.addBatch();
+                }
+
+                for (String k : batchSqls.keySet()) {
+                    batchSqls.get(k).executeBatch();
+                }
+            } catch (SQLException | H2ClientException e) {
+                logger.error(e.getMessage(), e);
+            }
+            batchSqls.clear();
+        }
+    }
 
+    private H2SqlEntity getH2SqlEntity(Object entity) {
+        if (entity instanceof H2SqlEntity) {
+            return (H2SqlEntity) entity;
+        }
+        return null;
     }
 }

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/dao/H2DAO.java

@@ -18,11 +18,45 @@
 
 package org.skywalking.apm.collector.storage.h2.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
 import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.storage.dao.DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * @author pengys5
  */
 public abstract class H2DAO extends DAO<H2Client> {
+    private final Logger logger = LoggerFactory.getLogger(H2DAO.class);
+    public final int getMaxId(String tableName, String columnName) {
+        String sql = "select max(" + columnName + ") from " + tableName;
+        return getIntValueBySQL(sql);
+    }
+
+    public final int getMinId(String tableName, String columnName) {
+        String sql = "select min(" + columnName + ") from " + tableName;
+        return getIntValueBySQL(sql);
+    }
+
+    public final int getIntValueBySQL(String sql) {
+        H2Client client = getClient();
+        try (ResultSet rs = client.executeQuery(sql, null)) {
+            if (rs.next()) {
+                int id = rs.getInt(1);
+                if (id == Integer.MAX_VALUE || id == Integer.MIN_VALUE) {
+                    return 0;
+                } else {
+                    return id;
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return 0;
+    }
+
 }

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2SqlEntity.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.storage.h2.define;
+
+/**
+ * @author clevertension
+ */
+public class H2SqlEntity {
+    private String sql;
+    private Object[] params;
+
+    public String getSql() {
+        return sql;
+    }
+
+    public void setSql(String sql) {
+        this.sql = sql;
+    }
+
+    public Object[] getParams() {
+        return params;
+    }
+
+    public void setParams(Object[] params) {
+        this.params = params;
+    }
+}

apm-collector/apm-collector-storage/src/main/java/org/skywalking/apm/collector/storage/h2/define/H2StorageInstaller.java

@@ -18,7 +18,6 @@
 
 package org.skywalking.apm.collector.storage.h2.define;
 
-import java.util.List;
 import org.skywalking.apm.collector.client.h2.H2Client;
 import org.skywalking.apm.collector.client.h2.H2ClientException;
 import org.skywalking.apm.collector.core.client.Client;
@@ -26,12 +25,20 @@ import org.skywalking.apm.collector.core.storage.StorageException;
 import org.skywalking.apm.collector.core.storage.StorageInstallException;
 import org.skywalking.apm.collector.core.storage.StorageInstaller;
 import org.skywalking.apm.collector.core.storage.TableDefine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
 
 /**
  * @author pengys5
  */
 public class H2StorageInstaller extends StorageInstaller {
 
+    private final Logger logger = LoggerFactory.getLogger(H2StorageInstaller.class);
+
     @Override protected void defineFilter(List<TableDefine> tableDefines) {
         int size = tableDefines.size();
         for (int i = size - 1; i >= 0; i--) {
@@ -42,11 +49,36 @@ public class H2StorageInstaller extends StorageInstaller {
     }
 
     @Override protected boolean isExists(Client client, TableDefine tableDefine) throws StorageException {
+        H2Client h2Client = (H2Client)client;
+        ResultSet rs = null;
+        try {
+            logger.info("check if table {} exist ", tableDefine.getName());
+            rs = h2Client.getConnection().getMetaData().getTables(null, null, tableDefine.getName().toUpperCase(), null);
+            if (rs.next()) {
+                return true;
+            }
+        } catch (SQLException | H2ClientException e) {
+            throw new StorageInstallException(e.getMessage(), e);
+        } finally {
+            try {
+                if (rs != null) {
+                    rs.close();
+                }
+            } catch (SQLException e) {
+                throw new StorageInstallException(e.getMessage(), e);
+            }
+        }
         return false;
     }
 
     @Override protected boolean deleteTable(Client client, TableDefine tableDefine) throws StorageException {
-        return false;
+        H2Client h2Client = (H2Client)client;
+        try {
+            h2Client.execute("drop table if exists " + tableDefine.getName());
+            return true;
+        } catch (H2ClientException e) {
+            throw new StorageInstallException(e.getMessage(), e);
+        }
     }
 
     @Override protected boolean createTable(Client client, TableDefine tableDefine) throws StorageException {
@@ -59,14 +91,16 @@ public class H2StorageInstaller extends StorageInstaller {
         h2TableDefine.getColumnDefines().forEach(columnDefine -> {
             H2ColumnDefine h2ColumnDefine = (H2ColumnDefine)columnDefine;
             if (h2ColumnDefine.getType().equals(H2ColumnDefine.Type.Varchar.name())) {
-                sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append("(255)");
+                sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append("(255),");
             } else {
-                sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType());
+                sqlBuilder.append(h2ColumnDefine.getName()).append(" ").append(h2ColumnDefine.getType()).append(",");
             }
         });
-
+        //remove last comma
+        sqlBuilder.delete(sqlBuilder.length() - 1, sqlBuilder.length());
         sqlBuilder.append(")");
         try {
+            logger.info("create h2 table with sql {}", sqlBuilder);
             h2Client.execute(sqlBuilder.toString());
         } catch (H2ClientException e) {
             throw new StorageInstallException(e.getMessage(), e);

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ApplicationH2DAO.java

@@ -18,14 +18,37 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.storage.define.register.ApplicationTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class ApplicationH2DAO extends H2DAO implements IApplicationDAO {
 
+    private final Logger logger = LoggerFactory.getLogger(ApplicationH2DAO.class);
+    private static final String GET_APPLICATION_CODE_SQL = "select {0} from {1} where {2} = ?";
     @Override public String getApplicationCode(int applicationId) {
-        return null;
+        logger.debug("get application code, applicationId: {}", applicationId);
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_APPLICATION_CODE_SQL, ApplicationTable.COLUMN_APPLICATION_CODE, ApplicationTable.TABLE, ApplicationTable.COLUMN_APPLICATION_ID);
+        Object[] params = new Object[]{applicationId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getString(1);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return Const.UNKNOWN;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/CpuMetricH2DAO.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.ui.dao;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
+import org.skywalking.apm.collector.storage.define.jvm.CpuMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+
+/**
+ * @author pengys5, clevertension
+ */
+public class CpuMetricH2DAO extends H2DAO implements ICpuMetricDAO {
+    private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class);
+    private static final String GET_CPU_METRIC_SQL = "select * from {0} where {1} = ?";
+    private static final String GET_CPU_METRICS_SQL = "select * from {0} where {1} in (";
+    @Override public int getMetric(int instanceId, long timeBucket) {
+        String id = timeBucket + Const.ID_SPLIT + instanceId;
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_CPU_METRIC_SQL, CpuMetricTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getInt(CpuMetricTable.COLUMN_USAGE_PERCENT);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return 0;
+    }
+
+    @Override public JsonArray getMetric(int instanceId, long startTimeBucket, long endTimeBucket) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_CPU_METRICS_SQL, CpuMetricTable.TABLE, "id");
+
+        long timeBucket = startTimeBucket;
+        List<String> idList = new ArrayList<>();
+        do {
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            String id = timeBucket + Const.ID_SPLIT + instanceId;
+            idList.add(id);
+        }
+        while (timeBucket <= endTimeBucket);
+
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+
+        JsonArray metrics = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                double cpuUsed = rs.getDouble(CpuMetricTable.COLUMN_USAGE_PERCENT);
+                metrics.add((int)(cpuUsed * 100));
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return metrics;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GCMetricH2DAO.java

@@ -18,23 +18,158 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonObject;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
+import org.skywalking.apm.collector.storage.define.jvm.GCMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.network.proto.GCPhrase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class GCMetricH2DAO extends H2DAO implements IGCMetricDAO {
-
+    private final Logger logger = LoggerFactory.getLogger(GCMetricH2DAO.class);
+    private static final String GET_GC_COUNT_SQL = "select {1}, sum({0}) as cnt, {1} from {2} where {3} = ? and {4} in (";
+    private static final String GET_GC_METRIC_SQL = "select * from {0} where {1} = ?";
+    private static final String GET_GC_METRICS_SQL = "select * from {0} where {1} in (";
     @Override public GCCount getGCCount(long[] timeBuckets, int instanceId) {
-        return null;
+        GCCount gcCount = new GCCount();
+        H2Client client = getClient();
+        String sql = GET_GC_COUNT_SQL;
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < timeBuckets.length; i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder + " group by {1}";
+        sql = SqlBuilder.buildSql(sql, GCMetricTable.COLUMN_COUNT, GCMetricTable.COLUMN_PHRASE,
+                GCMetricTable.TABLE, GCMetricTable.COLUMN_INSTANCE_ID, "id");
+        Object[] params = new Object[timeBuckets.length + 1];
+        for (int i = 0; i < timeBuckets.length; i++) {
+            params[i + 1] = timeBuckets[i];
+        }
+        params[0] = instanceId;
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                int phrase = rs.getInt(GCMetricTable.COLUMN_PHRASE);
+                int count = rs.getInt("cnt");
+
+                if (phrase == GCPhrase.NEW_VALUE) {
+                    gcCount.setYoung(count);
+                } else if (phrase == GCPhrase.OLD_VALUE) {
+                    gcCount.setOld(count);
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return gcCount;
     }
 
     @Override public JsonObject getMetric(int instanceId, long timeBucket) {
-        return null;
+        JsonObject response = new JsonObject();
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_GC_METRIC_SQL, GCMetricTable.TABLE, "id");
+        String youngId = timeBucket + Const.ID_SPLIT + GCPhrase.NEW_VALUE + instanceId;
+        Object[] params = new Object[]{youngId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                response.addProperty("ygc", rs.getInt(GCMetricTable.COLUMN_COUNT));
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        String oldId = timeBucket + Const.ID_SPLIT + GCPhrase.OLD_VALUE + instanceId;
+        Object[] params1 = new Object[]{oldId};
+        try (ResultSet rs = client.executeQuery(sql, params1)) {
+            if (rs.next()) {
+                response.addProperty("ogc", rs.getInt(GCMetricTable.COLUMN_COUNT));
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+
+        return response;
     }
 
     @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket) {
-        return null;
+        JsonObject response = new JsonObject();
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id");
+        long timeBucket = startTimeBucket;
+        List<String> idList = new ArrayList<>();
+        do {
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            String youngId = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + GCPhrase.NEW_VALUE;
+            idList.add(youngId);
+        }
+        while (timeBucket <= endTimeBucket);
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+
+        JsonArray youngArray = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                youngArray.add(rs.getInt(GCMetricTable.COLUMN_COUNT));
+            }
+            if (youngArray.size() == 0) {
+                youngArray.add(0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        response.add("ygc", youngArray);
+        List<String> idList1 = new ArrayList<>();
+        timeBucket = startTimeBucket;
+        do {
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            String oldId = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + GCPhrase.OLD_VALUE;
+            idList1.add(oldId);
+        }
+        while (timeBucket <= endTimeBucket);
+        String sql1 = SqlBuilder.buildSql(GET_GC_METRICS_SQL, GCMetricTable.TABLE, "id");
+        StringBuilder builder1 = new StringBuilder();
+        for (int i = 0; i < idList1.size(); i++) {
+            builder1.append("?,");
+        }
+        builder1.delete(builder1.length() - 1, builder1.length());
+        builder1.append(")");
+        sql1 = sql1 + builder1;
+        Object[] params1 = idList.toArray(new String[0]);
+        JsonArray oldArray = new JsonArray();
+
+        try (ResultSet rs = client.executeQuery(sql1, params1)) {
+            while (rs.next()) {
+                oldArray.add(rs.getInt(GCMetricTable.COLUMN_COUNT));
+            }
+            if (oldArray.size() == 0) {
+                oldArray.add(0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        response.add("ogc", oldArray);
+
+        return response;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/GlobalTraceH2DAO.java

@@ -18,18 +18,59 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class GlobalTraceH2DAO extends H2DAO implements IGlobalTraceDAO {
+    private final Logger logger = LoggerFactory.getLogger(GlobalTraceH2DAO.class);
+    private static final String GET_GLOBAL_TRACE_ID_SQL = "select {0} from {1} where {2} = ? limit 10";
+    private static final String GET_SEGMENT_IDS_SQL = "select {0} from {1} where {2} = ? limit 10";
     @Override public List<String> getGlobalTraceId(String segmentId) {
-        return null;
+        List<String> globalTraceIds = new ArrayList<>();
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_GLOBAL_TRACE_ID_SQL, GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID,
+                GlobalTraceTable.TABLE, GlobalTraceTable.COLUMN_SEGMENT_ID);
+        Object[] params = new Object[]{segmentId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                String globalTraceId = rs.getString(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID);
+                logger.debug("segmentId: {}, global trace id: {}", segmentId, globalTraceId);
+                globalTraceIds.add(globalTraceId);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return globalTraceIds;
     }
 
     @Override public List<String> getSegmentIds(String globalTraceId) {
-        return null;
+        List<String> segmentIds = new ArrayList<>();
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SEGMENT_IDS_SQL, GlobalTraceTable.COLUMN_SEGMENT_ID,
+                GlobalTraceTable.TABLE, GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID);
+        Object[] params = new Object[]{globalTraceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                String segmentId = rs.getString(GlobalTraceTable.COLUMN_SEGMENT_ID);
+                logger.debug("segmentId: {}, global trace id: {}", segmentId, globalTraceId);
+                segmentIds.add(globalTraceId);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return segmentIds;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstPerformanceH2DAO.java

@@ -18,31 +18,157 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
+import org.skywalking.apm.collector.storage.define.instance.InstPerformanceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class InstPerformanceH2DAO extends H2DAO implements IInstPerformanceDAO {
-
+    private final Logger logger = LoggerFactory.getLogger(InstPerformanceH2DAO.class);
+    private static final String GET_INST_PERF_SQL = "select * from {0} where {1} = ? and {2} in (";
+    private static final String GET_TPS_METRIC_SQL = "select * from {0} where {1} = ?";
+    private static final String GET_TPS_METRICS_SQL = "select * from {0} where {1} in (";
     @Override public InstPerformance get(long[] timeBuckets, int instanceId) {
+        H2Client client = getClient();
+        logger.info("the inst performance inst id = {}", instanceId);
+        String sql = SqlBuilder.buildSql(GET_INST_PERF_SQL, InstPerformanceTable.TABLE, InstPerformanceTable.COLUMN_INSTANCE_ID, InstPerformanceTable.COLUMN_TIME_BUCKET);
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < timeBuckets.length; i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = new Object[timeBuckets.length + 1];
+        for (int i = 0; i < timeBuckets.length; i++) {
+            params[i + 1] = timeBuckets[i];
+        }
+        params[0] = instanceId;
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS);
+                int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL);
+                return new InstPerformance(instanceId, callTimes, costTotal);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return null;
     }
 
     @Override public int getTpsMetric(int instanceId, long timeBucket) {
+        logger.info("getTpMetric instanceId = {}, startTimeBucket = {}", instanceId, timeBucket);
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id");
+        Object[] params = new Object[]{instanceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getInt(InstPerformanceTable.COLUMN_CALLS);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 
     @Override public JsonArray getTpsMetric(int instanceId, long startTimeBucket, long endTimeBucket) {
-        return null;
+        logger.info("getTpsMetric instanceId = {}, startTimeBucket = {}, endTimeBucket = {}", instanceId, startTimeBucket, endTimeBucket);
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id");
+
+        long timeBucket = startTimeBucket;
+        List<String> idList = new ArrayList<>();
+        do {
+            String id = timeBucket + Const.ID_SPLIT + instanceId;
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            idList.add(id);
+        }
+        while (timeBucket <= endTimeBucket);
+
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+
+        JsonArray metrics = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                int calls = rs.getInt(InstPerformanceTable.COLUMN_CALLS);
+                metrics.add(calls);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return metrics;
     }
 
     @Override public int getRespTimeMetric(int instanceId, long timeBucket) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_TPS_METRIC_SQL, InstPerformanceTable.TABLE, "id");
+        Object[] params = new Object[]{instanceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS);
+                int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL);
+                return costTotal / callTimes;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 
     @Override public JsonArray getRespTimeMetric(int instanceId, long startTimeBucket, long endTimeBucket) {
-        return null;
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_TPS_METRICS_SQL, InstPerformanceTable.TABLE, "id");
+
+        long timeBucket = startTimeBucket;
+        List<String> idList = new ArrayList<>();
+        do {
+            String id = timeBucket + Const.ID_SPLIT + instanceId;
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            idList.add(id);
+        }
+        while (timeBucket <= endTimeBucket);
+
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+
+        JsonArray metrics = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                int callTimes = rs.getInt(InstPerformanceTable.COLUMN_CALLS);
+                int costTotal = rs.getInt(InstPerformanceTable.COLUMN_COST_TOTAL);
+                metrics.add(costTotal / callTimes);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return metrics;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/InstanceH2DAO.java

@@ -18,32 +18,134 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.LinkedList;
 import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
 import org.skywalking.apm.collector.storage.define.register.InstanceDataDefine;
+import org.skywalking.apm.collector.storage.define.register.InstanceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ApplicationCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class InstanceH2DAO extends H2DAO implements IInstanceDAO {
-    @Override public Long lastHeartBeatTime() {
-        return null;
+    private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class);
+    private static final String GET_LAST_HEARTBEAT_TIME_SQL = "select {0} from {1} where {2} > ? limit 1";
+    private static final String GET_INST_LAST_HEARTBEAT_TIME_SQL = "select {0} from {1} where {2} > ? and {3} = ? limit 1";
+    private static final String GET_INSTANCE_SQL = "select * from {0} where {1} = ?";
+    private static final String GET_INSTANCES_SQL = "select * from {0} where {1} = ? and {2} >= ?";
+    private static final String GET_APPLICATIONS_SQL = "select {3}, count({0}) as cnt from {1} where {2} >= ? and {2} <= ? group by {3} limit 100";
+
+    @Override
+    public Long lastHeartBeatTime() {
+        H2Client client = getClient();
+        long fiveMinuteBefore = System.currentTimeMillis() - 5 * 60 * 1000;
+        fiveMinuteBefore = TimeBucketUtils.INSTANCE.getSecondTimeBucket(fiveMinuteBefore);
+        String sql = SqlBuilder.buildSql(GET_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME);
+        Object[] params = new Object[]{fiveMinuteBefore};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getLong(1);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return 0L;
     }
 
-    @Override public Long instanceLastHeartBeatTime(long applicationInstanceId) {
-        return null;
+    @Override
+    public Long instanceLastHeartBeatTime(long applicationInstanceId) {
+        H2Client client = getClient();
+        long fiveMinuteBefore = System.currentTimeMillis() - 5 * 60 * 1000;
+        fiveMinuteBefore = TimeBucketUtils.INSTANCE.getSecondTimeBucket(fiveMinuteBefore);
+        String sql = SqlBuilder.buildSql(GET_INST_LAST_HEARTBEAT_TIME_SQL, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.TABLE,
+                InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_INSTANCE_ID);
+        Object[] params = new Object[]{fiveMinuteBefore, applicationInstanceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getLong(1);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return 0L;
     }
 
-    @Override public JsonArray getApplications(long startTime, long endTime) {
-        return null;
+    @Override
+    public JsonArray getApplications(long startTime, long endTime) {
+        H2Client client = getClient();
+        JsonArray applications = new JsonArray();
+        String sql = SqlBuilder.buildSql(GET_APPLICATIONS_SQL, InstanceTable.COLUMN_INSTANCE_ID,
+                InstanceTable.TABLE, InstanceTable.COLUMN_HEARTBEAT_TIME, InstanceTable.COLUMN_APPLICATION_ID);
+        Object[] params = new Object[]{startTime, endTime};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                Integer applicationId = rs.getInt(InstanceTable.COLUMN_APPLICATION_ID);
+                logger.debug("applicationId: {}", applicationId);
+                JsonObject application = new JsonObject();
+                application.addProperty("applicationId", applicationId);
+                application.addProperty("applicationCode", ApplicationCache.getForUI(applicationId));
+                application.addProperty("instanceCount", rs.getInt("cnt"));
+                applications.add(application);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return applications;
     }
 
-    @Override public InstanceDataDefine.Instance getInstance(int instanceId) {
+    @Override
+    public InstanceDataDefine.Instance getInstance(int instanceId) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_INSTANCE_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_INSTANCE_ID);
+        Object[] params = new Object[]{instanceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                InstanceDataDefine.Instance instance = new InstanceDataDefine.Instance();
+                instance.setId(String.valueOf(instanceId));
+                instance.setApplicationId(rs.getInt(InstanceTable.COLUMN_APPLICATION_ID));
+                instance.setAgentUUID(rs.getString(InstanceTable.COLUMN_AGENT_UUID));
+                instance.setRegisterTime(rs.getLong(InstanceTable.COLUMN_REGISTER_TIME));
+                instance.setHeartBeatTime(rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME));
+                instance.setOsInfo(rs.getString(InstanceTable.COLUMN_OS_INFO));
+                return instance;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return null;
     }
 
-    @Override public List<InstanceDataDefine.Instance> getInstances(int applicationId, long timeBucket) {
-        return null;
+    @Override
+    public List<InstanceDataDefine.Instance> getInstances(int applicationId, long timeBucket) {
+        logger.debug("get instances info, application id: {}, timeBucket: {}", applicationId, timeBucket);
+        List<InstanceDataDefine.Instance> instanceList = new LinkedList<>();
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_INSTANCES_SQL, InstanceTable.TABLE, InstanceTable.COLUMN_APPLICATION_ID, InstanceTable.COLUMN_HEARTBEAT_TIME);
+        Object[] params = new Object[]{applicationId, timeBucket};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                InstanceDataDefine.Instance instance = new InstanceDataDefine.Instance();
+                instance.setApplicationId(rs.getInt(InstanceTable.COLUMN_APPLICATION_ID));
+                instance.setHeartBeatTime(rs.getLong(InstanceTable.COLUMN_HEARTBEAT_TIME));
+                instance.setInstanceId(rs.getInt(InstanceTable.COLUMN_INSTANCE_ID));
+                instanceList.add(instance);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return instanceList;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryMetricH2DAO.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.ui.dao;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
+import org.skywalking.apm.collector.storage.define.jvm.MemoryMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author clevertension
+ */
+public class MemoryMetricH2DAO extends H2DAO implements IMemoryMetricDAO {
+    private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class);
+    private static final String GET_MEMORY_METRIC_SQL = "select * from {0} where {1} =?";
+    private static final String GET_MEMORY_METRICS_SQL = "select * from {0} where {1} in (";
+    @Override public JsonObject getMetric(int instanceId, long timeBucket, boolean isHeap) {
+        H2Client client = getClient();
+        String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + isHeap;
+        String sql = SqlBuilder.buildSql(GET_MEMORY_METRIC_SQL, MemoryMetricTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        JsonObject metric = new JsonObject();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                metric.addProperty("max", rs.getInt(MemoryMetricTable.COLUMN_MAX));
+                metric.addProperty("init", rs.getInt(MemoryMetricTable.COLUMN_INIT));
+                metric.addProperty("used", rs.getInt(MemoryMetricTable.COLUMN_USED));
+            } else {
+                metric.addProperty("max", 0);
+                metric.addProperty("init", 0);
+                metric.addProperty("used", 0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return metric;
+    }
+
+    @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket, boolean isHeap) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_MEMORY_METRICS_SQL, MemoryMetricTable.TABLE, "id");
+        List<String> idList = new ArrayList<>();
+        long timeBucket = startTimeBucket;
+        do {
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + isHeap;
+            idList.add(id);
+        }
+        while (timeBucket <= endTimeBucket);
+
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+        JsonObject metric = new JsonObject();
+        JsonArray usedMetric = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                metric.addProperty("max", rs.getLong(MemoryMetricTable.COLUMN_MAX));
+                metric.addProperty("init", rs.getLong(MemoryMetricTable.COLUMN_INIT));
+                usedMetric.add(rs.getLong(MemoryMetricTable.COLUMN_USED));
+            }
+            if (usedMetric.size() == 0) {
+                metric.addProperty("max", 0);
+                metric.addProperty("init",0);
+                usedMetric.add(0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+
+        metric.add("used", usedMetric);
+        return metric;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/MemoryPoolMetricH2DAO.java

+/*
+ * Copyright 2017, OpenSkywalking Organization All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Project repository: https://github.com/OpenSkywalking/skywalking
+ */
+
+package org.skywalking.apm.collector.ui.dao;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.TimeBucketUtils;
+import org.skywalking.apm.collector.storage.define.jvm.MemoryPoolMetricTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
+import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+/**
+ * @author clevertension
+ */
+public class MemoryPoolMetricH2DAO extends H2DAO implements IMemoryPoolMetricDAO {
+    private final Logger logger = LoggerFactory.getLogger(InstanceH2DAO.class);
+    private static final String GET_MEMORY_POOL_METRIC_SQL = "select * from {0} where {1} =?";
+    private static final String GET_MEMORY_POOL_METRICS_SQL = "select * from {0} where {1} in (";
+    @Override public JsonObject getMetric(int instanceId, long timeBucket, int poolType) {
+        H2Client client = getClient();
+        String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + poolType;
+        String sql = SqlBuilder.buildSql(GET_MEMORY_POOL_METRIC_SQL, MemoryPoolMetricTable.TABLE, "id");
+        Object[] params = new Object[]{id};
+        JsonObject metric = new JsonObject();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                metric.addProperty("max", rs.getInt(MemoryPoolMetricTable.COLUMN_MAX));
+                metric.addProperty("init", rs.getInt(MemoryPoolMetricTable.COLUMN_INIT));
+                metric.addProperty("used", rs.getInt(MemoryPoolMetricTable.COLUMN_USED));
+            } else {
+                metric.addProperty("max", 0);
+                metric.addProperty("init", 0);
+                metric.addProperty("used", 0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return metric;
+    }
+
+    @Override public JsonObject getMetric(int instanceId, long startTimeBucket, long endTimeBucket, int poolType) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_MEMORY_POOL_METRICS_SQL, MemoryPoolMetricTable.TABLE, "id");
+        List<String> idList = new ArrayList<>();
+        long timeBucket = startTimeBucket;
+        do {
+            timeBucket = TimeBucketUtils.INSTANCE.addSecondForSecondTimeBucket(TimeBucketUtils.TimeBucketType.SECOND.name(), timeBucket, 1);
+            String id = timeBucket + Const.ID_SPLIT + instanceId + Const.ID_SPLIT + poolType;
+            idList.add(id);
+        }
+        while (timeBucket <= endTimeBucket);
+
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < idList.size(); i++) {
+            builder.append("?,");
+        }
+        builder.delete(builder.length() - 1, builder.length());
+        builder.append(")");
+        sql = sql + builder;
+        Object[] params = idList.toArray(new String[0]);
+        JsonObject metric = new JsonObject();
+        JsonArray usedMetric = new JsonArray();
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                metric.addProperty("max", rs.getLong(MemoryPoolMetricTable.COLUMN_MAX));
+                metric.addProperty("init", rs.getLong(MemoryPoolMetricTable.COLUMN_INIT));
+                usedMetric.add(rs.getLong(MemoryPoolMetricTable.COLUMN_USED));
+            }
+            if (usedMetric.size() == 0) {
+                metric.addProperty("max", 0);
+                metric.addProperty("init",0);
+                usedMetric.add(0);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+
+        metric.add("used", usedMetric);
+        return metric;
+    }
+}

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeComponentH2DAO.java

@@ -18,15 +18,66 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.node.NodeComponentTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ApplicationCache;
+import org.skywalking.apm.network.trace.component.ComponentsDefine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class NodeComponentH2DAO extends H2DAO implements INodeComponentDAO {
-
+    private final Logger logger = LoggerFactory.getLogger(NodeComponentH2DAO.class);
+    private static final String AGGREGATE_COMPONENT_SQL = "select {0}, {1}, {2} from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100";
     @Override public JsonArray load(long startTime, long endTime) {
-        return null;
+        JsonArray nodeComponentArray = new JsonArray();
+        nodeComponentArray.addAll(aggregationComponent(startTime, endTime));
+        return nodeComponentArray;
+    }
+    private JsonArray aggregationComponent(long startTime, long endTime) {
+        H2Client client = getClient();
+
+        JsonArray nodeComponentArray = new JsonArray();
+        String sql = SqlBuilder.buildSql(AGGREGATE_COMPONENT_SQL, NodeComponentTable.COLUMN_COMPONENT_ID,
+                NodeComponentTable.COLUMN_PEER, NodeComponentTable.COLUMN_PEER_ID,
+                NodeComponentTable.TABLE, NodeComponentTable.COLUMN_TIME_BUCKET);
+        Object[] params = new Object[]{startTime, endTime};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                int peerId = rs.getInt(NodeComponentTable.COLUMN_PEER_ID);
+                int componentId = rs.getInt(NodeComponentTable.COLUMN_COMPONENT_ID);
+                String componentName = ComponentsDefine.getInstance().getComponentName(componentId);
+                if (peerId != 0) {
+                    String peer = ApplicationCache.getForUI(peerId);
+                    nodeComponentArray.add(buildNodeComponent(peer, componentName));
+                }
+                String peer = rs.getString(NodeComponentTable.COLUMN_PEER);
+                if (StringUtils.isNotEmpty(peer)) {
+                    nodeComponentArray.add(buildNodeComponent(peer, componentName));
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return nodeComponentArray;
+    }
+
+    private JsonObject buildNodeComponent(String peer, String componentName) {
+        JsonObject nodeComponentObj = new JsonObject();
+        nodeComponentObj.addProperty("componentName", componentName);
+        nodeComponentObj.addProperty("peer", peer);
+        return nodeComponentObj;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeMappingH2DAO.java

@@ -18,15 +18,60 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.node.NodeMappingTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ApplicationCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class NodeMappingH2DAO extends H2DAO implements INodeMappingDAO {
-
+    private final Logger logger = LoggerFactory.getLogger(NodeMappingH2DAO.class);
+    private static final String NODE_MAPPING_SQL = "select {0}, {1}, {2} from {3} where {4} >= ? and {4} <= ? group by {0}, {1}, {2} limit 100";
     @Override public JsonArray load(long startTime, long endTime) {
-        return null;
+        H2Client client = getClient();
+        JsonArray nodeMappingArray = new JsonArray();
+        String sql = SqlBuilder.buildSql(NODE_MAPPING_SQL, NodeMappingTable.COLUMN_APPLICATION_ID,
+                NodeMappingTable.COLUMN_ADDRESS_ID, NodeMappingTable.COLUMN_ADDRESS,
+                NodeMappingTable.TABLE, NodeMappingTable.COLUMN_TIME_BUCKET);
+
+        Object[] params = new Object[]{startTime, endTime};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                int applicationId = rs.getInt(NodeMappingTable.COLUMN_APPLICATION_ID);
+                String applicationCode = ApplicationCache.getForUI(applicationId);
+                int addressId = rs.getInt(NodeMappingTable.COLUMN_ADDRESS_ID);
+                if (addressId != 0) {
+                    String address = ApplicationCache.getForUI(addressId);
+                    JsonObject nodeMappingObj = new JsonObject();
+                    nodeMappingObj.addProperty("applicationCode", applicationCode);
+                    nodeMappingObj.addProperty("address", address);
+                    nodeMappingArray.add(nodeMappingObj);
+                }
+                String address = rs.getString(NodeMappingTable.COLUMN_ADDRESS);
+                if (StringUtils.isNotEmpty(address)) {
+                    JsonObject nodeMappingObj = new JsonObject();
+                    nodeMappingObj.addProperty("applicationCode", applicationCode);
+                    nodeMappingObj.addProperty("address", address);
+                    nodeMappingArray.add(nodeMappingObj);
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        logger.debug("node mapping data: {}", nodeMappingArray.toString());
+        return nodeMappingArray;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/NodeReferenceH2DAO.java

@@ -18,14 +18,75 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.noderef.NodeReferenceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ApplicationCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class NodeReferenceH2DAO extends H2DAO implements INodeReferenceDAO {
+    private final Logger logger = LoggerFactory.getLogger(NodeReferenceH2DAO.class);
+    private static final String NODE_REFERENCE_SQL = "select {8}, {9}, {10}, sum({0}) as {0}, sum({1}) as {1}, sum({2}) as {2}, " +
+            "sum({3}) as {3}, sum({4}) as {4}, sum({5}) as {5} from {6} where {7} >= ? and {7} <= ? group by {8}, {9}, {10} limit 100";
     @Override public JsonArray load(long startTime, long endTime) {
-        return null;
+        H2Client client = getClient();
+        JsonArray nodeRefResSumArray = new JsonArray();
+        String sql = SqlBuilder.buildSql(NODE_REFERENCE_SQL, NodeReferenceTable.COLUMN_S1_LTE,
+                NodeReferenceTable.COLUMN_S3_LTE, NodeReferenceTable.COLUMN_S5_LTE,
+                NodeReferenceTable.COLUMN_S5_GT, NodeReferenceTable.COLUMN_SUMMARY,
+                NodeReferenceTable.COLUMN_ERROR, NodeReferenceTable.TABLE, NodeReferenceTable.COLUMN_TIME_BUCKET,
+                NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID, NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID, NodeReferenceTable.COLUMN_BEHIND_PEER);
+
+        Object[] params = new Object[]{startTime, endTime};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            while (rs.next()) {
+                int applicationId = rs.getInt(NodeReferenceTable.COLUMN_FRONT_APPLICATION_ID);
+                String applicationCode = ApplicationCache.getForUI(applicationId);
+                int behindApplicationId = rs.getInt(NodeReferenceTable.COLUMN_BEHIND_APPLICATION_ID);
+                if (behindApplicationId != 0) {
+                    String behindApplicationCode = ApplicationCache.getForUI(behindApplicationId);
+
+                    JsonObject nodeRefResSumObj = new JsonObject();
+                    nodeRefResSumObj.addProperty("front", applicationCode);
+                    nodeRefResSumObj.addProperty("behind", behindApplicationCode);
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S1_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S1_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S3_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S3_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S5_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_GT, rs.getDouble(NodeReferenceTable.COLUMN_S5_GT));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_ERROR, rs.getDouble(NodeReferenceTable.COLUMN_ERROR));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_SUMMARY, rs.getDouble(NodeReferenceTable.COLUMN_SUMMARY));
+                    nodeRefResSumArray.add(nodeRefResSumObj);
+                }
+                String behindPeer = rs.getString(NodeReferenceTable.COLUMN_BEHIND_PEER);
+                if (StringUtils.isNotEmpty(behindPeer)) {
+                    JsonObject nodeRefResSumObj = new JsonObject();
+                    nodeRefResSumObj.addProperty("front", applicationCode);
+                    nodeRefResSumObj.addProperty("behind", behindPeer);
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S1_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S1_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S3_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S3_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_LTE, rs.getDouble(NodeReferenceTable.COLUMN_S5_LTE));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_S5_GT, rs.getDouble(NodeReferenceTable.COLUMN_S5_GT));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_ERROR, rs.getDouble(NodeReferenceTable.COLUMN_ERROR));
+                    nodeRefResSumObj.addProperty(NodeReferenceTable.COLUMN_SUMMARY, rs.getDouble(NodeReferenceTable.COLUMN_SUMMARY));
+                    nodeRefResSumArray.add(nodeRefResSumObj);
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return nodeRefResSumArray;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentCostH2DAO.java

@@ -18,16 +18,142 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonObject;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.List;
+
+import org.elasticsearch.search.sort.SortOrder;
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.CollectionUtils;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.dao.DAOContainer;
+import org.skywalking.apm.collector.storage.define.global.GlobalTraceTable;
+import org.skywalking.apm.collector.storage.define.segment.SegmentCostTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class SegmentCostH2DAO extends H2DAO implements ISegmentCostDAO {
+    private final Logger logger = LoggerFactory.getLogger(SegmentCostH2DAO.class);
+    private static final String GET_SEGMENT_COST_SQL = "select * from {0} where {1} >= ? and {1} <= ?";
     @Override public JsonObject loadTop(long startTime, long endTime, long minCost, long maxCost, String operationName,
         Error error, int applicationId, List<String> segmentIds, int limit, int from, Sort sort) {
-        return null;
+        H2Client client = getClient();
+        String sql = GET_SEGMENT_COST_SQL;
+        List<Object> params = new ArrayList<>();
+        List<Object> columns = new ArrayList<>();
+        columns.add(SegmentCostTable.TABLE);
+        columns.add(SegmentCostTable.COLUMN_TIME_BUCKET);
+        params.add(startTime);
+        params.add(endTime);
+        int paramIndex = 1;
+        if (minCost != -1 || maxCost != -1) {
+            if (minCost != -1) {
+                paramIndex++;
+                sql = sql + " and {" + paramIndex + "} >= ?";
+                params.add(minCost);
+                columns.add(SegmentCostTable.COLUMN_COST);
+            }
+            if (maxCost != -1) {
+                paramIndex++;
+                sql = sql + " and {" + paramIndex + "} <= ?";
+                params.add(maxCost);
+                columns.add(SegmentCostTable.COLUMN_COST);
+            }
+        }
+        if (StringUtils.isNotEmpty(operationName)) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(operationName);
+            columns.add(SegmentCostTable.COLUMN_SERVICE_NAME);
+        }
+        if (CollectionUtils.isNotEmpty(segmentIds)) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} in (";
+            columns.add(SegmentCostTable.COLUMN_SEGMENT_ID);
+            StringBuilder builder = new StringBuilder();
+            for (int i = 0; i < segmentIds.size(); i++) {
+                builder.append("?,");
+            }
+            builder.delete(builder.length() - 1, builder.length());
+            builder.append(")");
+            sql = sql + builder;
+            for (String segmentId : segmentIds) {
+                params.add(segmentId);
+            }
+        }
+        if (Error.True.equals(error)) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(true);
+            columns.add(SegmentCostTable.COLUMN_IS_ERROR);
+        } else if (Error.False.equals(error)) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(false);
+            columns.add(SegmentCostTable.COLUMN_IS_ERROR);
+        }
+        if (applicationId != 0) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(applicationId);
+            columns.add(SegmentCostTable.COLUMN_APPLICATION_ID);
+        }
+
+        if (Sort.Cost.equals(sort)) {
+            sql = sql + " order by " + SegmentCostTable.COLUMN_COST + " " + SortOrder.DESC;
+        } else if (Sort.Time.equals(sort)) {
+            sql = sql + " order by " + SegmentCostTable.COLUMN_START_TIME + " " + SortOrder.DESC;
+        }
+
+        sql = sql + " limit " + from + "," + limit;
+        sql = SqlBuilder.buildSql(sql, columns);
+        Object[] p = params.toArray(new Object[0]);
+
+        JsonObject topSegPaging = new JsonObject();
+
+
+        JsonArray topSegArray = new JsonArray();
+        topSegPaging.add("data", topSegArray);
+        int cnt = 0;
+        int num = from;
+        try (ResultSet rs = client.executeQuery(sql, p)) {
+            while (rs.next()) {
+                JsonObject topSegmentJson = new JsonObject();
+                topSegmentJson.addProperty("num", num);
+                String segmentId = rs.getString(SegmentCostTable.COLUMN_SEGMENT_ID);
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_SEGMENT_ID, segmentId);
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_START_TIME, rs.getLong(SegmentCostTable.COLUMN_START_TIME));
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_END_TIME, rs.getLong(SegmentCostTable.COLUMN_END_TIME));
+
+                IGlobalTraceDAO globalTraceDAO = (IGlobalTraceDAO) DAOContainer.INSTANCE.get(IGlobalTraceDAO.class.getName());
+                List<String> globalTraces = globalTraceDAO.getGlobalTraceId(segmentId);
+                if (CollectionUtils.isNotEmpty(globalTraces)) {
+                    topSegmentJson.addProperty(GlobalTraceTable.COLUMN_GLOBAL_TRACE_ID, globalTraces.get(0));
+                }
+
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_APPLICATION_ID, rs.getInt(SegmentCostTable.COLUMN_APPLICATION_ID));
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_SERVICE_NAME, rs.getString(SegmentCostTable.COLUMN_SERVICE_NAME));
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_COST, rs.getLong(SegmentCostTable.COLUMN_COST));
+                topSegmentJson.addProperty(SegmentCostTable.COLUMN_IS_ERROR, rs.getBoolean(SegmentCostTable.COLUMN_IS_ERROR));
+
+                num++;
+                topSegArray.add(topSegmentJson);
+                cnt++;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        topSegPaging.addProperty("recordsTotal", cnt);
+        return topSegPaging;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/SegmentH2DAO.java

@@ -18,14 +18,48 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Base64;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.segment.SegmentTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
 import org.skywalking.apm.network.proto.TraceSegmentObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.protobuf.InvalidProtocolBufferException;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class SegmentH2DAO extends H2DAO implements ISegmentDAO {
+    private final Logger logger = LoggerFactory.getLogger(SegmentH2DAO.class);
+    private static final String GET_SEGMENT_SQL = "select {0} from {1} where {2} = ?";
     @Override public TraceSegmentObject load(String segmentId) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SEGMENT_SQL, SegmentTable.COLUMN_DATA_BINARY,
+                SegmentTable.TABLE, "id");
+        Object[] params = new Object[]{segmentId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                String dataBinaryBase64 = rs.getString(SegmentTable.COLUMN_DATA_BINARY);
+                if (StringUtils.isNotEmpty(dataBinaryBase64)) {
+                    byte[] dataBinary = Base64.getDecoder().decode(dataBinaryBase64);
+                    try {
+                        return TraceSegmentObject.parseFrom(dataBinary);
+                    } catch (InvalidProtocolBufferException e) {
+                        logger.error(e.getMessage(), e);
+                    }
+                }
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return null;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceEntryH2DAO.java

@@ -18,15 +18,82 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonObject;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.ColumnNameUtils;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.service.ServiceEntryTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ApplicationCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
  * @author pengys5
  */
 public class ServiceEntryH2DAO extends H2DAO implements IServiceEntryDAO {
+    private final Logger logger = LoggerFactory.getLogger(SegmentH2DAO.class);
+    private static final String GET_SERVICE_ENTRY_SQL = "select * from {0} where {1} >= ? and {2} <= ?";
     @Override public JsonObject load(int applicationId, String entryServiceName, long startTime, long endTime, int from,
         int size) {
-        return null;
+        H2Client client = getClient();
+        String sql = GET_SERVICE_ENTRY_SQL;
+        List<Object> params = new ArrayList<>();
+        List<Object> columns = new ArrayList<>();
+        columns.add(ServiceEntryTable.TABLE);
+        columns.add(ServiceEntryTable.COLUMN_NEWEST_TIME);
+        columns.add(ServiceEntryTable.COLUMN_REGISTER_TIME);
+        params.add(startTime);
+        params.add(endTime);
+        int paramIndex = 2;
+        if (applicationId != 0) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(applicationId);
+            columns.add(ServiceEntryTable.COLUMN_APPLICATION_ID);
+        }
+        if (StringUtils.isNotEmpty(entryServiceName)) {
+            paramIndex++;
+            sql = sql + " and {" + paramIndex + "} = ?";
+            params.add(entryServiceName);
+            columns.add(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME);
+        }
+        sql = sql + " limit " + from + "," + size;
+        sql = SqlBuilder.buildSql(sql, columns);
+        Object[] p = params.toArray(new Object[0]);
+        JsonArray serviceArray = new JsonArray();
+        JsonObject response = new JsonObject();
+        int index = 0;
+        try (ResultSet rs = client.executeQuery(sql, p)) {
+            while (rs.next()) {
+                int appId = rs.getInt(ServiceEntryTable.COLUMN_APPLICATION_ID);
+                int entryServiceId = rs.getInt(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID);
+                String applicationCode = ApplicationCache.getForUI(applicationId);
+                String entryServiceName1 = rs.getString(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME);
+
+                JsonObject row = new JsonObject();
+                row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_ENTRY_SERVICE_ID), entryServiceId);
+                row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_ENTRY_SERVICE_NAME), entryServiceName1);
+                row.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceEntryTable.COLUMN_APPLICATION_ID), appId);
+                row.addProperty("applicationCode", applicationCode);
+                serviceArray.add(row);
+                index++;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        response.addProperty("total", index);
+        response.add("array", serviceArray);
+
+        return response;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceNameH2DAO.java

@@ -18,18 +18,53 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.storage.define.register.ServiceNameTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class ServiceNameH2DAO extends H2DAO implements IServiceNameDAO {
-
+    private final Logger logger = LoggerFactory.getLogger(ServiceNameH2DAO.class);
+    private static final String GET_SERVICE_NAME_SQL = "select {0} from {1} where {2} = ?";
+    private static final String GET_SERVICE_ID_SQL = "select {0} from {1} where {2} = ? and {3} = ? limit 1";
     @Override public String getServiceName(int serviceId) {
-        return null;
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SERVICE_NAME_SQL, ServiceNameTable.COLUMN_SERVICE_NAME,
+                ServiceNameTable.TABLE, ServiceNameTable.COLUMN_SERVICE_ID);
+        Object[] params = new Object[]{serviceId};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                return rs.getString(ServiceNameTable.COLUMN_SERVICE_NAME);
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return Const.UNKNOWN;
     }
 
     @Override public int getServiceId(int applicationId, String serviceName) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SERVICE_ID_SQL, ServiceNameTable.COLUMN_SERVICE_ID,
+                ServiceNameTable.TABLE, ServiceNameTable.COLUMN_APPLICATION_ID, ServiceNameTable.COLUMN_SERVICE_NAME);
+        Object[] params = new Object[]{applicationId, serviceName};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                int serviceId = rs.getInt(ServiceNameTable.COLUMN_SERVICE_ID);
+                return serviceId;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return 0;
     }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/dao/ServiceReferenceH2DAO.java

@@ -18,19 +18,263 @@
 
 package org.skywalking.apm.collector.ui.dao;
 
-import com.google.gson.JsonArray;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.skywalking.apm.collector.client.h2.H2Client;
+import org.skywalking.apm.collector.client.h2.H2ClientException;
+import org.skywalking.apm.collector.core.util.ColumnNameUtils;
+import org.skywalking.apm.collector.core.util.Const;
+import org.skywalking.apm.collector.core.util.ObjectUtils;
+import org.skywalking.apm.collector.core.util.StringUtils;
+import org.skywalking.apm.collector.storage.define.serviceref.ServiceReferenceTable;
+import org.skywalking.apm.collector.storage.h2.SqlBuilder;
 import org.skywalking.apm.collector.storage.h2.dao.H2DAO;
+import org.skywalking.apm.collector.ui.cache.ServiceIdCache;
+import org.skywalking.apm.collector.ui.cache.ServiceNameCache;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
 
 /**
- * @author pengys5
+ * @author pengys5, clevertension
  */
 public class ServiceReferenceH2DAO extends H2DAO implements IServiceReferenceDAO {
+    private final Logger logger = LoggerFactory.getLogger(ServiceReferenceH2DAO.class);
+
+    private static final String GET_SRV_REF_LOAD1 = "select {4}, {5}, {6}, {7}, sum({8}) as cnt1, sum({9}) as cnt2, sum({10}) as cnt3" +
+            ",sum({11}) as cnt4, sum({12}) cnt5, sum({13}) as cnt6, sum({14}) as cnt7 from {0} where {1} >= ? and {1} <= ? and {2} = ? and {3} = ? group by {4}, {5}, {6}, {7}";
+    private static final String GET_SRV_REF_LOAD2 = "select {3}, {4}, {5}, {6}, sum({7}) as cnt1, sum({8}) as cnt2, sum({9}) as cnt3" +
+            ",sum({10}) as cnt4, sum({11}) cnt5, sum({12}) as cnt6, sum({13}) as cnt7 from {0} where {1} >= ? and {1} <= ? and {2} = ? group by {3}, {4}, {5}, {6}";
 
     @Override public JsonArray load(int entryServiceId, long startTime, long endTime) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE,
+                ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME,
+                ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID,
+                ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME,
+                ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE,
+                ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY,
+                ServiceReferenceTable.COLUMN_COST_SUMMARY);
+        String entryServiceName = ServiceNameCache.get(entryServiceId);
+        Object[] params = new Object[]{startTime, endTime, entryServiceId, entryServiceName};
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Map<String, JsonObject> serviceReferenceMap = new LinkedHashMap<>();
+
+                int frontServiceId = rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID);
+                if (frontServiceId != 0) {
+                    parseSubAggregate(serviceReferenceMap, rs, frontServiceId);
+                }
+
+                String frontServiceName = rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME);
+                if (StringUtils.isNotEmpty(frontServiceName)) {
+                    String[] serviceNames = frontServiceName.split(Const.ID_SPLIT);
+                    int frontServiceId1 = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]);
+                    parseSubAggregate(serviceReferenceMap, rs, frontServiceId1);
+                }
+
+                JsonArray serviceReferenceArray = new JsonArray();
+                JsonObject rootServiceReference = findRoot(serviceReferenceMap);
+                if (ObjectUtils.isNotEmpty(rootServiceReference)) {
+                    serviceReferenceArray.add(rootServiceReference);
+                    String id = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID));
+                    serviceReferenceMap.remove(id);
+
+                    int rootServiceId = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt();
+                    sortAsTree(rootServiceId, serviceReferenceArray, serviceReferenceMap);
+                }
+                return serviceReferenceArray;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
         return null;
     }
 
     @Override public JsonArray load(String entryServiceName, int entryApplicationId, long startTime, long endTime) {
+        H2Client client = getClient();
+        String sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD2, ServiceReferenceTable.TABLE,
+                ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME,
+                ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID,
+                ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME,
+                ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE,
+                ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY,
+                ServiceReferenceTable.COLUMN_COST_SUMMARY);
+        entryServiceName = entryApplicationId + Const.ID_SPLIT + entryServiceName;
+        Object[] params = new Object[]{startTime, endTime, entryServiceName};
+        int entryServiceId = ServiceIdCache.get(entryApplicationId, entryServiceName);
+        if (entryServiceId != 0) {
+            sql = SqlBuilder.buildSql(GET_SRV_REF_LOAD1, ServiceReferenceTable.TABLE,
+                    ServiceReferenceTable.COLUMN_TIME_BUCKET, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_ID, ServiceReferenceTable.COLUMN_ENTRY_SERVICE_NAME,
+                    ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID,
+                    ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME, ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME,
+                    ServiceReferenceTable.COLUMN_S1_LTE, ServiceReferenceTable.COLUMN_S3_LTE, ServiceReferenceTable.COLUMN_S5_LTE,
+                    ServiceReferenceTable.COLUMN_S5_GT, ServiceReferenceTable.COLUMN_ERROR, ServiceReferenceTable.COLUMN_SUMMARY,
+                    ServiceReferenceTable.COLUMN_COST_SUMMARY);
+            params = new Object[]{startTime, endTime, entryServiceId, entryServiceName};
+        }
+
+        try (ResultSet rs = client.executeQuery(sql, params)) {
+            if (rs.next()) {
+                Map<String, JsonObject> serviceReferenceMap = new LinkedHashMap<>();
+
+                int frontServiceId = rs.getInt(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID);
+                if (frontServiceId != 0) {
+                    parseSubAggregate(serviceReferenceMap, rs, frontServiceId);
+                }
+
+                String frontServiceName = rs.getString(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME);
+                if (StringUtils.isNotEmpty(frontServiceName)) {
+                    String[] serviceNames = frontServiceName.split(Const.ID_SPLIT);
+                    int frontServiceId1 = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]);
+                    parseSubAggregate(serviceReferenceMap, rs, frontServiceId1);
+                }
+
+                JsonArray serviceReferenceArray = new JsonArray();
+                JsonObject rootServiceReference = findRoot(serviceReferenceMap);
+                if (ObjectUtils.isNotEmpty(rootServiceReference)) {
+                    serviceReferenceArray.add(rootServiceReference);
+                    String id = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID));
+                    serviceReferenceMap.remove(id);
+
+                    int rootServiceId = rootServiceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt();
+                    sortAsTree(rootServiceId, serviceReferenceArray, serviceReferenceMap);
+                }
+                return serviceReferenceArray;
+            }
+        } catch (SQLException | H2ClientException e) {
+            logger.error(e.getMessage(), e);
+        }
+        return null;
+    }
+
+    private void parseSubAggregate(Map<String, JsonObject> serviceReferenceMap,
+                                   ResultSet rs,
+                                   int frontServiceId) {
+        try {
+            int behindServiceId = rs.getInt(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID);
+            if (behindServiceId != 0) {
+                long s1LteSum = rs.getLong("cnt1");
+                long s3LteSum = rs.getLong("cnt2");
+                long s5LteSum = rs.getLong("cnt3");
+                long s5GtSum = rs.getLong("cnt3");
+                long error = rs.getLong("cnt3");
+                long summary = rs.getLong("cnt3");
+                long costSum = rs.getLong("cnt3");
+
+                String frontServiceName = ServiceNameCache.getForUI(frontServiceId);
+                if (StringUtils.isNotEmpty(frontServiceName)) {
+                    frontServiceName = frontServiceName.split(Const.ID_SPLIT)[1];
+                }
+                String behindServiceName = ServiceNameCache.getForUI(behindServiceId);
+                if (StringUtils.isNotEmpty(frontServiceName)) {
+                    behindServiceName = behindServiceName.split(Const.ID_SPLIT)[1];
+                }
+
+                JsonObject serviceReference = new JsonObject();
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID), frontServiceId);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME), frontServiceName);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID), behindServiceId);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME), behindServiceName);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE), s1LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE), s3LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE), s5LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT), s5GtSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR), error);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY), summary);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY), costSum);
+                merge(serviceReferenceMap, serviceReference);
+            }
+        } catch (SQLException e) {
+            logger.error(e.getMessage(), e);
+        }
+
+        try {
+            String behindServiceName = rs.getString(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME);
+            if (StringUtils.isNotEmpty(behindServiceName)) {
+                long s1LteSum = rs.getLong("cnt1");
+                long s3LteSum = rs.getLong("cnt2");
+                long s5LteSum = rs.getLong("cnt3");
+                long s5GtSum = rs.getLong("cnt3");
+                long error = rs.getLong("cnt3");
+                long summary = rs.getLong("cnt3");
+                long costSum = rs.getLong("cnt3");
+
+                String frontServiceName = ServiceNameCache.getForUI(frontServiceId);
+                String[] serviceNames = behindServiceName.split(Const.ID_SPLIT);
+                int behindServiceId = ServiceIdCache.getForUI(Integer.parseInt(serviceNames[0]), serviceNames[1]);
+                behindServiceName = serviceNames[1];
+
+                JsonObject serviceReference = new JsonObject();
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID), frontServiceId);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_NAME), frontServiceName);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID), behindServiceId);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_NAME), behindServiceName);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE), s1LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE), s3LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE), s5LteSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT), s5GtSum);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR), error);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY), summary);
+                serviceReference.addProperty(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY), costSum);
+                merge(serviceReferenceMap, serviceReference);
+            }
+        } catch (SQLException e) {
+            logger.error(e.getMessage(), e);
+        }
+    }
+
+    private void merge(Map<String, JsonObject> serviceReferenceMap, JsonObject serviceReference) {
+        String id = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)) + Const.ID_SPLIT + serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID));
+
+        if (serviceReferenceMap.containsKey(id)) {
+            JsonObject reference = serviceReferenceMap.get(id);
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S1_LTE));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S3_LTE));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_LTE));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_S5_GT));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_ERROR));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_SUMMARY));
+            add(reference, serviceReference, ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_COST_SUMMARY));
+        } else {
+            serviceReferenceMap.put(id, serviceReference);
+        }
+    }
+
+    private void add(JsonObject oldReference, JsonObject newReference, String key) {
+        long oldValue = oldReference.get(key).getAsLong();
+        long newValue = newReference.get(key).getAsLong();
+        oldReference.addProperty(key, oldValue + newValue);
+    }
+
+    private JsonObject findRoot(Map<String, JsonObject> serviceReferenceMap) {
+        for (JsonObject serviceReference : serviceReferenceMap.values()) {
+            int frontServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)).getAsInt();
+            if (frontServiceId == 1) {
+                return serviceReference;
+            }
+        }
         return null;
     }
+
+    private void sortAsTree(int serviceId, JsonArray serviceReferenceArray,
+                            Map<String, JsonObject> serviceReferenceMap) {
+        Iterator<JsonObject> iterator = serviceReferenceMap.values().iterator();
+        while (iterator.hasNext()) {
+            JsonObject serviceReference = iterator.next();
+            int frontServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_FRONT_SERVICE_ID)).getAsInt();
+            if (serviceId == frontServiceId) {
+                serviceReferenceArray.add(serviceReference);
+
+                int behindServiceId = serviceReference.get(ColumnNameUtils.INSTANCE.rename(ServiceReferenceTable.COLUMN_BEHIND_SERVICE_ID)).getAsInt();
+                sortAsTree(behindServiceId, serviceReferenceArray, serviceReferenceMap);
+            }
+        }
+    }
 }

apm-collector/apm-collector-ui/src/main/java/org/skywalking/apm/collector/ui/service/InstanceHealthService.java

@@ -59,10 +59,14 @@ public class InstanceHealthService {
             IGCMetricDAO gcMetricDAO = (IGCMetricDAO)DAOContainer.INSTANCE.get(IGCMetricDAO.class.getName());
             JsonObject instanceJson = new JsonObject();
             instanceJson.addProperty("id", instance.getInstanceId());
-            instanceJson.addProperty("tps", performance.getCalls());
+            if (performance != null) {
+                instanceJson.addProperty("tps", performance.getCalls());
+            } else {
+                instanceJson.addProperty("tps", 0);
+            }
 
             int avg = 0;
-            if (performance.getCalls() != 0) {
+            if (performance != null && performance.getCalls() != 0) {
                 avg = (int)(performance.getCostTotal() / performance.getCalls());
             }
             instanceJson.addProperty("avg", avg);

apm-collector/apm-collector-ui/src/main/resources/META-INF/defines/h2_dao.define

@@ -8,6 +8,9 @@ org.skywalking.apm.collector.ui.dao.ApplicationH2DAO
 org.skywalking.apm.collector.ui.dao.ServiceNameH2DAO
 org.skywalking.apm.collector.ui.dao.InstanceH2DAO
 org.skywalking.apm.collector.ui.dao.InstPerformanceH2DAO
+org.skywalking.apm.collector.ui.dao.CpuMetricH2DAO
 org.skywalking.apm.collector.ui.dao.GCMetricH2DAO
+org.skywalking.apm.collector.ui.dao.MemoryMetricH2DAO
+org.skywalking.apm.collector.ui.dao.MemoryPoolMetricH2DAO
 org.skywalking.apm.collector.ui.dao.ServiceEntryH2DAO
 org.skywalking.apm.collector.ui.dao.ServiceReferenceH2DAO
\ No newline at end of file