sql_cli/sql/functions/
mod.rs

1use anyhow::{anyhow, Result};
2use std::collections::HashMap;
3use std::fmt;
4use std::sync::Arc;
5
6use crate::data::datatable::DataValue;
7
8pub mod ansi;
9pub mod astronomy;
10pub mod base_conversion;
11pub mod bigint;
12pub mod bitwise;
13pub mod bitwise_string;
14pub mod case_convert;
15pub mod cast;
16pub mod chemistry;
17pub mod comparison;
18pub mod constants;
19pub mod convert;
20pub mod date_time;
21pub mod financial;
22pub mod format;
23pub mod format_number;
24pub mod geometry;
25pub mod group_num;
26pub mod hash;
27pub mod integer_limits;
28pub mod math;
29pub mod mathematics;
30pub mod number_words;
31pub mod particle_charges;
32pub mod path;
33pub mod physics;
34pub mod random;
35pub mod roman;
36pub mod solar_system;
37pub mod statistics;
38pub mod string_fun;
39pub mod string_methods;
40pub mod string_utils;
41pub mod text_processing;
42pub mod trigonometry;
43pub mod type_checking;
44pub mod utility;
45pub mod vector;
46
47// Re-export MethodFunction trait
48pub use string_methods::MethodFunction;
49
50/// Category of SQL functions for organization and discovery
51#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
52pub enum FunctionCategory {
53    Constant,      // Mathematical and physical constants
54    Mathematical,  // Mathematical operations
55    Statistical,   // Statistical functions
56    Astronomical,  // Astronomical constants and calculations
57    Chemical,      // Chemical elements and properties
58    Date,          // Date/time operations
59    String,        // String manipulation
60    Aggregate,     // Aggregation functions
61    Conversion,    // Unit conversion functions
62    BigNumber,     // Arbitrary precision arithmetic
63    TableFunction, // Table-generating functions
64    Bitwise,       // Bitwise operations and binary visualization
65    Terminal,      // Terminal formatting (ANSI colors, styles)
66}
67
68impl fmt::Display for FunctionCategory {
69    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
70        match self {
71            FunctionCategory::Constant => write!(f, "Constant"),
72            FunctionCategory::Mathematical => write!(f, "Mathematical"),
73            FunctionCategory::Statistical => write!(f, "Statistical"),
74            FunctionCategory::Astronomical => write!(f, "Astronomical"),
75            FunctionCategory::Chemical => write!(f, "Chemical"),
76            FunctionCategory::Date => write!(f, "Date"),
77            FunctionCategory::String => write!(f, "String"),
78            FunctionCategory::Aggregate => write!(f, "Aggregate"),
79            FunctionCategory::Conversion => write!(f, "Conversion"),
80            FunctionCategory::BigNumber => write!(f, "BigNumber"),
81            FunctionCategory::TableFunction => write!(f, "TableFunction"),
82            FunctionCategory::Bitwise => write!(f, "Bitwise"),
83            FunctionCategory::Terminal => write!(f, "Terminal"),
84        }
85    }
86}
87
88/// Describes the number of arguments a function accepts
89#[derive(Debug, Clone)]
90pub enum ArgCount {
91    /// Exactly n arguments
92    Fixed(usize),
93    /// Between min and max arguments (inclusive)
94    Range(usize, usize),
95    /// Any number of arguments
96    Variadic,
97}
98
99impl ArgCount {
100    #[must_use]
101    pub fn is_valid(&self, count: usize) -> bool {
102        match self {
103            ArgCount::Fixed(n) => count == *n,
104            ArgCount::Range(min, max) => count >= *min && count <= *max,
105            ArgCount::Variadic => true,
106        }
107    }
108
109    #[must_use]
110    pub fn description(&self) -> String {
111        match self {
112            ArgCount::Fixed(0) => "no arguments".to_string(),
113            ArgCount::Fixed(1) => "1 argument".to_string(),
114            ArgCount::Fixed(n) => format!("{n} arguments"),
115            ArgCount::Range(min, max) => format!("{min} to {max} arguments"),
116            ArgCount::Variadic => "any number of arguments".to_string(),
117        }
118    }
119}
120
121/// Signature of a SQL function including metadata
122#[derive(Debug, Clone)]
123pub struct FunctionSignature {
124    pub name: &'static str,
125    pub category: FunctionCategory,
126    pub arg_count: ArgCount,
127    pub description: &'static str,
128    pub returns: &'static str,
129    pub examples: Vec<&'static str>,
130}
131
132/// Trait that all SQL functions must implement
133pub trait SqlFunction: Send + Sync {
134    /// Get the function's signature and metadata
135    fn signature(&self) -> FunctionSignature;
136
137    /// Evaluate the function with the given arguments
138    fn evaluate(&self, args: &[DataValue]) -> Result<DataValue>;
139
140    /// Validate arguments before evaluation (default implementation checks count)
141    fn validate_args(&self, args: &[DataValue]) -> Result<()> {
142        let sig = self.signature();
143        if !sig.arg_count.is_valid(args.len()) {
144            return Err(anyhow!(
145                "{}() expects {}, got {}",
146                sig.name,
147                sig.arg_count.description(),
148                args.len()
149            ));
150        }
151        Ok(())
152    }
153}
154
155/// Registry for all SQL functions
156pub struct FunctionRegistry {
157    functions: HashMap<String, Box<dyn SqlFunction>>,
158    by_category: HashMap<FunctionCategory, Vec<String>>,
159    methods: HashMap<String, Arc<dyn MethodFunction>>,
160}
161
162impl FunctionRegistry {
163    /// Create a new registry with all built-in functions
164    #[must_use]
165    pub fn new() -> Self {
166        let mut registry = Self {
167            functions: HashMap::new(),
168            by_category: HashMap::new(),
169            methods: HashMap::new(),
170        };
171
172        // Register all built-in functions
173        registry.register_constants();
174        registry.register_astronomical_functions();
175        registry.register_chemical_functions();
176        registry.register_mathematical_functions();
177        registry.register_statistical_functions();
178        registry.register_geometry_functions();
179        registry.register_physics_functions();
180        registry.register_date_time_functions();
181        registry.register_string_methods();
182        registry.register_financial_functions();
183        registry.register_bigint_functions();
184        registry.register_conversion_functions();
185        registry.register_hash_functions();
186        registry.register_comparison_functions();
187        registry.register_aggregate_functions();
188        registry.register_random_functions();
189        registry.register_format_functions();
190        registry.register_type_checking_functions();
191        registry.register_utility_functions();
192        registry.register_bitwise_functions();
193        registry.register_ansi_functions();
194        registry.register_vector_functions();
195
196        registry
197    }
198
199    /// Register a function in the registry
200    pub fn register(&mut self, func: Box<dyn SqlFunction>) {
201        let sig = func.signature();
202        let name = sig.name.to_uppercase();
203        let category = sig.category;
204
205        // Add to main registry
206        self.functions.insert(name.clone(), func);
207
208        // Add to category index
209        self.by_category.entry(category).or_default().push(name);
210    }
211
212    /// Get a function by name (case-insensitive)
213    #[must_use]
214    pub fn get(&self, name: &str) -> Option<&dyn SqlFunction> {
215        self.functions
216            .get(&name.to_uppercase())
217            .map(std::convert::AsRef::as_ref)
218    }
219
220    /// Check if a function exists
221    #[must_use]
222    pub fn contains(&self, name: &str) -> bool {
223        self.functions.contains_key(&name.to_uppercase())
224    }
225
226    /// Get all functions matching a prefix (for autocomplete)
227    #[must_use]
228    pub fn autocomplete(&self, prefix: &str) -> Vec<FunctionSignature> {
229        let prefix_upper = prefix.to_uppercase();
230        self.functions
231            .iter()
232            .filter(|(name, _)| name.starts_with(&prefix_upper))
233            .map(|(_, func)| func.signature())
234            .collect()
235    }
236
237    /// Get all functions in a category
238    #[must_use]
239    pub fn get_by_category(&self, category: FunctionCategory) -> Vec<FunctionSignature> {
240        self.by_category
241            .get(&category)
242            .map(|names| {
243                names
244                    .iter()
245                    .filter_map(|name| self.functions.get(name))
246                    .map(|func| func.signature())
247                    .collect()
248            })
249            .unwrap_or_default()
250    }
251
252    /// Get all available functions
253    #[must_use]
254    pub fn all_functions(&self) -> Vec<FunctionSignature> {
255        self.functions
256            .values()
257            .map(|func| func.signature())
258            .collect()
259    }
260
261    /// Register a method function
262    pub fn register_method(&mut self, method: Arc<dyn MethodFunction>) {
263        let method_name = method.method_name().to_uppercase();
264        self.methods.insert(method_name, method);
265    }
266
267    /// Get a method function by name
268    #[must_use]
269    pub fn get_method(&self, name: &str) -> Option<Arc<dyn MethodFunction>> {
270        // Try exact match first
271        if let Some(method) = self.methods.get(&name.to_uppercase()) {
272            return Some(Arc::clone(method));
273        }
274
275        // Try to find a method that handles this name
276        for method in self.methods.values() {
277            if method.handles_method(name) {
278                return Some(Arc::clone(method));
279            }
280        }
281
282        None
283    }
284
285    /// Check if a method exists
286    #[must_use]
287    pub fn has_method(&self, name: &str) -> bool {
288        self.get_method(name).is_some()
289    }
290
291    /// Generate markdown documentation for all functions
292    #[must_use]
293    pub fn generate_markdown_docs(&self) -> String {
294        use std::fmt::Write;
295        let mut doc = String::new();
296
297        writeln!(&mut doc, "# SQL CLI Function Reference\n").unwrap();
298        writeln!(
299            &mut doc,
300            "This document is auto-generated from the function registry.\n"
301        )
302        .unwrap();
303
304        // Get all categories in a deterministic order
305        let mut categories: Vec<FunctionCategory> = self.by_category.keys().copied().collect();
306        categories.sort_by_key(|c| format!("{c:?}"));
307
308        for category in categories {
309            let functions = self.get_by_category(category);
310            if functions.is_empty() {
311                continue;
312            }
313
314            writeln!(&mut doc, "## {category} Functions\n").unwrap();
315
316            // Sort functions by name for consistent output
317            let mut functions = functions;
318            functions.sort_by_key(|f| f.name);
319
320            for func in functions {
321                writeln!(&mut doc, "### {}()\n", func.name).unwrap();
322                writeln!(&mut doc, "**Description:** {}\n", func.description).unwrap();
323                writeln!(
324                    &mut doc,
325                    "**Arguments:** {}\n",
326                    func.arg_count.description()
327                )
328                .unwrap();
329                writeln!(&mut doc, "**Returns:** {}\n", func.returns).unwrap();
330
331                if !func.examples.is_empty() {
332                    writeln!(&mut doc, "**Examples:**").unwrap();
333                    writeln!(&mut doc, "```sql").unwrap();
334                    for example in &func.examples {
335                        writeln!(&mut doc, "{example}").unwrap();
336                    }
337                    writeln!(&mut doc, "```\n").unwrap();
338                }
339            }
340        }
341
342        doc
343    }
344
345    /// Generate help text for a specific function
346    #[must_use]
347    pub fn generate_function_help(&self, name: &str) -> Option<String> {
348        self.get(name).map(|func| {
349            let sig = func.signature();
350            let mut help = String::new();
351            use std::fmt::Write;
352
353            writeln!(&mut help, "Function: {}()", sig.name).unwrap();
354            writeln!(&mut help, "Category: {}", sig.category).unwrap();
355            writeln!(&mut help, "Description: {}", sig.description).unwrap();
356            writeln!(&mut help, "Arguments: {}", sig.arg_count.description()).unwrap();
357            writeln!(&mut help, "Returns: {}", sig.returns).unwrap();
358
359            if !sig.examples.is_empty() {
360                writeln!(&mut help, "\nExamples:").unwrap();
361                for example in &sig.examples {
362                    writeln!(&mut help, "  {example}").unwrap();
363                }
364            }
365
366            help
367        })
368    }
369
370    /// List all available functions with brief descriptions
371    #[must_use]
372    pub fn list_functions(&self) -> String {
373        use std::fmt::Write;
374        let mut list = String::new();
375
376        writeln!(&mut list, "Available SQL Functions:\n").unwrap();
377
378        let mut categories: Vec<FunctionCategory> = self.by_category.keys().copied().collect();
379        categories.sort_by_key(|c| format!("{c:?}"));
380
381        for category in categories {
382            let functions = self.get_by_category(category);
383            if functions.is_empty() {
384                continue;
385            }
386
387            writeln!(&mut list, "{category} Functions:").unwrap();
388
389            let mut functions = functions;
390            functions.sort_by_key(|f| f.name);
391
392            for func in functions {
393                writeln!(
394                    &mut list,
395                    "  {:20} - {}",
396                    format!("{}()", func.name),
397                    func.description
398                )
399                .unwrap();
400            }
401            writeln!(&mut list).unwrap();
402        }
403
404        list
405    }
406
407    /// Register constant functions
408    fn register_constants(&mut self) {
409        use constants::{
410            EFunction, HbarFunction, MassElectronFunction, MeFunction, PhiFunction,
411            PiDigitFunction, PiDigitsFunction, PiFunction, TauFunction,
412        };
413
414        self.register(Box::new(PiFunction));
415        self.register(Box::new(PiDigitsFunction)); // Arbitrary precision pi
416        self.register(Box::new(PiDigitFunction)); // Single digit lookup
417        self.register(Box::new(EFunction));
418        self.register(Box::new(MeFunction)); // Mass of electron
419        self.register(Box::new(MassElectronFunction)); // Alias for ME
420        self.register(Box::new(TauFunction));
421        self.register(Box::new(PhiFunction));
422        self.register(Box::new(HbarFunction));
423    }
424
425    /// Register astronomical functions
426    fn register_astronomical_functions(&mut self) {
427        use astronomy::{
428            AuFunction, DistJupiterFunction, DistMarsFunction, DistMercuryFunction,
429            DistNeptuneFunction, DistSaturnFunction, DistUranusFunction, DistVenusFunction,
430            LightYearFunction, MassEarthFunction, MassJupiterFunction, MassMarsFunction,
431            MassMercuryFunction, MassMoonFunction, MassNeptuneFunction, MassSaturnFunction,
432            MassSunFunction, MassUranusFunction, MassVenusFunction, ParsecFunction,
433            RadiusEarthFunction, RadiusJupiterFunction, RadiusMarsFunction, RadiusMercuryFunction,
434            RadiusMoonFunction, RadiusNeptuneFunction, RadiusSaturnFunction, RadiusSunFunction,
435            RadiusUranusFunction, RadiusVenusFunction,
436        };
437
438        use solar_system::{
439            DensitySolarBodyFunction, DistanceSolarBodyFunction, EscapeVelocitySolarBodyFunction,
440            GravitySolarBodyFunction, MassSolarBodyFunction, MoonsSolarBodyFunction,
441            OrbitalPeriodSolarBodyFunction, RadiusSolarBodyFunction,
442            RotationPeriodSolarBodyFunction,
443        };
444
445        self.register(Box::new(MassEarthFunction));
446        self.register(Box::new(MassSunFunction));
447        self.register(Box::new(MassMoonFunction));
448        self.register(Box::new(AuFunction)); // Astronomical unit
449        self.register(Box::new(LightYearFunction));
450        self.register(Box::new(ParsecFunction));
451
452        // Planetary masses
453        self.register(Box::new(MassMercuryFunction));
454        self.register(Box::new(MassVenusFunction));
455        self.register(Box::new(MassMarsFunction));
456        self.register(Box::new(MassJupiterFunction));
457        self.register(Box::new(MassSaturnFunction));
458        self.register(Box::new(MassUranusFunction));
459        self.register(Box::new(MassNeptuneFunction));
460
461        // Solar body radius functions
462        self.register(Box::new(RadiusSunFunction));
463        self.register(Box::new(RadiusEarthFunction));
464        self.register(Box::new(RadiusMoonFunction));
465        self.register(Box::new(RadiusMercuryFunction));
466        self.register(Box::new(RadiusVenusFunction));
467        self.register(Box::new(RadiusMarsFunction));
468        self.register(Box::new(RadiusJupiterFunction));
469        self.register(Box::new(RadiusSaturnFunction));
470        self.register(Box::new(RadiusUranusFunction));
471        self.register(Box::new(RadiusNeptuneFunction));
472
473        // Planetary distances from the Sun
474        self.register(Box::new(DistMercuryFunction));
475        self.register(Box::new(DistVenusFunction));
476        self.register(Box::new(DistMarsFunction));
477        self.register(Box::new(DistJupiterFunction));
478        self.register(Box::new(DistSaturnFunction));
479        self.register(Box::new(DistUranusFunction));
480        self.register(Box::new(DistNeptuneFunction));
481
482        // Solar system lookup functions
483        self.register(Box::new(MassSolarBodyFunction));
484        self.register(Box::new(RadiusSolarBodyFunction));
485        self.register(Box::new(DistanceSolarBodyFunction));
486        self.register(Box::new(OrbitalPeriodSolarBodyFunction));
487        self.register(Box::new(GravitySolarBodyFunction));
488        self.register(Box::new(DensitySolarBodyFunction));
489        self.register(Box::new(EscapeVelocitySolarBodyFunction));
490        self.register(Box::new(RotationPeriodSolarBodyFunction));
491        self.register(Box::new(MoonsSolarBodyFunction));
492    }
493
494    /// Register chemical functions
495    fn register_chemical_functions(&mut self) {
496        use chemistry::{
497            AtomicMassFunction, AtomicNumberFunction, AvogadroFunction, MoleculeFormulaFunction,
498            NeutronsFunction,
499        };
500
501        self.register(Box::new(AvogadroFunction));
502        self.register(Box::new(AtomicMassFunction));
503        self.register(Box::new(AtomicNumberFunction));
504        self.register(Box::new(NeutronsFunction));
505        self.register(Box::new(MoleculeFormulaFunction));
506    }
507
508    /// Register string method functions
509    fn register_string_methods(&mut self) {
510        use case_convert::{
511            ToCamelCaseFunction, ToConstantCaseFunction, ToKebabCaseFunction, ToPascalCaseFunction,
512            ToSnakeCaseFunction,
513        };
514        use number_words::{ToOrdinal, ToOrdinalWords, ToWords};
515        use path::{
516            BasenameFunction, DirnameFunction, ExtensionFunction, PathDepthFunction,
517            PathPartFunction, StemFunction,
518        };
519        use string_fun::{
520            InitCapFunction, MorseCodeFunction, PigLatinFunction, ProperFunction, ReverseFunction,
521            Rot13Function, ScrambleFunction, SoundexFunction,
522        };
523        use string_utils::{LPadFunction, RPadFunction, RepeatFunction};
524        use text_processing::{CleanText, ExtractWords, StripPunctuation, Tokenize, WordCount};
525
526        string_methods::register_string_methods(self);
527
528        // String utility functions
529        self.register(Box::new(RepeatFunction));
530        self.register(Box::new(LPadFunction));
531        self.register(Box::new(RPadFunction));
532
533        // Path / filename functions (POSIX-style)
534        self.register(Box::new(BasenameFunction));
535        self.register(Box::new(DirnameFunction));
536        self.register(Box::new(ExtensionFunction));
537        self.register(Box::new(StemFunction));
538        self.register(Box::new(PathDepthFunction));
539        self.register(Box::new(PathPartFunction));
540
541        // Case conversion functions
542        self.register(Box::new(ToSnakeCaseFunction));
543        self.register(Box::new(ToCamelCaseFunction));
544        self.register(Box::new(ToPascalCaseFunction));
545        self.register(Box::new(ToKebabCaseFunction));
546        self.register(Box::new(ToConstantCaseFunction));
547
548        // String fun & transformation functions
549        self.register(Box::new(ReverseFunction));
550        self.register(Box::new(InitCapFunction));
551        self.register(Box::new(ProperFunction));
552        self.register(Box::new(Rot13Function));
553        self.register(Box::new(SoundexFunction));
554        self.register(Box::new(PigLatinFunction));
555        self.register(Box::new(MorseCodeFunction));
556        self.register(Box::new(ScrambleFunction));
557
558        // Number to words functions
559        self.register(Box::new(ToWords));
560        self.register(Box::new(ToOrdinal));
561        self.register(Box::new(ToOrdinalWords));
562
563        // Text processing functions
564        self.register(Box::new(StripPunctuation));
565        self.register(Box::new(Tokenize));
566        self.register(Box::new(CleanText));
567        self.register(Box::new(ExtractWords));
568        self.register(Box::new(WordCount));
569    }
570
571    /// Register geometry functions
572    fn register_geometry_functions(&mut self) {
573        use geometry::{
574            CircleAreaFunction, CircleCircumferenceFunction, Distance2DFunction,
575            PythagorasFunction, SphereSurfaceAreaFunction, SphereVolumeFunction,
576            TriangleAreaFunction,
577        };
578
579        self.register(Box::new(PythagorasFunction));
580        self.register(Box::new(CircleAreaFunction));
581        self.register(Box::new(CircleCircumferenceFunction));
582        self.register(Box::new(SphereVolumeFunction));
583        self.register(Box::new(SphereSurfaceAreaFunction));
584        self.register(Box::new(TriangleAreaFunction));
585        self.register(Box::new(Distance2DFunction));
586    }
587
588    /// Register hash functions
589    fn register_hash_functions(&mut self) {
590        use hash::{Md5Function, Sha1Function, Sha256Function, Sha512Function};
591
592        self.register(Box::new(Md5Function));
593        self.register(Box::new(Sha1Function));
594        self.register(Box::new(Sha256Function));
595        self.register(Box::new(Sha512Function));
596    }
597
598    /// Register comparison functions
599    fn register_comparison_functions(&mut self) {
600        comparison::register_comparison_functions(self);
601    }
602
603    /// Register mathematical functions
604    fn register_mathematical_functions(&mut self) {
605        use base_conversion::{
606            FromBase, FromBinary, FromHex, FromOctal, ToBase, ToBinary, ToHex, ToOctal,
607        };
608        use integer_limits::{
609            ByteMax, ByteMin, CharMax, CharMin, Int16Max, Int16Min, Int32Max, Int32Min, Int64Max,
610            Int64Min, Int8Max, Int8Min, IntMax, IntMin, LongMax, LongMin, ShortMax, ShortMin,
611            Uint16Max, Uint32Max, Uint8Max,
612        };
613        use mathematics::{
614            IsPrimeFunction, NextPrimeFunction, NthPrimeFunction, PrevPrimeFunction,
615            PrimeCountFunction, PrimeFunction, PrimePiFunction,
616        };
617        use trigonometry::{
618            AcosFunction, AsinFunction, Atan2Function, AtanFunction, CosFunction, CoshFunction,
619            CotFunction, SinFunction, SinhFunction, TanFunction, TanhFunction,
620        };
621
622        // Prime number functions
623        self.register(Box::new(PrimeFunction));
624        self.register(Box::new(NthPrimeFunction)); // Alias for PRIME
625        self.register(Box::new(IsPrimeFunction));
626        self.register(Box::new(PrimeCountFunction));
627        self.register(Box::new(PrimePiFunction)); // Alias for PRIME_COUNT
628        self.register(Box::new(NextPrimeFunction));
629        self.register(Box::new(PrevPrimeFunction));
630
631        // Trigonometric functions
632        self.register(Box::new(SinFunction));
633        self.register(Box::new(CosFunction));
634        self.register(Box::new(TanFunction));
635        self.register(Box::new(CotFunction));
636        self.register(Box::new(AsinFunction));
637        self.register(Box::new(AcosFunction));
638        self.register(Box::new(AtanFunction));
639        self.register(Box::new(Atan2Function));
640
641        // Hyperbolic functions
642        self.register(Box::new(SinhFunction));
643        self.register(Box::new(CoshFunction));
644        self.register(Box::new(TanhFunction));
645
646        // Base conversion functions
647        self.register(Box::new(ToBase));
648        self.register(Box::new(FromBase));
649        self.register(Box::new(ToBinary));
650        self.register(Box::new(FromBinary));
651        self.register(Box::new(ToHex));
652        self.register(Box::new(FromHex));
653        self.register(Box::new(ToOctal));
654        self.register(Box::new(FromOctal));
655
656        // Integer limit functions
657        self.register(Box::new(Int8Min));
658        self.register(Box::new(Int8Max));
659        self.register(Box::new(Uint8Max));
660        self.register(Box::new(Int16Min));
661        self.register(Box::new(Int16Max));
662        self.register(Box::new(Uint16Max));
663        self.register(Box::new(Int32Min));
664        self.register(Box::new(Int32Max));
665        self.register(Box::new(Uint32Max));
666        self.register(Box::new(Int64Min));
667        self.register(Box::new(Int64Max));
668
669        // Alias functions for common names
670        self.register(Box::new(ByteMin));
671        self.register(Box::new(ByteMax));
672        self.register(Box::new(CharMin));
673        self.register(Box::new(CharMax));
674        self.register(Box::new(ShortMin));
675        self.register(Box::new(ShortMax));
676        self.register(Box::new(IntMin));
677        self.register(Box::new(IntMax));
678        self.register(Box::new(LongMin));
679        self.register(Box::new(LongMax));
680
681        // General math functions
682        math::register_math_functions(self);
683    }
684
685    /// Register physics constants
686    fn register_physics_functions(&mut self) {
687        physics::register_physics_functions(self);
688
689        // Register particle charge functions
690        use particle_charges::{
691            ChargeDownQuarkFunction, ChargeElectronFunction, ChargeMuonFunction,
692            ChargeNeutronFunction, ChargePositronFunction, ChargeProtonFunction, ChargeTauFunction,
693            ChargeUpQuarkFunction,
694        };
695
696        self.register(Box::new(ChargeElectronFunction));
697        self.register(Box::new(ChargeProtonFunction));
698        self.register(Box::new(ChargeNeutronFunction));
699        self.register(Box::new(ChargeUpQuarkFunction));
700        self.register(Box::new(ChargeDownQuarkFunction));
701        self.register(Box::new(ChargePositronFunction));
702        self.register(Box::new(ChargeMuonFunction));
703        self.register(Box::new(ChargeTauFunction));
704    }
705
706    /// Register date/time functions
707    fn register_date_time_functions(&mut self) {
708        date_time::register_date_time_functions(self);
709    }
710
711    /// Register financial functions
712    fn register_financial_functions(&mut self) {
713        financial::register_financial_functions(self);
714    }
715
716    /// Register conversion functions
717    fn register_conversion_functions(&mut self) {
718        use cast::CastFunction;
719        use convert::ConvertFunction;
720        use roman::{FromRoman, ToRoman};
721
722        self.register(Box::new(ConvertFunction));
723        self.register(Box::new(ToRoman));
724        self.register(Box::new(FromRoman));
725        // CAST(expr AS type) / expr::type, plus the NULL-on-failure TRY_CAST.
726        self.register(Box::new(CastFunction { try_cast: false }));
727        self.register(Box::new(CastFunction { try_cast: true }));
728    }
729
730    /// Register statistical functions
731    fn register_statistical_functions(&mut self) {
732        use statistics::{
733            CorrelationFunction, KurtosisFunction, MedianFunction, ModeFunction,
734            PercentileFunction, SkewFunction, VarPopFunction, VarSampFunction, VarianceFunction,
735        };
736
737        self.register(Box::new(MedianFunction));
738        self.register(Box::new(PercentileFunction));
739        self.register(Box::new(ModeFunction));
740        self.register(Box::new(VarianceFunction));
741        self.register(Box::new(VarSampFunction));
742        self.register(Box::new(VarPopFunction));
743        self.register(Box::new(CorrelationFunction));
744        self.register(Box::new(SkewFunction));
745        self.register(Box::new(KurtosisFunction));
746    }
747
748    /// Register aggregate and analytic functions
749    fn register_aggregate_functions(&mut self) {
750        use group_num::GroupNumFunction;
751
752        // Register GROUP_NUM function
753        // Note: We create a new instance per query to ensure clean memoization
754        self.register(Box::new(GroupNumFunction::new()));
755    }
756
757    /// Register random number generation functions
758    fn register_random_functions(&mut self) {
759        use random::{RandIntFunction, RandRangeFunction, RandomFunction};
760
761        self.register(Box::new(RandomFunction));
762        self.register(Box::new(RandIntFunction));
763        self.register(Box::new(RandRangeFunction));
764    }
765
766    /// Register formatting functions
767    fn register_format_functions(&mut self) {
768        use format::{
769            CenterFunction, DateFormatFunction, FormatDateFunction, FormatNumberFunction,
770            LPadFunction, RPadFunction,
771        };
772        use format_number::{FormatBytesFunction, FormatCurrencyFunction, RenderNumberFunction};
773
774        self.register(Box::new(FormatNumberFunction));
775        self.register(Box::new(FormatDateFunction));
776        self.register(Box::new(DateFormatFunction));
777        self.register(Box::new(LPadFunction));
778        self.register(Box::new(RPadFunction));
779        self.register(Box::new(CenterFunction));
780        self.register(Box::new(RenderNumberFunction));
781        self.register(Box::new(FormatCurrencyFunction));
782        self.register(Box::new(FormatBytesFunction));
783    }
784
785    /// Register type checking functions
786    fn register_type_checking_functions(&mut self) {
787        use type_checking::{
788            IsBoolFunction, IsDateFunction, IsFloatFunction, IsIntegerFunction, IsNotNullFunction,
789            IsNullFunction, IsNumericFunction,
790        };
791
792        self.register(Box::new(IsDateFunction));
793        self.register(Box::new(IsBoolFunction));
794        self.register(Box::new(IsNumericFunction));
795        self.register(Box::new(IsIntegerFunction));
796        self.register(Box::new(IsFloatFunction));
797        self.register(Box::new(IsNullFunction));
798        self.register(Box::new(IsNotNullFunction));
799    }
800
801    /// Register utility functions
802    fn register_utility_functions(&mut self) {
803        use utility::{
804            AsciiFunction, CharFunction, DecodeFunction, EncodeFunction, OrdFunction,
805            ToDecimalFunction, ToIntFunction, ToStringFunction, UnicodeFunction,
806        };
807
808        self.register(Box::new(AsciiFunction));
809        self.register(Box::new(OrdFunction));
810        self.register(Box::new(CharFunction));
811        self.register(Box::new(ToIntFunction));
812        self.register(Box::new(ToDecimalFunction));
813        self.register(Box::new(ToStringFunction));
814        self.register(Box::new(EncodeFunction));
815        self.register(Box::new(DecodeFunction));
816        self.register(Box::new(UnicodeFunction));
817    }
818
819    /// Register big integer and bit manipulation functions
820    fn register_bigint_functions(&mut self) {
821        use bigint::{
822            BigAddFunction, BigFactorialFunction, BigIntFunction, BigMulFunction, BigPowFunction,
823            BitAndFunction, BitOrFunction, BitShiftFunction, BitXorFunction, FromBinaryFunction,
824            FromHexFunction, ToBinaryFunction, ToHexFunction,
825        };
826
827        // Arbitrary precision arithmetic
828        self.register(Box::new(BigIntFunction));
829        self.register(Box::new(BigAddFunction));
830        self.register(Box::new(BigMulFunction));
831        self.register(Box::new(BigPowFunction));
832        self.register(Box::new(BigFactorialFunction));
833
834        // Bit manipulation
835        self.register(Box::new(BitAndFunction));
836        self.register(Box::new(BitOrFunction));
837        self.register(Box::new(BitXorFunction));
838        self.register(Box::new(BitShiftFunction));
839
840        // Base conversions
841        self.register(Box::new(ToBinaryFunction));
842        self.register(Box::new(FromBinaryFunction));
843        self.register(Box::new(ToHexFunction));
844        self.register(Box::new(FromHexFunction));
845    }
846
847    /// Register bitwise functions (additional bit operations not in bigint)
848    fn register_bitwise_functions(&mut self) {
849        bitwise::register_bitwise_functions(self);
850
851        // Register string-based bitwise operations
852        self.register(Box::new(bitwise_string::BitAndStr));
853        self.register(Box::new(bitwise_string::BitOrStr));
854        self.register(Box::new(bitwise_string::BitXorStr));
855        self.register(Box::new(bitwise_string::BitNotStr));
856        self.register(Box::new(bitwise_string::BitFlip));
857        self.register(Box::new(bitwise_string::BitCount));
858        self.register(Box::new(bitwise_string::BitRotateLeft));
859        self.register(Box::new(bitwise_string::BitRotateRight));
860        self.register(Box::new(bitwise_string::BitShiftLeft));
861        self.register(Box::new(bitwise_string::BitShiftRight));
862        self.register(Box::new(bitwise_string::HammingDistance));
863    }
864
865    /// Register ANSI terminal formatting functions
866    fn register_ansi_functions(&mut self) {
867        use ansi::{
868            AnsiBgFunction, AnsiBlinkFunction, AnsiBoldFunction, AnsiColorFunction,
869            AnsiItalicFunction, AnsiReverseFunction, AnsiRgbBgFunction, AnsiRgbFunction,
870            AnsiStrikethroughFunction, AnsiUnderlineFunction,
871        };
872
873        // Color functions
874        self.register(Box::new(AnsiColorFunction));
875        self.register(Box::new(AnsiBgFunction));
876        self.register(Box::new(AnsiRgbFunction));
877        self.register(Box::new(AnsiRgbBgFunction));
878
879        // Formatting functions
880        self.register(Box::new(AnsiBoldFunction));
881        self.register(Box::new(AnsiItalicFunction));
882        self.register(Box::new(AnsiUnderlineFunction));
883        self.register(Box::new(AnsiBlinkFunction));
884        self.register(Box::new(AnsiReverseFunction));
885        self.register(Box::new(AnsiStrikethroughFunction));
886    }
887
888    /// Register vector mathematics functions
889    fn register_vector_functions(&mut self) {
890        use vector::{
891            ClosestPointOnLineFunction, LineIntersectFunction, LineReflectPointFunction,
892            PointLineDistanceFunction, SegmentIntersectFunction, VecAddFunction, VecAngleFunction,
893            VecCrossFunction, VecDistanceFunction, VecDotFunction, VecFunction, VecMagFunction,
894            VecNormalizeFunction, VecScaleFunction, VecSubFunction,
895        };
896
897        // Vector construction
898        self.register(Box::new(VecFunction));
899
900        // Vector operations
901        self.register(Box::new(VecAddFunction));
902        self.register(Box::new(VecSubFunction));
903        self.register(Box::new(VecScaleFunction));
904
905        // Vector analysis
906        self.register(Box::new(VecDotFunction));
907        self.register(Box::new(VecMagFunction));
908        self.register(Box::new(VecNormalizeFunction));
909        self.register(Box::new(VecDistanceFunction));
910        self.register(Box::new(VecCrossFunction));
911        self.register(Box::new(VecAngleFunction));
912
913        // Line geometry
914        self.register(Box::new(LineIntersectFunction));
915        self.register(Box::new(SegmentIntersectFunction));
916        self.register(Box::new(ClosestPointOnLineFunction));
917        self.register(Box::new(PointLineDistanceFunction));
918        self.register(Box::new(LineReflectPointFunction));
919    }
920}
921
922impl Default for FunctionRegistry {
923    fn default() -> Self {
924        Self::new()
925    }
926}
927
928#[cfg(test)]
929mod tests {
930    use super::*;
931
932    #[test]
933    fn test_registry_creation() {
934        let registry = FunctionRegistry::new();
935
936        // Check that some known functions exist
937        assert!(registry.contains("PI"));
938        assert!(registry.contains("MASS_EARTH"));
939        assert!(registry.contains("ME"));
940    }
941
942    #[test]
943    fn test_case_insensitive_lookup() {
944        let registry = FunctionRegistry::new();
945
946        assert!(registry.get("pi").is_some());
947        assert!(registry.get("PI").is_some());
948        assert!(registry.get("Pi").is_some());
949    }
950
951    #[test]
952    fn test_autocomplete() {
953        let registry = FunctionRegistry::new();
954
955        let mass_functions = registry.autocomplete("MASS");
956        assert!(!mass_functions.is_empty());
957
958        // Should include MASS_EARTH, MASS_SUN, etc.
959        let names: Vec<&str> = mass_functions.iter().map(|sig| sig.name).collect();
960        assert!(names.contains(&"MASS_EARTH"));
961        assert!(names.contains(&"MASS_SUN"));
962    }
963}
sql_cli/sql/functions/mod.rs

sql_cli/sql/functions/
mod.rs
