surrealdb-core 3.2.2

A scalable, distributed, collaborative, document-graph database, for the realtime web
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use anyhow::Result;
use geo::algorithm::centroid::Centroid;
use geo::algorithm::chamberlain_duquette_area::ChamberlainDuquetteArea;
use geo::{Bearing, Distance, Haversine};

use crate::val::{Geometry, Value};

pub fn area((arg,): (Geometry,)) -> Result<Value> {
	match arg {
		Geometry::Point(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::Line(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::Polygon(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::MultiPoint(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::MultiLine(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::MultiPolygon(v) => Ok(v.chamberlain_duquette_unsigned_area().into()),
		Geometry::Collection(v) => Ok(v
			.into_iter()
			.collect::<geo::Geometry<f64>>()
			.chamberlain_duquette_unsigned_area()
			.into()),
	}
}

pub fn bearing((v, w): (Geometry, Geometry)) -> Result<Value> {
	Ok(match (v, w) {
		(Geometry::Point(v), Geometry::Point(w)) => {
			let bearing = Haversine.bearing(v, w);
			// Normalize bearing to [-180, 180] range for backward compatibility
			let normalized = if bearing > 180.0 {
				bearing - 360.0
			} else {
				bearing
			};
			normalized.into()
		}
		_ => Value::None,
	})
}

pub fn centroid((arg,): (Geometry,)) -> Result<Value> {
	let centroid = match arg {
		Geometry::Point(v) => Some(v.centroid()),
		Geometry::Line(v) => v.centroid(),
		Geometry::Polygon(v) => v.centroid(),
		Geometry::MultiPoint(v) => v.centroid(),
		Geometry::MultiLine(v) => v.centroid(),
		Geometry::MultiPolygon(v) => v.centroid(),
		Geometry::Collection(v) => v.into_iter().collect::<geo::Geometry<f64>>().centroid(),
	};
	Ok(centroid.map(Into::into).unwrap_or(Value::None))
}

pub fn distance((v, w): (Geometry, Geometry)) -> Result<Value> {
	Ok(match (v, w) {
		(Geometry::Point(v), Geometry::Point(w)) => Haversine.distance(v, w).into(),
		_ => Value::None,
	})
}

pub mod hash {

	use anyhow::{Result, bail};

	use crate::err::Error;
	use crate::fnc::args::Optional;
	use crate::fnc::util::geo;
	use crate::val::{Geometry, Value};

	pub fn encode((arg, Optional(len)): (Geometry, Optional<i64>)) -> Result<Value> {
		let len = match len {
			Some(len) if (1..=12).contains(&len) => len as usize,
			None => 12usize,
			_ => bail!(Error::InvalidFunctionArguments {
				name: String::from("geo::encode"),
				message: String::from(
					"The second argument must be an integer greater than 0 and less than or equal to 12."
				),
			}),
		};

		Ok(match arg {
			Geometry::Point(v) => geo::encode(v, len).into(),
			_ => Value::None,
		})
	}

	pub fn decode((arg,): (Value,)) -> Result<Value> {
		if let Some(s) = arg.as_strand() {
			Ok(geo::decode(s).into())
		} else {
			Ok(Value::None)
		}
	}
}

pub mod is {
	use anyhow::Result;

	use crate::val::{Geometry, Value};

	pub fn valid((arg,): (Geometry,)) -> Result<Value> {
		Ok(arg.is_valid().into())
	}
}