Skip to main content

surql_parser/upstream/sql/
data.rs

1use crate::upstream::fmt::CoverStmts;
2use crate::upstream::sql::{AssignOperator, Expr, Idiom};
3use surrealdb_types::{SqlFormat, ToSql, write_sql};
4#[derive(Clone, Debug, Default, PartialEq, Eq)]
5#[allow(clippy::enum_variant_names)]
6pub enum Data {
7	#[default]
8	EmptyExpression,
9	SetExpression(Vec<Assignment>),
10	UnsetExpression(Vec<Idiom>),
11	PatchExpression(Expr),
12	MergeExpression(Expr),
13	ReplaceExpression(Expr),
14	ContentExpression(Expr),
15	SingleExpression(Expr),
16	ValuesExpression(Vec<Vec<(Idiom, Expr)>>),
17	UpdateExpression(Vec<Assignment>),
18}
19#[derive(Clone, Debug, PartialEq, Eq)]
20#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
21pub struct Assignment {
22	#[cfg_attr(
23        feature = "arbitrary",
24        arbitrary(with = crate::upstream::sql::arbitrary::plain_idiom)
25    )]
26	pub place: Idiom,
27	pub operator: AssignOperator,
28	pub value: Expr,
29}
30impl ToSql for Data {
31	fn fmt_sql(&self, f: &mut String, sql_fmt: SqlFormat) {
32		match self {
33			Self::EmptyExpression => {}
34			Self::SetExpression(v) => {
35				f.push_str("SET ");
36				for (i, arg) in v.iter().enumerate() {
37					if i > 0 {
38						f.push_str(", ");
39					}
40					write_sql!(f, sql_fmt, "{} {} ", arg.place, arg.operator);
41					CoverStmts(&arg.value).fmt_sql(f, sql_fmt);
42				}
43			}
44			Self::UnsetExpression(v) => {
45				f.push_str("UNSET ");
46				for (i, idiom) in v.iter().enumerate() {
47					if i > 0 {
48						f.push_str(", ");
49					}
50					write_sql!(f, sql_fmt, "{}", idiom);
51				}
52			}
53			Self::PatchExpression(v) => {
54				write_sql!(f, sql_fmt, "PATCH {v}");
55			}
56			Self::MergeExpression(v) => {
57				write_sql!(f, sql_fmt, "MERGE {v}");
58			}
59			Self::ReplaceExpression(v) => {
60				write_sql!(f, sql_fmt, "REPLACE {v}");
61			}
62			Self::ContentExpression(v) => {
63				write_sql!(f, sql_fmt, "CONTENT {v}");
64			}
65			Self::SingleExpression(v) => CoverStmts(v).fmt_sql(f, sql_fmt),
66			Self::ValuesExpression(v) => {
67				f.push('(');
68				if let Some(first) = v.first() {
69					for (i, (idiom, _)) in first.iter().enumerate() {
70						if i > 0 {
71							f.push_str(", ");
72						}
73						write_sql!(f, sql_fmt, "{idiom}");
74					}
75				}
76				f.push_str(") VALUES ");
77				for (i, row) in v.iter().enumerate() {
78					if i > 0 {
79						f.push_str(", ");
80					}
81					f.push('(');
82					for (j, (_, expr)) in row.iter().enumerate() {
83						if j > 0 {
84							f.push_str(", ");
85						}
86						CoverStmts(expr).fmt_sql(f, sql_fmt);
87					}
88					f.push(')');
89				}
90			}
91			Self::UpdateExpression(v) => {
92				f.push_str("ON DUPLICATE KEY UPDATE ");
93				for (i, arg) in v.iter().enumerate() {
94					if i > 0 {
95						f.push_str(", ");
96					}
97					write_sql!(f, sql_fmt, "{} {} ", arg.place, arg.operator);
98					CoverStmts(&arg.value).fmt_sql(f, sql_fmt);
99				}
100			}
101		}
102	}
103}