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-expr/src/operator/mod.rs

mod reduce;

use std::sync::Arc;

pub use reduce::*;
use vortex_array::pipeline::operators::Operator;
use vortex_array::{Array, ArrayRef};
use vortex_error::{VortexResult, vortex_err};

use crate::traversal::{FoldUp, NodeFolder};
use crate::{ExprRef, RootVTable};

pub struct ExprOperatorConverter {
    root: ArrayRef,
}

impl ExprOperatorConverter {
    pub fn new(root: ArrayRef) -> Self {
        Self { root }
    }
}

// Needs a mapping from Root array to encoding -> Operator

impl NodeFolder for ExprOperatorConverter {
    type NodeTy = ExprRef;
    type Result = Arc<dyn Operator>;

    fn visit_up(
        &mut self,
        node: ExprRef,
        children: Vec<Arc<dyn Operator>>,
    ) -> VortexResult<FoldUp<Arc<dyn Operator>>> {
        if node.as_opt::<RootVTable>().is_some() {
            let pipeline = self.root.to_pipeline_plan()?;
            return Ok(FoldUp::Continue(pipeline));
        }
        node.operator(children)
            .ok_or_else(|| vortex_err!("Failed to convert operator: {:?}", node))
            .map(FoldUp::Continue)
    }
}

1	mod reduce;
2
3	use std::sync::Arc;
4
5	pub use reduce::*;
6	use vortex_array::pipeline::operators::Operator;
7	use vortex_array::{Array, ArrayRef};
8	use vortex_error::{VortexResult, vortex_err};
9
10	use crate::traversal::{FoldUp, NodeFolder};
11	use crate::{ExprRef, RootVTable};
12
13	pub struct ExprOperatorConverter {
14	root: ArrayRef,
15	}
16
17	impl ExprOperatorConverter {
NEW 18	pub fn new(root: ArrayRef) -> Self {	×
NEW 19	Self { root }	×
NEW 20	}	×
21	}
22
23	// Needs a mapping from Root array to encoding -> Operator
24
25	impl NodeFolder for ExprOperatorConverter {
26	type NodeTy = ExprRef;
27	type Result = Arc<dyn Operator>;
28
NEW 29	fn visit_up(	×
NEW 30	&mut self,	×
NEW 31	node: ExprRef,	×
NEW 32	children: Vec<Arc<dyn Operator>>,	×
NEW 33	) -> VortexResult<FoldUp<Arc<dyn Operator>>> {	×
NEW 34	if node.as_opt::<RootVTable>().is_some() {	×
NEW 35	let pipeline = self.root.to_pipeline_plan()?;	×
NEW 36	return Ok(FoldUp::Continue(pipeline));	×
NEW 37	}	×
NEW 38	node.operator(children)	×
NEW 39	.ok_or_else(\|\| vortex_err!("Failed to convert operator: {:?}", node))	×
NEW 40	.map(FoldUp::Continue)	×
NEW 41	}	×
42	}

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