aletheiadb 0.1.0

A high-performance bi-temporal graph database for LLM integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Sharding support for horizontal scalability.
//!
//! This module implements graph sharding for distributing data across multiple machines
//! when the dataset exceeds single-machine capacity. It uses domain-based partitioning
//! with edge replication as described in ADR-0014.
//!
//! # Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────────┐
//! │                      Shard Coordinator                           │
//! │   • Query routing         • Transaction coordination             │
//! │   • Shard discovery       • Rebalancing orchestration           │
//! └─────────────────────────────────────────────────────────────────┘
//!               │                    │                    │
//!               ▼                    ▼                    ▼
//!      ┌─────────────┐      ┌─────────────┐      ┌─────────────┐
//!      │   Shard 0   │      │   Shard 1   │      │   Shard 2   │
//!      │   People    │◄────►│   Places    │◄────►│   Events    │
//!      └─────────────┘      └─────────────┘      └─────────────┘
//! ```
//!
//! # Key Components
//!
//! - [`ShardId`]: Strongly-typed shard identifier
//! - [`ShardConfig`]: Configuration for shard topology
//! - [`ShardRouter`]: Routes queries to appropriate shards
//! - [`ShardCoordinator`]: Coordinates distributed operations
//! - [`DistributedTransaction`]: Two-phase commit for cross-shard writes
//! - [`RebalanceManager`]: Handles shard rebalancing
//!
//! # Example
//!
//! ```rust,no_run
//! use aletheiadb::storage::sharding::{ShardConfig, ShardCoordinator, ShardDefinition};
//!
//! # fn main() {
//! let config = ShardConfig::new(vec![
//!     ShardDefinition::new(0, "shard0:9000", vec!["Person", "User"]),
//!     ShardDefinition::new(1, "shard1:9000", vec!["Place", "Location"]),
//! ]);
//!
//! let coordinator = ShardCoordinator::new(config);
//! # }
//! ```

pub mod config;
pub mod coordinator;
pub mod executor;
pub mod migration;
pub mod network;
pub mod persistent_commit_log;
pub mod rebalance;
pub mod router;
pub mod rpc_client;
pub mod simulation;
pub mod transaction;
pub mod types;

// Re-export commonly used types
pub use config::{RebalanceConfig, ShardConfig, ShardDefinition, ShardDiscovery};
pub use coordinator::{DeadLetteredTransaction, RecoveryResult, ShardConnection, ShardCoordinator};
pub use executor::{
    AggregationStrategy, DistributedQuery, ExecutorConfig, ExecutorError, ExecutorResult,
    ExecutorStats, QueryExecutor, QueryResult, ShardResult,
};
pub use migration::{
    DualWriteRouter, MigrationConfig, MigrationError, MigrationExecutor, MigrationResult,
    MigrationStats, RoutingToken,
};
pub use network::{
    CircuitBreaker, CircuitBreakerConfig, CircuitState, ConnectionPool, MigrationBatch,
    MigrationResponse, MockShardClient, NetworkError, NetworkResult, PoolConfig, PoolStats,
    ShardClient,
};
pub use persistent_commit_log::{
    CommitLogConfig, CommitLogEntry, CommitLogError, CommitLogResult, CommitLogStats, EntryType,
    PersistentCommitLog,
};
pub use rebalance::{MigrationPlan, MigrationProgress, MigrationState, RebalanceManager};
pub use router::{ShardRouter, TraversalPlan, TraversalStep};
pub use rpc_client::{ClientStats, HttpShardClient, RpcConfig};
pub use simulation::{EdgeCutAnalysis, ShardingSimulation, SimulationResult};
#[allow(deprecated)]
pub use transaction::TwoPhaseCommitLog;
pub use transaction::{DistributedTransaction, ParticipantState, TransactionPhase};
pub use types::{RemoteEdgeRef, RemoteNodeRef, ShardId, ShardMetrics, ShardState, ShardStatus};