Skip to main content

grafeo_core/execution/
mod.rs

1//! Vectorized query execution engine.
2//!
3//! Grafeo uses vectorized processing - instead of one row at a time, we process
4//! batches of ~1024 rows. This unlocks SIMD and keeps the CPU busy.
5//!
6//! | Module | Purpose |
7//! | ------ | ------- |
8//! | [`chunk`] | Batched rows (DataChunk = multiple columns) |
9//! | [`vector`] | Single column of values |
10//! | [`factorized_vector`] | Factorized vectors for avoiding Cartesian products |
11//! | [`factorized_chunk`] | Multi-level factorized chunks |
12//! | [`selection`] | Bitmap for filtering without copying |
13//! | [`operators`] | Physical operators (scan, filter, join, etc.) |
14//! | [`pipeline`] | Push-based execution (data flows through operators) |
15//! | [`parallel`] | Morsel-driven parallelism |
16//! | [`spill`] | Disk spilling when memory is tight |
17//! | [`adaptive`] | Adaptive execution with runtime cardinality feedback |
18//! | [`collector`] | Generic collector pattern for parallel aggregation |
19//!
20//! The execution model is push-based: sources push data through a pipeline of
21//! operators until it reaches a sink.
22
23pub mod adaptive;
24pub mod chunk;
25pub mod chunk_state;
26pub mod collector;
27pub mod factorized_chunk;
28pub mod factorized_iter;
29pub mod factorized_vector;
30pub mod memory;
31pub mod operators;
32#[cfg(feature = "parallel")]
33pub mod parallel;
34pub mod pipeline;
35pub mod pipeline_convert;
36pub mod profile;
37pub mod selection;
38pub mod sink;
39pub mod source;
40#[cfg(feature = "spill")]
41pub mod spill;
42pub mod vector;
43
44pub use adaptive::{
45    AdaptiveCheckpoint, AdaptiveContext, AdaptiveEvent, AdaptiveExecutionConfig,
46    AdaptiveExecutionResult, AdaptivePipelineBuilder, AdaptivePipelineConfig,
47    AdaptivePipelineExecutor, AdaptiveSummary, CardinalityCheckpoint, CardinalityFeedback,
48    CardinalityTrackingOperator, CardinalityTrackingSink, CardinalityTrackingWrapper,
49    ReoptimizationDecision, SharedAdaptiveContext, evaluate_reoptimization, execute_adaptive,
50};
51pub use chunk::{ChunkZoneHints, DataChunk};
52pub use collector::{
53    Collector, CollectorStats, CountCollector, LimitCollector, MaterializeCollector,
54    PartitionCollector, StatsCollector,
55};
56#[cfg(feature = "spill")]
57pub use memory::OperatorMemoryContext;
58pub use memory::{ExecutionMemoryContext, ExecutionMemoryContextBuilder};
59#[cfg(feature = "parallel")]
60pub use parallel::{
61    CloneableOperatorFactory, MorselScheduler, ParallelPipeline, ParallelPipelineConfig,
62    ParallelSource, RangeSource,
63};
64pub use pipeline::{ChunkCollector, ChunkSizeHint, Pipeline, PushOperator, Sink, Source};
65pub use profile::{ProfileStats, ProfiledOperator, SharedProfileStats};
66pub use selection::SelectionVector;
67pub use sink::{CollectorSink, CountingSink, LimitingSink, MaterializingSink, NullSink};
68pub use source::{ChunkSource, EmptySource, GeneratorSource, OperatorSource, VectorSource};
69#[cfg(feature = "spill")]
70pub use spill::{SpillFile, SpillFileReader, SpillManager};
71pub use vector::ValueVector;
72
73// Factorized execution types
74pub use chunk_state::{ChunkState, FactorizationState, FactorizedSelection, LevelSelection};
75pub use factorized_chunk::{ChunkVariant, FactorizationLevel, FactorizedChunk};
76pub use factorized_iter::{PrecomputedIter, RowIndices, RowView, StreamingIter};
77pub use factorized_vector::{FactorizedState, FactorizedVector, UnflatMetadata};
78pub use operators::{FactorizedData, FlatDataWrapper};