reinhardt-db 0.1.2

Django-style database layer for Reinhardt framework
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Association proxies for Reinhardt
//!
//! This crate provides SQLAlchemy-style association proxies for simplifying
//! access to related objects through associations.
//!
//! # Features
//!
//! ## Relationship Types
//!
//! - **ForeignKey**: One-to-many and many-to-one relationships
//! - **OneToOne**: Unique one-to-one relationships
//! - **OneToMany**: Reverse side of ForeignKey relationships
//! - **ManyToMany**: Many-to-many relationships through junction tables
//! - **PolymorphicAssociation**: Polymorphic one-to-many relationships
//! - **PolymorphicManyToMany**: Polymorphic many-to-many relationships
//!
//! ## Automatic Reverse Relationship Accessors
//!
//! All relationship types support automatic generation of reverse accessor names
//! when `related_name` is not explicitly provided:
//!
//! ```
//! use reinhardt_db::associations::{ForeignKey, ReverseRelationship};
//!
//! #[derive(Clone)]
//! struct User {
//!     id: i64,
//! }
//!
//! let fk: ForeignKey<User, i64> = ForeignKey::new("author_id");
//! // Automatically generates "post_set" as the reverse accessor
//! assert_eq!(fk.get_or_generate_reverse_name("Post"), "post_set");
//! ```
//!
//! ## Polymorphic Associations
//!
//! Support for polymorphic associations allows a model to belong to multiple
//! different model types through a single association:
//!
//! ```
//! use reinhardt_db::associations::PolymorphicAssociation;
//!
//! #[derive(Clone)]
//! struct Comment {
//!     id: i64,
//!     commentable_id: i64,
//!     commentable_type: String,
//! }
//!
//! // A comment can belong to either a Post or a Video
//! let rel: PolymorphicAssociation<i64> = PolymorphicAssociation::new("commentable");
//! ```
//!
//! ## Loading Strategies
//!
//! Multiple loading strategies are available to optimize database queries:
//!
//! - **Lazy**: Load related objects only when accessed
//! - **Eager**: Load related objects immediately with the parent
//! - **SelectIn**: Use SELECT IN strategy for multiple objects
//! - **Joined**: Use SQL JOIN for single query loading
//! - **Subquery**: Use subquery for complex filtering

pub mod collection;
pub mod foreign_key;
pub mod loading;
pub mod many_to_many;
pub mod many_to_many_manager;
pub mod markers;
pub mod one_to_many;
pub mod one_to_one;
pub mod polymorphic;
pub mod proxy;
pub mod reverse;

pub use collection::AssociationCollection;
pub use foreign_key::{CascadeAction, ForeignKey};
pub use loading::{EagerLoader, JoinedLoader, LazyLoader, LoadingStrategy, SelectInLoader};
pub use many_to_many::ManyToMany;
pub use many_to_many_manager::ManyToManyManager;
pub use markers::{
	ForeignKeyField, ManyToManyField, OneToManyField, OneToOneField, PolymorphicManyToManyField,
};
pub use one_to_many::OneToMany;
pub use one_to_one::OneToOne;
pub use polymorphic::{PolymorphicAssociation, PolymorphicManyToMany};
pub use proxy::AssociationProxy;
pub use reverse::{
	ReverseRelationship, generate_reverse_accessor, generate_reverse_accessor_singular,
	to_snake_case,
};

/// Re-export commonly used types
pub mod prelude {
	pub use super::collection::*;
	pub use super::foreign_key::*;
	pub use super::loading::*;
	pub use super::many_to_many::*;
	pub use super::many_to_many_manager::*;
	pub use super::markers::*;
	pub use super::one_to_many::*;
	pub use super::one_to_one::*;
	pub use super::polymorphic::*;
	pub use super::proxy::*;
	pub use super::reverse::*;
}