1use {
2 crate::*,
3 gluesql_core::{
4 error::{EvaluateError, TranslateError},
5 prelude::{
6 Payload,
7 Value::{self, *},
8 },
9 },
10};
11
12test_case!(sin, {
13 let g = get_tester!();
14
15 let test_cases = [
16 (
17 "SELECT SIN(0.5) AS sin1, SIN(1) AS sin2",
18 Ok(select!(
19 "sin1" | "sin2"
20 F64 | F64;
21 0.5_f64.sin() 1.0_f64.sin()
22 )),
23 ),
24 (
25 "SELECT SIN(null) AS sin",
26 Ok(select_with_null!(sin; Value::Null)),
27 ),
28 (
29 "SELECT SIN(true) AS sin",
30 Err(EvaluateError::FunctionRequiresFloatValue("SIN".to_owned()).into()),
31 ),
32 (
33 "SELECT SIN(false) AS sin",
34 Err(EvaluateError::FunctionRequiresFloatValue("SIN".to_owned()).into()),
35 ),
36 (
37 "SELECT SIN('string') AS sin",
38 Err(EvaluateError::FunctionRequiresFloatValue("SIN".to_owned()).into()),
39 ),
40 (
41 "SELECT SIN() AS sin",
42 Err(TranslateError::FunctionArgsLengthNotMatching {
43 name: "SIN".to_owned(),
44 expected: 1,
45 found: 0,
46 }
47 .into()),
48 ),
49 (
50 "SELECT SIN(1.0, 2.0) AS sin",
51 Err(TranslateError::FunctionArgsLengthNotMatching {
52 name: "SIN".to_owned(),
53 expected: 1,
54 found: 2,
55 }
56 .into()),
57 ),
58 ];
59
60 for (sql, expected) in test_cases {
61 g.test(sql, expected).await;
62 }
63});
64
65test_case!(cos, {
66 let g = get_tester!();
67
68 let test_cases = [
69 (
70 "SELECT COS(0.5) AS cos1, COS(1) AS cos2",
71 Ok(select!(
72 "cos1" | "cos2"
73 F64 | F64;
74 0.5_f64.cos() 1.0_f64.cos()
75 )),
76 ),
77 (
78 "SELECT COS(null) AS cos",
79 Ok(select_with_null!(cos; Value::Null)),
80 ),
81 (
82 "SELECT COS(true) AS cos",
83 Err(EvaluateError::FunctionRequiresFloatValue("COS".to_owned()).into()),
84 ),
85 (
86 "SELECT COS(false) AS cos",
87 Err(EvaluateError::FunctionRequiresFloatValue("COS".to_owned()).into()),
88 ),
89 (
90 "SELECT COS('string') AS cos",
91 Err(EvaluateError::FunctionRequiresFloatValue("COS".to_owned()).into()),
92 ),
93 (
94 "SELECT COS() AS cos",
95 Err(TranslateError::FunctionArgsLengthNotMatching {
96 name: "COS".to_owned(),
97 expected: 1,
98 found: 0,
99 }
100 .into()),
101 ),
102 (
103 "SELECT COS(1.0, 2.0) AS cos",
104 Err(TranslateError::FunctionArgsLengthNotMatching {
105 name: "COS".to_owned(),
106 expected: 1,
107 found: 2,
108 }
109 .into()),
110 ),
111 ];
112
113 for (sql, expected) in test_cases {
114 g.test(sql, expected).await;
115 }
116});
117
118test_case!(tan, {
119 let g = get_tester!();
120
121 let test_cases = [
122 (
123 "SELECT TAN(0.5) AS tan1, TAN(1) AS tan2",
124 Ok(select!(
125 "tan1" | "tan2"
126 F64 | F64;
127 0.5_f64.tan() 1.0_f64.tan()
128 )),
129 ),
130 (
131 "SELECT TAN(null) AS tan",
132 Ok(select_with_null!(tan; Value::Null)),
133 ),
134 (
135 "SELECT TAN(true) AS tan",
136 Err(EvaluateError::FunctionRequiresFloatValue("TAN".to_owned()).into()),
137 ),
138 (
139 "SELECT TAN(false) AS tan",
140 Err(EvaluateError::FunctionRequiresFloatValue("TAN".to_owned()).into()),
141 ),
142 (
143 "SELECT TAN('string') AS tan",
144 Err(EvaluateError::FunctionRequiresFloatValue("TAN".to_owned()).into()),
145 ),
146 (
147 "SELECT TAN() AS tan",
148 Err(TranslateError::FunctionArgsLengthNotMatching {
149 name: "TAN".to_owned(),
150 expected: 1,
151 found: 0,
152 }
153 .into()),
154 ),
155 (
156 "SELECT TAN(1.0, 2.0) AS tan",
157 Err(TranslateError::FunctionArgsLengthNotMatching {
158 name: "TAN".to_owned(),
159 expected: 1,
160 found: 2,
161 }
162 .into()),
163 ),
164 ];
165
166 for (sql, expected) in test_cases {
167 g.test(sql, expected).await;
168 }
169});
170
171test_case!(asin, {
172 let g = get_tester!();
173
174 let test_cases = [
175 (
176 "SELECT ASIN(0.5) AS asin1, ASIN(1) AS asin2",
177 Ok(select!(
178 "asin1" | "asin2"
179 F64 | F64;
180 0.5_f64.asin() 1.0_f64.asin()
181 )),
182 ),
183 (
184 "SELECT ASIN('string') AS asin",
185 Err(EvaluateError::FunctionRequiresFloatValue("ASIN".to_owned()).into()),
186 ),
187 (
188 "SELECT ASIN(null) AS asin",
189 Ok(select_with_null!(asin; Null)),
190 ),
191 (
192 "SELECT ASIN() AS asin",
193 Err(TranslateError::FunctionArgsLengthNotMatching {
194 name: "ASIN".to_owned(),
195 expected: 1,
196 found: 0,
197 }
198 .into()),
199 ),
200 (
201 "SELECT ASIN(1.0, 2.0) AS sin",
202 Err(TranslateError::FunctionArgsLengthNotMatching {
203 name: "ASIN".to_owned(),
204 expected: 1,
205 found: 2,
206 }
207 .into()),
208 ),
209 ];
210
211 for (sql, expected) in test_cases {
212 g.test(sql, expected).await;
213 }
214});
215
216test_case!(acos, {
217 let g = get_tester!();
218
219 let test_cases = [
220 (
221 "SELECT ACOS(0.5) AS acos1, ACOS(1) AS acos2",
222 Ok(select!(
223 "acos1" | "acos2";
224 F64 | F64 ;
225 0.5_f64.acos() 1.0_f64.acos()
226 )),
227 ),
228 (
229 "SELECT ACOS('string') AS acos",
230 Err(EvaluateError::FunctionRequiresFloatValue("ACOS".to_owned()).into()),
231 ),
232 (
233 "SELECT ACOS(null) AS acos",
234 Ok(select_with_null!(acos; Null)),
235 ),
236 (
237 "SELECT ACOS(true) AS acos",
238 Err(EvaluateError::FunctionRequiresFloatValue("ACOS".to_owned()).into()),
239 ),
240 (
241 "SELECT ACOS() AS acos",
242 Err(TranslateError::FunctionArgsLengthNotMatching {
243 name: "ACOS".to_owned(),
244 expected: 1,
245 found: 0,
246 }
247 .into()),
248 ),
249 (
250 "SELECT ACOS(1.0, 2.0) AS acos",
251 Err(TranslateError::FunctionArgsLengthNotMatching {
252 name: "ACOS".to_owned(),
253 expected: 1,
254 found: 2,
255 }
256 .into()),
257 ),
258 ];
259
260 for (sql, expected) in test_cases {
261 g.test(sql, expected).await;
262 }
263});
264
265test_case!(atan, {
266 let g = get_tester!();
267
268 let test_cases = [
269 (
270 "CREATE TABLE SingleItem (id INTEGER DEFAULT ATAN(3.14))",
271 Ok(Payload::Create),
272 ),
273 (r"INSERT INTO SingleItem VALUES (0)", Ok(Payload::Insert(1))),
274 (
275 "SELECT ATAN(0.5) AS atan1, ATAN(1) AS atan2",
276 Ok(select!(
277 "atan1" | "atan2";
278 F64 | F64 ;
279 0.5_f64.atan() 1.0_f64.atan()
280 )),
281 ),
282 (
283 "SELECT ATAN('string') AS atan",
284 Err(EvaluateError::FunctionRequiresFloatValue("ATAN".to_owned()).into()),
285 ),
286 (
287 "SELECT ATAN(null) AS atan",
288 Ok(select_with_null!(atan; Null)),
289 ),
290 (
291 "SELECT ATAN(true) AS atan",
292 Err(EvaluateError::FunctionRequiresFloatValue("ATAN".to_owned()).into()),
293 ),
294 (
295 "SELECT ATAN() AS atan",
296 Err(TranslateError::FunctionArgsLengthNotMatching {
297 name: "ATAN".to_owned(),
298 expected: 1,
299 found: 0,
300 }
301 .into()),
302 ),
303 (
304 "SELECT ATAN(1.0, 2.0) AS atan",
305 Err(TranslateError::FunctionArgsLengthNotMatching {
306 name: "ATAN".to_owned(),
307 expected: 1,
308 found: 2,
309 }
310 .into()),
311 ),
312 ];
313
314 for (sql, expected) in test_cases {
315 g.test(sql, expected).await;
316 }
317});