oxirs-tdb 0.4.1

//! # OxiRS TDB - Apache Jena TDB/TDB2 Compatible Storage Engine
//!
//! [![Version](https://img.shields.io/badge/version-0.4.1-blue)](https://github.com/cool-japan/oxirs/releases)
//!
//! **Status**: Production Release (v0.4.1)
//! **Stability**: Public APIs are stable. Production-ready with comprehensive testing.
//!
//! High-performance RDF triple store with B+Tree indexes, ACID transactions,
//! and Apache Jena TDB/TDB2 API compatibility.
//!
//! ## Features
//!
//! - **B+Tree Storage** - Efficient range queries and sequential scans
//! - **Triple Indexes** - SPO, POS, OSP for optimal query performance
//! - **ACID Transactions** - Write-Ahead Logging (WAL) with 2PL concurrency control
//! - **Dictionary Encoding** - Compress IRIs and literals to 8-byte NodeIDs
//! - **Buffer Pool** - LRU caching for hot pages
//! - **100M+ Triples** - Scalable to large datasets
//!
//! ## Quick Start
//!
//! ```rust,no_run
//! use oxirs_tdb::TdbStore;
//! # fn example() -> Result<(), Box<dyn std::error::Error>> {
//! // Create a new TDB store
//! let mut store = TdbStore::open("/path/to/data")?;
//!
//! // Insert triples
//! // store.insert(...)?;
//!
//! // Query triples
//! // let results = store.query(...)?;
//!
//! # Ok(())
//! # }
//! ```
//!
//! ## Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────┐
//! │         TdbStore (High-level API)       │
//! └─────────────────┬───────────────────────┘
//!                   │
//!       ┌───────────┴───────────┐
//!       │                       │
//! ┌─────▼─────┐         ┌──────▼──────┐
//! │  Indexes  │         │ Dictionary  │
//! │ SPO/POS/  │         │   Encoding  │
//! │    OSP    │         │             │
//! └─────┬─────┘         └──────┬──────┘
//!       │                      │
//!       └───────────┬──────────┘
//!                   │
//!            ┌──────▼──────┐
//!            │   B+Tree    │
//!            └──────┬──────┘
//!                   │
//!       ┌───────────┴───────────┐
//!       │                       │
//! ┌─────▼─────┐         ┌──────▼──────┐
//! │  Buffer   │         │     WAL     │
//! │   Pool    │         │  (Logging)  │
//! └─────┬─────┘         └──────┬──────┘
//!       │                      │
//!       └───────────┬──────────┘
//!                   │
//!            ┌──────▼──────┐
//!            │ File Manager│
//!            │   (mmap)    │
//!            └─────────────┘
//! ```
//!
//! ## See Also
//!
//! - [`oxirs-core`](https://docs.rs/oxirs-core) - RDF data model
//! - [`oxirs-arq`](https://docs.rs/oxirs-arq) - SPARQL query engine

#![doc(html_root_url = "https://docs.rs/oxirs-tdb/0.4.1")]
#![warn(missing_docs)]
// NOTE: The former crate-wide `#![allow(dead_code/unused_imports/unused_variables)]`
// has been removed so the hardened durability core (storage/superblock,
// storage/file_manager, storage/buffer_pool, btree, index/triple_index,
// dictionary, store/store_impl, loader/bulk_loader) compiles strictly. The
// allows are re-applied per-module below only to the modules NOT in that core
// (many owned by other agents or peripheral to this pass), where resolving the
// pre-existing dead code is out of scope for the durability work.

// Core modules
pub mod error;

// Storage layer (peripheral submodules scoped inside storage/mod.rs)
pub mod storage;

// B+Tree implementation
pub mod btree;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod btree_index;

// Index structures (peripheral submodules scoped inside index/mod.rs)
pub mod index;

// Dictionary encoding
pub mod dictionary;

// Transaction management
#[allow(dead_code, unused_imports, unused_variables)]
pub mod transaction;

// Consensus algorithms for distributed coordination
#[allow(dead_code, unused_imports, unused_variables)]
pub mod consensus;

// Distributed coordination and replication
#[allow(dead_code, unused_imports, unused_variables)]
pub mod distributed;

// Data loading utilities (peripheral submodules scoped inside loader/mod.rs)
pub mod loader;

// Compression and optimization
#[allow(dead_code, unused_imports, unused_variables)]
pub mod compression;

// High-level store API (peripheral submodules scoped inside store/mod.rs)
pub mod store;

// Production hardening features
#[allow(dead_code, unused_imports, unused_variables)]
pub mod production;

// Backup and restore utilities
#[allow(dead_code, unused_imports, unused_variables)]
pub mod backup;

// Backup encryption for data at rest
#[allow(dead_code, unused_imports, unused_variables)]
pub mod backup_encryption;

// Online backup without downtime
#[allow(dead_code, unused_imports, unused_variables)]
pub mod online_backup;

// Crash recovery and corruption detection
#[allow(dead_code, unused_imports, unused_variables)]
pub mod recovery;

// Query hint support
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_hints;

// Query result caching
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_cache;

// Cost-based query optimization with StatisticsSnapshot integration
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_optimizer;

// Join order optimization for query planning
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_join_optimizer;

// Adaptive query execution with runtime plan adjustment
#[allow(dead_code, unused_imports, unused_variables)]
pub mod adaptive_execution;

// Statistics collection for cost-based optimization
#[allow(dead_code, unused_imports, unused_variables)]
pub mod statistics;

// Slow query logging and analysis for production monitoring
#[allow(dead_code, unused_imports, unused_variables)]
pub mod slow_query_log;

// Query timeout enforcement for production safety
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_timeout;

// Query monitoring (timeout enforcement and slow query logging)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_monitor;

// Advanced diagnostic tools
#[allow(dead_code, unused_imports, unused_variables)]
pub mod diagnostics;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod diagnostics_collectors;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod diagnostics_tests;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod diagnostics_types;

// Advanced diagnostic tools (monitoring and analysis)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod advanced_diagnostics;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod advanced_diagnostics_engine;
#[cfg(test)]
#[allow(dead_code, unused_imports, unused_variables)]
mod advanced_diagnostics_tests;
#[allow(dead_code, unused_imports, unused_variables)]
pub mod advanced_diagnostics_types;

// High-performance operations using SciRS2-Core
#[allow(dead_code, unused_imports, unused_variables)]
pub mod performance;

// Bulk operations for high-throughput processing
#[allow(dead_code, unused_imports, unused_variables)]
pub mod bulk_operations;

// RDF-star support for quoted triples
#[allow(dead_code, unused_imports, unused_variables)]
pub mod rdf_star;

// Connection pooling for multi-client access
#[allow(dead_code, unused_imports, unused_variables)]
pub mod connection_pool;

// Connection pool optimizer (advanced pool management)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod connection_pool_optimizer;

// Query resource quotas for per-query resource limiting
#[allow(dead_code, unused_imports, unused_variables)]
pub mod query_resource_quota;

// Materialized views for query acceleration
#[allow(dead_code, unused_imports, unused_variables)]
pub mod materialized_views;

// WAL archiving for point-in-time recovery
#[allow(dead_code, unused_imports, unused_variables)]
pub mod wal_archive;

// WAL shipping for continuous archiving
#[allow(dead_code, unused_imports, unused_variables)]
pub mod wal_shipping;

// Cloud storage integration (S3, GCS, Azure)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod cloud_storage;

// Database operations and management
#[allow(dead_code, unused_imports, unused_variables)]
pub mod database_ops;

// Observability and monitoring
#[allow(dead_code, unused_imports, unused_variables)]
pub mod observability;

// Full-text search over RDF literals (Tantivy-backed).
// Gated behind the non-default `full-text-search` feature so the default build
// stays Pure Rust (Tantivy pulls C `zstd-sys`). See Cargo.toml.
#[cfg(feature = "full-text-search")]
#[allow(dead_code, unused_imports, unused_variables)]
pub mod text_search;

// Bloom filter for probabilistic triple existence checks
#[allow(dead_code, unused_imports, unused_variables)]
pub mod bloom_filter;

// Re-export commonly used types
pub use backup_encryption::{BackupEncryption, EncryptedData, EncryptionConfig};
pub use bulk_operations::{
    BulkStats, BulkTripleProcessor, ParallelPipelineBuilder, StreamingTripleIterator,
};
pub use compression::{
    DeltaStoreConfig, DeltaStoreStats, EncodedDeltaLog, TripleDelta, TripleDeltaStore,
};
pub use connection_pool::{ConnectionPool, ConnectionPoolConfig, ConnectionPoolStatsSnapshot};
pub use database_ops::{
    CompactionStats, DatabaseMetadata, DatabaseOps, DatabaseStatus, RepairReport,
};
pub use error::{Result, TdbError};
pub use index::{BTreeTripleIndex, EncodedTriple, TripleIndexSet, TripleOrdering};
pub use loader::{BulkLoadStats, BulkLoader, BulkLoaderConfig, BulkLoaderFactory};
pub use loader::{
    NodeDictionary, ParallelBulkLoadConfig, ParallelBulkLoadStats, ParallelBulkLoader, RawTriple,
    RdfNode, TripleSource, VecTripleSource,
};
pub use materialized_views::{
    MaterializedView, MaterializedViewConfig, MaterializedViewManager,
    MaterializedViewManagerStats, RefreshStrategy, ViewInfo,
};
pub use observability::{
    HealthCheck, HealthCheckResult, HealthCheckResults, HealthStatus, MetricSnapshot,
    ObservabilityConfig, ObservabilityManager, TraceSpan, TraceSpanId,
};
pub use online_backup::{
    OnlineBackupManager, OnlineBackupStats, Snapshot, SnapshotConfig, SnapshotId, SnapshotStatus,
};
pub use query_resource_quota::{
    QueryQuotaStats, QueryResourceQuotaConfig, QueryResourceQuotaManager, QueryResourceTracker,
    QueryResourceUsage,
};
pub use store::{
    CompressionAlgorithm, GraphName, GraphTarget, QuadResult, QuadTermIter, ReplicationMode,
    StoreParams, StoreParamsBuilder, StorePresets, TdbConfig, TdbStats, TdbStore, TripleTermIter,
};
pub use wal_archive::{
    WalArchiveConfig, WalArchiveMetadata, WalArchiver, WalArchiverStatsSnapshot,
};
pub use wal_shipping::{
    ShippingConfig, ShippingDestination, ShippingRecord, ShippingStats, ShippingStatus, WalShipper,
};

// Temporal RDF: version control and time-travel queries (v0.3.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod temporal;

pub use temporal::{
    ChangeEntry, ChangeLog, ChangeLogStats, ChangeOperation, TemporalDiff, TemporalSnapshot,
    TemporalVersionStore, TimeTravelQuery, TimeTravelQueryBuilder, TripleKey, TriplePattern,
    VersionedTriple,
};

/// TDB storage engine version
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

/// Default page size (4KB)
pub const DEFAULT_PAGE_SIZE: usize = 4096;

/// Default buffer pool size (1000 pages = 4MB)
pub const DEFAULT_BUFFER_POOL_SIZE: usize = 1000;

// MVCC Transaction Manager: snapshot isolation and SSI (v0.3.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod mvcc;

pub use mvcc::deadlock::{DeadlockDetector, DeadlockScanResult};
pub use mvcc::{
    IsolationLevel, MvccError, MvccManager, MvccStats, TransactionContext, TransactionState, TxId,
    VersionedEntry, VersionedKey, TX_ID_COMMITTED,
};

// Multi-tenant isolation (v1.0.0 LTS)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod tenant;

pub use tenant::{
    TenantAuditEvent, TenantAuditLog, TenantConfig, TenantError, TenantHandle, TenantId,
    TenantIsolationLayer, TenantRegistry, TenantResult, TenantStats, TenantStore,
};

// TDB2-compatible data format (v1.1.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod tdb2;

pub use tdb2::{NodeTable, RdfTerm, Tdb2Database, Tdb2Format, TripleIndex};

// Backup engine: triple-level backup/restore with format + compression (v0.2.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod backup_engine;

pub use backup_engine::{
    BackupCompression, BackupDelta, BackupEngine, BackupFormat, BackupManifest, IncrementalBackup,
};

// Advanced SLA monitoring and enforcement (v0.2.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod sla;

pub use sla::{SlaComplianceReport, SlaMonitor, SlaViolation, StorageSla, ViolationType};

// Dataset import/export formats: CSV-RDF, JSON-LD, N-Quads (v0.2.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod formats;

pub use formats::{CsvRdfMapper, JsonLdImporter, NQuadsExporter, NQuadsImporter, RdfColumnType};

// WAL compaction and point-in-time recovery (v1.1.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod wal_compaction;

// LSM-tree compaction strategy with bloom filters (v1.1.0)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod lsm_compaction;

// v1.2.0 Compressed prefix table for IRI storage
#[allow(dead_code, unused_imports, unused_variables)]
pub mod prefix_table;

// v1.2.0 Triple store cardinality estimator for query optimization
#[allow(dead_code, unused_imports, unused_variables)]
pub mod index_statistics;

// v1.5.0 Write-ahead journal for crash recovery
#[allow(dead_code, unused_imports, unused_variables)]
pub mod journal;

/// Write buffer for batching triple insertions (v1.6.0).
#[allow(dead_code, unused_imports, unused_variables)]
pub mod triple_buffer;

/// Background compaction task scheduler (v1.7.0).
#[allow(dead_code, unused_imports, unused_variables)]
pub mod compaction_scheduler;

/// Atomic batch write operations with WAL integration (v1.8.0).
#[allow(dead_code, unused_imports, unused_variables)]
pub mod write_batch;

/// Database checkpoint management for crash recovery and WAL truncation (v1.9.0).
#[allow(dead_code, unused_imports, unused_variables)]
pub mod checkpoint_manager;

/// Database vacuuming and compaction: dead-space detection, fragmentation analysis, online vacuum (v2.0.0).
#[allow(dead_code, unused_imports, unused_variables)]
pub mod vacuum;

/// B-tree index rebuild from raw triple data: SPO/POS/OSP/GSPO/GPOS/GOSP orders,
/// sorted IndexEntry generation, rebuild statistics, and sortedness verification (v1.1.0 round 14)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod index_rebuilder;

/// Triple pattern cache: memoize repeated pattern lookups using LRU eviction (v1.1.0 round 15)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod triple_cache;

/// Bloom filter index for fast triple existence checks: FNV double-hashing,
/// capacity-tuned bit array, TripleBloomIndex wrapper (v1.1.0 round 16)
#[allow(dead_code, unused_imports, unused_variables)]
pub mod bloom_index;

/// Six-index triple store (SPO/POS/OSP and derived patterns) for O(log n)
/// pattern matching — used in TDB2 parity verification.
#[allow(dead_code, unused_imports, unused_variables)]
pub mod six_index_store;

pub use wal_compaction::{
    BaseSnapshot, CompactionConfig, CompactionStats as WalCompactionStats, PitrConfig, PitrEngine,
    RecoveryPlan, WalCompactor, WalRecord, WalRecordType, WalSegment,
};