M_* Dynamic Tables & Views Catalog

The foundational memory accounting view in SAP HANA. It exposes process-level resident physical RAM, internal pool-allocated memory, code/stack overhead, and the dynamic Effective Allocation Limit (Global Allocation Limit).

Used by DBAs as the primary health check to monitor memory headroom, prevent Out-of-Memory (OOM) fatal crashes, track tenant-level memory quotas, and verify whether the indexserver is approaching the 90% allocation watermark.

Exposes fine-grained internal memory consumption broken down by individual C++ heap allocators (over 200 distinct allocator classes inside the engine).

Forensic root cause analysis when M_SERVICE_MEMORY reports high used memory. Identifies whether memory is consumed by column store tables, statement execution, plan cache, persistence page buffers, or internal memory leaks.

Dynamic monitoring view detailing memory consumption and load states for all Column Store tables and partitioned fragments resident in RAM.

Identifying the largest memory-consuming application tables (e.g. ACDOCA, BSEG, MATDOC, EDI40), assessing partially loaded states, tracking table read counts, and calculating data compression savings.

Exposes column-level memory consumption, detailing distinct value dictionaries, compressed bit-packed vectors, and inverted search index footprints.

Diagnosing individual columns consuming disproportionate RAM within huge tables. Helps DBAs evaluate whether custom secondary indexes or high-cardinality text columns should be dropped or archived.

Comprehensive view encompassing all column partitions, main store parts, and write-optimized delta store fragments.

Detailed partition-by-partition analysis of multi-terabyte tables. Used to detect partition skew and uncompressed delta fragments.

Live monitoring view for Row Store tables. Tracks row count, allocated shared memory pages, and row store fragmentation.

Monitoring row store tables (system catalogs, configuration tables, locking queues). Critical for detecting row store fragmentation and planning offline or online row store reorganizations.

Maps application tables to their physical storage footprint in persistence files on disk (/hana/data).

Comparing table RAM footprint against disk persistence size, estimating data volume growth, and monitoring delta log volume on disk.

Tracks inter-process shared memory allocations (POSIX / System V shared memory segments) managed across HANA daemon processes.

Ensuring shared memory segments are cleaned up during service restarts and diagnosing fast restart option (tmpfs) memory allocations.

Real-time view of every internal C++ execution thread running in the database process hierarchy.

Triage for CPU spikes, thread pool exhaustion, thread hangs, and lock contention. Exposes the exact C++ method call stacks for threads in wait states.

Real-time monitor of all SQL statements and calculation views currently being executed by the engine.

Immediate live troubleshooting during system slowdowns. Shows SQL text, execution duration, CPU consumption, thread count, and connection ID for queries active right now.

Historical flight-recorder view capturing completed statements that exceeded configured runtime or memory thresholds in global.ini.

Post-mortem performance optimization, identification of poorly written ABAP custom reports, finding queries lacking indexes, and auditing heavy ad-hoc SQL.

In-memory cache of compiled SQL execution plans, abstract syntax trees, and cost optimizer costings.

Analyzing query plan reusability, identifying high compilation overhead, detecting SQL plan cache evictions, and diagnosing plan regressions using plan IDs.

Defines and monitors active Workload Management classes, thread limits, memory caps, and query timeouts.

Preventing analytics, reporting users, or data lake queries from starving OLTP business transactions of CPU and RAM.

Aggregated process statistics reporting real-time CPU utilization, open client connections, and heap allocations.

Top-level host capacity verification. Quick check to determine if the server is CPU bound or I/O bound.

Lock dependency view capturing lock wait chains. Shows the root transaction holding a conflicting lock and all transactions blocked waiting for it.

Critical triage during application lockups, batch job hangs, and SAP update work process freezes (SM12/SM50). Identifies the root blocking transaction ID and lock wait duration.

Exposes the complete transaction table managed by the Transaction Manager in the indexserver.

Tracking active transaction states (Active, Inactive, Committed, Rolled back), identifying write transactions, and finding idle sessions holding open locks.

Detailed low-level view of individual record/row-level locks currently acquired in memory.

Forensic lock analysis to identify specific locked primary keys and rows causing concurrency bottlenecks in high-volume tables (e.g. number range tables).

Exposes metadata and table-level object locks acquired during DDL, migrations, or backup executions.

Diagnosing DDL locks (e.g. `ALTER TABLE`, `CREATE INDEX`, `TRUNCATE`) that block concurrent DML business operations.

Exposes active Multi-Version Concurrency Control (MVCC) read transaction snapshots.

Diagnosing snapshot retention. Old open read snapshots prevent the database from freeing historical row versions, leading to memory bloat.

Monitors open transaction redo log records currently buffered in the logger pipeline before being committed.

Estimating rollback time for long-running batch transactions and checking uncommitted log volume.

Exposes the active status and internal phase of the current periodic Savepoint cycle.

Diagnosing savepoint blocking stalls. Monitors the critical phase where transaction commits are momentarily paused while the restart record is updated.

Historical statistical view capturing metrics across thousands of completed savepoints.

Analyzing storage write health over time, verifying savepoint interval compliance (default 300 seconds), and tuning `savepoint_interval_s`.

Monitors internal in-memory redo log buffers before synchronous flushing to `/hana/log`.

Diagnosing log write latency and commit stalls. Detects when transactions are blocked because all in-memory log buffers are full.

Lists physical redo log segments on `/hana/log`, their size (default 512 MB), and backup status.

Diagnosing `/hana/log` filesystem 100% full incidents. Shows whether segments are stuck in "Writing", "Closed", or "Retained" states.

Inspects internal data volume files (`datavolume0000.dat`) located in `/hana/data`.

Monitoring internal fragmentation and payload allocation within the data volumes. Used to decide when to run data volume defragmentation.

Complete historical catalog of all data backups (complete, differential, incremental) and automatic log backups.

Essential daily health check. Verifies backup completion, checks backup start and completion timestamps, and validates disaster recovery readiness.

Lists physical files, pipe paths, and byte sizes associated with each backup catalog entry.

Verifying physical backup archive files on NFS / Backint destinations and estimating backup throughput in MB/s.

Live filesystem I/O metrics broken down by data volumes, log volumes, and trace volumes.

Diagnosing storage latency bottlenecks. Measures read/write throughput (MB/s), total I/O operations count, and average service latency in milliseconds.

Service-level view of SAP HANA System Replication (HSR) sync states between primary and secondary nodes.

Validating that nameserver, indexserver, and other services are replicating redo logs without backlog or network errors.

Landscape-level HSR configuration view detailing replication modes, operation modes, and secondary tiers.

Verifying HSR replication mode (SYNC, SYNCMEM, ASYNC) and operation mode (logreplay, logreplay_readaccess, delta_datashipping).

Audit log capturing all historical failovers, takeovers, and failbacks executed across the replication topology.

Auditing DR drills, validating automated cluster failovers (Pacemaker/SUSE HAE), and determining exact takeover timestamps.

Comprehensive history of all Delta Merge operations executed against Column Store tables.

Troubleshooting long merge runtimes, CPU spikes caused by auto-merges, merge errors, and memory surges during delta consolidation.

Granular breakdown of Column Store merge execution phases (Phase 1 dictionary merge vs Phase 2 column copy).

Fine-tuning engine merge parameters. Pinpoints whether merge bottlenecks occur in dictionary calculation or data vector copying.

Exposes the status and queue depths of the engine background Job Worker thread pool.

Checking asynchronous background worker capacity for background compression, statistics updates, and savepoints.

Live view of all open network connections from application servers, clients, and DBA tools.

Investigating connection leaks, identifying which SAP application server or batch user is issuing requests, and finding idle connections.

Exposes session-level variables and application context attached to client connections.

Connecting a raw HANA connection ID back to specific ABAP business transactions (TCODE, ABAP report name, SAP user).

Lists versions and patch levels of all connecting client libraries and drivers.

Auditing client connectivity. Identifies outdated ODBC, JDBC, or Python hdbcli drivers that have known bugs or security flaws.

Monitors internal secure storage state, master encryption keys, and keystore status.

Validating data volume and log volume encryption key states and secure internal credentials.

The definitive process registry listing all daemon-supervised services across the entire SAP HANA landscape.

Verifying service health, locating process IDs (PIDs) on Linux, checking assigned SQL and internal communication ports, and validating startup progression.

Lists all database containers in an MDC environment along with their status and isolation mode.

Tenant database lifecycle management. Checking whether tenants are active, inspecting restart modes, and verifying tenant container status.

Hardware and operating system inventory exposed directly through SQL catalog queries.

Checking total physical RAM, CPU socket and core counts, OS distribution release, and Linux kernel version without logging into bash.

Single-row high-level dashboard summary providing a snapshot of overall database health.

First stop during morning operational checks. Reports database version, compile date, license state, memory usage, CPU usage, and active alerts.

Live queryable view of all configuration parameters across all layers (DEFAULT, SYSTEM, HOST, DATABASE).

Auditing configuration parameters without needing filesystem access to `.ini` files. Resolves parameter values and identifies overrides.

Engine alerts and events log capturing critical system issues such as disk-full warnings and license expirations.

Early warning detection of infrastructure failures before they trigger catastrophic database outages.

Multi-node scale-out topology monitor tracking worker nodes, standby nodes, and failover groups.

Scale-out cluster administration. Verifies host roles (worker, standby), storage partitioning, and automatic host failover status.

Directory listing of all diagnostic trace files (`alert_<SID>.trc`, `nameserver_*.trc`, `indexserver_*.trc`) on `/hana/shared`.

Identifying which trace files are growing rapidly, locating crash dumps, and inspecting trace file sizes and timestamps without SSH.

Catalog of emergency diagnostic crash dumps, OOM trace dumps, and runtime dumps (RTE dumps).

Root cause analysis for service crashes and OOM events. Identifies crash timestamp, culprit thread, and dump file name.

Exposes filesystem mount point statistics, available capacity, and usage percentages for `/hana/data`, `/hana/log`, and `/hana/shared`.

Preventing filesystem 100% full stalls. Alerts DBAs when data or log storage approaches disk capacity thresholds.