sql_cli/sql/functions/
astronomy.rs

1use anyhow::Result;
2
3use super::{ArgCount, FunctionCategory, FunctionSignature, SqlFunction};
4use crate::data::datatable::DataValue;
5
6// Solar System Masses (in kg)
7
8/// Earth mass function
9pub struct MassEarthFunction;
10
11impl SqlFunction for MassEarthFunction {
12    fn signature(&self) -> FunctionSignature {
13        FunctionSignature {
14            name: "MASS_EARTH",
15            category: FunctionCategory::Astronomical,
16            arg_count: ArgCount::Fixed(0),
17            description: "Returns Earth's mass in kg (5.972 × 10^24)",
18            returns: "FLOAT",
19            examples: vec![
20                "SELECT MASS_EARTH()",
21                "SELECT asteroid_mass / MASS_EARTH() AS earth_masses",
22            ],
23        }
24    }
25
26    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
27        self.validate_args(args)?;
28        Ok(DataValue::Float(5.97237e24))
29    }
30}
31
32/// Sun mass function
33pub struct MassSunFunction;
34
35impl SqlFunction for MassSunFunction {
36    fn signature(&self) -> FunctionSignature {
37        FunctionSignature {
38            name: "MASS_SUN",
39            category: FunctionCategory::Astronomical,
40            arg_count: ArgCount::Fixed(0),
41            description: "Returns the Sun's mass in kg (1.989 × 10^30)",
42            returns: "FLOAT",
43            examples: vec![
44                "SELECT MASS_SUN()",
45                "SELECT star_mass / MASS_SUN() AS solar_masses",
46            ],
47        }
48    }
49
50    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
51        self.validate_args(args)?;
52        Ok(DataValue::Float(1.989e30))
53    }
54}
55
56/// Moon mass function
57pub struct MassMoonFunction;
58
59impl SqlFunction for MassMoonFunction {
60    fn signature(&self) -> FunctionSignature {
61        FunctionSignature {
62            name: "MASS_MOON",
63            category: FunctionCategory::Astronomical,
64            arg_count: ArgCount::Fixed(0),
65            description: "Returns the Moon's mass in kg (7.342 × 10^22)",
66            returns: "FLOAT",
67            examples: vec![
68                "SELECT MASS_MOON()",
69                "SELECT satellite_mass / MASS_MOON() AS lunar_masses",
70            ],
71        }
72    }
73
74    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
75        self.validate_args(args)?;
76        Ok(DataValue::Float(7.342e22))
77    }
78}
79
80// Planetary Masses
81
82/// Mercury mass function
83pub struct MassMercuryFunction;
84
85impl SqlFunction for MassMercuryFunction {
86    fn signature(&self) -> FunctionSignature {
87        FunctionSignature {
88            name: "MASS_MERCURY",
89            category: FunctionCategory::Astronomical,
90            arg_count: ArgCount::Fixed(0),
91            description: "Returns Mercury's mass in kg (3.301 × 10^23)",
92            returns: "FLOAT",
93            examples: vec!["SELECT MASS_MERCURY()"],
94        }
95    }
96
97    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
98        self.validate_args(args)?;
99        Ok(DataValue::Float(3.3011e23))
100    }
101}
102
103/// Venus mass function
104pub struct MassVenusFunction;
105
106impl SqlFunction for MassVenusFunction {
107    fn signature(&self) -> FunctionSignature {
108        FunctionSignature {
109            name: "MASS_VENUS",
110            category: FunctionCategory::Astronomical,
111            arg_count: ArgCount::Fixed(0),
112            description: "Returns Venus's mass in kg (4.867 × 10^24)",
113            returns: "FLOAT",
114            examples: vec!["SELECT MASS_VENUS()"],
115        }
116    }
117
118    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
119        self.validate_args(args)?;
120        Ok(DataValue::Float(4.8675e24))
121    }
122}
123
124/// Mars mass function
125pub struct MassMarsFunction;
126
127impl SqlFunction for MassMarsFunction {
128    fn signature(&self) -> FunctionSignature {
129        FunctionSignature {
130            name: "MASS_MARS",
131            category: FunctionCategory::Astronomical,
132            arg_count: ArgCount::Fixed(0),
133            description: "Returns Mars's mass in kg (6.417 × 10^23)",
134            returns: "FLOAT",
135            examples: vec!["SELECT MASS_MARS()"],
136        }
137    }
138
139    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
140        self.validate_args(args)?;
141        Ok(DataValue::Float(6.4171e23))
142    }
143}
144
145/// Jupiter mass function
146pub struct MassJupiterFunction;
147
148impl SqlFunction for MassJupiterFunction {
149    fn signature(&self) -> FunctionSignature {
150        FunctionSignature {
151            name: "MASS_JUPITER",
152            category: FunctionCategory::Astronomical,
153            arg_count: ArgCount::Fixed(0),
154            description: "Returns Jupiter's mass in kg (1.898 × 10^27)",
155            returns: "FLOAT",
156            examples: vec![
157                "SELECT MASS_JUPITER()",
158                "SELECT exoplanet_mass / MASS_JUPITER() AS jupiter_masses",
159            ],
160        }
161    }
162
163    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
164        self.validate_args(args)?;
165        Ok(DataValue::Float(1.8982e27))
166    }
167}
168
169/// Saturn mass function
170pub struct MassSaturnFunction;
171
172impl SqlFunction for MassSaturnFunction {
173    fn signature(&self) -> FunctionSignature {
174        FunctionSignature {
175            name: "MASS_SATURN",
176            category: FunctionCategory::Astronomical,
177            arg_count: ArgCount::Fixed(0),
178            description: "Returns Saturn's mass in kg (5.683 × 10^26)",
179            returns: "FLOAT",
180            examples: vec!["SELECT MASS_SATURN()"],
181        }
182    }
183
184    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
185        self.validate_args(args)?;
186        Ok(DataValue::Float(5.6834e26))
187    }
188}
189
190/// Uranus mass function
191pub struct MassUranusFunction;
192
193impl SqlFunction for MassUranusFunction {
194    fn signature(&self) -> FunctionSignature {
195        FunctionSignature {
196            name: "MASS_URANUS",
197            category: FunctionCategory::Astronomical,
198            arg_count: ArgCount::Fixed(0),
199            description: "Returns Uranus's mass in kg (8.681 × 10^25)",
200            returns: "FLOAT",
201            examples: vec!["SELECT MASS_URANUS()"],
202        }
203    }
204
205    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
206        self.validate_args(args)?;
207        Ok(DataValue::Float(8.6810e25))
208    }
209}
210
211/// Neptune mass function
212pub struct MassNeptuneFunction;
213
214impl SqlFunction for MassNeptuneFunction {
215    fn signature(&self) -> FunctionSignature {
216        FunctionSignature {
217            name: "MASS_NEPTUNE",
218            category: FunctionCategory::Astronomical,
219            arg_count: ArgCount::Fixed(0),
220            description: "Returns Neptune's mass in kg (1.024 × 10^26)",
221            returns: "FLOAT",
222            examples: vec!["SELECT MASS_NEPTUNE()"],
223        }
224    }
225
226    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
227        self.validate_args(args)?;
228        Ok(DataValue::Float(1.02413e26))
229    }
230}
231
232// Radius Functions
233
234/// Sun radius function
235pub struct RadiusSunFunction;
236
237impl SqlFunction for RadiusSunFunction {
238    fn signature(&self) -> FunctionSignature {
239        FunctionSignature {
240            name: "RADIUS_SUN",
241            category: FunctionCategory::Astronomical,
242            arg_count: ArgCount::Fixed(0),
243            description: "Returns the Sun's radius in meters (6.96 × 10^8)",
244            returns: "FLOAT",
245            examples: vec![
246                "SELECT RADIUS_SUN()",
247                "SELECT star_radius / RADIUS_SUN() AS solar_radii",
248            ],
249        }
250    }
251
252    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
253        self.validate_args(args)?;
254        Ok(DataValue::Float(6.96e8))
255    }
256}
257
258/// Earth radius function
259pub struct RadiusEarthFunction;
260
261impl SqlFunction for RadiusEarthFunction {
262    fn signature(&self) -> FunctionSignature {
263        FunctionSignature {
264            name: "RADIUS_EARTH",
265            category: FunctionCategory::Astronomical,
266            arg_count: ArgCount::Fixed(0),
267            description: "Returns Earth's radius in meters (6.371 × 10^6)",
268            returns: "FLOAT",
269            examples: vec![
270                "SELECT RADIUS_EARTH()",
271                "SELECT planet_radius / RADIUS_EARTH() AS earth_radii",
272            ],
273        }
274    }
275
276    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
277        self.validate_args(args)?;
278        Ok(DataValue::Float(6.371e6))
279    }
280}
281
282/// Moon radius function
283pub struct RadiusMoonFunction;
284
285impl SqlFunction for RadiusMoonFunction {
286    fn signature(&self) -> FunctionSignature {
287        FunctionSignature {
288            name: "RADIUS_MOON",
289            category: FunctionCategory::Astronomical,
290            arg_count: ArgCount::Fixed(0),
291            description: "Returns the Moon's radius in meters (1.737 × 10^6)",
292            returns: "FLOAT",
293            examples: vec![
294                "SELECT RADIUS_MOON()",
295                "SELECT satellite_radius / RADIUS_MOON() AS lunar_radii",
296            ],
297        }
298    }
299
300    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
301        self.validate_args(args)?;
302        Ok(DataValue::Float(1.737e6))
303    }
304}
305
306/// Mercury radius function
307pub struct RadiusMercuryFunction;
308
309impl SqlFunction for RadiusMercuryFunction {
310    fn signature(&self) -> FunctionSignature {
311        FunctionSignature {
312            name: "RADIUS_MERCURY",
313            category: FunctionCategory::Astronomical,
314            arg_count: ArgCount::Fixed(0),
315            description: "Returns Mercury's radius in meters (2.440 × 10^6)",
316            returns: "FLOAT",
317            examples: vec!["SELECT RADIUS_MERCURY()"],
318        }
319    }
320
321    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
322        self.validate_args(args)?;
323        Ok(DataValue::Float(2.440e6))
324    }
325}
326
327/// Venus radius function
328pub struct RadiusVenusFunction;
329
330impl SqlFunction for RadiusVenusFunction {
331    fn signature(&self) -> FunctionSignature {
332        FunctionSignature {
333            name: "RADIUS_VENUS",
334            category: FunctionCategory::Astronomical,
335            arg_count: ArgCount::Fixed(0),
336            description: "Returns Venus's radius in meters (6.052 × 10^6)",
337            returns: "FLOAT",
338            examples: vec!["SELECT RADIUS_VENUS()"],
339        }
340    }
341
342    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
343        self.validate_args(args)?;
344        Ok(DataValue::Float(6.052e6))
345    }
346}
347
348/// Mars radius function
349pub struct RadiusMarsFunction;
350
351impl SqlFunction for RadiusMarsFunction {
352    fn signature(&self) -> FunctionSignature {
353        FunctionSignature {
354            name: "RADIUS_MARS",
355            category: FunctionCategory::Astronomical,
356            arg_count: ArgCount::Fixed(0),
357            description: "Returns Mars's radius in meters (3.390 × 10^6)",
358            returns: "FLOAT",
359            examples: vec!["SELECT RADIUS_MARS()"],
360        }
361    }
362
363    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
364        self.validate_args(args)?;
365        Ok(DataValue::Float(3.390e6))
366    }
367}
368
369/// Jupiter radius function
370pub struct RadiusJupiterFunction;
371
372impl SqlFunction for RadiusJupiterFunction {
373    fn signature(&self) -> FunctionSignature {
374        FunctionSignature {
375            name: "RADIUS_JUPITER",
376            category: FunctionCategory::Astronomical,
377            arg_count: ArgCount::Fixed(0),
378            description: "Returns Jupiter's radius in meters (6.991 × 10^7)",
379            returns: "FLOAT",
380            examples: vec![
381                "SELECT RADIUS_JUPITER()",
382                "SELECT exoplanet_radius / RADIUS_JUPITER() AS jupiter_radii",
383            ],
384        }
385    }
386
387    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
388        self.validate_args(args)?;
389        Ok(DataValue::Float(6.991e7))
390    }
391}
392
393/// Saturn radius function
394pub struct RadiusSaturnFunction;
395
396impl SqlFunction for RadiusSaturnFunction {
397    fn signature(&self) -> FunctionSignature {
398        FunctionSignature {
399            name: "RADIUS_SATURN",
400            category: FunctionCategory::Astronomical,
401            arg_count: ArgCount::Fixed(0),
402            description: "Returns Saturn's radius in meters (5.823 × 10^7)",
403            returns: "FLOAT",
404            examples: vec!["SELECT RADIUS_SATURN()"],
405        }
406    }
407
408    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
409        self.validate_args(args)?;
410        Ok(DataValue::Float(5.823e7))
411    }
412}
413
414/// Uranus radius function
415pub struct RadiusUranusFunction;
416
417impl SqlFunction for RadiusUranusFunction {
418    fn signature(&self) -> FunctionSignature {
419        FunctionSignature {
420            name: "RADIUS_URANUS",
421            category: FunctionCategory::Astronomical,
422            arg_count: ArgCount::Fixed(0),
423            description: "Returns Uranus's radius in meters (2.536 × 10^7)",
424            returns: "FLOAT",
425            examples: vec!["SELECT RADIUS_URANUS()"],
426        }
427    }
428
429    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
430        self.validate_args(args)?;
431        Ok(DataValue::Float(2.536e7))
432    }
433}
434
435/// Neptune radius function
436pub struct RadiusNeptuneFunction;
437
438impl SqlFunction for RadiusNeptuneFunction {
439    fn signature(&self) -> FunctionSignature {
440        FunctionSignature {
441            name: "RADIUS_NEPTUNE",
442            category: FunctionCategory::Astronomical,
443            arg_count: ArgCount::Fixed(0),
444            description: "Returns Neptune's radius in meters (2.462 × 10^7)",
445            returns: "FLOAT",
446            examples: vec!["SELECT RADIUS_NEPTUNE()"],
447        }
448    }
449
450    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
451        self.validate_args(args)?;
452        Ok(DataValue::Float(2.462e7))
453    }
454}
455
456// Distance Units
457
458/// Astronomical Unit function
459pub struct AuFunction;
460
461impl SqlFunction for AuFunction {
462    fn signature(&self) -> FunctionSignature {
463        FunctionSignature {
464            name: "AU",
465            category: FunctionCategory::Astronomical,
466            arg_count: ArgCount::Fixed(0),
467            description: "Returns one Astronomical Unit in meters (1.496 × 10^11)",
468            returns: "FLOAT",
469            examples: vec!["SELECT AU()", "SELECT distance_m / AU() AS distance_au"],
470        }
471    }
472
473    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
474        self.validate_args(args)?;
475        Ok(DataValue::Float(1.495978707e11))
476    }
477}
478
479/// Light Year function
480pub struct LightYearFunction;
481
482impl SqlFunction for LightYearFunction {
483    fn signature(&self) -> FunctionSignature {
484        FunctionSignature {
485            name: "LIGHT_YEAR",
486            category: FunctionCategory::Astronomical,
487            arg_count: ArgCount::Fixed(0),
488            description: "Returns one light year in meters (9.461 × 10^15)",
489            returns: "FLOAT",
490            examples: vec![
491                "SELECT LIGHT_YEAR()",
492                "SELECT star_distance / LIGHT_YEAR() AS distance_ly",
493            ],
494        }
495    }
496
497    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
498        self.validate_args(args)?;
499        Ok(DataValue::Float(9.4607e15))
500    }
501}
502
503/// Parsec function
504pub struct ParsecFunction;
505
506impl SqlFunction for ParsecFunction {
507    fn signature(&self) -> FunctionSignature {
508        FunctionSignature {
509            name: "PARSEC",
510            category: FunctionCategory::Astronomical,
511            arg_count: ArgCount::Fixed(0),
512            description: "Returns one parsec in meters (3.086 × 10^16)",
513            returns: "FLOAT",
514            examples: vec![
515                "SELECT PARSEC()",
516                "SELECT galaxy_distance / PARSEC() AS distance_pc",
517            ],
518        }
519    }
520
521    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
522        self.validate_args(args)?;
523        Ok(DataValue::Float(3.0857e16))
524    }
525}
526
527// Planetary Distances from the Sun
528
529/// Mercury distance from Sun
530pub struct DistMercuryFunction;
531
532impl SqlFunction for DistMercuryFunction {
533    fn signature(&self) -> FunctionSignature {
534        FunctionSignature {
535            name: "DIST_MERCURY",
536            category: FunctionCategory::Astronomical,
537            arg_count: ArgCount::Fixed(0),
538            description: "Returns Mercury's mean distance from the Sun in meters (5.791 × 10^10)",
539            returns: "FLOAT",
540            examples: vec![
541                "SELECT DIST_MERCURY()",
542                "SELECT DIST_MERCURY() / AU() AS mercury_au",
543            ],
544        }
545    }
546
547    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
548        self.validate_args(args)?;
549        Ok(DataValue::Float(5.791e10))
550    }
551}
552
553/// Venus distance from Sun
554pub struct DistVenusFunction;
555
556impl SqlFunction for DistVenusFunction {
557    fn signature(&self) -> FunctionSignature {
558        FunctionSignature {
559            name: "DIST_VENUS",
560            category: FunctionCategory::Astronomical,
561            arg_count: ArgCount::Fixed(0),
562            description: "Returns Venus's mean distance from the Sun in meters (1.082 × 10^11)",
563            returns: "FLOAT",
564            examples: vec![
565                "SELECT DIST_VENUS()",
566                "SELECT DIST_VENUS() / AU() AS venus_au",
567            ],
568        }
569    }
570
571    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
572        self.validate_args(args)?;
573        Ok(DataValue::Float(1.082e11))
574    }
575}
576
577/// Mars distance from Sun
578pub struct DistMarsFunction;
579
580impl SqlFunction for DistMarsFunction {
581    fn signature(&self) -> FunctionSignature {
582        FunctionSignature {
583            name: "DIST_MARS",
584            category: FunctionCategory::Astronomical,
585            arg_count: ArgCount::Fixed(0),
586            description: "Returns Mars's mean distance from the Sun in meters (2.279 × 10^11)",
587            returns: "FLOAT",
588            examples: vec!["SELECT DIST_MARS()", "SELECT DIST_MARS() / AU() AS mars_au"],
589        }
590    }
591
592    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
593        self.validate_args(args)?;
594        Ok(DataValue::Float(2.279e11))
595    }
596}
597
598/// Jupiter distance from Sun
599pub struct DistJupiterFunction;
600
601impl SqlFunction for DistJupiterFunction {
602    fn signature(&self) -> FunctionSignature {
603        FunctionSignature {
604            name: "DIST_JUPITER",
605            category: FunctionCategory::Astronomical,
606            arg_count: ArgCount::Fixed(0),
607            description: "Returns Jupiter's mean distance from the Sun in meters (7.786 × 10^11)",
608            returns: "FLOAT",
609            examples: vec![
610                "SELECT DIST_JUPITER()",
611                "SELECT DIST_JUPITER() / AU() AS jupiter_au",
612            ],
613        }
614    }
615
616    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
617        self.validate_args(args)?;
618        Ok(DataValue::Float(7.786e11))
619    }
620}
621
622/// Saturn distance from Sun
623pub struct DistSaturnFunction;
624
625impl SqlFunction for DistSaturnFunction {
626    fn signature(&self) -> FunctionSignature {
627        FunctionSignature {
628            name: "DIST_SATURN",
629            category: FunctionCategory::Astronomical,
630            arg_count: ArgCount::Fixed(0),
631            description: "Returns Saturn's mean distance from the Sun in meters (1.4335 × 10^12)",
632            returns: "FLOAT",
633            examples: vec![
634                "SELECT DIST_SATURN()",
635                "SELECT DIST_SATURN() / AU() AS saturn_au",
636            ],
637        }
638    }
639
640    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
641        self.validate_args(args)?;
642        Ok(DataValue::Float(1.4335e12))
643    }
644}
645
646/// Uranus distance from Sun
647pub struct DistUranusFunction;
648
649impl SqlFunction for DistUranusFunction {
650    fn signature(&self) -> FunctionSignature {
651        FunctionSignature {
652            name: "DIST_URANUS",
653            category: FunctionCategory::Astronomical,
654            arg_count: ArgCount::Fixed(0),
655            description: "Returns Uranus's mean distance from the Sun in meters (2.8725 × 10^12)",
656            returns: "FLOAT",
657            examples: vec![
658                "SELECT DIST_URANUS()",
659                "SELECT DIST_URANUS() / AU() AS uranus_au",
660            ],
661        }
662    }
663
664    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
665        self.validate_args(args)?;
666        Ok(DataValue::Float(2.8725e12))
667    }
668}
669
670/// Neptune distance from Sun
671pub struct DistNeptuneFunction;
672
673impl SqlFunction for DistNeptuneFunction {
674    fn signature(&self) -> FunctionSignature {
675        FunctionSignature {
676            name: "DIST_NEPTUNE",
677            category: FunctionCategory::Astronomical,
678            arg_count: ArgCount::Fixed(0),
679            description: "Returns Neptune's mean distance from the Sun in meters (4.4951 × 10^12)",
680            returns: "FLOAT",
681            examples: vec![
682                "SELECT DIST_NEPTUNE()",
683                "SELECT DIST_NEPTUNE() / AU() AS neptune_au",
684            ],
685        }
686    }
687
688    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
689        self.validate_args(args)?;
690        Ok(DataValue::Float(4.4951e12))
691    }
692}
693
694#[cfg(test)]
695mod tests {
696    use super::*;
697
698    #[test]
699    fn test_mass_earth() {
700        let func = MassEarthFunction;
701        let result = func.evaluate(&[]).unwrap();
702        match result {
703            DataValue::Float(val) => assert_eq!(val, 5.97237e24),
704            _ => panic!("Expected Float"),
705        }
706    }
707
708    #[test]
709    fn test_mass_sun() {
710        let func = MassSunFunction;
711        let result = func.evaluate(&[]).unwrap();
712        match result {
713            DataValue::Float(val) => assert_eq!(val, 1.989e30),
714            _ => panic!("Expected Float"),
715        }
716    }
717
718    #[test]
719    fn test_au() {
720        let func = AuFunction;
721        let result = func.evaluate(&[]).unwrap();
722        match result {
723            DataValue::Float(val) => assert_eq!(val, 1.495978707e11),
724            _ => panic!("Expected Float"),
725        }
726    }
727
728    #[test]
729    fn test_light_year() {
730        let func = LightYearFunction;
731        let result = func.evaluate(&[]).unwrap();
732        match result {
733            DataValue::Float(val) => assert_eq!(val, 9.4607e15),
734            _ => panic!("Expected Float"),
735        }
736    }
737}
sql_cli/sql/functions/astronomy.rs

sql_cli/sql/functions/
astronomy.rs
