com.arangodb.entity.CursorStats Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of arangodb-java-driver-shaded Show documentation
ArangoDB Java Driver Shaded
There is a newer version: 7.13.0
Show newest version
package com.arangodb.entity;

import com.arangodb.shaded.fasterxml.jackson.annotation.JsonAnySetter;

import java.util.HashMap;
import java.util.Map;

public final class CursorStats {
    private final Map properties = new HashMap<>();
    private Long writesExecuted;
    private Long writesIgnored;
    private Long scannedFull;
    private Long scannedIndex;
    private Long cursorsCreated;
    private Long cursorsRearmed;
    private Long cacheHits;
    private Long cacheMisses;
    private Long filtered;
    private Long httpRequests;
    private Long fullCount;
    private Double executionTime;
    private Long peakMemoryUsage;

    @JsonAnySetter
    public void add(String key, Object value) {
        properties.put(key, value);
    }

    public Object get(String key) {
        return properties.get(key);
    }

    /**
     * @return The total number of data-modification operations successfully executed.
     */
    public Long getWritesExecuted() {
        return writesExecuted;
    }

    /**
     * @return The total number of data-modification operations that were unsuccessful, but have been ignored because of
     * the ignoreErrors query option.
     */
    public Long getWritesIgnored() {
        return writesIgnored;
    }

    /**
     * @return The total number of documents iterated over when scanning a collection without an index. Documents
     * scanned by subqueries are included in the result, but operations triggered by built-in or user-defined AQL
     * functions are not.
     */
    public Long getScannedFull() {
        return scannedFull;
    }

    /**
     * @return The total number of documents iterated over when scanning a collection using an index. Documents scanned
     * by subqueries are included in the result, but operations triggered by built-in or user-defined AQL functions are
     * not.
     */
    public Long getScannedIndex() {
        return scannedIndex;
    }

    /**
     * @return The total number of cursor objects created during query execution. Cursor objects are created for index
     * lookups.
     */
    public Long getCursorsCreated() {
        return cursorsCreated;
    }

    /**
     * @return The total number of times an existing cursor object was repurposed. Repurposing an existing cursor object
     * is normally more efficient compared to destroying an existing cursor object and creating a new one from scratch.
     */
    public Long getCursorsRearmed() {
        return cursorsRearmed;
    }

    /**
     * @return The total number of index entries read from in-memory caches for indexes of type edge or persistent. This
     * value is only non-zero when reading from indexes that have an in-memory cache enabled, and when the query allows
     * using the in-memory cache (i.e. using equality lookups on all index attributes).
     */
    public Long getCacheHits() {
        return cacheHits;
    }

    /**
     * @return The total number of cache read attempts for index entries that could not be served from in-memory caches
     * for indexes of type edge or persistent. This value is only non-zero when reading from indexes that have an
     * in-memory cache enabled, the query allows using the in-memory cache (i.e. using equality lookups on all index
     * attributes) and the looked up values are not present in the cache.
     */
    public Long getCacheMisses() {
        return cacheMisses;
    }

    /**
     * @return The total number of documents removed after executing a filter condition in a FilterNode or another node
     * that post-filters data. Note that nodes of the IndexNode type can also filter documents by selecting only the
     * required index range from a collection, and the filtered value only indicates how much filtering was done by a
     * post filter in the IndexNode itself or following FilterNode nodes. Nodes of the EnumerateCollectionNode and
     * TraversalNode types can also apply filter conditions and can report the number of filtered documents.
     */
    public Long getFiltered() {
        return filtered;
    }

    /**
     * @return The total number of cluster-internal HTTP requests performed.
     */
    public Long getHttpRequests() {
        return httpRequests;
    }

    /**
     * @return The total number of documents that matched the search condition if the query’s final top-level LIMIT
     * operation were not present. This attribute may only be returned if the fullCount option was set when starting the
     * query and only contains a sensible value if the query contains a LIMIT operation on the top level.
     */
    public Long getFullCount() {
        return fullCount;
    }

    /**
     * @return The query execution time (wall-clock time) in seconds.
     */
    public Double getExecutionTime() {
        return executionTime;
    }

    /**
     * @return The maximum memory usage of the query while it was running. In a cluster, the memory accounting is done
     * per shard, and the memory usage reported is the peak memory usage value from the individual shards. Note that to
     * keep things lightweight, the per-query memory usage is tracked on a relatively high level, not including any
     * memory allocator overhead nor any memory used for temporary results calculations (e.g. memory
     * allocated/deallocated inside AQL expressions and function calls).
     */
    public Long getPeakMemoryUsage() {
        return peakMemoryUsage;
    }
}