sql_cli/sql/functions/
physics.rs

1use anyhow::Result;
2
3use super::{ArgCount, FunctionCategory, FunctionSignature, SqlFunction};
4use crate::data::datatable::DataValue;
5
6/// Speed of light in vacuum
7pub struct SpeedOfLightFunction;
8
9impl SqlFunction for SpeedOfLightFunction {
10    fn signature(&self) -> FunctionSignature {
11        FunctionSignature {
12            name: "C",
13            category: FunctionCategory::Constant,
14            arg_count: ArgCount::Fixed(0),
15            description: "Returns the speed of light in vacuum (m/s)",
16            returns: "FLOAT",
17            examples: vec!["SELECT C()", "SELECT distance / C() as light_time"],
18        }
19    }
20
21    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
22        self.validate_args(args)?;
23        Ok(DataValue::Float(299792458.0))
24    }
25}
26
27/// Gravitational constant
28pub struct GravitationalConstantFunction;
29
30impl SqlFunction for GravitationalConstantFunction {
31    fn signature(&self) -> FunctionSignature {
32        FunctionSignature {
33            name: "G",
34            category: FunctionCategory::Constant,
35            arg_count: ArgCount::Fixed(0),
36            description: "Returns the gravitational constant (m³ kg⁻¹ s⁻²)",
37            returns: "FLOAT",
38            examples: vec![
39                "SELECT G()",
40                "SELECT G() * mass1 * mass2 / (r * r) as force",
41            ],
42        }
43    }
44
45    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
46        self.validate_args(args)?;
47        Ok(DataValue::Float(6.67430e-11))
48    }
49}
50
51/// Coulomb's constant (k_e = 1/(4πε₀))
52pub struct CoulombConstantFunction;
53
54impl SqlFunction for CoulombConstantFunction {
55    fn signature(&self) -> FunctionSignature {
56        FunctionSignature {
57            name: "COULOMB",
58            category: FunctionCategory::Constant,
59            arg_count: ArgCount::Fixed(0),
60            description: "Returns Coulomb's constant k_e = 8.9875517873681764 × 10^9 N⋅m²⋅C⁻²",
61            returns: "FLOAT",
62            examples: vec![
63                "SELECT COULOMB()",
64                "SELECT COULOMB() * q1 * q2 / (r * r) as electric_force",
65            ],
66        }
67    }
68
69    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
70        self.validate_args(args)?;
71        Ok(DataValue::Float(8.9875517873681764e9))
72    }
73}
74
75/// Bohr radius
76pub struct BohrRadiusFunction;
77
78impl SqlFunction for BohrRadiusFunction {
79    fn signature(&self) -> FunctionSignature {
80        FunctionSignature {
81            name: "BOHR",
82            category: FunctionCategory::Constant,
83            arg_count: ArgCount::Fixed(0),
84            description: "Returns the Bohr radius a₀ = 5.29177210903 × 10^-11 m",
85            returns: "FLOAT",
86            examples: vec!["SELECT BOHR()", "SELECT BOHR() * n * n as orbital_radius"],
87        }
88    }
89
90    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
91        self.validate_args(args)?;
92        Ok(DataValue::Float(5.29177210903e-11))
93    }
94}
95
96/// Planck constant
97pub struct PlanckFunction;
98
99impl SqlFunction for PlanckFunction {
100    fn signature(&self) -> FunctionSignature {
101        FunctionSignature {
102            name: "H",
103            category: FunctionCategory::Constant,
104            arg_count: ArgCount::Fixed(0),
105            description: "Returns the Planck constant (J⋅s)",
106            returns: "FLOAT",
107            examples: vec!["SELECT H()", "SELECT H() * frequency as energy"],
108        }
109    }
110
111    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
112        self.validate_args(args)?;
113        Ok(DataValue::Float(6.62607015e-34))
114    }
115}
116
117/// Boltzmann constant
118pub struct BoltzmannFunction;
119
120impl SqlFunction for BoltzmannFunction {
121    fn signature(&self) -> FunctionSignature {
122        FunctionSignature {
123            name: "K",
124            category: FunctionCategory::Constant,
125            arg_count: ArgCount::Fixed(0),
126            description: "Returns the Boltzmann constant (J/K)",
127            returns: "FLOAT",
128            examples: vec!["SELECT K()", "SELECT K() * temperature as thermal_energy"],
129        }
130    }
131
132    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
133        self.validate_args(args)?;
134        Ok(DataValue::Float(1.380649e-23))
135    }
136}
137
138/// Universal gas constant
139pub struct GasConstantFunction;
140
141impl SqlFunction for GasConstantFunction {
142    fn signature(&self) -> FunctionSignature {
143        FunctionSignature {
144            name: "R",
145            category: FunctionCategory::Constant,
146            arg_count: ArgCount::Fixed(0),
147            description: "Returns the universal gas constant (J mol⁻¹ K⁻¹)",
148            returns: "FLOAT",
149            examples: vec![
150                "SELECT R()",
151                "SELECT pressure * volume / (R() * temperature) as moles",
152            ],
153        }
154    }
155
156    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
157        self.validate_args(args)?;
158        Ok(DataValue::Float(8.314462618))
159    }
160}
161
162/// Electric permittivity of vacuum
163pub struct PermittivityFunction;
164
165impl SqlFunction for PermittivityFunction {
166    fn signature(&self) -> FunctionSignature {
167        FunctionSignature {
168            name: "E0",
169            category: FunctionCategory::Constant,
170            arg_count: ArgCount::Fixed(0),
171            description: "Returns the electric permittivity of vacuum (F/m)",
172            returns: "FLOAT",
173            examples: vec![
174                "SELECT E0()",
175                "SELECT 1 / (4 * PI() * E0()) as coulomb_constant",
176            ],
177        }
178    }
179
180    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
181        self.validate_args(args)?;
182        Ok(DataValue::Float(8.8541878128e-12))
183    }
184}
185
186/// Magnetic permeability of vacuum
187pub struct PermeabilityFunction;
188
189impl SqlFunction for PermeabilityFunction {
190    fn signature(&self) -> FunctionSignature {
191        FunctionSignature {
192            name: "MU0",
193            category: FunctionCategory::Constant,
194            arg_count: ArgCount::Fixed(0),
195            description: "Returns the magnetic permeability of vacuum (N/A²)",
196            returns: "FLOAT",
197            examples: vec!["SELECT MU0()", "SELECT SQRT(MU0() * E0()) as impedance"],
198        }
199    }
200
201    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
202        self.validate_args(args)?;
203        Ok(DataValue::Float(1.25663706212e-6))
204    }
205}
206
207/// Elementary charge
208pub struct ElementaryChargeFunction;
209
210impl SqlFunction for ElementaryChargeFunction {
211    fn signature(&self) -> FunctionSignature {
212        FunctionSignature {
213            name: "QE",
214            category: FunctionCategory::Constant,
215            arg_count: ArgCount::Fixed(0),
216            description: "Returns the elementary charge (C)",
217            returns: "FLOAT",
218            examples: vec!["SELECT QE()", "SELECT n_electrons * QE() as total_charge"],
219        }
220    }
221
222    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
223        self.validate_args(args)?;
224        Ok(DataValue::Float(1.602176634e-19))
225    }
226}
227
228/// Proton mass
229pub struct ProtonMassFunction;
230
231impl SqlFunction for ProtonMassFunction {
232    fn signature(&self) -> FunctionSignature {
233        FunctionSignature {
234            name: "MP",
235            category: FunctionCategory::Constant,
236            arg_count: ArgCount::Fixed(0),
237            description: "Returns the proton mass (kg)",
238            returns: "FLOAT",
239            examples: vec!["SELECT MP()", "SELECT mass / MP() as proton_masses"],
240        }
241    }
242
243    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
244        self.validate_args(args)?;
245        Ok(DataValue::Float(1.67262192369e-27))
246    }
247}
248
249/// Neutron mass
250pub struct NeutronMassFunction;
251
252impl SqlFunction for NeutronMassFunction {
253    fn signature(&self) -> FunctionSignature {
254        FunctionSignature {
255            name: "MN",
256            category: FunctionCategory::Constant,
257            arg_count: ArgCount::Fixed(0),
258            description: "Returns the neutron mass (kg)",
259            returns: "FLOAT",
260            examples: vec!["SELECT MN()", "SELECT mass / MN() as neutron_masses"],
261        }
262    }
263
264    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
265        self.validate_args(args)?;
266        Ok(DataValue::Float(1.67492749804e-27))
267    }
268}
269
270/// Atomic mass unit
271pub struct AtomicMassUnitFunction;
272
273impl SqlFunction for AtomicMassUnitFunction {
274    fn signature(&self) -> FunctionSignature {
275        FunctionSignature {
276            name: "AMU",
277            category: FunctionCategory::Constant,
278            arg_count: ArgCount::Fixed(0),
279            description: "Returns the atomic mass unit (kg)",
280            returns: "FLOAT",
281            examples: vec!["SELECT AMU()", "SELECT molecular_weight * AMU() as mass_kg"],
282        }
283    }
284
285    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
286        self.validate_args(args)?;
287        Ok(DataValue::Float(1.66053906660e-27))
288    }
289}
290
291/// Fine structure constant
292pub struct FineStructureFunction;
293
294impl SqlFunction for FineStructureFunction {
295    fn signature(&self) -> FunctionSignature {
296        FunctionSignature {
297            name: "ALPHA",
298            category: FunctionCategory::Constant,
299            arg_count: ArgCount::Fixed(0),
300            description: "Returns the fine structure constant (dimensionless)",
301            returns: "FLOAT",
302            examples: vec![
303                "SELECT ALPHA()",
304                "SELECT 1 / ALPHA() as inverse_fine_structure",
305            ],
306        }
307    }
308
309    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
310        self.validate_args(args)?;
311        Ok(DataValue::Float(7.2973525693e-3))
312    }
313}
314
315/// Rydberg constant
316pub struct RydbergFunction;
317
318impl SqlFunction for RydbergFunction {
319    fn signature(&self) -> FunctionSignature {
320        FunctionSignature {
321            name: "RY",
322            category: FunctionCategory::Constant,
323            arg_count: ArgCount::Fixed(0),
324            description: "Returns the Rydberg constant (m⁻¹)",
325            returns: "FLOAT",
326            examples: vec!["SELECT RY()", "SELECT 1 / RY() as rydberg_wavelength"],
327        }
328    }
329
330    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
331        self.validate_args(args)?;
332        Ok(DataValue::Float(10973731.568160))
333    }
334}
335
336/// Stefan-Boltzmann constant
337pub struct StefanBoltzmannFunction;
338
339impl SqlFunction for StefanBoltzmannFunction {
340    fn signature(&self) -> FunctionSignature {
341        FunctionSignature {
342            name: "SIGMA",
343            category: FunctionCategory::Constant,
344            arg_count: ArgCount::Fixed(0),
345            description: "Returns the Stefan-Boltzmann constant (W m⁻² K⁻⁴)",
346            returns: "FLOAT",
347            examples: vec![
348                "SELECT SIGMA()",
349                "SELECT SIGMA() * area * POWER(temp, 4) as radiated_power",
350            ],
351        }
352    }
353
354    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
355        self.validate_args(args)?;
356        Ok(DataValue::Float(5.670374419e-8))
357    }
358}
359
360/// Classical electron radius
361pub struct ElectronRadiusFunction;
362
363impl SqlFunction for ElectronRadiusFunction {
364    fn signature(&self) -> FunctionSignature {
365        FunctionSignature {
366            name: "RE",
367            category: FunctionCategory::Constant,
368            arg_count: ArgCount::Fixed(0),
369            description: "Returns the classical electron radius (m)",
370            returns: "FLOAT",
371            examples: vec!["SELECT RE()", "SELECT radius / RE() as electron_radii"],
372        }
373    }
374
375    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
376        self.validate_args(args)?;
377        Ok(DataValue::Float(2.8179403262e-15))
378    }
379}
380
381/// Proton radius
382pub struct ProtonRadiusFunction;
383
384impl SqlFunction for ProtonRadiusFunction {
385    fn signature(&self) -> FunctionSignature {
386        FunctionSignature {
387            name: "RP",
388            category: FunctionCategory::Constant,
389            arg_count: ArgCount::Fixed(0),
390            description: "Returns the proton radius (m)",
391            returns: "FLOAT",
392            examples: vec!["SELECT RP()", "SELECT radius / RP() as proton_radii"],
393        }
394    }
395
396    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
397        self.validate_args(args)?;
398        Ok(DataValue::Float(8.414e-16))
399    }
400}
401
402/// Neutron radius
403pub struct NeutronRadiusFunction;
404
405impl SqlFunction for NeutronRadiusFunction {
406    fn signature(&self) -> FunctionSignature {
407        FunctionSignature {
408            name: "RN",
409            category: FunctionCategory::Constant,
410            arg_count: ArgCount::Fixed(0),
411            description: "Returns the neutron radius (m)",
412            returns: "FLOAT",
413            examples: vec!["SELECT RN()", "SELECT radius / RN() as neutron_radii"],
414        }
415    }
416
417    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue> {
418        self.validate_args(args)?;
419        Ok(DataValue::Float(8.4e-16))
420    }
421}
422
423/// Register all physics functions
424pub fn register_physics_functions(registry: &mut super::FunctionRegistry) {
425    // Fundamental constants
426    registry.register(Box::new(SpeedOfLightFunction));
427    registry.register(Box::new(GravitationalConstantFunction));
428    registry.register(Box::new(PlanckFunction));
429    registry.register(Box::new(BoltzmannFunction));
430    registry.register(Box::new(GasConstantFunction));
431
432    // Electromagnetic constants
433    registry.register(Box::new(CoulombConstantFunction));
434    registry.register(Box::new(BohrRadiusFunction));
435    registry.register(Box::new(PermittivityFunction));
436    registry.register(Box::new(PermeabilityFunction));
437    registry.register(Box::new(ElementaryChargeFunction));
438
439    // Particle masses
440    registry.register(Box::new(ProtonMassFunction));
441    registry.register(Box::new(NeutronMassFunction));
442    registry.register(Box::new(AtomicMassUnitFunction));
443
444    // Other physics constants
445    registry.register(Box::new(FineStructureFunction));
446    registry.register(Box::new(RydbergFunction));
447    registry.register(Box::new(StefanBoltzmannFunction));
448
449    // Particle radii
450    registry.register(Box::new(ElectronRadiusFunction));
451    registry.register(Box::new(ProtonRadiusFunction));
452    registry.register(Box::new(NeutronRadiusFunction));
453}
sql_cli/sql/functions/physics.rs

sql_cli/sql/functions/
physics.rs
