Struct StreamJoinRange 

pub struct StreamJoinRange<I1, I2, O>
where
    I1: IndexedZSetReader,
    I2: IndexedZSetReader,
    O: IndexedZSet,
{ /* private fields */ }

Implementations

impl<I1, I2, O> StreamJoinRange<I1, I2, O>

where I1: IndexedZSetReader, I2: IndexedZSetReader, O: IndexedZSet,

pub fn new( factories: &StreamJoinRangeFactories<I2, O>, range_func: Box<dyn Fn(&I1::Key, &mut I2::Key, &mut I2::Key)>, join_func: Box<dyn Fn(&I1::Key, &I1::Val, &I2::Key, &I2::Val, &mut dyn FnMut(&mut O::Key, &mut O::Val))>, ) -> Self

Trait Implementations

impl<I1, I2, O> BinaryOperator<I1, I2, O> for StreamJoinRange<I1, I2, O>

where I1: IndexedZSetReader + Clone, I2: IndexedZSetReader + Clone, O: IndexedZSet,

async fn eval(&mut self, i1: &I1, i2: &I2) -> O

Consume input by reference.

async fn eval_owned(&mut self, lhs: I1, rhs: I2) -> O

Consume input by value.

async fn eval_owned_and_ref(&mut self, lhs: I1, rhs: &I2) -> O

Consume the first input by value and the second by reference.

async fn eval_ref_and_owned(&mut self, lhs: &I1, rhs: I2) -> O

Consume the first input by reference and the second by value.

fn input_preference(&self) -> (OwnershipPreference, OwnershipPreference)

Ownership preference on the operator’s input streams (see OwnershipPreference).

impl<I1, I2, O> Operator for StreamJoinRange<I1, I2, O>

where I1: IndexedZSetReader, I2: IndexedZSetReader, O: IndexedZSet,

fn name(&self) -> Cow<'static, str>

Human-readable operator name for debugging purposes.

fn fixedpoint(&self, _scope: Scope) -> bool

Check if the operator is in a stable state.

fn location(&self) -> OperatorLocation

The location the operator was created at

fn init(&mut self, _global_id: &GlobalNodeId)

Initialize the operator

fn metadata(&self, _meta: &mut OperatorMeta)

Collects metadata about the current operator

fn clock_start(&mut self, _scope: Scope)

Notify the operator about the start of a new clock epoch.

fn clock_end(&mut self, _scope: Scope)

fn is_async(&self) -> bool

Returns true if self is an asynchronous operator.

fn is_input(&self) -> bool

Returns true if self is an input operator.

fn ready(&self) -> bool

Returns true if self has received all required external inputs and is ready to run.

fn register_ready_callback<F>(&mut self, _cb: F)

where F: Fn() + Send + Sync + 'static,

Register callback to be invoked when an asynchronous operator becomes ready.

fn checkpoint( &mut self, base: &StoragePath, persistent_id: Option<&str>, files: &mut Vec<Arc<dyn FileCommitter>>, ) -> Result<(), Error>

Instructs the operator to checkpoint its state to persistent storage in directory base. Any files that the operator creates should have persistent_id in their names to keep them unique.

fn restore( &mut self, base: &StoragePath, persistent_id: Option<&str>, ) -> Result<(), Error>

Instruct the operator to restore its state from persistent storage in directory base, using persistent_id to find its files.

fn clear_state(&mut self) -> Result<(), Error>

Clear the operator’s state.

fn start_replay(&mut self) -> Result<(), Error>

Start replaying the operator’s state to the replay stream.

fn is_replay_complete(&self) -> bool

Check if the operator has finished replaying its state.

fn end_replay(&mut self) -> Result<(), Error>

Cleanup any state needed for replay and prepare the operator for normal operation.

fn start_transaction(&mut self)

Notify the operator about start of a transaction.

fn flush(&mut self)

Notifies the operator that all of its predecessors have produced all outputs for the current transaction.

fn is_flush_complete(&self) -> bool

Invoked after flush after each eval call to check if all outputs have been produced. Because it is invoked only after calling eval, every operator must produce at least one output.

fn flush_progress(&self) -> Option<Position>

Returns the current progress of the operator in processing the current transaction.

fn start_compaction(&mut self)

Start compaction of the operator’s state.

fn is_compaction_complete(&self) -> bool

Returns true when the operator’s background compaction has fully converged. Operators without a trace always return true.