16970635821

Committed 14 Aug 2025 04:13PM UTC coverage: 85.882% (-1.8%) from 87.693%

Build # 16970635821

Build Type

Pull #4215

github

Committed by

web-flow

Commit Message

Merge 5182504a6 into f547cbca5

Pull Request Pull Request #4215: Ji/vectors

Run Details

80 of 1729 new or added lines in 38 files covered. (4.63%)

117 existing lines in 25 files now uncovered.

56994 of 66363 relevant lines covered (85.88%)

609331.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/vortex-array/src/pipeline/operators/mod.rs

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

//! Plan nodes represent the logical structure of a pipeline.

pub mod compare;
pub mod constant;
pub mod primitive;
pub mod scalar_compare;

use std::any::Any;
use std::fmt::Debug;
use std::sync::Arc;

use dyn_hash::DynHash;
use vortex_error::VortexResult;

use crate::pipeline::Kernel;
use crate::pipeline::types::VType;
use crate::pipeline::vector::VectorId;

// TODO: clean up this diagram
// compare(_, _) <-  for <- bitpacked
//               <- 12

// !--> reduce_child(compare(_, _), for <- bitpacked) -->
// --> reduce_child(compare(_, _), 12) -->

// compare_single[12](_) <- for(10) <- bitpacked

// compare_single[2](_) <- bitpacked

/// An operator represents a node in a logical query plan.
pub trait Operator: Debug + DynHash + 'static {
    fn as_any(&self) -> &dyn Any;

    /// The output [`VType`] of this operator.
    fn vtype(&self) -> VType;

    /// The children of this operator.
    fn children(&self) -> &[Arc<dyn Operator>];

    fn with_children(&self, children: Vec<Arc<dyn Operator>>) -> Arc<dyn Operator>;

    /// Whether this operator works by mutating its first child in-place.
    ///
    /// If `true`, the operator is invoked with the first child's input data passed via the
    /// mutable output view. The node is expected to mutate this data in-place.
    fn in_place(&self) -> bool {
        false
    }

    /// Create a kernel for this operator
    fn bind(&self, ctx: &dyn BindContext) -> VortexResult<Box<dyn Kernel>>;

    //TODO: fixme
    /// Given a set of reduced children, try and reduce the current node.
    /// If Keep is returned then the children of this node as still updated.
    fn reduce_children(&self, children: &[Arc<dyn Operator>]) -> Option<Arc<dyn Operator>> {
        None
    }

    /// Given a reduced parent, try and reduce the current node.
    /// If `Replace` is returned then  the parent node and this node and replaced by the returned node.
    fn reduce_parent(&self, parent: Arc<dyn Operator>) -> Option<Arc<dyn Operator>> {
        None
    }
}

dyn_hash::hash_trait_object!(Operator);

/// The context used when binding an operator for execution.
pub trait BindContext {
    fn children(&self) -> &[VectorId];
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	//! Plan nodes represent the logical structure of a pipeline.
5
6	pub mod compare;
7	pub mod constant;
8	pub mod primitive;
9	pub mod scalar_compare;
10
11	use std::any::Any;
12	use std::fmt::Debug;
13	use std::sync::Arc;
14
15	use dyn_hash::DynHash;
16	use vortex_error::VortexResult;
17
18	use crate::pipeline::Kernel;
19	use crate::pipeline::types::VType;
20	use crate::pipeline::vector::VectorId;
21
22	// TODO: clean up this diagram
23	// compare(_, _) <- for <- bitpacked
24	// <- 12
25
26	// !--> reduce_child(compare(_, _), for <- bitpacked) -->
27	// --> reduce_child(compare(_, _), 12) -->
28
29	// compare_single[12](_) <- for(10) <- bitpacked
30
31	// compare_single[2](_) <- bitpacked
32
33	/// An operator represents a node in a logical query plan.
34	pub trait Operator: Debug + DynHash + 'static {
35	fn as_any(&self) -> &dyn Any;
36
37	/// The output [`VType`] of this operator.
38	fn vtype(&self) -> VType;
39
40	/// The children of this operator.
41	fn children(&self) -> &[Arc<dyn Operator>];
42
43	fn with_children(&self, children: Vec<Arc<dyn Operator>>) -> Arc<dyn Operator>;
44
45	/// Whether this operator works by mutating its first child in-place.
46	///
47	/// If `true`, the operator is invoked with the first child's input data passed via the
48	/// mutable output view. The node is expected to mutate this data in-place.
NEW 49	fn in_place(&self) -> bool {	×
NEW 50	false	×
NEW 51	}	×
52
53	/// Create a kernel for this operator
54	fn bind(&self, ctx: &dyn BindContext) -> VortexResult<Box<dyn Kernel>>;
55
56	//TODO: fixme
57	/// Given a set of reduced children, try and reduce the current node.
58	/// If Keep is returned then the children of this node as still updated.
NEW 59	fn reduce_children(&self, children: &[Arc<dyn Operator>]) -> Option<Arc<dyn Operator>> {	×
NEW 60	None	×
NEW 61	}	×
62
63	/// Given a reduced parent, try and reduce the current node.
64	/// If `Replace` is returned then the parent node and this node and replaced by the returned node.
NEW 65	fn reduce_parent(&self, parent: Arc<dyn Operator>) -> Option<Arc<dyn Operator>> {	×
NEW 66	None	×
NEW 67	}	×
68	}
69
70	dyn_hash::hash_trait_object!(Operator);
71
72	/// The context used when binding an operator for execution.
73	pub trait BindContext {
74	fn children(&self) -> &[VectorId];
75	}

vortex-data / vortex / 16970635821

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous