surrealdb-sql 1.1.0

Full type definitions for the SurrealQL query language
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::err::Error;
use crate::index::SearchParams;
use crate::value::serde::ser;
use crate::{Ident, Scoring};
use ser::Serializer as _;
use serde::ser::Error as _;
use serde::ser::Impossible;
use serde::Serialize;

pub(super) struct Serializer;

impl ser::Serializer for Serializer {
	type Ok = SearchParams;
	type Error = Error;

	type SerializeSeq = Impossible<SearchParams, Error>;
	type SerializeTuple = Impossible<SearchParams, Error>;
	type SerializeTupleStruct = Impossible<SearchParams, Error>;
	type SerializeTupleVariant = Impossible<SearchParams, Error>;
	type SerializeMap = Impossible<SearchParams, Error>;
	type SerializeStruct = SerializeSearch;
	type SerializeStructVariant = Impossible<SearchParams, Error>;

	const EXPECTED: &'static str = "a struct `SearchParams`";

	#[inline]
	fn serialize_struct(
		self,
		_name: &'static str,
		_len: usize,
	) -> Result<Self::SerializeStruct, Error> {
		Ok(SerializeSearch::default())
	}

	#[inline]
	fn serialize_newtype_struct<T>(
		self,
		_name: &'static str,
		value: &T,
	) -> Result<Self::Ok, Self::Error>
	where
		T: ?Sized + Serialize,
	{
		value.serialize(self.wrap())
	}
}

#[derive(Default)]
pub(super) struct SerializeSearch {
	az: Ident,
	hl: bool,
	sc: Option<Scoring>,
	doc_ids_order: u32,
	doc_lengths_order: u32,
	postings_order: u32,
	terms_order: u32,
}

impl serde::ser::SerializeStruct for SerializeSearch {
	type Ok = SearchParams;
	type Error = Error;

	fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
	where
		T: ?Sized + Serialize,
	{
		match key {
			"az" => {
				self.az = Ident(value.serialize(ser::string::Serializer.wrap())?);
			}
			"hl" => {
				self.hl = value.serialize(ser::primitive::bool::Serializer.wrap())?;
			}
			"sc" => {
				self.sc = Some(value.serialize(ser::scoring::Serializer.wrap())?);
			}
			"doc_ids_order" => {
				self.doc_ids_order = value.serialize(ser::primitive::u32::Serializer.wrap())?;
			}
			"doc_lengths_order" => {
				self.doc_lengths_order = value.serialize(ser::primitive::u32::Serializer.wrap())?;
			}
			"postings_order" => {
				self.postings_order = value.serialize(ser::primitive::u32::Serializer.wrap())?;
			}
			"terms_order" => {
				self.terms_order = value.serialize(ser::primitive::u32::Serializer.wrap())?;
			}
			key => {
				return Err(Error::custom(format!("unexpected field `SearchParams {{ {key} }}`")));
			}
		}
		Ok(())
	}

	fn end(self) -> Result<Self::Ok, Error> {
		match self.sc {
			Some(sc) => Ok(SearchParams {
				az: self.az,
				hl: self.hl,
				sc,
				doc_ids_order: self.doc_ids_order,
				doc_lengths_order: self.doc_lengths_order,
				postings_order: self.postings_order,
				terms_order: self.terms_order,
			}),
			_ => Err(Error::custom("`SearchParams` missing required field(s)")),
		}
	}
}

#[test]
fn search_params() {
	let params = SearchParams {
		az: Default::default(),
		hl: false,
		sc: Scoring::Vs,
		doc_ids_order: 0,
		doc_lengths_order: 0,
		postings_order: 0,
		terms_order: 0,
	};
	let serialized = params.serialize(Serializer.wrap()).unwrap();
	assert_eq!(params, serialized);
}