Implement hashed implementation of Uniq<Array> (#1310)

lib/src/sql/algorithm.rs

@@ -5,7 +5,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Algorithm {
 	EdDSA,
 	Es256,

lib/src/sql/array.rs

@@ -15,12 +15,13 @@ use nom::character::complete::char;
 use nom::combinator::opt;
 use nom::multi::separated_list0;
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 use std::fmt::{self, Display, Formatter};
 use std::ops;
 use std::ops::Deref;
 use std::ops::DerefMut;
 
-#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Array(pub Vec<Value>);
 
 impl From<Value> for Array {
@@ -318,13 +319,16 @@ pub trait Uniq<T> {
 
 impl Uniq<Array> for Array {
 	fn uniq(mut self) -> Array {
-		for x in (0..self.len()).rev() {
+		let mut set: HashSet<&Value> = HashSet::new();
-			for y in (x + 1..self.len()).rev() {
+		let mut to_remove: Vec<usize> = Vec::new();
-				if self[x] == self[y] {
+		for (i, item) in self.iter().enumerate() {
-					self.remove(y);
+			if !set.insert(item) {
-				}
+				to_remove.push(i);
 			}
 		}
+		for i in to_remove.iter().rev() {
+			self.remove(*i);
+		}
 		self
 	}
 }
@@ -352,6 +356,16 @@ mod tests {
 
 	use super::*;
 
+	#[test]
+	fn array_empty() {
+		let sql = "[]";
+		let res = array(sql);
+		assert!(res.is_ok());
+		let out = res.unwrap().1;
+		assert_eq!("[]", format!("{}", out));
+		assert_eq!(out.0.len(), 0);
+	}
+
 	#[test]
 	fn array_normal() {
 		let sql = "[1,2,3]";
@@ -381,4 +395,14 @@ mod tests {
 		assert_eq!("[1, 2, 3 + 1]", format!("{}", out));
 		assert_eq!(out.0.len(), 3);
 	}
+
+	#[test]
+	fn array_fnc_uniq_normal() {
+		let sql = "[1,2,1,3,3,4]";
+		let res = array(sql);
+		assert!(res.is_ok());
+		let out = res.unwrap().1.uniq();
+		assert_eq!("[1, 2, 3, 4]", format!("{}", out));
+		assert_eq!(out.0.len(), 4);
+	}
 }

lib/src/sql/base.rs

@@ -7,7 +7,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Base {
 	Kv,
 	Ns,

lib/src/sql/cond.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Cond(pub Value);
 
 impl Deref for Cond {

lib/src/sql/constant.rs

@@ -12,7 +12,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize, Store)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize, Store, Hash)]
 pub enum Constant {
 	MathE,
 	MathFrac1Pi,

lib/src/sql/data.rs

@@ -18,7 +18,7 @@ use nom::multi::separated_list1;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Data {
 	EmptyExpression,
 	SetExpression(Vec<(Idiom, Operator, Value)>),

lib/src/sql/datetime.rs

@@ -14,7 +14,7 @@ use std::ops;
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Datetime(pub DateTime<Utc>);
 
 impl Default for Datetime {

lib/src/sql/dir.rs

@@ -4,7 +4,7 @@ use nom::character::complete::char;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Dir {
 	In,
 	Out,

lib/src/sql/duration.rs

@@ -20,7 +20,7 @@ static SECONDS_PER_DAY: u64 = 24 * SECONDS_PER_HOUR;
 static SECONDS_PER_HOUR: u64 = 60 * SECONDS_PER_MINUTE;
 static SECONDS_PER_MINUTE: u64 = 60;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Duration(pub time::Duration);
 
 impl From<time::Duration> for Duration {

lib/src/sql/edges.rs

@@ -9,7 +9,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Edges {
 	pub dir: Dir,
 	pub from: Thing,

lib/src/sql/expression.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::str;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Expression {
 	pub l: Value,
 	pub o: Operator,

lib/src/sql/fetch.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub struct Fetchs(pub Vec<Fetch>);
 
 impl Deref for Fetchs {
@@ -33,7 +33,7 @@ impl fmt::Display for Fetchs {
 	}
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub struct Fetch(pub Idiom);
 
 impl Deref for Fetch {

lib/src/sql/field.rs

@@ -16,7 +16,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter, Write};
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Fields(pub Vec<Field>);
 
 impl Fields {
@@ -191,7 +191,7 @@ pub fn fields(i: &str) -> IResult<&str, Fields> {
 	Ok((i, Fields(v)))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Field {
 	All,
 	Alone(Value),

lib/src/sql/function.rs

@@ -17,7 +17,7 @@ use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Function {
 	Future(Value),
 	Cast(String, Value),

lib/src/sql/geometry.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::derive_hash_xor_eq)]
+
 use crate::sql::comment::mightbespace;
 use crate::sql::common::commas;
 use crate::sql::error::IResult;
@@ -18,8 +20,8 @@ use nom::sequence::preceded;
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
-use std::fmt;
 use std::iter::FromIterator;
+use std::{fmt, hash};
 
 const SINGLE: char = '\'';
 const DOUBLE: char = '\"';
@@ -514,6 +516,73 @@ impl Serialize for Geometry {
 	}
 }
 
+impl hash::Hash for Geometry {
+	fn hash<H: hash::Hasher>(&self, state: &mut H) {
+		match self {
+			Geometry::Point(p) => {
+				"Point".hash(state);
+				p.x().to_bits().hash(state);
+				p.y().to_bits().hash(state);
+			}
+			Geometry::Line(l) => {
+				"Line".hash(state);
+				l.points().for_each(|v| {
+					v.x().to_bits().hash(state);
+					v.y().to_bits().hash(state);
+				});
+			}
+			Geometry::Polygon(p) => {
+				"Polygon".hash(state);
+				p.exterior().points().for_each(|ext| {
+					ext.x().to_bits().hash(state);
+					ext.y().to_bits().hash(state);
+				});
+				p.interiors().iter().for_each(|int| {
+					int.points().for_each(|v| {
+						v.x().to_bits().hash(state);
+						v.y().to_bits().hash(state);
+					});
+				});
+			}
+			Geometry::MultiPoint(v) => {
+				"MultiPoint".hash(state);
+				v.0.iter().for_each(|v| {
+					v.x().to_bits().hash(state);
+					v.y().to_bits().hash(state);
+				});
+			}
+			Geometry::MultiLine(ml) => {
+				"MultiLine".hash(state);
+				ml.0.iter().for_each(|ls| {
+					ls.points().for_each(|p| {
+						p.x().to_bits().hash(state);
+						p.y().to_bits().hash(state);
+					});
+				});
+			}
+			Geometry::MultiPolygon(mp) => {
+				"MultiPolygon".hash(state);
+				mp.0.iter().for_each(|p| {
+					p.exterior().points().for_each(|ext| {
+						ext.x().to_bits().hash(state);
+						ext.y().to_bits().hash(state);
+					});
+					p.interiors().iter().for_each(|int| {
+						int.points().for_each(|v| {
+							v.x().to_bits().hash(state);
+							v.y().to_bits().hash(state);
+						});
+					});
+				});
+			}
+			Geometry::Collection(v) => {
+				"GeometryCollection".hash(state);
+				v.iter().for_each(|v| v.hash(state));
+			}
+		}
+	}
+}
+
 pub fn geometry(i: &str) -> IResult<&str, Geometry> {
 	alt((simple, point, line, polygon, multipoint, multiline, multipolygon, collection))(i)
 }

lib/src/sql/graph.rs

@@ -13,7 +13,7 @@ use nom::combinator::opt;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter, Write};
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Graph {
 	pub dir: Dir,
 	pub what: Tables,

lib/src/sql/group.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Groups(pub Vec<Group>);
 
 impl Deref for Groups {
@@ -35,7 +35,7 @@ impl Display for Groups {
 	}
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Group(pub Idiom);
 
 impl Deref for Group {

lib/src/sql/id.rs

@@ -14,7 +14,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Id {
 	Number(i64),
 	String(String),

lib/src/sql/ident.rs

@@ -21,7 +21,7 @@ const BRACKET_END: &str = r#"⟩"#;
 const BACKTICK: &str = r#"`"#;
 const BACKTICK_ESC: &str = r#"\`"#;
 
-#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Ident(pub String);
 
 impl From<String> for Ident {

lib/src/sql/idiom.rs

@@ -19,7 +19,7 @@ use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Idioms(pub Vec<Idiom>);
 
 impl Deref for Idioms {
@@ -40,7 +40,7 @@ pub fn locals(i: &str) -> IResult<&str, Idioms> {
 	Ok((i, Idioms(v)))
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Idiom(pub Vec<Part>);
 
 impl Deref for Idiom {

lib/src/sql/kind.rs

@@ -11,7 +11,7 @@ use nom::multi::separated_list1;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Kind {
 	Any,
 	Array,

lib/src/sql/limit.rs

@@ -11,7 +11,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Limit(pub Value);
 
 impl Limit {

lib/src/sql/model.rs

@@ -44,7 +44,7 @@ impl Iterator for IntoIter {
 	}
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Model {
 	Count(String, u64),
 	Range(String, u64, u64),

lib/src/sql/number.rs

@@ -12,6 +12,7 @@ use nom::number::complete::recognize_float;
 use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::fmt::{self, Display, Formatter};
+use std::hash;
 use std::iter::Product;
 use std::iter::Sum;
 use std::ops;
@@ -386,6 +387,16 @@ impl Ord for Number {
 	}
 }
 
+impl hash::Hash for Number {
+	fn hash<H: hash::Hasher>(&self, state: &mut H) {
+		match self {
+			Number::Int(v) => v.hash(state),
+			Number::Float(v) => v.to_bits().hash(state),
+			Number::Decimal(v) => v.hash(state),
+		}
+	}
+}
+
 impl PartialEq for Number {
 	fn eq(&self, other: &Self) -> bool {
 		match (self, other) {

lib/src/sql/object.rs

@@ -26,7 +26,7 @@ use std::fmt;
 use std::ops::Deref;
 use std::ops::DerefMut;
 
-#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Object(pub BTreeMap<String, Value>);
 
 impl From<BTreeMap<String, Value>> for Object {

lib/src/sql/operation.rs

@@ -2,14 +2,14 @@ use crate::sql::idiom::Idiom;
 use crate::sql::value::Value;
 use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Operation {
 	pub op: Op,
 	pub path: Idiom,
 	pub value: Value,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Op {
 	None,
 	Add,

lib/src/sql/operator.rs

@@ -9,7 +9,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Operator {
 	Or,  // ||
 	And, // &&

lib/src/sql/order.rs

@@ -12,7 +12,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Orders(pub Vec<Order>);
 
 impl Deref for Orders {
@@ -36,7 +36,7 @@ impl fmt::Display for Orders {
 	}
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Order {
 	pub order: Idiom,
 	pub random: bool,

lib/src/sql/output.rs

@@ -7,7 +7,7 @@ use nom::combinator::map;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Output {
 	None,
 	Null,

lib/src/sql/param.rs

@@ -14,7 +14,7 @@ use std::fmt;
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Param(pub Idiom);
 
 impl From<Idiom> for Param {

lib/src/sql/part.rs

@@ -15,7 +15,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::str;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub enum Part {
 	All,
 	Last,

lib/src/sql/permission.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub struct Permissions {
 	pub select: Permission,
 	pub create: Permission,
@@ -131,7 +131,7 @@ fn specific(i: &str) -> IResult<&str, Permissions> {
 	))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Permission {
 	None,
 	Full,

lib/src/sql/query.rs

@@ -7,7 +7,7 @@ use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct Query(pub Statements);
 
 impl Deref for Query {

lib/src/sql/range.rs

@@ -5,7 +5,7 @@ use nom::character::complete::char;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Range {
 	pub tb: String,
 	pub beg: Id,

lib/src/sql/regex.rs

@@ -8,7 +8,7 @@ use std::fmt;
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Regex(String);
 
 impl From<&str> for Regex {

lib/src/sql/script.rs

@@ -23,7 +23,7 @@ const BACKTICK_ESC: &str = r#"\`"#;
 const OBJECT_BEG: &str = "{";
 const OBJECT_END: &str = "}";
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Script(pub String);
 
 impl From<String> for Script {

lib/src/sql/split.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Splits(pub Vec<Split>);
 
 impl Deref for Splits {
@@ -35,7 +35,7 @@ impl fmt::Display for Splits {
 	}
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Split(pub Idiom);
 
 impl Deref for Split {

lib/src/sql/start.rs

@@ -11,7 +11,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Start(pub Value);
 
 impl Start {

lib/src/sql/statement.rs

@@ -35,7 +35,7 @@ use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 use std::time::Duration;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub struct Statements(pub Vec<Statement>);
 
 impl Deref for Statements {
@@ -60,7 +60,7 @@ pub fn statements(i: &str) -> IResult<&str, Statements> {
 	Ok((i, Statements(v)))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Statement {
 	Use(UseStatement),
 	Set(SetStatement),

lib/src/sql/statements/begin.rs

@@ -8,7 +8,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct BeginStatement;
 
 impl fmt::Display for BeginStatement {

lib/src/sql/statements/cancel.rs

@@ -8,7 +8,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct CancelStatement;
 
 impl fmt::Display for CancelStatement {

lib/src/sql/statements/commit.rs

@@ -8,7 +8,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct CommitStatement;
 
 impl fmt::Display for CommitStatement {

lib/src/sql/statements/create.rs

@@ -19,7 +19,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct CreateStatement {
 	pub what: Values,
 	pub data: Option<Data>,

lib/src/sql/statements/define.rs

@@ -33,7 +33,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::fmt::Display;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub enum DefineStatement {
 	Namespace(DefineNamespaceStatement),
 	Database(DefineDatabaseStatement),
@@ -102,7 +102,7 @@ pub fn define(i: &str) -> IResult<&str, DefineStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineNamespaceStatement {
 	pub name: Ident,
 }
@@ -151,7 +151,7 @@ fn namespace(i: &str) -> IResult<&str, DefineNamespaceStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineDatabaseStatement {
 	pub name: Ident,
 }
@@ -205,7 +205,7 @@ fn database(i: &str) -> IResult<&str, DefineDatabaseStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineLoginStatement {
 	pub name: Ident,
 	pub base: Base,
@@ -328,7 +328,7 @@ fn login_hash(i: &str) -> IResult<&str, DefineLoginOption> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineTokenStatement {
 	pub name: Ident,
 	pub base: Base,
@@ -447,7 +447,7 @@ fn token(i: &str) -> IResult<&str, DefineTokenStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineScopeStatement {
 	pub name: Ident,
 	pub code: String,
@@ -530,7 +530,7 @@ fn scope(i: &str) -> IResult<&str, DefineScopeStatement> {
 	))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum DefineScopeOption {
 	Session(Duration),
 	Signup(Value),
@@ -569,7 +569,7 @@ fn scope_signin(i: &str) -> IResult<&str, DefineScopeOption> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineTableStatement {
 	pub name: Ident,
 	pub drop: bool,
@@ -698,7 +698,7 @@ fn table(i: &str) -> IResult<&str, DefineTableStatement> {
 	))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum DefineTableOption {
 	Drop,
 	View(View),
@@ -745,7 +745,7 @@ fn table_permissions(i: &str) -> IResult<&str, DefineTableOption> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineEventStatement {
 	pub name: Ident,
 	pub what: Ident,
@@ -824,7 +824,7 @@ fn event(i: &str) -> IResult<&str, DefineEventStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineFieldStatement {
 	pub name: Idiom,
 	pub what: Ident,
@@ -920,7 +920,7 @@ fn field(i: &str) -> IResult<&str, DefineFieldStatement> {
 	))
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum DefineFieldOption {
 	Kind(Kind),
 	Value(Value),
@@ -966,7 +966,7 @@ fn field_permissions(i: &str) -> IResult<&str, DefineFieldOption> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DefineIndexStatement {
 	pub name: Ident,
 	pub what: Ident,

lib/src/sql/statements/delete.rs

@@ -20,7 +20,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct DeleteStatement {
 	pub what: Values,
 	pub cond: Option<Cond>,

lib/src/sql/statements/ifelse.rs

@@ -12,7 +12,7 @@ use nom::multi::separated_list0;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct IfelseStatement {
 	pub exprs: Vec<(Value, Value)>,
 	pub close: Option<Value>,

lib/src/sql/statements/info.rs

@@ -14,7 +14,7 @@ use nom::bytes::complete::tag_no_case;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub enum InfoStatement {
 	Kv,
 	Ns,

lib/src/sql/statements/insert.rs

@@ -21,7 +21,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct InsertStatement {
 	pub into: Table,
 	pub data: Data,

lib/src/sql/statements/kill.rs

@@ -12,7 +12,7 @@ use nom::bytes::complete::tag_no_case;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct KillStatement {
 	pub id: Uuid,
 }

lib/src/sql/statements/live.rs

@@ -21,7 +21,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct LiveStatement {
 	pub id: Uuid,
 	pub expr: Fields,

lib/src/sql/statements/option.rs

@@ -11,7 +11,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct OptionStatement {
 	pub name: Ident,
 	pub what: bool,

lib/src/sql/statements/output.rs

@@ -13,7 +13,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct OutputStatement {
 	pub what: Value,
 	pub fetch: Option<Fetchs>,

lib/src/sql/statements/relate.rs

@@ -28,7 +28,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RelateStatement {
 	pub kind: Table,
 	pub from: Value,

lib/src/sql/statements/remove.rs

@@ -18,7 +18,7 @@ use nom::sequence::tuple;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub enum RemoveStatement {
 	Namespace(RemoveNamespaceStatement),
 	Database(RemoveDatabaseStatement),
@@ -87,7 +87,7 @@ pub fn remove(i: &str) -> IResult<&str, RemoveStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveNamespaceStatement {
 	pub name: Ident,
 }
@@ -143,7 +143,7 @@ fn namespace(i: &str) -> IResult<&str, RemoveNamespaceStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveDatabaseStatement {
 	pub name: Ident,
 }
@@ -199,7 +199,7 @@ fn database(i: &str) -> IResult<&str, RemoveDatabaseStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveLoginStatement {
 	pub name: Ident,
 	pub base: Base,
@@ -278,7 +278,7 @@ fn login(i: &str) -> IResult<&str, RemoveLoginStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveTokenStatement {
 	pub name: Ident,
 	pub base: Base,
@@ -372,7 +372,7 @@ fn token(i: &str) -> IResult<&str, RemoveTokenStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveScopeStatement {
 	pub name: Ident,
 }
@@ -428,7 +428,7 @@ fn scope(i: &str) -> IResult<&str, RemoveScopeStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveTableStatement {
 	pub name: Ident,
 }
@@ -484,7 +484,7 @@ fn table(i: &str) -> IResult<&str, RemoveTableStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveEventStatement {
 	pub name: Ident,
 	pub what: Ident,
@@ -544,7 +544,7 @@ fn event(i: &str) -> IResult<&str, RemoveEventStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveFieldStatement {
 	pub name: Idiom,
 	pub what: Ident,
@@ -604,7 +604,7 @@ fn field(i: &str) -> IResult<&str, RemoveFieldStatement> {
 // --------------------------------------------------
 // --------------------------------------------------
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct RemoveIndexStatement {
 	pub name: Ident,
 	pub what: Ident,

lib/src/sql/statements/select.rs

@@ -26,7 +26,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct SelectStatement {
 	pub expr: Fields,
 	pub what: Values,

lib/src/sql/statements/set.rs

@@ -14,7 +14,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct SetStatement {
 	pub name: String,
 	pub what: Value,

lib/src/sql/statements/update.rs

@@ -20,7 +20,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct UpdateStatement {
 	pub what: Values,
 	pub data: Option<Data>,

lib/src/sql/statements/yuse.rs

@@ -7,7 +7,7 @@ use nom::bytes::complete::tag_no_case;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Store, Hash)]
 pub struct UseStatement {
 	pub ns: Option<String>,
 	pub db: Option<String>,

lib/src/sql/strand.rs

@@ -21,7 +21,7 @@ const SINGLE_ESC: &str = r#"\'"#;
 const DOUBLE: char = '"';
 const DOUBLE_ESC: &str = r#"\""#;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Strand(pub String);
 
 impl From<String> for Strand {

lib/src/sql/subquery.rs

@@ -20,7 +20,7 @@ use serde::{Deserialize, Serialize};
 use std::cmp::Ordering;
 use std::fmt::{self, Display, Formatter};
 
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub enum Subquery {
 	Value(Value),
 	Ifelse(IfelseStatement),

lib/src/sql/table.rs

@@ -11,7 +11,7 @@ use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Tables(pub Vec<Table>);
 
 impl From<Table> for Tables {
@@ -38,7 +38,7 @@ pub fn tables(i: &str) -> IResult<&str, Tables> {
 	Ok((i, Tables(v)))
 }
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Table(pub String);
 
 impl From<String> for Table {

lib/src/sql/thing.rs

@@ -16,7 +16,7 @@ use serde::ser::SerializeStruct;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize, Store)]
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Deserialize, Store, Hash)]
 pub struct Thing {
 	pub tb: String,
 	pub id: Id,

lib/src/sql/timeout.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Deref;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Timeout(pub Duration);
 
 impl Deref for Timeout {

lib/src/sql/uuid.rs

@@ -13,7 +13,7 @@ use std::fmt::{self, Display, Formatter};
 use std::ops::Deref;
 use std::str;
 
-#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, Ord, PartialEq, PartialOrd, Deserialize, Hash)]
 pub struct Uuid(pub uuid::Uuid);
 
 impl From<&str> for Uuid {

lib/src/sql/value/value.rs

@@ -55,7 +55,7 @@ use std::str::FromStr;
 
 static MATCHER: Lazy<SkimMatcherV2> = Lazy::new(|| SkimMatcherV2::default().ignore_case());
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize, Hash)]
 pub struct Values(pub Vec<Value>);
 
 impl Deref for Values {
@@ -94,7 +94,7 @@ pub fn whats(i: &str) -> IResult<&str, Values> {
 	Ok((i, Values(v)))
 }
 
-#[derive(Clone, Debug, PartialEq, PartialOrd, Deserialize, Store)]
+#[derive(Clone, Debug, PartialEq, PartialOrd, Deserialize, Store, Hash)]
 pub enum Value {
 	None,
 	Null,

lib/src/sql/version.rs

@@ -5,7 +5,7 @@ use nom::bytes::complete::tag_no_case;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct Version(pub Datetime);
 
 impl fmt::Display for Version {

lib/src/sql/view.rs

@@ -10,7 +10,7 @@ use nom::sequence::preceded;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 
-#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Eq, PartialEq, PartialOrd, Serialize, Deserialize, Hash)]
 pub struct View {
 	pub expr: Fields,
 	pub what: Tables,

lib/tests/function.rs

@@ -0,0 +1,38 @@
+mod parse;
+use parse::Parse;
+use surrealdb::sql::Value;
+use surrealdb::Datastore;
+use surrealdb::Error;
+use surrealdb::Session;
+
+#[tokio::test]
+async fn array_distinct() -> Result<(), Error> {
+	let sql = r#"
+		SELECT * FROM array::distinct([1, 3, 2, 1, 3, 3, 4]);
+		SELECT * FROM array::distinct([]);
+		SELECT * FROM array::distinct("something");
+		SELECT * FROM array::distinct(["something"]);
+	"#;
+	let dbs = Datastore::new("memory").await?;
+	let ses = Session::for_kv().with_ns("test").with_db("test");
+	let res = &mut dbs.execute(&sql, &ses, None, false).await?;
+	assert_eq!(res.len(), 4);
+	//
+	let tmp = res.remove(0).result?;
+	let val = Value::parse("[1, 3, 2, 4]");
+	assert_eq!(tmp, val);
+	//
+	let tmp = res.remove(0).result?;
+	let val = Value::parse("[]");
+	assert_eq!(tmp, val);
+	//
+	let tmp = res.remove(0).result?;
+	let val = Value::parse("[NONE]");
+	assert_eq!(tmp, val);
+	//
+	let tmp = res.remove(0).result?;
+	let val = Value::parse("['something']");
+	assert_eq!(tmp, val);
+	//
+	Ok(())
+}