17040114484

Committed 18 Aug 2025 12:07PM UTC coverage: 86.042% (-1.9%) from 87.913%

Build # 17040114484

Build Type

Pull #4215

github

Committed by

web-flow

Commit Message

Merge 4600ca5c4 into cb1a92920

Pull Request Pull Request #4215: Ji/vectors

Run Details

132 of 1817 new or added lines in 42 files covered. (7.26%)

125 existing lines in 26 files now uncovered.

56932 of 66168 relevant lines covered (86.04%)

611735.65 hits per line

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

0.0

/vortex-vector/src/query/operators.rs

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

use vortex_error::{VortexExpect, VortexResult};

use crate::Kernel;
use crate::operators::BindContext;
use crate::query::Pipeline;
use crate::query::buffers::VectorAllocationPlan;
use crate::query::dag::DagNode;
use crate::vector::VectorId;

impl Pipeline<'_> {
    pub(crate) fn bind_operators(
        dag: &[DagNode],
        allocation_plan: &VectorAllocationPlan,
    ) -> VortexResult<Vec<Box<dyn Kernel>>> {
        let mut operators = Vec::with_capacity(dag.len());
        for node in dag {
            let input_ids = node
                .children
                .iter()
                .map(|node_idx| {
                    allocation_plan.output_targets[*node_idx]
                        .vector_id()
                        .vortex_expect("Input node must have an output vector ID")
                })
                .collect::<Vec<_>>();
            let bind_context = PipelineBindContext {
                children: input_ids,
            };
            let operator = node.plan_node.bind(&bind_context)?;
            operators.push(operator);
        }
        Ok(operators)
    }
}

struct PipelineBindContext {
    children: Vec<VectorId>,
}

impl BindContext for PipelineBindContext {
    fn children(&self) -> &[VectorId] {
        &self.children
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use vortex_error::{VortexExpect, VortexResult};
5
6	use crate::Kernel;
7	use crate::operators::BindContext;
8	use crate::query::Pipeline;
9	use crate::query::buffers::VectorAllocationPlan;
10	use crate::query::dag::DagNode;
11	use crate::vector::VectorId;
12
13	impl Pipeline<'_> {
NEW 14	pub(crate) fn bind_operators(	×
NEW 15	dag: &[DagNode],	×
NEW 16	allocation_plan: &VectorAllocationPlan,	×
NEW 17	) -> VortexResult<Vec<Box<dyn Kernel>>> {	×
NEW 18	let mut operators = Vec::with_capacity(dag.len());	×
NEW 19	for node in dag {	×
NEW 20	let input_ids = node	×
NEW 21	.children	×
NEW 22	.iter()	×
NEW 23	.map(\|node_idx\| {	×
NEW 24	allocation_plan.output_targets[*node_idx]	×
NEW 25	.vector_id()	×
NEW 26	.vortex_expect("Input node must have an output vector ID")	×
NEW 27	})	×
NEW 28	.collect::<Vec<_>>();	×
NEW 29	let bind_context = PipelineBindContext {	×
NEW 30	children: input_ids,	×
NEW 31	};	×
NEW 32	let operator = node.plan_node.bind(&bind_context)?;	×
NEW 33	operators.push(operator);	×
34	}
NEW 35	Ok(operators)	×
NEW 36	}	×
37	}
38
39	struct PipelineBindContext {
40	children: Vec<VectorId>,
41	}
42
43	impl BindContext for PipelineBindContext {
NEW 44	fn children(&self) -> &[VectorId] {	×
NEW 45	&self.children	×
NEW 46	}	×
47	}

vortex-data / vortex / 17040114484

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