surrealdb-core 3.2.0

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
105

use anyhow::Result;

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

pub fn days((val,): (Duration,)) -> Result<Value> {
	Ok(val.days().into())
}

pub fn hours((val,): (Duration,)) -> Result<Value> {
	Ok(val.hours().into())
}

pub fn micros((val,): (Duration,)) -> Result<Value> {
	Ok(Value::try_from(val.micros())?)
}

pub fn millis((val,): (Duration,)) -> Result<Value> {
	Ok(Value::try_from(val.millis())?)
}

pub fn mins((val,): (Duration,)) -> Result<Value> {
	Ok(val.mins().into())
}

pub fn nanos((val,): (Duration,)) -> Result<Value> {
	Ok(Value::try_from(val.nanos())?)
}

pub fn secs((val,): (Duration,)) -> Result<Value> {
	Ok(val.secs().into())
}

pub fn weeks((val,): (Duration,)) -> Result<Value> {
	Ok(val.weeks().into())
}

pub fn years((val,): (Duration,)) -> Result<Value> {
	Ok(val.years().into())
}

pub mod from {

	use anyhow::Result;

	use crate::err::Error;
	use crate::val::{Duration, Value};

	fn to_unsigned(name: &str, val: i64) -> Result<u64> {
		u64::try_from(val).map_err(|_| {
			anyhow::Error::new(Error::ArithmeticNegativeOverflow(format!("{name}({val})")))
		})
	}

	pub fn days((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_days", val)?;
		Duration::from_days(n)
			.map(|x| x.into())
			.ok_or_else(|| Error::ArithmeticOverflow(format!("duration::from_days({n})")))
			.map_err(anyhow::Error::new)
	}

	pub fn hours((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_hours", val)?;
		Duration::from_hours(n)
			.map(|x| x.into())
			.ok_or_else(|| Error::ArithmeticOverflow(format!("duration::from_hours({n})")))
			.map_err(anyhow::Error::new)
	}

	pub fn micros((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_micros", val)?;
		Ok(Duration::from_micros(n).into())
	}

	pub fn millis((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_millis", val)?;
		Ok(Duration::from_millis(n).into())
	}

	pub fn mins((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_mins", val)?;
		Duration::from_mins(n)
			.map(|x| x.into())
			.ok_or_else(|| Error::ArithmeticOverflow(format!("duration::from_mins({n})")))
			.map_err(anyhow::Error::new)
	}

	pub fn nanos((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_nanos", val)?;
		Ok(Duration::from_nanos(n).into())
	}

	pub fn secs((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_secs", val)?;
		Ok(Duration::from_secs(n).into())
	}

	pub fn weeks((val,): (i64,)) -> Result<Value> {
		let n = to_unsigned("duration::from_weeks", val)?;
		Duration::from_weeks(n)
			.map(|x| x.into())
			.ok_or_else(|| Error::ArithmeticOverflow(format!("duration::from_weeks({n})")))
			.map_err(anyhow::Error::new)
	}
}