fluidB
/
fluidb
1
0
Fork 0
Code Pull Requests Activity

more types

Browse Source
main
Ziyang Hu 2 years ago
parent a58446bb10
commit c8fe31865b
2 changed files with 76 additions and 23 deletions
Show Stats Download Patch File Download Diff File

19
src/typing.rs
Unescape Escape View File

@ -8,7 +8,21 @@ pub enum PrimitiveType {
UInt,
Float,
String,
Bytes,
BitArr,
U8Arr,
I8Arr,
I16Arr,
U16Arr,
I32Arr,
U32Arr,
I64Arr,
U64Arr,
F16Arr,
F32Arr,
F64Arr,
C32Arr,
C64Arr,
C128Arr,
Uuid,
Timestamp,
Datetime,
@ -40,7 +54,8 @@ pub fn define_types<T: Env<Typing>>(env: &mut T) {
env.define("UInt", Typing::Primitive(PrimitiveType::UInt));
env.define("Float", Typing::Primitive(PrimitiveType::Float));
env.define("String", Typing::Primitive(PrimitiveType::String));
env.define("Bytes", Typing::Primitive(PrimitiveType::Bytes));
env.define("Bytes", Typing::Primitive(PrimitiveType::U8Arr));
env.define("U8Arr", Typing::Primitive(PrimitiveType::U8Arr));
env.define("Uuid", Typing::Primitive(PrimitiveType::Uuid));
env.define("Timestamp", Typing::Primitive(PrimitiveType::Timestamp));
env.define("Datetime", Typing::Primitive(PrimitiveType::Datetime));

80
src/value.rs
Unescape Escape View File

@ -7,7 +7,7 @@ use uuid::Uuid;
use crate::typing::Typing;
use Ordering::{Greater, Less, Equal};
// TODO: array types, alignment of values
#[repr(u8)]
#[derive(Ord, PartialOrd, Eq, PartialEq)]
pub enum ValueTag {
@ -31,7 +31,21 @@ pub enum ValueTag {
// BigDecimalTag = 53,
// InetTag = 55,
// CrsTag = 57,
// BytesTag = 99,
// BitArrTag = 60,
// U8ArrTag = 61,
// I8ArrTag = 62,
// U16ArrTag = 63,
// I16ArrTag = 64,
// U32ArrTag = 65,
// I32ArrTag = 66,
// U64ArrTag = 67,
// I64ArrTag = 68,
// F16ArrTag = 69,
// F32ArrTag = 70,
// F64ArrTag = 71,
// C32ArrTag = 72,
// C64ArrTag = 73,
// C128ArrTag = 74,
ListTag = 101,
DictTag = 103,
}
@ -122,7 +136,11 @@ impl<'a> ByteArrayParser<'a> {
#[inline]
pub fn compare_varint(&mut self, other: &mut Self) -> Ordering {
self.parse_varint().unwrap().cmp(&other.parse_varint().unwrap())
self.parse_varint().expect(
"Failed to parse VarInt when comparing"
).cmp(&other.parse_varint().expect(
"Failed to parse VarInt when comparing"
))
}
#[inline]
@ -137,7 +155,11 @@ impl<'a> ByteArrayParser<'a> {
#[inline]
pub fn compare_zigzag(&mut self, other: &mut Self) -> Ordering {
self.parse_zigzag().unwrap().cmp(&other.parse_zigzag().unwrap())
self.parse_zigzag().expect(
"Failed to parse ZigZag when comparing"
).cmp(&other.parse_zigzag().expect(
"Failed to parse ZigZag when comparing"
))
}
#[inline]
@ -153,14 +175,22 @@ impl<'a> ByteArrayParser<'a> {
#[inline]
pub fn compare_float(&mut self, other: &mut Self) -> Ordering {
OrderedFloat(self.parse_float().unwrap()).cmp(&OrderedFloat(other.parse_float().unwrap()))
OrderedFloat(self.parse_float().expect(
"Failed to parse Float when comparing"
)).cmp(&OrderedFloat(other.parse_float().expect(
"Failed to parse Float when comparing"
)))
}
// This should first compare UUID version, then for V1, compare the timestamps
#[inline]
pub fn compare_uuid(&mut self, other: &mut Self) -> Ordering {
let ua = self.parse_uuid().unwrap();
let ua = self.parse_uuid().expect(
"Failed to parse Uuid when comparing"
);
let (a3, a2, a1, a4) = ua.as_fields();
let ub = other.parse_uuid().unwrap();
let ub = other.parse_uuid().expect(
"Failed to parse Uuid when comparing"
);
let (b3, b2, b1, b4) = ub.as_fields();
if let x @ (Greater | Less) = a1.cmp(&b1) { return x; }
if let x @ (Greater | Less) = a2.cmp(&b2) { return x; }
@ -180,11 +210,11 @@ impl<'a> ByteArrayParser<'a> {
#[inline]
pub fn compare_string(&mut self, other: &mut Self) -> Ordering {
let len_a = self.parse_varint().unwrap();
let len_b = self.parse_varint().unwrap();
let len_a = self.parse_varint().expect("Failed to get String length when comparing");
let len_b = self.parse_varint().expect("Failed to get String length when comparing");
for _ in 0..min(len_a, len_b) {
let byte_a = self.advance(1).unwrap()[0];
let byte_b = other.advance(1).unwrap()[0];
let byte_a = self.advance(1).expect("Unexpected end of String when comparing")[0];
let byte_b = other.advance(1).expect("Unexpected end of String when comparing")[0];
if let x @ (Greater | Less) = byte_a.cmp(&byte_b) { return x; }
}
len_a.cmp(&len_b)
@ -241,8 +271,8 @@ impl<'a> ByteArrayParser<'a> {
}
}
pub fn compare_list(&mut self, other: &mut Self) -> Ordering {
let len_a = self.parse_varint().unwrap();
let len_b = self.parse_varint().unwrap();
let len_a = self.parse_varint().expect("Failed to get List length when comparing");
let len_b = self.parse_varint().expect("Failed to get List length when comparing");
for _ in 0..min(len_a, len_b) {
if let x @ (Greater | Less) = self.compare_value(other) { return x; }
}
@ -260,8 +290,8 @@ impl<'a> ByteArrayParser<'a> {
Some(ret)
}
pub fn compare_dict(&mut self, other: &mut Self) -> Ordering {
let len_a = self.parse_varint().unwrap();
let len_b = self.parse_varint().unwrap();
let len_a = self.parse_varint().expect("Failed to get Dict length when comparing");
let len_b = self.parse_varint().expect("Failed to get Dict length when comparing");
for _ in 0..min(len_a, len_b) {
if let x @ (Greater | Less) = self.compare_string(other) { return x; }
if let x @ (Greater | Less) = self.compare_value(other) { return x; }
@ -283,10 +313,14 @@ impl<T: Write> ByteArrayBuilder<T> {
pub fn build_varint(&mut self, u: u64) {
let mut u = u;
while u > 0b01111111 {
self.byte_writer.write_all(&[0b10000000 | (u as u8 & 0b01111111)]).unwrap();
self.byte_writer.write_all(&[0b10000000 | (u as u8 & 0b01111111)]).expect(
"Failed to write when building VarInt"
);
u >>= 7;
}
self.byte_writer.write_all(&[u as u8]).unwrap();
self.byte_writer.write_all(&[u as u8]).expect(
"Failed to write when building Varint"
);
}
#[inline]
@ -302,23 +336,27 @@ impl<T: Write> ByteArrayBuilder<T> {
#[inline]
pub fn build_float(&mut self, f: f64) {
self.byte_writer.write_all(&f.to_be_bytes()).unwrap();
self.byte_writer.write_all(&f.to_be_bytes()).expect(
"Failed to write when building Float"
);
}
#[inline]
pub fn build_uuid(&mut self, u: Uuid) {
self.byte_writer.write_all(u.as_bytes()).unwrap();
self.byte_writer.write_all(u.as_bytes()).expect(
"Failed to write when building Uuid"
);
}
#[inline]
pub fn build_string(&mut self, s: &str) {
self.build_varint(s.len() as u64);
self.byte_writer.write_all(s.as_bytes()).unwrap();
self.byte_writer.write_all(s.as_bytes()).expect("Failed to write when building String");
}
#[inline]
pub fn build_tag(&mut self, t: ValueTag) {
self.byte_writer.write_all(&[t as u8]).unwrap();
self.byte_writer.write_all(&[t as u8]).expect("Failed to write when building Tag");
}
pub fn build_value(&mut self, v: &Value) {

Write Preview
Loading…
Cancel
Save