Example usage for org.hibernate.stat Statistics getOptimisticFailureCount

List of usage examples for org.hibernate.stat Statistics getOptimisticFailureCount

Introduction

In this page you can find the example usage for org.hibernate.stat Statistics getOptimisticFailureCount.

Prototype

long getOptimisticFailureCount();

Source Link

Document

The number of Hibernate StaleObjectStateExceptions or JPA OptimisticLockExceptions that occurred.

Usage

From source file:com.openkm.servlet.admin.HibernateStatsServlet.java

License:Open Source License

/**
 * Refresh stats// www  . jav  a  2s . c  o  m
 */
private synchronized void refresh() {
    Statistics statistics = HibernateUtil.getSessionFactory().getStatistics();
    generalStatistics.set(0, statistics.getConnectCount());
    generalStatistics.set(1, statistics.getFlushCount());
    generalStatistics.set(2, statistics.getPrepareStatementCount());
    generalStatistics.set(3, statistics.getCloseStatementCount());
    generalStatistics.set(4, statistics.getSessionCloseCount());
    generalStatistics.set(5, statistics.getSessionOpenCount());
    generalStatistics.set(6, statistics.getTransactionCount());
    generalStatistics.set(7, statistics.getSuccessfulTransactionCount());
    generalStatistics.set(8, statistics.getOptimisticFailureCount());
    queryStatistics.clear();
    String[] names = statistics.getQueries();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            queryStatistics.put(names[i], statistics.getQueryStatistics(names[i]));
        }
    }

    entityStatistics.clear();
    names = statistics.getEntityNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            entityStatistics.put(names[i], statistics.getEntityStatistics(names[i]));
        }
    }

    collectionStatistics.clear();
    names = statistics.getCollectionRoleNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            collectionStatistics.put(names[i], statistics.getCollectionStatistics(names[i]));
        }
    }

    secondLevelCacheStatistics.clear();
    names = statistics.getSecondLevelCacheRegionNames();

    if (names != null && names.length > 0) {
        for (int i = 0; i < names.length; i++) {
            secondLevelCacheStatistics.put(names[i], statistics.getSecondLevelCacheStatistics(names[i]));
        }
    }
}

From source file:com.thoughtworks.go.server.service.support.HibernateInformationProvider.java

License:Apache License

@Override
public Map<String, Object> asJson() {
    LinkedHashMap<String, Object> json = new LinkedHashMap<>();
    Statistics statistics = sessionFactory.getStatistics();
    if (!statistics.isStatisticsEnabled()) {
        return json;
    }//w w  w  .  j  a  v  a  2 s  .c  o m
    json.put("EntityDeleteCount", statistics.getEntityDeleteCount());
    json.put("EntityInsertCount", statistics.getEntityInsertCount());
    json.put("EntityLoadCount", statistics.getEntityLoadCount());
    json.put("EntityFetchCount", statistics.getEntityFetchCount());
    json.put("EntityUpdateCount", statistics.getEntityUpdateCount());
    json.put("QueryExecutionCount", statistics.getQueryExecutionCount());
    json.put("QueryExecutionMaxTime", statistics.getQueryExecutionMaxTime());
    json.put("QueryExecutionMaxTimeQueryString", statistics.getQueryExecutionMaxTimeQueryString());
    json.put("QueryCacheHitCount", statistics.getQueryCacheHitCount());
    json.put("QueryCacheMissCount", statistics.getQueryCacheMissCount());
    json.put("QueryCachePutCount", statistics.getQueryCachePutCount());
    json.put("FlushCount", statistics.getFlushCount());
    json.put("ConnectCount", statistics.getConnectCount());
    json.put("SecondLevelCacheHitCount", statistics.getSecondLevelCacheHitCount());
    json.put("SecondLevelCacheMissCount", statistics.getSecondLevelCacheMissCount());
    json.put("SecondLevelCachePutCount", statistics.getSecondLevelCachePutCount());
    json.put("SessionCloseCount", statistics.getSessionCloseCount());
    json.put("SessionOpenCount", statistics.getSessionOpenCount());
    json.put("CollectionLoadCount", statistics.getCollectionLoadCount());
    json.put("CollectionFetchCount", statistics.getCollectionFetchCount());
    json.put("CollectionUpdateCount", statistics.getCollectionUpdateCount());
    json.put("CollectionRemoveCount", statistics.getCollectionRemoveCount());
    json.put("CollectionRecreateCount", statistics.getCollectionRecreateCount());
    json.put("StartTime", statistics.getStartTime());
    json.put("SecondLevelCacheRegionNames", statistics.getSecondLevelCacheRegionNames());
    json.put("SuccessfulTransactionCount", statistics.getSuccessfulTransactionCount());
    json.put("TransactionCount", statistics.getTransactionCount());
    json.put("PrepareStatementCount", statistics.getPrepareStatementCount());
    json.put("CloseStatementCount", statistics.getCloseStatementCount());
    json.put("OptimisticFailureCount", statistics.getOptimisticFailureCount());

    LinkedHashMap<String, Object> queryStats = new LinkedHashMap<>();
    json.put("Queries", queryStats);

    String[] queries = statistics.getQueries();
    for (String query : queries) {
        queryStats.put(query, statistics.getQueryStatistics(query));
    }

    LinkedHashMap<String, Object> entityStatistics = new LinkedHashMap<>();
    json.put("EntityStatistics", entityStatistics);

    String[] entityNames = statistics.getEntityNames();
    for (String entityName : entityNames) {
        entityStatistics.put(entityName, statistics.getEntityStatistics(entityName));
    }

    LinkedHashMap<String, Object> roleStatistics = new LinkedHashMap<>();
    json.put("RoleStatistics", roleStatistics);

    String[] roleNames = statistics.getCollectionRoleNames();
    for (String roleName : roleNames) {
        roleStatistics.put(roleName, statistics.getCollectionStatistics(roleName));
    }

    return json;
}

From source file:de.iew.framework.hibernate.statistics.StatisticsLogger.java

License:Apache License

public void logStatistics() {
    Statistics statistics = this.sessionFactory.getStatistics();
    statistics.setStatisticsEnabled(true);
    StringBuilder sb = new StringBuilder("\nStatistics");
    sb.append("\nCloseStatementCount: ").append(statistics.getCloseStatementCount());

    sb.append("\nEntityDeleteCount: ").append(statistics.getEntityDeleteCount());
    sb.append("\nEntityInsertCount: ").append(statistics.getEntityInsertCount());
    sb.append("\nEntityLoadCount: ").append(statistics.getEntityLoadCount());
    sb.append("\nEntityFetchCount: ").append(statistics.getEntityFetchCount());
    sb.append("\nEntityUpdateCount: ").append(statistics.getEntityUpdateCount());
    sb.append("\nQueryExecutionCount: ").append(statistics.getQueryExecutionCount());
    sb.append("\nQueryExecutionMaxTime: ").append(statistics.getQueryExecutionMaxTime());
    sb.append("\nQueryExecutionMaxTimeQueryString: ").append(statistics.getQueryExecutionMaxTimeQueryString());
    sb.append("\nQueryCacheHitCount: ").append(statistics.getQueryCacheHitCount());
    sb.append("\nQueryCacheMissCount: ").append(statistics.getQueryCacheMissCount());
    sb.append("\nQueryCachePutCount: ").append(statistics.getQueryCachePutCount());
    sb.append("\nNaturalIdQueryExecutionCount: ").append(statistics.getNaturalIdQueryExecutionCount());
    sb.append("\nNaturalIdQueryExecutionMaxTime: ").append(statistics.getNaturalIdQueryExecutionMaxTime());
    sb.append("\nNaturalIdQueryExecutionMaxTimeRegion: ")
            .append(statistics.getNaturalIdQueryExecutionMaxTimeRegion());
    sb.append("\nNaturalIdCacheHitCount: ").append(statistics.getNaturalIdCacheHitCount());
    sb.append("\nNaturalIdCacheMissCount: ").append(statistics.getNaturalIdCacheMissCount());
    sb.append("\nNaturalIdCachePutCount: ").append(statistics.getNaturalIdCachePutCount());
    sb.append("\nUpdateTimestampsCacheHitCount: ").append(statistics.getUpdateTimestampsCacheHitCount());
    sb.append("\nUpdateTimestampsCacheMissCount: ").append(statistics.getUpdateTimestampsCacheMissCount());
    sb.append("\nUpdateTimestampsCachePutCount: ").append(statistics.getUpdateTimestampsCachePutCount());
    sb.append("\nFlushCount: ").append(statistics.getFlushCount());
    sb.append("\nConnectCount: ").append(statistics.getConnectCount());
    sb.append("\nSecondLevelCacheHitCount: ").append(statistics.getSecondLevelCacheHitCount());
    sb.append("\nSecondLevelCacheMissCount: ").append(statistics.getSecondLevelCacheMissCount());
    sb.append("\nSecondLevelCachePutCount: ").append(statistics.getSecondLevelCachePutCount());
    sb.append("\nSessionCloseCount: ").append(statistics.getSessionCloseCount());
    sb.append("\nSessionOpenCount: ").append(statistics.getSessionOpenCount());
    sb.append("\nCollectionLoadCount: ").append(statistics.getCollectionLoadCount());
    sb.append("\nCollectionFetchCount: ").append(statistics.getCollectionFetchCount());
    sb.append("\nCollectionUpdateCount: ").append(statistics.getCollectionUpdateCount());
    sb.append("\nCollectionRemoveCount: ").append(statistics.getCollectionRemoveCount());
    sb.append("\nCollectionRecreateCount: ").append(statistics.getCollectionRecreateCount());
    sb.append("\nStartTime: ").append(statistics.getStartTime());
    sb.append("\nQueries: ").append(statistics.getQueries());
    sb.append("\nEntityNames: ").append(statistics.getEntityNames());
    sb.append("\nCollectionRoleNames: ").append(statistics.getCollectionRoleNames());
    sb.append("\nSecondLevelCacheRegionNames: ").append(statistics.getSecondLevelCacheRegionNames());
    sb.append("\nSuccessfulTransactionCount: ").append(statistics.getSuccessfulTransactionCount());
    sb.append("\nTransactionCount: ").append(statistics.getTransactionCount());
    sb.append("\nPrepareStatementCount: ").append(statistics.getPrepareStatementCount());
    sb.append("\nCloseStatementCount: ").append(statistics.getCloseStatementCount());
    sb.append("\nOptimisticFailureCount: ").append(statistics.getOptimisticFailureCount());

    if (log.isDebugEnabled()) {
        log.debug(sb);//from  w  ww . j  a v  a2  s . c  om
    }

}

From source file:gr.interamerican.bo2.impl.open.hibernate.HibernateBo2Utils.java

License:Open Source License

/**
 * Logs {@link SessionFactory} statistics.
 * //from  w w  w. ja va  2 s  .c  o  m
 * @param sessionFactory 
 */
@SuppressWarnings("nls")
public static void logSessionFactoryStatistics(SessionFactory sessionFactory) {
    Statistics statistics = sessionFactory.getStatistics();
    Object[] stats = new Object[] { statistics.getCollectionFetchCount(), statistics.getCollectionLoadCount(),
            statistics.getEntityFetchCount(), statistics.getEntityLoadCount(), statistics.getFlushCount(),
            statistics.getOptimisticFailureCount(), statistics.getQueryExecutionMaxTime(),
            statistics.getQueryExecutionMaxTimeQueryString(), statistics.getSessionOpenCount(),
            statistics.getSecondLevelCacheHitCount(), statistics.getSecondLevelCacheMissCount() };
    StringBuilder sb = new StringBuilder();
    for (Object o : stats) {
        String s = (o == null) ? "null" : o.toString();
        sb.append(s + StringConstants.COMMA + StringConstants.SPACE);
    }
    sb.setLength(sb.length() - 2);
    Debug.debug(logger, "Factory statistics: [ " + sb.toString() + " ]");
}

From source file:net.welen.buzz.typehandler.impl.hibernate.HibernateStatisticsUnitHandler.java

License:Open Source License

public void getValues(BuzzAnswer values) throws TypeHandlerException {
    for (String name : getMeasurableUnits()) {
        boolean debug = LOG.isDebugEnabled();

        // Find the Hibernate Session Factory in JNDI
        SessionFactory sessionFactory = null;

        Object o;//ww w  .j  av a 2  s  .  c o m
        try {
            if (debug) {
                LOG.debug("Looking up: " + name);
            }
            o = new InitialContext().lookup(name);
        } catch (NamingException e) {
            throw new TypeHandlerException(e);
        }
        if (debug) {
            LOG.debug("Found class: " + o.getClass().getName());
        }

        if (o.getClass().getName().equals("org.hibernate.ejb.EntityManagerFactoryImpl")) {
            // Hibernate 4
            sessionFactory = ((EntityManagerFactoryImpl) o).getSessionFactory();
        } else {
            // Hibernate 3
            sessionFactory = (SessionFactory) o;
        }

        // Get all values
        Statistics stats = sessionFactory.getStatistics();
        String measurementUnit = getMeasurementUnit();
        values.put(measurementUnit, name, "SessionOpenCount", stats.getSessionOpenCount());
        values.put(measurementUnit, name, "SessionCloseCount", stats.getSessionCloseCount());
        values.put(measurementUnit, name, "FlushCount", stats.getFlushCount());
        values.put(measurementUnit, name, "ConnectCount", stats.getConnectCount());
        values.put(measurementUnit, name, "PrepareStatementCount", stats.getPrepareStatementCount());
        values.put(measurementUnit, name, "CloseStatementCount", stats.getCloseStatementCount());
        values.put(measurementUnit, name, "EntityLoadCount", stats.getEntityLoadCount());
        values.put(measurementUnit, name, "EntityUpdateCount", stats.getEntityUpdateCount());
        values.put(measurementUnit, name, "EntityInsertCount", stats.getEntityInsertCount());
        values.put(measurementUnit, name, "EntityDeleteCount", stats.getEntityDeleteCount());
        values.put(measurementUnit, name, "EntityFetchCount", stats.getEntityFetchCount());
        values.put(measurementUnit, name, "CollectionLoadCount", stats.getCollectionLoadCount());
        values.put(measurementUnit, name, "CollectionUpdateCount", stats.getCollectionUpdateCount());
        values.put(measurementUnit, name, "CollectionRemoveCount", stats.getCollectionRemoveCount());
        values.put(measurementUnit, name, "CollectionRecreateCount", stats.getCollectionRecreateCount());
        values.put(measurementUnit, name, "CollectionFetchCount", stats.getCollectionFetchCount());
        values.put(measurementUnit, name, "SecondLevelCacheHitCount", stats.getSecondLevelCacheHitCount());
        values.put(measurementUnit, name, "SecondLevelCacheMissCount", stats.getSecondLevelCacheMissCount());
        values.put(measurementUnit, name, "SecondLevelCachePutCount", stats.getSecondLevelCachePutCount());
        values.put(measurementUnit, name, "QueryExecutionCount", stats.getQueryExecutionCount());
        values.put(measurementUnit, name, "QueryExecutionMaxTime", stats.getQueryExecutionMaxTime());
        values.put(measurementUnit, name, "QueryCacheHitCount", stats.getQueryCacheHitCount());
        values.put(measurementUnit, name, "QueryCacheMissCount", stats.getQueryCacheMissCount());
        values.put(measurementUnit, name, "QueryCachePutCount", stats.getQueryCachePutCount());
        values.put(measurementUnit, name, "TransactionCount", stats.getTransactionCount());
        values.put(measurementUnit, name, "OptimisticFailureCount", stats.getOptimisticFailureCount());

        // TODO What about?
        // sessionFactory.getStatistics().getEntityStatistics(<parameter from setup? OR loop?>).
        // sessionFactory.getStatistics().getCollectionStatistics(<parameter from setup? OR loop?>)
        // sessionFactory.getStatistics().getQueryStatistics(<<parameter from setup? OR loop?>)
    }
}

From source file:org.beangle.ems.dev.hibernate.web.action.CacheAction.java

License:Open Source License

public String index() {
    Statistics statistics = sessionFactory.getStatistics();
    Date lastUpdate = new Date();
    Date activation = null;//from w w w. ja  va 2s . c  o m
    Date deactivation = null;

    List<Long> generalStatistics = CollectUtils.newArrayList(18);
    final String action = get("do");
    final StringBuilder info = new StringBuilder(512);

    if ("activate".equals(action) && !statistics.isStatisticsEnabled()) {
        statistics.setStatisticsEnabled(true);
        activation = new Date();
        getSession().put("hibernate.stat.activation", activation);
        getSession().remove("hibernate.stat.deactivation");
        info.append("Statistics enabled\n");
    } else if ("deactivate".equals(action) && statistics.isStatisticsEnabled()) {
        statistics.setStatisticsEnabled(false);
        deactivation = new Date();
        getSession().put("hibernate.stat.deactivation", deactivation);
        activation = (Date) getSession().get("hibernate.stat.activation");
        info.append("Statistics disabled\n");
    } else if ("clear".equals(action)) {
        activation = null;
        deactivation = null;
        statistics.clear();
        getSession().remove("hibernate.stat.activation");
        getSession().remove("hibernate.stat.deactivation");
        generalStatistics.clear();
        info.append("Statistics cleared\n");
    } else {
        activation = (Date) getSession().get("hibernate.stat.activation");
        deactivation = (Date) getSession().get("hibernate.stat.deactivation");
    }

    if (info.length() > 0)
        addMessage(info.toString());

    boolean active = statistics.isStatisticsEnabled();
    if (active) {
        generalStatistics.add(statistics.getConnectCount());
        generalStatistics.add(statistics.getFlushCount());

        generalStatistics.add(statistics.getPrepareStatementCount());
        generalStatistics.add(statistics.getCloseStatementCount());

        generalStatistics.add(statistics.getSessionCloseCount());
        generalStatistics.add(statistics.getSessionOpenCount());

        generalStatistics.add(statistics.getTransactionCount());
        generalStatistics.add(statistics.getSuccessfulTransactionCount());
        generalStatistics.add(statistics.getOptimisticFailureCount());
    }
    put("active", active);
    put("lastUpdate", lastUpdate);
    if (null != activation) {
        if (null != deactivation) {
            put("duration", deactivation.getTime() - activation.getTime());
        } else {
            put("duration", lastUpdate.getTime() - activation.getTime());
        }
    }
    put("activation", activation);
    put("deactivation", deactivation);
    put("generalStatistics", generalStatistics);
    return forward();
}

From source file:org.glite.security.voms.admin.core.tasks.LogHibernateStatsTask.java

License:Apache License

@Override
public void run() {

    Statistics stats = HibernateFactory.getFactory().getStatistics();
    if (stats != null) {
        LOG.info("Logging statistics....");
        LOG.info("start time: {}", stats.getStartTime());
        LOG.info("sessions opened: {}", stats.getSessionOpenCount());
        LOG.info("sessions closed: {}", stats.getSessionCloseCount());
        LOG.info("transactions: {}", stats.getTransactionCount());
        LOG.info("successful transactions: {}", stats.getSuccessfulTransactionCount());
        LOG.info("optimistic lock failures: {}", stats.getOptimisticFailureCount());
        LOG.info("flushes: {}", stats.getFlushCount());
        LOG.info("connections obtained: {}", stats.getConnectCount());
        LOG.info("statements prepared: {}", stats.getPrepareStatementCount());
        LOG.info("statements closed: {}", stats.getCloseStatementCount());
        LOG.info("second level cache puts: {}", stats.getSecondLevelCachePutCount());
        LOG.info("second level cache hits: {}", stats.getSecondLevelCacheHitCount());
        LOG.info("second level cache misses: {}", stats.getSecondLevelCacheMissCount());
        LOG.info("entities loaded: {}", stats.getEntityLoadCount());
        LOG.info("entities updated: {}", stats.getEntityUpdateCount());
        LOG.info("entities inserted: {}", stats.getEntityInsertCount());
        LOG.info("entities deleted: {}", stats.getEntityDeleteCount());
        LOG.info("entities fetched (minimize this): {}", stats.getEntityFetchCount());
        LOG.info("collections loaded: {}", stats.getCollectionLoadCount());
        LOG.info("collections updated: {}", stats.getCollectionUpdateCount());
        LOG.info("collections removed: {}", stats.getCollectionRemoveCount());
        LOG.info("collections recreated: {}", stats.getCollectionRecreateCount());
        LOG.info("collections fetched (minimize this): {}", stats.getCollectionFetchCount());
        LOG.info("queries executed to database: {}", stats.getQueryExecutionCount());
        LOG.info("query cache puts: {}", stats.getQueryCachePutCount());
        LOG.info("query cache hits: {}", stats.getQueryCacheMissCount());
        LOG.info("query cache misses: {}", stats.getQueryCacheMissCount());
        LOG.info("max query time: {} ms, for query {}", stats.getQueryExecutionMaxTime(),
                stats.getQueryExecutionMaxTimeQueryString());
    }/*from w w  w  . j a va2  s .  c o m*/
}

From source file:org.jboss.as.jpa.hibernate4.management.HibernateManagementAdaptor.java

License:Open Source License

private void registerStatisticAttributes(ManagementResourceRegistration jpaHibernateRegistration) {

    /**//from  w w  w. j  a  v a2 s . c om
     * Get global number of entity deletes
     * @return entity deletion count
     */
    jpaHibernateRegistration.registerMetric(OPERATION_ENTITY_DELETE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getEntityDeleteCount());
        }
    });

    /**
     * Get global number of entity inserts
     * @return entity insertion count
     */
    jpaHibernateRegistration.registerMetric(OPERATION_ENTITY_INSERT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getEntityInsertCount());
        }
    });

    /**
     * Get global number of entity loads
     * @return entity load (from DB)
     */
    jpaHibernateRegistration.registerMetric(OPERATION_ENTITY_LOAD_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getEntityLoadCount());
        }
    });

    /**
     * Get global number of entity fetchs
     * @return entity fetch (from DB)
     */
    jpaHibernateRegistration.registerMetric(OPERATION_ENTITY_FETCH_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getEntityFetchCount());
        }
    });

    /**
     * Get global number of entity updates
     * @return entity update
     */
    jpaHibernateRegistration.registerMetric(OPERATION_ENTITY_UPDATE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getEntityUpdateCount());
        }
    });

    /**
     * Get global number of executed queries
     * @return query execution count
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_EXECUTION_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getQueryExecutionCount());
        }
    });

    /**
     * Get the time in milliseconds of the slowest query.
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_EXECUTION_MAX_TIME, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getQueryExecutionMaxTime());
        }
    });

    /**
     * Get the query string for the slowest query.
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_EXECUTION_MAX_TIME_QUERY_STRING,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    String sql = stats.getQueryExecutionMaxTimeQueryString();
                    if (sql != null) {
                        response.set(sql);
                    } else {
                        context.getResult(); // result will be undefined
                    }
                }
            });

    /**
     * Get the global number of cached queries successfully retrieved from cache
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_CACHE_HIT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getQueryCacheHitCount());
        }
    });

    /**
     * Get the global number of cached queries *not* found in cache
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_CACHE_MISS_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getQueryCacheMissCount());
        }
    });

    /**
     * Get the global number of cacheable queries put in cache
     */
    jpaHibernateRegistration.registerMetric(OPERATION_QUERY_CACHE_PUT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getQueryCachePutCount());
        }
    });

    /**
     * Get the global number of flush executed by sessions (either implicit or explicit)
     */
    jpaHibernateRegistration.registerMetric(OPERATION_FLUSH_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getFlushCount());
        }
    });

    /**
     * Get the global number of connections asked by the sessions
     * (the actual number of connections used may be much smaller depending
     * whether you use a connection pool or not)
     */
    jpaHibernateRegistration.registerMetric(OPERATION_CONNECT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getConnectCount());
        }
    });

    /**
     * Global number of cacheable entities/collections successfully retrieved from the cache
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SECOND_LEVEL_CACHE_HIT_COUNT,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.getSecondLevelCacheHitCount());
                }
            });

    /**
     * Global number of cacheable entities/collections not found in the cache and loaded from the database.
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SECOND_LEVEL_CACHE_MISS_COUNT,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.getSecondLevelCacheMissCount());
                }
            });

    /**
     * Global number of cacheable entities/collections put in the cache
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SECOND_LEVEL_CACHE_PUT_COUNT,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.getSecondLevelCachePutCount());
                }
            });

    /**
     * Global number of sessions closed
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SESSION_CLOSE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getSessionCloseCount());
        }
    });

    /**
     * Global number of sessions opened
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SESSION_OPEN_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getSessionOpenCount());
        }
    });

    /**
     * Global number of collections loaded
     */
    jpaHibernateRegistration.registerMetric(OPERATION_COLLECTION_LOAD_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCollectionLoadCount());
        }
    });

    /**
     * Global number of collections fetched
     */
    jpaHibernateRegistration.registerMetric(OPERATION_COLLECTION_FETCH_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCollectionFetchCount());
        }
    });

    /**
     * Global number of collections updated
     */
    jpaHibernateRegistration.registerMetric(OPERATION_COLLECTION_UPDATE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCollectionUpdateCount());
        }
    });

    /**
     * Global number of collections removed
     */
    //even on inverse="true"
    jpaHibernateRegistration.registerMetric(OPERATION_COLLECTION_REMOVE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCollectionRemoveCount());
        }
    });

    /**
     * Global number of collections recreated
     */
    jpaHibernateRegistration.registerMetric(OPERATION_COLLECTION_RECREATED_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCollectionRecreateCount());
        }
    });

    /**
     * The number of transactions we know to have been successful
     */
    jpaHibernateRegistration.registerMetric(OPERATION_SUCCESSFUL_TRANSACTION_COUNT,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.getSuccessfulTransactionCount());
                }
            });

    /**
     * The number of transactions we know to have completed
     */
    jpaHibernateRegistration.registerMetric(OPERATION_COMPLETED_TRANSACTION_COUNT,
            new AbstractMetricsHandler() {
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.getTransactionCount());
                }
            });

    /**
     * The number of prepared statements that were acquired
     */
    jpaHibernateRegistration.registerMetric(OPERATION_PREPARED_STATEMENT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getPrepareStatementCount());
        }
    });

    /**
     * The number of prepared statements that were released
     */
    jpaHibernateRegistration.registerMetric(OPERATION_CLOSE_STATEMENT_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getCloseStatementCount());
        }
    });

    /**
     * The number of <tt>StaleObjectStateException</tt>s
     * that occurred
     */
    jpaHibernateRegistration.registerMetric(OPERATION_OPTIMISTIC_FAILURE_COUNT, new AbstractMetricsHandler() {
        @Override
        void handle(final ModelNode response, final String name, Statistics stats, OperationContext context) {
            response.set(stats.getOptimisticFailureCount());
        }
    });

    /**
     * enable/disable statistics attribute
     */
    // void registerReadWriteAttribute(String attributeName, OperationStepHandler readHandler, OperationStepHandler writeHandler, AttributeAccess.Storage storage);
    jpaHibernateRegistration.registerReadWriteAttribute(OPERATION_STATISTICS_ENABLED,
            new AbstractMetricsHandler() { // readHandler
                @Override
                void handle(final ModelNode response, final String name, Statistics stats,
                        OperationContext context) {
                    response.set(stats.isStatisticsEnabled());
                }
            }, StatisticsEnabledWriteHandler.INSTANCE, AttributeAccess.Storage.RUNTIME);

}

From source file:org.olat.restapi.system.DatabaseWebService.java

License:Apache License

private HibernateStatisticsVO getHibernateStatistics() {

    Statistics statistics = DBFactory.getInstance().getStatistics();
    if (!statistics.isStatisticsEnabled()) {
        return null;
    }/*  w ww  .  j av  a  2  s .c  o  m*/

    HibernateStatisticsVO stats = new HibernateStatisticsVO();
    stats.setOpenSessionsCount(statistics.getSessionOpenCount());
    stats.setTransactionsCount(statistics.getTransactionCount());
    stats.setSuccessfulTransactionCount(statistics.getSuccessfulTransactionCount());
    stats.setFailedTransactionsCount(
            statistics.getTransactionCount() - statistics.getSuccessfulTransactionCount());
    stats.setOptimisticFailureCount(statistics.getOptimisticFailureCount());
    stats.setQueryExecutionCount(statistics.getQueryExecutionCount());
    stats.setQueryExecutionMaxTime(statistics.getQueryExecutionMaxTime());
    stats.setQueryExecutionMaxTimeQueryString(statistics.getQueryExecutionMaxTimeQueryString());
    return stats;
}

From source file:org.unitime.commons.hibernate.stats.StatsProvider.java

License:Open Source License

/**
 * Format statistics in HTML/*from  ww w . ja v a2 s. c o m*/
 * @param sessionFactory Hibernate Session Factory
 * @param summaryOnly true - Display only summary info
 * @return HTML String
 */
public String getStatsHtml(SessionFactory sessionFactory, boolean summaryOnly) {

    StringBuffer hibStats = new StringBuffer();

    try {
        // Get statistics
        Statistics stats = sessionFactory.getStatistics();

        // Checks statistics enabled
        if (!stats.isStatisticsEnabled()) {
            return "<font color='red'><b>Hibernate statistics is not enabled.</b></font>";
        }

        // Row Color for even numbered rows
        String evenRowColor = "#FAFAFA";

        // Generate HTML table
        Table table = new Table();
        table.setWidth("100%");
        table.setBorder(0);
        table.setCellSpacing(0);
        table.setCellPadding(3);

        // Links
        StringBuffer links = new StringBuffer("");

        links.append("<A class=\"l7\" href=\"#Entity\">Entity</A>");
        if (!summaryOnly)
            links.append(" - <A class=\"l7\" href=\"#EntityDetail\">Detail</A>");

        links.append(" | <A class=\"l7\" href=\"#Collection\">Collection</A>");
        if (!summaryOnly)
            links.append(" - <A class=\"l7\" href=\"#CollectionDetail\">Detail</A>");

        links.append(" | <A class=\"l7\" href=\"#SecondLevelCache\">Second Level Cache</A>");
        if (!summaryOnly)
            links.append(" - <A class=\"l7\" href=\"#SecondLevelCacheDetail\">Detail</A>");

        links.append(" | <A class=\"l7\" href=\"#Query\">Query</A>");
        if (!summaryOnly)
            links.append(" - <A class=\"l7\" href=\"#QueryDetail\">Detail</A>");

        TableRow row = new TableRow();
        row.addContent(cell(links.toString(), 1, 2, true, "center", "middle"));
        table.addContent(row);

        // Link to top
        TableRow linkToTop = new TableRow();
        linkToTop.addContent(
                cell("<A class=\"l7\" href=\"#BackToTop\">Back to Top</A>", 1, 2, true, "right", "middle"));

        // ---------------------- Overall Stats ------------------------
        row = new TableRow();
        row.addContent(headerCell("<A name=\"BackToTop\">Metric</A>", 1, 1));
        row.addContent(headerCell("Value", 1, 1));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Start Time", 1, 1, true));
        row.addContent(cell(new Date(stats.getStartTime()).toString(), 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Connect Count", 1, 1, true));
        row.addContent(cell(stats.getConnectCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Flush Count", 1, 1, true));
        row.addContent(cell(stats.getFlushCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Session Open Count", 1, 1, true));
        row.addContent(cell(stats.getSessionOpenCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Session Close Count", 1, 1, true));
        row.addContent(cell(stats.getSessionCloseCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Transaction Count", 1, 1, true));
        row.addContent(cell(stats.getTransactionCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Successful Transaction Count", 1, 1, true));
        row.addContent(cell(stats.getSuccessfulTransactionCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Prepare Statement Count", 1, 1, true));
        row.addContent(cell(stats.getPrepareStatementCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Close Statement Count", 1, 1, true));
        row.addContent(cell(stats.getCloseStatementCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Optimistic Failure Count", 1, 1, true));
        row.addContent(cell(stats.getOptimisticFailureCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell("<hr>", 1, 2, false));
        table.addContent(row);

        // ---------------------- Entity Stats ------------------------
        row = new TableRow();
        row.addContent(headerCell("<A name=\"Entity\">Entity</A>:", 1, 2));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Fetch Count", 1, 1, true));
        row.addContent(cell(stats.getEntityFetchCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Load Count", 1, 1, true));
        row.addContent(cell(stats.getEntityLoadCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Insert Count", 1, 1, true));
        row.addContent(cell(stats.getEntityInsertCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Update Count", 1, 1, true));
        row.addContent(cell(stats.getEntityUpdateCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Delete Count", 1, 1, true));
        row.addContent(cell(stats.getEntityDeleteCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell("<hr>", 1, 2, false));
        table.addContent(row);

        table.addContent(linkToTop);

        // ---------------------- Detailed Entity Stats ------------------------

        if (!summaryOnly) {

            row = new TableRow();
            row.addContent(headerCell("<A name=\"EntityDetail\">Entity Statistics Detail</A>:", 1, 2));
            table.addContent(row);

            String[] cEntityNames = stats.getEntityNames();

            if (cEntityNames == null || cEntityNames.length == 0) {
                row = new TableRow();
                row.addContent(cell("No entity names found", 1, 2, false));
                table.addContent(row);
            } else {
                Table subTable = new Table();
                subTable.setCellSpacing(1);
                subTable.setCellPadding(3);

                row = new TableRow();
                row.addContent(headerCell(" &nbsp; ", 1, 1));
                row.addContent(headerCell(" Fetches ", 1, 1));
                row.addContent(headerCell(" Loads ", 1, 1));
                row.addContent(headerCell(" Inserts ", 1, 1));
                row.addContent(headerCell(" Updates ", 1, 1));
                row.addContent(headerCell(" Deletes ", 1, 1));
                subTable.addContent(row);

                for (int i = 0; i < cEntityNames.length; i++) {
                    String entityName = cEntityNames[i];
                    EntityStatistics eStats = stats.getEntityStatistics(entityName);

                    row = new TableRow();
                    if (i % 2 == 0)
                        row.setBgColor(evenRowColor);
                    row.addContent(cell(entityName + " &nbsp;", 1, 1, true));
                    row.addContent(cell(eStats.getFetchCount() + "", 1, 1, false));
                    row.addContent(cell(eStats.getLoadCount() + "", 1, 1, false));
                    row.addContent(cell(eStats.getInsertCount() + "", 1, 1, false));
                    row.addContent(cell(eStats.getUpdateCount() + "", 1, 1, false));
                    row.addContent(cell(eStats.getDeleteCount() + "", 1, 1, false));
                    subTable.addContent(row);
                }

                row = new TableRow();
                row.addContent(cell(subTable.toHtml(), 1, 2, true));
                table.addContent(row);
            }

            row = new TableRow();
            row.addContent(cell("<hr>", 1, 2, false));
            table.addContent(row);

            table.addContent(linkToTop);
        }

        // ---------------------- Collection Stats ------------------------
        row = new TableRow();
        row.addContent(headerCell("<A name=\"Collection\">Collection</A>:", 1, 2));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Fetch Count", 1, 1, true));
        row.addContent(cell(stats.getCollectionFetchCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Load Count", 1, 1, true));
        row.addContent(cell(stats.getCollectionLoadCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Update Count", 1, 1, true));
        row.addContent(cell(stats.getCollectionUpdateCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Remove Count", 1, 1, true));
        row.addContent(cell(stats.getCollectionRemoveCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Recreate Count", 1, 1, true));
        row.addContent(cell(stats.getCollectionRecreateCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell("<hr>", 1, 2, false));
        table.addContent(row);

        table.addContent(linkToTop);

        // ---------------------- Detailed Collection Stats ------------------------
        if (!summaryOnly) {

            row = new TableRow();
            row.addContent(headerCell("<A name=\"CollectionDetail\">Collection Statistics Detail</A>:", 1, 2));
            table.addContent(row);

            String[] cRoleNames = stats.getCollectionRoleNames();

            if (cRoleNames == null || cRoleNames.length == 0) {
                row = new TableRow();
                row.addContent(cell("No collection roles found", 1, 2, false));
                table.addContent(row);
            } else {
                Table subTable = new Table();
                subTable.setCellSpacing(1);
                subTable.setCellPadding(3);

                row = new TableRow();
                row.addContent(headerCell(" &nbsp; ", 1, 1));
                row.addContent(headerCell(" Fetches ", 1, 1));
                row.addContent(headerCell(" Loads ", 1, 1));
                row.addContent(headerCell(" Updates ", 1, 1));
                row.addContent(headerCell(" Removes ", 1, 1));
                row.addContent(headerCell(" Recreates ", 1, 1));
                subTable.addContent(row);

                for (int i = 0; i < cRoleNames.length; i++) {
                    String roleName = cRoleNames[i];
                    CollectionStatistics cStats = stats.getCollectionStatistics(roleName);

                    row = new TableRow();
                    if (i % 2 == 0)
                        row.setBgColor(evenRowColor);
                    row.addContent(cell(roleName + " &nbsp;", 1, 1, true));
                    row.addContent(cell(cStats.getFetchCount() + "", 1, 1, false));
                    row.addContent(cell(cStats.getLoadCount() + "", 1, 1, false));
                    row.addContent(cell(cStats.getUpdateCount() + "", 1, 1, false));
                    row.addContent(cell(cStats.getRemoveCount() + "", 1, 1, false));
                    row.addContent(cell(cStats.getRecreateCount() + "", 1, 1, false));
                    subTable.addContent(row);
                }

                row = new TableRow();
                row.addContent(cell(subTable.toHtml(), 1, 2, true));
                table.addContent(row);
            }

            row = new TableRow();
            row.addContent(cell("<hr>", 1, 2, false));
            table.addContent(row);

            table.addContent(linkToTop);
        }

        // ---------------------- Second Level Cache Stats ------------------------
        row = new TableRow();
        row.addContent(headerCell("<A name=\"SecondLevelCache\">Second Level Cache</A>:", 1, 2));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Hit Count", 1, 1, true));
        row.addContent(cell(stats.getSecondLevelCacheHitCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Miss Count", 1, 1, true));
        row.addContent(cell(stats.getSecondLevelCacheMissCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Put Count", 1, 1, true));
        row.addContent(cell(stats.getSecondLevelCachePutCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell("<hr>", 1, 2, false));
        table.addContent(row);

        table.addContent(linkToTop);

        // ---------------------- Detailed Second Level Cache Stats ------------------------
        if (!summaryOnly) {

            row = new TableRow();
            row.addContent(headerCell(
                    "<A name=\"SecondLevelCacheDetail\">Second Level Cache Statistics Detail</A>:", 1, 2));
            table.addContent(row);

            String[] cRegionNames = stats.getSecondLevelCacheRegionNames();

            if (cRegionNames == null || cRegionNames.length == 0) {
                row = new TableRow();
                row.addContent(cell("No region names found", 1, 2, false));
                table.addContent(row);
            } else {
                Table subTable = new Table();
                subTable.setCellSpacing(1);
                subTable.setCellPadding(3);

                row = new TableRow();
                row.addContent(headerCell(" &nbsp; ", 1, 1));
                row.addContent(headerCell(" Entities ", 1, 1));
                row.addContent(headerCell(" Hits ", 1, 1));
                row.addContent(headerCell(" Misses ", 1, 1));
                row.addContent(headerCell(" Puts ", 1, 1));
                row.addContent(headerCell(" In Memory ", 1, 1));
                row.addContent(headerCell(" On Disk ", 1, 1));
                row.addContent(headerCell(" Memory ", 1, 1));
                subTable.addContent(row);

                long elementsInMem = 0, elementsOnDisk = 0, putCnt = 0, missCnt = 0, hitCnt = 0, size = 0;

                for (int i = 0; i < cRegionNames.length; i++) {
                    String cRegionName = cRegionNames[i];
                    SecondLevelCacheStatistics sStats = stats.getSecondLevelCacheStatistics(cRegionName);

                    row = new TableRow();
                    if (i % 2 == 0)
                        row.setBgColor(evenRowColor);
                    row.addContent(cell(cRegionName + " &nbsp;", 1, 1, true));
                    row.addContent(cell(
                            String.valueOf(sStats.getElementCountInMemory() + sStats.getElementCountOnDisk()),
                            1, 1, false)); //sStats.getEntries().size()
                    row.addContent(cell(sStats.getHitCount() + "", 1, 1, false));
                    row.addContent(cell(sStats.getMissCount() + "", 1, 1, false));
                    row.addContent(cell(sStats.getPutCount() + "", 1, 1, false));
                    row.addContent(cell(sStats.getElementCountInMemory() + "", 1, 1, false));
                    row.addContent(cell(sStats.getElementCountOnDisk() + "", 1, 1, false));
                    row.addContent(cell(sStats.getSizeInMemory() + " bytes", 1, 1, false));
                    elementsInMem += sStats.getElementCountInMemory();
                    elementsOnDisk += sStats.getElementCountOnDisk();
                    putCnt += sStats.getPutCount();
                    missCnt += sStats.getMissCount();
                    hitCnt += sStats.getHitCount();
                    size += sStats.getSizeInMemory();
                    subTable.addContent(row);
                }

                row = new TableRow();
                row.addContent(headerCell("Total &nbsp;", 1, 1));
                row.addContent(headerCell("" + (elementsInMem + elementsOnDisk), 1, 1));
                row.addContent(headerCell("" + hitCnt, 1, 1));
                row.addContent(headerCell("" + missCnt, 1, 1));
                row.addContent(headerCell("" + putCnt, 1, 1));
                row.addContent(headerCell("" + elementsInMem, 1, 1));
                row.addContent(headerCell("" + elementsOnDisk, 1, 1));
                row.addContent(headerCell(size + " bytes", 1, 1));
                subTable.addContent(row);

                row = new TableRow();
                row.addContent(cell(subTable.toHtml(), 1, 2, true));
                table.addContent(row);
            }

            row = new TableRow();
            row.addContent(cell("<hr>", 1, 2, false));
            table.addContent(row);

            table.addContent(linkToTop);
        }

        // ---------------------- Query Stats ------------------------
        row = new TableRow();
        row.addContent(headerCell("<A name=\"Query\">Query</A>:", 1, 2));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Execution Count", 1, 1, true));
        row.addContent(cell(stats.getQueryExecutionCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Execution Max Time", 1, 1, true));
        row.addContent(cell(stats.getQueryExecutionMaxTime() + " ms", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Cache Hit Count", 1, 1, true));
        row.addContent(cell(stats.getQueryCacheHitCount() + " ms", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Cache Miss Count", 1, 1, true));
        row.addContent(cell(stats.getQueryCacheMissCount() + " ms", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell(" &nbsp; Cache Put Count", 1, 1, true));
        row.addContent(cell(stats.getQueryCachePutCount() + "", 1, 1, false));
        table.addContent(row);

        row = new TableRow();
        row.addContent(cell("<hr>", 1, 2, false));
        table.addContent(row);

        table.addContent(linkToTop);

        // ---------------------- Detailed Query Stats ------------------------
        if (!summaryOnly) {

            row = new TableRow();
            row.addContent(headerCell("<A name=\"QueryDetail\">Query Statistics Detail</A>:", 1, 2));
            table.addContent(row);

            String[] cQueryStrings = stats.getQueries();

            if (cQueryStrings == null || cQueryStrings.length == 0) {
                row = new TableRow();
                row.addContent(cell("No query strings found", 1, 2, false));
                table.addContent(row);
            } else {
                Table subTable = new Table();
                subTable.setCellSpacing(1);
                subTable.setCellPadding(3);

                row = new TableRow();
                row.addContent(headerCell(" &nbsp; ", 1, 1));
                row.addContent(headerCell(" Execs ", 1, 1));
                row.addContent(headerCell(" Rows ", 1, 1));
                row.addContent(headerCell(" Max Time ", 1, 1));
                row.addContent(headerCell(" Min Time ", 1, 1));
                row.addContent(headerCell(" Avg Time ", 1, 1));
                row.addContent(headerCell(" Cache Hits ", 1, 1));
                row.addContent(headerCell(" Cache Misses ", 1, 1));
                row.addContent(headerCell(" Cache Puts ", 1, 1));
                subTable.addContent(row);

                for (int i = 0; i < cQueryStrings.length; i++) {
                    String cQueryString = cQueryStrings[i];
                    QueryStatistics qStats = stats.getQueryStatistics(cQueryString);

                    row = new TableRow();
                    if (i % 2 == 0)
                        row.setBgColor(evenRowColor);
                    row.addContent(cell(cQueryString + " &nbsp;", 1, 1, false));
                    row.addContent(cell(qStats.getExecutionCount() + "", 1, 1, false));
                    row.addContent(cell(qStats.getExecutionRowCount() + "", 1, 1, false));
                    row.addContent(cell(qStats.getExecutionMaxTime() + " ms", 1, 1, false));
                    row.addContent(cell(qStats.getExecutionMinTime() + " ms", 1, 1, false));
                    row.addContent(cell(qStats.getExecutionAvgTime() + " ms", 1, 1, false));
                    row.addContent(cell(qStats.getCacheHitCount() + "", 1, 1, false));
                    row.addContent(cell(qStats.getCacheMissCount() + "", 1, 1, false));
                    row.addContent(cell(qStats.getCachePutCount() + "", 1, 1, false));
                    subTable.addContent(row);
                }

                row = new TableRow();
                row.addContent(cell(subTable.toHtml(), 1, 2, true));
                table.addContent(row);
            }

            row = new TableRow();
            row.addContent(cell("<hr>", 1, 2, false));
            table.addContent(row);

            table.addContent(linkToTop);
        }

        // Add to generated HTML
        hibStats.append(table.toHtml());
    } catch (Exception e) {
        hibStats.append("Exception occured: " + e.getMessage());
        e.printStackTrace();
    }

    return hibStats.toString();
}