17008093231

Committed 16 Aug 2025 11:54AM UTC coverage: 87.913% (+0.06%) from 87.855%

Build # 17008093231

Build Type

push

github

Committed by

web-flow

Commit Message

fix(deps): update slf4j monorepo to v2.0.17 (patch) (#4258)

This PR contains the following updates:

| Package | Change | Age | Confidence |
|---|---|---|---|
| [org.slf4j:slf4j-api](http://www.slf4j.org)
([source](https://redirect.github.com/qos-ch/slf4j),
[changelog](https://www.slf4j.org/news.html)) | `2.0.9` -> `2.0.17` |
[![age](https://developer.mend.io/api/mc/badges/age/maven/org.slf4j:slf4j-api/2.0.17?slim=true)](https://docs.renovatebot.com/merge-confidence/)
|
[![confidence](https://developer.mend.io/api/mc/badges/confidence/maven/org.slf4j:slf4j-api/2.0.9/2.0.17?slim=true)](https://docs.renovatebot.com/merge-confidence/)
|
| [org.slf4j:slf4j-simple](http://www.slf4j.org)
([source](https://redirect.github.com/qos-ch/slf4j),
[changelog](https://www.slf4j.org/news.html)) | `2.0.9` -> `2.0.17` |
[![age](https://developer.mend.io/api/mc/badges/age/maven/org.slf4j:slf4j-simple/2.0.17?slim=true)](https://docs.renovatebot.com/merge-confidence/)
|
[![confidence](https://developer.mend.io/api/mc/badges/confidence/maven/org.slf4j:slf4j-simple/2.0.9/2.0.17?slim=true)](https://docs.renovatebot.com/merge-confidence/)
|

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined),
Automerge - At any time (no schedule defined).

🚦 **Automerge**: Enabled.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about these
updates again.

---

- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box

---

This PR was generated by [Mend Renovate](https://mend.io/renovate/).
View the [repository job
log](https://developer.mend.io/github/vortex-data/vortex).

<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0MS43MS4xIiwidXBkYXRlZEluVmVyIjoiNDEuNzEuMSIsInRhcmdldEJyYW5jaCI6ImRldmVsb3AiLCJsYWJlbHMiOlsiY2hvcmUiXX0=-->

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

Run Details

56580 of 64359 relevant lines covered (87.91%)

628739.98 hits per line

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

48.42

/vortex-expr/src/exprs/operators.rs

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

use core::fmt;
use std::fmt::{Display, Formatter};

use vortex_array::compute;
use vortex_error::VortexError;
use vortex_proto::expr::binary_opts::BinaryOp;

/// Equalities, inequalities, and boolean operations over possibly null values.
///
/// For most operations, if either side is null, the result is null.
///
/// The Boolean operators (And, Or) obey [Kleene (three-valued) logic](https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics).
#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Operator {
    /// Expressions are equal.
    Eq,
    /// Expressions are not equal.
    NotEq,
    /// Expression is greater than another
    Gt,
    /// Expression is greater or equal to another
    Gte,
    /// Expression is less than another
    Lt,
    /// Expression is less or equal to another
    Lte,
    /// Boolean AND (∧).
    And,
    /// Boolean OR (∨).
    Or,
    /// The sum of the arguments.
    ///
    /// Errs at runtime if the sum would overflow or underflow.
    Add,
    /// The difference between the arguments.
    ///
    /// Errs at runtime if the sum would overflow or underflow.
    ///
    /// The result is null at any index that either input is null.
    Sub,
}

impl From<Operator> for i32 {
    fn from(value: Operator) -> Self {
        let op: BinaryOp = value.into();
        op.into()
    }
}

impl From<Operator> for BinaryOp {
    fn from(value: Operator) -> Self {
        match value {
            Operator::Eq => BinaryOp::Eq,
            Operator::NotEq => BinaryOp::NotEq,
            Operator::Gt => BinaryOp::Gt,
            Operator::Gte => BinaryOp::Gte,
            Operator::Lt => BinaryOp::Lt,
            Operator::Lte => BinaryOp::Lte,
            Operator::And => BinaryOp::And,
            Operator::Or => BinaryOp::Or,
            Operator::Add => BinaryOp::Add,
            Operator::Sub => BinaryOp::Sub,
        }
    }
}

impl TryFrom<i32> for Operator {
    type Error = VortexError;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        Ok(BinaryOp::try_from(value)?.into())
    }
}

impl From<BinaryOp> for Operator {
    fn from(value: BinaryOp) -> Self {
        match value {
            BinaryOp::Eq => Operator::Eq,
            BinaryOp::NotEq => Operator::NotEq,
            BinaryOp::Gt => Operator::Gt,
            BinaryOp::Gte => Operator::Gte,
            BinaryOp::Lt => Operator::Lt,
            BinaryOp::Lte => Operator::Lte,
            BinaryOp::And => Operator::And,
            BinaryOp::Or => Operator::Or,
            BinaryOp::Add => Operator::Add,
            BinaryOp::Sub => Operator::Sub,
        }
    }
}

impl Display for Operator {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let display = match &self {
            Operator::Eq => "=",
            Operator::NotEq => "!=",
            Operator::Gt => ">",
            Operator::Gte => ">=",
            Operator::Lt => "<",
            Operator::Lte => "<=",
            Operator::And => "and",
            Operator::Or => "or",
            Operator::Add => "+",
            Operator::Sub => "-",
        };
        Display::fmt(display, f)
    }
}

impl Operator {
    pub fn inverse(self) -> Option<Self> {
        match self {
            Operator::Eq => Some(Operator::NotEq),
            Operator::NotEq => Some(Operator::Eq),
            Operator::Gt => Some(Operator::Lte),
            Operator::Gte => Some(Operator::Lt),
            Operator::Lt => Some(Operator::Gte),
            Operator::Lte => Some(Operator::Gt),
            Operator::And | Operator::Or | Operator::Add | Operator::Sub => None,
        }
    }

    pub fn logical_inverse(self) -> Option<Self> {
        match self {
            Operator::And => Some(Operator::Or),
            Operator::Or => Some(Operator::And),
            _ => None,
        }
    }

    /// Change the sides of the operator, where changing lhs and rhs won't change the result of the operation
    pub fn swap(self) -> Self {
        match self {
            Operator::Eq => Operator::Eq,
            Operator::NotEq => Operator::NotEq,
            Operator::Gt => Operator::Lt,
            Operator::Gte => Operator::Lte,
            Operator::Lt => Operator::Gt,
            Operator::Lte => Operator::Gte,
            Operator::And => Operator::And,
            Operator::Or => Operator::Or,
            Operator::Add => Operator::Add,
            Operator::Sub => Operator::Sub,
        }
    }

    pub fn maybe_cmp_operator(self) -> Option<compute::Operator> {
        match self {
            Operator::Eq => Some(compute::Operator::Eq),
            Operator::NotEq => Some(compute::Operator::NotEq),
            Operator::Lt => Some(compute::Operator::Lt),
            Operator::Lte => Some(compute::Operator::Lte),
            Operator::Gt => Some(compute::Operator::Gt),
            Operator::Gte => Some(compute::Operator::Gte),
            _ => None,
        }
    }
}

impl From<compute::Operator> for Operator {
    fn from(cmp_operator: compute::Operator) -> Self {
        match cmp_operator {
            compute::Operator::Eq => Operator::Eq,
            compute::Operator::NotEq => Operator::NotEq,
            compute::Operator::Gt => Operator::Gt,
            compute::Operator::Gte => Operator::Gte,
            compute::Operator::Lt => Operator::Lt,
            compute::Operator::Lte => Operator::Lte,
        }
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use core::fmt;
5	use std::fmt::{Display, Formatter};
6
7	use vortex_array::compute;
8	use vortex_error::VortexError;
9	use vortex_proto::expr::binary_opts::BinaryOp;
10
11	/// Equalities, inequalities, and boolean operations over possibly null values.
12	///
13	/// For most operations, if either side is null, the result is null.
14	///
15	/// The Boolean operators (And, Or) obey [Kleene (three-valued) logic](https://en.wikipedia.org/wiki/Three-valued_logic#Kleene_and_Priest_logics).
16	#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Hash)]
17	#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18	pub enum Operator {
19	/// Expressions are equal.
20	Eq,
21	/// Expressions are not equal.
22	NotEq,
23	/// Expression is greater than another
24	Gt,
25	/// Expression is greater or equal to another
26	Gte,
27	/// Expression is less than another
28	Lt,
29	/// Expression is less or equal to another
30	Lte,
31	/// Boolean AND (∧).
32	And,
33	/// Boolean OR (∨).
34	Or,
35	/// The sum of the arguments.
36	///
37	/// Errs at runtime if the sum would overflow or underflow.
38	Add,
39	/// The difference between the arguments.
40	///
41	/// Errs at runtime if the sum would overflow or underflow.
42	///
43	/// The result is null at any index that either input is null.
44	Sub,
45	}
46
47	impl From<Operator> for i32 {
48	fn from(value: Operator) -> Self {	20✔
49	let op: BinaryOp = value.into();	20✔
50	op.into()	20✔
51	}	20✔
52	}
53
54	impl From<Operator> for BinaryOp {
55	fn from(value: Operator) -> Self {	20✔
56	match value {	20✔
57	Operator::Eq => BinaryOp::Eq,	4✔
58	Operator::NotEq => BinaryOp::NotEq,	1✔
59	Operator::Gt => BinaryOp::Gt,	3✔
60	Operator::Gte => BinaryOp::Gte,	1✔
61	Operator::Lt => BinaryOp::Lt,	2✔
62	Operator::Lte => BinaryOp::Lte,	1✔
63	Operator::And => BinaryOp::And,	4✔
64	Operator::Or => BinaryOp::Or,	3✔
65	Operator::Add => BinaryOp::Add,	1✔
66	Operator::Sub => BinaryOp::Sub,	×
67	}
68	}	20✔
69	}
70
71	impl TryFrom<i32> for Operator {
72	type Error = VortexError;
73
74	fn try_from(value: i32) -> Result<Self, Self::Error> {	×
75	Ok(BinaryOp::try_from(value)?.into())	×
76	}	×
77	}
78
79	impl From<BinaryOp> for Operator {
80	fn from(value: BinaryOp) -> Self {	20✔
81	match value {	20✔
82	BinaryOp::Eq => Operator::Eq,	4✔
83	BinaryOp::NotEq => Operator::NotEq,	1✔
84	BinaryOp::Gt => Operator::Gt,	3✔
85	BinaryOp::Gte => Operator::Gte,	1✔
86	BinaryOp::Lt => Operator::Lt,	2✔
87	BinaryOp::Lte => Operator::Lte,	1✔
88	BinaryOp::And => Operator::And,	4✔
89	BinaryOp::Or => Operator::Or,	3✔
90	BinaryOp::Add => Operator::Add,	1✔
91	BinaryOp::Sub => Operator::Sub,	×
92	}
93	}	20✔
94	}
95
96	impl Display for Operator {
97	fn fmt(&self, f: &mut Formatter) -> fmt::Result {	17✔
98	let display = match &self {	17✔
99	Operator::Eq => "=",	1✔
100	Operator::NotEq => "!=",	2✔
101	Operator::Gt => ">",	1✔
102	Operator::Gte => ">=",	3✔
103	Operator::Lt => "<",	2✔
104	Operator::Lte => "<=",	3✔
105	Operator::And => "and",	3✔
106	Operator::Or => "or",	2✔
107	Operator::Add => "+",	×
108	Operator::Sub => "-",	×
109	};
110	Display::fmt(display, f)	17✔
111	}	17✔
112	}
113
114	impl Operator {
115	pub fn inverse(self) -> Option<Self> {	×
116	match self {	×
117	Operator::Eq => Some(Operator::NotEq),	×
118	Operator::NotEq => Some(Operator::Eq),	×
119	Operator::Gt => Some(Operator::Lte),	×
120	Operator::Gte => Some(Operator::Lt),	×
121	Operator::Lt => Some(Operator::Gte),	×
122	Operator::Lte => Some(Operator::Gt),	×
123	Operator::And \| Operator::Or \| Operator::Add \| Operator::Sub => None,	×
124	}
125	}	×
126
127	pub fn logical_inverse(self) -> Option<Self> {	×
128	match self {	×
129	Operator::And => Some(Operator::Or),	×
130	Operator::Or => Some(Operator::And),	×
131	_ => None,	×
132	}
133	}	×
134
135	/// Change the sides of the operator, where changing lhs and rhs won't change the result of the operation
136	pub fn swap(self) -> Self {	508✔
137	match self {	508✔
138	Operator::Eq => Operator::Eq,	×
139	Operator::NotEq => Operator::NotEq,	×
140	Operator::Gt => Operator::Lt,	72✔
141	Operator::Gte => Operator::Lte,	361✔
142	Operator::Lt => Operator::Gt,	75✔
143	Operator::Lte => Operator::Gte,	×
144	Operator::And => Operator::And,	×
145	Operator::Or => Operator::Or,	×
146	Operator::Add => Operator::Add,	×
147	Operator::Sub => Operator::Sub,	×
148	}
149	}	508✔
150
151	pub fn maybe_cmp_operator(self) -> Option<compute::Operator> {	×
152	match self {	×
153	Operator::Eq => Some(compute::Operator::Eq),	×
154	Operator::NotEq => Some(compute::Operator::NotEq),	×
155	Operator::Lt => Some(compute::Operator::Lt),	×
156	Operator::Lte => Some(compute::Operator::Lte),	×
157	Operator::Gt => Some(compute::Operator::Gt),	×
158	Operator::Gte => Some(compute::Operator::Gte),	×
159	_ => None,	×
160	}
161	}	×
162	}
163
164	impl From<compute::Operator> for Operator {
165	fn from(cmp_operator: compute::Operator) -> Self {	×
166	match cmp_operator {	×
167	compute::Operator::Eq => Operator::Eq,	×
168	compute::Operator::NotEq => Operator::NotEq,	×
169	compute::Operator::Gt => Operator::Gt,	×
170	compute::Operator::Gte => Operator::Gte,	×
171	compute::Operator::Lt => Operator::Lt,	×
172	compute::Operator::Lte => Operator::Lte,	×
173	}
174	}	×
175	}

vortex-data / vortex / 17008093231

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