NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Drops EncodedTerm Ord and PartialOrd implementations

Browse Source
pull/22/head
Tpt 5 years ago committed by Tpt
parent 8c115abc19
commit 8aa5bf4ceb
3 changed files with 161 additions and 68 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      lib/Cargo.toml
  2. 88
      lib/src/sparql/eval.rs
  3. 140
      lib/src/store/numeric_encoder.rs

1
lib/Cargo.toml
Unescape View File

@ -17,7 +17,6 @@ lazy_static = "1"
rocksdb = { version = "0.13", optional = true } rocksdb = { version = "0.13", optional = true }
byteorder = { version = "1", features = ["i128"] } byteorder = { version = "1", features = ["i128"] }
quick-xml = "0.17" quick-xml = "0.17"
ordered-float = "1"
num-traits = "0.2" num-traits = "0.2"
chrono = "0.4" chrono = "0.4"
rand = "0.7" rand = "0.7"

88
lib/src/sparql/eval.rs
Unescape View File

@ -840,15 +840,15 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
NumericBinaryOperands::Decimal(v1, v2) => v1.checked_div(v2)?.into(), NumericBinaryOperands::Decimal(v1, v2) => v1.checked_div(v2)?.into(),
}), }),
PlanExpression::UnaryPlus(e) => match self.eval_expression(e, tuple)? { PlanExpression::UnaryPlus(e) => match self.eval_expression(e, tuple)? {
EncodedTerm::FloatLiteral(value) => Some((*value).into()), EncodedTerm::FloatLiteral(value) => Some(value.into()),
EncodedTerm::DoubleLiteral(value) => Some((*value).into()), EncodedTerm::DoubleLiteral(value) => Some(value.into()),
EncodedTerm::IntegerLiteral(value) => Some((value).into()), EncodedTerm::IntegerLiteral(value) => Some(value.into()),
EncodedTerm::DecimalLiteral(value) => Some((value).into()), EncodedTerm::DecimalLiteral(value) => Some(value.into()),
_ => None, _ => None,
}, },
PlanExpression::UnaryMinus(e) => match self.eval_expression(e, tuple)? { PlanExpression::UnaryMinus(e) => match self.eval_expression(e, tuple)? {
EncodedTerm::FloatLiteral(value) => Some((-*value).into()), EncodedTerm::FloatLiteral(value) => Some((-value).into()),
EncodedTerm::DoubleLiteral(value) => Some((-*value).into()), EncodedTerm::DoubleLiteral(value) => Some((-value).into()),
EncodedTerm::IntegerLiteral(value) => Some((-value).into()), EncodedTerm::IntegerLiteral(value) => Some((-value).into()),
EncodedTerm::DecimalLiteral(value) => Some((-value).into()), EncodedTerm::DecimalLiteral(value) => Some((-value).into()),
_ => None, _ => None,
@ -1362,8 +1362,8 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
_ => None, _ => None,
}, },
PlanExpression::DecimalCast(e) => match self.eval_expression(e, tuple)? { PlanExpression::DecimalCast(e) => match self.eval_expression(e, tuple)? {
EncodedTerm::FloatLiteral(value) => Some(Decimal::from_f32(*value).into()), EncodedTerm::FloatLiteral(value) => Some(Decimal::from_f32(value).into()),
EncodedTerm::DoubleLiteral(value) => Some(Decimal::from_f64(*value).into()), EncodedTerm::DoubleLiteral(value) => Some(Decimal::from_f64(value).into()),
EncodedTerm::IntegerLiteral(value) => Some(Decimal::from(value).into()), EncodedTerm::IntegerLiteral(value) => Some(Decimal::from(value).into()),
EncodedTerm::DecimalLiteral(value) => Some(value.into()), EncodedTerm::DecimalLiteral(value) => Some(value.into()),
EncodedTerm::BooleanLiteral(value) => { EncodedTerm::BooleanLiteral(value) => {
@ -1411,8 +1411,8 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
match term { match term {
EncodedTerm::BooleanLiteral(value) => Some(value), EncodedTerm::BooleanLiteral(value) => Some(value),
EncodedTerm::StringLiteral { .. } => Some(term != ENCODED_EMPTY_STRING_LITERAL), EncodedTerm::StringLiteral { .. } => Some(term != ENCODED_EMPTY_STRING_LITERAL),
EncodedTerm::FloatLiteral(value) => Some(*value != 0f32), EncodedTerm::FloatLiteral(value) => Some(value != 0f32),
EncodedTerm::DoubleLiteral(value) => Some(*value != 0f64), EncodedTerm::DoubleLiteral(value) => Some(value != 0f64),
EncodedTerm::IntegerLiteral(value) => Some(value != 0), EncodedTerm::IntegerLiteral(value) => Some(value != 0),
EncodedTerm::DecimalLiteral(value) => Some(value != Decimal::from(0)), EncodedTerm::DecimalLiteral(value) => Some(value != Decimal::from(0)),
_ => None, _ => None,
@ -1651,31 +1651,31 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
}, },
EncodedTerm::FloatLiteral(a) => match b { EncodedTerm::FloatLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => Some(a == b), EncodedTerm::FloatLiteral(b) => Some(a == b),
EncodedTerm::DoubleLiteral(b) => Some(a.to_f64()? == *b), EncodedTerm::DoubleLiteral(b) => Some(a.to_f64()? == b),
EncodedTerm::IntegerLiteral(b) => Some(*a == b.to_f32()?), EncodedTerm::IntegerLiteral(b) => Some(a == b.to_f32()?),
EncodedTerm::DecimalLiteral(b) => Some(*a == b.to_f32()), EncodedTerm::DecimalLiteral(b) => Some(a == b.to_f32()),
EncodedTerm::TypedLiteral { .. } => None, EncodedTerm::TypedLiteral { .. } => None,
_ => Some(false), _ => Some(false),
}, },
EncodedTerm::DoubleLiteral(a) => match b { EncodedTerm::DoubleLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => Some(*a == b.to_f64()?), EncodedTerm::FloatLiteral(b) => Some(a == b.to_f64()?),
EncodedTerm::DoubleLiteral(b) => Some(a == b), EncodedTerm::DoubleLiteral(b) => Some(a == b),
EncodedTerm::IntegerLiteral(b) => Some(*a == b.to_f64()?), EncodedTerm::IntegerLiteral(b) => Some(a == b.to_f64()?),
EncodedTerm::DecimalLiteral(b) => Some(*a == b.to_f64()), EncodedTerm::DecimalLiteral(b) => Some(a == b.to_f64()),
EncodedTerm::TypedLiteral { .. } => None, EncodedTerm::TypedLiteral { .. } => None,
_ => Some(false), _ => Some(false),
}, },
EncodedTerm::IntegerLiteral(a) => match b { EncodedTerm::IntegerLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => Some(a.to_f32()? == *b), EncodedTerm::FloatLiteral(b) => Some(a.to_f32()? == b),
EncodedTerm::DoubleLiteral(b) => Some(a.to_f64()? == *b), EncodedTerm::DoubleLiteral(b) => Some(a.to_f64()? == b),
EncodedTerm::IntegerLiteral(b) => Some(a == b), EncodedTerm::IntegerLiteral(b) => Some(a == b),
EncodedTerm::DecimalLiteral(b) => Some(Decimal::from(a) == b), EncodedTerm::DecimalLiteral(b) => Some(Decimal::from(a) == b),
EncodedTerm::TypedLiteral { .. } => None, EncodedTerm::TypedLiteral { .. } => None,
_ => Some(false), _ => Some(false),
}, },
EncodedTerm::DecimalLiteral(a) => match b { EncodedTerm::DecimalLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => Some(a.to_f32() == *b), EncodedTerm::FloatLiteral(b) => Some(a.to_f32() == b),
EncodedTerm::DoubleLiteral(b) => Some(a.to_f64() == *b), EncodedTerm::DoubleLiteral(b) => Some(a.to_f64() == b),
EncodedTerm::IntegerLiteral(b) => Some(a == Decimal::from(b)), EncodedTerm::IntegerLiteral(b) => Some(a == Decimal::from(b)),
EncodedTerm::DecimalLiteral(b) => Some(a == b), EncodedTerm::DecimalLiteral(b) => Some(a == b),
EncodedTerm::TypedLiteral { .. } => None, EncodedTerm::TypedLiteral { .. } => None,
@ -1796,29 +1796,29 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
} }
} }
EncodedTerm::FloatLiteral(a) => match b { EncodedTerm::FloatLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => (*a).partial_cmp(&*b), EncodedTerm::FloatLiteral(b) => a.partial_cmp(&b),
EncodedTerm::DoubleLiteral(b) => a.to_f64()?.partial_cmp(&*b), EncodedTerm::DoubleLiteral(b) => a.to_f64()?.partial_cmp(&b),
EncodedTerm::IntegerLiteral(b) => (*a).partial_cmp(&b.to_f32()?), EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&b.to_f32()?),
EncodedTerm::DecimalLiteral(b) => (*a).partial_cmp(&b.to_f32()), EncodedTerm::DecimalLiteral(b) => a.partial_cmp(&b.to_f32()),
_ => None, _ => None,
}, },
EncodedTerm::DoubleLiteral(a) => match b { EncodedTerm::DoubleLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => (*a).partial_cmp(&b.to_f64()?), EncodedTerm::FloatLiteral(b) => a.partial_cmp(&b.to_f64()?),
EncodedTerm::DoubleLiteral(b) => (*a).partial_cmp(&*b), EncodedTerm::DoubleLiteral(b) => a.partial_cmp(&b),
EncodedTerm::IntegerLiteral(b) => (*a).partial_cmp(&b.to_f64()?), EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&b.to_f64()?),
EncodedTerm::DecimalLiteral(b) => (*a).partial_cmp(&b.to_f64()), EncodedTerm::DecimalLiteral(b) => a.partial_cmp(&b.to_f64()),
_ => None, _ => None,
}, },
EncodedTerm::IntegerLiteral(a) => match b { EncodedTerm::IntegerLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => a.to_f32()?.partial_cmp(&*b), EncodedTerm::FloatLiteral(b) => a.to_f32()?.partial_cmp(&b),
EncodedTerm::DoubleLiteral(b) => a.to_f64()?.partial_cmp(&*b), EncodedTerm::DoubleLiteral(b) => a.to_f64()?.partial_cmp(&b),
EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&b), EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&b),
EncodedTerm::DecimalLiteral(b) => Decimal::from(a).partial_cmp(&b), EncodedTerm::DecimalLiteral(b) => Decimal::from(a).partial_cmp(&b),
_ => None, _ => None,
}, },
EncodedTerm::DecimalLiteral(a) => match b { EncodedTerm::DecimalLiteral(a) => match b {
EncodedTerm::FloatLiteral(b) => a.to_f32().partial_cmp(&*b), EncodedTerm::FloatLiteral(b) => a.to_f32().partial_cmp(&b),
EncodedTerm::DoubleLiteral(b) => a.to_f64().partial_cmp(&*b), EncodedTerm::DoubleLiteral(b) => a.to_f64().partial_cmp(&b),
EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&Decimal::from(b)), EncodedTerm::IntegerLiteral(b) => a.partial_cmp(&Decimal::from(b)),
EncodedTerm::DecimalLiteral(b) => a.partial_cmp(&b), EncodedTerm::DecimalLiteral(b) => a.partial_cmp(&b),
_ => None, _ => None,
@ -1885,34 +1885,34 @@ impl NumericBinaryOperands {
fn new(a: EncodedTerm, b: EncodedTerm) -> Option<Self> { fn new(a: EncodedTerm, b: EncodedTerm) -> Option<Self> {
match (a, b) { match (a, b) {
(EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, v2.to_f32()?)) Some(NumericBinaryOperands::Float(v1, v2.to_f32()?))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(v1.to_f64()?, *v2)) Some(NumericBinaryOperands::Double(v1.to_f64()?, v2))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, v2.to_f32()?)) Some(NumericBinaryOperands::Float(v1, v2.to_f32()?))
} }
(EncodedTerm::FloatLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::FloatLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Float(*v1, v2.to_f32())) Some(NumericBinaryOperands::Float(v1, v2.to_f32()))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, v2.to_f64()?)) Some(NumericBinaryOperands::Double(v1, v2.to_f64()?))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, *v2)) Some(NumericBinaryOperands::Double(v1, v2))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, v2.to_f64()?)) Some(NumericBinaryOperands::Double(v1, v2.to_f64()?))
} }
(EncodedTerm::DoubleLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => { (EncodedTerm::DoubleLiteral(v1), EncodedTerm::DecimalLiteral(v2)) => {
Some(NumericBinaryOperands::Double(*v1, v2.to_f64())) Some(NumericBinaryOperands::Double(v1, v2.to_f64()))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(v1.to_f32()?, *v2)) Some(NumericBinaryOperands::Float(v1.to_f32()?, v2))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(v1.to_f64()?, *v2)) Some(NumericBinaryOperands::Double(v1.to_f64()?, v2))
} }
(EncodedTerm::IntegerLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::IntegerLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Integer(v1, v2)) Some(NumericBinaryOperands::Integer(v1, v2))
@ -1921,10 +1921,10 @@ impl NumericBinaryOperands {
Some(NumericBinaryOperands::Decimal(Decimal::from(v1), v2)) Some(NumericBinaryOperands::Decimal(Decimal::from(v1), v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::FloatLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::FloatLiteral(v2)) => {
Some(NumericBinaryOperands::Float(v1.to_f32(), *v2)) Some(NumericBinaryOperands::Float(v1.to_f32(), v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::DoubleLiteral(v2)) => {
Some(NumericBinaryOperands::Double(v1.to_f64(), *v2)) Some(NumericBinaryOperands::Double(v1.to_f64(), v2))
} }
(EncodedTerm::DecimalLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => { (EncodedTerm::DecimalLiteral(v1), EncodedTerm::IntegerLiteral(v2)) => {
Some(NumericBinaryOperands::Decimal(v1, Decimal::from(v2))) Some(NumericBinaryOperands::Decimal(v1, Decimal::from(v2)))

140
lib/src/store/numeric_encoder.rs
Unescape View File

@ -9,10 +9,11 @@ use chrono::prelude::*;
use failure::format_err; use failure::format_err;
use md5::digest::Digest; use md5::digest::Digest;
use md5::Md5; use md5::Md5;
use ordered_float::OrderedFloat;
use rand::random; use rand::random;
use rio_api::model as rio; use rio_api::model as rio;
use std::collections::HashMap; use std::collections::HashMap;
use std::hash::Hash;
use std::hash::Hasher;
use std::io::Read; use std::io::Read;
use std::io::Write; use std::io::Write;
use std::mem::size_of; use std::mem::size_of;
@ -89,7 +90,7 @@ pub const ENCODED_XSD_DATE_TIME_NAMED_NODE: EncodedTerm = EncodedTerm::NamedNode
iri_id: XSD_DATE_TIME_ID, iri_id: XSD_DATE_TIME_ID,
}; };
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Copy, Hash)] #[derive(Debug, Clone, Copy)]
pub enum EncodedTerm { pub enum EncodedTerm {
DefaultGraph, DefaultGraph,
NamedNode { iri_id: u128 }, NamedNode { iri_id: u128 },
@ -98,8 +99,8 @@ pub enum EncodedTerm {
LangStringLiteral { value_id: u128, language_id: u128 }, LangStringLiteral { value_id: u128, language_id: u128 },
TypedLiteral { value_id: u128, datatype_id: u128 }, TypedLiteral { value_id: u128, datatype_id: u128 },
BooleanLiteral(bool), BooleanLiteral(bool),
FloatLiteral(OrderedFloat<f32>), FloatLiteral(f32),
DoubleLiteral(OrderedFloat<f64>), DoubleLiteral(f64),
IntegerLiteral(i64), IntegerLiteral(i64),
DecimalLiteral(Decimal), DecimalLiteral(Decimal),
DateLiteral(Date<FixedOffset>), DateLiteral(Date<FixedOffset>),
@ -109,6 +110,109 @@ pub enum EncodedTerm {
NaiveDateTimeLiteral(NaiveDateTime), NaiveDateTimeLiteral(NaiveDateTime),
} }
impl PartialEq for EncodedTerm {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(EncodedTerm::DefaultGraph, EncodedTerm::DefaultGraph) => true,
(
EncodedTerm::NamedNode { iri_id: iri_id_a },
EncodedTerm::NamedNode { iri_id: iri_id_b },
) => iri_id_a == iri_id_b,
(EncodedTerm::BlankNode { id: id_a }, EncodedTerm::BlankNode { id: id_b }) => {
id_a == id_b
}
(
EncodedTerm::StringLiteral {
value_id: value_id_a,
},
EncodedTerm::StringLiteral {
value_id: value_id_b,
},
) => value_id_a == value_id_b,
(
EncodedTerm::LangStringLiteral {
value_id: value_id_a,
language_id: language_id_a,
},
EncodedTerm::LangStringLiteral {
value_id: value_id_b,
language_id: language_id_b,
},
) => value_id_a == value_id_b && language_id_a == language_id_b,
(
EncodedTerm::TypedLiteral {
value_id: value_id_a,
datatype_id: datatype_id_a,
},
EncodedTerm::TypedLiteral {
value_id: value_id_b,
datatype_id: datatype_id_b,
},
) => value_id_a == value_id_b && datatype_id_a == datatype_id_b,
(EncodedTerm::BooleanLiteral(a), EncodedTerm::BooleanLiteral(b)) => a == b,
(EncodedTerm::FloatLiteral(a), EncodedTerm::FloatLiteral(b)) => {
if a.is_nan() {
b.is_nan()
} else {
a == b
}
}
(EncodedTerm::DoubleLiteral(a), EncodedTerm::DoubleLiteral(b)) => {
if a.is_nan() {
b.is_nan()
} else {
a == b
}
}
(EncodedTerm::IntegerLiteral(a), EncodedTerm::IntegerLiteral(b)) => a == b,
(EncodedTerm::DecimalLiteral(a), EncodedTerm::DecimalLiteral(b)) => a == b,
(EncodedTerm::DateLiteral(a), EncodedTerm::DateLiteral(b)) => a == b,
(EncodedTerm::NaiveDateLiteral(a), EncodedTerm::NaiveDateLiteral(b)) => a == b,
(EncodedTerm::NaiveTimeLiteral(a), EncodedTerm::NaiveTimeLiteral(b)) => a == b,
(EncodedTerm::DateTimeLiteral(a), EncodedTerm::DateTimeLiteral(b)) => a == b,
(EncodedTerm::NaiveDateTimeLiteral(a), EncodedTerm::NaiveDateTimeLiteral(b)) => a == b,
(_, _) => false,
}
}
}
impl Eq for EncodedTerm {}
impl Hash for EncodedTerm {
fn hash<H: Hasher>(&self, state: &mut H) {
match self {
EncodedTerm::NamedNode { iri_id } => iri_id.hash(state),
EncodedTerm::BlankNode { id } => id.hash(state),
EncodedTerm::DefaultGraph => (),
EncodedTerm::StringLiteral { value_id } => value_id.hash(state),
EncodedTerm::LangStringLiteral {
value_id,
language_id,
} => {
value_id.hash(state);
language_id.hash(state);
}
EncodedTerm::TypedLiteral {
value_id,
datatype_id,
} => {
value_id.hash(state);
datatype_id.hash(state);
}
EncodedTerm::BooleanLiteral(value) => value.hash(state),
EncodedTerm::FloatLiteral(value) => state.write(&value.to_ne_bytes()),
EncodedTerm::DoubleLiteral(value) => state.write(&value.to_ne_bytes()),
EncodedTerm::IntegerLiteral(value) => value.hash(state),
EncodedTerm::DecimalLiteral(value) => value.hash(state),
EncodedTerm::DateLiteral(value) => value.hash(state),
EncodedTerm::NaiveDateLiteral(value) => value.hash(state),
EncodedTerm::NaiveTimeLiteral(value) => value.hash(state),
EncodedTerm::DateTimeLiteral(value) => value.hash(state),
EncodedTerm::NaiveDateTimeLiteral(value) => value.hash(state),
}
}
}
impl EncodedTerm { impl EncodedTerm {
pub fn is_named_node(&self) -> bool { pub fn is_named_node(&self) -> bool {
match self { match self {
@ -214,13 +318,13 @@ impl From<u32> for EncodedTerm {
impl From<f32> for EncodedTerm { impl From<f32> for EncodedTerm {
fn from(value: f32) -> Self { fn from(value: f32) -> Self {
EncodedTerm::FloatLiteral(value.into()) EncodedTerm::FloatLiteral(value)
} }
} }
impl From<f64> for EncodedTerm { impl From<f64> for EncodedTerm {
fn from(value: f64) -> Self { fn from(value: f64) -> Self {
EncodedTerm::DoubleLiteral(value.into()) EncodedTerm::DoubleLiteral(value)
} }
} }
@ -364,7 +468,7 @@ impl From<&Term> for EncodedTerm {
} }
} }
#[derive(Eq, PartialEq, Ord, PartialOrd, Debug, Clone, Hash)] #[derive(Eq, PartialEq, Debug, Clone, Hash)]
pub struct EncodedQuad { pub struct EncodedQuad {
pub subject: EncodedTerm, pub subject: EncodedTerm,
pub predicate: EncodedTerm, pub predicate: EncodedTerm,
@ -435,12 +539,8 @@ impl<R: Read> TermReader for R {
}), }),
TYPE_BOOLEAN_LITERAL_TRUE => Ok(EncodedTerm::BooleanLiteral(true)), TYPE_BOOLEAN_LITERAL_TRUE => Ok(EncodedTerm::BooleanLiteral(true)),
TYPE_BOOLEAN_LITERAL_FALSE => Ok(EncodedTerm::BooleanLiteral(false)), TYPE_BOOLEAN_LITERAL_FALSE => Ok(EncodedTerm::BooleanLiteral(false)),
TYPE_FLOAT_LITERAL => Ok(EncodedTerm::FloatLiteral(OrderedFloat( TYPE_FLOAT_LITERAL => Ok(EncodedTerm::FloatLiteral(self.read_f32::<LittleEndian>()?)),
self.read_f32::<LittleEndian>()?, TYPE_DOUBLE_LITERAL => Ok(EncodedTerm::DoubleLiteral(self.read_f64::<LittleEndian>()?)),
))),
TYPE_DOUBLE_LITERAL => Ok(EncodedTerm::DoubleLiteral(OrderedFloat(
self.read_f64::<LittleEndian>()?,
))),
TYPE_INTEGER_LITERAL => Ok(EncodedTerm::IntegerLiteral( TYPE_INTEGER_LITERAL => Ok(EncodedTerm::IntegerLiteral(
self.read_i64::<LittleEndian>()?, self.read_i64::<LittleEndian>()?,
)), )),
@ -956,17 +1056,11 @@ pub fn parse_boolean_str(value: &str) -> Option<EncodedTerm> {
} }
pub fn parse_float_str(value: &str) -> Option<EncodedTerm> { pub fn parse_float_str(value: &str) -> Option<EncodedTerm> {
value value.parse().map(EncodedTerm::FloatLiteral).ok()
.parse()
.map(|value| EncodedTerm::FloatLiteral(OrderedFloat(value)))
.ok()
} }
pub fn parse_double_str(value: &str) -> Option<EncodedTerm> { pub fn parse_double_str(value: &str) -> Option<EncodedTerm> {
value value.parse().map(EncodedTerm::DoubleLiteral).ok()
.parse()
.map(|value| EncodedTerm::DoubleLiteral(OrderedFloat(value)))
.ok()
} }
pub fn parse_integer_str(value: &str) -> Option<EncodedTerm> { pub fn parse_integer_str(value: &str) -> Option<EncodedTerm> {
@ -1089,8 +1183,8 @@ impl<S: StrLookup> Decoder for S {
) )
.into()), .into()),
EncodedTerm::BooleanLiteral(value) => Ok(Literal::from(value).into()), EncodedTerm::BooleanLiteral(value) => Ok(Literal::from(value).into()),
EncodedTerm::FloatLiteral(value) => Ok(Literal::from(*value).into()), EncodedTerm::FloatLiteral(value) => Ok(Literal::from(value).into()),
EncodedTerm::DoubleLiteral(value) => Ok(Literal::from(*value).into()), EncodedTerm::DoubleLiteral(value) => Ok(Literal::from(value).into()),
EncodedTerm::IntegerLiteral(value) => Ok(Literal::from(value).into()), EncodedTerm::IntegerLiteral(value) => Ok(Literal::from(value).into()),
EncodedTerm::DecimalLiteral(value) => Ok(Literal::from(value).into()), EncodedTerm::DecimalLiteral(value) => Ok(Literal::from(value).into()),
EncodedTerm::DateLiteral(value) => Ok(Literal::from(value).into()), EncodedTerm::DateLiteral(value) => Ok(Literal::from(value).into()),

Write Preview
Loading…
Cancel
Save