The functions, handles and methods applications use to access and manage data with WiredTiger. More...
Classes | |
struct | WT_ITEM |
A raw item of data to be managed, including a pointer to the data and a length. More... | |
struct | WT_MODIFY |
A set of modifications for a value, including a pointer to new data and a length, plus a target offset in the value and an optional length of data in the value to be replaced. More... | |
struct | WT_CURSOR |
A WT_CURSOR handle is the interface to a cursor. More... | |
struct | WT_SESSION |
All data operations are performed in the context of a WT_SESSION. More... | |
struct | WT_CONNECTION |
A connection to a WiredTiger database. More... | |
struct | WT_EVENT_HANDLER |
The interface implemented by applications to handle error, informational and progress messages. More... | |
struct | WT_CONFIG_ITEM |
The configuration information returned by the WiredTiger configuration parsing functions in the WT_EXTENSION_API and the public API. More... | |
struct | WT_CONFIG_PARSER |
A handle that can be used to search and traverse configuration strings compatible with the WiredTiger API. More... | |
Macros | |
#define | WT_INTPACK64_MAXSIZE |
The maximum packed size of a 64-bit integer. More... | |
#define | WT_INTPACK32_MAXSIZE |
The maximum packed size of a 32-bit integer. More... | |
Enumerations | |
enum | WT_TS_TXN_TYPE { WT_TS_TXN_TYPE_COMMIT, WT_TS_TXN_TYPE_DURABLE, WT_TS_TXN_TYPE_PREPARE, WT_TS_TXN_TYPE_READ } |
WT_SESSION::timestamp_transaction_uint timestamp types. More... | |
enum | WT_EVENT_TYPE { WT_EVENT_COMPACT_CHECK, WT_EVENT_CONN_CLOSE, WT_EVENT_CONN_READY } |
WT_EVENT_HANDLER::special event types. More... | |
Functions | |
int | wiredtiger_open (const char *home, WT_EVENT_HANDLER *event_handler, const char *config, WT_CONNECTION **connectionp) |
Open a connection to a database. More... | |
const char * | wiredtiger_strerror (int error) |
Return information about a WiredTiger error as a string (see WT_SESSION::strerror for a thread-safe API). More... | |
Data packing and unpacking | |
typedef struct __wt_pack_stream | WT_PACK_STREAM |
Streaming interface to packing. More... | |
int | wiredtiger_struct_pack (WT_SESSION *session, void *buffer, size_t len, const char *format,...) |
Pack a structure into a buffer. More... | |
int | wiredtiger_struct_size (WT_SESSION *session, size_t *lenp, const char *format,...) |
Calculate the size required to pack a structure. More... | |
int | wiredtiger_struct_unpack (WT_SESSION *session, const void *buffer, size_t len, const char *format,...) |
Unpack a structure from a buffer. More... | |
int | wiredtiger_pack_start (WT_SESSION *session, const char *format, void *buffer, size_t size, WT_PACK_STREAM **psp) |
Start a packing operation into a buffer with the given format string. More... | |
int | wiredtiger_unpack_start (WT_SESSION *session, const char *format, const void *buffer, size_t size, WT_PACK_STREAM **psp) |
Start an unpacking operation from a buffer with the given format string. More... | |
int | wiredtiger_pack_close (WT_PACK_STREAM *ps, size_t *usedp) |
Close a packing stream. More... | |
int | wiredtiger_pack_item (WT_PACK_STREAM *ps, WT_ITEM *item) |
Pack an item into a packing stream. More... | |
int | wiredtiger_pack_int (WT_PACK_STREAM *ps, int64_t i) |
Pack a signed integer into a packing stream. More... | |
int | wiredtiger_pack_str (WT_PACK_STREAM *ps, const char *s) |
Pack a string into a packing stream. More... | |
int | wiredtiger_pack_uint (WT_PACK_STREAM *ps, uint64_t u) |
Pack an unsigned integer into a packing stream. More... | |
int | wiredtiger_unpack_item (WT_PACK_STREAM *ps, WT_ITEM *item) |
Unpack an item from a packing stream. More... | |
int | wiredtiger_unpack_int (WT_PACK_STREAM *ps, int64_t *ip) |
Unpack a signed integer from a packing stream. More... | |
int | wiredtiger_unpack_str (WT_PACK_STREAM *ps, const char **sp) |
Unpack a string from a packing stream. More... | |
int | wiredtiger_unpack_uint (WT_PACK_STREAM *ps, uint64_t *up) |
Unpack an unsigned integer from a packing stream. More... | |
Configuration strings | |
int | wiredtiger_config_parser_open (WT_SESSION *session, const char *config, size_t len, WT_CONFIG_PARSER **config_parserp) |
Create a handle that can be used to parse or create configuration strings compatible with the WiredTiger API. More... | |
Support functions | |
uint32_t(*)(const void *, size_t) | wiredtiger_crc32c_func (void) |
Return a pointer to a function that calculates a CRC32C checksum. More... | |
uint32_t(*)(uint32_t seed, const void *, size_t) | wiredtiger_crc32c_with_seed_func (void) |
Return a pointer to a function that calculates a CRC32C checksum given a starting CRC seed. More... | |
int | wiredtiger_calc_modify (WT_SESSION *session, const WT_ITEM *oldv, const WT_ITEM *newv, size_t maxdiff, WT_MODIFY *entries, int *nentriesp) |
Calculate a set of WT_MODIFY operations to represent an update. More... | |
const char * | wiredtiger_version (int *majorp, int *minorp, int *patchp) |
Get version information. More... | |
Error returns | |
Most functions and methods in WiredTiger return an integer code indicating whether the operation succeeded or failed. A return of zero indicates success; all non-zero return values indicate some kind of failure. WiredTiger reserves all values from -31,800 to -31,999 as possible error return values. WiredTiger may also return C99/POSIX error codes such as The following are all of the WiredTiger-specific error returns: | |
#define | WT_ROLLBACK |
Conflict between concurrent operations. More... | |
#define | WT_DUPLICATE_KEY |
Attempt to insert an existing key. More... | |
#define | WT_ERROR |
Non-specific WiredTiger error. More... | |
#define | WT_NOTFOUND |
Item not found. More... | |
#define | WT_PANIC |
WiredTiger library panic. More... | |
#define | WT_RUN_RECOVERY |
Recovery must be run to continue. More... | |
#define | WT_CACHE_FULL |
Operation would overflow cache. More... | |
#define | WT_PREPARE_CONFLICT |
Conflict with a prepared update. More... | |
#define | WT_TRY_SALVAGE |
Database corruption detected. More... | |
Incremental backup types | |
#define | WT_BACKUP_INVALID |
Invalid backup type. | |
#define | WT_BACKUP_FILE |
Whole file. | |
#define | WT_BACKUP_RANGE |
File range. | |
Log record and operation types | |
#define | WT_LOGREC_CHECKPOINT |
Checkpoint. | |
#define | WT_LOGREC_COMMIT |
Transaction commit. | |
#define | WT_LOGREC_FILE_SYNC |
File sync. | |
#define | WT_LOGREC_MESSAGE |
Message. | |
#define | WT_LOGREC_SYSTEM |
System/internal record. | |
#define | WT_LOGOP_INVALID |
Invalid operation. | |
#define | WT_LOGOP_COL_PUT |
Column-store put. | |
#define | WT_LOGOP_COL_REMOVE |
Column-store remove. | |
#define | WT_LOGOP_COL_TRUNCATE |
Column-store truncate. | |
#define | WT_LOGOP_ROW_PUT |
Row-store put. | |
#define | WT_LOGOP_ROW_REMOVE |
Row-store remove. | |
#define | WT_LOGOP_ROW_TRUNCATE |
Row-store truncate. | |
#define | WT_LOGOP_CHECKPOINT_START |
Checkpoint start. | |
#define | WT_LOGOP_PREV_LSN |
Previous LSN. | |
#define | WT_LOGOP_COL_MODIFY |
Column-store modify. | |
#define | WT_LOGOP_ROW_MODIFY |
Row-store modify. | |
#define | WT_LOGOP_TXN_TIMESTAMP |
Diagnostic: transaction timestamps. | |
#define | WT_LOGOP_BACKUP_ID |
Incremental backup IDs. | |
Connection statistics | |
Statistics are accessed through cursors with | |
#define | WT_STAT_CONN_LSM_WORK_QUEUE_APP |
LSM: application work units currently queued. | |
#define | WT_STAT_CONN_LSM_WORK_QUEUE_MANAGER |
LSM: merge work units currently queued. | |
#define | WT_STAT_CONN_LSM_ROWS_MERGED |
LSM: rows merged in an LSM tree. | |
#define | WT_STAT_CONN_LSM_CHECKPOINT_THROTTLE |
LSM: sleep for LSM checkpoint throttle. | |
#define | WT_STAT_CONN_LSM_MERGE_THROTTLE |
LSM: sleep for LSM merge throttle. | |
#define | WT_STAT_CONN_LSM_WORK_QUEUE_SWITCH |
LSM: switch work units currently queued. | |
#define | WT_STAT_CONN_LSM_WORK_UNITS_DISCARDED |
LSM: tree maintenance operations discarded. | |
#define | WT_STAT_CONN_LSM_WORK_UNITS_DONE |
LSM: tree maintenance operations executed. | |
#define | WT_STAT_CONN_LSM_WORK_UNITS_CREATED |
LSM: tree maintenance operations scheduled. | |
#define | WT_STAT_CONN_LSM_WORK_QUEUE_MAX |
LSM: tree queue hit maximum. | |
#define | WT_STAT_CONN_AUTOCOMMIT_READONLY_RETRY |
autocommit: retries for readonly operations | |
#define | WT_STAT_CONN_AUTOCOMMIT_UPDATE_RETRY |
autocommit: retries for update operations | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_FAIL |
background-compact: background compact failed calls | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_FAIL_CACHE_PRESSURE |
background-compact: background compact failed calls due to cache pressure | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_INTERRUPTED |
background-compact: background compact interrupted | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_EMA |
background-compact: background compact moving average of bytes rewritten | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_BYTES_RECOVERED |
background-compact: background compact recovered bytes | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_RUNNING |
background-compact: background compact running | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_EXCLUDE |
background-compact: background compact skipped file as it is part of the exclude list | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_SKIPPED |
background-compact: background compact skipped file as not meeting requirements for compaction | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_SLEEP_CACHE_PRESSURE |
background-compact: background compact sleeps due to cache pressure | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_SUCCESS |
background-compact: background compact successful calls | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_TIMEOUT |
background-compact: background compact timeout | |
#define | WT_STAT_CONN_BACKGROUND_COMPACT_FILES_TRACKED |
background-compact: number of files tracked by background compaction | |
#define | WT_STAT_CONN_BACKUP_CURSOR_OPEN |
backup: backup cursor open | |
#define | WT_STAT_CONN_BACKUP_DUP_OPEN |
backup: backup duplicate cursor open | |
#define | WT_STAT_CONN_BACKUP_GRANULARITY |
backup: backup granularity size | |
#define | WT_STAT_CONN_BACKUP_BITS_CLR |
backup: backup total bits cleared | |
#define | WT_STAT_CONN_BACKUP_INCREMENTAL |
backup: incremental backup enabled | |
#define | WT_STAT_CONN_BACKUP_START |
backup: opening the backup cursor in progress | |
#define | WT_STAT_CONN_BACKUP_BLOCKS |
backup: total modified incremental blocks | |
#define | WT_STAT_CONN_BACKUP_BLOCKS_COMPRESSED |
backup: total modified incremental blocks with compressed data | |
#define | WT_STAT_CONN_BACKUP_BLOCKS_UNCOMPRESSED |
backup: total modified incremental blocks without compressed data | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_UPDATE |
block-cache: cached blocks updated | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYTES_UPDATE |
block-cache: cached bytes updated | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_EVICTED |
block-cache: evicted blocks | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_FILESIZE |
block-cache: file size causing bypass | |
#define | WT_STAT_CONN_BLOCK_CACHE_LOOKUPS |
block-cache: lookups | |
#define | WT_STAT_CONN_BLOCK_CACHE_NOT_EVICTED_OVERHEAD |
block-cache: number of blocks not evicted due to overhead | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_WRITEALLOC |
block-cache: number of bypasses because no-write-allocate setting was on | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_OVERHEAD_PUT |
block-cache: number of bypasses due to overhead on put | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_GET |
block-cache: number of bypasses on get | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_PUT |
block-cache: number of bypasses on put because file is too small | |
#define | WT_STAT_CONN_BLOCK_CACHE_EVICTION_PASSES |
block-cache: number of eviction passes | |
#define | WT_STAT_CONN_BLOCK_CACHE_HITS |
block-cache: number of hits | |
#define | WT_STAT_CONN_BLOCK_CACHE_MISSES |
block-cache: number of misses | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYPASS_CHKPT |
block-cache: number of put bypasses on checkpoint I/O | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_REMOVED |
block-cache: removed blocks | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_REMOVED_BLOCKED |
block-cache: time sleeping to remove block (usecs) | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS |
block-cache: total blocks | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_INSERT_READ |
block-cache: total blocks inserted on read path | |
#define | WT_STAT_CONN_BLOCK_CACHE_BLOCKS_INSERT_WRITE |
block-cache: total blocks inserted on write path | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYTES |
block-cache: total bytes | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYTES_INSERT_READ |
block-cache: total bytes inserted on read path | |
#define | WT_STAT_CONN_BLOCK_CACHE_BYTES_INSERT_WRITE |
block-cache: total bytes inserted on write path | |
#define | WT_STAT_CONN_BLOCK_PRELOAD |
block-manager: blocks pre-loaded | |
#define | WT_STAT_CONN_BLOCK_READ |
block-manager: blocks read | |
#define | WT_STAT_CONN_BLOCK_WRITE |
block-manager: blocks written | |
#define | WT_STAT_CONN_BLOCK_BYTE_READ |
block-manager: bytes read | |
#define | WT_STAT_CONN_BLOCK_BYTE_READ_MMAP |
block-manager: bytes read via memory map API | |
#define | WT_STAT_CONN_BLOCK_BYTE_READ_SYSCALL |
block-manager: bytes read via system call API | |
#define | WT_STAT_CONN_BLOCK_BYTE_WRITE |
block-manager: bytes written | |
#define | WT_STAT_CONN_BLOCK_BYTE_WRITE_COMPACT |
block-manager: bytes written by compaction | |
#define | WT_STAT_CONN_BLOCK_BYTE_WRITE_CHECKPOINT |
block-manager: bytes written for checkpoint | |
#define | WT_STAT_CONN_BLOCK_BYTE_WRITE_MMAP |
block-manager: bytes written via memory map API | |
#define | WT_STAT_CONN_BLOCK_BYTE_WRITE_SYSCALL |
block-manager: bytes written via system call API | |
#define | WT_STAT_CONN_BLOCK_MAP_READ |
block-manager: mapped blocks read | |
#define | WT_STAT_CONN_BLOCK_BYTE_MAP_READ |
block-manager: mapped bytes read | |
#define | WT_STAT_CONN_BLOCK_REMAP_FILE_RESIZE |
block-manager: number of times the file was remapped because it changed size via fallocate or truncate | |
#define | WT_STAT_CONN_BLOCK_REMAP_FILE_WRITE |
block-manager: number of times the region was remapped via write | |
#define | WT_STAT_CONN_EVICTION_APP_TIME |
cache: application thread time evicting (usecs) | |
#define | WT_STAT_CONN_CACHE_READ_APP_COUNT |
cache: application threads page read from disk to cache count | |
#define | WT_STAT_CONN_CACHE_READ_APP_TIME |
cache: application threads page read from disk to cache time (usecs) | |
#define | WT_STAT_CONN_CACHE_WRITE_APP_COUNT |
cache: application threads page write from cache to disk count | |
#define | WT_STAT_CONN_CACHE_WRITE_APP_TIME |
cache: application threads page write from cache to disk time (usecs) | |
#define | WT_STAT_CONN_CACHE_BYTES_UPDATES |
cache: bytes allocated for updates | |
#define | WT_STAT_CONN_CACHE_BYTES_IMAGE |
cache: bytes belonging to page images in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_HS |
cache: bytes belonging to the history store table in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_INUSE |
cache: bytes currently in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_DIRTY_TOTAL |
cache: bytes dirty in the cache cumulative | |
#define | WT_STAT_CONN_CACHE_BYTES_OTHER |
cache: bytes not belonging to page images in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_READ |
cache: bytes read into cache | |
#define | WT_STAT_CONN_CACHE_BYTES_WRITE |
cache: bytes written from cache | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_CHECKPOINT |
cache: checkpoint blocked page eviction | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS |
cache: checkpoint of history store file blocked non-history store page eviction | |
#define | WT_STAT_CONN_EVICTION_SERVER_EVICT_ATTEMPT |
cache: evict page attempts by eviction server | |
#define | WT_STAT_CONN_EVICTION_WORKER_EVICT_ATTEMPT |
cache: evict page attempts by eviction worker threads | |
#define | WT_STAT_CONN_EVICTION_SERVER_EVICT_FAIL |
cache: evict page failures by eviction server | |
#define | WT_STAT_CONN_EVICTION_WORKER_EVICT_FAIL |
cache: evict page failures by eviction worker threads | |
#define | WT_STAT_CONN_EVICTION_GET_REF_EMPTY |
cache: eviction calls to get a page found queue empty | |
#define | WT_STAT_CONN_EVICTION_GET_REF_EMPTY2 |
cache: eviction calls to get a page found queue empty after locking | |
#define | WT_STAT_CONN_EVICTION_AGGRESSIVE_SET |
cache: eviction currently operating in aggressive mode | |
#define | WT_STAT_CONN_EVICTION_EMPTY_SCORE |
cache: eviction empty score | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_1 |
cache: eviction gave up due to detecting a disk value without a timestamp behind the last update on the chain | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_2 |
cache: eviction gave up due to detecting a tombstone without a timestamp ahead of the selected on disk update | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_3 |
cache: eviction gave up due to detecting a tombstone without a timestamp ahead of the selected on disk update after validating the update chain | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_4 |
cache: eviction gave up due to detecting update chain entries without timestamps after the selected on disk update | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_REMOVE_HS_RACE_WITH_CHECKPOINT |
cache: eviction gave up due to needing to remove a record from the history store but checkpoint is running | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_NO_PROGRESS |
cache: eviction gave up due to no progress being made | |
#define | WT_STAT_CONN_EVICTION_WALK_PASSES |
cache: eviction passes of a file | |
#define | WT_STAT_CONN_EVICTION_QUEUE_EMPTY |
cache: eviction server candidate queue empty when topping up | |
#define | WT_STAT_CONN_EVICTION_QUEUE_NOT_EMPTY |
cache: eviction server candidate queue not empty when topping up | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_DIRTY_PAGES_DURING_CHECKPOINT |
cache: eviction server skips dirty pages during a running checkpoint | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_INTL_PAGE_WITH_ACTIVE_CHILD |
cache: eviction server skips internal pages as it has an active child. | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_METATDATA_WITH_HISTORY |
cache: eviction server skips metadata pages with history | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_PAGES_LAST_RUNNING |
cache: eviction server skips pages that are written with transactions greater than the last running | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_PAGES_RETRY |
cache: eviction server skips pages that previously failed eviction and likely will again | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_UNWANTED_PAGES |
cache: eviction server skips pages that we do not want to evict | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_UNWANTED_TREE |
cache: eviction server skips tree that we do not want to evict | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_TREES_TOO_MANY_ACTIVE_WALKS |
cache: eviction server skips trees because there are too many active walks | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_CHECKPOINTING_TREES |
cache: eviction server skips trees that are being checkpointed | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_TREES_STICK_IN_CACHE |
cache: eviction server skips trees that are configured to stick in cache | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_TREES_EVICTION_DISABLED |
cache: eviction server skips trees that disable eviction | |
#define | WT_STAT_CONN_EVICTION_SERVER_SKIP_TREES_NOT_USEFUL_BEFORE |
cache: eviction server skips trees that were not useful before | |
#define | WT_STAT_CONN_EVICTION_SERVER_SLEPT |
cache: eviction server slept, because we did not make progress with eviction | |
#define | WT_STAT_CONN_EVICTION_SLOW |
cache: eviction server unable to reach eviction goal | |
#define | WT_STAT_CONN_EVICTION_WALK_LEAF_NOTFOUND |
cache: eviction server waiting for a leaf page | |
#define | WT_STAT_CONN_EVICTION_STATE |
cache: eviction state | |
#define | WT_STAT_CONN_EVICTION_WALK_SLEEPS |
cache: eviction walk most recent sleeps for checkpoint handle gathering | |
#define | WT_STAT_CONN_NPOS_EVICT_WALK_MAX |
cache: eviction walk restored - had to walk this many pages | |
#define | WT_STAT_CONN_EVICTION_RESTORED_POS |
cache: eviction walk restored position | |
#define | WT_STAT_CONN_EVICTION_RESTORED_POS_DIFFER |
cache: eviction walk restored position differs from the saved one | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT10 |
cache: eviction walk target pages histogram - 0-9 | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT32 |
cache: eviction walk target pages histogram - 10-31 | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_GE128 |
cache: eviction walk target pages histogram - 128 and higher | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT64 |
cache: eviction walk target pages histogram - 32-63 | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_LT128 |
cache: eviction walk target pages histogram - 64-128 | |
#define | WT_STAT_CONN_CACHE_EVICTION_TARGET_PAGE_REDUCED |
cache: eviction walk target pages reduced due to history store cache pressure | |
#define | WT_STAT_CONN_EVICTION_TARGET_STRATEGY_BOTH_CLEAN_AND_DIRTY |
cache: eviction walk target strategy both clean and dirty pages | |
#define | WT_STAT_CONN_EVICTION_TARGET_STRATEGY_CLEAN |
cache: eviction walk target strategy only clean pages | |
#define | WT_STAT_CONN_EVICTION_TARGET_STRATEGY_DIRTY |
cache: eviction walk target strategy only dirty pages | |
#define | WT_STAT_CONN_EVICTION_WALKS_ABANDONED |
cache: eviction walks abandoned | |
#define | WT_STAT_CONN_EVICTION_WALKS_STOPPED |
cache: eviction walks gave up because they restarted their walk twice | |
#define | WT_STAT_CONN_EVICTION_WALKS_GAVE_UP_NO_TARGETS |
cache: eviction walks gave up because they saw too many pages and found no candidates | |
#define | WT_STAT_CONN_EVICTION_WALKS_GAVE_UP_RATIO |
cache: eviction walks gave up because they saw too many pages and found too few candidates | |
#define | WT_STAT_CONN_EVICTION_WALK_RANDOM_RETURNS_NULL_POSITION |
cache: eviction walks random search fails to locate a page, results in a null position | |
#define | WT_STAT_CONN_EVICTION_WALKS_ENDED |
cache: eviction walks reached end of tree | |
#define | WT_STAT_CONN_EVICTION_WALK_RESTART |
cache: eviction walks restarted | |
#define | WT_STAT_CONN_EVICTION_WALK_FROM_ROOT |
cache: eviction walks started from root of tree | |
#define | WT_STAT_CONN_EVICTION_WALK_SAVED_POS |
cache: eviction walks started from saved location in tree | |
#define | WT_STAT_CONN_EVICTION_ACTIVE_WORKERS |
cache: eviction worker thread active | |
#define | WT_STAT_CONN_EVICTION_STABLE_STATE_WORKERS |
cache: eviction worker thread stable number | |
#define | WT_STAT_CONN_EVICTION_WALKS_ACTIVE |
cache: files with active eviction walks | |
#define | WT_STAT_CONN_EVICTION_WALKS_STARTED |
cache: files with new eviction walks started | |
#define | WT_STAT_CONN_EVICTION_FORCE_NO_RETRY |
cache: forced eviction - do not retry count to evict pages selected to evict during reconciliation | |
#define | WT_STAT_CONN_EVICTION_FORCE_HS_FAIL |
cache: forced eviction - history store pages failed to evict while session has history store cursor open | |
#define | WT_STAT_CONN_EVICTION_FORCE_HS |
cache: forced eviction - history store pages selected while session has history store cursor open | |
#define | WT_STAT_CONN_EVICTION_FORCE_HS_SUCCESS |
cache: forced eviction - history store pages successfully evicted while session has history store cursor open | |
#define | WT_STAT_CONN_EVICTION_FORCE_CLEAN |
cache: forced eviction - pages evicted that were clean count | |
#define | WT_STAT_CONN_EVICTION_FORCE_DIRTY |
cache: forced eviction - pages evicted that were dirty count | |
#define | WT_STAT_CONN_EVICTION_FORCE_LONG_UPDATE_LIST |
cache: forced eviction - pages selected because of a large number of updates to a single item | |
#define | WT_STAT_CONN_EVICTION_FORCE_DELETE |
cache: forced eviction - pages selected because of too many deleted items count | |
#define | WT_STAT_CONN_EVICTION_FORCE |
cache: forced eviction - pages selected count | |
#define | WT_STAT_CONN_EVICTION_FORCE_FAIL |
cache: forced eviction - pages selected unable to be evicted count | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_HAZARD |
cache: hazard pointer blocked page eviction | |
#define | WT_STAT_CONN_CACHE_HAZARD_CHECKS |
cache: hazard pointer check calls | |
#define | WT_STAT_CONN_CACHE_HAZARD_WALKS |
cache: hazard pointer check entries walked | |
#define | WT_STAT_CONN_CACHE_HAZARD_MAX |
cache: hazard pointer maximum array length | |
#define | WT_STAT_CONN_CACHE_HS_INSERT |
cache: history store table insert calls | |
#define | WT_STAT_CONN_CACHE_HS_INSERT_RESTART |
cache: history store table insert calls that returned restart | |
#define | WT_STAT_CONN_CACHE_HS_ONDISK_MAX |
cache: history store table max on-disk size | |
#define | WT_STAT_CONN_CACHE_HS_ONDISK |
cache: history store table on-disk size | |
#define | WT_STAT_CONN_CACHE_HS_READ |
cache: history store table reads | |
#define | WT_STAT_CONN_CACHE_HS_READ_MISS |
cache: history store table reads missed | |
#define | WT_STAT_CONN_CACHE_HS_READ_SQUASH |
cache: history store table reads requiring squashed modifies | |
#define | WT_STAT_CONN_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP |
cache: history store table resolved updates without timestamps that lose their durable timestamp | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE |
cache: history store table truncation by rollback to stable to remove an unstable update | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS |
cache: history store table truncation by rollback to stable to remove an update | |
#define | WT_STAT_CONN_CACHE_HS_BTREE_TRUNCATE |
cache: history store table truncation to remove all the keys of a btree | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE |
cache: history store table truncation to remove an update | |
#define | WT_STAT_CONN_CACHE_HS_ORDER_REMOVE |
cache: history store table truncation to remove range of updates due to an update without a timestamp on data page | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL |
cache: history store table truncation to remove range of updates due to key being removed from the data page during reconciliation | |
#define | WT_STAT_CONN_CACHE_HS_BTREE_TRUNCATE_DRYRUN |
cache: history store table truncations that would have happened in non-dryrun mode | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE_DRYRUN |
cache: history store table truncations to remove an unstable update that would have happened in non-dryrun mode | |
#define | WT_STAT_CONN_CACHE_HS_KEY_TRUNCATE_RTS_DRYRUN |
cache: history store table truncations to remove an update that would have happened in non-dryrun mode | |
#define | WT_STAT_CONN_CACHE_HS_ORDER_REINSERT |
cache: history store table updates without timestamps fixed up by reinserting with the fixed timestamp | |
#define | WT_STAT_CONN_CACHE_HS_WRITE_SQUASH |
cache: history store table writes requiring squashed modifies | |
#define | WT_STAT_CONN_CACHE_INMEM_SPLITTABLE |
cache: in-memory page passed criteria to be split | |
#define | WT_STAT_CONN_CACHE_INMEM_SPLIT |
cache: in-memory page splits | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_INTERNAL_PAGE_SPLIT |
cache: internal page split blocked its eviction | |
#define | WT_STAT_CONN_CACHE_EVICTION_INTERNAL |
cache: internal pages evicted | |
#define | WT_STAT_CONN_EVICTION_INTERNAL_PAGES_QUEUED |
cache: internal pages queued for eviction | |
#define | WT_STAT_CONN_EVICTION_INTERNAL_PAGES_SEEN |
cache: internal pages seen by eviction walk | |
#define | WT_STAT_CONN_EVICTION_INTERNAL_PAGES_ALREADY_QUEUED |
cache: internal pages seen by eviction walk that are already queued | |
#define | WT_STAT_CONN_CACHE_EVICTION_SPLIT_INTERNAL |
cache: internal pages split during eviction | |
#define | WT_STAT_CONN_CACHE_EVICTION_SPLIT_LEAF |
cache: leaf pages split during eviction | |
#define | WT_STAT_CONN_CACHE_EVICTION_RANDOM_SAMPLE_INMEM_ROOT |
cache: locate a random in-mem ref by examining all entries on the root page | |
#define | WT_STAT_CONN_CACHE_BYTES_MAX |
cache: maximum bytes configured | |
#define | WT_STAT_CONN_EVICTION_MAXIMUM_MILLISECONDS |
cache: maximum milliseconds spent at a single eviction | |
#define | WT_STAT_CONN_EVICTION_MAXIMUM_PAGE_SIZE |
cache: maximum page size seen at eviction | |
#define | WT_STAT_CONN_EVICTION_APP_DIRTY_ATTEMPT |
cache: modified page evict attempts by application threads | |
#define | WT_STAT_CONN_EVICTION_APP_DIRTY_FAIL |
cache: modified page evict failures by application threads | |
#define | WT_STAT_CONN_CACHE_EVICTION_DIRTY |
cache: modified pages evicted | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_MULTI_BLOCK_RECONCILIATION_DURING_CHECKPOINT |
cache: multi-block reconciliation blocked whilst checkpoint is running | |
#define | WT_STAT_CONN_NPOS_READ_WALK_MAX |
cache: npos read - had to walk this many pages | |
#define | WT_STAT_CONN_EVICTION_TIMED_OUT_OPS |
cache: operations timed out waiting for space in cache | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_OVERFLOW_KEYS |
cache: overflow keys on a multiblock row-store page blocked its eviction | |
#define | WT_STAT_CONN_CACHE_READ_OVERFLOW |
cache: overflow pages read into cache | |
#define | WT_STAT_CONN_EVICTION_APP_ATTEMPT |
cache: page evict attempts by application threads | |
#define | WT_STAT_CONN_EVICTION_APP_FAIL |
cache: page evict failures by application threads | |
#define | WT_STAT_CONN_CACHE_EVICTION_DEEPEN |
cache: page split during eviction deepened the tree | |
#define | WT_STAT_CONN_CACHE_WRITE_HS |
cache: page written requiring history store records | |
#define | WT_STAT_CONN_EVICTION_CONSIDER_PREFETCH |
cache: pages considered for eviction that were brought in by pre-fetch | |
#define | WT_STAT_CONN_CACHE_PAGES_INUSE |
cache: pages currently held in the cache | |
#define | WT_STAT_CONN_CACHE_EVICTION_DIRTY_OBSOLETE_TW |
cache: pages dirtied due to obsolete time window by eviction | |
#define | WT_STAT_CONN_EVICTION_PAGES_IN_PARALLEL_WITH_CHECKPOINT |
cache: pages evicted in parallel with checkpoint | |
#define | WT_STAT_CONN_EVICTION_PAGES_ORDINARY_QUEUED |
cache: pages queued for eviction | |
#define | WT_STAT_CONN_EVICTION_PAGES_QUEUED_POST_LRU |
cache: pages queued for eviction post lru sorting | |
#define | WT_STAT_CONN_EVICTION_PAGES_QUEUED_URGENT |
cache: pages queued for urgent eviction | |
#define | WT_STAT_CONN_EVICTION_PAGES_QUEUED_OLDEST |
cache: pages queued for urgent eviction during walk | |
#define | WT_STAT_CONN_EVICTION_PAGES_QUEUED_URGENT_HS_DIRTY |
cache: pages queued for urgent eviction from history store due to high dirty content | |
#define | WT_STAT_CONN_CACHE_READ |
cache: pages read into cache | |
#define | WT_STAT_CONN_CACHE_READ_DELETED |
cache: pages read into cache after truncate | |
#define | WT_STAT_CONN_CACHE_READ_DELETED_PREPARED |
cache: pages read into cache after truncate in prepare state | |
#define | WT_STAT_CONN_CACHE_READ_CHECKPOINT |
cache: pages read into cache by checkpoint | |
#define | WT_STAT_CONN_EVICTION_CLEAR_ORDINARY |
cache: pages removed from the ordinary queue to be queued for urgent eviction | |
#define | WT_STAT_CONN_CACHE_PAGES_REQUESTED |
cache: pages requested from the cache | |
#define | WT_STAT_CONN_CACHE_PAGES_PREFETCH |
cache: pages requested from the cache due to pre-fetch | |
#define | WT_STAT_CONN_CACHE_EVICTION_PAGES_SEEN |
cache: pages seen by eviction walk | |
#define | WT_STAT_CONN_EVICTION_PAGES_ALREADY_QUEUED |
cache: pages seen by eviction walk that are already queued | |
#define | WT_STAT_CONN_EVICTION_FAIL |
cache: pages selected for eviction unable to be evicted | |
#define | WT_STAT_CONN_EVICTION_FAIL_ACTIVE_CHILDREN_ON_AN_INTERNAL_PAGE |
cache: pages selected for eviction unable to be evicted because of active children on an internal page | |
#define | WT_STAT_CONN_EVICTION_FAIL_IN_RECONCILIATION |
cache: pages selected for eviction unable to be evicted because of failure in reconciliation | |
#define | WT_STAT_CONN_EVICTION_FAIL_CHECKPOINT_NO_TS |
cache: pages selected for eviction unable to be evicted because of race between checkpoint and updates without timestamps | |
#define | WT_STAT_CONN_EVICTION_WALK |
cache: pages walked for eviction | |
#define | WT_STAT_CONN_CACHE_WRITE |
cache: pages written from cache | |
#define | WT_STAT_CONN_CACHE_WRITE_RESTORE |
cache: pages written requiring in-memory restoration | |
#define | WT_STAT_CONN_CACHE_OVERHEAD |
cache: percentage overhead | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_RECENTLY_MODIFIED |
cache: recent modification of a page blocked its eviction | |
#define | WT_STAT_CONN_CACHE_REVERSE_SPLITS |
cache: reverse splits performed | |
#define | WT_STAT_CONN_CACHE_REVERSE_SPLITS_SKIPPED_VLCS |
cache: reverse splits skipped because of VLCS namespace gap restrictions | |
#define | WT_STAT_CONN_CACHE_HS_INSERT_FULL_UPDATE |
cache: the number of times full update inserted to history store | |
#define | WT_STAT_CONN_CACHE_HS_INSERT_REVERSE_MODIFY |
cache: the number of times reverse modify inserted to history store | |
#define | WT_STAT_CONN_EVICTION_REENTRY_HS_EVICTION_MILLISECONDS |
cache: total milliseconds spent inside reentrant history store evictions in a reconciliation | |
#define | WT_STAT_CONN_CACHE_BYTES_INTERNAL |
cache: tracked bytes belonging to internal pages in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_LEAF |
cache: tracked bytes belonging to leaf pages in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_DIRTY |
cache: tracked dirty bytes in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_DIRTY_INTERNAL |
cache: tracked dirty internal page bytes in the cache | |
#define | WT_STAT_CONN_CACHE_BYTES_DIRTY_LEAF |
cache: tracked dirty leaf page bytes in the cache | |
#define | WT_STAT_CONN_CACHE_PAGES_DIRTY |
cache: tracked dirty pages in the cache | |
#define | WT_STAT_CONN_CACHE_EVICTION_BLOCKED_UNCOMMITTED_TRUNCATE |
cache: uncommitted truncate blocked page eviction | |
#define | WT_STAT_CONN_CACHE_EVICTION_CLEAN |
cache: unmodified pages evicted | |
#define | WT_STAT_CONN_FSYNC_ALL_FH_TOTAL |
capacity: background fsync file handles considered | |
#define | WT_STAT_CONN_FSYNC_ALL_FH |
capacity: background fsync file handles synced | |
#define | WT_STAT_CONN_FSYNC_ALL_TIME |
capacity: background fsync time (msecs) | |
#define | WT_STAT_CONN_CAPACITY_BYTES_READ |
capacity: bytes read | |
#define | WT_STAT_CONN_CAPACITY_BYTES_CKPT |
capacity: bytes written for checkpoint | |
#define | WT_STAT_CONN_CAPACITY_BYTES_CHUNKCACHE |
capacity: bytes written for chunk cache | |
#define | WT_STAT_CONN_CAPACITY_BYTES_EVICT |
capacity: bytes written for eviction | |
#define | WT_STAT_CONN_CAPACITY_BYTES_LOG |
capacity: bytes written for log | |
#define | WT_STAT_CONN_CAPACITY_BYTES_WRITTEN |
capacity: bytes written total | |
#define | WT_STAT_CONN_CAPACITY_THRESHOLD |
capacity: threshold to call fsync | |
#define | WT_STAT_CONN_CAPACITY_TIME_TOTAL |
capacity: time waiting due to total capacity (usecs) | |
#define | WT_STAT_CONN_CAPACITY_TIME_CKPT |
capacity: time waiting during checkpoint (usecs) | |
#define | WT_STAT_CONN_CAPACITY_TIME_EVICT |
capacity: time waiting during eviction (usecs) | |
#define | WT_STAT_CONN_CAPACITY_TIME_LOG |
capacity: time waiting during logging (usecs) | |
#define | WT_STAT_CONN_CAPACITY_TIME_READ |
capacity: time waiting during read (usecs) | |
#define | WT_STAT_CONN_CAPACITY_TIME_CHUNKCACHE |
capacity: time waiting for chunk cache IO bandwidth (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_SUCCESS |
checkpoint: checkpoint cleanup successful calls | |
#define | WT_STAT_CONN_CHECKPOINT_SNAPSHOT_ACQUIRED |
checkpoint: checkpoint has acquired a snapshot for its transaction | |
#define | WT_STAT_CONN_CHECKPOINT_SKIPPED |
checkpoint: checkpoints skipped because database was clean | |
#define | WT_STAT_CONN_CHECKPOINT_FSYNC_POST |
checkpoint: fsync calls after allocating the transaction ID | |
#define | WT_STAT_CONN_CHECKPOINT_FSYNC_POST_DURATION |
checkpoint: fsync duration after allocating the transaction ID (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_GENERATION |
checkpoint: generation | |
#define | WT_STAT_CONN_CHECKPOINT_TIME_MAX |
checkpoint: max time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_TIME_MIN |
checkpoint: min time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_DROP_DURATION |
checkpoint: most recent duration for checkpoint dropping all handles (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_DURATION |
checkpoint: most recent duration for gathering all handles (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_APPLY_DURATION |
checkpoint: most recent duration for gathering applied handles (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_SKIP_DURATION |
checkpoint: most recent duration for gathering skipped handles (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_META_CHECK_DURATION |
checkpoint: most recent duration for handles metadata checked (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_LOCK_DURATION |
checkpoint: most recent duration for locking the handles (usecs) | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_APPLIED |
checkpoint: most recent handles applied | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_DROPPED |
checkpoint: most recent handles checkpoint dropped | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_META_CHECKED |
checkpoint: most recent handles metadata checked | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_LOCKED |
checkpoint: most recent handles metadata locked | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_SKIPPED |
checkpoint: most recent handles skipped | |
#define | WT_STAT_CONN_CHECKPOINT_HANDLE_WALKED |
checkpoint: most recent handles walked | |
#define | WT_STAT_CONN_CHECKPOINT_TIME_RECENT |
checkpoint: most recent time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINTS_API |
checkpoint: number of checkpoints started by api | |
#define | WT_STAT_CONN_CHECKPOINTS_COMPACT |
checkpoint: number of checkpoints started by compaction | |
#define | WT_STAT_CONN_CHECKPOINT_SYNC |
checkpoint: number of files synced | |
#define | WT_STAT_CONN_CHECKPOINT_PRESYNC |
checkpoint: number of handles visited after writes complete | |
#define | WT_STAT_CONN_CHECKPOINT_HS_PAGES_RECONCILED |
checkpoint: number of history store pages caused to be reconciled | |
#define | WT_STAT_CONN_CHECKPOINT_PAGES_VISITED_INTERNAL |
checkpoint: number of internal pages visited | |
#define | WT_STAT_CONN_CHECKPOINT_PAGES_VISITED_LEAF |
checkpoint: number of leaf pages visited | |
#define | WT_STAT_CONN_CHECKPOINT_PAGES_RECONCILED |
checkpoint: number of pages caused to be reconciled | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_EVICT |
checkpoint: pages added for eviction during checkpoint cleanup | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_OBSOLETE_TW |
checkpoint: pages dirtied due to obsolete time window by checkpoint cleanup | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_READ_RECLAIM_SPACE |
checkpoint: pages read into cache during checkpoint cleanup (reclaim_space) | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_READ_OBSOLETE_TW |
checkpoint: pages read into cache during checkpoint cleanup due to obsolete time window | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_REMOVED |
checkpoint: pages removed during checkpoint cleanup | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_WALK_SKIPPED |
checkpoint: pages skipped during checkpoint cleanup tree walk | |
#define | WT_STAT_CONN_CHECKPOINT_CLEANUP_PAGES_VISITED |
checkpoint: pages visited during checkpoint cleanup | |
#define | WT_STAT_CONN_CHECKPOINT_PREP_RUNNING |
checkpoint: prepare currently running | |
#define | WT_STAT_CONN_CHECKPOINT_PREP_MAX |
checkpoint: prepare max time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_PREP_MIN |
checkpoint: prepare min time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_PREP_RECENT |
checkpoint: prepare most recent time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_PREP_TOTAL |
checkpoint: prepare total time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_STATE |
checkpoint: progress state | |
#define | WT_STAT_CONN_CHECKPOINT_SCRUB_TARGET |
checkpoint: scrub dirty target | |
#define | WT_STAT_CONN_CHECKPOINT_SCRUB_MAX |
checkpoint: scrub max time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_SCRUB_MIN |
checkpoint: scrub min time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_SCRUB_RECENT |
checkpoint: scrub most recent time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_SCRUB_TOTAL |
checkpoint: scrub total time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_STOP_STRESS_ACTIVE |
checkpoint: stop timing stress active | |
#define | WT_STAT_CONN_CHECKPOINT_TREE_DURATION |
checkpoint: time spent on per-tree checkpoint work (usecs) | |
#define | WT_STAT_CONN_CHECKPOINTS_TOTAL_FAILED |
checkpoint: total failed number of checkpoints | |
#define | WT_STAT_CONN_CHECKPOINTS_TOTAL_SUCCEED |
checkpoint: total succeed number of checkpoints | |
#define | WT_STAT_CONN_CHECKPOINT_TIME_TOTAL |
checkpoint: total time (msecs) | |
#define | WT_STAT_CONN_CHECKPOINT_OBSOLETE_APPLIED |
checkpoint: transaction checkpoints due to obsolete pages | |
#define | WT_STAT_CONN_CHECKPOINT_WAIT_REDUCE_DIRTY |
checkpoint: wait cycles while cache dirty level is decreasing | |
#define | WT_STAT_CONN_CHUNKCACHE_SPANS_CHUNKS_READ |
chunk-cache: aggregate number of spanned chunks on read | |
#define | WT_STAT_CONN_CHUNKCACHE_CHUNKS_EVICTED |
chunk-cache: chunks evicted | |
#define | WT_STAT_CONN_CHUNKCACHE_EXCEEDED_BITMAP_CAPACITY |
chunk-cache: could not allocate due to exceeding bitmap capacity | |
#define | WT_STAT_CONN_CHUNKCACHE_EXCEEDED_CAPACITY |
chunk-cache: could not allocate due to exceeding capacity | |
#define | WT_STAT_CONN_CHUNKCACHE_LOOKUPS |
chunk-cache: lookups | |
#define | WT_STAT_CONN_CHUNKCACHE_CHUNKS_LOADED_FROM_FLUSHED_TABLES |
chunk-cache: number of chunks loaded from flushed tables in chunk cache | |
#define | WT_STAT_CONN_CHUNKCACHE_METADATA_INSERTED |
chunk-cache: number of metadata entries inserted | |
#define | WT_STAT_CONN_CHUNKCACHE_METADATA_REMOVED |
chunk-cache: number of metadata entries removed | |
#define | WT_STAT_CONN_CHUNKCACHE_METADATA_WORK_UNITS_DROPPED |
chunk-cache: number of metadata inserts/deletes dropped by the worker thread | |
#define | WT_STAT_CONN_CHUNKCACHE_METADATA_WORK_UNITS_CREATED |
chunk-cache: number of metadata inserts/deletes pushed to the worker thread | |
#define | WT_STAT_CONN_CHUNKCACHE_METADATA_WORK_UNITS_DEQUEUED |
chunk-cache: number of metadata inserts/deletes read by the worker thread | |
#define | WT_STAT_CONN_CHUNKCACHE_MISSES |
chunk-cache: number of misses | |
#define | WT_STAT_CONN_CHUNKCACHE_IO_FAILED |
chunk-cache: number of times a read from storage failed | |
#define | WT_STAT_CONN_CHUNKCACHE_RETRIES |
chunk-cache: retried accessing a chunk while I/O was in progress | |
#define | WT_STAT_CONN_CHUNKCACHE_RETRIES_CHECKSUM_MISMATCH |
chunk-cache: retries from a chunk cache checksum mismatch | |
#define | WT_STAT_CONN_CHUNKCACHE_TOOMANY_RETRIES |
chunk-cache: timed out due to too many retries | |
#define | WT_STAT_CONN_CHUNKCACHE_BYTES_READ_PERSISTENT |
chunk-cache: total bytes read from persistent content | |
#define | WT_STAT_CONN_CHUNKCACHE_BYTES_INUSE |
chunk-cache: total bytes used by the cache | |
#define | WT_STAT_CONN_CHUNKCACHE_BYTES_INUSE_PINNED |
chunk-cache: total bytes used by the cache for pinned chunks | |
#define | WT_STAT_CONN_CHUNKCACHE_CHUNKS_INUSE |
chunk-cache: total chunks held by the chunk cache | |
#define | WT_STAT_CONN_CHUNKCACHE_CREATED_FROM_METADATA |
chunk-cache: total number of chunks inserted on startup from persisted metadata. | |
#define | WT_STAT_CONN_CHUNKCACHE_CHUNKS_PINNED |
chunk-cache: total pinned chunks held by the chunk cache | |
#define | WT_STAT_CONN_COND_AUTO_WAIT_RESET |
connection: auto adjusting condition resets | |
#define | WT_STAT_CONN_COND_AUTO_WAIT |
connection: auto adjusting condition wait calls | |
#define | WT_STAT_CONN_COND_AUTO_WAIT_SKIPPED |
connection: auto adjusting condition wait raced to update timeout and skipped updating | |
#define | WT_STAT_CONN_TIME_TRAVEL |
connection: detected system time went backwards | |
#define | WT_STAT_CONN_FILE_OPEN |
connection: files currently open | |
#define | WT_STAT_CONN_BUCKETS_DH |
connection: hash bucket array size for data handles | |
#define | WT_STAT_CONN_BUCKETS |
connection: hash bucket array size general | |
#define | WT_STAT_CONN_MEMORY_ALLOCATION |
connection: memory allocations | |
#define | WT_STAT_CONN_MEMORY_FREE |
connection: memory frees | |
#define | WT_STAT_CONN_MEMORY_GROW |
connection: memory re-allocations | |
#define | WT_STAT_CONN_NO_SESSION_SWEEP_5MIN |
connection: number of sessions without a sweep for 5+ minutes | |
#define | WT_STAT_CONN_NO_SESSION_SWEEP_60MIN |
connection: number of sessions without a sweep for 60+ minutes | |
#define | WT_STAT_CONN_COND_WAIT |
connection: pthread mutex condition wait calls | |
#define | WT_STAT_CONN_RWLOCK_READ |
connection: pthread mutex shared lock read-lock calls | |
#define | WT_STAT_CONN_RWLOCK_WRITE |
connection: pthread mutex shared lock write-lock calls | |
#define | WT_STAT_CONN_FSYNC_IO |
connection: total fsync I/Os | |
#define | WT_STAT_CONN_READ_IO |
connection: total read I/Os | |
#define | WT_STAT_CONN_WRITE_IO |
connection: total write I/Os | |
#define | WT_STAT_CONN_CURSOR_TREE_WALK_DEL_PAGE_SKIP |
cursor: Total number of deleted pages skipped during tree walk | |
#define | WT_STAT_CONN_CURSOR_NEXT_SKIP_TOTAL |
cursor: Total number of entries skipped by cursor next calls | |
#define | WT_STAT_CONN_CURSOR_PREV_SKIP_TOTAL |
cursor: Total number of entries skipped by cursor prev calls | |
#define | WT_STAT_CONN_CURSOR_SKIP_HS_CUR_POSITION |
cursor: Total number of entries skipped to position the history store cursor | |
#define | WT_STAT_CONN_CURSOR_TREE_WALK_INMEM_DEL_PAGE_SKIP |
cursor: Total number of in-memory deleted pages skipped during tree walk | |
#define | WT_STAT_CONN_CURSOR_TREE_WALK_ONDISK_DEL_PAGE_SKIP |
cursor: Total number of on-disk deleted pages skipped during tree walk | |
#define | WT_STAT_CONN_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS |
cursor: Total number of times a search near has exited due to prefix config | |
#define | WT_STAT_CONN_CURSOR_REPOSITION_FAILED |
cursor: Total number of times cursor fails to temporarily release pinned page to encourage eviction of hot or large page | |
#define | WT_STAT_CONN_CURSOR_REPOSITION |
cursor: Total number of times cursor temporarily releases pinned page to encourage eviction of hot or large page | |
#define | WT_STAT_CONN_CURSOR_BULK_COUNT |
cursor: bulk cursor count | |
#define | WT_STAT_CONN_CURSOR_CACHED_COUNT |
cursor: cached cursor count | |
#define | WT_STAT_CONN_CURSOR_BOUND_ERROR |
cursor: cursor bound calls that return an error | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_RESET |
cursor: cursor bounds cleared from reset | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_COMPARISONS |
cursor: cursor bounds comparisons performed | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_NEXT_UNPOSITIONED |
cursor: cursor bounds next called on an unpositioned cursor | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_NEXT_EARLY_EXIT |
cursor: cursor bounds next early exit | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_PREV_UNPOSITIONED |
cursor: cursor bounds prev called on an unpositioned cursor | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_PREV_EARLY_EXIT |
cursor: cursor bounds prev early exit | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_SEARCH_EARLY_EXIT |
cursor: cursor bounds search early exit | |
#define | WT_STAT_CONN_CURSOR_BOUNDS_SEARCH_NEAR_REPOSITIONED_CURSOR |
cursor: cursor bounds search near call repositioned cursor | |
#define | WT_STAT_CONN_CURSOR_INSERT_BULK |
cursor: cursor bulk loaded cursor insert calls | |
#define | WT_STAT_CONN_CURSOR_CACHE_ERROR |
cursor: cursor cache calls that return an error | |
#define | WT_STAT_CONN_CURSOR_CACHE |
cursor: cursor close calls that result in cache | |
#define | WT_STAT_CONN_CURSOR_CLOSE_ERROR |
cursor: cursor close calls that return an error | |
#define | WT_STAT_CONN_CURSOR_COMPARE_ERROR |
cursor: cursor compare calls that return an error | |
#define | WT_STAT_CONN_CURSOR_CREATE |
cursor: cursor create calls | |
#define | WT_STAT_CONN_CURSOR_EQUALS_ERROR |
cursor: cursor equals calls that return an error | |
#define | WT_STAT_CONN_CURSOR_GET_KEY_ERROR |
cursor: cursor get key calls that return an error | |
#define | WT_STAT_CONN_CURSOR_GET_VALUE_ERROR |
cursor: cursor get value calls that return an error | |
#define | WT_STAT_CONN_CURSOR_INSERT |
cursor: cursor insert calls | |
#define | WT_STAT_CONN_CURSOR_INSERT_ERROR |
cursor: cursor insert calls that return an error | |
#define | WT_STAT_CONN_CURSOR_INSERT_CHECK_ERROR |
cursor: cursor insert check calls that return an error | |
#define | WT_STAT_CONN_CURSOR_INSERT_BYTES |
cursor: cursor insert key and value bytes | |
#define | WT_STAT_CONN_CURSOR_LARGEST_KEY_ERROR |
cursor: cursor largest key calls that return an error | |
#define | WT_STAT_CONN_CURSOR_MODIFY |
cursor: cursor modify calls | |
#define | WT_STAT_CONN_CURSOR_MODIFY_ERROR |
cursor: cursor modify calls that return an error | |
#define | WT_STAT_CONN_CURSOR_MODIFY_BYTES |
cursor: cursor modify key and value bytes affected | |
#define | WT_STAT_CONN_CURSOR_MODIFY_BYTES_TOUCH |
cursor: cursor modify value bytes modified | |
#define | WT_STAT_CONN_CURSOR_NEXT |
cursor: cursor next calls | |
#define | WT_STAT_CONN_CURSOR_NEXT_ERROR |
cursor: cursor next calls that return an error | |
#define | WT_STAT_CONN_CURSOR_NEXT_HS_TOMBSTONE |
cursor: cursor next calls that skip due to a globally visible history store tombstone | |
#define | WT_STAT_CONN_CURSOR_NEXT_SKIP_LT_100 |
cursor: cursor next calls that skip greater than 1 and fewer than 100 entries | |
#define | WT_STAT_CONN_CURSOR_NEXT_SKIP_GE_100 |
cursor: cursor next calls that skip greater than or equal to 100 entries | |
#define | WT_STAT_CONN_CURSOR_NEXT_RANDOM_ERROR |
cursor: cursor next random calls that return an error | |
#define | WT_STAT_CONN_CURSOR_RESTART |
cursor: cursor operation restarted | |
#define | WT_STAT_CONN_CURSOR_PREV |
cursor: cursor prev calls | |
#define | WT_STAT_CONN_CURSOR_PREV_ERROR |
cursor: cursor prev calls that return an error | |
#define | WT_STAT_CONN_CURSOR_PREV_HS_TOMBSTONE |
cursor: cursor prev calls that skip due to a globally visible history store tombstone | |
#define | WT_STAT_CONN_CURSOR_PREV_SKIP_GE_100 |
cursor: cursor prev calls that skip greater than or equal to 100 entries | |
#define | WT_STAT_CONN_CURSOR_PREV_SKIP_LT_100 |
cursor: cursor prev calls that skip less than 100 entries | |
#define | WT_STAT_CONN_CURSOR_RECONFIGURE_ERROR |
cursor: cursor reconfigure calls that return an error | |
#define | WT_STAT_CONN_CURSOR_REMOVE |
cursor: cursor remove calls | |
#define | WT_STAT_CONN_CURSOR_REMOVE_ERROR |
cursor: cursor remove calls that return an error | |
#define | WT_STAT_CONN_CURSOR_REMOVE_BYTES |
cursor: cursor remove key bytes removed | |
#define | WT_STAT_CONN_CURSOR_REOPEN_ERROR |
cursor: cursor reopen calls that return an error | |
#define | WT_STAT_CONN_CURSOR_RESERVE |
cursor: cursor reserve calls | |
#define | WT_STAT_CONN_CURSOR_RESERVE_ERROR |
cursor: cursor reserve calls that return an error | |
#define | WT_STAT_CONN_CURSOR_RESET |
cursor: cursor reset calls | |
#define | WT_STAT_CONN_CURSOR_RESET_ERROR |
cursor: cursor reset calls that return an error | |
#define | WT_STAT_CONN_CURSOR_SEARCH |
cursor: cursor search calls | |
#define | WT_STAT_CONN_CURSOR_SEARCH_ERROR |
cursor: cursor search calls that return an error | |
#define | WT_STAT_CONN_CURSOR_SEARCH_HS |
cursor: cursor search history store calls | |
#define | WT_STAT_CONN_CURSOR_SEARCH_NEAR |
cursor: cursor search near calls | |
#define | WT_STAT_CONN_CURSOR_SEARCH_NEAR_ERROR |
cursor: cursor search near calls that return an error | |
#define | WT_STAT_CONN_CURSOR_SWEEP_BUCKETS |
cursor: cursor sweep buckets | |
#define | WT_STAT_CONN_CURSOR_SWEEP_CLOSED |
cursor: cursor sweep cursors closed | |
#define | WT_STAT_CONN_CURSOR_SWEEP_EXAMINED |
cursor: cursor sweep cursors examined | |
#define | WT_STAT_CONN_CURSOR_SWEEP |
cursor: cursor sweeps | |
#define | WT_STAT_CONN_CURSOR_TRUNCATE |
cursor: cursor truncate calls | |
#define | WT_STAT_CONN_CURSOR_TRUNCATE_KEYS_DELETED |
cursor: cursor truncates performed on individual keys | |
#define | WT_STAT_CONN_CURSOR_UPDATE |
cursor: cursor update calls | |
#define | WT_STAT_CONN_CURSOR_UPDATE_ERROR |
cursor: cursor update calls that return an error | |
#define | WT_STAT_CONN_CURSOR_UPDATE_BYTES |
cursor: cursor update key and value bytes | |
#define | WT_STAT_CONN_CURSOR_UPDATE_BYTES_CHANGED |
cursor: cursor update value size change | |
#define | WT_STAT_CONN_CURSOR_REOPEN |
cursor: cursors reused from cache | |
#define | WT_STAT_CONN_CURSOR_OPEN_COUNT |
cursor: open cursor count | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_TABLE_COUNT |
data-handle: Table connection data handles currently active | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_TIERED_COUNT |
data-handle: Tiered connection data handles currently active | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_TIERED_TREE_COUNT |
data-handle: Tiered_Tree connection data handles currently active | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_BTREE_COUNT |
data-handle: btree connection data handles currently active | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_CHECKPOINT_COUNT |
data-handle: checkpoint connection data handles currently active | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_SIZE |
data-handle: connection data handle size | |
#define | WT_STAT_CONN_DH_CONN_HANDLE_COUNT |
data-handle: connection data handles currently active | |
#define | WT_STAT_CONN_DH_SWEEP_REF |
data-handle: connection sweep candidate became referenced | |
#define | WT_STAT_CONN_DH_SWEEP_DEAD_CLOSE |
data-handle: connection sweep dead dhandles closed | |
#define | WT_STAT_CONN_DH_SWEEP_REMOVE |
data-handle: connection sweep dhandles removed from hash list | |
#define | WT_STAT_CONN_DH_SWEEP_EXPIRED_CLOSE |
data-handle: connection sweep expired dhandles closed | |
#define | WT_STAT_CONN_DH_SWEEP_TOD |
data-handle: connection sweep time-of-death sets | |
#define | WT_STAT_CONN_DH_SWEEPS |
data-handle: connection sweeps | |
#define | WT_STAT_CONN_DH_SWEEP_SKIP_CKPT |
data-handle: connection sweeps skipped due to checkpoint gathering handles | |
#define | WT_STAT_CONN_DH_SESSION_HANDLES |
data-handle: session dhandles swept | |
#define | WT_STAT_CONN_DH_SESSION_SWEEPS |
data-handle: session sweep attempts | |
#define | WT_STAT_CONN_LOCK_BTREE_PAGE_COUNT |
lock: btree page lock acquisitions | |
#define | WT_STAT_CONN_LOCK_BTREE_PAGE_WAIT_APPLICATION |
lock: btree page lock application thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_BTREE_PAGE_WAIT_INTERNAL |
lock: btree page lock internal thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_CHECKPOINT_COUNT |
lock: checkpoint lock acquisitions | |
#define | WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_APPLICATION |
lock: checkpoint lock application thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_CHECKPOINT_WAIT_INTERNAL |
lock: checkpoint lock internal thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_DHANDLE_WAIT_APPLICATION |
lock: dhandle lock application thread time waiting (usecs) | |
#define | WT_STAT_CONN_LOCK_DHANDLE_WAIT_INTERNAL |
lock: dhandle lock internal thread time waiting (usecs) | |
#define | WT_STAT_CONN_LOCK_DHANDLE_READ_COUNT |
lock: dhandle read lock acquisitions | |
#define | WT_STAT_CONN_LOCK_DHANDLE_WRITE_COUNT |
lock: dhandle write lock acquisitions | |
#define | WT_STAT_CONN_LOCK_METADATA_COUNT |
lock: metadata lock acquisitions | |
#define | WT_STAT_CONN_LOCK_METADATA_WAIT_APPLICATION |
lock: metadata lock application thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_METADATA_WAIT_INTERNAL |
lock: metadata lock internal thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_SCHEMA_COUNT |
lock: schema lock acquisitions | |
#define | WT_STAT_CONN_LOCK_SCHEMA_WAIT_APPLICATION |
lock: schema lock application thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_SCHEMA_WAIT_INTERNAL |
lock: schema lock internal thread wait time (usecs) | |
#define | WT_STAT_CONN_LOCK_TABLE_WAIT_APPLICATION |
lock: table lock application thread time waiting for the table lock (usecs) | |
#define | WT_STAT_CONN_LOCK_TABLE_WAIT_INTERNAL |
lock: table lock internal thread time waiting for the table lock (usecs) | |
#define | WT_STAT_CONN_LOCK_TABLE_READ_COUNT |
lock: table read lock acquisitions | |
#define | WT_STAT_CONN_LOCK_TABLE_WRITE_COUNT |
lock: table write lock acquisitions | |
#define | WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_APPLICATION |
lock: txn global lock application thread time waiting (usecs) | |
#define | WT_STAT_CONN_LOCK_TXN_GLOBAL_WAIT_INTERNAL |
lock: txn global lock internal thread time waiting (usecs) | |
#define | WT_STAT_CONN_LOCK_TXN_GLOBAL_READ_COUNT |
lock: txn global read lock acquisitions | |
#define | WT_STAT_CONN_LOCK_TXN_GLOBAL_WRITE_COUNT |
lock: txn global write lock acquisitions | |
#define | WT_STAT_CONN_LOG_SLOT_SWITCH_BUSY |
log: busy returns attempting to switch slots | |
#define | WT_STAT_CONN_LOG_FORCE_REMOVE_SLEEP |
log: force log remove time sleeping (usecs) | |
#define | WT_STAT_CONN_LOG_BYTES_PAYLOAD |
log: log bytes of payload data | |
#define | WT_STAT_CONN_LOG_BYTES_WRITTEN |
log: log bytes written | |
#define | WT_STAT_CONN_LOG_ZERO_FILLS |
log: log files manually zero-filled | |
#define | WT_STAT_CONN_LOG_FLUSH |
log: log flush operations | |
#define | WT_STAT_CONN_LOG_FORCE_WRITE |
log: log force write operations | |
#define | WT_STAT_CONN_LOG_FORCE_WRITE_SKIP |
log: log force write operations skipped | |
#define | WT_STAT_CONN_LOG_COMPRESS_WRITES |
log: log records compressed | |
#define | WT_STAT_CONN_LOG_COMPRESS_WRITE_FAILS |
log: log records not compressed | |
#define | WT_STAT_CONN_LOG_COMPRESS_SMALL |
log: log records too small to compress | |
#define | WT_STAT_CONN_LOG_RELEASE_WRITE_LSN |
log: log release advances write LSN | |
#define | WT_STAT_CONN_LOG_SCANS |
log: log scan operations | |
#define | WT_STAT_CONN_LOG_SCAN_REREADS |
log: log scan records requiring two reads | |
#define | WT_STAT_CONN_LOG_WRITE_LSN |
log: log server thread advances write LSN | |
#define | WT_STAT_CONN_LOG_WRITE_LSN_SKIP |
log: log server thread write LSN walk skipped | |
#define | WT_STAT_CONN_LOG_SYNC |
log: log sync operations | |
#define | WT_STAT_CONN_LOG_SYNC_DURATION |
log: log sync time duration (usecs) | |
#define | WT_STAT_CONN_LOG_SYNC_DIR |
log: log sync_dir operations | |
#define | WT_STAT_CONN_LOG_SYNC_DIR_DURATION |
log: log sync_dir time duration (usecs) | |
#define | WT_STAT_CONN_LOG_WRITES |
log: log write operations | |
#define | WT_STAT_CONN_LOG_SLOT_CONSOLIDATED |
log: logging bytes consolidated | |
#define | WT_STAT_CONN_LOG_MAX_FILESIZE |
log: maximum log file size | |
#define | WT_STAT_CONN_LOG_PREALLOC_MAX |
log: number of pre-allocated log files to create | |
#define | WT_STAT_CONN_LOG_PREALLOC_MISSED |
log: pre-allocated log files not ready and missed | |
#define | WT_STAT_CONN_LOG_PREALLOC_FILES |
log: pre-allocated log files prepared | |
#define | WT_STAT_CONN_LOG_PREALLOC_USED |
log: pre-allocated log files used | |
#define | WT_STAT_CONN_LOG_SCAN_RECORDS |
log: records processed by log scan | |
#define | WT_STAT_CONN_LOG_SLOT_CLOSE_RACE |
log: slot close lost race | |
#define | WT_STAT_CONN_LOG_SLOT_CLOSE_UNBUF |
log: slot close unbuffered waits | |
#define | WT_STAT_CONN_LOG_SLOT_CLOSES |
log: slot closures | |
#define | WT_STAT_CONN_LOG_SLOT_RACES |
log: slot join atomic update races | |
#define | WT_STAT_CONN_LOG_SLOT_YIELD_RACE |
log: slot join calls atomic updates raced | |
#define | WT_STAT_CONN_LOG_SLOT_IMMEDIATE |
log: slot join calls did not yield | |
#define | WT_STAT_CONN_LOG_SLOT_YIELD_CLOSE |
log: slot join calls found active slot closed | |
#define | WT_STAT_CONN_LOG_SLOT_YIELD_SLEEP |
log: slot join calls slept | |
#define | WT_STAT_CONN_LOG_SLOT_YIELD |
log: slot join calls yielded | |
#define | WT_STAT_CONN_LOG_SLOT_ACTIVE_CLOSED |
log: slot join found active slot closed | |
#define | WT_STAT_CONN_LOG_SLOT_YIELD_DURATION |
log: slot joins yield time (usecs) | |
#define | WT_STAT_CONN_LOG_SLOT_NO_FREE_SLOTS |
log: slot transitions unable to find free slot | |
#define | WT_STAT_CONN_LOG_SLOT_UNBUFFERED |
log: slot unbuffered writes | |
#define | WT_STAT_CONN_LOG_COMPRESS_MEM |
log: total in-memory size of compressed records | |
#define | WT_STAT_CONN_LOG_BUFFER_SIZE |
log: total log buffer size | |
#define | WT_STAT_CONN_LOG_COMPRESS_LEN |
log: total size of compressed records | |
#define | WT_STAT_CONN_LOG_SLOT_COALESCED |
log: written slots coalesced | |
#define | WT_STAT_CONN_LOG_CLOSE_YIELDS |
log: yields waiting for previous log file close | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT10 |
perf: file system read latency histogram (bucket 1) - 0-10ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT50 |
perf: file system read latency histogram (bucket 2) - 10-49ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT100 |
perf: file system read latency histogram (bucket 3) - 50-99ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT250 |
perf: file system read latency histogram (bucket 4) - 100-249ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT500 |
perf: file system read latency histogram (bucket 5) - 250-499ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_LT1000 |
perf: file system read latency histogram (bucket 6) - 500-999ms | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_GT1000 |
perf: file system read latency histogram (bucket 7) - 1000ms+ | |
#define | WT_STAT_CONN_PERF_HIST_FSREAD_LATENCY_TOTAL_MSECS |
perf: file system read latency histogram total (msecs) | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT10 |
perf: file system write latency histogram (bucket 1) - 0-10ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT50 |
perf: file system write latency histogram (bucket 2) - 10-49ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT100 |
perf: file system write latency histogram (bucket 3) - 50-99ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT250 |
perf: file system write latency histogram (bucket 4) - 100-249ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT500 |
perf: file system write latency histogram (bucket 5) - 250-499ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_LT1000 |
perf: file system write latency histogram (bucket 6) - 500-999ms | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_GT1000 |
perf: file system write latency histogram (bucket 7) - 1000ms+ | |
#define | WT_STAT_CONN_PERF_HIST_FSWRITE_LATENCY_TOTAL_MSECS |
perf: file system write latency histogram total (msecs) | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT100 |
perf: operation read latency histogram (bucket 1) - 0-100us | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT250 |
perf: operation read latency histogram (bucket 2) - 100-249us | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT500 |
perf: operation read latency histogram (bucket 3) - 250-499us | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT1000 |
perf: operation read latency histogram (bucket 4) - 500-999us | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_LT10000 |
perf: operation read latency histogram (bucket 5) - 1000-9999us | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_GT10000 |
perf: operation read latency histogram (bucket 6) - 10000us+ | |
#define | WT_STAT_CONN_PERF_HIST_OPREAD_LATENCY_TOTAL_USECS |
perf: operation read latency histogram total (usecs) | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT100 |
perf: operation write latency histogram (bucket 1) - 0-100us | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT250 |
perf: operation write latency histogram (bucket 2) - 100-249us | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT500 |
perf: operation write latency histogram (bucket 3) - 250-499us | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT1000 |
perf: operation write latency histogram (bucket 4) - 500-999us | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_LT10000 |
perf: operation write latency histogram (bucket 5) - 1000-9999us | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_GT10000 |
perf: operation write latency histogram (bucket 6) - 10000us+ | |
#define | WT_STAT_CONN_PERF_HIST_OPWRITE_LATENCY_TOTAL_USECS |
perf: operation write latency histogram total (usecs) | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_INTERNAL_PAGE |
prefetch: could not perform pre-fetch on internal page | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_NO_FLAG_SET |
prefetch: could not perform pre-fetch on ref without the pre-fetch flag set | |
#define | WT_STAT_CONN_PREFETCH_FAILED_START |
prefetch: number of times pre-fetch failed to start | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_SAME_REF |
prefetch: pre-fetch not repeating for recently pre-fetched ref | |
#define | WT_STAT_CONN_PREFETCH_DISK_ONE |
prefetch: pre-fetch not triggered after single disk read | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_NO_VALID_DHANDLE |
prefetch: pre-fetch not triggered as there is no valid dhandle | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED |
prefetch: pre-fetch not triggered by page read | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_DISK_READ_COUNT |
prefetch: pre-fetch not triggered due to disk read count | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_INTERNAL_SESSION |
prefetch: pre-fetch not triggered due to internal session | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_SPECIAL_HANDLE |
prefetch: pre-fetch not triggered due to special btree handle | |
#define | WT_STAT_CONN_PREFETCH_PAGES_FAIL |
prefetch: pre-fetch page not on disk when reading | |
#define | WT_STAT_CONN_PREFETCH_PAGES_QUEUED |
prefetch: pre-fetch pages queued | |
#define | WT_STAT_CONN_PREFETCH_PAGES_READ |
prefetch: pre-fetch pages read in background | |
#define | WT_STAT_CONN_PREFETCH_SKIPPED_ERROR_OK |
prefetch: pre-fetch skipped reading in a page due to harmless error | |
#define | WT_STAT_CONN_PREFETCH_ATTEMPTS |
prefetch: pre-fetch triggered by page read | |
#define | WT_STAT_CONN_REC_VLCS_EMPTIED_PAGES |
reconciliation: VLCS pages explicitly reconciled as empty | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TS |
reconciliation: approximate byte size of timestamps in pages written | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_BYTES_TXN |
reconciliation: approximate byte size of transaction IDs in pages written | |
#define | WT_STAT_CONN_REC_PAGE_DELETE_FAST |
reconciliation: fast-path pages deleted | |
#define | WT_STAT_CONN_REC_OVERFLOW_KEY_LEAF |
reconciliation: leaf-page overflow keys | |
#define | WT_STAT_CONN_REC_MAXIMUM_MILLISECONDS |
reconciliation: maximum milliseconds spent in a reconciliation call | |
#define | WT_STAT_CONN_REC_MAXIMUM_IMAGE_BUILD_MILLISECONDS |
reconciliation: maximum milliseconds spent in building a disk image in a reconciliation | |
#define | WT_STAT_CONN_REC_MAXIMUM_HS_WRAPUP_MILLISECONDS |
reconciliation: maximum milliseconds spent in moving updates to the history store in a reconciliation | |
#define | WT_STAT_CONN_REC_OVERFLOW_VALUE |
reconciliation: overflow values written | |
#define | WT_STAT_CONN_REC_PAGES |
reconciliation: page reconciliation calls | |
#define | WT_STAT_CONN_REC_PAGES_EVICTION |
reconciliation: page reconciliation calls for eviction | |
#define | WT_STAT_CONN_REC_PAGES_WITH_PREPARE |
reconciliation: page reconciliation calls that resulted in values with prepared transaction metadata | |
#define | WT_STAT_CONN_REC_PAGES_WITH_TS |
reconciliation: page reconciliation calls that resulted in values with timestamps | |
#define | WT_STAT_CONN_REC_PAGES_WITH_TXN |
reconciliation: page reconciliation calls that resulted in values with transaction ids | |
#define | WT_STAT_CONN_REC_PAGE_DELETE |
reconciliation: pages deleted | |
#define | WT_STAT_CONN_REC_TIME_AGGR_NEWEST_START_DURABLE_TS |
reconciliation: pages written including an aggregated newest start durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS |
reconciliation: pages written including an aggregated newest stop durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TS |
reconciliation: pages written including an aggregated newest stop timestamp | |
#define | WT_STAT_CONN_REC_TIME_AGGR_NEWEST_STOP_TXN |
reconciliation: pages written including an aggregated newest stop transaction ID | |
#define | WT_STAT_CONN_REC_TIME_AGGR_NEWEST_TXN |
reconciliation: pages written including an aggregated newest transaction ID | |
#define | WT_STAT_CONN_REC_TIME_AGGR_OLDEST_START_TS |
reconciliation: pages written including an aggregated oldest start timestamp | |
#define | WT_STAT_CONN_REC_TIME_AGGR_PREPARED |
reconciliation: pages written including an aggregated prepare | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_PREPARED |
reconciliation: pages written including at least one prepare state | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_START_TS |
reconciliation: pages written including at least one start durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TS |
reconciliation: pages written including at least one start timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_START_TXN |
reconciliation: pages written including at least one start transaction ID | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS |
reconciliation: pages written including at least one stop durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TS |
reconciliation: pages written including at least one stop timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PAGES_STOP_TXN |
reconciliation: pages written including at least one stop transaction ID | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_PREPARED |
reconciliation: records written including a prepare state | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_START_TS |
reconciliation: records written including a start durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_START_TS |
reconciliation: records written including a start timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_START_TXN |
reconciliation: records written including a start transaction ID | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_DURABLE_STOP_TS |
reconciliation: records written including a stop durable timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_STOP_TS |
reconciliation: records written including a stop timestamp | |
#define | WT_STAT_CONN_REC_TIME_WINDOW_STOP_TXN |
reconciliation: records written including a stop transaction ID | |
#define | WT_STAT_CONN_REC_SPLIT_STASHED_BYTES |
reconciliation: split bytes currently awaiting free | |
#define | WT_STAT_CONN_REC_SPLIT_STASHED_OBJECTS |
reconciliation: split objects currently awaiting free | |
#define | WT_STAT_CONN_LOCAL_OBJECTS_INUSE |
session: attempts to remove a local object and the object is in use | |
#define | WT_STAT_CONN_FLUSH_TIER_FAIL |
session: flush_tier failed calls | |
#define | WT_STAT_CONN_FLUSH_TIER |
session: flush_tier operation calls | |
#define | WT_STAT_CONN_FLUSH_TIER_SKIPPED |
session: flush_tier tables skipped due to no checkpoint | |
#define | WT_STAT_CONN_FLUSH_TIER_SWITCHED |
session: flush_tier tables switched | |
#define | WT_STAT_CONN_LOCAL_OBJECTS_REMOVED |
session: local objects removed | |
#define | WT_STAT_CONN_SESSION_OPEN |
session: open session count | |
#define | WT_STAT_CONN_SESSION_QUERY_TS |
session: session query timestamp calls | |
#define | WT_STAT_CONN_SESSION_TABLE_ALTER_FAIL |
session: table alter failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_ALTER_SUCCESS |
session: table alter successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_ALTER_TRIGGER_CHECKPOINT |
session: table alter triggering checkpoint calls | |
#define | WT_STAT_CONN_SESSION_TABLE_ALTER_SKIP |
session: table alter unchanged and skipped | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_CONFLICTING_CHECKPOINT |
session: table compact conflicted with checkpoint | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_DHANDLE_SUCCESS |
session: table compact dhandle successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL |
session: table compact failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_FAIL_CACHE_PRESSURE |
session: table compact failed calls due to cache pressure | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_PASSES |
session: table compact passes | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_EVICTION |
session: table compact pulled into eviction | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_RUNNING |
session: table compact running | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_SKIPPED |
session: table compact skipped as process would not reduce file size | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_SUCCESS |
session: table compact successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_COMPACT_TIMEOUT |
session: table compact timeout | |
#define | WT_STAT_CONN_SESSION_TABLE_CREATE_FAIL |
session: table create failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_CREATE_SUCCESS |
session: table create successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_CREATE_IMPORT_FAIL |
session: table create with import failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_CREATE_IMPORT_REPAIR |
session: table create with import repair calls | |
#define | WT_STAT_CONN_SESSION_TABLE_CREATE_IMPORT_SUCCESS |
session: table create with import successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_DROP_FAIL |
session: table drop failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_DROP_SUCCESS |
session: table drop successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_SALVAGE_FAIL |
session: table salvage failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_SALVAGE_SUCCESS |
session: table salvage successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_TRUNCATE_FAIL |
session: table truncate failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_TRUNCATE_SUCCESS |
session: table truncate successful calls | |
#define | WT_STAT_CONN_SESSION_TABLE_VERIFY_FAIL |
session: table verify failed calls | |
#define | WT_STAT_CONN_SESSION_TABLE_VERIFY_SUCCESS |
session: table verify successful calls | |
#define | WT_STAT_CONN_TIERED_WORK_UNITS_DEQUEUED |
session: tiered operations dequeued and processed | |
#define | WT_STAT_CONN_TIERED_WORK_UNITS_REMOVED |
session: tiered operations removed without processing | |
#define | WT_STAT_CONN_TIERED_WORK_UNITS_CREATED |
session: tiered operations scheduled | |
#define | WT_STAT_CONN_TIERED_RETENTION |
session: tiered storage local retention time (secs) | |
#define | WT_STAT_CONN_THREAD_FSYNC_ACTIVE |
thread-state: active filesystem fsync calls | |
#define | WT_STAT_CONN_THREAD_READ_ACTIVE |
thread-state: active filesystem read calls | |
#define | WT_STAT_CONN_THREAD_WRITE_ACTIVE |
thread-state: active filesystem write calls | |
#define | WT_STAT_CONN_APPLICATION_CACHE_OPS |
thread-yield: application thread operations waiting for cache | |
#define | WT_STAT_CONN_APPLICATION_EVICT_SNAPSHOT_REFRESHED |
thread-yield: application thread snapshot refreshed for eviction | |
#define | WT_STAT_CONN_APPLICATION_CACHE_TIME |
thread-yield: application thread time waiting for cache (usecs) | |
#define | WT_STAT_CONN_TXN_RELEASE_BLOCKED |
thread-yield: connection close blocked waiting for transaction state stabilization | |
#define | WT_STAT_CONN_CONN_CLOSE_BLOCKED_LSM |
thread-yield: connection close yielded for lsm manager shutdown | |
#define | WT_STAT_CONN_DHANDLE_LOCK_BLOCKED |
thread-yield: data handle lock yielded | |
#define | WT_STAT_CONN_PAGE_INDEX_SLOT_REF_BLOCKED |
thread-yield: get reference for page index and slot time sleeping (usecs) | |
#define | WT_STAT_CONN_PREPARED_TRANSITION_BLOCKED_PAGE |
thread-yield: page access yielded due to prepare state change | |
#define | WT_STAT_CONN_PAGE_BUSY_BLOCKED |
thread-yield: page acquire busy blocked | |
#define | WT_STAT_CONN_PAGE_FORCIBLE_EVICT_BLOCKED |
thread-yield: page acquire eviction blocked | |
#define | WT_STAT_CONN_PAGE_LOCKED_BLOCKED |
thread-yield: page acquire locked blocked | |
#define | WT_STAT_CONN_PAGE_READ_BLOCKED |
thread-yield: page acquire read blocked | |
#define | WT_STAT_CONN_PAGE_SLEEP |
thread-yield: page acquire time sleeping (usecs) | |
#define | WT_STAT_CONN_PAGE_DEL_ROLLBACK_BLOCKED |
thread-yield: page delete rollback time sleeping for state change (usecs) | |
#define | WT_STAT_CONN_CHILD_MODIFY_BLOCKED_PAGE |
thread-yield: page reconciliation yielded due to child modification | |
#define | WT_STAT_CONN_TXN_PREPARED_UPDATES |
transaction: Number of prepared updates | |
#define | WT_STAT_CONN_TXN_PREPARED_UPDATES_COMMITTED |
transaction: Number of prepared updates committed | |
#define | WT_STAT_CONN_TXN_PREPARED_UPDATES_KEY_REPEATED |
transaction: Number of prepared updates repeated on the same key | |
#define | WT_STAT_CONN_TXN_PREPARED_UPDATES_ROLLEDBACK |
transaction: Number of prepared updates rolled back | |
#define | WT_STAT_CONN_TXN_READ_RACE_PREPARE_COMMIT |
transaction: a reader raced with a prepared transaction commit and skipped an update or updates | |
#define | WT_STAT_CONN_TXN_READ_OVERFLOW_REMOVE |
transaction: number of times overflow removed value is read | |
#define | WT_STAT_CONN_TXN_ROLLBACK_OLDEST_PINNED |
transaction: oldest pinned transaction ID rolled back for eviction | |
#define | WT_STAT_CONN_TXN_PREPARE |
transaction: prepared transactions | |
#define | WT_STAT_CONN_TXN_PREPARE_COMMIT |
transaction: prepared transactions committed | |
#define | WT_STAT_CONN_TXN_PREPARE_ACTIVE |
transaction: prepared transactions currently active | |
#define | WT_STAT_CONN_TXN_PREPARE_ROLLBACK |
transaction: prepared transactions rolled back | |
#define | WT_STAT_CONN_TXN_QUERY_TS |
transaction: query timestamp calls | |
#define | WT_STAT_CONN_TXN_READ_RACE_PREPARE_UPDATE |
transaction: race to read prepared update retry | |
#define | WT_STAT_CONN_TXN_RTS |
transaction: rollback to stable calls | |
#define | WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS_DRYRUN |
transaction: rollback to stable history store keys that would have been swept in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START |
transaction: rollback to stable history store records with stop timestamps older than newer records | |
#define | WT_STAT_CONN_TXN_RTS_INCONSISTENT_CKPT |
transaction: rollback to stable inconsistent checkpoint | |
#define | WT_STAT_CONN_TXN_RTS_KEYS_REMOVED |
transaction: rollback to stable keys removed | |
#define | WT_STAT_CONN_TXN_RTS_KEYS_RESTORED |
transaction: rollback to stable keys restored | |
#define | WT_STAT_CONN_TXN_RTS_KEYS_REMOVED_DRYRUN |
transaction: rollback to stable keys that would have been removed in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_KEYS_RESTORED_DRYRUN |
transaction: rollback to stable keys that would have been restored in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_PAGES_VISITED |
transaction: rollback to stable pages visited | |
#define | WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES |
transaction: rollback to stable restored tombstones from history store | |
#define | WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES |
transaction: rollback to stable restored updates from history store | |
#define | WT_STAT_CONN_TXN_RTS_DELETE_RLE_SKIPPED |
transaction: rollback to stable skipping delete rle | |
#define | WT_STAT_CONN_TXN_RTS_STABLE_RLE_SKIPPED |
transaction: rollback to stable skipping stable rle | |
#define | WT_STAT_CONN_TXN_RTS_SWEEP_HS_KEYS |
transaction: rollback to stable sweeping history store keys | |
#define | WT_STAT_CONN_TXN_RTS_HS_RESTORE_TOMBSTONES_DRYRUN |
transaction: rollback to stable tombstones from history store that would have been restored in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_TREE_WALK_SKIP_PAGES |
transaction: rollback to stable tree walk skipping pages | |
#define | WT_STAT_CONN_TXN_RTS_UPD_ABORTED |
transaction: rollback to stable updates aborted | |
#define | WT_STAT_CONN_TXN_RTS_HS_RESTORE_UPDATES_DRYRUN |
transaction: rollback to stable updates from history store that would have been restored in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_HS_REMOVED |
transaction: rollback to stable updates removed from history store | |
#define | WT_STAT_CONN_TXN_RTS_UPD_ABORTED_DRYRUN |
transaction: rollback to stable updates that would have been aborted in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_RTS_HS_REMOVED_DRYRUN |
transaction: rollback to stable updates that would have been removed from history store in non-dryrun mode | |
#define | WT_STAT_CONN_TXN_SESSIONS_WALKED |
transaction: sessions scanned in each walk of concurrent sessions | |
#define | WT_STAT_CONN_TXN_SET_TS |
transaction: set timestamp calls | |
#define | WT_STAT_CONN_TXN_SET_TS_DURABLE |
transaction: set timestamp durable calls | |
#define | WT_STAT_CONN_TXN_SET_TS_DURABLE_UPD |
transaction: set timestamp durable updates | |
#define | WT_STAT_CONN_TXN_SET_TS_FORCE |
transaction: set timestamp force calls | |
#define | WT_STAT_CONN_TXN_SET_TS_OUT_OF_ORDER |
transaction: set timestamp global oldest timestamp set to be more recent than the global stable timestamp | |
#define | WT_STAT_CONN_TXN_SET_TS_OLDEST |
transaction: set timestamp oldest calls | |
#define | WT_STAT_CONN_TXN_SET_TS_OLDEST_UPD |
transaction: set timestamp oldest updates | |
#define | WT_STAT_CONN_TXN_SET_TS_STABLE |
transaction: set timestamp stable calls | |
#define | WT_STAT_CONN_TXN_SET_TS_STABLE_UPD |
transaction: set timestamp stable updates | |
#define | WT_STAT_CONN_TXN_BEGIN |
transaction: transaction begins | |
#define | WT_STAT_CONN_TXN_HS_CKPT_DURATION |
transaction: transaction checkpoint history store file duration (usecs) | |
#define | WT_STAT_CONN_TXN_PINNED_RANGE |
transaction: transaction range of IDs currently pinned | |
#define | WT_STAT_CONN_TXN_PINNED_CHECKPOINT_RANGE |
transaction: transaction range of IDs currently pinned by a checkpoint | |
#define | WT_STAT_CONN_TXN_PINNED_TIMESTAMP |
transaction: transaction range of timestamps currently pinned | |
#define | WT_STAT_CONN_TXN_PINNED_TIMESTAMP_CHECKPOINT |
transaction: transaction range of timestamps pinned by a checkpoint | |
#define | WT_STAT_CONN_TXN_PINNED_TIMESTAMP_READER |
transaction: transaction range of timestamps pinned by the oldest active read timestamp | |
#define | WT_STAT_CONN_TXN_PINNED_TIMESTAMP_OLDEST |
transaction: transaction range of timestamps pinned by the oldest timestamp | |
#define | WT_STAT_CONN_TXN_TIMESTAMP_OLDEST_ACTIVE_READ |
transaction: transaction read timestamp of the oldest active reader | |
#define | WT_STAT_CONN_TXN_ROLLBACK_TO_STABLE_RUNNING |
transaction: transaction rollback to stable currently running | |
#define | WT_STAT_CONN_TXN_WALK_SESSIONS |
transaction: transaction walk of concurrent sessions | |
#define | WT_STAT_CONN_TXN_COMMIT |
transaction: transactions committed | |
#define | WT_STAT_CONN_TXN_ROLLBACK |
transaction: transactions rolled back | |
#define | WT_STAT_CONN_TXN_UPDATE_CONFLICT |
transaction: update conflicts | |
Statistics for data sources | |
#define | WT_STAT_DSRC_BLOOM_FALSE_POSITIVE |
LSM: bloom filter false positives. | |
#define | WT_STAT_DSRC_BLOOM_HIT |
LSM: bloom filter hits. | |
#define | WT_STAT_DSRC_BLOOM_MISS |
LSM: bloom filter misses. | |
#define | WT_STAT_DSRC_BLOOM_PAGE_EVICT |
LSM: bloom filter pages evicted from cache. | |
#define | WT_STAT_DSRC_BLOOM_PAGE_READ |
LSM: bloom filter pages read into cache. | |
#define | WT_STAT_DSRC_BLOOM_COUNT |
LSM: bloom filters in the LSM tree. | |
#define | WT_STAT_DSRC_LSM_CHUNK_COUNT |
LSM: chunks in the LSM tree. | |
#define | WT_STAT_DSRC_LSM_GENERATION_MAX |
LSM: highest merge generation in the LSM tree. | |
#define | WT_STAT_DSRC_LSM_LOOKUP_NO_BLOOM |
LSM: queries that could have benefited from a Bloom filter that did not exist. | |
#define | WT_STAT_DSRC_LSM_CHECKPOINT_THROTTLE |
LSM: sleep for LSM checkpoint throttle. | |
#define | WT_STAT_DSRC_LSM_MERGE_THROTTLE |
LSM: sleep for LSM merge throttle. | |
#define | WT_STAT_DSRC_BLOOM_SIZE |
LSM: total size of bloom filters. | |
#define | WT_STAT_DSRC_AUTOCOMMIT_READONLY_RETRY |
autocommit: retries for readonly operations | |
#define | WT_STAT_DSRC_AUTOCOMMIT_UPDATE_RETRY |
autocommit: retries for update operations | |
#define | WT_STAT_DSRC_BACKUP_BLOCKS_COMPRESSED |
backup: total modified incremental blocks with compressed data | |
#define | WT_STAT_DSRC_BACKUP_BLOCKS_UNCOMPRESSED |
backup: total modified incremental blocks without compressed data | |
#define | WT_STAT_DSRC_BLOCK_EXTENSION |
block-manager: allocations requiring file extension | |
#define | WT_STAT_DSRC_BLOCK_ALLOC |
block-manager: blocks allocated | |
#define | WT_STAT_DSRC_BLOCK_FREE |
block-manager: blocks freed | |
#define | WT_STAT_DSRC_BLOCK_CHECKPOINT_SIZE |
block-manager: checkpoint size | |
#define | WT_STAT_DSRC_ALLOCATION_SIZE |
block-manager: file allocation unit size | |
#define | WT_STAT_DSRC_BLOCK_REUSE_BYTES |
block-manager: file bytes available for reuse | |
#define | WT_STAT_DSRC_BLOCK_MAGIC |
block-manager: file magic number | |
#define | WT_STAT_DSRC_BLOCK_MAJOR |
block-manager: file major version number | |
#define | WT_STAT_DSRC_BLOCK_SIZE |
block-manager: file size in bytes | |
#define | WT_STAT_DSRC_BLOCK_MINOR |
block-manager: minor version number | |
#define | WT_STAT_DSRC_BTREE_CHECKPOINT_GENERATION |
btree: btree checkpoint generation | |
#define | WT_STAT_DSRC_BTREE_CLEAN_CHECKPOINT_TIMER |
btree: btree clean tree checkpoint expiration time | |
#define | WT_STAT_DSRC_BTREE_COMPACT_PAGES_REVIEWED |
btree: btree compact pages reviewed | |
#define | WT_STAT_DSRC_BTREE_COMPACT_PAGES_REWRITTEN |
btree: btree compact pages rewritten | |
#define | WT_STAT_DSRC_BTREE_COMPACT_PAGES_SKIPPED |
btree: btree compact pages skipped | |
#define | WT_STAT_DSRC_BTREE_COMPACT_BYTES_REWRITTEN_EXPECTED |
btree: btree expected number of compact bytes rewritten | |
#define | WT_STAT_DSRC_BTREE_COMPACT_PAGES_REWRITTEN_EXPECTED |
btree: btree expected number of compact pages rewritten | |
#define | WT_STAT_DSRC_BTREE_CHECKPOINT_PAGES_RECONCILED |
btree: btree number of pages reconciled during checkpoint | |
#define | WT_STAT_DSRC_BTREE_COMPACT_SKIPPED |
btree: btree skipped by compaction as process would not reduce size | |
#define | WT_STAT_DSRC_BTREE_COLUMN_FIX |
btree: column-store fixed-size leaf pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_COLUMN_TWS |
btree: column-store fixed-size time windows, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_COLUMN_INTERNAL |
btree: column-store internal pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_COLUMN_RLE |
btree: column-store variable-size RLE encoded values, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_COLUMN_DELETED |
btree: column-store variable-size deleted values, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_COLUMN_VARIABLE |
btree: column-store variable-size leaf pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_FIXED_LEN |
btree: fixed-record size | |
#define | WT_STAT_DSRC_BTREE_MAXINTLPAGE |
btree: maximum internal page size | |
#define | WT_STAT_DSRC_BTREE_MAXLEAFKEY |
btree: maximum leaf page key size | |
#define | WT_STAT_DSRC_BTREE_MAXLEAFPAGE |
btree: maximum leaf page size | |
#define | WT_STAT_DSRC_BTREE_MAXLEAFVALUE |
btree: maximum leaf page value size | |
#define | WT_STAT_DSRC_BTREE_MAXIMUM_DEPTH |
btree: maximum tree depth | |
#define | WT_STAT_DSRC_BTREE_ENTRIES |
btree: number of key/value pairs, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_OVERFLOW |
btree: overflow pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_ROW_EMPTY_VALUES |
btree: row-store empty values, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_ROW_INTERNAL |
btree: row-store internal pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_BTREE_ROW_LEAF |
btree: row-store leaf pages, only reported if tree_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_BYTES_INUSE |
cache: bytes currently in the cache | |
#define | WT_STAT_DSRC_CACHE_BYTES_DIRTY_TOTAL |
cache: bytes dirty in the cache cumulative | |
#define | WT_STAT_DSRC_CACHE_BYTES_READ |
cache: bytes read into cache | |
#define | WT_STAT_DSRC_CACHE_BYTES_WRITE |
cache: bytes written from cache | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT |
cache: checkpoint blocked page eviction | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_CHECKPOINT_HS |
cache: checkpoint of history store file blocked non-history store page eviction | |
#define | WT_STAT_DSRC_EVICTION_FAIL |
cache: data source pages selected for eviction unable to be evicted | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_1 |
cache: eviction gave up due to detecting a disk value without a timestamp behind the last update on the chain | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_2 |
cache: eviction gave up due to detecting a tombstone without a timestamp ahead of the selected on disk update | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_3 |
cache: eviction gave up due to detecting a tombstone without a timestamp ahead of the selected on disk update after validating the update chain | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_TS_CHECKPOINT_RACE_4 |
cache: eviction gave up due to detecting update chain entries without timestamps after the selected on disk update | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_REMOVE_HS_RACE_WITH_CHECKPOINT |
cache: eviction gave up due to needing to remove a record from the history store but checkpoint is running | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_NO_PROGRESS |
cache: eviction gave up due to no progress being made | |
#define | WT_STAT_DSRC_EVICTION_WALK_PASSES |
cache: eviction walk passes of a file | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT10 |
cache: eviction walk target pages histogram - 0-9 | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT32 |
cache: eviction walk target pages histogram - 10-31 | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_GE128 |
cache: eviction walk target pages histogram - 128 and higher | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT64 |
cache: eviction walk target pages histogram - 32-63 | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_LT128 |
cache: eviction walk target pages histogram - 64-128 | |
#define | WT_STAT_DSRC_CACHE_EVICTION_TARGET_PAGE_REDUCED |
cache: eviction walk target pages reduced due to history store cache pressure | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_HAZARD |
cache: hazard pointer blocked page eviction | |
#define | WT_STAT_DSRC_CACHE_HS_INSERT |
cache: history store table insert calls | |
#define | WT_STAT_DSRC_CACHE_HS_INSERT_RESTART |
cache: history store table insert calls that returned restart | |
#define | WT_STAT_DSRC_CACHE_HS_READ |
cache: history store table reads | |
#define | WT_STAT_DSRC_CACHE_HS_READ_MISS |
cache: history store table reads missed | |
#define | WT_STAT_DSRC_CACHE_HS_READ_SQUASH |
cache: history store table reads requiring squashed modifies | |
#define | WT_STAT_DSRC_CACHE_HS_ORDER_LOSE_DURABLE_TIMESTAMP |
cache: history store table resolved updates without timestamps that lose their durable timestamp | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE |
cache: history store table truncation by rollback to stable to remove an unstable update | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS |
cache: history store table truncation by rollback to stable to remove an update | |
#define | WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE |
cache: history store table truncation to remove all the keys of a btree | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE |
cache: history store table truncation to remove an update | |
#define | WT_STAT_DSRC_CACHE_HS_ORDER_REMOVE |
cache: history store table truncation to remove range of updates due to an update without a timestamp on data page | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_ONPAGE_REMOVAL |
cache: history store table truncation to remove range of updates due to key being removed from the data page during reconciliation | |
#define | WT_STAT_DSRC_CACHE_HS_BTREE_TRUNCATE_DRYRUN |
cache: history store table truncations that would have happened in non-dryrun mode | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_UNSTABLE_DRYRUN |
cache: history store table truncations to remove an unstable update that would have happened in non-dryrun mode | |
#define | WT_STAT_DSRC_CACHE_HS_KEY_TRUNCATE_RTS_DRYRUN |
cache: history store table truncations to remove an update that would have happened in non-dryrun mode | |
#define | WT_STAT_DSRC_CACHE_HS_ORDER_REINSERT |
cache: history store table updates without timestamps fixed up by reinserting with the fixed timestamp | |
#define | WT_STAT_DSRC_CACHE_HS_WRITE_SQUASH |
cache: history store table writes requiring squashed modifies | |
#define | WT_STAT_DSRC_CACHE_INMEM_SPLITTABLE |
cache: in-memory page passed criteria to be split | |
#define | WT_STAT_DSRC_CACHE_INMEM_SPLIT |
cache: in-memory page splits | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_INTERNAL_PAGE_SPLIT |
cache: internal page split blocked its eviction | |
#define | WT_STAT_DSRC_CACHE_EVICTION_INTERNAL |
cache: internal pages evicted | |
#define | WT_STAT_DSRC_CACHE_EVICTION_SPLIT_INTERNAL |
cache: internal pages split during eviction | |
#define | WT_STAT_DSRC_CACHE_EVICTION_SPLIT_LEAF |
cache: leaf pages split during eviction | |
#define | WT_STAT_DSRC_CACHE_EVICTION_RANDOM_SAMPLE_INMEM_ROOT |
cache: locate a random in-mem ref by examining all entries on the root page | |
#define | WT_STAT_DSRC_CACHE_EVICTION_DIRTY |
cache: modified pages evicted | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_MULTI_BLOCK_RECONCILIATION_DURING_CHECKPOINT |
cache: multi-block reconciliation blocked whilst checkpoint is running | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_OVERFLOW_KEYS |
cache: overflow keys on a multiblock row-store page blocked its eviction | |
#define | WT_STAT_DSRC_CACHE_READ_OVERFLOW |
cache: overflow pages read into cache | |
#define | WT_STAT_DSRC_CACHE_EVICTION_DEEPEN |
cache: page split during eviction deepened the tree | |
#define | WT_STAT_DSRC_CACHE_WRITE_HS |
cache: page written requiring history store records | |
#define | WT_STAT_DSRC_CACHE_EVICTION_DIRTY_OBSOLETE_TW |
cache: pages dirtied due to obsolete time window by eviction | |
#define | WT_STAT_DSRC_CACHE_READ |
cache: pages read into cache | |
#define | WT_STAT_DSRC_CACHE_READ_DELETED |
cache: pages read into cache after truncate | |
#define | WT_STAT_DSRC_CACHE_READ_DELETED_PREPARED |
cache: pages read into cache after truncate in prepare state | |
#define | WT_STAT_DSRC_CACHE_READ_CHECKPOINT |
cache: pages read into cache by checkpoint | |
#define | WT_STAT_DSRC_CACHE_PAGES_REQUESTED |
cache: pages requested from the cache | |
#define | WT_STAT_DSRC_CACHE_PAGES_PREFETCH |
cache: pages requested from the cache due to pre-fetch | |
#define | WT_STAT_DSRC_CACHE_EVICTION_PAGES_SEEN |
cache: pages seen by eviction walk | |
#define | WT_STAT_DSRC_CACHE_WRITE |
cache: pages written from cache | |
#define | WT_STAT_DSRC_CACHE_WRITE_RESTORE |
cache: pages written requiring in-memory restoration | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_RECENTLY_MODIFIED |
cache: recent modification of a page blocked its eviction | |
#define | WT_STAT_DSRC_CACHE_REVERSE_SPLITS |
cache: reverse splits performed | |
#define | WT_STAT_DSRC_CACHE_REVERSE_SPLITS_SKIPPED_VLCS |
cache: reverse splits skipped because of VLCS namespace gap restrictions | |
#define | WT_STAT_DSRC_CACHE_HS_INSERT_FULL_UPDATE |
cache: the number of times full update inserted to history store | |
#define | WT_STAT_DSRC_CACHE_HS_INSERT_REVERSE_MODIFY |
cache: the number of times reverse modify inserted to history store | |
#define | WT_STAT_DSRC_CACHE_BYTES_DIRTY |
cache: tracked dirty bytes in the cache | |
#define | WT_STAT_DSRC_CACHE_BYTES_DIRTY_INTERNAL |
cache: tracked dirty internal page bytes in the cache | |
#define | WT_STAT_DSRC_CACHE_BYTES_DIRTY_LEAF |
cache: tracked dirty leaf page bytes in the cache | |
#define | WT_STAT_DSRC_CACHE_EVICTION_BLOCKED_UNCOMMITTED_TRUNCATE |
cache: uncommitted truncate blocked page eviction | |
#define | WT_STAT_DSRC_CACHE_EVICTION_CLEAN |
cache: unmodified pages evicted | |
#define | WT_STAT_DSRC_CACHE_STATE_GEN_AVG_GAP |
cache_walk: Average difference between current eviction generation when the page was last considered, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_AVG_WRITTEN_SIZE |
cache_walk: Average on-disk page image size seen, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_AVG_VISITED_AGE |
cache_walk: Average time in cache for pages that have been visited by the eviction server, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_AVG_UNVISITED_AGE |
cache_walk: Average time in cache for pages that have not been visited by the eviction server, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_PAGES_CLEAN |
cache_walk: Clean pages currently in cache, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_GEN_CURRENT |
cache_walk: Current eviction generation, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_PAGES_DIRTY |
cache_walk: Dirty pages currently in cache, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_ROOT_ENTRIES |
cache_walk: Entries in the root page, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_PAGES_INTERNAL |
cache_walk: Internal pages currently in cache, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_PAGES_LEAF |
cache_walk: Leaf pages currently in cache, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_GEN_MAX_GAP |
cache_walk: Maximum difference between current eviction generation when the page was last considered, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_MAX_PAGESIZE |
cache_walk: Maximum page size seen, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_MIN_WRITTEN_SIZE |
cache_walk: Minimum on-disk page image size seen, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_UNVISITED_COUNT |
cache_walk: Number of pages never visited by eviction server, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_SMALLER_ALLOC_SIZE |
cache_walk: On-disk page image sizes smaller than a single allocation unit, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_MEMORY |
cache_walk: Pages created in memory and never written, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_QUEUED |
cache_walk: Pages currently queued for eviction, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_NOT_QUEUEABLE |
cache_walk: Pages that could not be queued for eviction, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_REFS_SKIPPED |
cache_walk: Refs skipped during cache traversal, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_ROOT_SIZE |
cache_walk: Size of the root page, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CACHE_STATE_PAGES |
cache_walk: Total number of pages currently in cache, only reported if cache_walk or all statistics are enabled | |
#define | WT_STAT_DSRC_CHECKPOINT_SNAPSHOT_ACQUIRED |
checkpoint: checkpoint has acquired a snapshot for its transaction | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_EVICT |
checkpoint: pages added for eviction during checkpoint cleanup | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_OBSOLETE_TW |
checkpoint: pages dirtied due to obsolete time window by checkpoint cleanup | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_READ_RECLAIM_SPACE |
checkpoint: pages read into cache during checkpoint cleanup (reclaim_space) | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_READ_OBSOLETE_TW |
checkpoint: pages read into cache during checkpoint cleanup due to obsolete time window | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_REMOVED |
checkpoint: pages removed during checkpoint cleanup | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_WALK_SKIPPED |
checkpoint: pages skipped during checkpoint cleanup tree walk | |
#define | WT_STAT_DSRC_CHECKPOINT_CLEANUP_PAGES_VISITED |
checkpoint: pages visited during checkpoint cleanup | |
#define | WT_STAT_DSRC_CHECKPOINT_OBSOLETE_APPLIED |
checkpoint: transaction checkpoints due to obsolete pages | |
#define | WT_STAT_DSRC_COMPRESS_PRECOMP_INTL_MAX_PAGE_SIZE |
compression: compressed page maximum internal page size prior to compression | |
#define | WT_STAT_DSRC_COMPRESS_PRECOMP_LEAF_MAX_PAGE_SIZE |
compression: compressed page maximum leaf page size prior to compression | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_FAIL |
compression: page written to disk failed to compress | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_TOO_SMALL |
compression: page written to disk was too small to compress | |
#define | WT_STAT_DSRC_COMPRESS_READ |
compression: pages read from disk | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_MAX |
compression: pages read from disk with compression ratio greater than 64 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_2 |
compression: pages read from disk with compression ratio smaller than 2 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_4 |
compression: pages read from disk with compression ratio smaller than 4 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_8 |
compression: pages read from disk with compression ratio smaller than 8 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_16 |
compression: pages read from disk with compression ratio smaller than 16 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_32 |
compression: pages read from disk with compression ratio smaller than 32 | |
#define | WT_STAT_DSRC_COMPRESS_READ_RATIO_HIST_64 |
compression: pages read from disk with compression ratio smaller than 64 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE |
compression: pages written to disk | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_MAX |
compression: pages written to disk with compression ratio greater than 64 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_2 |
compression: pages written to disk with compression ratio smaller than 2 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_4 |
compression: pages written to disk with compression ratio smaller than 4 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_8 |
compression: pages written to disk with compression ratio smaller than 8 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_16 |
compression: pages written to disk with compression ratio smaller than 16 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_32 |
compression: pages written to disk with compression ratio smaller than 32 | |
#define | WT_STAT_DSRC_COMPRESS_WRITE_RATIO_HIST_64 |
compression: pages written to disk with compression ratio smaller than 64 | |
#define | WT_STAT_DSRC_CURSOR_TREE_WALK_DEL_PAGE_SKIP |
cursor: Total number of deleted pages skipped during tree walk | |
#define | WT_STAT_DSRC_CURSOR_NEXT_SKIP_TOTAL |
cursor: Total number of entries skipped by cursor next calls | |
#define | WT_STAT_DSRC_CURSOR_PREV_SKIP_TOTAL |
cursor: Total number of entries skipped by cursor prev calls | |
#define | WT_STAT_DSRC_CURSOR_SKIP_HS_CUR_POSITION |
cursor: Total number of entries skipped to position the history store cursor | |
#define | WT_STAT_DSRC_CURSOR_TREE_WALK_INMEM_DEL_PAGE_SKIP |
cursor: Total number of in-memory deleted pages skipped during tree walk | |
#define | WT_STAT_DSRC_CURSOR_TREE_WALK_ONDISK_DEL_PAGE_SKIP |
cursor: Total number of on-disk deleted pages skipped during tree walk | |
#define | WT_STAT_DSRC_CURSOR_SEARCH_NEAR_PREFIX_FAST_PATHS |
cursor: Total number of times a search near has exited due to prefix config | |
#define | WT_STAT_DSRC_CURSOR_REPOSITION_FAILED |
cursor: Total number of times cursor fails to temporarily release pinned page to encourage eviction of hot or large page | |
#define | WT_STAT_DSRC_CURSOR_REPOSITION |
cursor: Total number of times cursor temporarily releases pinned page to encourage eviction of hot or large page | |
#define | WT_STAT_DSRC_CURSOR_INSERT_BULK |
cursor: bulk loaded cursor insert calls | |
#define | WT_STAT_DSRC_CURSOR_REOPEN |
cursor: cache cursors reuse count | |
#define | WT_STAT_DSRC_CURSOR_CACHE |
cursor: close calls that result in cache | |
#define | WT_STAT_DSRC_CURSOR_CREATE |
cursor: create calls | |
#define | WT_STAT_DSRC_CURSOR_BOUND_ERROR |
cursor: cursor bound calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_RESET |
cursor: cursor bounds cleared from reset | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_COMPARISONS |
cursor: cursor bounds comparisons performed | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_UNPOSITIONED |
cursor: cursor bounds next called on an unpositioned cursor | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_NEXT_EARLY_EXIT |
cursor: cursor bounds next early exit | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_PREV_UNPOSITIONED |
cursor: cursor bounds prev called on an unpositioned cursor | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_PREV_EARLY_EXIT |
cursor: cursor bounds prev early exit | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_EARLY_EXIT |
cursor: cursor bounds search early exit | |
#define | WT_STAT_DSRC_CURSOR_BOUNDS_SEARCH_NEAR_REPOSITIONED_CURSOR |
cursor: cursor bounds search near call repositioned cursor | |
#define | WT_STAT_DSRC_CURSOR_CACHE_ERROR |
cursor: cursor cache calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_CLOSE_ERROR |
cursor: cursor close calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_COMPARE_ERROR |
cursor: cursor compare calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_EQUALS_ERROR |
cursor: cursor equals calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_GET_KEY_ERROR |
cursor: cursor get key calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_GET_VALUE_ERROR |
cursor: cursor get value calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_INSERT_ERROR |
cursor: cursor insert calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_INSERT_CHECK_ERROR |
cursor: cursor insert check calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_LARGEST_KEY_ERROR |
cursor: cursor largest key calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_MODIFY_ERROR |
cursor: cursor modify calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_NEXT_ERROR |
cursor: cursor next calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_NEXT_HS_TOMBSTONE |
cursor: cursor next calls that skip due to a globally visible history store tombstone | |
#define | WT_STAT_DSRC_CURSOR_NEXT_SKIP_LT_100 |
cursor: cursor next calls that skip greater than 1 and fewer than 100 entries | |
#define | WT_STAT_DSRC_CURSOR_NEXT_SKIP_GE_100 |
cursor: cursor next calls that skip greater than or equal to 100 entries | |
#define | WT_STAT_DSRC_CURSOR_NEXT_RANDOM_ERROR |
cursor: cursor next random calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_PREV_ERROR |
cursor: cursor prev calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_PREV_HS_TOMBSTONE |
cursor: cursor prev calls that skip due to a globally visible history store tombstone | |
#define | WT_STAT_DSRC_CURSOR_PREV_SKIP_GE_100 |
cursor: cursor prev calls that skip greater than or equal to 100 entries | |
#define | WT_STAT_DSRC_CURSOR_PREV_SKIP_LT_100 |
cursor: cursor prev calls that skip less than 100 entries | |
#define | WT_STAT_DSRC_CURSOR_RECONFIGURE_ERROR |
cursor: cursor reconfigure calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_REMOVE_ERROR |
cursor: cursor remove calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_REOPEN_ERROR |
cursor: cursor reopen calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_RESERVE_ERROR |
cursor: cursor reserve calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_RESET_ERROR |
cursor: cursor reset calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_SEARCH_ERROR |
cursor: cursor search calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_SEARCH_NEAR_ERROR |
cursor: cursor search near calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_UPDATE_ERROR |
cursor: cursor update calls that return an error | |
#define | WT_STAT_DSRC_CURSOR_INSERT |
cursor: insert calls | |
#define | WT_STAT_DSRC_CURSOR_INSERT_BYTES |
cursor: insert key and value bytes | |
#define | WT_STAT_DSRC_CURSOR_MODIFY |
cursor: modify | |
#define | WT_STAT_DSRC_CURSOR_MODIFY_BYTES |
cursor: modify key and value bytes affected | |
#define | WT_STAT_DSRC_CURSOR_MODIFY_BYTES_TOUCH |
cursor: modify value bytes modified | |
#define | WT_STAT_DSRC_CURSOR_NEXT |
cursor: next calls | |
#define | WT_STAT_DSRC_CURSOR_OPEN_COUNT |
cursor: open cursor count | |
#define | WT_STAT_DSRC_CURSOR_RESTART |
cursor: operation restarted | |
#define | WT_STAT_DSRC_CURSOR_PREV |
cursor: prev calls | |
#define | WT_STAT_DSRC_CURSOR_REMOVE |
cursor: remove calls | |
#define | WT_STAT_DSRC_CURSOR_REMOVE_BYTES |
cursor: remove key bytes removed | |
#define | WT_STAT_DSRC_CURSOR_RESERVE |
cursor: reserve calls | |
#define | WT_STAT_DSRC_CURSOR_RESET |
cursor: reset calls | |
#define | WT_STAT_DSRC_CURSOR_SEARCH |
cursor: search calls | |
#define | WT_STAT_DSRC_CURSOR_SEARCH_HS |
cursor: search history store calls | |
#define | WT_STAT_DSRC_CURSOR_SEARCH_NEAR |
cursor: search near calls | |
#define | WT_STAT_DSRC_CURSOR_TRUNCATE |
cursor: truncate calls | |
#define | WT_STAT_DSRC_CURSOR_UPDATE |
cursor: update calls | |
#define | WT_STAT_DSRC_CURSOR_UPDATE_BYTES |
cursor: update key and value bytes | |
#define | WT_STAT_DSRC_CURSOR_UPDATE_BYTES_CHANGED |
cursor: update value size change | |
#define | WT_STAT_DSRC_REC_VLCS_EMPTIED_PAGES |
reconciliation: VLCS pages explicitly reconciled as empty | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TS |
reconciliation: approximate byte size of timestamps in pages written | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_BYTES_TXN |
reconciliation: approximate byte size of transaction IDs in pages written | |
#define | WT_STAT_DSRC_REC_DICTIONARY |
reconciliation: dictionary matches | |
#define | WT_STAT_DSRC_REC_PAGE_DELETE_FAST |
reconciliation: fast-path pages deleted | |
#define | WT_STAT_DSRC_REC_SUFFIX_COMPRESSION |
reconciliation: internal page key bytes discarded using suffix compression | |
#define | WT_STAT_DSRC_REC_MULTIBLOCK_INTERNAL |
reconciliation: internal page multi-block writes | |
#define | WT_STAT_DSRC_REC_PREFIX_COMPRESSION |
reconciliation: leaf page key bytes discarded using prefix compression | |
#define | WT_STAT_DSRC_REC_MULTIBLOCK_LEAF |
reconciliation: leaf page multi-block writes | |
#define | WT_STAT_DSRC_REC_OVERFLOW_KEY_LEAF |
reconciliation: leaf-page overflow keys | |
#define | WT_STAT_DSRC_REC_MULTIBLOCK_MAX |
reconciliation: maximum blocks required for a page | |
#define | WT_STAT_DSRC_REC_OVERFLOW_VALUE |
reconciliation: overflow values written | |
#define | WT_STAT_DSRC_REC_PAGES |
reconciliation: page reconciliation calls | |
#define | WT_STAT_DSRC_REC_PAGES_EVICTION |
reconciliation: page reconciliation calls for eviction | |
#define | WT_STAT_DSRC_REC_PAGE_DELETE |
reconciliation: pages deleted | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_START_DURABLE_TS |
reconciliation: pages written including an aggregated newest start durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_DURABLE_TS |
reconciliation: pages written including an aggregated newest stop durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TS |
reconciliation: pages written including an aggregated newest stop timestamp | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_STOP_TXN |
reconciliation: pages written including an aggregated newest stop transaction ID | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_NEWEST_TXN |
reconciliation: pages written including an aggregated newest transaction ID | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_OLDEST_START_TS |
reconciliation: pages written including an aggregated oldest start timestamp | |
#define | WT_STAT_DSRC_REC_TIME_AGGR_PREPARED |
reconciliation: pages written including an aggregated prepare | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_PREPARED |
reconciliation: pages written including at least one prepare | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_START_TS |
reconciliation: pages written including at least one start durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TS |
reconciliation: pages written including at least one start timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_START_TXN |
reconciliation: pages written including at least one start transaction ID | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_DURABLE_STOP_TS |
reconciliation: pages written including at least one stop durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TS |
reconciliation: pages written including at least one stop timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PAGES_STOP_TXN |
reconciliation: pages written including at least one stop transaction ID | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_PREPARED |
reconciliation: records written including a prepare | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_START_TS |
reconciliation: records written including a start durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_START_TS |
reconciliation: records written including a start timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_START_TXN |
reconciliation: records written including a start transaction ID | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_DURABLE_STOP_TS |
reconciliation: records written including a stop durable timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TS |
reconciliation: records written including a stop timestamp | |
#define | WT_STAT_DSRC_REC_TIME_WINDOW_STOP_TXN |
reconciliation: records written including a stop transaction ID | |
#define | WT_STAT_DSRC_SESSION_COMPACT |
session: object compaction | |
#define | WT_STAT_DSRC_TXN_READ_RACE_PREPARE_COMMIT |
transaction: a reader raced with a prepared transaction commit and skipped an update or updates | |
#define | WT_STAT_DSRC_TXN_READ_OVERFLOW_REMOVE |
transaction: number of times overflow removed value is read | |
#define | WT_STAT_DSRC_TXN_READ_RACE_PREPARE_UPDATE |
transaction: race to read prepared update retry | |
#define | WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS_DRYRUN |
transaction: rollback to stable history store keys that would have been swept in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_RTS_HS_STOP_OLDER_THAN_NEWER_START |
transaction: rollback to stable history store records with stop timestamps older than newer records | |
#define | WT_STAT_DSRC_TXN_RTS_INCONSISTENT_CKPT |
transaction: rollback to stable inconsistent checkpoint | |
#define | WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED |
transaction: rollback to stable keys removed | |
#define | WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED |
transaction: rollback to stable keys restored | |
#define | WT_STAT_DSRC_TXN_RTS_KEYS_REMOVED_DRYRUN |
transaction: rollback to stable keys that would have been removed in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_RTS_KEYS_RESTORED_DRYRUN |
transaction: rollback to stable keys that would have been restored in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES |
transaction: rollback to stable restored tombstones from history store | |
#define | WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES |
transaction: rollback to stable restored updates from history store | |
#define | WT_STAT_DSRC_TXN_RTS_DELETE_RLE_SKIPPED |
transaction: rollback to stable skipping delete rle | |
#define | WT_STAT_DSRC_TXN_RTS_STABLE_RLE_SKIPPED |
transaction: rollback to stable skipping stable rle | |
#define | WT_STAT_DSRC_TXN_RTS_SWEEP_HS_KEYS |
transaction: rollback to stable sweeping history store keys | |
#define | WT_STAT_DSRC_TXN_RTS_HS_RESTORE_TOMBSTONES_DRYRUN |
transaction: rollback to stable tombstones from history store that would have been restored in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_RTS_HS_RESTORE_UPDATES_DRYRUN |
transaction: rollback to stable updates from history store that would have been restored in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_RTS_HS_REMOVED |
transaction: rollback to stable updates removed from history store | |
#define | WT_STAT_DSRC_TXN_RTS_HS_REMOVED_DRYRUN |
transaction: rollback to stable updates that would have been removed from history store in non-dryrun mode | |
#define | WT_STAT_DSRC_TXN_UPDATE_CONFLICT |
transaction: update conflicts | |
Statistics for session | |
#define | WT_STAT_SESSION_BYTES_READ |
session: bytes read into cache | |
#define | WT_STAT_SESSION_BYTES_WRITE |
session: bytes written from cache | |
#define | WT_STAT_SESSION_LOCK_DHANDLE_WAIT |
session: dhandle lock wait time (usecs) | |
#define | WT_STAT_SESSION_TXN_BYTES_DIRTY |
session: dirty bytes in this txn | |
#define | WT_STAT_SESSION_READ_TIME |
session: page read from disk to cache time (usecs) | |
#define | WT_STAT_SESSION_WRITE_TIME |
session: page write from cache to disk time (usecs) | |
#define | WT_STAT_SESSION_LOCK_SCHEMA_WAIT |
session: schema lock wait time (usecs) | |
#define | WT_STAT_SESSION_CACHE_TIME |
session: time waiting for cache (usecs) | |
Verbose categories | |
enum | WT_VERBOSE_CATEGORY { WT_VERB_ALL, WT_VERB_API, WT_VERB_BACKUP, WT_VERB_BLKCACHE, WT_VERB_BLOCK, WT_VERB_CHECKPOINT, WT_VERB_CHECKPOINT_CLEANUP, WT_VERB_CHECKPOINT_PROGRESS, WT_VERB_CHUNKCACHE, WT_VERB_COMPACT, WT_VERB_COMPACT_PROGRESS, WT_VERB_CONFIGURATION, WT_VERB_DEFAULT, WT_VERB_ERROR_RETURNS, WT_VERB_EVICTION, WT_VERB_EXTENSION, WT_VERB_FILEOPS, WT_VERB_GENERATION, WT_VERB_HANDLEOPS, WT_VERB_HS, WT_VERB_HS_ACTIVITY, WT_VERB_LOG, WT_VERB_LSM, WT_VERB_LSM_MANAGER, WT_VERB_MUTEX, WT_VERB_METADATA, WT_VERB_OUT_OF_ORDER, WT_VERB_OVERFLOW, WT_VERB_PREFETCH, WT_VERB_READ, WT_VERB_RECONCILE, WT_VERB_RECOVERY, WT_VERB_RECOVERY_PROGRESS, WT_VERB_RTS, WT_VERB_SALVAGE, WT_VERB_SHARED_CACHE, WT_VERB_SPLIT, WT_VERB_TEMPORARY, WT_VERB_THREAD_GROUP, WT_VERB_TIERED, WT_VERB_TIMESTAMP, WT_VERB_TRANSACTION, WT_VERB_VERIFY, WT_VERB_VERSION, WT_VERB_WRITE, WT_VERB_NUM_CATEGORIES } |
WiredTiger verbose event categories. More... | |
Verbose levels | |
enum | WT_VERBOSE_LEVEL { WT_VERBOSE_ERROR, WT_VERBOSE_WARNING, WT_VERBOSE_NOTICE, WT_VERBOSE_INFO, WT_VERBOSE_DEBUG_1, WT_VERBOSE_DEBUG_2, WT_VERBOSE_DEBUG_3, WT_VERBOSE_DEBUG_4, WT_VERBOSE_DEBUG_5 } |
WiredTiger verbosity levels. More... | |
The functions, handles and methods applications use to access and manage data with WiredTiger.
struct WT_ITEM |
A raw item of data to be managed, including a pointer to the data and a length.
WT_ITEM structures do not need to be cleared before use.
Class Members | ||
---|---|---|
const void * | data |
The memory reference of the data item. For items returned by a WT_CURSOR, the pointer is only valid until the next operation on that cursor. Applications that need to keep an item across multiple cursor operations must make a copy. |
size_t | size |
The number of bytes in the data item. The maximum length of a single column stored in a table is not fixed (as it partially depends on the underlying file configuration), but is always a small number of bytes less than 4GB. |
struct WT_MODIFY |
A set of modifications for a value, including a pointer to new data and a length, plus a target offset in the value and an optional length of data in the value to be replaced.
WT_MODIFY structures do not need to be cleared before use.
Class Members | ||
---|---|---|
WT_ITEM | data |
New data. The size of the new data may be zero when no new data is provided. |
size_t | offset |
The zero-based byte offset in the value where the new data is placed. If the offset is past the end of the value, padding bytes are appended to the value up to the specified offset. If the value is a string (value format |
size_t | size |
The number of bytes in the value to be replaced. If the size is zero, no bytes from the value are replaced and the new data is inserted. If the offset is past the end of the value, the size is ignored. If the offset plus the size overlaps the end of the previous value, bytes from the offset to the end of the value are replaced and any remaining new data is appended. |
#define WT_CACHE_FULL |
Operation would overflow cache.
This error is generated when wiredtiger_open is configured to run in-memory, and a data modification operation requires more than the configured cache size to complete. The operation may be retried; if a transaction is in progress, it should be rolled back and the operation retried in a new transaction.
#define WT_DUPLICATE_KEY |
Attempt to insert an existing key.
This error is generated when the application attempts to insert a record with the same key as an existing record without the 'overwrite' configuration to WT_SESSION::open_cursor.
#define WT_ERROR |
Non-specific WiredTiger error.
This error is returned when an error is not covered by a specific error return. The operation may be retried; if a transaction is in progress, it should be rolled back and the operation retried in a new transaction.
#define WT_INTPACK32_MAXSIZE |
The maximum packed size of a 32-bit integer.
The wiredtiger_struct_pack function will pack single integers into at most this many bytes.
#define WT_INTPACK64_MAXSIZE |
The maximum packed size of a 64-bit integer.
The wiredtiger_struct_pack function will pack single long integers into at most this many bytes.
#define WT_NOTFOUND |
Item not found.
This error indicates an operation did not find a value to return. This includes cursor search and other operations where no record matched the cursor's search key such as WT_CURSOR::update or WT_CURSOR::remove.
#define WT_PANIC |
WiredTiger library panic.
This error indicates an underlying problem that requires a database restart. The application may exit immediately, no further WiredTiger calls are required (and further calls will themselves immediately fail).
#define WT_PREPARE_CONFLICT |
Conflict with a prepared update.
This error is generated when the application attempts to read an updated record which is part of a transaction that has been prepared but not yet resolved.
#define WT_ROLLBACK |
Conflict between concurrent operations.
This error is generated when an operation cannot be completed due to a conflict with concurrent operations. The operation may be retried; if a transaction is in progress, it should be rolled back and the operation retried in a new transaction.
#define WT_RUN_RECOVERY |
Recovery must be run to continue.
This error is generated when wiredtiger_open is configured to return an error if recovery is required to use the database.
#define WT_TRY_SALVAGE |
Database corruption detected.
This error is generated when corruption is detected in an on-disk file. During normal operations, this may occur in rare circumstances as a result of a system crash. The application may choose to salvage the file or retry wiredtiger_open with the 'salvage=true' configuration setting.
typedef struct __wt_pack_stream WT_PACK_STREAM |
Streaming interface to packing.
This allows applications to pack or unpack records one field at a time. This is an opaque handle returned by wiredtiger_pack_start or wiredtiger_unpack_start. It must be closed with wiredtiger_pack_close.
enum WT_EVENT_TYPE |
enum WT_TS_TXN_TYPE |
WT_SESSION::timestamp_transaction_uint timestamp types.
Enumerator | |
---|---|
WT_TS_TXN_TYPE_COMMIT | Commit timestamp. |
WT_TS_TXN_TYPE_DURABLE | Durable timestamp. |
WT_TS_TXN_TYPE_PREPARE | Prepare timestamp. |
WT_TS_TXN_TYPE_READ | Read timestamp. |
enum WT_VERBOSE_CATEGORY |
WiredTiger verbose event categories.
Note that the verbose categories cover a wide set of sub-systems and operations within WiredTiger. As such, the categories are subject to change and evolve between different WiredTiger releases.
enum WT_VERBOSE_LEVEL |
WiredTiger verbosity levels.
The levels define a range of severity categories, with WT_VERBOSE_ERROR
being the lowest, most critical level (used by messages on critical error paths) and WT_VERBOSE_DEBUG_5
being the highest verbosity/informational level (mostly adopted for debugging).
int wiredtiger_calc_modify | ( | WT_SESSION * | session, |
const WT_ITEM * | oldv, | ||
const WT_ITEM * | newv, | ||
size_t | maxdiff, | ||
WT_MODIFY * | entries, | ||
int * | nentriesp | ||
) |
Calculate a set of WT_MODIFY operations to represent an update.
This call will calculate a set of modifications to an old value that produce the new value. If more modifications are required than fit in the array passed in by the caller, or if more bytes have changed than the maxdiff
parameter, the call will fail. The matching algorithm is approximate, so it may fail and return WT_NOTFOUND if a matching set of WT_MODIFY operations is not found.
The maxdiff
parameter bounds how much work will be done searching for a match: to ensure a match is found, it may need to be set larger than actual number of bytes that differ between the old and new values. In particular, repeated patterns of bytes in the values can lead to suboptimal matching, and matching ranges less than 64 bytes long will not be detected.
If the call succeeds, the WT_MODIFY operations will point into newv
, which must remain valid until WT_CURSOR::modify is called.
session | the current WiredTiger session (may be NULL) | |
oldv | old value | |
newv | new value | |
maxdiff | maximum bytes difference | |
[out] | entries | array of modifications producing the new value |
[in,out] | nentriesp | size of entries array passed in, set to the number of entries used |
int wiredtiger_config_parser_open | ( | WT_SESSION * | session, |
const char * | config, | ||
size_t | len, | ||
WT_CONFIG_PARSER ** | config_parserp | ||
) |
Create a handle that can be used to parse or create configuration strings compatible with the WiredTiger API.
This call is outside the scope of a WiredTiger connection handle, since applications may need to generate configuration strings prior to calling wiredtiger_open.
session | the session handle to be used for error reporting (if NULL, error messages will be written to stderr). | |
config | the configuration string being parsed. The string must remain valid for the lifetime of the parser handle. | |
len | the number of valid bytes in config | |
[out] | config_parserp | A pointer to the newly opened handle |
int wiredtiger_open | ( | const char * | home, |
WT_EVENT_HANDLER * | event_handler, | ||
const char * | config, | ||
WT_CONNECTION ** | connectionp | ||
) |
Open a connection to a database.
home | The path to the database home directory. See Database Home Directory for more information. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
event_handler | An event handler. If NULL , a default event handler is installed that writes error messages to stderr. See Message handling using the WT_EVENT_HANDLER for more information. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
config | configuration string, see Configuration Strings. Permitted values:
WiredTiger.config or WiredTiger.basecfg appear in the WiredTiger home directory, they are read for configuration values (see WiredTiger.config file and WiredTiger.basecfg file for details). See Configuration ordering for ordering of the configuration mechanisms. | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
[out] | connectionp | A pointer to the newly opened connection handle |
int wiredtiger_pack_close | ( | WT_PACK_STREAM * | ps, |
size_t * | usedp | ||
) |
Close a packing stream.
ps | the packing stream handle | |
[out] | usedp | the number of bytes in the buffer used by the stream |
int wiredtiger_pack_int | ( | WT_PACK_STREAM * | ps, |
int64_t | i | ||
) |
Pack a signed integer into a packing stream.
ps | the packing stream handle |
i | a signed integer to pack |
int wiredtiger_pack_item | ( | WT_PACK_STREAM * | ps, |
WT_ITEM * | item | ||
) |
Pack an item into a packing stream.
ps | the packing stream handle |
item | an item to pack |
int wiredtiger_pack_start | ( | WT_SESSION * | session, |
const char * | format, | ||
void * | buffer, | ||
size_t | size, | ||
WT_PACK_STREAM ** | psp | ||
) |
Start a packing operation into a buffer with the given format string.
This should be followed by a series of calls to wiredtiger_pack_item, wiredtiger_pack_int, wiredtiger_pack_str or wiredtiger_pack_uint to fill in the values.
session | the session handle | |
format | the data format, see Packing and Unpacking Data | |
buffer | a pointer to memory to hold the packed data | |
size | the size of the buffer | |
[out] | psp | the new packing stream handle |
int wiredtiger_pack_str | ( | WT_PACK_STREAM * | ps, |
const char * | s | ||
) |
Pack a string into a packing stream.
ps | the packing stream handle |
s | a string to pack |
int wiredtiger_pack_uint | ( | WT_PACK_STREAM * | ps, |
uint64_t | u | ||
) |
Pack an unsigned integer into a packing stream.
ps | the packing stream handle |
u | an unsigned integer to pack |
const char* wiredtiger_strerror | ( | int | error | ) |
Return information about a WiredTiger error as a string (see WT_SESSION::strerror for a thread-safe API).
error | a return value from a WiredTiger, ISO C, or POSIX standard API call |
int wiredtiger_struct_pack | ( | WT_SESSION * | session, |
void * | buffer, | ||
size_t | len, | ||
const char * | format, | ||
... | |||
) |
Pack a structure into a buffer.
See Packing and Unpacking Data for a description of the permitted format strings.
For example, the string "iSh"
will pack a 32-bit integer followed by a NUL-terminated string, followed by a 16-bit integer. The default, big-endian encoding will be used, with no alignment. This could be used in C as follows:
Then later, the values can be unpacked as follows:
session | the session handle |
buffer | a pointer to a packed byte array |
len | the number of valid bytes in the buffer |
format | the data format, see Packing and Unpacking Data |
int wiredtiger_struct_size | ( | WT_SESSION * | session, |
size_t * | lenp, | ||
const char * | format, | ||
... | |||
) |
Calculate the size required to pack a structure.
Note that for variable-sized fields including variable-sized strings and integers, the calculated sized merely reflects the expected sizes specified in the format string itself.
session | the session handle |
lenp | a location where the number of bytes needed for the matching call to wiredtiger_struct_pack is returned |
format | the data format, see Packing and Unpacking Data |
int wiredtiger_struct_unpack | ( | WT_SESSION * | session, |
const void * | buffer, | ||
size_t | len, | ||
const char * | format, | ||
... | |||
) |
Unpack a structure from a buffer.
Reverse of wiredtiger_struct_pack: gets values out of a packed byte string.
session | the session handle |
buffer | a pointer to a packed byte array |
len | the number of valid bytes in the buffer |
format | the data format, see Packing and Unpacking Data |
int wiredtiger_unpack_int | ( | WT_PACK_STREAM * | ps, |
int64_t * | ip | ||
) |
Unpack a signed integer from a packing stream.
ps | the packing stream handle | |
[out] | ip | the unpacked signed integer |
int wiredtiger_unpack_item | ( | WT_PACK_STREAM * | ps, |
WT_ITEM * | item | ||
) |
Unpack an item from a packing stream.
ps | the packing stream handle |
item | an item to unpack |
int wiredtiger_unpack_start | ( | WT_SESSION * | session, |
const char * | format, | ||
const void * | buffer, | ||
size_t | size, | ||
WT_PACK_STREAM ** | psp | ||
) |
Start an unpacking operation from a buffer with the given format string.
This should be followed by a series of calls to wiredtiger_unpack_item, wiredtiger_unpack_int, wiredtiger_unpack_str or wiredtiger_unpack_uint to retrieve the packed values.
session | the session handle | |
format | the data format, see Packing and Unpacking Data | |
buffer | a pointer to memory holding the packed data | |
size | the size of the buffer | |
[out] | psp | the new packing stream handle |
int wiredtiger_unpack_str | ( | WT_PACK_STREAM * | ps, |
const char ** | sp | ||
) |
Unpack a string from a packing stream.
ps | the packing stream handle | |
[out] | sp | the unpacked string |
int wiredtiger_unpack_uint | ( | WT_PACK_STREAM * | ps, |
uint64_t * | up | ||
) |
Unpack an unsigned integer from a packing stream.
ps | the packing stream handle | |
[out] | up | the unpacked unsigned integer |
const char* wiredtiger_version | ( | int * | majorp, |
int * | minorp, | ||
int * | patchp | ||
) |
Get version information.
majorp | a location where the major version number is returned |
minorp | a location where the minor version number is returned |
patchp | a location where the patch version number is returned |
uint32_t(*)(const void *, size_t) wiredtiger_crc32c_func(void) |
Return a pointer to a function that calculates a CRC32C checksum.
The WiredTiger library CRC32C checksum function uses hardware support where available, else it falls back to a software implementation. Selecting a CRC32C checksum function can be slow, so the return value should be cached by the caller for repeated use.
uint32_t(*)(uint32_t seed, const void *, size_t) wiredtiger_crc32c_with_seed_func(void) |
Return a pointer to a function that calculates a CRC32C checksum given a starting CRC seed.
The WiredTiger library CRC32C checksum function uses hardware support where available, else it falls back to a software implementation. Selecting a CRC32C checksum function can be slow, so the return value should be cached by the caller for repeated use. This version returns a function that accepts a starting seed value for the CRC. This version is useful where an application wants to calculate the CRC of a large buffer in smaller incremental pieces. The starting seed to calculate the CRC of a piece is then the cumulative CRC of all the previous pieces.