reddb-io-server 1.24.10

RedDB server-side engine: storage, runtime, replication, MCP, AI, and the gRPC/HTTP/RedWire/PG-wire dispatchers. Re-exported by the umbrella `reddb` crate.
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
107
108
109
110
111
112
113
114
115
116

//! Query Engine for RedDB
//!
//! Provides query execution, filtering, sorting, and similarity search
//! capabilities for the RedDB storage engine.
//!
//! # Components
//!
//! - **filter**: Filter predicates (Eq, Lt, Gt, Between, Like, etc.)
//! - **sort**: Sorting and ordering operations
//! - **executor**: Query plan execution
//! - **similarity**: Vector similarity search integration
//! - **modes**: Multi-mode query parsing (SQL, Gremlin, Cypher, SPARQL, Natural Language)
//!
//! # Multi-Mode Parsing
//!
//! The query engine supports multiple query languages with automatic mode detection:
//!
//! ```ignore
//! use reddb_rql::modes::{parse_multi, detect_mode, QueryMode};
//!
//! // Gremlin
//! let gremlin = parse_multi("g.V().hasLabel('host').out('connects')").unwrap();
//!
//! // SPARQL
//! let sparql = parse_multi("SELECT ?host WHERE { ?host :hasIP ?ip }").unwrap();
//!
//! // Natural language
//! let natural = parse_multi("find all hosts with ssh open").unwrap();
//! ```
//!
//! # Example
//!
//! ```ignore
//! use reddb::storage::query::{Query, Filter, OrderBy, Direction};
//!
//! let query = Query::select("users")
//!     .filter(Filter::eq("status", "active"))
//!     .filter(Filter::gt("age", 18))
//!     .order_by("created_at", Direction::Desc)
//!     .limit(10);
//!
//! let results = executor.execute(&query)?;
//! ```

pub mod analyze_cmd;
pub mod batch;
pub mod binary;
pub mod engine;
pub mod evaluator;
pub mod executor;
pub mod executors;
pub mod filter;
pub mod filter_compiled;
pub mod planner;
pub mod rag;
pub mod similarity;
pub mod sort;
pub mod step;
#[cfg(test)]
pub(crate) mod test_support;
pub mod unified;
pub mod user_params;
pub(crate) mod value_compare;

// Re-export common types
pub use engine::{
    Binding, BindingBuilder, BindingIterator, Op, OpBGP, OpDisjunction, OpDistinct, OpExtend,
    OpFilter, OpGroup, OpJoin, OpLeftJoin, OpMinus, OpNull, OpOrder, OpProject, OpReduced,
    OpSequence, OpSlice, OpTable, OpTransform, OpTriple, OpUnion, OpVisitor, Pattern, QueryEngine,
    QueryEngineFactory, QueryEngineRegistry, QueryIter, QueryIterBase, QueryIterFilter,
    QueryIterJoin, QueryIterProject, QueryIterSlice, QueryIterSort, QueryIterUnion, TransformCopy,
    TransformPushFilter, Triple, Var,
};
pub use executor::{QueryExecutor, QueryPlan, QueryResult};
pub use executors::{
    CteContext, CteExecutor, CteStats, ExecuteResult, GremlinExecutor, MultiModeExecutor,
    NaturalExecutor, SparqlExecutor,
};
pub use filter::{Filter, FilterOp, Predicate};
pub use planner::{
    CacheStats, CachedPlan, CardinalityEstimate, CostEstimator, PlanCache, PlanCost,
    QueryPlan as PlannerQueryPlan, QueryPlanner,
};
pub use rag::{
    ChunkSource, ContextChunk, EntityType, MultiSourceRetriever, QueryAnalysis, QueryIntent,
    RagConfig, RagEngine, RetrievalContext, RetrievalStrategy, SimilarEntity,
};
pub use reddb_types::{SqlTypeName, TypeModifier};
pub use similarity::{SimilarityQuery, SimilarityResult};
pub use sort::{Direction, NullsOrder, OrderBy, QueryLimits, SortKey};
pub use step::{
    AggregateStep, BarrierStep, BasicTraversal, BranchStep, ChooseStep, CollectingBarrierStep,
    DedupStep, Direction as TraversalDirection, EdgeSourceStep, EdgeStep, ExecutionMode,
    FilterStep, FlatMapStep, FoldStep, GroupStep, HasStep, IdStep, LimitStep, LoopState, MapStep,
    OptionalStep, OrderStep, Path, PathStep, Predicate as StepPredicate, ProjectStep, PropertyStep,
    RangeStep, ReducingBarrierStep, RepeatStep, SelectStep, SideEffectStep, SourceStep, Step,
    StepPosition, StepResult, StoreStep, Traversal, TraversalParent, Traverser, TraverserGenerator,
    TraverserRequirement, TraverserValue, UnionStep, ValueMapStep, VertexSourceStep, VertexStep,
    WhereStep,
};
pub use unified::{
    ExecutionError, GraphPath, MatchedEdge, MatchedNode, QueryStats, UnifiedExecutor,
    UnifiedRecord, UnifiedResult,
};

/// Returns true when the table source should be interpreted as the universal entity
/// space (table, document, graph, vector mixed mode).
pub fn is_universal_entity_source(table: &str) -> bool {
    table.eq_ignore_ascii_case("any")
        || table.eq_ignore_ascii_case("_any")
        || table.eq_ignore_ascii_case("all")
        || table.eq_ignore_ascii_case("entity")
        || table.eq_ignore_ascii_case("universal")
        || table.eq_ignore_ascii_case("mixed")
        || table == "*"
}