Skip to content

Commit eb84a4e

Browse files
tobixdevtobixdev
committed
First step towards fixing the problem with terms vs. values
1 parent 957d041 commit eb84a4e

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

98 files changed

+1048
-1053
lines changed

‎lib/arrow-rdf-functions/src/comparison/eq.rs

Lines changed: 0 additions & 78 deletions
This file was deleted.

‎lib/arrow-rdf-functions/src/comparison/generic.rs

Lines changed: 24 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
1-
use crate::ScalarBinaryRdfOp;
1+
use crate::BinaryRdfValueOp;
22
use crate::ThinResult;
3-
use model::Boolean;
4-
use model::InternalTermRef;
3+
use model::ThinError;
4+
use model::{Boolean, RdfValueRef};
5+
use std::cmp::Ordering;
56

67
macro_rules! create_binary_cmp_udf {
7-
($STRUCT: ident, $OP: tt) => {
8+
($STRUCT: ident, $ORDERINGS: expr) => {
89
#[derive(Debug)]
9-
pub struct $STRUCT {
10-
}
10+
pub struct $STRUCT {}
1111

1212
impl Default for $STRUCT {
1313
fn default() -> Self {
@@ -21,55 +21,45 @@ macro_rules! create_binary_cmp_udf {
2121
}
2222
}
2323

24-
impl ScalarBinaryRdfOp for $STRUCT {
25-
type ArgLhs<'data> = InternalTermRef<'data>;
26-
type ArgRhs<'data> = InternalTermRef<'data>;
24+
impl BinaryRdfValueOp for $STRUCT {
25+
type ArgLhs<'data> = RdfValueRef<'data>;
26+
type ArgRhs<'data> = RdfValueRef<'data>;
2727
type Result<'data> = Boolean;
2828

2929
fn evaluate<'data>(
3030
&self,
3131
lhs: Self::ArgLhs<'data>,
3232
rhs: Self::ArgRhs<'data>,
3333
) -> ThinResult<Self::Result<'data>> {
34-
let result = match (lhs, rhs) {
35-
(InternalTermRef::NamedNode(l), InternalTermRef::NamedNode(r)) => l $OP r,
36-
(InternalTermRef::BooleanLiteral(l), InternalTermRef::BooleanLiteral(r)) => l $OP r,
37-
(InternalTermRef::NumericLiteral(l), InternalTermRef::NumericLiteral(r)) => l $OP r,
38-
(InternalTermRef::SimpleLiteral(l), InternalTermRef::SimpleLiteral(r)) => l $OP r,
39-
(InternalTermRef::LanguageStringLiteral(l), InternalTermRef::LanguageStringLiteral(r)) => l $OP r,
40-
(InternalTermRef::DateTimeLiteral(l), InternalTermRef::DateTimeLiteral(r)) => l $OP r,
41-
(InternalTermRef::DateLiteral(l), InternalTermRef::DateLiteral(r)) => l $OP r,
42-
(InternalTermRef::TimeLiteral(l), InternalTermRef::TimeLiteral(r)) => l $OP r,
43-
(InternalTermRef::DurationLiteral(l), InternalTermRef::DurationLiteral(r)) => l $OP r,
44-
(InternalTermRef::YearMonthDurationLiteral(l), InternalTermRef::YearMonthDurationLiteral(r)) => l $OP r,
45-
(InternalTermRef::DayTimeDurationLiteral(l), InternalTermRef::DayTimeDurationLiteral(r)) => l $OP r,
46-
(InternalTermRef::TypedLiteral(l), InternalTermRef::TypedLiteral(r)) => l $OP r,
47-
_ => false,
48-
};
49-
Ok(result.into())
34+
lhs.partial_cmp(&rhs)
35+
.map(|o| $ORDERINGS.contains(&o))
36+
.map(Into::into)
37+
.ok_or(ThinError::Expected)
5038
}
5139
}
52-
}
40+
};
5341
}
5442

55-
create_binary_cmp_udf!(GreaterThanRdfOp, >);
56-
create_binary_cmp_udf!(GreaterOrEqualRdfOp, >=);
57-
create_binary_cmp_udf!(LessThanRdfOp, <);
58-
create_binary_cmp_udf!(LessOrEqualRdfOp, <=);
43+
create_binary_cmp_udf!(EqRdfOp, [Ordering::Equal]);
44+
create_binary_cmp_udf!(GreaterThanRdfOp, [Ordering::Greater]);
45+
create_binary_cmp_udf!(GreaterOrEqualRdfOp, [Ordering::Equal, Ordering::Greater]);
46+
create_binary_cmp_udf!(LessThanRdfOp, [Ordering::Less]);
47+
create_binary_cmp_udf!(LessOrEqualRdfOp, [Ordering::Less, Ordering::Equal]);
5948

6049
#[cfg(test)]
6150
mod tests {
6251
use crate::comparison::generic::LessThanRdfOp;
63-
use crate::ScalarBinaryRdfOp;
64-
use model::{InternalTermRef, Numeric};
52+
use crate::BinaryRdfValueOp;
53+
use model::Numeric;
54+
use model::RdfValueRef;
6555

6656
#[test]
6757
fn test_lth_int_with_float() {
6858
let less_than = LessThanRdfOp::new();
6959
let result = less_than
7060
.evaluate(
71-
InternalTermRef::NumericLiteral(Numeric::Int(5.into())),
72-
InternalTermRef::NumericLiteral(Numeric::Float(10.0.into())),
61+
RdfValueRef::NumericLiteral(Numeric::Int(5.into())),
62+
RdfValueRef::NumericLiteral(Numeric::Float(10.0.into())),
7363
)
7464
.unwrap();
7565
assert_eq!(result, true.into());

‎lib/arrow-rdf-functions/src/comparison/mod.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
mod eq;
21
mod generic;
32
mod same_term;
43

5-
pub use eq::EqRdfOp;
6-
pub use generic::{GreaterOrEqualRdfOp, GreaterThanRdfOp, LessOrEqualRdfOp, LessThanRdfOp};
4+
pub use generic::{
5+
EqRdfOp, GreaterOrEqualRdfOp, GreaterThanRdfOp, LessOrEqualRdfOp, LessThanRdfOp,
6+
};
77
pub use same_term::SameTermRdfOp;

‎lib/arrow-rdf-functions/src/comparison/same_term.rs

Lines changed: 19 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
use crate::{ScalarBinaryRdfOp, ThinResult};
2-
use model::{Boolean, InternalTermRef};
1+
use crate::{BinaryRdfTermOp, BinaryRdfValueOp, ThinResult};
2+
use model::{Boolean, RdfValueRef, TermRef};
33

44
#[derive(Debug)]
55
pub struct SameTermRdfOp;
@@ -16,41 +16,29 @@ impl SameTermRdfOp {
1616
}
1717
}
1818

19-
impl ScalarBinaryRdfOp for SameTermRdfOp {
20-
type ArgLhs<'data> = InternalTermRef<'data>;
21-
type ArgRhs<'data> = InternalTermRef<'data>;
19+
impl BinaryRdfValueOp for SameTermRdfOp {
20+
type ArgLhs<'data> = RdfValueRef<'data>;
21+
type ArgRhs<'data> = RdfValueRef<'data>;
2222
type Result<'data> = Boolean;
2323

2424
fn evaluate<'data>(
2525
&self,
2626
lhs: Self::ArgLhs<'data>,
2727
rhs: Self::ArgRhs<'data>,
2828
) -> ThinResult<Self::Result<'data>> {
29-
let result = match (lhs, rhs) {
30-
(InternalTermRef::NamedNode(l), InternalTermRef::NamedNode(r)) => l == r,
31-
(InternalTermRef::BlankNode(l), InternalTermRef::BlankNode(r)) => l == r,
32-
(InternalTermRef::BooleanLiteral(l), InternalTermRef::BooleanLiteral(r)) => l == r,
33-
(InternalTermRef::NumericLiteral(l), InternalTermRef::NumericLiteral(r)) => l == r,
34-
(InternalTermRef::SimpleLiteral(l), InternalTermRef::SimpleLiteral(r)) => l == r,
35-
(
36-
InternalTermRef::LanguageStringLiteral(l),
37-
InternalTermRef::LanguageStringLiteral(r),
38-
) => l == r,
39-
(InternalTermRef::DateTimeLiteral(l), InternalTermRef::DateTimeLiteral(r)) => l == r,
40-
(InternalTermRef::DateLiteral(l), InternalTermRef::DateLiteral(r)) => l == r,
41-
(InternalTermRef::TimeLiteral(l), InternalTermRef::TimeLiteral(r)) => l == r,
42-
(InternalTermRef::DurationLiteral(l), InternalTermRef::DurationLiteral(r)) => l == r,
43-
(
44-
InternalTermRef::YearMonthDurationLiteral(l),
45-
InternalTermRef::YearMonthDurationLiteral(r),
46-
) => l == r,
47-
(
48-
InternalTermRef::DayTimeDurationLiteral(l),
49-
InternalTermRef::DayTimeDurationLiteral(r),
50-
) => l == r,
51-
(InternalTermRef::TypedLiteral(l), InternalTermRef::TypedLiteral(r)) => l == r,
52-
_ => false,
53-
};
54-
Ok(result.into())
29+
// TODO: fix PartialEq for RdfValue to be SameTerm
30+
Ok((lhs == rhs).into())
31+
}
32+
}
33+
34+
impl BinaryRdfTermOp for SameTermRdfOp {
35+
type Result<'data> = Boolean;
36+
37+
fn evaluate<'data>(
38+
&self,
39+
lhs: TermRef<'data>,
40+
rhs: TermRef<'data>,
41+
) -> ThinResult<Self::Result<'data>> {
42+
Ok((lhs == rhs).into())
5543
}
5644
}

‎lib/arrow-rdf-functions/src/conversion/as_boolean.rs

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
1-
use crate::{ScalarUnaryRdfOp, ThinResult};
2-
use model::{Boolean, InternalTermRef, Numeric, ThinError};
1+
use crate::{UnaryRdfValueOp, ThinResult};
2+
use model::{Boolean, Numeric, ThinError};
3+
use model::RdfValueRef;
34

45
#[derive(Debug)]
56
pub struct AsBooleanRdfOp;
@@ -16,15 +17,15 @@ impl AsBooleanRdfOp {
1617
}
1718
}
1819

19-
impl ScalarUnaryRdfOp for AsBooleanRdfOp {
20-
type Arg<'data> = InternalTermRef<'data>;
20+
impl UnaryRdfValueOp for AsBooleanRdfOp {
21+
type Arg<'data> = RdfValueRef<'data>;
2122
type Result<'data> = Boolean;
2223

2324
fn evaluate<'data>(&self, value: Self::Arg<'data>) -> ThinResult<Self::Result<'data>> {
2425
let converted = match value {
25-
InternalTermRef::BooleanLiteral(v) => v,
26-
InternalTermRef::SimpleLiteral(v) => v.value.parse()?,
27-
InternalTermRef::NumericLiteral(numeric) => match numeric {
26+
RdfValueRef::BooleanLiteral(v) => v,
27+
RdfValueRef::SimpleLiteral(v) => v.value.parse()?,
28+
RdfValueRef::NumericLiteral(numeric) => match numeric {
2829
Numeric::Int(v) => Boolean::from(v),
2930
Numeric::Integer(v) => Boolean::from(v),
3031
Numeric::Float(v) => Boolean::from(v),

‎lib/arrow-rdf-functions/src/conversion/as_datetime.rs

Lines changed: 7 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
1-
use crate::{ScalarUnaryRdfOp, ThinResult};
2-
use model::{DateTime, InternalTermRef, ThinError};
1+
use crate::{UnaryRdfValueOp, ThinResult};
2+
use model::{DateTime, ThinError};
3+
use model::RdfValueRef;
34

45
#[derive(Debug)]
56
pub struct AsDateTimeRdfOp;
@@ -16,14 +17,14 @@ impl AsDateTimeRdfOp {
1617
}
1718
}
1819

19-
impl ScalarUnaryRdfOp for AsDateTimeRdfOp {
20-
type Arg<'data> = InternalTermRef<'data>;
20+
impl UnaryRdfValueOp for AsDateTimeRdfOp {
21+
type Arg<'data> = RdfValueRef<'data>;
2122
type Result<'data> = DateTime;
2223

2324
fn evaluate<'data>(&self, value: Self::Arg<'data>) -> ThinResult<Self::Result<'data>> {
2425
let converted = match value {
25-
InternalTermRef::SimpleLiteral(v) => v.value.parse()?,
26-
InternalTermRef::DateTimeLiteral(v) => v,
26+
RdfValueRef::SimpleLiteral(v) => v.value.parse()?,
27+
RdfValueRef::DateTimeLiteral(v) => v,
2728
_ => return ThinError::expected(),
2829
};
2930
Ok(converted)

‎lib/arrow-rdf-functions/src/conversion/as_decimal.rs

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
1-
use crate::{ScalarUnaryRdfOp, ThinResult};
2-
use model::{Decimal, InternalTermRef, Numeric, ThinError};
1+
use crate::{ThinResult, UnaryRdfValueOp};
2+
use model::RdfValueRef;
3+
use model::{Decimal, Numeric, ThinError};
34

45
#[derive(Debug)]
56
pub struct AsDecimalRdfOp;
@@ -16,15 +17,15 @@ impl AsDecimalRdfOp {
1617
}
1718
}
1819

19-
impl ScalarUnaryRdfOp for AsDecimalRdfOp {
20-
type Arg<'data> = InternalTermRef<'data>;
20+
impl UnaryRdfValueOp for AsDecimalRdfOp {
21+
type Arg<'data> = RdfValueRef<'data>;
2122
type Result<'data> = Decimal;
2223

2324
fn evaluate<'data>(&self, value: Self::Arg<'data>) -> ThinResult<Self::Result<'data>> {
2425
let converted = match value {
25-
InternalTermRef::BooleanLiteral(v) => Decimal::from(v),
26-
InternalTermRef::SimpleLiteral(v) => v.value.parse()?,
27-
InternalTermRef::NumericLiteral(numeric) => match numeric {
26+
RdfValueRef::BooleanLiteral(v) => Decimal::from(v),
27+
RdfValueRef::SimpleLiteral(v) => v.value.parse()?,
28+
RdfValueRef::NumericLiteral(numeric) => match numeric {
2829
Numeric::Int(v) => Decimal::from(v),
2930
Numeric::Integer(v) => Decimal::from(v),
3031
Numeric::Float(v) => Decimal::try_from(v)?,

‎lib/arrow-rdf-functions/src/conversion/as_double.rs

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
1-
use crate::{ScalarUnaryRdfOp, ThinResult};
2-
use model::{Double, InternalTermRef, Numeric, ThinError};
1+
use crate::{UnaryRdfValueOp, ThinResult};
2+
use model::{Double, Numeric, ThinError};
3+
use model::RdfValueRef;
34

45
#[derive(Debug)]
56
pub struct AsDoubleRdfOp;
@@ -16,15 +17,15 @@ impl AsDoubleRdfOp {
1617
}
1718
}
1819

19-
impl ScalarUnaryRdfOp for AsDoubleRdfOp {
20-
type Arg<'data> = InternalTermRef<'data>;
20+
impl UnaryRdfValueOp for AsDoubleRdfOp {
21+
type Arg<'data> = RdfValueRef<'data>;
2122
type Result<'data> = Double;
2223

2324
fn evaluate<'data>(&self, value: Self::Arg<'data>) -> ThinResult<Self::Result<'data>> {
2425
let converted = match value {
25-
InternalTermRef::BooleanLiteral(v) => Double::from(v),
26-
InternalTermRef::SimpleLiteral(v) => v.value.parse()?,
27-
InternalTermRef::NumericLiteral(numeric) => match numeric {
26+
RdfValueRef::BooleanLiteral(v) => Double::from(v),
27+
RdfValueRef::SimpleLiteral(v) => v.value.parse()?,
28+
RdfValueRef::NumericLiteral(numeric) => match numeric {
2829
Numeric::Int(v) => Double::from(v),
2930
Numeric::Integer(v) => Double::from(v),
3031
Numeric::Float(v) => Double::from(v),

0 commit comments

Comments
 (0)