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

sql_cli/sql/functions/
physics.rs
