surrealdb-core 3.2.1

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

use std::sync::Arc;

use surrealdb_types::{SqlFormat, ToSql, write_sql};

use crate::exec::physical_expr::{EvalContext, PhysicalExpr};
use crate::exec::{AccessMode, BoxFut, CombineAccessModes};
use crate::expr::FlowResult;
use crate::val::Value;

/// IF/THEN/ELSE expression - IF condition THEN value ELSE other END
#[derive(Debug, Clone)]
pub struct IfElseExpr {
	/// List of (condition, value) pairs for IF and ELSE IF branches
	pub(crate) branches: Vec<(Arc<dyn PhysicalExpr>, Arc<dyn PhysicalExpr>)>,
	/// Optional ELSE branch (final fallback)
	pub(crate) otherwise: Option<Arc<dyn PhysicalExpr>>,
}
impl PhysicalExpr for IfElseExpr {
	fn name(&self) -> &'static str {
		"IfElse"
	}

	fn as_any(&self) -> &dyn std::any::Any {
		self
	}

	fn required_context(&self) -> crate::exec::ContextLevel {
		use crate::exec::ContextLevel;

		// Combine all branches' context requirements
		let branches_ctx = self
			.branches
			.iter()
			.flat_map(|(cond, val)| [cond.required_context(), val.required_context()])
			.max()
			.unwrap_or(ContextLevel::Root);

		let otherwise_ctx =
			self.otherwise.as_ref().map_or(ContextLevel::Root, |e| e.required_context());

		branches_ctx.max(otherwise_ctx)
	}

	fn evaluate<'a>(&'a self, ctx: EvalContext<'a>) -> BoxFut<'a, FlowResult<Value>> {
		Box::pin(async move {
			// Evaluate each condition in order
			for (condition, value) in &self.branches {
				let cond_result = condition.evaluate(ctx.clone()).await?;
				// Check if condition is truthy
				if cond_result.is_truthy() {
					return value.evaluate(ctx).await;
				}
			}

			// No condition was true, evaluate the else branch if present
			if let Some(otherwise) = &self.otherwise {
				otherwise.evaluate(ctx).await
			} else {
				// No else branch, return NONE
				Ok(Value::None)
			}
		})
	}

	fn access_mode(&self) -> AccessMode {
		// Combine all branches' access modes
		let branches_mode = self
			.branches
			.iter()
			.flat_map(|(cond, val)| [cond.access_mode(), val.access_mode()])
			.combine_all();

		let otherwise_mode =
			self.otherwise.as_ref().map_or(AccessMode::ReadOnly, |e| e.access_mode());

		branches_mode.combine(otherwise_mode)
	}
}

impl ToSql for IfElseExpr {
	fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
		for (i, (condition, value)) in self.branches.iter().enumerate() {
			if i == 0 {
				write_sql!(f, fmt, "IF {} THEN {}", condition, value);
			} else {
				write_sql!(f, fmt, " ELSE IF {} THEN {}", condition, value);
			}
		}
		if let Some(otherwise) = &self.otherwise {
			write_sql!(f, fmt, " ELSE {}", otherwise);
		}
		f.push_str(" END");
	}
}