Snapshot Manager

This section documents the snapshot management classes that provide database snapshot capabilities.

SnapshotManager

class matrixone.snapshot.SnapshotManager(client, executor=None)

Bases: BaseSnapshotManager

Synchronous snapshot management for MatrixOne database operations.

This class provides comprehensive snapshot functionality for creating, managing, and restoring database snapshots at various levels (database, table, or cluster). Snapshots enable point-in-time recovery and data protection capabilities.

Key Features:

• Multi-level snapshots: Create snapshots at CLUSTER, ACCOUNT, DATABASE, or TABLE level

• Snapshot lifecycle management: Create, list, get, delete, and check existence of snapshots

• Transaction-aware operations: Use via executor pattern for both client and session contexts

• Unified interface: Same API works in both client and session contexts

• Point-in-time recovery: Restore databases/tables to specific snapshot states

Executor Pattern:

• If executor is None, uses self.client.execute (default client-level executor)

• If executor is provided (e.g., session), uses executor.execute (transaction-aware)

• This allows the same logic to work in both client and session contexts

• All operations can participate in transactions when used via session

Usage Examples:

from matrixone import Client, SnapshotLevel

client = Client(host='localhost', port=6001, user='root', password='111', database='test')

# Create database-level snapshot
snapshot = client.snapshots.create(
    name='daily_backup',
    level=SnapshotLevel.DATABASE,
    database='my_database'
)
print(f"Snapshot created: {snapshot.name} at {snapshot.created_at}")

# Create table-level snapshot
table_snapshot = client.snapshots.create(
    name='table_backup',
    level=SnapshotLevel.TABLE,
    database='my_database',
    table='users'
)

# List all snapshots
all_snapshots = client.snapshots.list()
for snap in all_snapshots:
    print(f"{snap.name}: {snap.level} - {snap.created_at}")

# Get specific snapshot
snapshot = client.snapshots.get('daily_backup')
print(f"Snapshot level: {snapshot.level}")

# Check if snapshot exists
if client.snapshots.exists('daily_backup'):
    print("Snapshot exists!")

# Delete snapshot
client.snapshots.delete('daily_backup')

# Using within a transaction (all operations are atomic)
with client.session() as session:
    # Create multiple snapshots in a transaction
    session.snapshots.create(
        name='backup_1',
        level=SnapshotLevel.DATABASE,
        database='db1'
    )
    session.snapshots.create(
        name='backup_2',
        level=SnapshotLevel.DATABASE,
        database='db2'
    )
    # Both snapshots created atomically when transaction commits

Version Requirements:

Snapshot functionality requires MatrixOne version 1.0.0 or higher. Earlier versions do not support snapshot operations.

See also

• RestoreManager: For restoring databases from snapshots

• CloneManager: For cloning databases using snapshots

• PitrManager: For point-in-time recovery operations

create(name: str, level: str | SnapshotLevel, database: str | None = None, table: str | None = None, description: str | None = None) → Snapshot

Create a snapshot.

Parameters:

• name – Snapshot name

• level – Snapshot level (SnapshotLevel enum or string)

• database – Database name (for database/table level)

• table – Table name (for table level)

• description – Snapshot description (not currently used by MatrixOne)

Returns:

Snapshot object

list() → List[Snapshot]

List all snapshots.

Returns:

List of Snapshot objects

get(name: str) → Snapshot

Get snapshot by name.

Parameters:

name – Snapshot name

Returns:

Snapshot object

delete(name: str) → None

Delete snapshot.

Parameters:

name – Snapshot name

exists(name: str) → bool

Check if snapshot exists.

Parameters:

name – Snapshot name

Returns:

True if snapshot exists, False otherwise

Snapshot

class matrixone.snapshot.Snapshot(name: str, level: str | SnapshotLevel, created_at: datetime, description: str | None = None, database: str | None = None, table: str | None = None)

Bases: object

Snapshot information object representing a MatrixOne database snapshot.

This class encapsulates metadata about a database snapshot including its name, level, creation time, and associated database/table information.

Attributes:

name (str): Snapshot name (unique identifier)
level (SnapshotLevel): Snapshot level (CLUSTER, ACCOUNT, DATABASE, or TABLE)
created_at (datetime): Snapshot creation timestamp
description (Optional[str]): Optional description/comment
database (Optional[str]): Database name (for DATABASE/TABLE level snapshots)
table (Optional[str]): Table name (for TABLE level snapshots)

Examples:

>>> snapshot = Snapshot(
...     name='daily_backup',
...     level=SnapshotLevel.DATABASE,
...     created_at=datetime.now(),
...     database='my_database'
... )
>>> print(snapshot.name)
'daily_backup'
>>> print(snapshot.level)
SnapshotLevel.DATABASE

__init__(name: str, level: str | SnapshotLevel, created_at: datetime, description: str | None = None, database: str | None = None, table: str | None = None)

SnapshotLevel

class matrixone.snapshot.SnapshotLevel(value)

Bases: Enum

Snapshot level enumeration for specifying snapshot granularity.

MatrixOne supports four levels of snapshots: - CLUSTER: Entire cluster snapshot (all databases and tables) - ACCOUNT: Account-level snapshot (all databases in an account) - DATABASE: Database-level snapshot (specific database) - TABLE: Table-level snapshot (specific table in a database)

CLUSTER = 'cluster'

ACCOUNT = 'account'

DATABASE = 'database'

TABLE = 'table'