criterium 3.1.3

Lightweigt dynamic database queries for rusqlite.
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

// SPDX-FileCopyrightText: 2025 Slatian
//
// SPDX-License-Identifier: LGPL-3.0-only

//! Matches against textual values.

pub mod direct_match;

#[cfg(feature = "rusqlite")]
pub mod rusqlite;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

use crate::NumberCriterium;

/// The StringCriterium describes a set of comparisons that
/// can be made against a textual field.
///
/// No automatic type conversion will happen.
///
/// If the field is some form of null, undefined or unset
/// only the IsNone condition is allowed to match.
#[derive(Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]
pub enum StringCriterium {
	/// The field is equal to the given string (`f == s`).
	Equals(String),

	/// The field starts with the given string (`f.starts_with(s)`).
	HasPrefix(String),

	/// The field ends with the given string (`f.ends_with(s)`).
	HasSuffix(String),

	/// The field contains the given string (`f.contains(s)`).
	Contains(String),

	/// Matches the length of the string in characters (unicode codepoints).
	Length(NumberCriterium<usize>),

	/// The field has no value.
	IsNone,
}

// Conversion implementations

impl From<String> for StringCriterium {
	/// Converts any String to a `StringCriterium` with an `Equals` condition.
	fn from(string: String) -> Self {
		Self::Equals(string)
	}
}

impl From<Option<String>> for StringCriterium {
	/// Converts `Some(String)` to a `StringCriterium` with an `Equals` condition.
	/// If `None` is passed, the `IsNone` condition will be used.
	fn from(string_opt: Option<String>) -> Self {
		match string_opt {
			Some(s) => s.into(),
			None => Self::IsNone,
		}
	}
}

impl From<&str> for StringCriterium {
	/// Converts any `&str` to a `StringCriterium` with an `Equals` condition.
	fn from(string: &str) -> Self {
		Self::Equals(string.to_string())
	}
}

impl From<Option<&str>> for StringCriterium {
	/// Converts `Some(String)` to a `StringCriterium` with an `Equals` condition.
	/// If `None` is passed, the `IsNone` condition will be used.
	fn from(string_opt: Option<&str>) -> Self {
		match string_opt {
			Some(s) => s.into(),
			None => Self::IsNone,
		}
	}
}

#[cfg(test)]
mod test {
	use super::*;
	use crate::direct_match::DirectMatch;

	#[test]
	fn direct_match_string_equal() {
		let c_empty = StringCriterium::Equals("".to_string());
		let str_opt_none: Option<&str> = None;
		assert!(c_empty.criterium_match(""));
		assert!(c_empty.criterium_match(&("".to_string())));
		assert!(!c_empty.criterium_match("test"));
		assert!(!c_empty.criterium_match(&("test".to_string())));
		assert!(!c_empty.criterium_match(&str_opt_none));
		assert!(!c_empty.criterium_match(&(" ".to_string())));

		let c_none = StringCriterium::IsNone;
		assert!(!c_none.criterium_match(""));
		assert!(!c_none.criterium_match(&("".to_string())));
		assert!(!c_none.criterium_match("test"));
		assert!(!c_none.criterium_match(&("test".to_string())));
		assert!(c_none.criterium_match(&str_opt_none));
		assert!(!c_none.criterium_match(&(" ".to_string())));

		let c_test = StringCriterium::Equals("test".to_string());
		assert!(!c_test.criterium_match(""));
		assert!(!c_test.criterium_match(&("".to_string())));
		assert!(c_test.criterium_match("test"));
		assert!(c_test.criterium_match(&("test".to_string())));
		assert!(!c_test.criterium_match(&str_opt_none));
		assert!(!c_test.criterium_match(&(" ".to_string())));
	}

	#[test]
	fn direct_match_string_substring() {
		let c_prefix = StringCriterium::HasPrefix("foo".to_string());
		assert!(c_prefix.criterium_match("foo"));
		assert!(c_prefix.criterium_match("foo_"));
		assert!(!c_prefix.criterium_match("_foo"));
		assert!(!c_prefix.criterium_match("fo_foo_"));
		assert!(!c_prefix.criterium_match(""));
		let c_suffix = StringCriterium::HasSuffix("foo".to_string());
		assert!(c_suffix.criterium_match("foo"));
		assert!(!c_suffix.criterium_match("foo_"));
		assert!(c_suffix.criterium_match("blafoo"));
		assert!(!c_suffix.criterium_match("_foo_"));
		assert!(!c_suffix.criterium_match(""));
		let c_contains = StringCriterium::Contains("foo".to_string());
		assert!(c_contains.criterium_match("foo"));
		assert!(c_contains.criterium_match("foo_"));
		assert!(c_contains.criterium_match("_foo"));
		assert!(c_contains.criterium_match("_foo_"));
		assert!(!c_contains.criterium_match("_bar_"));
		assert!(!c_contains.criterium_match(""));
	}
}