Skip to main content

flowscope_core/generated/
functions.rs

1//! Function classification sets.
2//!
3//! Generated from functions.json
4//!
5//! This module provides sets of SQL function names categorized by their behavior
6//! (aggregate, window, table-generating). These classifications are used during
7//! lineage analysis to determine how expressions should be analyzed.
8
9use std::collections::HashSet;
10use std::sync::LazyLock;
11
12/// Aggregate functions (57 total).
13pub static AGGREGATE_FUNCTIONS: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
14    let mut set = HashSet::new();
15    set.insert("agg_func");
16    set.insert("ai_agg");
17    set.insert("ai_summarize_agg");
18    set.insert("any_value");
19    set.insert("approx_distinct");
20    set.insert("approx_quantile");
21    set.insert("approx_quantiles");
22    set.insert("approx_top_k");
23    set.insert("approx_top_k_accumulate");
24    set.insert("approx_top_k_combine");
25    set.insert("approx_top_sum");
26    set.insert("approximate_similarity");
27    set.insert("arg_max");
28    set.insert("arg_min");
29    set.insert("array_agg");
30    set.insert("array_concat_agg");
31    set.insert("array_union_agg");
32    set.insert("array_unique_agg");
33    set.insert("avg");
34    set.insert("bitmap_construct_agg");
35    set.insert("bitmap_or_agg");
36    set.insert("bitwise_and_agg");
37    set.insert("bitwise_or_agg");
38    set.insert("bitwise_xor_agg");
39    set.insert("boolxor_agg");
40    set.insert("combined_agg_func");
41    set.insert("combined_parameterized_agg");
42    set.insert("corr");
43    set.insert("count");
44    set.insert("count_if");
45    set.insert("covar_pop");
46    set.insert("covar_samp");
47    set.insert("first");
48    set.insert("group_concat");
49    set.insert("grouping");
50    set.insert("grouping_id");
51    set.insert("hll");
52    set.insert("json_object_agg");
53    set.insert("jsonb_object_agg");
54    set.insert("last");
55    set.insert("logical_and");
56    set.insert("logical_or");
57    set.insert("max");
58    set.insert("median");
59    set.insert("min");
60    set.insert("minhash");
61    set.insert("minhash_combine");
62    set.insert("object_agg");
63    set.insert("parameterized_agg");
64    set.insert("quantile");
65    set.insert("skewness");
66    set.insert("stddev");
67    set.insert("stddev_pop");
68    set.insert("stddev_samp");
69    set.insert("sum");
70    set.insert("variance");
71    set.insert("variance_pop");
72    set
73});
74
75/// Window functions (13 total).
76pub static WINDOW_FUNCTIONS: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
77    let mut set = HashSet::new();
78    set.insert("cume_dist");
79    set.insert("dense_rank");
80    set.insert("first_value");
81    set.insert("lag");
82    set.insert("last_value");
83    set.insert("lead");
84    set.insert("nth_value");
85    set.insert("ntile");
86    set.insert("percent_rank");
87    set.insert("percentile_cont");
88    set.insert("percentile_disc");
89    set.insert("rank");
90    set.insert("row_number");
91    set
92});
93
94/// Table-generating functions / UDTFs (5 total).
95pub static UDTF_FUNCTIONS: LazyLock<HashSet<&'static str>> = LazyLock::new(|| {
96    let mut set = HashSet::new();
97    set.insert("explode");
98    set.insert("explode_outer");
99    set.insert("posexplode");
100    set.insert("posexplode_outer");
101    set.insert("unnest");
102    set
103});
104
105/// Checks if a function is an aggregate function (e.g., SUM, COUNT, AVG).
106///
107/// Aggregate functions combine multiple input rows into a single output value.
108/// This classification is used to detect aggregation in SELECT expressions
109/// and validate GROUP BY semantics.
110///
111/// The check is case-insensitive. Uses ASCII lowercase for performance since
112/// SQL function names are always ASCII.
113pub fn is_aggregate_function(name: &str) -> bool {
114    // SQL function names are ASCII, so we can use the faster ASCII lowercase
115    let lower = name.to_ascii_lowercase();
116    AGGREGATE_FUNCTIONS.contains(lower.as_str())
117}
118
119/// Checks if a function is a window function (e.g., ROW_NUMBER, RANK, LAG).
120///
121/// Window functions perform calculations across a set of rows related to
122/// the current row, without collapsing them into a single output.
123///
124/// The check is case-insensitive. Uses ASCII lowercase for performance since
125/// SQL function names are always ASCII.
126pub fn is_window_function(name: &str) -> bool {
127    // SQL function names are ASCII, so we can use the faster ASCII lowercase
128    let lower = name.to_ascii_lowercase();
129    WINDOW_FUNCTIONS.contains(lower.as_str())
130}
131
132/// Checks if a function is a table-generating function / UDTF (e.g., UNNEST, EXPLODE).
133///
134/// UDTFs return multiple rows for each input row, expanding the result set.
135/// This classification affects how lineage is tracked through these functions.
136///
137/// The check is case-insensitive. Uses ASCII lowercase for performance since
138/// SQL function names are always ASCII.
139pub fn is_udtf_function(name: &str) -> bool {
140    // SQL function names are ASCII, so we can use the faster ASCII lowercase
141    let lower = name.to_ascii_lowercase();
142    UDTF_FUNCTIONS.contains(lower.as_str())
143}
144
145/// Return type rule for function type inference.
146///
147/// This enum represents the different strategies for determining a function's
148/// return type during type inference in SQL analysis.
149#[derive(Debug, Clone, Copy, PartialEq, Eq)]
150pub enum ReturnTypeRule {
151    /// Returns Integer (e.g., COUNT, ROW_NUMBER)
152    Integer,
153    /// Returns Number (e.g., SUM, AVG)
154    Numeric,
155    /// Returns Text (e.g., CONCAT, SUBSTRING)
156    Text,
157    /// Returns Timestamp (e.g., NOW, CURRENT_TIMESTAMP)
158    Timestamp,
159    /// Returns Boolean (e.g., AND, OR)
160    Boolean,
161    /// Returns Date (e.g., CURRENT_DATE)
162    Date,
163    /// Returns same type as first argument (e.g., MIN, MAX, COALESCE)
164    MatchFirstArg,
165}
166
167/// Infers the return type rule for a SQL function.
168///
169/// This function returns the return type rule for known SQL functions,
170/// enabling data-driven type inference. The check is case-insensitive.
171///
172/// # Arguments
173///
174/// * `name` - The function name (case-insensitive)
175///
176/// # Returns
177///
178/// `Some(ReturnTypeRule)` if the function has a known return type rule,
179/// `None` otherwise (fallback to existing logic).
180///
181/// # Example
182///
183/// ```ignore
184/// use flowscope_core::generated::infer_function_return_type;
185///
186/// assert_eq!(infer_function_return_type("COUNT"), Some(ReturnTypeRule::Integer));
187/// assert_eq!(infer_function_return_type("MIN"), Some(ReturnTypeRule::MatchFirstArg));
188/// assert_eq!(infer_function_return_type("UNKNOWN_FUNC"), None);
189/// ```
190pub fn infer_function_return_type(name: &str) -> Option<ReturnTypeRule> {
191    // SQL function names are ASCII, so we can use the faster ASCII lowercase
192    let lower = name.to_ascii_lowercase();
193    match lower.as_str() {
194        "and" => Some(ReturnTypeRule::Boolean),
195        "any_value" => Some(ReturnTypeRule::MatchFirstArg),
196        "avg" => Some(ReturnTypeRule::Numeric),
197        "coalesce" => Some(ReturnTypeRule::MatchFirstArg),
198        "concat" => Some(ReturnTypeRule::Text),
199        "concat_ws" => Some(ReturnTypeRule::Text),
200        "count" => Some(ReturnTypeRule::Integer),
201        "current_date" => Some(ReturnTypeRule::Date),
202        "current_timestamp" => Some(ReturnTypeRule::Timestamp),
203        "date_trunc" => Some(ReturnTypeRule::MatchFirstArg),
204        "dense_rank" => Some(ReturnTypeRule::Integer),
205        "first_value" => Some(ReturnTypeRule::MatchFirstArg),
206        "lag" => Some(ReturnTypeRule::MatchFirstArg),
207        "last_value" => Some(ReturnTypeRule::MatchFirstArg),
208        "lead" => Some(ReturnTypeRule::MatchFirstArg),
209        "lower" => Some(ReturnTypeRule::Text),
210        "max" => Some(ReturnTypeRule::MatchFirstArg),
211        "min" => Some(ReturnTypeRule::MatchFirstArg),
212        "now" => Some(ReturnTypeRule::Timestamp),
213        "ntile" => Some(ReturnTypeRule::Integer),
214        "or" => Some(ReturnTypeRule::Boolean),
215        "rank" => Some(ReturnTypeRule::Integer),
216        "replace" => Some(ReturnTypeRule::Text),
217        "row_number" => Some(ReturnTypeRule::Integer),
218        "substring" => Some(ReturnTypeRule::Text),
219        "sum" => Some(ReturnTypeRule::Numeric),
220        "trim" => Some(ReturnTypeRule::Text),
221        "upper" => Some(ReturnTypeRule::Text),
222        _ => None,
223    }
224}
225
226/// Function category for completion context filtering.
227#[derive(Debug, Clone, Copy, PartialEq, Eq)]
228pub enum FunctionCategory {
229    /// Aggregate functions (SUM, COUNT, AVG, etc.)
230    Aggregate,
231    /// Window functions (ROW_NUMBER, RANK, LAG, etc.)
232    Window,
233    /// Scalar functions (LOWER, CONCAT, ABS, etc.)
234    Scalar,
235}
236
237/// Function parameter information for completion.
238#[derive(Debug, Clone)]
239pub struct FunctionParam {
240    /// Parameter name (e.g., "expression", "separator")
241    pub name: &'static str,
242    /// Whether this parameter is required
243    pub required: bool,
244}
245
246/// Function signature for smart completion.
247///
248/// Contains all metadata needed to display rich function completions
249/// with parameter hints and return type information.
250#[derive(Debug, Clone)]
251pub struct FunctionSignature {
252    /// Function name in lowercase (for lookup)
253    pub name: &'static str,
254    /// Display name in uppercase (for completion label)
255    pub display_name: &'static str,
256    /// Function parameters
257    pub params: &'static [FunctionParam],
258    /// Return type rule, if known
259    pub return_type: Option<ReturnTypeRule>,
260    /// Function category
261    pub category: FunctionCategory,
262}
263
264impl FunctionSignature {
265    /// Formats the function signature as "NAME(params) → TYPE"
266    pub fn format_signature(&self) -> String {
267        let params_str = self
268            .params
269            .iter()
270            .map(|p| {
271                if p.required {
272                    p.name.to_string()
273                } else {
274                    format!("[{}]", p.name)
275                }
276            })
277            .collect::<Vec<_>>()
278            .join(", ");
279
280        let return_str = self
281            .return_type
282            .map(|rt| {
283                format!(
284                    " → {}",
285                    match rt {
286                        ReturnTypeRule::Integer => "INTEGER",
287                        ReturnTypeRule::Numeric => "NUMERIC",
288                        ReturnTypeRule::Text => "TEXT",
289                        ReturnTypeRule::Timestamp => "TIMESTAMP",
290                        ReturnTypeRule::Boolean => "BOOLEAN",
291                        ReturnTypeRule::Date => "DATE",
292                        ReturnTypeRule::MatchFirstArg => "T",
293                    }
294                )
295            })
296            .unwrap_or_default();
297
298        format!("{}({}){}", self.display_name, params_str, return_str)
299    }
300}
301
302/// Static function parameter definitions.
303static PARAMS_ABS: &[FunctionParam] = &[FunctionParam {
304    name: "this",
305    required: true,
306}];
307static PARAMS_ACOS: &[FunctionParam] = &[FunctionParam {
308    name: "this",
309    required: true,
310}];
311static PARAMS_ACOSH: &[FunctionParam] = &[FunctionParam {
312    name: "this",
313    required: true,
314}];
315static PARAMS_ADD_MONTHS: &[FunctionParam] = &[
316    FunctionParam {
317        name: "this",
318        required: true,
319    },
320    FunctionParam {
321        name: "expression",
322        required: true,
323    },
324];
325static PARAMS_AGG_FUNC: &[FunctionParam] = &[FunctionParam {
326    name: "this",
327    required: true,
328}];
329static PARAMS_AI_AGG: &[FunctionParam] = &[
330    FunctionParam {
331        name: "this",
332        required: true,
333    },
334    FunctionParam {
335        name: "expression",
336        required: true,
337    },
338];
339static PARAMS_AI_CLASSIFY: &[FunctionParam] = &[
340    FunctionParam {
341        name: "this",
342        required: true,
343    },
344    FunctionParam {
345        name: "categories",
346        required: true,
347    },
348    FunctionParam {
349        name: "config",
350        required: false,
351    },
352];
353static PARAMS_AI_SUMMARIZE_AGG: &[FunctionParam] = &[FunctionParam {
354    name: "this",
355    required: true,
356}];
357static PARAMS_AND: &[FunctionParam] = &[
358    FunctionParam {
359        name: "this",
360        required: true,
361    },
362    FunctionParam {
363        name: "expression",
364        required: true,
365    },
366];
367static PARAMS_ANY_VALUE: &[FunctionParam] = &[FunctionParam {
368    name: "this",
369    required: true,
370}];
371static PARAMS_APPLY: &[FunctionParam] = &[
372    FunctionParam {
373        name: "this",
374        required: true,
375    },
376    FunctionParam {
377        name: "expression",
378        required: true,
379    },
380];
381static PARAMS_APPROXIMATE_SIMILARITY: &[FunctionParam] = &[FunctionParam {
382    name: "this",
383    required: true,
384}];
385static PARAMS_APPROX_DISTINCT: &[FunctionParam] = &[
386    FunctionParam {
387        name: "this",
388        required: true,
389    },
390    FunctionParam {
391        name: "accuracy",
392        required: false,
393    },
394];
395static PARAMS_APPROX_QUANTILE: &[FunctionParam] = &[
396    FunctionParam {
397        name: "this",
398        required: true,
399    },
400    FunctionParam {
401        name: "quantile",
402        required: true,
403    },
404    FunctionParam {
405        name: "accuracy",
406        required: false,
407    },
408    FunctionParam {
409        name: "weight",
410        required: false,
411    },
412    FunctionParam {
413        name: "error_tolerance",
414        required: false,
415    },
416];
417static PARAMS_APPROX_QUANTILES: &[FunctionParam] = &[
418    FunctionParam {
419        name: "this",
420        required: true,
421    },
422    FunctionParam {
423        name: "expression",
424        required: false,
425    },
426];
427static PARAMS_APPROX_TOP_K: &[FunctionParam] = &[
428    FunctionParam {
429        name: "this",
430        required: true,
431    },
432    FunctionParam {
433        name: "expression",
434        required: false,
435    },
436    FunctionParam {
437        name: "counters",
438        required: false,
439    },
440];
441static PARAMS_APPROX_TOP_K_ACCUMULATE: &[FunctionParam] = &[
442    FunctionParam {
443        name: "this",
444        required: true,
445    },
446    FunctionParam {
447        name: "expression",
448        required: false,
449    },
450];
451static PARAMS_APPROX_TOP_K_COMBINE: &[FunctionParam] = &[
452    FunctionParam {
453        name: "this",
454        required: true,
455    },
456    FunctionParam {
457        name: "expression",
458        required: false,
459    },
460];
461static PARAMS_APPROX_TOP_SUM: &[FunctionParam] = &[
462    FunctionParam {
463        name: "this",
464        required: true,
465    },
466    FunctionParam {
467        name: "expression",
468        required: true,
469    },
470    FunctionParam {
471        name: "count",
472        required: true,
473    },
474];
475static PARAMS_ARG_MAX: &[FunctionParam] = &[
476    FunctionParam {
477        name: "this",
478        required: true,
479    },
480    FunctionParam {
481        name: "expression",
482        required: true,
483    },
484    FunctionParam {
485        name: "count",
486        required: false,
487    },
488];
489static PARAMS_ARG_MIN: &[FunctionParam] = &[
490    FunctionParam {
491        name: "this",
492        required: true,
493    },
494    FunctionParam {
495        name: "expression",
496        required: true,
497    },
498    FunctionParam {
499        name: "count",
500        required: false,
501    },
502];
503static PARAMS_ARRAY: &[FunctionParam] = &[FunctionParam {
504    name: "expressions",
505    required: false,
506}];
507static PARAMS_ARRAY_AGG: &[FunctionParam] = &[FunctionParam {
508    name: "this",
509    required: true,
510}];
511static PARAMS_ARRAY_ALL: &[FunctionParam] = &[
512    FunctionParam {
513        name: "this",
514        required: true,
515    },
516    FunctionParam {
517        name: "expression",
518        required: true,
519    },
520];
521static PARAMS_ARRAY_ANY: &[FunctionParam] = &[
522    FunctionParam {
523        name: "this",
524        required: true,
525    },
526    FunctionParam {
527        name: "expression",
528        required: true,
529    },
530];
531static PARAMS_ARRAY_CONCAT: &[FunctionParam] = &[
532    FunctionParam {
533        name: "this",
534        required: true,
535    },
536    FunctionParam {
537        name: "expressions",
538        required: false,
539    },
540];
541static PARAMS_ARRAY_CONCAT_AGG: &[FunctionParam] = &[FunctionParam {
542    name: "this",
543    required: true,
544}];
545static PARAMS_ARRAY_CONSTRUCT_COMPACT: &[FunctionParam] = &[FunctionParam {
546    name: "expressions",
547    required: true,
548}];
549static PARAMS_ARRAY_CONTAINS: &[FunctionParam] = &[
550    FunctionParam {
551        name: "this",
552        required: true,
553    },
554    FunctionParam {
555        name: "expression",
556        required: true,
557    },
558];
559static PARAMS_ARRAY_CONTAINS_ALL: &[FunctionParam] = &[
560    FunctionParam {
561        name: "this",
562        required: true,
563    },
564    FunctionParam {
565        name: "expression",
566        required: true,
567    },
568];
569static PARAMS_ARRAY_FILTER: &[FunctionParam] = &[
570    FunctionParam {
571        name: "this",
572        required: true,
573    },
574    FunctionParam {
575        name: "expression",
576        required: true,
577    },
578];
579static PARAMS_ARRAY_FIRST: &[FunctionParam] = &[FunctionParam {
580    name: "this",
581    required: true,
582}];
583static PARAMS_ARRAY_INTERSECT: &[FunctionParam] = &[FunctionParam {
584    name: "expressions",
585    required: true,
586}];
587static PARAMS_ARRAY_TO_STRING: &[FunctionParam] = &[
588    FunctionParam {
589        name: "this",
590        required: true,
591    },
592    FunctionParam {
593        name: "expression",
594        required: true,
595    },
596    FunctionParam {
597        name: "null",
598        required: false,
599    },
600];
601static PARAMS_ARRAY_LAST: &[FunctionParam] = &[FunctionParam {
602    name: "this",
603    required: true,
604}];
605static PARAMS_ARRAY_SIZE: &[FunctionParam] = &[
606    FunctionParam {
607        name: "this",
608        required: true,
609    },
610    FunctionParam {
611        name: "expression",
612        required: false,
613    },
614];
615static PARAMS_ARRAY_OVERLAPS: &[FunctionParam] = &[
616    FunctionParam {
617        name: "this",
618        required: true,
619    },
620    FunctionParam {
621        name: "expression",
622        required: true,
623    },
624];
625static PARAMS_ARRAY_REMOVE: &[FunctionParam] = &[
626    FunctionParam {
627        name: "this",
628        required: true,
629    },
630    FunctionParam {
631        name: "expression",
632        required: true,
633    },
634];
635static PARAMS_ARRAY_REVERSE: &[FunctionParam] = &[FunctionParam {
636    name: "this",
637    required: true,
638}];
639static PARAMS_ARRAY_SLICE: &[FunctionParam] = &[
640    FunctionParam {
641        name: "this",
642        required: true,
643    },
644    FunctionParam {
645        name: "start",
646        required: true,
647    },
648    FunctionParam {
649        name: "end",
650        required: false,
651    },
652    FunctionParam {
653        name: "step",
654        required: false,
655    },
656];
657static PARAMS_ARRAY_SORT: &[FunctionParam] = &[
658    FunctionParam {
659        name: "this",
660        required: true,
661    },
662    FunctionParam {
663        name: "expression",
664        required: false,
665    },
666];
667static PARAMS_ARRAY_SUM: &[FunctionParam] = &[
668    FunctionParam {
669        name: "this",
670        required: true,
671    },
672    FunctionParam {
673        name: "expression",
674        required: false,
675    },
676];
677static PARAMS_ARRAY_UNION_AGG: &[FunctionParam] = &[FunctionParam {
678    name: "this",
679    required: true,
680}];
681static PARAMS_ARRAY_UNIQUE_AGG: &[FunctionParam] = &[FunctionParam {
682    name: "this",
683    required: true,
684}];
685static PARAMS_ASCII: &[FunctionParam] = &[FunctionParam {
686    name: "this",
687    required: true,
688}];
689static PARAMS_ASIN: &[FunctionParam] = &[FunctionParam {
690    name: "this",
691    required: true,
692}];
693static PARAMS_ASINH: &[FunctionParam] = &[FunctionParam {
694    name: "this",
695    required: true,
696}];
697static PARAMS_ATAN: &[FunctionParam] = &[
698    FunctionParam {
699        name: "this",
700        required: true,
701    },
702    FunctionParam {
703        name: "expression",
704        required: false,
705    },
706];
707static PARAMS_ATAN2: &[FunctionParam] = &[
708    FunctionParam {
709        name: "this",
710        required: true,
711    },
712    FunctionParam {
713        name: "expression",
714        required: true,
715    },
716];
717static PARAMS_ATANH: &[FunctionParam] = &[FunctionParam {
718    name: "this",
719    required: true,
720}];
721static PARAMS_AVG: &[FunctionParam] = &[FunctionParam {
722    name: "this",
723    required: true,
724}];
725static PARAMS_BASE64DECODE_BINARY: &[FunctionParam] = &[
726    FunctionParam {
727        name: "this",
728        required: true,
729    },
730    FunctionParam {
731        name: "alphabet",
732        required: false,
733    },
734];
735static PARAMS_BASE64DECODE_STRING: &[FunctionParam] = &[
736    FunctionParam {
737        name: "this",
738        required: true,
739    },
740    FunctionParam {
741        name: "alphabet",
742        required: false,
743    },
744];
745static PARAMS_BASE64ENCODE: &[FunctionParam] = &[
746    FunctionParam {
747        name: "this",
748        required: true,
749    },
750    FunctionParam {
751        name: "max_line_length",
752        required: false,
753    },
754    FunctionParam {
755        name: "alphabet",
756        required: false,
757    },
758];
759static PARAMS_BITMAP_BIT_POSITION: &[FunctionParam] = &[FunctionParam {
760    name: "this",
761    required: true,
762}];
763static PARAMS_BITMAP_BUCKET_NUMBER: &[FunctionParam] = &[FunctionParam {
764    name: "this",
765    required: true,
766}];
767static PARAMS_BITMAP_CONSTRUCT_AGG: &[FunctionParam] = &[FunctionParam {
768    name: "this",
769    required: true,
770}];
771static PARAMS_BITMAP_COUNT: &[FunctionParam] = &[FunctionParam {
772    name: "this",
773    required: true,
774}];
775static PARAMS_BITMAP_OR_AGG: &[FunctionParam] = &[FunctionParam {
776    name: "this",
777    required: true,
778}];
779static PARAMS_BITWISE_AND_AGG: &[FunctionParam] = &[FunctionParam {
780    name: "this",
781    required: true,
782}];
783static PARAMS_BITWISE_COUNT: &[FunctionParam] = &[FunctionParam {
784    name: "this",
785    required: true,
786}];
787static PARAMS_BITWISE_OR_AGG: &[FunctionParam] = &[FunctionParam {
788    name: "this",
789    required: true,
790}];
791static PARAMS_BITWISE_XOR_AGG: &[FunctionParam] = &[FunctionParam {
792    name: "this",
793    required: true,
794}];
795static PARAMS_BIT_LENGTH: &[FunctionParam] = &[FunctionParam {
796    name: "this",
797    required: true,
798}];
799static PARAMS_BOOLAND: &[FunctionParam] = &[
800    FunctionParam {
801        name: "this",
802        required: true,
803    },
804    FunctionParam {
805        name: "expression",
806        required: true,
807    },
808];
809static PARAMS_LOGICAL_AND: &[FunctionParam] = &[FunctionParam {
810    name: "this",
811    required: true,
812}];
813static PARAMS_BOOLNOT: &[FunctionParam] = &[FunctionParam {
814    name: "this",
815    required: true,
816}];
817static PARAMS_BOOLOR: &[FunctionParam] = &[
818    FunctionParam {
819        name: "this",
820        required: true,
821    },
822    FunctionParam {
823        name: "expression",
824        required: true,
825    },
826];
827static PARAMS_LOGICAL_OR: &[FunctionParam] = &[FunctionParam {
828    name: "this",
829    required: true,
830}];
831static PARAMS_BOOLXOR_AGG: &[FunctionParam] = &[FunctionParam {
832    name: "this",
833    required: true,
834}];
835static PARAMS_BYTE_LENGTH: &[FunctionParam] = &[FunctionParam {
836    name: "this",
837    required: true,
838}];
839static PARAMS_CASE: &[FunctionParam] = &[
840    FunctionParam {
841        name: "this",
842        required: false,
843    },
844    FunctionParam {
845        name: "ifs",
846        required: true,
847    },
848    FunctionParam {
849        name: "default",
850        required: false,
851    },
852];
853static PARAMS_CAST: &[FunctionParam] = &[
854    FunctionParam {
855        name: "this",
856        required: true,
857    },
858    FunctionParam {
859        name: "to",
860        required: true,
861    },
862    FunctionParam {
863        name: "format",
864        required: false,
865    },
866    FunctionParam {
867        name: "safe",
868        required: false,
869    },
870    FunctionParam {
871        name: "action",
872        required: false,
873    },
874    FunctionParam {
875        name: "default",
876        required: false,
877    },
878];
879static PARAMS_CAST_TO_STR_TYPE: &[FunctionParam] = &[
880    FunctionParam {
881        name: "this",
882        required: true,
883    },
884    FunctionParam {
885        name: "to",
886        required: true,
887    },
888];
889static PARAMS_CBRT: &[FunctionParam] = &[FunctionParam {
890    name: "this",
891    required: true,
892}];
893static PARAMS_CEIL: &[FunctionParam] = &[
894    FunctionParam {
895        name: "this",
896        required: true,
897    },
898    FunctionParam {
899        name: "decimals",
900        required: false,
901    },
902    FunctionParam {
903        name: "to",
904        required: false,
905    },
906];
907static PARAMS_CHR: &[FunctionParam] = &[
908    FunctionParam {
909        name: "expressions",
910        required: true,
911    },
912    FunctionParam {
913        name: "charset",
914        required: false,
915    },
916];
917static PARAMS_LENGTH: &[FunctionParam] = &[
918    FunctionParam {
919        name: "this",
920        required: true,
921    },
922    FunctionParam {
923        name: "binary",
924        required: false,
925    },
926    FunctionParam {
927        name: "encoding",
928        required: false,
929    },
930];
931static PARAMS_COALESCE: &[FunctionParam] = &[
932    FunctionParam {
933        name: "this",
934        required: true,
935    },
936    FunctionParam {
937        name: "expressions",
938        required: false,
939    },
940    FunctionParam {
941        name: "is_nvl",
942        required: false,
943    },
944    FunctionParam {
945        name: "is_null",
946        required: false,
947    },
948];
949static PARAMS_CODE_POINTS_TO_BYTES: &[FunctionParam] = &[FunctionParam {
950    name: "this",
951    required: true,
952}];
953static PARAMS_CODE_POINTS_TO_STRING: &[FunctionParam] = &[FunctionParam {
954    name: "this",
955    required: true,
956}];
957static PARAMS_COLLATE: &[FunctionParam] = &[
958    FunctionParam {
959        name: "this",
960        required: true,
961    },
962    FunctionParam {
963        name: "expression",
964        required: true,
965    },
966];
967static PARAMS_COLLATION: &[FunctionParam] = &[FunctionParam {
968    name: "this",
969    required: true,
970}];
971static PARAMS_COLUMNS: &[FunctionParam] = &[
972    FunctionParam {
973        name: "this",
974        required: true,
975    },
976    FunctionParam {
977        name: "unpack",
978        required: false,
979    },
980];
981static PARAMS_COMBINED_AGG_FUNC: &[FunctionParam] = &[
982    FunctionParam {
983        name: "this",
984        required: true,
985    },
986    FunctionParam {
987        name: "expressions",
988        required: false,
989    },
990];
991static PARAMS_COMBINED_PARAMETERIZED_AGG: &[FunctionParam] = &[
992    FunctionParam {
993        name: "this",
994        required: true,
995    },
996    FunctionParam {
997        name: "expressions",
998        required: true,
999    },
1000    FunctionParam {
1001        name: "params",
1002        required: true,
1003    },
1004];
1005static PARAMS_COMPRESS: &[FunctionParam] = &[
1006    FunctionParam {
1007        name: "this",
1008        required: true,
1009    },
1010    FunctionParam {
1011        name: "method",
1012        required: false,
1013    },
1014];
1015static PARAMS_CONCAT: &[FunctionParam] = &[
1016    FunctionParam {
1017        name: "expressions",
1018        required: true,
1019    },
1020    FunctionParam {
1021        name: "safe",
1022        required: false,
1023    },
1024    FunctionParam {
1025        name: "coalesce",
1026        required: false,
1027    },
1028];
1029static PARAMS_CONCAT_WS: &[FunctionParam] = &[
1030    FunctionParam {
1031        name: "expressions",
1032        required: true,
1033    },
1034    FunctionParam {
1035        name: "safe",
1036        required: false,
1037    },
1038    FunctionParam {
1039        name: "coalesce",
1040        required: false,
1041    },
1042];
1043static PARAMS_CONNECT_BY_ROOT: &[FunctionParam] = &[FunctionParam {
1044    name: "this",
1045    required: true,
1046}];
1047static PARAMS_CONTAINS: &[FunctionParam] = &[
1048    FunctionParam {
1049        name: "this",
1050        required: true,
1051    },
1052    FunctionParam {
1053        name: "expression",
1054        required: true,
1055    },
1056    FunctionParam {
1057        name: "json_scope",
1058        required: false,
1059    },
1060];
1061static PARAMS_CONVERT: &[FunctionParam] = &[
1062    FunctionParam {
1063        name: "this",
1064        required: true,
1065    },
1066    FunctionParam {
1067        name: "expression",
1068        required: true,
1069    },
1070    FunctionParam {
1071        name: "style",
1072        required: false,
1073    },
1074    FunctionParam {
1075        name: "safe",
1076        required: false,
1077    },
1078];
1079static PARAMS_CONVERT_TIMEZONE: &[FunctionParam] = &[
1080    FunctionParam {
1081        name: "source_tz",
1082        required: false,
1083    },
1084    FunctionParam {
1085        name: "target_tz",
1086        required: true,
1087    },
1088    FunctionParam {
1089        name: "timestamp",
1090        required: true,
1091    },
1092    FunctionParam {
1093        name: "options",
1094        required: false,
1095    },
1096];
1097static PARAMS_CONVERT_TO_CHARSET: &[FunctionParam] = &[
1098    FunctionParam {
1099        name: "this",
1100        required: true,
1101    },
1102    FunctionParam {
1103        name: "dest",
1104        required: true,
1105    },
1106    FunctionParam {
1107        name: "source",
1108        required: false,
1109    },
1110];
1111static PARAMS_CORR: &[FunctionParam] = &[
1112    FunctionParam {
1113        name: "this",
1114        required: true,
1115    },
1116    FunctionParam {
1117        name: "expression",
1118        required: true,
1119    },
1120];
1121static PARAMS_COS: &[FunctionParam] = &[FunctionParam {
1122    name: "this",
1123    required: true,
1124}];
1125static PARAMS_COSH: &[FunctionParam] = &[FunctionParam {
1126    name: "this",
1127    required: true,
1128}];
1129static PARAMS_COSINE_DISTANCE: &[FunctionParam] = &[
1130    FunctionParam {
1131        name: "this",
1132        required: true,
1133    },
1134    FunctionParam {
1135        name: "expression",
1136        required: true,
1137    },
1138];
1139static PARAMS_COT: &[FunctionParam] = &[FunctionParam {
1140    name: "this",
1141    required: true,
1142}];
1143static PARAMS_COTH: &[FunctionParam] = &[FunctionParam {
1144    name: "this",
1145    required: true,
1146}];
1147static PARAMS_COUNT: &[FunctionParam] = &[
1148    FunctionParam {
1149        name: "this",
1150        required: false,
1151    },
1152    FunctionParam {
1153        name: "expressions",
1154        required: false,
1155    },
1156    FunctionParam {
1157        name: "big_int",
1158        required: false,
1159    },
1160];
1161static PARAMS_COUNT_IF: &[FunctionParam] = &[FunctionParam {
1162    name: "this",
1163    required: true,
1164}];
1165static PARAMS_COVAR_POP: &[FunctionParam] = &[
1166    FunctionParam {
1167        name: "this",
1168        required: true,
1169    },
1170    FunctionParam {
1171        name: "expression",
1172        required: true,
1173    },
1174];
1175static PARAMS_COVAR_SAMP: &[FunctionParam] = &[
1176    FunctionParam {
1177        name: "this",
1178        required: true,
1179    },
1180    FunctionParam {
1181        name: "expression",
1182        required: true,
1183    },
1184];
1185static PARAMS_CSC: &[FunctionParam] = &[FunctionParam {
1186    name: "this",
1187    required: true,
1188}];
1189static PARAMS_CSCH: &[FunctionParam] = &[FunctionParam {
1190    name: "this",
1191    required: true,
1192}];
1193static PARAMS_CUME_DIST: &[FunctionParam] = &[FunctionParam {
1194    name: "expressions",
1195    required: false,
1196}];
1197static PARAMS_CURRENT_DATE: &[FunctionParam] = &[FunctionParam {
1198    name: "this",
1199    required: false,
1200}];
1201static PARAMS_CURRENT_DATETIME: &[FunctionParam] = &[FunctionParam {
1202    name: "this",
1203    required: false,
1204}];
1205static PARAMS_CURRENT_SCHEMA: &[FunctionParam] = &[FunctionParam {
1206    name: "this",
1207    required: false,
1208}];
1209static PARAMS_CURRENT_TIME: &[FunctionParam] = &[FunctionParam {
1210    name: "this",
1211    required: false,
1212}];
1213static PARAMS_CURRENT_TIMESTAMP: &[FunctionParam] = &[
1214    FunctionParam {
1215        name: "this",
1216        required: false,
1217    },
1218    FunctionParam {
1219        name: "sysdate",
1220        required: false,
1221    },
1222];
1223static PARAMS_CURRENT_USER: &[FunctionParam] = &[FunctionParam {
1224    name: "this",
1225    required: false,
1226}];
1227static PARAMS_DATE: &[FunctionParam] = &[
1228    FunctionParam {
1229        name: "this",
1230        required: false,
1231    },
1232    FunctionParam {
1233        name: "zone",
1234        required: false,
1235    },
1236    FunctionParam {
1237        name: "expressions",
1238        required: false,
1239    },
1240];
1241static PARAMS_DATE_DIFF: &[FunctionParam] = &[
1242    FunctionParam {
1243        name: "this",
1244        required: true,
1245    },
1246    FunctionParam {
1247        name: "expression",
1248        required: true,
1249    },
1250    FunctionParam {
1251        name: "unit",
1252        required: false,
1253    },
1254    FunctionParam {
1255        name: "zone",
1256        required: false,
1257    },
1258    FunctionParam {
1259        name: "big_int",
1260        required: false,
1261    },
1262];
1263static PARAMS_DATE_FROM_PARTS: &[FunctionParam] = &[
1264    FunctionParam {
1265        name: "year",
1266        required: true,
1267    },
1268    FunctionParam {
1269        name: "month",
1270        required: false,
1271    },
1272    FunctionParam {
1273        name: "day",
1274        required: false,
1275    },
1276];
1277static PARAMS_DATETIME: &[FunctionParam] = &[
1278    FunctionParam {
1279        name: "this",
1280        required: true,
1281    },
1282    FunctionParam {
1283        name: "expression",
1284        required: false,
1285    },
1286];
1287static PARAMS_DATETIME_ADD: &[FunctionParam] = &[
1288    FunctionParam {
1289        name: "this",
1290        required: true,
1291    },
1292    FunctionParam {
1293        name: "expression",
1294        required: true,
1295    },
1296    FunctionParam {
1297        name: "unit",
1298        required: false,
1299    },
1300];
1301static PARAMS_DATETIME_DIFF: &[FunctionParam] = &[
1302    FunctionParam {
1303        name: "this",
1304        required: true,
1305    },
1306    FunctionParam {
1307        name: "expression",
1308        required: true,
1309    },
1310    FunctionParam {
1311        name: "unit",
1312        required: false,
1313    },
1314];
1315static PARAMS_DATETIME_SUB: &[FunctionParam] = &[
1316    FunctionParam {
1317        name: "this",
1318        required: true,
1319    },
1320    FunctionParam {
1321        name: "expression",
1322        required: true,
1323    },
1324    FunctionParam {
1325        name: "unit",
1326        required: false,
1327    },
1328];
1329static PARAMS_DATETIME_TRUNC: &[FunctionParam] = &[
1330    FunctionParam {
1331        name: "this",
1332        required: true,
1333    },
1334    FunctionParam {
1335        name: "unit",
1336        required: true,
1337    },
1338    FunctionParam {
1339        name: "zone",
1340        required: false,
1341    },
1342];
1343static PARAMS_DATE_ADD: &[FunctionParam] = &[
1344    FunctionParam {
1345        name: "this",
1346        required: true,
1347    },
1348    FunctionParam {
1349        name: "expression",
1350        required: true,
1351    },
1352    FunctionParam {
1353        name: "unit",
1354        required: false,
1355    },
1356];
1357static PARAMS_DATE_BIN: &[FunctionParam] = &[
1358    FunctionParam {
1359        name: "this",
1360        required: true,
1361    },
1362    FunctionParam {
1363        name: "expression",
1364        required: true,
1365    },
1366    FunctionParam {
1367        name: "unit",
1368        required: false,
1369    },
1370    FunctionParam {
1371        name: "zone",
1372        required: false,
1373    },
1374    FunctionParam {
1375        name: "origin",
1376        required: false,
1377    },
1378];
1379static PARAMS_DATE_FROM_UNIX_DATE: &[FunctionParam] = &[FunctionParam {
1380    name: "this",
1381    required: true,
1382}];
1383static PARAMS_DATE_STR_TO_DATE: &[FunctionParam] = &[FunctionParam {
1384    name: "this",
1385    required: true,
1386}];
1387static PARAMS_DATE_SUB: &[FunctionParam] = &[
1388    FunctionParam {
1389        name: "this",
1390        required: true,
1391    },
1392    FunctionParam {
1393        name: "expression",
1394        required: true,
1395    },
1396    FunctionParam {
1397        name: "unit",
1398        required: false,
1399    },
1400];
1401static PARAMS_DATE_TO_DATE_STR: &[FunctionParam] = &[FunctionParam {
1402    name: "this",
1403    required: true,
1404}];
1405static PARAMS_DATE_TO_DI: &[FunctionParam] = &[FunctionParam {
1406    name: "this",
1407    required: true,
1408}];
1409static PARAMS_DATE_TRUNC: &[FunctionParam] = &[
1410    FunctionParam {
1411        name: "unit",
1412        required: true,
1413    },
1414    FunctionParam {
1415        name: "this",
1416        required: true,
1417    },
1418    FunctionParam {
1419        name: "zone",
1420        required: false,
1421    },
1422];
1423static PARAMS_DAY: &[FunctionParam] = &[FunctionParam {
1424    name: "this",
1425    required: true,
1426}];
1427static PARAMS_DAY_OF_MONTH: &[FunctionParam] = &[FunctionParam {
1428    name: "this",
1429    required: true,
1430}];
1431static PARAMS_DAY_OF_WEEK: &[FunctionParam] = &[FunctionParam {
1432    name: "this",
1433    required: true,
1434}];
1435static PARAMS_DAY_OF_WEEK_ISO: &[FunctionParam] = &[FunctionParam {
1436    name: "this",
1437    required: true,
1438}];
1439static PARAMS_DAY_OF_YEAR: &[FunctionParam] = &[FunctionParam {
1440    name: "this",
1441    required: true,
1442}];
1443static PARAMS_DECODE: &[FunctionParam] = &[
1444    FunctionParam {
1445        name: "this",
1446        required: true,
1447    },
1448    FunctionParam {
1449        name: "charset",
1450        required: true,
1451    },
1452    FunctionParam {
1453        name: "replace",
1454        required: false,
1455    },
1456];
1457static PARAMS_DECODE_CASE: &[FunctionParam] = &[FunctionParam {
1458    name: "expressions",
1459    required: true,
1460}];
1461static PARAMS_DECOMPRESS_BINARY: &[FunctionParam] = &[
1462    FunctionParam {
1463        name: "this",
1464        required: true,
1465    },
1466    FunctionParam {
1467        name: "method",
1468        required: true,
1469    },
1470];
1471static PARAMS_DECOMPRESS_STRING: &[FunctionParam] = &[
1472    FunctionParam {
1473        name: "this",
1474        required: true,
1475    },
1476    FunctionParam {
1477        name: "method",
1478        required: true,
1479    },
1480];
1481static PARAMS_DEGREES: &[FunctionParam] = &[FunctionParam {
1482    name: "this",
1483    required: true,
1484}];
1485static PARAMS_DENSE_RANK: &[FunctionParam] = &[FunctionParam {
1486    name: "expressions",
1487    required: false,
1488}];
1489static PARAMS_DI_TO_DATE: &[FunctionParam] = &[FunctionParam {
1490    name: "this",
1491    required: true,
1492}];
1493static PARAMS_ENCODE: &[FunctionParam] = &[
1494    FunctionParam {
1495        name: "this",
1496        required: true,
1497    },
1498    FunctionParam {
1499        name: "charset",
1500        required: true,
1501    },
1502];
1503static PARAMS_ENDS_WITH: &[FunctionParam] = &[
1504    FunctionParam {
1505        name: "this",
1506        required: true,
1507    },
1508    FunctionParam {
1509        name: "expression",
1510        required: true,
1511    },
1512];
1513static PARAMS_EQUAL_NULL: &[FunctionParam] = &[
1514    FunctionParam {
1515        name: "this",
1516        required: true,
1517    },
1518    FunctionParam {
1519        name: "expression",
1520        required: true,
1521    },
1522];
1523static PARAMS_EUCLIDEAN_DISTANCE: &[FunctionParam] = &[
1524    FunctionParam {
1525        name: "this",
1526        required: true,
1527    },
1528    FunctionParam {
1529        name: "expression",
1530        required: true,
1531    },
1532];
1533static PARAMS_EXISTS: &[FunctionParam] = &[
1534    FunctionParam {
1535        name: "this",
1536        required: true,
1537    },
1538    FunctionParam {
1539        name: "expression",
1540        required: false,
1541    },
1542];
1543static PARAMS_EXP: &[FunctionParam] = &[FunctionParam {
1544    name: "this",
1545    required: true,
1546}];
1547static PARAMS_EXPLODE: &[FunctionParam] = &[
1548    FunctionParam {
1549        name: "this",
1550        required: true,
1551    },
1552    FunctionParam {
1553        name: "expressions",
1554        required: false,
1555    },
1556];
1557static PARAMS_EXPLODE_OUTER: &[FunctionParam] = &[
1558    FunctionParam {
1559        name: "this",
1560        required: true,
1561    },
1562    FunctionParam {
1563        name: "expressions",
1564        required: false,
1565    },
1566];
1567static PARAMS_EXPLODING_GENERATE_SERIES: &[FunctionParam] = &[
1568    FunctionParam {
1569        name: "start",
1570        required: true,
1571    },
1572    FunctionParam {
1573        name: "end",
1574        required: true,
1575    },
1576    FunctionParam {
1577        name: "step",
1578        required: false,
1579    },
1580    FunctionParam {
1581        name: "is_end_exclusive",
1582        required: false,
1583    },
1584];
1585static PARAMS_EXTRACT: &[FunctionParam] = &[
1586    FunctionParam {
1587        name: "this",
1588        required: true,
1589    },
1590    FunctionParam {
1591        name: "expression",
1592        required: true,
1593    },
1594];
1595static PARAMS_FACTORIAL: &[FunctionParam] = &[FunctionParam {
1596    name: "this",
1597    required: true,
1598}];
1599static PARAMS_FARM_FINGERPRINT: &[FunctionParam] = &[FunctionParam {
1600    name: "expressions",
1601    required: true,
1602}];
1603static PARAMS_FEATURES_AT_TIME: &[FunctionParam] = &[
1604    FunctionParam {
1605        name: "this",
1606        required: true,
1607    },
1608    FunctionParam {
1609        name: "time",
1610        required: false,
1611    },
1612    FunctionParam {
1613        name: "num_rows",
1614        required: false,
1615    },
1616    FunctionParam {
1617        name: "ignore_feature_nulls",
1618        required: false,
1619    },
1620];
1621static PARAMS_FIRST: &[FunctionParam] = &[
1622    FunctionParam {
1623        name: "this",
1624        required: true,
1625    },
1626    FunctionParam {
1627        name: "expression",
1628        required: false,
1629    },
1630];
1631static PARAMS_FIRST_VALUE: &[FunctionParam] = &[FunctionParam {
1632    name: "this",
1633    required: true,
1634}];
1635static PARAMS_FLATTEN: &[FunctionParam] = &[FunctionParam {
1636    name: "this",
1637    required: true,
1638}];
1639static PARAMS_FLOAT64: &[FunctionParam] = &[
1640    FunctionParam {
1641        name: "this",
1642        required: true,
1643    },
1644    FunctionParam {
1645        name: "expression",
1646        required: false,
1647    },
1648];
1649static PARAMS_FLOOR: &[FunctionParam] = &[
1650    FunctionParam {
1651        name: "this",
1652        required: true,
1653    },
1654    FunctionParam {
1655        name: "decimals",
1656        required: false,
1657    },
1658    FunctionParam {
1659        name: "to",
1660        required: false,
1661    },
1662];
1663static PARAMS_FORMAT: &[FunctionParam] = &[
1664    FunctionParam {
1665        name: "this",
1666        required: true,
1667    },
1668    FunctionParam {
1669        name: "expressions",
1670        required: false,
1671    },
1672];
1673static PARAMS_FROM_BASE: &[FunctionParam] = &[
1674    FunctionParam {
1675        name: "this",
1676        required: true,
1677    },
1678    FunctionParam {
1679        name: "expression",
1680        required: true,
1681    },
1682];
1683static PARAMS_FROM_BASE32: &[FunctionParam] = &[FunctionParam {
1684    name: "this",
1685    required: true,
1686}];
1687static PARAMS_FROM_BASE64: &[FunctionParam] = &[FunctionParam {
1688    name: "this",
1689    required: true,
1690}];
1691static PARAMS_FROM_ISO8601TIMESTAMP: &[FunctionParam] = &[FunctionParam {
1692    name: "this",
1693    required: true,
1694}];
1695static PARAMS_GAP_FILL: &[FunctionParam] = &[
1696    FunctionParam {
1697        name: "this",
1698        required: true,
1699    },
1700    FunctionParam {
1701        name: "ts_column",
1702        required: true,
1703    },
1704    FunctionParam {
1705        name: "bucket_width",
1706        required: true,
1707    },
1708    FunctionParam {
1709        name: "partitioning_columns",
1710        required: false,
1711    },
1712    FunctionParam {
1713        name: "value_columns",
1714        required: false,
1715    },
1716    FunctionParam {
1717        name: "origin",
1718        required: false,
1719    },
1720    FunctionParam {
1721        name: "ignore_nulls",
1722        required: false,
1723    },
1724];
1725static PARAMS_GENERATE_DATE_ARRAY: &[FunctionParam] = &[
1726    FunctionParam {
1727        name: "start",
1728        required: true,
1729    },
1730    FunctionParam {
1731        name: "end",
1732        required: true,
1733    },
1734    FunctionParam {
1735        name: "step",
1736        required: false,
1737    },
1738];
1739static PARAMS_GENERATE_EMBEDDING: &[FunctionParam] = &[
1740    FunctionParam {
1741        name: "this",
1742        required: true,
1743    },
1744    FunctionParam {
1745        name: "expression",
1746        required: true,
1747    },
1748    FunctionParam {
1749        name: "params_struct",
1750        required: false,
1751    },
1752    FunctionParam {
1753        name: "is_text",
1754        required: false,
1755    },
1756];
1757static PARAMS_GENERATE_SERIES: &[FunctionParam] = &[
1758    FunctionParam {
1759        name: "start",
1760        required: true,
1761    },
1762    FunctionParam {
1763        name: "end",
1764        required: true,
1765    },
1766    FunctionParam {
1767        name: "step",
1768        required: false,
1769    },
1770    FunctionParam {
1771        name: "is_end_exclusive",
1772        required: false,
1773    },
1774];
1775static PARAMS_GENERATE_TIMESTAMP_ARRAY: &[FunctionParam] = &[
1776    FunctionParam {
1777        name: "start",
1778        required: true,
1779    },
1780    FunctionParam {
1781        name: "end",
1782        required: true,
1783    },
1784    FunctionParam {
1785        name: "step",
1786        required: true,
1787    },
1788];
1789static PARAMS_UUID: &[FunctionParam] = &[
1790    FunctionParam {
1791        name: "this",
1792        required: false,
1793    },
1794    FunctionParam {
1795        name: "name",
1796        required: false,
1797    },
1798    FunctionParam {
1799        name: "is_string",
1800        required: false,
1801    },
1802];
1803static PARAMS_GETBIT: &[FunctionParam] = &[
1804    FunctionParam {
1805        name: "this",
1806        required: true,
1807    },
1808    FunctionParam {
1809        name: "expression",
1810        required: true,
1811    },
1812];
1813static PARAMS_GET_EXTRACT: &[FunctionParam] = &[
1814    FunctionParam {
1815        name: "this",
1816        required: true,
1817    },
1818    FunctionParam {
1819        name: "expression",
1820        required: true,
1821    },
1822];
1823static PARAMS_GREATEST: &[FunctionParam] = &[
1824    FunctionParam {
1825        name: "this",
1826        required: true,
1827    },
1828    FunctionParam {
1829        name: "expressions",
1830        required: false,
1831    },
1832    FunctionParam {
1833        name: "null_if_any_null",
1834        required: false,
1835    },
1836];
1837static PARAMS_GREATEST_IGNORE_NULLS: &[FunctionParam] = &[FunctionParam {
1838    name: "expressions",
1839    required: true,
1840}];
1841static PARAMS_GROUPING: &[FunctionParam] = &[FunctionParam {
1842    name: "expressions",
1843    required: true,
1844}];
1845static PARAMS_GROUPING_ID: &[FunctionParam] = &[FunctionParam {
1846    name: "expressions",
1847    required: true,
1848}];
1849static PARAMS_GROUP_CONCAT: &[FunctionParam] = &[
1850    FunctionParam {
1851        name: "this",
1852        required: true,
1853    },
1854    FunctionParam {
1855        name: "separator",
1856        required: false,
1857    },
1858    FunctionParam {
1859        name: "on_overflow",
1860        required: false,
1861    },
1862];
1863static PARAMS_HEX: &[FunctionParam] = &[FunctionParam {
1864    name: "this",
1865    required: true,
1866}];
1867static PARAMS_HEX_DECODE_STRING: &[FunctionParam] = &[FunctionParam {
1868    name: "this",
1869    required: true,
1870}];
1871static PARAMS_HEX_ENCODE: &[FunctionParam] = &[
1872    FunctionParam {
1873        name: "this",
1874        required: true,
1875    },
1876    FunctionParam {
1877        name: "case",
1878        required: false,
1879    },
1880];
1881static PARAMS_HLL: &[FunctionParam] = &[
1882    FunctionParam {
1883        name: "this",
1884        required: true,
1885    },
1886    FunctionParam {
1887        name: "expressions",
1888        required: false,
1889    },
1890];
1891static PARAMS_HOUR: &[FunctionParam] = &[FunctionParam {
1892    name: "this",
1893    required: true,
1894}];
1895static PARAMS_IF: &[FunctionParam] = &[
1896    FunctionParam {
1897        name: "this",
1898        required: true,
1899    },
1900    FunctionParam {
1901        name: "true",
1902        required: true,
1903    },
1904    FunctionParam {
1905        name: "false",
1906        required: false,
1907    },
1908];
1909static PARAMS_INITCAP: &[FunctionParam] = &[
1910    FunctionParam {
1911        name: "this",
1912        required: true,
1913    },
1914    FunctionParam {
1915        name: "expression",
1916        required: false,
1917    },
1918];
1919static PARAMS_INLINE: &[FunctionParam] = &[FunctionParam {
1920    name: "this",
1921    required: true,
1922}];
1923static PARAMS_STUFF: &[FunctionParam] = &[
1924    FunctionParam {
1925        name: "this",
1926        required: true,
1927    },
1928    FunctionParam {
1929        name: "start",
1930        required: true,
1931    },
1932    FunctionParam {
1933        name: "length",
1934        required: true,
1935    },
1936    FunctionParam {
1937        name: "expression",
1938        required: true,
1939    },
1940];
1941static PARAMS_INT64: &[FunctionParam] = &[FunctionParam {
1942    name: "this",
1943    required: true,
1944}];
1945static PARAMS_IS_INF: &[FunctionParam] = &[FunctionParam {
1946    name: "this",
1947    required: true,
1948}];
1949static PARAMS_IS_NAN: &[FunctionParam] = &[FunctionParam {
1950    name: "this",
1951    required: true,
1952}];
1953static PARAMS_IS_ASCII: &[FunctionParam] = &[FunctionParam {
1954    name: "this",
1955    required: true,
1956}];
1957static PARAMS_IS_NULL_VALUE: &[FunctionParam] = &[FunctionParam {
1958    name: "this",
1959    required: true,
1960}];
1961static PARAMS_JAROWINKLER_SIMILARITY: &[FunctionParam] = &[
1962    FunctionParam {
1963        name: "this",
1964        required: true,
1965    },
1966    FunctionParam {
1967        name: "expression",
1968        required: true,
1969    },
1970];
1971static PARAMS_JSONB_CONTAINS: &[FunctionParam] = &[
1972    FunctionParam {
1973        name: "this",
1974        required: true,
1975    },
1976    FunctionParam {
1977        name: "expression",
1978        required: true,
1979    },
1980];
1981static PARAMS_JSONB_EXISTS: &[FunctionParam] = &[
1982    FunctionParam {
1983        name: "this",
1984        required: true,
1985    },
1986    FunctionParam {
1987        name: "path",
1988        required: true,
1989    },
1990];
1991static PARAMS_JSONB_EXTRACT: &[FunctionParam] = &[
1992    FunctionParam {
1993        name: "this",
1994        required: true,
1995    },
1996    FunctionParam {
1997        name: "expression",
1998        required: true,
1999    },
2000];
2001static PARAMS_JSONB_EXTRACT_SCALAR: &[FunctionParam] = &[
2002    FunctionParam {
2003        name: "this",
2004        required: true,
2005    },
2006    FunctionParam {
2007        name: "expression",
2008        required: true,
2009    },
2010    FunctionParam {
2011        name: "json_type",
2012        required: false,
2013    },
2014];
2015static PARAMS_JSON_ARRAY_APPEND: &[FunctionParam] = &[
2016    FunctionParam {
2017        name: "this",
2018        required: true,
2019    },
2020    FunctionParam {
2021        name: "expressions",
2022        required: true,
2023    },
2024];
2025static PARAMS_JSON_ARRAY_CONTAINS: &[FunctionParam] = &[
2026    FunctionParam {
2027        name: "this",
2028        required: true,
2029    },
2030    FunctionParam {
2031        name: "expression",
2032        required: true,
2033    },
2034    FunctionParam {
2035        name: "json_type",
2036        required: false,
2037    },
2038];
2039static PARAMS_JSON_ARRAY_INSERT: &[FunctionParam] = &[
2040    FunctionParam {
2041        name: "this",
2042        required: true,
2043    },
2044    FunctionParam {
2045        name: "expressions",
2046        required: true,
2047    },
2048];
2049static PARAMS_JSON_EXTRACT: &[FunctionParam] = &[
2050    FunctionParam {
2051        name: "this",
2052        required: true,
2053    },
2054    FunctionParam {
2055        name: "expression",
2056        required: true,
2057    },
2058    FunctionParam {
2059        name: "only_json_types",
2060        required: false,
2061    },
2062    FunctionParam {
2063        name: "expressions",
2064        required: false,
2065    },
2066    FunctionParam {
2067        name: "variant_extract",
2068        required: false,
2069    },
2070    FunctionParam {
2071        name: "json_query",
2072        required: false,
2073    },
2074    FunctionParam {
2075        name: "option",
2076        required: false,
2077    },
2078    FunctionParam {
2079        name: "quote",
2080        required: false,
2081    },
2082    FunctionParam {
2083        name: "on_condition",
2084        required: false,
2085    },
2086    FunctionParam {
2087        name: "requires_json",
2088        required: false,
2089    },
2090];
2091static PARAMS_JSON_EXTRACT_ARRAY: &[FunctionParam] = &[
2092    FunctionParam {
2093        name: "this",
2094        required: true,
2095    },
2096    FunctionParam {
2097        name: "expression",
2098        required: false,
2099    },
2100];
2101static PARAMS_JSON_EXTRACT_SCALAR: &[FunctionParam] = &[
2102    FunctionParam {
2103        name: "this",
2104        required: true,
2105    },
2106    FunctionParam {
2107        name: "expression",
2108        required: true,
2109    },
2110    FunctionParam {
2111        name: "only_json_types",
2112        required: false,
2113    },
2114    FunctionParam {
2115        name: "expressions",
2116        required: false,
2117    },
2118    FunctionParam {
2119        name: "json_type",
2120        required: false,
2121    },
2122    FunctionParam {
2123        name: "scalar_only",
2124        required: false,
2125    },
2126];
2127static PARAMS_JSON_FORMAT: &[FunctionParam] = &[
2128    FunctionParam {
2129        name: "this",
2130        required: false,
2131    },
2132    FunctionParam {
2133        name: "options",
2134        required: false,
2135    },
2136    FunctionParam {
2137        name: "is_json",
2138        required: false,
2139    },
2140    FunctionParam {
2141        name: "to_json",
2142        required: false,
2143    },
2144];
2145static PARAMS_PARSE_JSON: &[FunctionParam] = &[
2146    FunctionParam {
2147        name: "this",
2148        required: true,
2149    },
2150    FunctionParam {
2151        name: "expression",
2152        required: false,
2153    },
2154    FunctionParam {
2155        name: "safe",
2156        required: false,
2157    },
2158];
2159static PARAMS_JSON_REMOVE: &[FunctionParam] = &[
2160    FunctionParam {
2161        name: "this",
2162        required: true,
2163    },
2164    FunctionParam {
2165        name: "expressions",
2166        required: true,
2167    },
2168];
2169static PARAMS_JSON_SET: &[FunctionParam] = &[
2170    FunctionParam {
2171        name: "this",
2172        required: true,
2173    },
2174    FunctionParam {
2175        name: "expressions",
2176        required: true,
2177    },
2178];
2179static PARAMS_JSON_STRIP_NULLS: &[FunctionParam] = &[
2180    FunctionParam {
2181        name: "this",
2182        required: true,
2183    },
2184    FunctionParam {
2185        name: "expression",
2186        required: false,
2187    },
2188    FunctionParam {
2189        name: "include_arrays",
2190        required: false,
2191    },
2192    FunctionParam {
2193        name: "remove_empty",
2194        required: false,
2195    },
2196];
2197static PARAMS_JSON_TYPE: &[FunctionParam] = &[
2198    FunctionParam {
2199        name: "this",
2200        required: true,
2201    },
2202    FunctionParam {
2203        name: "expression",
2204        required: false,
2205    },
2206];
2207static PARAMS_JUSTIFY_DAYS: &[FunctionParam] = &[FunctionParam {
2208    name: "this",
2209    required: true,
2210}];
2211static PARAMS_JUSTIFY_HOURS: &[FunctionParam] = &[FunctionParam {
2212    name: "this",
2213    required: true,
2214}];
2215static PARAMS_JUSTIFY_INTERVAL: &[FunctionParam] = &[FunctionParam {
2216    name: "this",
2217    required: true,
2218}];
2219static PARAMS_JSON_ARRAY: &[FunctionParam] = &[
2220    FunctionParam {
2221        name: "expressions",
2222        required: false,
2223    },
2224    FunctionParam {
2225        name: "null_handling",
2226        required: false,
2227    },
2228    FunctionParam {
2229        name: "return_type",
2230        required: false,
2231    },
2232    FunctionParam {
2233        name: "strict",
2234        required: false,
2235    },
2236];
2237static PARAMS_JSON_ARRAY_AGG: &[FunctionParam] = &[
2238    FunctionParam {
2239        name: "this",
2240        required: true,
2241    },
2242    FunctionParam {
2243        name: "order",
2244        required: false,
2245    },
2246    FunctionParam {
2247        name: "null_handling",
2248        required: false,
2249    },
2250    FunctionParam {
2251        name: "return_type",
2252        required: false,
2253    },
2254    FunctionParam {
2255        name: "strict",
2256        required: false,
2257    },
2258];
2259static PARAMS_JSON_BOOL: &[FunctionParam] = &[FunctionParam {
2260    name: "this",
2261    required: true,
2262}];
2263static PARAMS_JSONB_CONTAINS_ALL_TOP_KEYS: &[FunctionParam] = &[
2264    FunctionParam {
2265        name: "this",
2266        required: true,
2267    },
2268    FunctionParam {
2269        name: "expression",
2270        required: true,
2271    },
2272];
2273static PARAMS_JSONB_CONTAINS_ANY_TOP_KEYS: &[FunctionParam] = &[
2274    FunctionParam {
2275        name: "this",
2276        required: true,
2277    },
2278    FunctionParam {
2279        name: "expression",
2280        required: true,
2281    },
2282];
2283static PARAMS_JSONB_DELETE_AT_PATH: &[FunctionParam] = &[
2284    FunctionParam {
2285        name: "this",
2286        required: true,
2287    },
2288    FunctionParam {
2289        name: "expression",
2290        required: true,
2291    },
2292];
2293static PARAMS_JSONB_OBJECT_AGG: &[FunctionParam] = &[
2294    FunctionParam {
2295        name: "this",
2296        required: true,
2297    },
2298    FunctionParam {
2299        name: "expression",
2300        required: true,
2301    },
2302];
2303static PARAMS_JSON_CAST: &[FunctionParam] = &[
2304    FunctionParam {
2305        name: "this",
2306        required: true,
2307    },
2308    FunctionParam {
2309        name: "to",
2310        required: true,
2311    },
2312    FunctionParam {
2313        name: "format",
2314        required: false,
2315    },
2316    FunctionParam {
2317        name: "safe",
2318        required: false,
2319    },
2320    FunctionParam {
2321        name: "action",
2322        required: false,
2323    },
2324    FunctionParam {
2325        name: "default",
2326        required: false,
2327    },
2328];
2329static PARAMS_JSON_EXISTS: &[FunctionParam] = &[
2330    FunctionParam {
2331        name: "this",
2332        required: true,
2333    },
2334    FunctionParam {
2335        name: "path",
2336        required: true,
2337    },
2338    FunctionParam {
2339        name: "passing",
2340        required: false,
2341    },
2342    FunctionParam {
2343        name: "on_condition",
2344        required: false,
2345    },
2346];
2347static PARAMS_JSON_KEYS_AT_DEPTH: &[FunctionParam] = &[
2348    FunctionParam {
2349        name: "this",
2350        required: true,
2351    },
2352    FunctionParam {
2353        name: "expression",
2354        required: false,
2355    },
2356    FunctionParam {
2357        name: "mode",
2358        required: false,
2359    },
2360];
2361static PARAMS_JSON_OBJECT: &[FunctionParam] = &[
2362    FunctionParam {
2363        name: "expressions",
2364        required: false,
2365    },
2366    FunctionParam {
2367        name: "null_handling",
2368        required: false,
2369    },
2370    FunctionParam {
2371        name: "unique_keys",
2372        required: false,
2373    },
2374    FunctionParam {
2375        name: "return_type",
2376        required: false,
2377    },
2378    FunctionParam {
2379        name: "encoding",
2380        required: false,
2381    },
2382];
2383static PARAMS_JSON_OBJECT_AGG: &[FunctionParam] = &[
2384    FunctionParam {
2385        name: "expressions",
2386        required: false,
2387    },
2388    FunctionParam {
2389        name: "null_handling",
2390        required: false,
2391    },
2392    FunctionParam {
2393        name: "unique_keys",
2394        required: false,
2395    },
2396    FunctionParam {
2397        name: "return_type",
2398        required: false,
2399    },
2400    FunctionParam {
2401        name: "encoding",
2402        required: false,
2403    },
2404];
2405static PARAMS_JSON_TABLE: &[FunctionParam] = &[
2406    FunctionParam {
2407        name: "this",
2408        required: true,
2409    },
2410    FunctionParam {
2411        name: "schema",
2412        required: true,
2413    },
2414    FunctionParam {
2415        name: "path",
2416        required: false,
2417    },
2418    FunctionParam {
2419        name: "error_handling",
2420        required: false,
2421    },
2422    FunctionParam {
2423        name: "empty_handling",
2424        required: false,
2425    },
2426];
2427static PARAMS_JSON_VALUE_ARRAY: &[FunctionParam] = &[
2428    FunctionParam {
2429        name: "this",
2430        required: true,
2431    },
2432    FunctionParam {
2433        name: "expression",
2434        required: false,
2435    },
2436];
2437static PARAMS_LAG: &[FunctionParam] = &[
2438    FunctionParam {
2439        name: "this",
2440        required: true,
2441    },
2442    FunctionParam {
2443        name: "offset",
2444        required: false,
2445    },
2446    FunctionParam {
2447        name: "default",
2448        required: false,
2449    },
2450];
2451static PARAMS_LAST: &[FunctionParam] = &[
2452    FunctionParam {
2453        name: "this",
2454        required: true,
2455    },
2456    FunctionParam {
2457        name: "expression",
2458        required: false,
2459    },
2460];
2461static PARAMS_LAST_DAY: &[FunctionParam] = &[
2462    FunctionParam {
2463        name: "this",
2464        required: true,
2465    },
2466    FunctionParam {
2467        name: "unit",
2468        required: false,
2469    },
2470];
2471static PARAMS_LAST_VALUE: &[FunctionParam] = &[FunctionParam {
2472    name: "this",
2473    required: true,
2474}];
2475static PARAMS_LAX_BOOL: &[FunctionParam] = &[FunctionParam {
2476    name: "this",
2477    required: true,
2478}];
2479static PARAMS_LAX_FLOAT64: &[FunctionParam] = &[FunctionParam {
2480    name: "this",
2481    required: true,
2482}];
2483static PARAMS_LAX_INT64: &[FunctionParam] = &[FunctionParam {
2484    name: "this",
2485    required: true,
2486}];
2487static PARAMS_LAX_STRING: &[FunctionParam] = &[FunctionParam {
2488    name: "this",
2489    required: true,
2490}];
2491static PARAMS_LOWER: &[FunctionParam] = &[FunctionParam {
2492    name: "this",
2493    required: true,
2494}];
2495static PARAMS_LEAD: &[FunctionParam] = &[
2496    FunctionParam {
2497        name: "this",
2498        required: true,
2499    },
2500    FunctionParam {
2501        name: "offset",
2502        required: false,
2503    },
2504    FunctionParam {
2505        name: "default",
2506        required: false,
2507    },
2508];
2509static PARAMS_LEAST: &[FunctionParam] = &[
2510    FunctionParam {
2511        name: "this",
2512        required: true,
2513    },
2514    FunctionParam {
2515        name: "expressions",
2516        required: false,
2517    },
2518    FunctionParam {
2519        name: "null_if_any_null",
2520        required: false,
2521    },
2522];
2523static PARAMS_LEAST_IGNORE_NULLS: &[FunctionParam] = &[FunctionParam {
2524    name: "expressions",
2525    required: true,
2526}];
2527static PARAMS_LEFT: &[FunctionParam] = &[
2528    FunctionParam {
2529        name: "this",
2530        required: true,
2531    },
2532    FunctionParam {
2533        name: "expression",
2534        required: true,
2535    },
2536];
2537static PARAMS_LEVENSHTEIN: &[FunctionParam] = &[
2538    FunctionParam {
2539        name: "this",
2540        required: true,
2541    },
2542    FunctionParam {
2543        name: "expression",
2544        required: false,
2545    },
2546    FunctionParam {
2547        name: "ins_cost",
2548        required: false,
2549    },
2550    FunctionParam {
2551        name: "del_cost",
2552        required: false,
2553    },
2554    FunctionParam {
2555        name: "sub_cost",
2556        required: false,
2557    },
2558    FunctionParam {
2559        name: "max_dist",
2560        required: false,
2561    },
2562];
2563static PARAMS_LIST: &[FunctionParam] = &[FunctionParam {
2564    name: "expressions",
2565    required: false,
2566}];
2567static PARAMS_LN: &[FunctionParam] = &[FunctionParam {
2568    name: "this",
2569    required: true,
2570}];
2571static PARAMS_LOG: &[FunctionParam] = &[
2572    FunctionParam {
2573        name: "this",
2574        required: true,
2575    },
2576    FunctionParam {
2577        name: "expression",
2578        required: false,
2579    },
2580];
2581static PARAMS_LOWER_HEX: &[FunctionParam] = &[FunctionParam {
2582    name: "this",
2583    required: true,
2584}];
2585static PARAMS_MAKE_INTERVAL: &[FunctionParam] = &[
2586    FunctionParam {
2587        name: "year",
2588        required: false,
2589    },
2590    FunctionParam {
2591        name: "month",
2592        required: false,
2593    },
2594    FunctionParam {
2595        name: "day",
2596        required: false,
2597    },
2598    FunctionParam {
2599        name: "hour",
2600        required: false,
2601    },
2602    FunctionParam {
2603        name: "minute",
2604        required: false,
2605    },
2606    FunctionParam {
2607        name: "second",
2608        required: false,
2609    },
2610];
2611static PARAMS_MAP: &[FunctionParam] = &[
2612    FunctionParam {
2613        name: "keys",
2614        required: false,
2615    },
2616    FunctionParam {
2617        name: "values",
2618        required: false,
2619    },
2620];
2621static PARAMS_MAP_FROM_ENTRIES: &[FunctionParam] = &[FunctionParam {
2622    name: "this",
2623    required: true,
2624}];
2625static PARAMS_MATCH_AGAINST: &[FunctionParam] = &[
2626    FunctionParam {
2627        name: "this",
2628        required: true,
2629    },
2630    FunctionParam {
2631        name: "expressions",
2632        required: true,
2633    },
2634    FunctionParam {
2635        name: "modifier",
2636        required: false,
2637    },
2638];
2639static PARAMS_MAX: &[FunctionParam] = &[
2640    FunctionParam {
2641        name: "this",
2642        required: true,
2643    },
2644    FunctionParam {
2645        name: "expressions",
2646        required: false,
2647    },
2648];
2649static PARAMS_MD5: &[FunctionParam] = &[FunctionParam {
2650    name: "this",
2651    required: true,
2652}];
2653static PARAMS_MD5DIGEST: &[FunctionParam] = &[FunctionParam {
2654    name: "this",
2655    required: true,
2656}];
2657static PARAMS_MEDIAN: &[FunctionParam] = &[FunctionParam {
2658    name: "this",
2659    required: true,
2660}];
2661static PARAMS_MIN: &[FunctionParam] = &[
2662    FunctionParam {
2663        name: "this",
2664        required: true,
2665    },
2666    FunctionParam {
2667        name: "expressions",
2668        required: false,
2669    },
2670];
2671static PARAMS_MINHASH: &[FunctionParam] = &[
2672    FunctionParam {
2673        name: "this",
2674        required: true,
2675    },
2676    FunctionParam {
2677        name: "expressions",
2678        required: true,
2679    },
2680];
2681static PARAMS_MINHASH_COMBINE: &[FunctionParam] = &[FunctionParam {
2682    name: "this",
2683    required: true,
2684}];
2685static PARAMS_MINUTE: &[FunctionParam] = &[FunctionParam {
2686    name: "this",
2687    required: true,
2688}];
2689static PARAMS_MONTH: &[FunctionParam] = &[FunctionParam {
2690    name: "this",
2691    required: true,
2692}];
2693static PARAMS_MONTHNAME: &[FunctionParam] = &[FunctionParam {
2694    name: "this",
2695    required: true,
2696}];
2697static PARAMS_MONTHS_BETWEEN: &[FunctionParam] = &[
2698    FunctionParam {
2699        name: "this",
2700        required: true,
2701    },
2702    FunctionParam {
2703        name: "expression",
2704        required: true,
2705    },
2706    FunctionParam {
2707        name: "roundoff",
2708        required: false,
2709    },
2710];
2711static PARAMS_MD5NUMBER_LOWER64: &[FunctionParam] = &[FunctionParam {
2712    name: "this",
2713    required: true,
2714}];
2715static PARAMS_MD5NUMBER_UPPER64: &[FunctionParam] = &[FunctionParam {
2716    name: "this",
2717    required: true,
2718}];
2719static PARAMS_ML_FORECAST: &[FunctionParam] = &[
2720    FunctionParam {
2721        name: "this",
2722        required: true,
2723    },
2724    FunctionParam {
2725        name: "expression",
2726        required: false,
2727    },
2728    FunctionParam {
2729        name: "params_struct",
2730        required: false,
2731    },
2732];
2733static PARAMS_ML_TRANSLATE: &[FunctionParam] = &[
2734    FunctionParam {
2735        name: "this",
2736        required: true,
2737    },
2738    FunctionParam {
2739        name: "expression",
2740        required: true,
2741    },
2742    FunctionParam {
2743        name: "params_struct",
2744        required: true,
2745    },
2746];
2747static PARAMS_NEXT_DAY: &[FunctionParam] = &[
2748    FunctionParam {
2749        name: "this",
2750        required: true,
2751    },
2752    FunctionParam {
2753        name: "expression",
2754        required: true,
2755    },
2756];
2757static PARAMS_NEXT_VALUE_FOR: &[FunctionParam] = &[
2758    FunctionParam {
2759        name: "this",
2760        required: true,
2761    },
2762    FunctionParam {
2763        name: "order",
2764        required: false,
2765    },
2766];
2767static PARAMS_NORMALIZE: &[FunctionParam] = &[
2768    FunctionParam {
2769        name: "this",
2770        required: true,
2771    },
2772    FunctionParam {
2773        name: "form",
2774        required: false,
2775    },
2776    FunctionParam {
2777        name: "is_casefold",
2778        required: false,
2779    },
2780];
2781static PARAMS_NTH_VALUE: &[FunctionParam] = &[
2782    FunctionParam {
2783        name: "this",
2784        required: true,
2785    },
2786    FunctionParam {
2787        name: "offset",
2788        required: true,
2789    },
2790];
2791static PARAMS_NTILE: &[FunctionParam] = &[FunctionParam {
2792    name: "this",
2793    required: false,
2794}];
2795static PARAMS_NULLIF: &[FunctionParam] = &[
2796    FunctionParam {
2797        name: "this",
2798        required: true,
2799    },
2800    FunctionParam {
2801        name: "expression",
2802        required: true,
2803    },
2804];
2805static PARAMS_NUMBER_TO_STR: &[FunctionParam] = &[
2806    FunctionParam {
2807        name: "this",
2808        required: true,
2809    },
2810    FunctionParam {
2811        name: "format",
2812        required: true,
2813    },
2814    FunctionParam {
2815        name: "culture",
2816        required: false,
2817    },
2818];
2819static PARAMS_NVL2: &[FunctionParam] = &[
2820    FunctionParam {
2821        name: "this",
2822        required: true,
2823    },
2824    FunctionParam {
2825        name: "true",
2826        required: true,
2827    },
2828    FunctionParam {
2829        name: "false",
2830        required: false,
2831    },
2832];
2833static PARAMS_OBJECT_AGG: &[FunctionParam] = &[
2834    FunctionParam {
2835        name: "this",
2836        required: true,
2837    },
2838    FunctionParam {
2839        name: "expression",
2840        required: true,
2841    },
2842];
2843static PARAMS_OBJECT_INSERT: &[FunctionParam] = &[
2844    FunctionParam {
2845        name: "this",
2846        required: true,
2847    },
2848    FunctionParam {
2849        name: "key",
2850        required: true,
2851    },
2852    FunctionParam {
2853        name: "value",
2854        required: true,
2855    },
2856    FunctionParam {
2857        name: "update_flag",
2858        required: false,
2859    },
2860];
2861static PARAMS_OPEN_JSON: &[FunctionParam] = &[
2862    FunctionParam {
2863        name: "this",
2864        required: true,
2865    },
2866    FunctionParam {
2867        name: "path",
2868        required: false,
2869    },
2870    FunctionParam {
2871        name: "expressions",
2872        required: false,
2873    },
2874];
2875static PARAMS_OR: &[FunctionParam] = &[
2876    FunctionParam {
2877        name: "this",
2878        required: true,
2879    },
2880    FunctionParam {
2881        name: "expression",
2882        required: true,
2883    },
2884];
2885static PARAMS_OVERLAY: &[FunctionParam] = &[
2886    FunctionParam {
2887        name: "this",
2888        required: true,
2889    },
2890    FunctionParam {
2891        name: "expression",
2892        required: true,
2893    },
2894    FunctionParam {
2895        name: "from_",
2896        required: true,
2897    },
2898    FunctionParam {
2899        name: "for_",
2900        required: false,
2901    },
2902];
2903static PARAMS_PAD: &[FunctionParam] = &[
2904    FunctionParam {
2905        name: "this",
2906        required: true,
2907    },
2908    FunctionParam {
2909        name: "expression",
2910        required: true,
2911    },
2912    FunctionParam {
2913        name: "fill_pattern",
2914        required: false,
2915    },
2916    FunctionParam {
2917        name: "is_left",
2918        required: true,
2919    },
2920];
2921static PARAMS_PARAMETERIZED_AGG: &[FunctionParam] = &[
2922    FunctionParam {
2923        name: "this",
2924        required: true,
2925    },
2926    FunctionParam {
2927        name: "expressions",
2928        required: true,
2929    },
2930    FunctionParam {
2931        name: "params",
2932        required: true,
2933    },
2934];
2935static PARAMS_PARSE_BIGNUMERIC: &[FunctionParam] = &[FunctionParam {
2936    name: "this",
2937    required: true,
2938}];
2939static PARAMS_PARSE_DATETIME: &[FunctionParam] = &[
2940    FunctionParam {
2941        name: "this",
2942        required: true,
2943    },
2944    FunctionParam {
2945        name: "format",
2946        required: false,
2947    },
2948    FunctionParam {
2949        name: "zone",
2950        required: false,
2951    },
2952];
2953static PARAMS_PARSE_IP: &[FunctionParam] = &[
2954    FunctionParam {
2955        name: "this",
2956        required: true,
2957    },
2958    FunctionParam {
2959        name: "type",
2960        required: true,
2961    },
2962    FunctionParam {
2963        name: "permissive",
2964        required: false,
2965    },
2966];
2967static PARAMS_PARSE_NUMERIC: &[FunctionParam] = &[FunctionParam {
2968    name: "this",
2969    required: true,
2970}];
2971static PARAMS_PARSE_TIME: &[FunctionParam] = &[
2972    FunctionParam {
2973        name: "this",
2974        required: true,
2975    },
2976    FunctionParam {
2977        name: "format",
2978        required: true,
2979    },
2980];
2981static PARAMS_PARSE_URL: &[FunctionParam] = &[
2982    FunctionParam {
2983        name: "this",
2984        required: true,
2985    },
2986    FunctionParam {
2987        name: "part_to_extract",
2988        required: false,
2989    },
2990    FunctionParam {
2991        name: "key",
2992        required: false,
2993    },
2994    FunctionParam {
2995        name: "permissive",
2996        required: false,
2997    },
2998];
2999static PARAMS_PERCENTILE_CONT: &[FunctionParam] = &[
3000    FunctionParam {
3001        name: "this",
3002        required: true,
3003    },
3004    FunctionParam {
3005        name: "expression",
3006        required: false,
3007    },
3008];
3009static PARAMS_PERCENTILE_DISC: &[FunctionParam] = &[
3010    FunctionParam {
3011        name: "this",
3012        required: true,
3013    },
3014    FunctionParam {
3015        name: "expression",
3016        required: false,
3017    },
3018];
3019static PARAMS_PERCENT_RANK: &[FunctionParam] = &[FunctionParam {
3020    name: "expressions",
3021    required: false,
3022}];
3023static PARAMS_POSEXPLODE: &[FunctionParam] = &[
3024    FunctionParam {
3025        name: "this",
3026        required: true,
3027    },
3028    FunctionParam {
3029        name: "expressions",
3030        required: false,
3031    },
3032];
3033static PARAMS_POSEXPLODE_OUTER: &[FunctionParam] = &[
3034    FunctionParam {
3035        name: "this",
3036        required: true,
3037    },
3038    FunctionParam {
3039        name: "expressions",
3040        required: false,
3041    },
3042];
3043static PARAMS_POW: &[FunctionParam] = &[
3044    FunctionParam {
3045        name: "this",
3046        required: true,
3047    },
3048    FunctionParam {
3049        name: "expression",
3050        required: true,
3051    },
3052];
3053static PARAMS_PREDICT: &[FunctionParam] = &[
3054    FunctionParam {
3055        name: "this",
3056        required: true,
3057    },
3058    FunctionParam {
3059        name: "expression",
3060        required: true,
3061    },
3062    FunctionParam {
3063        name: "params_struct",
3064        required: false,
3065    },
3066];
3067static PARAMS_PREVIOUS_DAY: &[FunctionParam] = &[
3068    FunctionParam {
3069        name: "this",
3070        required: true,
3071    },
3072    FunctionParam {
3073        name: "expression",
3074        required: true,
3075    },
3076];
3077static PARAMS_QUANTILE: &[FunctionParam] = &[
3078    FunctionParam {
3079        name: "this",
3080        required: true,
3081    },
3082    FunctionParam {
3083        name: "quantile",
3084        required: true,
3085    },
3086];
3087static PARAMS_QUARTER: &[FunctionParam] = &[FunctionParam {
3088    name: "this",
3089    required: true,
3090}];
3091static PARAMS_RADIANS: &[FunctionParam] = &[FunctionParam {
3092    name: "this",
3093    required: true,
3094}];
3095static PARAMS_RAND: &[FunctionParam] = &[
3096    FunctionParam {
3097        name: "this",
3098        required: false,
3099    },
3100    FunctionParam {
3101        name: "lower",
3102        required: false,
3103    },
3104    FunctionParam {
3105        name: "upper",
3106        required: false,
3107    },
3108];
3109static PARAMS_RANDN: &[FunctionParam] = &[FunctionParam {
3110    name: "this",
3111    required: false,
3112}];
3113static PARAMS_RANGE_BUCKET: &[FunctionParam] = &[
3114    FunctionParam {
3115        name: "this",
3116        required: true,
3117    },
3118    FunctionParam {
3119        name: "expression",
3120        required: true,
3121    },
3122];
3123static PARAMS_RANGE_N: &[FunctionParam] = &[
3124    FunctionParam {
3125        name: "this",
3126        required: true,
3127    },
3128    FunctionParam {
3129        name: "expressions",
3130        required: true,
3131    },
3132    FunctionParam {
3133        name: "each",
3134        required: false,
3135    },
3136];
3137static PARAMS_RANK: &[FunctionParam] = &[FunctionParam {
3138    name: "expressions",
3139    required: false,
3140}];
3141static PARAMS_READ_CSV: &[FunctionParam] = &[
3142    FunctionParam {
3143        name: "this",
3144        required: true,
3145    },
3146    FunctionParam {
3147        name: "expressions",
3148        required: false,
3149    },
3150];
3151static PARAMS_READ_PARQUET: &[FunctionParam] = &[FunctionParam {
3152    name: "expressions",
3153    required: true,
3154}];
3155static PARAMS_REDUCE: &[FunctionParam] = &[
3156    FunctionParam {
3157        name: "this",
3158        required: true,
3159    },
3160    FunctionParam {
3161        name: "initial",
3162        required: true,
3163    },
3164    FunctionParam {
3165        name: "merge",
3166        required: true,
3167    },
3168    FunctionParam {
3169        name: "finish",
3170        required: false,
3171    },
3172];
3173static PARAMS_REGEXP_COUNT: &[FunctionParam] = &[
3174    FunctionParam {
3175        name: "this",
3176        required: true,
3177    },
3178    FunctionParam {
3179        name: "expression",
3180        required: true,
3181    },
3182    FunctionParam {
3183        name: "position",
3184        required: false,
3185    },
3186    FunctionParam {
3187        name: "parameters",
3188        required: false,
3189    },
3190];
3191static PARAMS_REGEXP_EXTRACT: &[FunctionParam] = &[
3192    FunctionParam {
3193        name: "this",
3194        required: true,
3195    },
3196    FunctionParam {
3197        name: "expression",
3198        required: true,
3199    },
3200    FunctionParam {
3201        name: "position",
3202        required: false,
3203    },
3204    FunctionParam {
3205        name: "occurrence",
3206        required: false,
3207    },
3208    FunctionParam {
3209        name: "parameters",
3210        required: false,
3211    },
3212    FunctionParam {
3213        name: "group",
3214        required: false,
3215    },
3216];
3217static PARAMS_REGEXP_EXTRACT_ALL: &[FunctionParam] = &[
3218    FunctionParam {
3219        name: "this",
3220        required: true,
3221    },
3222    FunctionParam {
3223        name: "expression",
3224        required: true,
3225    },
3226    FunctionParam {
3227        name: "group",
3228        required: false,
3229    },
3230    FunctionParam {
3231        name: "parameters",
3232        required: false,
3233    },
3234    FunctionParam {
3235        name: "position",
3236        required: false,
3237    },
3238    FunctionParam {
3239        name: "occurrence",
3240        required: false,
3241    },
3242];
3243static PARAMS_REGEXP_FULL_MATCH: &[FunctionParam] = &[
3244    FunctionParam {
3245        name: "this",
3246        required: true,
3247    },
3248    FunctionParam {
3249        name: "expression",
3250        required: true,
3251    },
3252    FunctionParam {
3253        name: "options",
3254        required: false,
3255    },
3256];
3257static PARAMS_REGEXP_INSTR: &[FunctionParam] = &[
3258    FunctionParam {
3259        name: "this",
3260        required: true,
3261    },
3262    FunctionParam {
3263        name: "expression",
3264        required: true,
3265    },
3266    FunctionParam {
3267        name: "position",
3268        required: false,
3269    },
3270    FunctionParam {
3271        name: "occurrence",
3272        required: false,
3273    },
3274    FunctionParam {
3275        name: "option",
3276        required: false,
3277    },
3278    FunctionParam {
3279        name: "parameters",
3280        required: false,
3281    },
3282    FunctionParam {
3283        name: "group",
3284        required: false,
3285    },
3286];
3287static PARAMS_REGEXP_I_LIKE: &[FunctionParam] = &[
3288    FunctionParam {
3289        name: "this",
3290        required: true,
3291    },
3292    FunctionParam {
3293        name: "expression",
3294        required: true,
3295    },
3296    FunctionParam {
3297        name: "flag",
3298        required: false,
3299    },
3300];
3301static PARAMS_REGEXP_LIKE: &[FunctionParam] = &[
3302    FunctionParam {
3303        name: "this",
3304        required: true,
3305    },
3306    FunctionParam {
3307        name: "expression",
3308        required: true,
3309    },
3310    FunctionParam {
3311        name: "flag",
3312        required: false,
3313    },
3314];
3315static PARAMS_REGEXP_REPLACE: &[FunctionParam] = &[
3316    FunctionParam {
3317        name: "this",
3318        required: true,
3319    },
3320    FunctionParam {
3321        name: "expression",
3322        required: true,
3323    },
3324    FunctionParam {
3325        name: "replacement",
3326        required: false,
3327    },
3328    FunctionParam {
3329        name: "position",
3330        required: false,
3331    },
3332    FunctionParam {
3333        name: "occurrence",
3334        required: false,
3335    },
3336    FunctionParam {
3337        name: "modifiers",
3338        required: false,
3339    },
3340    FunctionParam {
3341        name: "single_replace",
3342        required: false,
3343    },
3344];
3345static PARAMS_REGEXP_SPLIT: &[FunctionParam] = &[
3346    FunctionParam {
3347        name: "this",
3348        required: true,
3349    },
3350    FunctionParam {
3351        name: "expression",
3352        required: true,
3353    },
3354    FunctionParam {
3355        name: "limit",
3356        required: false,
3357    },
3358];
3359static PARAMS_REGR_AVGX: &[FunctionParam] = &[
3360    FunctionParam {
3361        name: "this",
3362        required: true,
3363    },
3364    FunctionParam {
3365        name: "expression",
3366        required: true,
3367    },
3368];
3369static PARAMS_REGR_AVGY: &[FunctionParam] = &[
3370    FunctionParam {
3371        name: "this",
3372        required: true,
3373    },
3374    FunctionParam {
3375        name: "expression",
3376        required: true,
3377    },
3378];
3379static PARAMS_REGR_VALX: &[FunctionParam] = &[
3380    FunctionParam {
3381        name: "this",
3382        required: true,
3383    },
3384    FunctionParam {
3385        name: "expression",
3386        required: true,
3387    },
3388];
3389static PARAMS_REGR_VALY: &[FunctionParam] = &[
3390    FunctionParam {
3391        name: "this",
3392        required: true,
3393    },
3394    FunctionParam {
3395        name: "expression",
3396        required: true,
3397    },
3398];
3399static PARAMS_REPEAT: &[FunctionParam] = &[
3400    FunctionParam {
3401        name: "this",
3402        required: true,
3403    },
3404    FunctionParam {
3405        name: "times",
3406        required: true,
3407    },
3408];
3409static PARAMS_REPLACE: &[FunctionParam] = &[
3410    FunctionParam {
3411        name: "this",
3412        required: true,
3413    },
3414    FunctionParam {
3415        name: "expression",
3416        required: true,
3417    },
3418    FunctionParam {
3419        name: "replacement",
3420        required: false,
3421    },
3422];
3423static PARAMS_REVERSE: &[FunctionParam] = &[FunctionParam {
3424    name: "this",
3425    required: true,
3426}];
3427static PARAMS_RIGHT: &[FunctionParam] = &[
3428    FunctionParam {
3429        name: "this",
3430        required: true,
3431    },
3432    FunctionParam {
3433        name: "expression",
3434        required: true,
3435    },
3436];
3437static PARAMS_ROUND: &[FunctionParam] = &[
3438    FunctionParam {
3439        name: "this",
3440        required: true,
3441    },
3442    FunctionParam {
3443        name: "decimals",
3444        required: false,
3445    },
3446    FunctionParam {
3447        name: "truncate",
3448        required: false,
3449    },
3450];
3451static PARAMS_ROW_NUMBER: &[FunctionParam] = &[FunctionParam {
3452    name: "this",
3453    required: false,
3454}];
3455static PARAMS_RTRIMMED_LENGTH: &[FunctionParam] = &[FunctionParam {
3456    name: "this",
3457    required: true,
3458}];
3459static PARAMS_SAFE_ADD: &[FunctionParam] = &[
3460    FunctionParam {
3461        name: "this",
3462        required: true,
3463    },
3464    FunctionParam {
3465        name: "expression",
3466        required: true,
3467    },
3468];
3469static PARAMS_SAFE_CONVERT_BYTES_TO_STRING: &[FunctionParam] = &[FunctionParam {
3470    name: "this",
3471    required: true,
3472}];
3473static PARAMS_SAFE_DIVIDE: &[FunctionParam] = &[
3474    FunctionParam {
3475        name: "this",
3476        required: true,
3477    },
3478    FunctionParam {
3479        name: "expression",
3480        required: true,
3481    },
3482];
3483static PARAMS_SAFE_MULTIPLY: &[FunctionParam] = &[
3484    FunctionParam {
3485        name: "this",
3486        required: true,
3487    },
3488    FunctionParam {
3489        name: "expression",
3490        required: true,
3491    },
3492];
3493static PARAMS_SAFE_NEGATE: &[FunctionParam] = &[FunctionParam {
3494    name: "this",
3495    required: true,
3496}];
3497static PARAMS_SAFE_SUBTRACT: &[FunctionParam] = &[
3498    FunctionParam {
3499        name: "this",
3500        required: true,
3501    },
3502    FunctionParam {
3503        name: "expression",
3504        required: true,
3505    },
3506];
3507static PARAMS_SEARCH: &[FunctionParam] = &[
3508    FunctionParam {
3509        name: "this",
3510        required: true,
3511    },
3512    FunctionParam {
3513        name: "expression",
3514        required: true,
3515    },
3516    FunctionParam {
3517        name: "json_scope",
3518        required: false,
3519    },
3520    FunctionParam {
3521        name: "analyzer",
3522        required: false,
3523    },
3524    FunctionParam {
3525        name: "analyzer_options",
3526        required: false,
3527    },
3528    FunctionParam {
3529        name: "search_mode",
3530        required: false,
3531    },
3532];
3533static PARAMS_SEC: &[FunctionParam] = &[FunctionParam {
3534    name: "this",
3535    required: true,
3536}];
3537static PARAMS_SECH: &[FunctionParam] = &[FunctionParam {
3538    name: "this",
3539    required: true,
3540}];
3541static PARAMS_SECOND: &[FunctionParam] = &[FunctionParam {
3542    name: "this",
3543    required: true,
3544}];
3545static PARAMS_SHA: &[FunctionParam] = &[FunctionParam {
3546    name: "this",
3547    required: true,
3548}];
3549static PARAMS_SHA2: &[FunctionParam] = &[
3550    FunctionParam {
3551        name: "this",
3552        required: true,
3553    },
3554    FunctionParam {
3555        name: "length",
3556        required: false,
3557    },
3558];
3559static PARAMS_SIGN: &[FunctionParam] = &[FunctionParam {
3560    name: "this",
3561    required: true,
3562}];
3563static PARAMS_SIN: &[FunctionParam] = &[FunctionParam {
3564    name: "this",
3565    required: true,
3566}];
3567static PARAMS_SINH: &[FunctionParam] = &[FunctionParam {
3568    name: "this",
3569    required: true,
3570}];
3571static PARAMS_SKEWNESS: &[FunctionParam] = &[FunctionParam {
3572    name: "this",
3573    required: true,
3574}];
3575static PARAMS_SORT_ARRAY: &[FunctionParam] = &[
3576    FunctionParam {
3577        name: "this",
3578        required: true,
3579    },
3580    FunctionParam {
3581        name: "asc",
3582        required: false,
3583    },
3584    FunctionParam {
3585        name: "nulls_first",
3586        required: false,
3587    },
3588];
3589static PARAMS_SOUNDEX: &[FunctionParam] = &[FunctionParam {
3590    name: "this",
3591    required: true,
3592}];
3593static PARAMS_SOUNDEX_P123: &[FunctionParam] = &[FunctionParam {
3594    name: "this",
3595    required: true,
3596}];
3597static PARAMS_SPACE: &[FunctionParam] = &[FunctionParam {
3598    name: "this",
3599    required: true,
3600}];
3601static PARAMS_SPLIT: &[FunctionParam] = &[
3602    FunctionParam {
3603        name: "this",
3604        required: true,
3605    },
3606    FunctionParam {
3607        name: "expression",
3608        required: true,
3609    },
3610    FunctionParam {
3611        name: "limit",
3612        required: false,
3613    },
3614];
3615static PARAMS_STRING_TO_ARRAY: &[FunctionParam] = &[
3616    FunctionParam {
3617        name: "this",
3618        required: true,
3619    },
3620    FunctionParam {
3621        name: "expression",
3622        required: false,
3623    },
3624    FunctionParam {
3625        name: "null",
3626        required: false,
3627    },
3628];
3629static PARAMS_SPLIT_PART: &[FunctionParam] = &[
3630    FunctionParam {
3631        name: "this",
3632        required: true,
3633    },
3634    FunctionParam {
3635        name: "delimiter",
3636        required: false,
3637    },
3638    FunctionParam {
3639        name: "part_index",
3640        required: false,
3641    },
3642];
3643static PARAMS_SQRT: &[FunctionParam] = &[FunctionParam {
3644    name: "this",
3645    required: true,
3646}];
3647static PARAMS_STANDARD_HASH: &[FunctionParam] = &[
3648    FunctionParam {
3649        name: "this",
3650        required: true,
3651    },
3652    FunctionParam {
3653        name: "expression",
3654        required: false,
3655    },
3656];
3657static PARAMS_STARTS_WITH: &[FunctionParam] = &[
3658    FunctionParam {
3659        name: "this",
3660        required: true,
3661    },
3662    FunctionParam {
3663        name: "expression",
3664        required: true,
3665    },
3666];
3667static PARAMS_STAR_MAP: &[FunctionParam] = &[FunctionParam {
3668    name: "this",
3669    required: true,
3670}];
3671static PARAMS_STDDEV: &[FunctionParam] = &[FunctionParam {
3672    name: "this",
3673    required: true,
3674}];
3675static PARAMS_STDDEV_POP: &[FunctionParam] = &[FunctionParam {
3676    name: "this",
3677    required: true,
3678}];
3679static PARAMS_STDDEV_SAMP: &[FunctionParam] = &[FunctionParam {
3680    name: "this",
3681    required: true,
3682}];
3683static PARAMS_STRING: &[FunctionParam] = &[
3684    FunctionParam {
3685        name: "this",
3686        required: true,
3687    },
3688    FunctionParam {
3689        name: "zone",
3690        required: false,
3691    },
3692];
3693static PARAMS_STRUCT: &[FunctionParam] = &[FunctionParam {
3694    name: "expressions",
3695    required: false,
3696}];
3697static PARAMS_STRUCT_EXTRACT: &[FunctionParam] = &[
3698    FunctionParam {
3699        name: "this",
3700        required: true,
3701    },
3702    FunctionParam {
3703        name: "expression",
3704        required: true,
3705    },
3706];
3707static PARAMS_STR_POSITION: &[FunctionParam] = &[
3708    FunctionParam {
3709        name: "this",
3710        required: true,
3711    },
3712    FunctionParam {
3713        name: "substr",
3714        required: true,
3715    },
3716    FunctionParam {
3717        name: "position",
3718        required: false,
3719    },
3720    FunctionParam {
3721        name: "occurrence",
3722        required: false,
3723    },
3724];
3725static PARAMS_STR_TO_DATE: &[FunctionParam] = &[
3726    FunctionParam {
3727        name: "this",
3728        required: true,
3729    },
3730    FunctionParam {
3731        name: "format",
3732        required: false,
3733    },
3734    FunctionParam {
3735        name: "safe",
3736        required: false,
3737    },
3738];
3739static PARAMS_STR_TO_MAP: &[FunctionParam] = &[
3740    FunctionParam {
3741        name: "this",
3742        required: true,
3743    },
3744    FunctionParam {
3745        name: "pair_delim",
3746        required: false,
3747    },
3748    FunctionParam {
3749        name: "key_value_delim",
3750        required: false,
3751    },
3752    FunctionParam {
3753        name: "duplicate_resolution_callback",
3754        required: false,
3755    },
3756];
3757static PARAMS_STR_TO_TIME: &[FunctionParam] = &[
3758    FunctionParam {
3759        name: "this",
3760        required: true,
3761    },
3762    FunctionParam {
3763        name: "format",
3764        required: true,
3765    },
3766    FunctionParam {
3767        name: "zone",
3768        required: false,
3769    },
3770    FunctionParam {
3771        name: "safe",
3772        required: false,
3773    },
3774];
3775static PARAMS_STR_TO_UNIX: &[FunctionParam] = &[
3776    FunctionParam {
3777        name: "this",
3778        required: false,
3779    },
3780    FunctionParam {
3781        name: "format",
3782        required: false,
3783    },
3784];
3785static PARAMS_ST_DISTANCE: &[FunctionParam] = &[
3786    FunctionParam {
3787        name: "this",
3788        required: true,
3789    },
3790    FunctionParam {
3791        name: "expression",
3792        required: true,
3793    },
3794    FunctionParam {
3795        name: "use_spheroid",
3796        required: false,
3797    },
3798];
3799static PARAMS_ST_POINT: &[FunctionParam] = &[
3800    FunctionParam {
3801        name: "this",
3802        required: true,
3803    },
3804    FunctionParam {
3805        name: "expression",
3806        required: true,
3807    },
3808    FunctionParam {
3809        name: "null",
3810        required: false,
3811    },
3812];
3813static PARAMS_SUBSTRING: &[FunctionParam] = &[
3814    FunctionParam {
3815        name: "this",
3816        required: true,
3817    },
3818    FunctionParam {
3819        name: "start",
3820        required: false,
3821    },
3822    FunctionParam {
3823        name: "length",
3824        required: false,
3825    },
3826];
3827static PARAMS_SUBSTRING_INDEX: &[FunctionParam] = &[
3828    FunctionParam {
3829        name: "this",
3830        required: true,
3831    },
3832    FunctionParam {
3833        name: "delimiter",
3834        required: true,
3835    },
3836    FunctionParam {
3837        name: "count",
3838        required: true,
3839    },
3840];
3841static PARAMS_SUM: &[FunctionParam] = &[FunctionParam {
3842    name: "this",
3843    required: true,
3844}];
3845static PARAMS_SHA1DIGEST: &[FunctionParam] = &[FunctionParam {
3846    name: "this",
3847    required: true,
3848}];
3849static PARAMS_SHA2DIGEST: &[FunctionParam] = &[
3850    FunctionParam {
3851        name: "this",
3852        required: true,
3853    },
3854    FunctionParam {
3855        name: "length",
3856        required: false,
3857    },
3858];
3859static PARAMS_TAN: &[FunctionParam] = &[FunctionParam {
3860    name: "this",
3861    required: true,
3862}];
3863static PARAMS_TANH: &[FunctionParam] = &[FunctionParam {
3864    name: "this",
3865    required: true,
3866}];
3867static PARAMS_TIME: &[FunctionParam] = &[
3868    FunctionParam {
3869        name: "this",
3870        required: false,
3871    },
3872    FunctionParam {
3873        name: "zone",
3874        required: false,
3875    },
3876];
3877static PARAMS_TIME_FROM_PARTS: &[FunctionParam] = &[
3878    FunctionParam {
3879        name: "hour",
3880        required: true,
3881    },
3882    FunctionParam {
3883        name: "min",
3884        required: true,
3885    },
3886    FunctionParam {
3887        name: "sec",
3888        required: true,
3889    },
3890    FunctionParam {
3891        name: "nano",
3892        required: false,
3893    },
3894    FunctionParam {
3895        name: "fractions",
3896        required: false,
3897    },
3898    FunctionParam {
3899        name: "precision",
3900        required: false,
3901    },
3902];
3903static PARAMS_TIMESTAMP: &[FunctionParam] = &[
3904    FunctionParam {
3905        name: "this",
3906        required: false,
3907    },
3908    FunctionParam {
3909        name: "zone",
3910        required: false,
3911    },
3912    FunctionParam {
3913        name: "with_tz",
3914        required: false,
3915    },
3916];
3917static PARAMS_TIMESTAMP_DIFF: &[FunctionParam] = &[
3918    FunctionParam {
3919        name: "this",
3920        required: true,
3921    },
3922    FunctionParam {
3923        name: "expression",
3924        required: true,
3925    },
3926    FunctionParam {
3927        name: "unit",
3928        required: false,
3929    },
3930];
3931static PARAMS_TIMESTAMP_FROM_PARTS: &[FunctionParam] = &[
3932    FunctionParam {
3933        name: "year",
3934        required: false,
3935    },
3936    FunctionParam {
3937        name: "month",
3938        required: false,
3939    },
3940    FunctionParam {
3941        name: "day",
3942        required: false,
3943    },
3944    FunctionParam {
3945        name: "hour",
3946        required: false,
3947    },
3948    FunctionParam {
3949        name: "min",
3950        required: false,
3951    },
3952    FunctionParam {
3953        name: "sec",
3954        required: false,
3955    },
3956    FunctionParam {
3957        name: "nano",
3958        required: false,
3959    },
3960    FunctionParam {
3961        name: "zone",
3962        required: false,
3963    },
3964    FunctionParam {
3965        name: "milli",
3966        required: false,
3967    },
3968    FunctionParam {
3969        name: "this",
3970        required: false,
3971    },
3972    FunctionParam {
3973        name: "expression",
3974        required: false,
3975    },
3976];
3977static PARAMS_TIMESTAMP_LTZ_FROM_PARTS: &[FunctionParam] = &[
3978    FunctionParam {
3979        name: "year",
3980        required: false,
3981    },
3982    FunctionParam {
3983        name: "month",
3984        required: false,
3985    },
3986    FunctionParam {
3987        name: "day",
3988        required: false,
3989    },
3990    FunctionParam {
3991        name: "hour",
3992        required: false,
3993    },
3994    FunctionParam {
3995        name: "min",
3996        required: false,
3997    },
3998    FunctionParam {
3999        name: "sec",
4000        required: false,
4001    },
4002    FunctionParam {
4003        name: "nano",
4004        required: false,
4005    },
4006];
4007static PARAMS_TIMESTAMP_TZ_FROM_PARTS: &[FunctionParam] = &[
4008    FunctionParam {
4009        name: "year",
4010        required: false,
4011    },
4012    FunctionParam {
4013        name: "month",
4014        required: false,
4015    },
4016    FunctionParam {
4017        name: "day",
4018        required: false,
4019    },
4020    FunctionParam {
4021        name: "hour",
4022        required: false,
4023    },
4024    FunctionParam {
4025        name: "min",
4026        required: false,
4027    },
4028    FunctionParam {
4029        name: "sec",
4030        required: false,
4031    },
4032    FunctionParam {
4033        name: "nano",
4034        required: false,
4035    },
4036    FunctionParam {
4037        name: "zone",
4038        required: false,
4039    },
4040];
4041static PARAMS_TIMESTAMP_ADD: &[FunctionParam] = &[
4042    FunctionParam {
4043        name: "this",
4044        required: true,
4045    },
4046    FunctionParam {
4047        name: "expression",
4048        required: true,
4049    },
4050    FunctionParam {
4051        name: "unit",
4052        required: false,
4053    },
4054];
4055static PARAMS_TIMESTAMP_SUB: &[FunctionParam] = &[
4056    FunctionParam {
4057        name: "this",
4058        required: true,
4059    },
4060    FunctionParam {
4061        name: "expression",
4062        required: true,
4063    },
4064    FunctionParam {
4065        name: "unit",
4066        required: false,
4067    },
4068];
4069static PARAMS_TIMESTAMP_TRUNC: &[FunctionParam] = &[
4070    FunctionParam {
4071        name: "this",
4072        required: true,
4073    },
4074    FunctionParam {
4075        name: "unit",
4076        required: true,
4077    },
4078    FunctionParam {
4079        name: "zone",
4080        required: false,
4081    },
4082];
4083static PARAMS_TIME_ADD: &[FunctionParam] = &[
4084    FunctionParam {
4085        name: "this",
4086        required: true,
4087    },
4088    FunctionParam {
4089        name: "expression",
4090        required: true,
4091    },
4092    FunctionParam {
4093        name: "unit",
4094        required: false,
4095    },
4096];
4097static PARAMS_TIME_DIFF: &[FunctionParam] = &[
4098    FunctionParam {
4099        name: "this",
4100        required: true,
4101    },
4102    FunctionParam {
4103        name: "expression",
4104        required: true,
4105    },
4106    FunctionParam {
4107        name: "unit",
4108        required: false,
4109    },
4110];
4111static PARAMS_TIME_SLICE: &[FunctionParam] = &[
4112    FunctionParam {
4113        name: "this",
4114        required: true,
4115    },
4116    FunctionParam {
4117        name: "expression",
4118        required: true,
4119    },
4120    FunctionParam {
4121        name: "unit",
4122        required: true,
4123    },
4124    FunctionParam {
4125        name: "kind",
4126        required: false,
4127    },
4128];
4129static PARAMS_TIME_STR_TO_DATE: &[FunctionParam] = &[FunctionParam {
4130    name: "this",
4131    required: true,
4132}];
4133static PARAMS_TIME_STR_TO_TIME: &[FunctionParam] = &[
4134    FunctionParam {
4135        name: "this",
4136        required: true,
4137    },
4138    FunctionParam {
4139        name: "zone",
4140        required: false,
4141    },
4142];
4143static PARAMS_TIME_STR_TO_UNIX: &[FunctionParam] = &[FunctionParam {
4144    name: "this",
4145    required: true,
4146}];
4147static PARAMS_TIME_SUB: &[FunctionParam] = &[
4148    FunctionParam {
4149        name: "this",
4150        required: true,
4151    },
4152    FunctionParam {
4153        name: "expression",
4154        required: true,
4155    },
4156    FunctionParam {
4157        name: "unit",
4158        required: false,
4159    },
4160];
4161static PARAMS_TIME_TO_STR: &[FunctionParam] = &[
4162    FunctionParam {
4163        name: "this",
4164        required: true,
4165    },
4166    FunctionParam {
4167        name: "format",
4168        required: true,
4169    },
4170    FunctionParam {
4171        name: "culture",
4172        required: false,
4173    },
4174    FunctionParam {
4175        name: "zone",
4176        required: false,
4177    },
4178];
4179static PARAMS_TIME_TO_TIME_STR: &[FunctionParam] = &[FunctionParam {
4180    name: "this",
4181    required: true,
4182}];
4183static PARAMS_TIME_TO_UNIX: &[FunctionParam] = &[FunctionParam {
4184    name: "this",
4185    required: true,
4186}];
4187static PARAMS_TIME_TRUNC: &[FunctionParam] = &[
4188    FunctionParam {
4189        name: "this",
4190        required: true,
4191    },
4192    FunctionParam {
4193        name: "unit",
4194        required: true,
4195    },
4196    FunctionParam {
4197        name: "zone",
4198        required: false,
4199    },
4200];
4201static PARAMS_TO_ARRAY: &[FunctionParam] = &[FunctionParam {
4202    name: "this",
4203    required: true,
4204}];
4205static PARAMS_TO_BASE32: &[FunctionParam] = &[FunctionParam {
4206    name: "this",
4207    required: true,
4208}];
4209static PARAMS_TO_BASE64: &[FunctionParam] = &[FunctionParam {
4210    name: "this",
4211    required: true,
4212}];
4213static PARAMS_TO_CHAR: &[FunctionParam] = &[
4214    FunctionParam {
4215        name: "this",
4216        required: true,
4217    },
4218    FunctionParam {
4219        name: "format",
4220        required: false,
4221    },
4222    FunctionParam {
4223        name: "nlsparam",
4224        required: false,
4225    },
4226    FunctionParam {
4227        name: "is_numeric",
4228        required: false,
4229    },
4230];
4231static PARAMS_TO_CODE_POINTS: &[FunctionParam] = &[FunctionParam {
4232    name: "this",
4233    required: true,
4234}];
4235static PARAMS_TO_DAYS: &[FunctionParam] = &[FunctionParam {
4236    name: "this",
4237    required: true,
4238}];
4239static PARAMS_TO_DOUBLE: &[FunctionParam] = &[
4240    FunctionParam {
4241        name: "this",
4242        required: true,
4243    },
4244    FunctionParam {
4245        name: "format",
4246        required: false,
4247    },
4248];
4249static PARAMS_TO_MAP: &[FunctionParam] = &[FunctionParam {
4250    name: "this",
4251    required: true,
4252}];
4253static PARAMS_TO_NUMBER: &[FunctionParam] = &[
4254    FunctionParam {
4255        name: "this",
4256        required: true,
4257    },
4258    FunctionParam {
4259        name: "format",
4260        required: false,
4261    },
4262    FunctionParam {
4263        name: "nlsparam",
4264        required: false,
4265    },
4266    FunctionParam {
4267        name: "precision",
4268        required: false,
4269    },
4270    FunctionParam {
4271        name: "scale",
4272        required: false,
4273    },
4274];
4275static PARAMS_TRANSFORM: &[FunctionParam] = &[
4276    FunctionParam {
4277        name: "this",
4278        required: true,
4279    },
4280    FunctionParam {
4281        name: "expression",
4282        required: true,
4283    },
4284];
4285static PARAMS_TRANSLATE: &[FunctionParam] = &[
4286    FunctionParam {
4287        name: "this",
4288        required: true,
4289    },
4290    FunctionParam {
4291        name: "from_",
4292        required: true,
4293    },
4294    FunctionParam {
4295        name: "to",
4296        required: true,
4297    },
4298];
4299static PARAMS_TRIM: &[FunctionParam] = &[
4300    FunctionParam {
4301        name: "this",
4302        required: true,
4303    },
4304    FunctionParam {
4305        name: "expression",
4306        required: false,
4307    },
4308    FunctionParam {
4309        name: "position",
4310        required: false,
4311    },
4312    FunctionParam {
4313        name: "collation",
4314        required: false,
4315    },
4316];
4317static PARAMS_TRY: &[FunctionParam] = &[FunctionParam {
4318    name: "this",
4319    required: true,
4320}];
4321static PARAMS_TRY_BASE64DECODE_BINARY: &[FunctionParam] = &[
4322    FunctionParam {
4323        name: "this",
4324        required: true,
4325    },
4326    FunctionParam {
4327        name: "alphabet",
4328        required: false,
4329    },
4330];
4331static PARAMS_TRY_BASE64DECODE_STRING: &[FunctionParam] = &[
4332    FunctionParam {
4333        name: "this",
4334        required: true,
4335    },
4336    FunctionParam {
4337        name: "alphabet",
4338        required: false,
4339    },
4340];
4341static PARAMS_TRY_CAST: &[FunctionParam] = &[
4342    FunctionParam {
4343        name: "this",
4344        required: true,
4345    },
4346    FunctionParam {
4347        name: "to",
4348        required: true,
4349    },
4350    FunctionParam {
4351        name: "format",
4352        required: false,
4353    },
4354    FunctionParam {
4355        name: "safe",
4356        required: false,
4357    },
4358    FunctionParam {
4359        name: "action",
4360        required: false,
4361    },
4362    FunctionParam {
4363        name: "default",
4364        required: false,
4365    },
4366    FunctionParam {
4367        name: "requires_string",
4368        required: false,
4369    },
4370];
4371static PARAMS_TRY_HEX_DECODE_BINARY: &[FunctionParam] = &[FunctionParam {
4372    name: "this",
4373    required: true,
4374}];
4375static PARAMS_TRY_HEX_DECODE_STRING: &[FunctionParam] = &[FunctionParam {
4376    name: "this",
4377    required: true,
4378}];
4379static PARAMS_TS_OR_DI_TO_DI: &[FunctionParam] = &[FunctionParam {
4380    name: "this",
4381    required: true,
4382}];
4383static PARAMS_TS_OR_DS_ADD: &[FunctionParam] = &[
4384    FunctionParam {
4385        name: "this",
4386        required: true,
4387    },
4388    FunctionParam {
4389        name: "expression",
4390        required: true,
4391    },
4392    FunctionParam {
4393        name: "unit",
4394        required: false,
4395    },
4396    FunctionParam {
4397        name: "return_type",
4398        required: false,
4399    },
4400];
4401static PARAMS_TS_OR_DS_DIFF: &[FunctionParam] = &[
4402    FunctionParam {
4403        name: "this",
4404        required: true,
4405    },
4406    FunctionParam {
4407        name: "expression",
4408        required: true,
4409    },
4410    FunctionParam {
4411        name: "unit",
4412        required: false,
4413    },
4414];
4415static PARAMS_TS_OR_DS_TO_DATE: &[FunctionParam] = &[
4416    FunctionParam {
4417        name: "this",
4418        required: true,
4419    },
4420    FunctionParam {
4421        name: "format",
4422        required: false,
4423    },
4424    FunctionParam {
4425        name: "safe",
4426        required: false,
4427    },
4428];
4429static PARAMS_TS_OR_DS_TO_DATETIME: &[FunctionParam] = &[FunctionParam {
4430    name: "this",
4431    required: true,
4432}];
4433static PARAMS_TS_OR_DS_TO_DATE_STR: &[FunctionParam] = &[FunctionParam {
4434    name: "this",
4435    required: true,
4436}];
4437static PARAMS_TS_OR_DS_TO_TIME: &[FunctionParam] = &[
4438    FunctionParam {
4439        name: "this",
4440        required: true,
4441    },
4442    FunctionParam {
4443        name: "format",
4444        required: false,
4445    },
4446    FunctionParam {
4447        name: "safe",
4448        required: false,
4449    },
4450];
4451static PARAMS_TS_OR_DS_TO_TIMESTAMP: &[FunctionParam] = &[FunctionParam {
4452    name: "this",
4453    required: true,
4454}];
4455static PARAMS_TYPEOF: &[FunctionParam] = &[FunctionParam {
4456    name: "this",
4457    required: true,
4458}];
4459static PARAMS_UPPER: &[FunctionParam] = &[FunctionParam {
4460    name: "this",
4461    required: true,
4462}];
4463static PARAMS_UNHEX: &[FunctionParam] = &[
4464    FunctionParam {
4465        name: "this",
4466        required: true,
4467    },
4468    FunctionParam {
4469        name: "expression",
4470        required: false,
4471    },
4472];
4473static PARAMS_UNICODE: &[FunctionParam] = &[FunctionParam {
4474    name: "this",
4475    required: true,
4476}];
4477static PARAMS_UNIX_DATE: &[FunctionParam] = &[FunctionParam {
4478    name: "this",
4479    required: true,
4480}];
4481static PARAMS_UNIX_MICROS: &[FunctionParam] = &[FunctionParam {
4482    name: "this",
4483    required: true,
4484}];
4485static PARAMS_UNIX_MILLIS: &[FunctionParam] = &[FunctionParam {
4486    name: "this",
4487    required: true,
4488}];
4489static PARAMS_UNIX_SECONDS: &[FunctionParam] = &[FunctionParam {
4490    name: "this",
4491    required: true,
4492}];
4493static PARAMS_UNIX_TO_STR: &[FunctionParam] = &[
4494    FunctionParam {
4495        name: "this",
4496        required: true,
4497    },
4498    FunctionParam {
4499        name: "format",
4500        required: false,
4501    },
4502];
4503static PARAMS_UNIX_TO_TIME: &[FunctionParam] = &[
4504    FunctionParam {
4505        name: "this",
4506        required: true,
4507    },
4508    FunctionParam {
4509        name: "scale",
4510        required: false,
4511    },
4512    FunctionParam {
4513        name: "zone",
4514        required: false,
4515    },
4516    FunctionParam {
4517        name: "hours",
4518        required: false,
4519    },
4520    FunctionParam {
4521        name: "minutes",
4522        required: false,
4523    },
4524    FunctionParam {
4525        name: "format",
4526        required: false,
4527    },
4528];
4529static PARAMS_UNIX_TO_TIME_STR: &[FunctionParam] = &[FunctionParam {
4530    name: "this",
4531    required: true,
4532}];
4533static PARAMS_UNNEST: &[FunctionParam] = &[
4534    FunctionParam {
4535        name: "expressions",
4536        required: true,
4537    },
4538    FunctionParam {
4539        name: "alias",
4540        required: false,
4541    },
4542    FunctionParam {
4543        name: "offset",
4544        required: false,
4545    },
4546    FunctionParam {
4547        name: "explode_array",
4548        required: false,
4549    },
4550];
4551static PARAMS_UTC_TIME: &[FunctionParam] = &[FunctionParam {
4552    name: "this",
4553    required: false,
4554}];
4555static PARAMS_UTC_TIMESTAMP: &[FunctionParam] = &[FunctionParam {
4556    name: "this",
4557    required: false,
4558}];
4559static PARAMS_VARIANCE: &[FunctionParam] = &[FunctionParam {
4560    name: "this",
4561    required: true,
4562}];
4563static PARAMS_VARIANCE_POP: &[FunctionParam] = &[FunctionParam {
4564    name: "this",
4565    required: true,
4566}];
4567static PARAMS_VAR_MAP: &[FunctionParam] = &[
4568    FunctionParam {
4569        name: "keys",
4570        required: true,
4571    },
4572    FunctionParam {
4573        name: "values",
4574        required: true,
4575    },
4576];
4577static PARAMS_VECTOR_SEARCH: &[FunctionParam] = &[
4578    FunctionParam {
4579        name: "this",
4580        required: true,
4581    },
4582    FunctionParam {
4583        name: "column_to_search",
4584        required: true,
4585    },
4586    FunctionParam {
4587        name: "query_table",
4588        required: true,
4589    },
4590    FunctionParam {
4591        name: "query_column_to_search",
4592        required: false,
4593    },
4594    FunctionParam {
4595        name: "top_k",
4596        required: false,
4597    },
4598    FunctionParam {
4599        name: "distance_type",
4600        required: false,
4601    },
4602    FunctionParam {
4603        name: "options",
4604        required: false,
4605    },
4606];
4607static PARAMS_WEEK: &[FunctionParam] = &[
4608    FunctionParam {
4609        name: "this",
4610        required: true,
4611    },
4612    FunctionParam {
4613        name: "mode",
4614        required: false,
4615    },
4616];
4617static PARAMS_WEEK_OF_YEAR: &[FunctionParam] = &[FunctionParam {
4618    name: "this",
4619    required: true,
4620}];
4621static PARAMS_WIDTH_BUCKET: &[FunctionParam] = &[
4622    FunctionParam {
4623        name: "this",
4624        required: true,
4625    },
4626    FunctionParam {
4627        name: "min_value",
4628        required: true,
4629    },
4630    FunctionParam {
4631        name: "max_value",
4632        required: true,
4633    },
4634    FunctionParam {
4635        name: "num_buckets",
4636        required: true,
4637    },
4638];
4639static PARAMS_XML_ELEMENT: &[FunctionParam] = &[
4640    FunctionParam {
4641        name: "this",
4642        required: true,
4643    },
4644    FunctionParam {
4645        name: "expressions",
4646        required: false,
4647    },
4648];
4649static PARAMS_XOR: &[FunctionParam] = &[
4650    FunctionParam {
4651        name: "this",
4652        required: false,
4653    },
4654    FunctionParam {
4655        name: "expression",
4656        required: false,
4657    },
4658    FunctionParam {
4659        name: "expressions",
4660        required: false,
4661    },
4662];
4663static PARAMS_XML_TABLE: &[FunctionParam] = &[
4664    FunctionParam {
4665        name: "this",
4666        required: true,
4667    },
4668    FunctionParam {
4669        name: "namespaces",
4670        required: false,
4671    },
4672    FunctionParam {
4673        name: "passing",
4674        required: false,
4675    },
4676    FunctionParam {
4677        name: "columns",
4678        required: false,
4679    },
4680    FunctionParam {
4681        name: "by_ref",
4682        required: false,
4683    },
4684];
4685static PARAMS_YEAR: &[FunctionParam] = &[FunctionParam {
4686    name: "this",
4687    required: true,
4688}];
4689static PARAMS_YEAR_OF_WEEK: &[FunctionParam] = &[FunctionParam {
4690    name: "this",
4691    required: true,
4692}];
4693static PARAMS_YEAR_OF_WEEK_ISO: &[FunctionParam] = &[FunctionParam {
4694    name: "this",
4695    required: true,
4696}];
4697
4698/// Looks up a function signature by name.
4699///
4700/// Returns the complete function signature including parameters, return type,
4701/// and category. The lookup is case-insensitive.
4702///
4703/// # Arguments
4704///
4705/// * `name` - The function name (case-insensitive)
4706///
4707/// # Returns
4708///
4709/// `Some(FunctionSignature)` if the function is known, `None` otherwise.
4710pub fn get_function_signature(name: &str) -> Option<FunctionSignature> {
4711    let lower = name.to_ascii_lowercase();
4712    match lower.as_str() {
4713        "abs" => Some(FunctionSignature {
4714            name: "abs",
4715            display_name: "ABS",
4716            params: PARAMS_ABS,
4717            return_type: None,
4718            category: FunctionCategory::Scalar,
4719        }),
4720        "acos" => Some(FunctionSignature {
4721            name: "acos",
4722            display_name: "ACOS",
4723            params: PARAMS_ACOS,
4724            return_type: None,
4725            category: FunctionCategory::Scalar,
4726        }),
4727        "acosh" => Some(FunctionSignature {
4728            name: "acosh",
4729            display_name: "ACOSH",
4730            params: PARAMS_ACOSH,
4731            return_type: None,
4732            category: FunctionCategory::Scalar,
4733        }),
4734        "add_months" => Some(FunctionSignature {
4735            name: "add_months",
4736            display_name: "ADD_MONTHS",
4737            params: PARAMS_ADD_MONTHS,
4738            return_type: None,
4739            category: FunctionCategory::Scalar,
4740        }),
4741        "agg_func" => Some(FunctionSignature {
4742            name: "agg_func",
4743            display_name: "AGG_FUNC",
4744            params: PARAMS_AGG_FUNC,
4745            return_type: None,
4746            category: FunctionCategory::Aggregate,
4747        }),
4748        "ai_agg" => Some(FunctionSignature {
4749            name: "ai_agg",
4750            display_name: "AI_AGG",
4751            params: PARAMS_AI_AGG,
4752            return_type: None,
4753            category: FunctionCategory::Aggregate,
4754        }),
4755        "ai_classify" => Some(FunctionSignature {
4756            name: "ai_classify",
4757            display_name: "AI_CLASSIFY",
4758            params: PARAMS_AI_CLASSIFY,
4759            return_type: None,
4760            category: FunctionCategory::Scalar,
4761        }),
4762        "ai_summarize_agg" => Some(FunctionSignature {
4763            name: "ai_summarize_agg",
4764            display_name: "AI_SUMMARIZE_AGG",
4765            params: PARAMS_AI_SUMMARIZE_AGG,
4766            return_type: None,
4767            category: FunctionCategory::Aggregate,
4768        }),
4769        "and" => Some(FunctionSignature {
4770            name: "and",
4771            display_name: "AND",
4772            params: PARAMS_AND,
4773            return_type: Some(ReturnTypeRule::Boolean),
4774            category: FunctionCategory::Scalar,
4775        }),
4776        "any_value" => Some(FunctionSignature {
4777            name: "any_value",
4778            display_name: "ANY_VALUE",
4779            params: PARAMS_ANY_VALUE,
4780            return_type: Some(ReturnTypeRule::MatchFirstArg),
4781            category: FunctionCategory::Aggregate,
4782        }),
4783        "apply" => Some(FunctionSignature {
4784            name: "apply",
4785            display_name: "APPLY",
4786            params: PARAMS_APPLY,
4787            return_type: None,
4788            category: FunctionCategory::Scalar,
4789        }),
4790        "approximate_similarity" => Some(FunctionSignature {
4791            name: "approximate_similarity",
4792            display_name: "APPROXIMATE_SIMILARITY",
4793            params: PARAMS_APPROXIMATE_SIMILARITY,
4794            return_type: None,
4795            category: FunctionCategory::Aggregate,
4796        }),
4797        "approx_distinct" => Some(FunctionSignature {
4798            name: "approx_distinct",
4799            display_name: "APPROX_DISTINCT",
4800            params: PARAMS_APPROX_DISTINCT,
4801            return_type: None,
4802            category: FunctionCategory::Aggregate,
4803        }),
4804        "approx_quantile" => Some(FunctionSignature {
4805            name: "approx_quantile",
4806            display_name: "APPROX_QUANTILE",
4807            params: PARAMS_APPROX_QUANTILE,
4808            return_type: None,
4809            category: FunctionCategory::Aggregate,
4810        }),
4811        "approx_quantiles" => Some(FunctionSignature {
4812            name: "approx_quantiles",
4813            display_name: "APPROX_QUANTILES",
4814            params: PARAMS_APPROX_QUANTILES,
4815            return_type: None,
4816            category: FunctionCategory::Aggregate,
4817        }),
4818        "approx_top_k" => Some(FunctionSignature {
4819            name: "approx_top_k",
4820            display_name: "APPROX_TOP_K",
4821            params: PARAMS_APPROX_TOP_K,
4822            return_type: None,
4823            category: FunctionCategory::Aggregate,
4824        }),
4825        "approx_top_k_accumulate" => Some(FunctionSignature {
4826            name: "approx_top_k_accumulate",
4827            display_name: "APPROX_TOP_K_ACCUMULATE",
4828            params: PARAMS_APPROX_TOP_K_ACCUMULATE,
4829            return_type: None,
4830            category: FunctionCategory::Aggregate,
4831        }),
4832        "approx_top_k_combine" => Some(FunctionSignature {
4833            name: "approx_top_k_combine",
4834            display_name: "APPROX_TOP_K_COMBINE",
4835            params: PARAMS_APPROX_TOP_K_COMBINE,
4836            return_type: None,
4837            category: FunctionCategory::Aggregate,
4838        }),
4839        "approx_top_sum" => Some(FunctionSignature {
4840            name: "approx_top_sum",
4841            display_name: "APPROX_TOP_SUM",
4842            params: PARAMS_APPROX_TOP_SUM,
4843            return_type: None,
4844            category: FunctionCategory::Aggregate,
4845        }),
4846        "arg_max" => Some(FunctionSignature {
4847            name: "arg_max",
4848            display_name: "ARG_MAX",
4849            params: PARAMS_ARG_MAX,
4850            return_type: None,
4851            category: FunctionCategory::Aggregate,
4852        }),
4853        "arg_min" => Some(FunctionSignature {
4854            name: "arg_min",
4855            display_name: "ARG_MIN",
4856            params: PARAMS_ARG_MIN,
4857            return_type: None,
4858            category: FunctionCategory::Aggregate,
4859        }),
4860        "array" => Some(FunctionSignature {
4861            name: "array",
4862            display_name: "ARRAY",
4863            params: PARAMS_ARRAY,
4864            return_type: None,
4865            category: FunctionCategory::Scalar,
4866        }),
4867        "array_agg" => Some(FunctionSignature {
4868            name: "array_agg",
4869            display_name: "ARRAY_AGG",
4870            params: PARAMS_ARRAY_AGG,
4871            return_type: None,
4872            category: FunctionCategory::Aggregate,
4873        }),
4874        "array_all" => Some(FunctionSignature {
4875            name: "array_all",
4876            display_name: "ARRAY_ALL",
4877            params: PARAMS_ARRAY_ALL,
4878            return_type: None,
4879            category: FunctionCategory::Scalar,
4880        }),
4881        "array_any" => Some(FunctionSignature {
4882            name: "array_any",
4883            display_name: "ARRAY_ANY",
4884            params: PARAMS_ARRAY_ANY,
4885            return_type: None,
4886            category: FunctionCategory::Scalar,
4887        }),
4888        "array_concat" => Some(FunctionSignature {
4889            name: "array_concat",
4890            display_name: "ARRAY_CONCAT",
4891            params: PARAMS_ARRAY_CONCAT,
4892            return_type: None,
4893            category: FunctionCategory::Scalar,
4894        }),
4895        "array_concat_agg" => Some(FunctionSignature {
4896            name: "array_concat_agg",
4897            display_name: "ARRAY_CONCAT_AGG",
4898            params: PARAMS_ARRAY_CONCAT_AGG,
4899            return_type: None,
4900            category: FunctionCategory::Aggregate,
4901        }),
4902        "array_construct_compact" => Some(FunctionSignature {
4903            name: "array_construct_compact",
4904            display_name: "ARRAY_CONSTRUCT_COMPACT",
4905            params: PARAMS_ARRAY_CONSTRUCT_COMPACT,
4906            return_type: None,
4907            category: FunctionCategory::Scalar,
4908        }),
4909        "array_contains" => Some(FunctionSignature {
4910            name: "array_contains",
4911            display_name: "ARRAY_CONTAINS",
4912            params: PARAMS_ARRAY_CONTAINS,
4913            return_type: None,
4914            category: FunctionCategory::Scalar,
4915        }),
4916        "array_contains_all" => Some(FunctionSignature {
4917            name: "array_contains_all",
4918            display_name: "ARRAY_CONTAINS_ALL",
4919            params: PARAMS_ARRAY_CONTAINS_ALL,
4920            return_type: None,
4921            category: FunctionCategory::Scalar,
4922        }),
4923        "array_filter" => Some(FunctionSignature {
4924            name: "array_filter",
4925            display_name: "ARRAY_FILTER",
4926            params: PARAMS_ARRAY_FILTER,
4927            return_type: None,
4928            category: FunctionCategory::Scalar,
4929        }),
4930        "array_first" => Some(FunctionSignature {
4931            name: "array_first",
4932            display_name: "ARRAY_FIRST",
4933            params: PARAMS_ARRAY_FIRST,
4934            return_type: None,
4935            category: FunctionCategory::Scalar,
4936        }),
4937        "array_intersect" => Some(FunctionSignature {
4938            name: "array_intersect",
4939            display_name: "ARRAY_INTERSECT",
4940            params: PARAMS_ARRAY_INTERSECT,
4941            return_type: None,
4942            category: FunctionCategory::Scalar,
4943        }),
4944        "array_to_string" => Some(FunctionSignature {
4945            name: "array_to_string",
4946            display_name: "ARRAY_TO_STRING",
4947            params: PARAMS_ARRAY_TO_STRING,
4948            return_type: None,
4949            category: FunctionCategory::Scalar,
4950        }),
4951        "array_last" => Some(FunctionSignature {
4952            name: "array_last",
4953            display_name: "ARRAY_LAST",
4954            params: PARAMS_ARRAY_LAST,
4955            return_type: None,
4956            category: FunctionCategory::Scalar,
4957        }),
4958        "array_size" => Some(FunctionSignature {
4959            name: "array_size",
4960            display_name: "ARRAY_SIZE",
4961            params: PARAMS_ARRAY_SIZE,
4962            return_type: None,
4963            category: FunctionCategory::Scalar,
4964        }),
4965        "array_overlaps" => Some(FunctionSignature {
4966            name: "array_overlaps",
4967            display_name: "ARRAY_OVERLAPS",
4968            params: PARAMS_ARRAY_OVERLAPS,
4969            return_type: None,
4970            category: FunctionCategory::Scalar,
4971        }),
4972        "array_remove" => Some(FunctionSignature {
4973            name: "array_remove",
4974            display_name: "ARRAY_REMOVE",
4975            params: PARAMS_ARRAY_REMOVE,
4976            return_type: None,
4977            category: FunctionCategory::Scalar,
4978        }),
4979        "array_reverse" => Some(FunctionSignature {
4980            name: "array_reverse",
4981            display_name: "ARRAY_REVERSE",
4982            params: PARAMS_ARRAY_REVERSE,
4983            return_type: None,
4984            category: FunctionCategory::Scalar,
4985        }),
4986        "array_slice" => Some(FunctionSignature {
4987            name: "array_slice",
4988            display_name: "ARRAY_SLICE",
4989            params: PARAMS_ARRAY_SLICE,
4990            return_type: None,
4991            category: FunctionCategory::Scalar,
4992        }),
4993        "array_sort" => Some(FunctionSignature {
4994            name: "array_sort",
4995            display_name: "ARRAY_SORT",
4996            params: PARAMS_ARRAY_SORT,
4997            return_type: None,
4998            category: FunctionCategory::Scalar,
4999        }),
5000        "array_sum" => Some(FunctionSignature {
5001            name: "array_sum",
5002            display_name: "ARRAY_SUM",
5003            params: PARAMS_ARRAY_SUM,
5004            return_type: None,
5005            category: FunctionCategory::Scalar,
5006        }),
5007        "array_union_agg" => Some(FunctionSignature {
5008            name: "array_union_agg",
5009            display_name: "ARRAY_UNION_AGG",
5010            params: PARAMS_ARRAY_UNION_AGG,
5011            return_type: None,
5012            category: FunctionCategory::Aggregate,
5013        }),
5014        "array_unique_agg" => Some(FunctionSignature {
5015            name: "array_unique_agg",
5016            display_name: "ARRAY_UNIQUE_AGG",
5017            params: PARAMS_ARRAY_UNIQUE_AGG,
5018            return_type: None,
5019            category: FunctionCategory::Aggregate,
5020        }),
5021        "ascii" => Some(FunctionSignature {
5022            name: "ascii",
5023            display_name: "ASCII",
5024            params: PARAMS_ASCII,
5025            return_type: None,
5026            category: FunctionCategory::Scalar,
5027        }),
5028        "asin" => Some(FunctionSignature {
5029            name: "asin",
5030            display_name: "ASIN",
5031            params: PARAMS_ASIN,
5032            return_type: None,
5033            category: FunctionCategory::Scalar,
5034        }),
5035        "asinh" => Some(FunctionSignature {
5036            name: "asinh",
5037            display_name: "ASINH",
5038            params: PARAMS_ASINH,
5039            return_type: None,
5040            category: FunctionCategory::Scalar,
5041        }),
5042        "atan" => Some(FunctionSignature {
5043            name: "atan",
5044            display_name: "ATAN",
5045            params: PARAMS_ATAN,
5046            return_type: None,
5047            category: FunctionCategory::Scalar,
5048        }),
5049        "atan2" => Some(FunctionSignature {
5050            name: "atan2",
5051            display_name: "ATAN2",
5052            params: PARAMS_ATAN2,
5053            return_type: None,
5054            category: FunctionCategory::Scalar,
5055        }),
5056        "atanh" => Some(FunctionSignature {
5057            name: "atanh",
5058            display_name: "ATANH",
5059            params: PARAMS_ATANH,
5060            return_type: None,
5061            category: FunctionCategory::Scalar,
5062        }),
5063        "avg" => Some(FunctionSignature {
5064            name: "avg",
5065            display_name: "AVG",
5066            params: PARAMS_AVG,
5067            return_type: Some(ReturnTypeRule::Numeric),
5068            category: FunctionCategory::Aggregate,
5069        }),
5070        "base64decode_binary" => Some(FunctionSignature {
5071            name: "base64decode_binary",
5072            display_name: "BASE64DECODE_BINARY",
5073            params: PARAMS_BASE64DECODE_BINARY,
5074            return_type: None,
5075            category: FunctionCategory::Scalar,
5076        }),
5077        "base64decode_string" => Some(FunctionSignature {
5078            name: "base64decode_string",
5079            display_name: "BASE64DECODE_STRING",
5080            params: PARAMS_BASE64DECODE_STRING,
5081            return_type: None,
5082            category: FunctionCategory::Scalar,
5083        }),
5084        "base64encode" => Some(FunctionSignature {
5085            name: "base64encode",
5086            display_name: "BASE64ENCODE",
5087            params: PARAMS_BASE64ENCODE,
5088            return_type: None,
5089            category: FunctionCategory::Scalar,
5090        }),
5091        "bitmap_bit_position" => Some(FunctionSignature {
5092            name: "bitmap_bit_position",
5093            display_name: "BITMAP_BIT_POSITION",
5094            params: PARAMS_BITMAP_BIT_POSITION,
5095            return_type: None,
5096            category: FunctionCategory::Scalar,
5097        }),
5098        "bitmap_bucket_number" => Some(FunctionSignature {
5099            name: "bitmap_bucket_number",
5100            display_name: "BITMAP_BUCKET_NUMBER",
5101            params: PARAMS_BITMAP_BUCKET_NUMBER,
5102            return_type: None,
5103            category: FunctionCategory::Scalar,
5104        }),
5105        "bitmap_construct_agg" => Some(FunctionSignature {
5106            name: "bitmap_construct_agg",
5107            display_name: "BITMAP_CONSTRUCT_AGG",
5108            params: PARAMS_BITMAP_CONSTRUCT_AGG,
5109            return_type: None,
5110            category: FunctionCategory::Aggregate,
5111        }),
5112        "bitmap_count" => Some(FunctionSignature {
5113            name: "bitmap_count",
5114            display_name: "BITMAP_COUNT",
5115            params: PARAMS_BITMAP_COUNT,
5116            return_type: None,
5117            category: FunctionCategory::Scalar,
5118        }),
5119        "bitmap_or_agg" => Some(FunctionSignature {
5120            name: "bitmap_or_agg",
5121            display_name: "BITMAP_OR_AGG",
5122            params: PARAMS_BITMAP_OR_AGG,
5123            return_type: None,
5124            category: FunctionCategory::Aggregate,
5125        }),
5126        "bitwise_and_agg" => Some(FunctionSignature {
5127            name: "bitwise_and_agg",
5128            display_name: "BITWISE_AND_AGG",
5129            params: PARAMS_BITWISE_AND_AGG,
5130            return_type: None,
5131            category: FunctionCategory::Aggregate,
5132        }),
5133        "bitwise_count" => Some(FunctionSignature {
5134            name: "bitwise_count",
5135            display_name: "BITWISE_COUNT",
5136            params: PARAMS_BITWISE_COUNT,
5137            return_type: None,
5138            category: FunctionCategory::Scalar,
5139        }),
5140        "bitwise_or_agg" => Some(FunctionSignature {
5141            name: "bitwise_or_agg",
5142            display_name: "BITWISE_OR_AGG",
5143            params: PARAMS_BITWISE_OR_AGG,
5144            return_type: None,
5145            category: FunctionCategory::Aggregate,
5146        }),
5147        "bitwise_xor_agg" => Some(FunctionSignature {
5148            name: "bitwise_xor_agg",
5149            display_name: "BITWISE_XOR_AGG",
5150            params: PARAMS_BITWISE_XOR_AGG,
5151            return_type: None,
5152            category: FunctionCategory::Aggregate,
5153        }),
5154        "bit_length" => Some(FunctionSignature {
5155            name: "bit_length",
5156            display_name: "BIT_LENGTH",
5157            params: PARAMS_BIT_LENGTH,
5158            return_type: None,
5159            category: FunctionCategory::Scalar,
5160        }),
5161        "booland" => Some(FunctionSignature {
5162            name: "booland",
5163            display_name: "BOOLAND",
5164            params: PARAMS_BOOLAND,
5165            return_type: None,
5166            category: FunctionCategory::Scalar,
5167        }),
5168        "logical_and" => Some(FunctionSignature {
5169            name: "logical_and",
5170            display_name: "LOGICAL_AND",
5171            params: PARAMS_LOGICAL_AND,
5172            return_type: None,
5173            category: FunctionCategory::Aggregate,
5174        }),
5175        "boolnot" => Some(FunctionSignature {
5176            name: "boolnot",
5177            display_name: "BOOLNOT",
5178            params: PARAMS_BOOLNOT,
5179            return_type: None,
5180            category: FunctionCategory::Scalar,
5181        }),
5182        "boolor" => Some(FunctionSignature {
5183            name: "boolor",
5184            display_name: "BOOLOR",
5185            params: PARAMS_BOOLOR,
5186            return_type: None,
5187            category: FunctionCategory::Scalar,
5188        }),
5189        "logical_or" => Some(FunctionSignature {
5190            name: "logical_or",
5191            display_name: "LOGICAL_OR",
5192            params: PARAMS_LOGICAL_OR,
5193            return_type: None,
5194            category: FunctionCategory::Aggregate,
5195        }),
5196        "boolxor_agg" => Some(FunctionSignature {
5197            name: "boolxor_agg",
5198            display_name: "BOOLXOR_AGG",
5199            params: PARAMS_BOOLXOR_AGG,
5200            return_type: None,
5201            category: FunctionCategory::Aggregate,
5202        }),
5203        "byte_length" => Some(FunctionSignature {
5204            name: "byte_length",
5205            display_name: "BYTE_LENGTH",
5206            params: PARAMS_BYTE_LENGTH,
5207            return_type: None,
5208            category: FunctionCategory::Scalar,
5209        }),
5210        "case" => Some(FunctionSignature {
5211            name: "case",
5212            display_name: "CASE",
5213            params: PARAMS_CASE,
5214            return_type: None,
5215            category: FunctionCategory::Scalar,
5216        }),
5217        "cast" => Some(FunctionSignature {
5218            name: "cast",
5219            display_name: "CAST",
5220            params: PARAMS_CAST,
5221            return_type: None,
5222            category: FunctionCategory::Scalar,
5223        }),
5224        "cast_to_str_type" => Some(FunctionSignature {
5225            name: "cast_to_str_type",
5226            display_name: "CAST_TO_STR_TYPE",
5227            params: PARAMS_CAST_TO_STR_TYPE,
5228            return_type: None,
5229            category: FunctionCategory::Scalar,
5230        }),
5231        "cbrt" => Some(FunctionSignature {
5232            name: "cbrt",
5233            display_name: "CBRT",
5234            params: PARAMS_CBRT,
5235            return_type: None,
5236            category: FunctionCategory::Scalar,
5237        }),
5238        "ceil" => Some(FunctionSignature {
5239            name: "ceil",
5240            display_name: "CEIL",
5241            params: PARAMS_CEIL,
5242            return_type: None,
5243            category: FunctionCategory::Scalar,
5244        }),
5245        "chr" => Some(FunctionSignature {
5246            name: "chr",
5247            display_name: "CHR",
5248            params: PARAMS_CHR,
5249            return_type: None,
5250            category: FunctionCategory::Scalar,
5251        }),
5252        "length" => Some(FunctionSignature {
5253            name: "length",
5254            display_name: "LENGTH",
5255            params: PARAMS_LENGTH,
5256            return_type: None,
5257            category: FunctionCategory::Scalar,
5258        }),
5259        "coalesce" => Some(FunctionSignature {
5260            name: "coalesce",
5261            display_name: "COALESCE",
5262            params: PARAMS_COALESCE,
5263            return_type: Some(ReturnTypeRule::MatchFirstArg),
5264            category: FunctionCategory::Scalar,
5265        }),
5266        "code_points_to_bytes" => Some(FunctionSignature {
5267            name: "code_points_to_bytes",
5268            display_name: "CODE_POINTS_TO_BYTES",
5269            params: PARAMS_CODE_POINTS_TO_BYTES,
5270            return_type: None,
5271            category: FunctionCategory::Scalar,
5272        }),
5273        "code_points_to_string" => Some(FunctionSignature {
5274            name: "code_points_to_string",
5275            display_name: "CODE_POINTS_TO_STRING",
5276            params: PARAMS_CODE_POINTS_TO_STRING,
5277            return_type: None,
5278            category: FunctionCategory::Scalar,
5279        }),
5280        "collate" => Some(FunctionSignature {
5281            name: "collate",
5282            display_name: "COLLATE",
5283            params: PARAMS_COLLATE,
5284            return_type: None,
5285            category: FunctionCategory::Scalar,
5286        }),
5287        "collation" => Some(FunctionSignature {
5288            name: "collation",
5289            display_name: "COLLATION",
5290            params: PARAMS_COLLATION,
5291            return_type: None,
5292            category: FunctionCategory::Scalar,
5293        }),
5294        "columns" => Some(FunctionSignature {
5295            name: "columns",
5296            display_name: "COLUMNS",
5297            params: PARAMS_COLUMNS,
5298            return_type: None,
5299            category: FunctionCategory::Scalar,
5300        }),
5301        "combined_agg_func" => Some(FunctionSignature {
5302            name: "combined_agg_func",
5303            display_name: "COMBINED_AGG_FUNC",
5304            params: PARAMS_COMBINED_AGG_FUNC,
5305            return_type: None,
5306            category: FunctionCategory::Aggregate,
5307        }),
5308        "combined_parameterized_agg" => Some(FunctionSignature {
5309            name: "combined_parameterized_agg",
5310            display_name: "COMBINED_PARAMETERIZED_AGG",
5311            params: PARAMS_COMBINED_PARAMETERIZED_AGG,
5312            return_type: None,
5313            category: FunctionCategory::Aggregate,
5314        }),
5315        "compress" => Some(FunctionSignature {
5316            name: "compress",
5317            display_name: "COMPRESS",
5318            params: PARAMS_COMPRESS,
5319            return_type: None,
5320            category: FunctionCategory::Scalar,
5321        }),
5322        "concat" => Some(FunctionSignature {
5323            name: "concat",
5324            display_name: "CONCAT",
5325            params: PARAMS_CONCAT,
5326            return_type: Some(ReturnTypeRule::Text),
5327            category: FunctionCategory::Scalar,
5328        }),
5329        "concat_ws" => Some(FunctionSignature {
5330            name: "concat_ws",
5331            display_name: "CONCAT_WS",
5332            params: PARAMS_CONCAT_WS,
5333            return_type: Some(ReturnTypeRule::Text),
5334            category: FunctionCategory::Scalar,
5335        }),
5336        "connect_by_root" => Some(FunctionSignature {
5337            name: "connect_by_root",
5338            display_name: "CONNECT_BY_ROOT",
5339            params: PARAMS_CONNECT_BY_ROOT,
5340            return_type: None,
5341            category: FunctionCategory::Scalar,
5342        }),
5343        "contains" => Some(FunctionSignature {
5344            name: "contains",
5345            display_name: "CONTAINS",
5346            params: PARAMS_CONTAINS,
5347            return_type: None,
5348            category: FunctionCategory::Scalar,
5349        }),
5350        "convert" => Some(FunctionSignature {
5351            name: "convert",
5352            display_name: "CONVERT",
5353            params: PARAMS_CONVERT,
5354            return_type: None,
5355            category: FunctionCategory::Scalar,
5356        }),
5357        "convert_timezone" => Some(FunctionSignature {
5358            name: "convert_timezone",
5359            display_name: "CONVERT_TIMEZONE",
5360            params: PARAMS_CONVERT_TIMEZONE,
5361            return_type: None,
5362            category: FunctionCategory::Scalar,
5363        }),
5364        "convert_to_charset" => Some(FunctionSignature {
5365            name: "convert_to_charset",
5366            display_name: "CONVERT_TO_CHARSET",
5367            params: PARAMS_CONVERT_TO_CHARSET,
5368            return_type: None,
5369            category: FunctionCategory::Scalar,
5370        }),
5371        "corr" => Some(FunctionSignature {
5372            name: "corr",
5373            display_name: "CORR",
5374            params: PARAMS_CORR,
5375            return_type: None,
5376            category: FunctionCategory::Aggregate,
5377        }),
5378        "cos" => Some(FunctionSignature {
5379            name: "cos",
5380            display_name: "COS",
5381            params: PARAMS_COS,
5382            return_type: None,
5383            category: FunctionCategory::Scalar,
5384        }),
5385        "cosh" => Some(FunctionSignature {
5386            name: "cosh",
5387            display_name: "COSH",
5388            params: PARAMS_COSH,
5389            return_type: None,
5390            category: FunctionCategory::Scalar,
5391        }),
5392        "cosine_distance" => Some(FunctionSignature {
5393            name: "cosine_distance",
5394            display_name: "COSINE_DISTANCE",
5395            params: PARAMS_COSINE_DISTANCE,
5396            return_type: None,
5397            category: FunctionCategory::Scalar,
5398        }),
5399        "cot" => Some(FunctionSignature {
5400            name: "cot",
5401            display_name: "COT",
5402            params: PARAMS_COT,
5403            return_type: None,
5404            category: FunctionCategory::Scalar,
5405        }),
5406        "coth" => Some(FunctionSignature {
5407            name: "coth",
5408            display_name: "COTH",
5409            params: PARAMS_COTH,
5410            return_type: None,
5411            category: FunctionCategory::Scalar,
5412        }),
5413        "count" => Some(FunctionSignature {
5414            name: "count",
5415            display_name: "COUNT",
5416            params: PARAMS_COUNT,
5417            return_type: Some(ReturnTypeRule::Integer),
5418            category: FunctionCategory::Aggregate,
5419        }),
5420        "count_if" => Some(FunctionSignature {
5421            name: "count_if",
5422            display_name: "COUNT_IF",
5423            params: PARAMS_COUNT_IF,
5424            return_type: None,
5425            category: FunctionCategory::Aggregate,
5426        }),
5427        "covar_pop" => Some(FunctionSignature {
5428            name: "covar_pop",
5429            display_name: "COVAR_POP",
5430            params: PARAMS_COVAR_POP,
5431            return_type: None,
5432            category: FunctionCategory::Aggregate,
5433        }),
5434        "covar_samp" => Some(FunctionSignature {
5435            name: "covar_samp",
5436            display_name: "COVAR_SAMP",
5437            params: PARAMS_COVAR_SAMP,
5438            return_type: None,
5439            category: FunctionCategory::Aggregate,
5440        }),
5441        "csc" => Some(FunctionSignature {
5442            name: "csc",
5443            display_name: "CSC",
5444            params: PARAMS_CSC,
5445            return_type: None,
5446            category: FunctionCategory::Scalar,
5447        }),
5448        "csch" => Some(FunctionSignature {
5449            name: "csch",
5450            display_name: "CSCH",
5451            params: PARAMS_CSCH,
5452            return_type: None,
5453            category: FunctionCategory::Scalar,
5454        }),
5455        "cume_dist" => Some(FunctionSignature {
5456            name: "cume_dist",
5457            display_name: "CUME_DIST",
5458            params: PARAMS_CUME_DIST,
5459            return_type: None,
5460            category: FunctionCategory::Window,
5461        }),
5462        "current_date" => Some(FunctionSignature {
5463            name: "current_date",
5464            display_name: "CURRENT_DATE",
5465            params: PARAMS_CURRENT_DATE,
5466            return_type: Some(ReturnTypeRule::Date),
5467            category: FunctionCategory::Scalar,
5468        }),
5469        "current_datetime" => Some(FunctionSignature {
5470            name: "current_datetime",
5471            display_name: "CURRENT_DATETIME",
5472            params: PARAMS_CURRENT_DATETIME,
5473            return_type: None,
5474            category: FunctionCategory::Scalar,
5475        }),
5476        "current_schema" => Some(FunctionSignature {
5477            name: "current_schema",
5478            display_name: "CURRENT_SCHEMA",
5479            params: PARAMS_CURRENT_SCHEMA,
5480            return_type: None,
5481            category: FunctionCategory::Scalar,
5482        }),
5483        "current_time" => Some(FunctionSignature {
5484            name: "current_time",
5485            display_name: "CURRENT_TIME",
5486            params: PARAMS_CURRENT_TIME,
5487            return_type: None,
5488            category: FunctionCategory::Scalar,
5489        }),
5490        "current_timestamp" => Some(FunctionSignature {
5491            name: "current_timestamp",
5492            display_name: "CURRENT_TIMESTAMP",
5493            params: PARAMS_CURRENT_TIMESTAMP,
5494            return_type: Some(ReturnTypeRule::Timestamp),
5495            category: FunctionCategory::Scalar,
5496        }),
5497        "current_timestamp_ltz" => Some(FunctionSignature {
5498            name: "current_timestamp_ltz",
5499            display_name: "CURRENT_TIMESTAMP_LTZ",
5500            params: &[],
5501            return_type: None,
5502            category: FunctionCategory::Scalar,
5503        }),
5504        "current_user" => Some(FunctionSignature {
5505            name: "current_user",
5506            display_name: "CURRENT_USER",
5507            params: PARAMS_CURRENT_USER,
5508            return_type: None,
5509            category: FunctionCategory::Scalar,
5510        }),
5511        "date" => Some(FunctionSignature {
5512            name: "date",
5513            display_name: "DATE",
5514            params: PARAMS_DATE,
5515            return_type: None,
5516            category: FunctionCategory::Scalar,
5517        }),
5518        "date_diff" => Some(FunctionSignature {
5519            name: "date_diff",
5520            display_name: "DATE_DIFF",
5521            params: PARAMS_DATE_DIFF,
5522            return_type: None,
5523            category: FunctionCategory::Scalar,
5524        }),
5525        "date_from_parts" => Some(FunctionSignature {
5526            name: "date_from_parts",
5527            display_name: "DATE_FROM_PARTS",
5528            params: PARAMS_DATE_FROM_PARTS,
5529            return_type: None,
5530            category: FunctionCategory::Scalar,
5531        }),
5532        "datetime" => Some(FunctionSignature {
5533            name: "datetime",
5534            display_name: "DATETIME",
5535            params: PARAMS_DATETIME,
5536            return_type: None,
5537            category: FunctionCategory::Scalar,
5538        }),
5539        "datetime_add" => Some(FunctionSignature {
5540            name: "datetime_add",
5541            display_name: "DATETIME_ADD",
5542            params: PARAMS_DATETIME_ADD,
5543            return_type: None,
5544            category: FunctionCategory::Scalar,
5545        }),
5546        "datetime_diff" => Some(FunctionSignature {
5547            name: "datetime_diff",
5548            display_name: "DATETIME_DIFF",
5549            params: PARAMS_DATETIME_DIFF,
5550            return_type: None,
5551            category: FunctionCategory::Scalar,
5552        }),
5553        "datetime_sub" => Some(FunctionSignature {
5554            name: "datetime_sub",
5555            display_name: "DATETIME_SUB",
5556            params: PARAMS_DATETIME_SUB,
5557            return_type: None,
5558            category: FunctionCategory::Scalar,
5559        }),
5560        "datetime_trunc" => Some(FunctionSignature {
5561            name: "datetime_trunc",
5562            display_name: "DATETIME_TRUNC",
5563            params: PARAMS_DATETIME_TRUNC,
5564            return_type: None,
5565            category: FunctionCategory::Scalar,
5566        }),
5567        "date_add" => Some(FunctionSignature {
5568            name: "date_add",
5569            display_name: "DATE_ADD",
5570            params: PARAMS_DATE_ADD,
5571            return_type: None,
5572            category: FunctionCategory::Scalar,
5573        }),
5574        "date_bin" => Some(FunctionSignature {
5575            name: "date_bin",
5576            display_name: "DATE_BIN",
5577            params: PARAMS_DATE_BIN,
5578            return_type: None,
5579            category: FunctionCategory::Scalar,
5580        }),
5581        "date_from_unix_date" => Some(FunctionSignature {
5582            name: "date_from_unix_date",
5583            display_name: "DATE_FROM_UNIX_DATE",
5584            params: PARAMS_DATE_FROM_UNIX_DATE,
5585            return_type: None,
5586            category: FunctionCategory::Scalar,
5587        }),
5588        "date_str_to_date" => Some(FunctionSignature {
5589            name: "date_str_to_date",
5590            display_name: "DATE_STR_TO_DATE",
5591            params: PARAMS_DATE_STR_TO_DATE,
5592            return_type: None,
5593            category: FunctionCategory::Scalar,
5594        }),
5595        "date_sub" => Some(FunctionSignature {
5596            name: "date_sub",
5597            display_name: "DATE_SUB",
5598            params: PARAMS_DATE_SUB,
5599            return_type: None,
5600            category: FunctionCategory::Scalar,
5601        }),
5602        "date_to_date_str" => Some(FunctionSignature {
5603            name: "date_to_date_str",
5604            display_name: "DATE_TO_DATE_STR",
5605            params: PARAMS_DATE_TO_DATE_STR,
5606            return_type: None,
5607            category: FunctionCategory::Scalar,
5608        }),
5609        "date_to_di" => Some(FunctionSignature {
5610            name: "date_to_di",
5611            display_name: "DATE_TO_DI",
5612            params: PARAMS_DATE_TO_DI,
5613            return_type: None,
5614            category: FunctionCategory::Scalar,
5615        }),
5616        "date_trunc" => Some(FunctionSignature {
5617            name: "date_trunc",
5618            display_name: "DATE_TRUNC",
5619            params: PARAMS_DATE_TRUNC,
5620            return_type: Some(ReturnTypeRule::MatchFirstArg),
5621            category: FunctionCategory::Scalar,
5622        }),
5623        "day" => Some(FunctionSignature {
5624            name: "day",
5625            display_name: "DAY",
5626            params: PARAMS_DAY,
5627            return_type: None,
5628            category: FunctionCategory::Scalar,
5629        }),
5630        "day_of_month" => Some(FunctionSignature {
5631            name: "day_of_month",
5632            display_name: "DAY_OF_MONTH",
5633            params: PARAMS_DAY_OF_MONTH,
5634            return_type: None,
5635            category: FunctionCategory::Scalar,
5636        }),
5637        "day_of_week" => Some(FunctionSignature {
5638            name: "day_of_week",
5639            display_name: "DAY_OF_WEEK",
5640            params: PARAMS_DAY_OF_WEEK,
5641            return_type: None,
5642            category: FunctionCategory::Scalar,
5643        }),
5644        "day_of_week_iso" => Some(FunctionSignature {
5645            name: "day_of_week_iso",
5646            display_name: "DAY_OF_WEEK_ISO",
5647            params: PARAMS_DAY_OF_WEEK_ISO,
5648            return_type: None,
5649            category: FunctionCategory::Scalar,
5650        }),
5651        "day_of_year" => Some(FunctionSignature {
5652            name: "day_of_year",
5653            display_name: "DAY_OF_YEAR",
5654            params: PARAMS_DAY_OF_YEAR,
5655            return_type: None,
5656            category: FunctionCategory::Scalar,
5657        }),
5658        "decode" => Some(FunctionSignature {
5659            name: "decode",
5660            display_name: "DECODE",
5661            params: PARAMS_DECODE,
5662            return_type: None,
5663            category: FunctionCategory::Scalar,
5664        }),
5665        "decode_case" => Some(FunctionSignature {
5666            name: "decode_case",
5667            display_name: "DECODE_CASE",
5668            params: PARAMS_DECODE_CASE,
5669            return_type: None,
5670            category: FunctionCategory::Scalar,
5671        }),
5672        "decompress_binary" => Some(FunctionSignature {
5673            name: "decompress_binary",
5674            display_name: "DECOMPRESS_BINARY",
5675            params: PARAMS_DECOMPRESS_BINARY,
5676            return_type: None,
5677            category: FunctionCategory::Scalar,
5678        }),
5679        "decompress_string" => Some(FunctionSignature {
5680            name: "decompress_string",
5681            display_name: "DECOMPRESS_STRING",
5682            params: PARAMS_DECOMPRESS_STRING,
5683            return_type: None,
5684            category: FunctionCategory::Scalar,
5685        }),
5686        "degrees" => Some(FunctionSignature {
5687            name: "degrees",
5688            display_name: "DEGREES",
5689            params: PARAMS_DEGREES,
5690            return_type: None,
5691            category: FunctionCategory::Scalar,
5692        }),
5693        "dense_rank" => Some(FunctionSignature {
5694            name: "dense_rank",
5695            display_name: "DENSE_RANK",
5696            params: PARAMS_DENSE_RANK,
5697            return_type: Some(ReturnTypeRule::Integer),
5698            category: FunctionCategory::Window,
5699        }),
5700        "di_to_date" => Some(FunctionSignature {
5701            name: "di_to_date",
5702            display_name: "DI_TO_DATE",
5703            params: PARAMS_DI_TO_DATE,
5704            return_type: None,
5705            category: FunctionCategory::Scalar,
5706        }),
5707        "encode" => Some(FunctionSignature {
5708            name: "encode",
5709            display_name: "ENCODE",
5710            params: PARAMS_ENCODE,
5711            return_type: None,
5712            category: FunctionCategory::Scalar,
5713        }),
5714        "ends_with" => Some(FunctionSignature {
5715            name: "ends_with",
5716            display_name: "ENDS_WITH",
5717            params: PARAMS_ENDS_WITH,
5718            return_type: None,
5719            category: FunctionCategory::Scalar,
5720        }),
5721        "equal_null" => Some(FunctionSignature {
5722            name: "equal_null",
5723            display_name: "EQUAL_NULL",
5724            params: PARAMS_EQUAL_NULL,
5725            return_type: None,
5726            category: FunctionCategory::Scalar,
5727        }),
5728        "euclidean_distance" => Some(FunctionSignature {
5729            name: "euclidean_distance",
5730            display_name: "EUCLIDEAN_DISTANCE",
5731            params: PARAMS_EUCLIDEAN_DISTANCE,
5732            return_type: None,
5733            category: FunctionCategory::Scalar,
5734        }),
5735        "exists" => Some(FunctionSignature {
5736            name: "exists",
5737            display_name: "EXISTS",
5738            params: PARAMS_EXISTS,
5739            return_type: None,
5740            category: FunctionCategory::Scalar,
5741        }),
5742        "exp" => Some(FunctionSignature {
5743            name: "exp",
5744            display_name: "EXP",
5745            params: PARAMS_EXP,
5746            return_type: None,
5747            category: FunctionCategory::Scalar,
5748        }),
5749        "explode" => Some(FunctionSignature {
5750            name: "explode",
5751            display_name: "EXPLODE",
5752            params: PARAMS_EXPLODE,
5753            return_type: None,
5754            category: FunctionCategory::Scalar,
5755        }),
5756        "explode_outer" => Some(FunctionSignature {
5757            name: "explode_outer",
5758            display_name: "EXPLODE_OUTER",
5759            params: PARAMS_EXPLODE_OUTER,
5760            return_type: None,
5761            category: FunctionCategory::Scalar,
5762        }),
5763        "exploding_generate_series" => Some(FunctionSignature {
5764            name: "exploding_generate_series",
5765            display_name: "EXPLODING_GENERATE_SERIES",
5766            params: PARAMS_EXPLODING_GENERATE_SERIES,
5767            return_type: None,
5768            category: FunctionCategory::Scalar,
5769        }),
5770        "extract" => Some(FunctionSignature {
5771            name: "extract",
5772            display_name: "EXTRACT",
5773            params: PARAMS_EXTRACT,
5774            return_type: None,
5775            category: FunctionCategory::Scalar,
5776        }),
5777        "factorial" => Some(FunctionSignature {
5778            name: "factorial",
5779            display_name: "FACTORIAL",
5780            params: PARAMS_FACTORIAL,
5781            return_type: None,
5782            category: FunctionCategory::Scalar,
5783        }),
5784        "farm_fingerprint" => Some(FunctionSignature {
5785            name: "farm_fingerprint",
5786            display_name: "FARM_FINGERPRINT",
5787            params: PARAMS_FARM_FINGERPRINT,
5788            return_type: None,
5789            category: FunctionCategory::Scalar,
5790        }),
5791        "features_at_time" => Some(FunctionSignature {
5792            name: "features_at_time",
5793            display_name: "FEATURES_AT_TIME",
5794            params: PARAMS_FEATURES_AT_TIME,
5795            return_type: None,
5796            category: FunctionCategory::Scalar,
5797        }),
5798        "first" => Some(FunctionSignature {
5799            name: "first",
5800            display_name: "FIRST",
5801            params: PARAMS_FIRST,
5802            return_type: None,
5803            category: FunctionCategory::Aggregate,
5804        }),
5805        "first_value" => Some(FunctionSignature {
5806            name: "first_value",
5807            display_name: "FIRST_VALUE",
5808            params: PARAMS_FIRST_VALUE,
5809            return_type: Some(ReturnTypeRule::MatchFirstArg),
5810            category: FunctionCategory::Window,
5811        }),
5812        "flatten" => Some(FunctionSignature {
5813            name: "flatten",
5814            display_name: "FLATTEN",
5815            params: PARAMS_FLATTEN,
5816            return_type: None,
5817            category: FunctionCategory::Scalar,
5818        }),
5819        "float64" => Some(FunctionSignature {
5820            name: "float64",
5821            display_name: "FLOAT64",
5822            params: PARAMS_FLOAT64,
5823            return_type: None,
5824            category: FunctionCategory::Scalar,
5825        }),
5826        "floor" => Some(FunctionSignature {
5827            name: "floor",
5828            display_name: "FLOOR",
5829            params: PARAMS_FLOOR,
5830            return_type: None,
5831            category: FunctionCategory::Scalar,
5832        }),
5833        "format" => Some(FunctionSignature {
5834            name: "format",
5835            display_name: "FORMAT",
5836            params: PARAMS_FORMAT,
5837            return_type: None,
5838            category: FunctionCategory::Scalar,
5839        }),
5840        "from_base" => Some(FunctionSignature {
5841            name: "from_base",
5842            display_name: "FROM_BASE",
5843            params: PARAMS_FROM_BASE,
5844            return_type: None,
5845            category: FunctionCategory::Scalar,
5846        }),
5847        "from_base32" => Some(FunctionSignature {
5848            name: "from_base32",
5849            display_name: "FROM_BASE32",
5850            params: PARAMS_FROM_BASE32,
5851            return_type: None,
5852            category: FunctionCategory::Scalar,
5853        }),
5854        "from_base64" => Some(FunctionSignature {
5855            name: "from_base64",
5856            display_name: "FROM_BASE64",
5857            params: PARAMS_FROM_BASE64,
5858            return_type: None,
5859            category: FunctionCategory::Scalar,
5860        }),
5861        "from_iso8601timestamp" => Some(FunctionSignature {
5862            name: "from_iso8601timestamp",
5863            display_name: "FROM_ISO8601TIMESTAMP",
5864            params: PARAMS_FROM_ISO8601TIMESTAMP,
5865            return_type: None,
5866            category: FunctionCategory::Scalar,
5867        }),
5868        "gap_fill" => Some(FunctionSignature {
5869            name: "gap_fill",
5870            display_name: "GAP_FILL",
5871            params: PARAMS_GAP_FILL,
5872            return_type: None,
5873            category: FunctionCategory::Scalar,
5874        }),
5875        "generate_date_array" => Some(FunctionSignature {
5876            name: "generate_date_array",
5877            display_name: "GENERATE_DATE_ARRAY",
5878            params: PARAMS_GENERATE_DATE_ARRAY,
5879            return_type: None,
5880            category: FunctionCategory::Scalar,
5881        }),
5882        "generate_embedding" => Some(FunctionSignature {
5883            name: "generate_embedding",
5884            display_name: "GENERATE_EMBEDDING",
5885            params: PARAMS_GENERATE_EMBEDDING,
5886            return_type: None,
5887            category: FunctionCategory::Scalar,
5888        }),
5889        "generate_series" => Some(FunctionSignature {
5890            name: "generate_series",
5891            display_name: "GENERATE_SERIES",
5892            params: PARAMS_GENERATE_SERIES,
5893            return_type: None,
5894            category: FunctionCategory::Scalar,
5895        }),
5896        "generate_timestamp_array" => Some(FunctionSignature {
5897            name: "generate_timestamp_array",
5898            display_name: "GENERATE_TIMESTAMP_ARRAY",
5899            params: PARAMS_GENERATE_TIMESTAMP_ARRAY,
5900            return_type: None,
5901            category: FunctionCategory::Scalar,
5902        }),
5903        "uuid" => Some(FunctionSignature {
5904            name: "uuid",
5905            display_name: "UUID",
5906            params: PARAMS_UUID,
5907            return_type: None,
5908            category: FunctionCategory::Scalar,
5909        }),
5910        "getbit" => Some(FunctionSignature {
5911            name: "getbit",
5912            display_name: "GETBIT",
5913            params: PARAMS_GETBIT,
5914            return_type: None,
5915            category: FunctionCategory::Scalar,
5916        }),
5917        "get_extract" => Some(FunctionSignature {
5918            name: "get_extract",
5919            display_name: "GET_EXTRACT",
5920            params: PARAMS_GET_EXTRACT,
5921            return_type: None,
5922            category: FunctionCategory::Scalar,
5923        }),
5924        "greatest" => Some(FunctionSignature {
5925            name: "greatest",
5926            display_name: "GREATEST",
5927            params: PARAMS_GREATEST,
5928            return_type: None,
5929            category: FunctionCategory::Scalar,
5930        }),
5931        "greatest_ignore_nulls" => Some(FunctionSignature {
5932            name: "greatest_ignore_nulls",
5933            display_name: "GREATEST_IGNORE_NULLS",
5934            params: PARAMS_GREATEST_IGNORE_NULLS,
5935            return_type: None,
5936            category: FunctionCategory::Scalar,
5937        }),
5938        "grouping" => Some(FunctionSignature {
5939            name: "grouping",
5940            display_name: "GROUPING",
5941            params: PARAMS_GROUPING,
5942            return_type: None,
5943            category: FunctionCategory::Aggregate,
5944        }),
5945        "grouping_id" => Some(FunctionSignature {
5946            name: "grouping_id",
5947            display_name: "GROUPING_ID",
5948            params: PARAMS_GROUPING_ID,
5949            return_type: None,
5950            category: FunctionCategory::Aggregate,
5951        }),
5952        "group_concat" => Some(FunctionSignature {
5953            name: "group_concat",
5954            display_name: "GROUP_CONCAT",
5955            params: PARAMS_GROUP_CONCAT,
5956            return_type: None,
5957            category: FunctionCategory::Aggregate,
5958        }),
5959        "hex" => Some(FunctionSignature {
5960            name: "hex",
5961            display_name: "HEX",
5962            params: PARAMS_HEX,
5963            return_type: None,
5964            category: FunctionCategory::Scalar,
5965        }),
5966        "hex_decode_string" => Some(FunctionSignature {
5967            name: "hex_decode_string",
5968            display_name: "HEX_DECODE_STRING",
5969            params: PARAMS_HEX_DECODE_STRING,
5970            return_type: None,
5971            category: FunctionCategory::Scalar,
5972        }),
5973        "hex_encode" => Some(FunctionSignature {
5974            name: "hex_encode",
5975            display_name: "HEX_ENCODE",
5976            params: PARAMS_HEX_ENCODE,
5977            return_type: None,
5978            category: FunctionCategory::Scalar,
5979        }),
5980        "hll" => Some(FunctionSignature {
5981            name: "hll",
5982            display_name: "HLL",
5983            params: PARAMS_HLL,
5984            return_type: None,
5985            category: FunctionCategory::Aggregate,
5986        }),
5987        "hour" => Some(FunctionSignature {
5988            name: "hour",
5989            display_name: "HOUR",
5990            params: PARAMS_HOUR,
5991            return_type: None,
5992            category: FunctionCategory::Scalar,
5993        }),
5994        "if" => Some(FunctionSignature {
5995            name: "if",
5996            display_name: "IF",
5997            params: PARAMS_IF,
5998            return_type: None,
5999            category: FunctionCategory::Scalar,
6000        }),
6001        "initcap" => Some(FunctionSignature {
6002            name: "initcap",
6003            display_name: "INITCAP",
6004            params: PARAMS_INITCAP,
6005            return_type: None,
6006            category: FunctionCategory::Scalar,
6007        }),
6008        "inline" => Some(FunctionSignature {
6009            name: "inline",
6010            display_name: "INLINE",
6011            params: PARAMS_INLINE,
6012            return_type: None,
6013            category: FunctionCategory::Scalar,
6014        }),
6015        "stuff" => Some(FunctionSignature {
6016            name: "stuff",
6017            display_name: "STUFF",
6018            params: PARAMS_STUFF,
6019            return_type: None,
6020            category: FunctionCategory::Scalar,
6021        }),
6022        "int64" => Some(FunctionSignature {
6023            name: "int64",
6024            display_name: "INT64",
6025            params: PARAMS_INT64,
6026            return_type: None,
6027            category: FunctionCategory::Scalar,
6028        }),
6029        "is_inf" => Some(FunctionSignature {
6030            name: "is_inf",
6031            display_name: "IS_INF",
6032            params: PARAMS_IS_INF,
6033            return_type: None,
6034            category: FunctionCategory::Scalar,
6035        }),
6036        "is_nan" => Some(FunctionSignature {
6037            name: "is_nan",
6038            display_name: "IS_NAN",
6039            params: PARAMS_IS_NAN,
6040            return_type: None,
6041            category: FunctionCategory::Scalar,
6042        }),
6043        "is_ascii" => Some(FunctionSignature {
6044            name: "is_ascii",
6045            display_name: "IS_ASCII",
6046            params: PARAMS_IS_ASCII,
6047            return_type: None,
6048            category: FunctionCategory::Scalar,
6049        }),
6050        "is_null_value" => Some(FunctionSignature {
6051            name: "is_null_value",
6052            display_name: "IS_NULL_VALUE",
6053            params: PARAMS_IS_NULL_VALUE,
6054            return_type: None,
6055            category: FunctionCategory::Scalar,
6056        }),
6057        "jarowinkler_similarity" => Some(FunctionSignature {
6058            name: "jarowinkler_similarity",
6059            display_name: "JAROWINKLER_SIMILARITY",
6060            params: PARAMS_JAROWINKLER_SIMILARITY,
6061            return_type: None,
6062            category: FunctionCategory::Scalar,
6063        }),
6064        "jsonb_contains" => Some(FunctionSignature {
6065            name: "jsonb_contains",
6066            display_name: "JSONB_CONTAINS",
6067            params: PARAMS_JSONB_CONTAINS,
6068            return_type: None,
6069            category: FunctionCategory::Scalar,
6070        }),
6071        "jsonb_exists" => Some(FunctionSignature {
6072            name: "jsonb_exists",
6073            display_name: "JSONB_EXISTS",
6074            params: PARAMS_JSONB_EXISTS,
6075            return_type: None,
6076            category: FunctionCategory::Scalar,
6077        }),
6078        "jsonb_extract" => Some(FunctionSignature {
6079            name: "jsonb_extract",
6080            display_name: "JSONB_EXTRACT",
6081            params: PARAMS_JSONB_EXTRACT,
6082            return_type: None,
6083            category: FunctionCategory::Scalar,
6084        }),
6085        "jsonb_extract_scalar" => Some(FunctionSignature {
6086            name: "jsonb_extract_scalar",
6087            display_name: "JSONB_EXTRACT_SCALAR",
6088            params: PARAMS_JSONB_EXTRACT_SCALAR,
6089            return_type: None,
6090            category: FunctionCategory::Scalar,
6091        }),
6092        "json_array_append" => Some(FunctionSignature {
6093            name: "json_array_append",
6094            display_name: "JSON_ARRAY_APPEND",
6095            params: PARAMS_JSON_ARRAY_APPEND,
6096            return_type: None,
6097            category: FunctionCategory::Scalar,
6098        }),
6099        "json_array_contains" => Some(FunctionSignature {
6100            name: "json_array_contains",
6101            display_name: "JSON_ARRAY_CONTAINS",
6102            params: PARAMS_JSON_ARRAY_CONTAINS,
6103            return_type: None,
6104            category: FunctionCategory::Scalar,
6105        }),
6106        "json_array_insert" => Some(FunctionSignature {
6107            name: "json_array_insert",
6108            display_name: "JSON_ARRAY_INSERT",
6109            params: PARAMS_JSON_ARRAY_INSERT,
6110            return_type: None,
6111            category: FunctionCategory::Scalar,
6112        }),
6113        "json_extract" => Some(FunctionSignature {
6114            name: "json_extract",
6115            display_name: "JSON_EXTRACT",
6116            params: PARAMS_JSON_EXTRACT,
6117            return_type: None,
6118            category: FunctionCategory::Scalar,
6119        }),
6120        "json_extract_array" => Some(FunctionSignature {
6121            name: "json_extract_array",
6122            display_name: "JSON_EXTRACT_ARRAY",
6123            params: PARAMS_JSON_EXTRACT_ARRAY,
6124            return_type: None,
6125            category: FunctionCategory::Scalar,
6126        }),
6127        "json_extract_scalar" => Some(FunctionSignature {
6128            name: "json_extract_scalar",
6129            display_name: "JSON_EXTRACT_SCALAR",
6130            params: PARAMS_JSON_EXTRACT_SCALAR,
6131            return_type: None,
6132            category: FunctionCategory::Scalar,
6133        }),
6134        "json_format" => Some(FunctionSignature {
6135            name: "json_format",
6136            display_name: "JSON_FORMAT",
6137            params: PARAMS_JSON_FORMAT,
6138            return_type: None,
6139            category: FunctionCategory::Scalar,
6140        }),
6141        "parse_json" => Some(FunctionSignature {
6142            name: "parse_json",
6143            display_name: "PARSE_JSON",
6144            params: PARAMS_PARSE_JSON,
6145            return_type: None,
6146            category: FunctionCategory::Scalar,
6147        }),
6148        "json_remove" => Some(FunctionSignature {
6149            name: "json_remove",
6150            display_name: "JSON_REMOVE",
6151            params: PARAMS_JSON_REMOVE,
6152            return_type: None,
6153            category: FunctionCategory::Scalar,
6154        }),
6155        "json_set" => Some(FunctionSignature {
6156            name: "json_set",
6157            display_name: "JSON_SET",
6158            params: PARAMS_JSON_SET,
6159            return_type: None,
6160            category: FunctionCategory::Scalar,
6161        }),
6162        "json_strip_nulls" => Some(FunctionSignature {
6163            name: "json_strip_nulls",
6164            display_name: "JSON_STRIP_NULLS",
6165            params: PARAMS_JSON_STRIP_NULLS,
6166            return_type: None,
6167            category: FunctionCategory::Scalar,
6168        }),
6169        "json_type" => Some(FunctionSignature {
6170            name: "json_type",
6171            display_name: "JSON_TYPE",
6172            params: PARAMS_JSON_TYPE,
6173            return_type: None,
6174            category: FunctionCategory::Scalar,
6175        }),
6176        "justify_days" => Some(FunctionSignature {
6177            name: "justify_days",
6178            display_name: "JUSTIFY_DAYS",
6179            params: PARAMS_JUSTIFY_DAYS,
6180            return_type: None,
6181            category: FunctionCategory::Scalar,
6182        }),
6183        "justify_hours" => Some(FunctionSignature {
6184            name: "justify_hours",
6185            display_name: "JUSTIFY_HOURS",
6186            params: PARAMS_JUSTIFY_HOURS,
6187            return_type: None,
6188            category: FunctionCategory::Scalar,
6189        }),
6190        "justify_interval" => Some(FunctionSignature {
6191            name: "justify_interval",
6192            display_name: "JUSTIFY_INTERVAL",
6193            params: PARAMS_JUSTIFY_INTERVAL,
6194            return_type: None,
6195            category: FunctionCategory::Scalar,
6196        }),
6197        "json_array" => Some(FunctionSignature {
6198            name: "json_array",
6199            display_name: "JSON_ARRAY",
6200            params: PARAMS_JSON_ARRAY,
6201            return_type: None,
6202            category: FunctionCategory::Scalar,
6203        }),
6204        "json_array_agg" => Some(FunctionSignature {
6205            name: "json_array_agg",
6206            display_name: "JSON_ARRAY_AGG",
6207            params: PARAMS_JSON_ARRAY_AGG,
6208            return_type: None,
6209            category: FunctionCategory::Scalar,
6210        }),
6211        "json_bool" => Some(FunctionSignature {
6212            name: "json_bool",
6213            display_name: "JSON_BOOL",
6214            params: PARAMS_JSON_BOOL,
6215            return_type: None,
6216            category: FunctionCategory::Scalar,
6217        }),
6218        "jsonb_contains_all_top_keys" => Some(FunctionSignature {
6219            name: "jsonb_contains_all_top_keys",
6220            display_name: "JSONB_CONTAINS_ALL_TOP_KEYS",
6221            params: PARAMS_JSONB_CONTAINS_ALL_TOP_KEYS,
6222            return_type: None,
6223            category: FunctionCategory::Scalar,
6224        }),
6225        "jsonb_contains_any_top_keys" => Some(FunctionSignature {
6226            name: "jsonb_contains_any_top_keys",
6227            display_name: "JSONB_CONTAINS_ANY_TOP_KEYS",
6228            params: PARAMS_JSONB_CONTAINS_ANY_TOP_KEYS,
6229            return_type: None,
6230            category: FunctionCategory::Scalar,
6231        }),
6232        "jsonb_delete_at_path" => Some(FunctionSignature {
6233            name: "jsonb_delete_at_path",
6234            display_name: "JSONB_DELETE_AT_PATH",
6235            params: PARAMS_JSONB_DELETE_AT_PATH,
6236            return_type: None,
6237            category: FunctionCategory::Scalar,
6238        }),
6239        "jsonb_object_agg" => Some(FunctionSignature {
6240            name: "jsonb_object_agg",
6241            display_name: "JSONB_OBJECT_AGG",
6242            params: PARAMS_JSONB_OBJECT_AGG,
6243            return_type: None,
6244            category: FunctionCategory::Aggregate,
6245        }),
6246        "json_cast" => Some(FunctionSignature {
6247            name: "json_cast",
6248            display_name: "JSON_CAST",
6249            params: PARAMS_JSON_CAST,
6250            return_type: None,
6251            category: FunctionCategory::Scalar,
6252        }),
6253        "json_exists" => Some(FunctionSignature {
6254            name: "json_exists",
6255            display_name: "JSON_EXISTS",
6256            params: PARAMS_JSON_EXISTS,
6257            return_type: None,
6258            category: FunctionCategory::Scalar,
6259        }),
6260        "json_keys_at_depth" => Some(FunctionSignature {
6261            name: "json_keys_at_depth",
6262            display_name: "JSON_KEYS_AT_DEPTH",
6263            params: PARAMS_JSON_KEYS_AT_DEPTH,
6264            return_type: None,
6265            category: FunctionCategory::Scalar,
6266        }),
6267        "json_object" => Some(FunctionSignature {
6268            name: "json_object",
6269            display_name: "JSON_OBJECT",
6270            params: PARAMS_JSON_OBJECT,
6271            return_type: None,
6272            category: FunctionCategory::Scalar,
6273        }),
6274        "json_object_agg" => Some(FunctionSignature {
6275            name: "json_object_agg",
6276            display_name: "JSON_OBJECT_AGG",
6277            params: PARAMS_JSON_OBJECT_AGG,
6278            return_type: None,
6279            category: FunctionCategory::Aggregate,
6280        }),
6281        "json_table" => Some(FunctionSignature {
6282            name: "json_table",
6283            display_name: "JSON_TABLE",
6284            params: PARAMS_JSON_TABLE,
6285            return_type: None,
6286            category: FunctionCategory::Scalar,
6287        }),
6288        "json_value_array" => Some(FunctionSignature {
6289            name: "json_value_array",
6290            display_name: "JSON_VALUE_ARRAY",
6291            params: PARAMS_JSON_VALUE_ARRAY,
6292            return_type: None,
6293            category: FunctionCategory::Scalar,
6294        }),
6295        "lag" => Some(FunctionSignature {
6296            name: "lag",
6297            display_name: "LAG",
6298            params: PARAMS_LAG,
6299            return_type: Some(ReturnTypeRule::MatchFirstArg),
6300            category: FunctionCategory::Window,
6301        }),
6302        "last" => Some(FunctionSignature {
6303            name: "last",
6304            display_name: "LAST",
6305            params: PARAMS_LAST,
6306            return_type: None,
6307            category: FunctionCategory::Aggregate,
6308        }),
6309        "last_day" => Some(FunctionSignature {
6310            name: "last_day",
6311            display_name: "LAST_DAY",
6312            params: PARAMS_LAST_DAY,
6313            return_type: None,
6314            category: FunctionCategory::Scalar,
6315        }),
6316        "last_value" => Some(FunctionSignature {
6317            name: "last_value",
6318            display_name: "LAST_VALUE",
6319            params: PARAMS_LAST_VALUE,
6320            return_type: Some(ReturnTypeRule::MatchFirstArg),
6321            category: FunctionCategory::Window,
6322        }),
6323        "lax_bool" => Some(FunctionSignature {
6324            name: "lax_bool",
6325            display_name: "LAX_BOOL",
6326            params: PARAMS_LAX_BOOL,
6327            return_type: None,
6328            category: FunctionCategory::Scalar,
6329        }),
6330        "lax_float64" => Some(FunctionSignature {
6331            name: "lax_float64",
6332            display_name: "LAX_FLOAT64",
6333            params: PARAMS_LAX_FLOAT64,
6334            return_type: None,
6335            category: FunctionCategory::Scalar,
6336        }),
6337        "lax_int64" => Some(FunctionSignature {
6338            name: "lax_int64",
6339            display_name: "LAX_INT64",
6340            params: PARAMS_LAX_INT64,
6341            return_type: None,
6342            category: FunctionCategory::Scalar,
6343        }),
6344        "lax_string" => Some(FunctionSignature {
6345            name: "lax_string",
6346            display_name: "LAX_STRING",
6347            params: PARAMS_LAX_STRING,
6348            return_type: None,
6349            category: FunctionCategory::Scalar,
6350        }),
6351        "lower" => Some(FunctionSignature {
6352            name: "lower",
6353            display_name: "LOWER",
6354            params: PARAMS_LOWER,
6355            return_type: Some(ReturnTypeRule::Text),
6356            category: FunctionCategory::Scalar,
6357        }),
6358        "lead" => Some(FunctionSignature {
6359            name: "lead",
6360            display_name: "LEAD",
6361            params: PARAMS_LEAD,
6362            return_type: Some(ReturnTypeRule::MatchFirstArg),
6363            category: FunctionCategory::Window,
6364        }),
6365        "least" => Some(FunctionSignature {
6366            name: "least",
6367            display_name: "LEAST",
6368            params: PARAMS_LEAST,
6369            return_type: None,
6370            category: FunctionCategory::Scalar,
6371        }),
6372        "least_ignore_nulls" => Some(FunctionSignature {
6373            name: "least_ignore_nulls",
6374            display_name: "LEAST_IGNORE_NULLS",
6375            params: PARAMS_LEAST_IGNORE_NULLS,
6376            return_type: None,
6377            category: FunctionCategory::Scalar,
6378        }),
6379        "left" => Some(FunctionSignature {
6380            name: "left",
6381            display_name: "LEFT",
6382            params: PARAMS_LEFT,
6383            return_type: None,
6384            category: FunctionCategory::Scalar,
6385        }),
6386        "levenshtein" => Some(FunctionSignature {
6387            name: "levenshtein",
6388            display_name: "LEVENSHTEIN",
6389            params: PARAMS_LEVENSHTEIN,
6390            return_type: None,
6391            category: FunctionCategory::Scalar,
6392        }),
6393        "list" => Some(FunctionSignature {
6394            name: "list",
6395            display_name: "LIST",
6396            params: PARAMS_LIST,
6397            return_type: None,
6398            category: FunctionCategory::Scalar,
6399        }),
6400        "ln" => Some(FunctionSignature {
6401            name: "ln",
6402            display_name: "LN",
6403            params: PARAMS_LN,
6404            return_type: None,
6405            category: FunctionCategory::Scalar,
6406        }),
6407        "log" => Some(FunctionSignature {
6408            name: "log",
6409            display_name: "LOG",
6410            params: PARAMS_LOG,
6411            return_type: None,
6412            category: FunctionCategory::Scalar,
6413        }),
6414        "lower_hex" => Some(FunctionSignature {
6415            name: "lower_hex",
6416            display_name: "LOWER_HEX",
6417            params: PARAMS_LOWER_HEX,
6418            return_type: None,
6419            category: FunctionCategory::Scalar,
6420        }),
6421        "make_interval" => Some(FunctionSignature {
6422            name: "make_interval",
6423            display_name: "MAKE_INTERVAL",
6424            params: PARAMS_MAKE_INTERVAL,
6425            return_type: None,
6426            category: FunctionCategory::Scalar,
6427        }),
6428        "map" => Some(FunctionSignature {
6429            name: "map",
6430            display_name: "MAP",
6431            params: PARAMS_MAP,
6432            return_type: None,
6433            category: FunctionCategory::Scalar,
6434        }),
6435        "map_from_entries" => Some(FunctionSignature {
6436            name: "map_from_entries",
6437            display_name: "MAP_FROM_ENTRIES",
6438            params: PARAMS_MAP_FROM_ENTRIES,
6439            return_type: None,
6440            category: FunctionCategory::Scalar,
6441        }),
6442        "match_against" => Some(FunctionSignature {
6443            name: "match_against",
6444            display_name: "MATCH_AGAINST",
6445            params: PARAMS_MATCH_AGAINST,
6446            return_type: None,
6447            category: FunctionCategory::Scalar,
6448        }),
6449        "max" => Some(FunctionSignature {
6450            name: "max",
6451            display_name: "MAX",
6452            params: PARAMS_MAX,
6453            return_type: Some(ReturnTypeRule::MatchFirstArg),
6454            category: FunctionCategory::Aggregate,
6455        }),
6456        "md5" => Some(FunctionSignature {
6457            name: "md5",
6458            display_name: "MD5",
6459            params: PARAMS_MD5,
6460            return_type: None,
6461            category: FunctionCategory::Scalar,
6462        }),
6463        "md5digest" => Some(FunctionSignature {
6464            name: "md5digest",
6465            display_name: "MD5DIGEST",
6466            params: PARAMS_MD5DIGEST,
6467            return_type: None,
6468            category: FunctionCategory::Scalar,
6469        }),
6470        "median" => Some(FunctionSignature {
6471            name: "median",
6472            display_name: "MEDIAN",
6473            params: PARAMS_MEDIAN,
6474            return_type: None,
6475            category: FunctionCategory::Aggregate,
6476        }),
6477        "min" => Some(FunctionSignature {
6478            name: "min",
6479            display_name: "MIN",
6480            params: PARAMS_MIN,
6481            return_type: Some(ReturnTypeRule::MatchFirstArg),
6482            category: FunctionCategory::Aggregate,
6483        }),
6484        "minhash" => Some(FunctionSignature {
6485            name: "minhash",
6486            display_name: "MINHASH",
6487            params: PARAMS_MINHASH,
6488            return_type: None,
6489            category: FunctionCategory::Aggregate,
6490        }),
6491        "minhash_combine" => Some(FunctionSignature {
6492            name: "minhash_combine",
6493            display_name: "MINHASH_COMBINE",
6494            params: PARAMS_MINHASH_COMBINE,
6495            return_type: None,
6496            category: FunctionCategory::Aggregate,
6497        }),
6498        "minute" => Some(FunctionSignature {
6499            name: "minute",
6500            display_name: "MINUTE",
6501            params: PARAMS_MINUTE,
6502            return_type: None,
6503            category: FunctionCategory::Scalar,
6504        }),
6505        "month" => Some(FunctionSignature {
6506            name: "month",
6507            display_name: "MONTH",
6508            params: PARAMS_MONTH,
6509            return_type: None,
6510            category: FunctionCategory::Scalar,
6511        }),
6512        "monthname" => Some(FunctionSignature {
6513            name: "monthname",
6514            display_name: "MONTHNAME",
6515            params: PARAMS_MONTHNAME,
6516            return_type: None,
6517            category: FunctionCategory::Scalar,
6518        }),
6519        "months_between" => Some(FunctionSignature {
6520            name: "months_between",
6521            display_name: "MONTHS_BETWEEN",
6522            params: PARAMS_MONTHS_BETWEEN,
6523            return_type: None,
6524            category: FunctionCategory::Scalar,
6525        }),
6526        "md5number_lower64" => Some(FunctionSignature {
6527            name: "md5number_lower64",
6528            display_name: "MD5NUMBER_LOWER64",
6529            params: PARAMS_MD5NUMBER_LOWER64,
6530            return_type: None,
6531            category: FunctionCategory::Scalar,
6532        }),
6533        "md5number_upper64" => Some(FunctionSignature {
6534            name: "md5number_upper64",
6535            display_name: "MD5NUMBER_UPPER64",
6536            params: PARAMS_MD5NUMBER_UPPER64,
6537            return_type: None,
6538            category: FunctionCategory::Scalar,
6539        }),
6540        "ml_forecast" => Some(FunctionSignature {
6541            name: "ml_forecast",
6542            display_name: "ML_FORECAST",
6543            params: PARAMS_ML_FORECAST,
6544            return_type: None,
6545            category: FunctionCategory::Scalar,
6546        }),
6547        "ml_translate" => Some(FunctionSignature {
6548            name: "ml_translate",
6549            display_name: "ML_TRANSLATE",
6550            params: PARAMS_ML_TRANSLATE,
6551            return_type: None,
6552            category: FunctionCategory::Scalar,
6553        }),
6554        "next_day" => Some(FunctionSignature {
6555            name: "next_day",
6556            display_name: "NEXT_DAY",
6557            params: PARAMS_NEXT_DAY,
6558            return_type: None,
6559            category: FunctionCategory::Scalar,
6560        }),
6561        "next_value_for" => Some(FunctionSignature {
6562            name: "next_value_for",
6563            display_name: "NEXT_VALUE_FOR",
6564            params: PARAMS_NEXT_VALUE_FOR,
6565            return_type: None,
6566            category: FunctionCategory::Scalar,
6567        }),
6568        "normalize" => Some(FunctionSignature {
6569            name: "normalize",
6570            display_name: "NORMALIZE",
6571            params: PARAMS_NORMALIZE,
6572            return_type: None,
6573            category: FunctionCategory::Scalar,
6574        }),
6575        "now" => Some(FunctionSignature {
6576            name: "now",
6577            display_name: "NOW",
6578            params: &[],
6579            return_type: Some(ReturnTypeRule::Timestamp),
6580            category: FunctionCategory::Scalar,
6581        }),
6582        "nth_value" => Some(FunctionSignature {
6583            name: "nth_value",
6584            display_name: "NTH_VALUE",
6585            params: PARAMS_NTH_VALUE,
6586            return_type: None,
6587            category: FunctionCategory::Window,
6588        }),
6589        "ntile" => Some(FunctionSignature {
6590            name: "ntile",
6591            display_name: "NTILE",
6592            params: PARAMS_NTILE,
6593            return_type: Some(ReturnTypeRule::Integer),
6594            category: FunctionCategory::Window,
6595        }),
6596        "nullif" => Some(FunctionSignature {
6597            name: "nullif",
6598            display_name: "NULLIF",
6599            params: PARAMS_NULLIF,
6600            return_type: None,
6601            category: FunctionCategory::Scalar,
6602        }),
6603        "number_to_str" => Some(FunctionSignature {
6604            name: "number_to_str",
6605            display_name: "NUMBER_TO_STR",
6606            params: PARAMS_NUMBER_TO_STR,
6607            return_type: None,
6608            category: FunctionCategory::Scalar,
6609        }),
6610        "nvl2" => Some(FunctionSignature {
6611            name: "nvl2",
6612            display_name: "NVL2",
6613            params: PARAMS_NVL2,
6614            return_type: None,
6615            category: FunctionCategory::Scalar,
6616        }),
6617        "object_agg" => Some(FunctionSignature {
6618            name: "object_agg",
6619            display_name: "OBJECT_AGG",
6620            params: PARAMS_OBJECT_AGG,
6621            return_type: None,
6622            category: FunctionCategory::Aggregate,
6623        }),
6624        "object_insert" => Some(FunctionSignature {
6625            name: "object_insert",
6626            display_name: "OBJECT_INSERT",
6627            params: PARAMS_OBJECT_INSERT,
6628            return_type: None,
6629            category: FunctionCategory::Scalar,
6630        }),
6631        "open_json" => Some(FunctionSignature {
6632            name: "open_json",
6633            display_name: "OPEN_JSON",
6634            params: PARAMS_OPEN_JSON,
6635            return_type: None,
6636            category: FunctionCategory::Scalar,
6637        }),
6638        "or" => Some(FunctionSignature {
6639            name: "or",
6640            display_name: "OR",
6641            params: PARAMS_OR,
6642            return_type: Some(ReturnTypeRule::Boolean),
6643            category: FunctionCategory::Scalar,
6644        }),
6645        "overlay" => Some(FunctionSignature {
6646            name: "overlay",
6647            display_name: "OVERLAY",
6648            params: PARAMS_OVERLAY,
6649            return_type: None,
6650            category: FunctionCategory::Scalar,
6651        }),
6652        "pad" => Some(FunctionSignature {
6653            name: "pad",
6654            display_name: "PAD",
6655            params: PARAMS_PAD,
6656            return_type: None,
6657            category: FunctionCategory::Scalar,
6658        }),
6659        "parameterized_agg" => Some(FunctionSignature {
6660            name: "parameterized_agg",
6661            display_name: "PARAMETERIZED_AGG",
6662            params: PARAMS_PARAMETERIZED_AGG,
6663            return_type: None,
6664            category: FunctionCategory::Aggregate,
6665        }),
6666        "parse_bignumeric" => Some(FunctionSignature {
6667            name: "parse_bignumeric",
6668            display_name: "PARSE_BIGNUMERIC",
6669            params: PARAMS_PARSE_BIGNUMERIC,
6670            return_type: None,
6671            category: FunctionCategory::Scalar,
6672        }),
6673        "parse_datetime" => Some(FunctionSignature {
6674            name: "parse_datetime",
6675            display_name: "PARSE_DATETIME",
6676            params: PARAMS_PARSE_DATETIME,
6677            return_type: None,
6678            category: FunctionCategory::Scalar,
6679        }),
6680        "parse_ip" => Some(FunctionSignature {
6681            name: "parse_ip",
6682            display_name: "PARSE_IP",
6683            params: PARAMS_PARSE_IP,
6684            return_type: None,
6685            category: FunctionCategory::Scalar,
6686        }),
6687        "parse_numeric" => Some(FunctionSignature {
6688            name: "parse_numeric",
6689            display_name: "PARSE_NUMERIC",
6690            params: PARAMS_PARSE_NUMERIC,
6691            return_type: None,
6692            category: FunctionCategory::Scalar,
6693        }),
6694        "parse_time" => Some(FunctionSignature {
6695            name: "parse_time",
6696            display_name: "PARSE_TIME",
6697            params: PARAMS_PARSE_TIME,
6698            return_type: None,
6699            category: FunctionCategory::Scalar,
6700        }),
6701        "parse_url" => Some(FunctionSignature {
6702            name: "parse_url",
6703            display_name: "PARSE_URL",
6704            params: PARAMS_PARSE_URL,
6705            return_type: None,
6706            category: FunctionCategory::Scalar,
6707        }),
6708        "percentile_cont" => Some(FunctionSignature {
6709            name: "percentile_cont",
6710            display_name: "PERCENTILE_CONT",
6711            params: PARAMS_PERCENTILE_CONT,
6712            return_type: None,
6713            category: FunctionCategory::Window,
6714        }),
6715        "percentile_disc" => Some(FunctionSignature {
6716            name: "percentile_disc",
6717            display_name: "PERCENTILE_DISC",
6718            params: PARAMS_PERCENTILE_DISC,
6719            return_type: None,
6720            category: FunctionCategory::Window,
6721        }),
6722        "percent_rank" => Some(FunctionSignature {
6723            name: "percent_rank",
6724            display_name: "PERCENT_RANK",
6725            params: PARAMS_PERCENT_RANK,
6726            return_type: None,
6727            category: FunctionCategory::Window,
6728        }),
6729        "pi" => Some(FunctionSignature {
6730            name: "pi",
6731            display_name: "PI",
6732            params: &[],
6733            return_type: None,
6734            category: FunctionCategory::Scalar,
6735        }),
6736        "posexplode" => Some(FunctionSignature {
6737            name: "posexplode",
6738            display_name: "POSEXPLODE",
6739            params: PARAMS_POSEXPLODE,
6740            return_type: None,
6741            category: FunctionCategory::Scalar,
6742        }),
6743        "posexplode_outer" => Some(FunctionSignature {
6744            name: "posexplode_outer",
6745            display_name: "POSEXPLODE_OUTER",
6746            params: PARAMS_POSEXPLODE_OUTER,
6747            return_type: None,
6748            category: FunctionCategory::Scalar,
6749        }),
6750        "pow" => Some(FunctionSignature {
6751            name: "pow",
6752            display_name: "POW",
6753            params: PARAMS_POW,
6754            return_type: None,
6755            category: FunctionCategory::Scalar,
6756        }),
6757        "predict" => Some(FunctionSignature {
6758            name: "predict",
6759            display_name: "PREDICT",
6760            params: PARAMS_PREDICT,
6761            return_type: None,
6762            category: FunctionCategory::Scalar,
6763        }),
6764        "previous_day" => Some(FunctionSignature {
6765            name: "previous_day",
6766            display_name: "PREVIOUS_DAY",
6767            params: PARAMS_PREVIOUS_DAY,
6768            return_type: None,
6769            category: FunctionCategory::Scalar,
6770        }),
6771        "quantile" => Some(FunctionSignature {
6772            name: "quantile",
6773            display_name: "QUANTILE",
6774            params: PARAMS_QUANTILE,
6775            return_type: None,
6776            category: FunctionCategory::Aggregate,
6777        }),
6778        "quarter" => Some(FunctionSignature {
6779            name: "quarter",
6780            display_name: "QUARTER",
6781            params: PARAMS_QUARTER,
6782            return_type: None,
6783            category: FunctionCategory::Scalar,
6784        }),
6785        "radians" => Some(FunctionSignature {
6786            name: "radians",
6787            display_name: "RADIANS",
6788            params: PARAMS_RADIANS,
6789            return_type: None,
6790            category: FunctionCategory::Scalar,
6791        }),
6792        "rand" => Some(FunctionSignature {
6793            name: "rand",
6794            display_name: "RAND",
6795            params: PARAMS_RAND,
6796            return_type: None,
6797            category: FunctionCategory::Scalar,
6798        }),
6799        "randn" => Some(FunctionSignature {
6800            name: "randn",
6801            display_name: "RANDN",
6802            params: PARAMS_RANDN,
6803            return_type: None,
6804            category: FunctionCategory::Scalar,
6805        }),
6806        "range_bucket" => Some(FunctionSignature {
6807            name: "range_bucket",
6808            display_name: "RANGE_BUCKET",
6809            params: PARAMS_RANGE_BUCKET,
6810            return_type: None,
6811            category: FunctionCategory::Scalar,
6812        }),
6813        "range_n" => Some(FunctionSignature {
6814            name: "range_n",
6815            display_name: "RANGE_N",
6816            params: PARAMS_RANGE_N,
6817            return_type: None,
6818            category: FunctionCategory::Scalar,
6819        }),
6820        "rank" => Some(FunctionSignature {
6821            name: "rank",
6822            display_name: "RANK",
6823            params: PARAMS_RANK,
6824            return_type: Some(ReturnTypeRule::Integer),
6825            category: FunctionCategory::Window,
6826        }),
6827        "read_csv" => Some(FunctionSignature {
6828            name: "read_csv",
6829            display_name: "READ_CSV",
6830            params: PARAMS_READ_CSV,
6831            return_type: None,
6832            category: FunctionCategory::Scalar,
6833        }),
6834        "read_parquet" => Some(FunctionSignature {
6835            name: "read_parquet",
6836            display_name: "READ_PARQUET",
6837            params: PARAMS_READ_PARQUET,
6838            return_type: None,
6839            category: FunctionCategory::Scalar,
6840        }),
6841        "reduce" => Some(FunctionSignature {
6842            name: "reduce",
6843            display_name: "REDUCE",
6844            params: PARAMS_REDUCE,
6845            return_type: None,
6846            category: FunctionCategory::Scalar,
6847        }),
6848        "regexp_count" => Some(FunctionSignature {
6849            name: "regexp_count",
6850            display_name: "REGEXP_COUNT",
6851            params: PARAMS_REGEXP_COUNT,
6852            return_type: None,
6853            category: FunctionCategory::Scalar,
6854        }),
6855        "regexp_extract" => Some(FunctionSignature {
6856            name: "regexp_extract",
6857            display_name: "REGEXP_EXTRACT",
6858            params: PARAMS_REGEXP_EXTRACT,
6859            return_type: None,
6860            category: FunctionCategory::Scalar,
6861        }),
6862        "regexp_extract_all" => Some(FunctionSignature {
6863            name: "regexp_extract_all",
6864            display_name: "REGEXP_EXTRACT_ALL",
6865            params: PARAMS_REGEXP_EXTRACT_ALL,
6866            return_type: None,
6867            category: FunctionCategory::Scalar,
6868        }),
6869        "regexp_full_match" => Some(FunctionSignature {
6870            name: "regexp_full_match",
6871            display_name: "REGEXP_FULL_MATCH",
6872            params: PARAMS_REGEXP_FULL_MATCH,
6873            return_type: None,
6874            category: FunctionCategory::Scalar,
6875        }),
6876        "regexp_instr" => Some(FunctionSignature {
6877            name: "regexp_instr",
6878            display_name: "REGEXP_INSTR",
6879            params: PARAMS_REGEXP_INSTR,
6880            return_type: None,
6881            category: FunctionCategory::Scalar,
6882        }),
6883        "regexp_i_like" => Some(FunctionSignature {
6884            name: "regexp_i_like",
6885            display_name: "REGEXP_I_LIKE",
6886            params: PARAMS_REGEXP_I_LIKE,
6887            return_type: None,
6888            category: FunctionCategory::Scalar,
6889        }),
6890        "regexp_like" => Some(FunctionSignature {
6891            name: "regexp_like",
6892            display_name: "REGEXP_LIKE",
6893            params: PARAMS_REGEXP_LIKE,
6894            return_type: None,
6895            category: FunctionCategory::Scalar,
6896        }),
6897        "regexp_replace" => Some(FunctionSignature {
6898            name: "regexp_replace",
6899            display_name: "REGEXP_REPLACE",
6900            params: PARAMS_REGEXP_REPLACE,
6901            return_type: None,
6902            category: FunctionCategory::Scalar,
6903        }),
6904        "regexp_split" => Some(FunctionSignature {
6905            name: "regexp_split",
6906            display_name: "REGEXP_SPLIT",
6907            params: PARAMS_REGEXP_SPLIT,
6908            return_type: None,
6909            category: FunctionCategory::Scalar,
6910        }),
6911        "regr_avgx" => Some(FunctionSignature {
6912            name: "regr_avgx",
6913            display_name: "REGR_AVGX",
6914            params: PARAMS_REGR_AVGX,
6915            return_type: None,
6916            category: FunctionCategory::Scalar,
6917        }),
6918        "regr_avgy" => Some(FunctionSignature {
6919            name: "regr_avgy",
6920            display_name: "REGR_AVGY",
6921            params: PARAMS_REGR_AVGY,
6922            return_type: None,
6923            category: FunctionCategory::Scalar,
6924        }),
6925        "regr_valx" => Some(FunctionSignature {
6926            name: "regr_valx",
6927            display_name: "REGR_VALX",
6928            params: PARAMS_REGR_VALX,
6929            return_type: None,
6930            category: FunctionCategory::Scalar,
6931        }),
6932        "regr_valy" => Some(FunctionSignature {
6933            name: "regr_valy",
6934            display_name: "REGR_VALY",
6935            params: PARAMS_REGR_VALY,
6936            return_type: None,
6937            category: FunctionCategory::Scalar,
6938        }),
6939        "repeat" => Some(FunctionSignature {
6940            name: "repeat",
6941            display_name: "REPEAT",
6942            params: PARAMS_REPEAT,
6943            return_type: None,
6944            category: FunctionCategory::Scalar,
6945        }),
6946        "replace" => Some(FunctionSignature {
6947            name: "replace",
6948            display_name: "REPLACE",
6949            params: PARAMS_REPLACE,
6950            return_type: Some(ReturnTypeRule::Text),
6951            category: FunctionCategory::Scalar,
6952        }),
6953        "reverse" => Some(FunctionSignature {
6954            name: "reverse",
6955            display_name: "REVERSE",
6956            params: PARAMS_REVERSE,
6957            return_type: None,
6958            category: FunctionCategory::Scalar,
6959        }),
6960        "right" => Some(FunctionSignature {
6961            name: "right",
6962            display_name: "RIGHT",
6963            params: PARAMS_RIGHT,
6964            return_type: None,
6965            category: FunctionCategory::Scalar,
6966        }),
6967        "round" => Some(FunctionSignature {
6968            name: "round",
6969            display_name: "ROUND",
6970            params: PARAMS_ROUND,
6971            return_type: None,
6972            category: FunctionCategory::Scalar,
6973        }),
6974        "row_number" => Some(FunctionSignature {
6975            name: "row_number",
6976            display_name: "ROW_NUMBER",
6977            params: PARAMS_ROW_NUMBER,
6978            return_type: Some(ReturnTypeRule::Integer),
6979            category: FunctionCategory::Window,
6980        }),
6981        "rtrimmed_length" => Some(FunctionSignature {
6982            name: "rtrimmed_length",
6983            display_name: "RTRIMMED_LENGTH",
6984            params: PARAMS_RTRIMMED_LENGTH,
6985            return_type: None,
6986            category: FunctionCategory::Scalar,
6987        }),
6988        "safe_add" => Some(FunctionSignature {
6989            name: "safe_add",
6990            display_name: "SAFE_ADD",
6991            params: PARAMS_SAFE_ADD,
6992            return_type: None,
6993            category: FunctionCategory::Scalar,
6994        }),
6995        "safe_convert_bytes_to_string" => Some(FunctionSignature {
6996            name: "safe_convert_bytes_to_string",
6997            display_name: "SAFE_CONVERT_BYTES_TO_STRING",
6998            params: PARAMS_SAFE_CONVERT_BYTES_TO_STRING,
6999            return_type: None,
7000            category: FunctionCategory::Scalar,
7001        }),
7002        "safe_divide" => Some(FunctionSignature {
7003            name: "safe_divide",
7004            display_name: "SAFE_DIVIDE",
7005            params: PARAMS_SAFE_DIVIDE,
7006            return_type: None,
7007            category: FunctionCategory::Scalar,
7008        }),
7009        "safe_multiply" => Some(FunctionSignature {
7010            name: "safe_multiply",
7011            display_name: "SAFE_MULTIPLY",
7012            params: PARAMS_SAFE_MULTIPLY,
7013            return_type: None,
7014            category: FunctionCategory::Scalar,
7015        }),
7016        "safe_negate" => Some(FunctionSignature {
7017            name: "safe_negate",
7018            display_name: "SAFE_NEGATE",
7019            params: PARAMS_SAFE_NEGATE,
7020            return_type: None,
7021            category: FunctionCategory::Scalar,
7022        }),
7023        "safe_subtract" => Some(FunctionSignature {
7024            name: "safe_subtract",
7025            display_name: "SAFE_SUBTRACT",
7026            params: PARAMS_SAFE_SUBTRACT,
7027            return_type: None,
7028            category: FunctionCategory::Scalar,
7029        }),
7030        "search" => Some(FunctionSignature {
7031            name: "search",
7032            display_name: "SEARCH",
7033            params: PARAMS_SEARCH,
7034            return_type: None,
7035            category: FunctionCategory::Scalar,
7036        }),
7037        "sec" => Some(FunctionSignature {
7038            name: "sec",
7039            display_name: "SEC",
7040            params: PARAMS_SEC,
7041            return_type: None,
7042            category: FunctionCategory::Scalar,
7043        }),
7044        "sech" => Some(FunctionSignature {
7045            name: "sech",
7046            display_name: "SECH",
7047            params: PARAMS_SECH,
7048            return_type: None,
7049            category: FunctionCategory::Scalar,
7050        }),
7051        "second" => Some(FunctionSignature {
7052            name: "second",
7053            display_name: "SECOND",
7054            params: PARAMS_SECOND,
7055            return_type: None,
7056            category: FunctionCategory::Scalar,
7057        }),
7058        "sha" => Some(FunctionSignature {
7059            name: "sha",
7060            display_name: "SHA",
7061            params: PARAMS_SHA,
7062            return_type: None,
7063            category: FunctionCategory::Scalar,
7064        }),
7065        "sha2" => Some(FunctionSignature {
7066            name: "sha2",
7067            display_name: "SHA2",
7068            params: PARAMS_SHA2,
7069            return_type: None,
7070            category: FunctionCategory::Scalar,
7071        }),
7072        "sign" => Some(FunctionSignature {
7073            name: "sign",
7074            display_name: "SIGN",
7075            params: PARAMS_SIGN,
7076            return_type: None,
7077            category: FunctionCategory::Scalar,
7078        }),
7079        "sin" => Some(FunctionSignature {
7080            name: "sin",
7081            display_name: "SIN",
7082            params: PARAMS_SIN,
7083            return_type: None,
7084            category: FunctionCategory::Scalar,
7085        }),
7086        "sinh" => Some(FunctionSignature {
7087            name: "sinh",
7088            display_name: "SINH",
7089            params: PARAMS_SINH,
7090            return_type: None,
7091            category: FunctionCategory::Scalar,
7092        }),
7093        "skewness" => Some(FunctionSignature {
7094            name: "skewness",
7095            display_name: "SKEWNESS",
7096            params: PARAMS_SKEWNESS,
7097            return_type: None,
7098            category: FunctionCategory::Aggregate,
7099        }),
7100        "sort_array" => Some(FunctionSignature {
7101            name: "sort_array",
7102            display_name: "SORT_ARRAY",
7103            params: PARAMS_SORT_ARRAY,
7104            return_type: None,
7105            category: FunctionCategory::Scalar,
7106        }),
7107        "soundex" => Some(FunctionSignature {
7108            name: "soundex",
7109            display_name: "SOUNDEX",
7110            params: PARAMS_SOUNDEX,
7111            return_type: None,
7112            category: FunctionCategory::Scalar,
7113        }),
7114        "soundex_p123" => Some(FunctionSignature {
7115            name: "soundex_p123",
7116            display_name: "SOUNDEX_P123",
7117            params: PARAMS_SOUNDEX_P123,
7118            return_type: None,
7119            category: FunctionCategory::Scalar,
7120        }),
7121        "space" => Some(FunctionSignature {
7122            name: "space",
7123            display_name: "SPACE",
7124            params: PARAMS_SPACE,
7125            return_type: None,
7126            category: FunctionCategory::Scalar,
7127        }),
7128        "split" => Some(FunctionSignature {
7129            name: "split",
7130            display_name: "SPLIT",
7131            params: PARAMS_SPLIT,
7132            return_type: None,
7133            category: FunctionCategory::Scalar,
7134        }),
7135        "string_to_array" => Some(FunctionSignature {
7136            name: "string_to_array",
7137            display_name: "STRING_TO_ARRAY",
7138            params: PARAMS_STRING_TO_ARRAY,
7139            return_type: None,
7140            category: FunctionCategory::Scalar,
7141        }),
7142        "split_part" => Some(FunctionSignature {
7143            name: "split_part",
7144            display_name: "SPLIT_PART",
7145            params: PARAMS_SPLIT_PART,
7146            return_type: None,
7147            category: FunctionCategory::Scalar,
7148        }),
7149        "sqrt" => Some(FunctionSignature {
7150            name: "sqrt",
7151            display_name: "SQRT",
7152            params: PARAMS_SQRT,
7153            return_type: None,
7154            category: FunctionCategory::Scalar,
7155        }),
7156        "standard_hash" => Some(FunctionSignature {
7157            name: "standard_hash",
7158            display_name: "STANDARD_HASH",
7159            params: PARAMS_STANDARD_HASH,
7160            return_type: None,
7161            category: FunctionCategory::Scalar,
7162        }),
7163        "starts_with" => Some(FunctionSignature {
7164            name: "starts_with",
7165            display_name: "STARTS_WITH",
7166            params: PARAMS_STARTS_WITH,
7167            return_type: None,
7168            category: FunctionCategory::Scalar,
7169        }),
7170        "star_map" => Some(FunctionSignature {
7171            name: "star_map",
7172            display_name: "STAR_MAP",
7173            params: PARAMS_STAR_MAP,
7174            return_type: None,
7175            category: FunctionCategory::Scalar,
7176        }),
7177        "stddev" => Some(FunctionSignature {
7178            name: "stddev",
7179            display_name: "STDDEV",
7180            params: PARAMS_STDDEV,
7181            return_type: None,
7182            category: FunctionCategory::Aggregate,
7183        }),
7184        "stddev_pop" => Some(FunctionSignature {
7185            name: "stddev_pop",
7186            display_name: "STDDEV_POP",
7187            params: PARAMS_STDDEV_POP,
7188            return_type: None,
7189            category: FunctionCategory::Aggregate,
7190        }),
7191        "stddev_samp" => Some(FunctionSignature {
7192            name: "stddev_samp",
7193            display_name: "STDDEV_SAMP",
7194            params: PARAMS_STDDEV_SAMP,
7195            return_type: None,
7196            category: FunctionCategory::Aggregate,
7197        }),
7198        "string" => Some(FunctionSignature {
7199            name: "string",
7200            display_name: "STRING",
7201            params: PARAMS_STRING,
7202            return_type: None,
7203            category: FunctionCategory::Scalar,
7204        }),
7205        "struct" => Some(FunctionSignature {
7206            name: "struct",
7207            display_name: "STRUCT",
7208            params: PARAMS_STRUCT,
7209            return_type: None,
7210            category: FunctionCategory::Scalar,
7211        }),
7212        "struct_extract" => Some(FunctionSignature {
7213            name: "struct_extract",
7214            display_name: "STRUCT_EXTRACT",
7215            params: PARAMS_STRUCT_EXTRACT,
7216            return_type: None,
7217            category: FunctionCategory::Scalar,
7218        }),
7219        "str_position" => Some(FunctionSignature {
7220            name: "str_position",
7221            display_name: "STR_POSITION",
7222            params: PARAMS_STR_POSITION,
7223            return_type: None,
7224            category: FunctionCategory::Scalar,
7225        }),
7226        "str_to_date" => Some(FunctionSignature {
7227            name: "str_to_date",
7228            display_name: "STR_TO_DATE",
7229            params: PARAMS_STR_TO_DATE,
7230            return_type: None,
7231            category: FunctionCategory::Scalar,
7232        }),
7233        "str_to_map" => Some(FunctionSignature {
7234            name: "str_to_map",
7235            display_name: "STR_TO_MAP",
7236            params: PARAMS_STR_TO_MAP,
7237            return_type: None,
7238            category: FunctionCategory::Scalar,
7239        }),
7240        "str_to_time" => Some(FunctionSignature {
7241            name: "str_to_time",
7242            display_name: "STR_TO_TIME",
7243            params: PARAMS_STR_TO_TIME,
7244            return_type: None,
7245            category: FunctionCategory::Scalar,
7246        }),
7247        "str_to_unix" => Some(FunctionSignature {
7248            name: "str_to_unix",
7249            display_name: "STR_TO_UNIX",
7250            params: PARAMS_STR_TO_UNIX,
7251            return_type: None,
7252            category: FunctionCategory::Scalar,
7253        }),
7254        "st_distance" => Some(FunctionSignature {
7255            name: "st_distance",
7256            display_name: "ST_DISTANCE",
7257            params: PARAMS_ST_DISTANCE,
7258            return_type: None,
7259            category: FunctionCategory::Scalar,
7260        }),
7261        "st_point" => Some(FunctionSignature {
7262            name: "st_point",
7263            display_name: "ST_POINT",
7264            params: PARAMS_ST_POINT,
7265            return_type: None,
7266            category: FunctionCategory::Scalar,
7267        }),
7268        "substring" => Some(FunctionSignature {
7269            name: "substring",
7270            display_name: "SUBSTRING",
7271            params: PARAMS_SUBSTRING,
7272            return_type: Some(ReturnTypeRule::Text),
7273            category: FunctionCategory::Scalar,
7274        }),
7275        "substring_index" => Some(FunctionSignature {
7276            name: "substring_index",
7277            display_name: "SUBSTRING_INDEX",
7278            params: PARAMS_SUBSTRING_INDEX,
7279            return_type: None,
7280            category: FunctionCategory::Scalar,
7281        }),
7282        "sum" => Some(FunctionSignature {
7283            name: "sum",
7284            display_name: "SUM",
7285            params: PARAMS_SUM,
7286            return_type: Some(ReturnTypeRule::Numeric),
7287            category: FunctionCategory::Aggregate,
7288        }),
7289        "sha1digest" => Some(FunctionSignature {
7290            name: "sha1digest",
7291            display_name: "SHA1DIGEST",
7292            params: PARAMS_SHA1DIGEST,
7293            return_type: None,
7294            category: FunctionCategory::Scalar,
7295        }),
7296        "sha2digest" => Some(FunctionSignature {
7297            name: "sha2digest",
7298            display_name: "SHA2DIGEST",
7299            params: PARAMS_SHA2DIGEST,
7300            return_type: None,
7301            category: FunctionCategory::Scalar,
7302        }),
7303        "tan" => Some(FunctionSignature {
7304            name: "tan",
7305            display_name: "TAN",
7306            params: PARAMS_TAN,
7307            return_type: None,
7308            category: FunctionCategory::Scalar,
7309        }),
7310        "tanh" => Some(FunctionSignature {
7311            name: "tanh",
7312            display_name: "TANH",
7313            params: PARAMS_TANH,
7314            return_type: None,
7315            category: FunctionCategory::Scalar,
7316        }),
7317        "time" => Some(FunctionSignature {
7318            name: "time",
7319            display_name: "TIME",
7320            params: PARAMS_TIME,
7321            return_type: None,
7322            category: FunctionCategory::Scalar,
7323        }),
7324        "time_from_parts" => Some(FunctionSignature {
7325            name: "time_from_parts",
7326            display_name: "TIME_FROM_PARTS",
7327            params: PARAMS_TIME_FROM_PARTS,
7328            return_type: None,
7329            category: FunctionCategory::Scalar,
7330        }),
7331        "timestamp" => Some(FunctionSignature {
7332            name: "timestamp",
7333            display_name: "TIMESTAMP",
7334            params: PARAMS_TIMESTAMP,
7335            return_type: None,
7336            category: FunctionCategory::Scalar,
7337        }),
7338        "timestamp_diff" => Some(FunctionSignature {
7339            name: "timestamp_diff",
7340            display_name: "TIMESTAMP_DIFF",
7341            params: PARAMS_TIMESTAMP_DIFF,
7342            return_type: None,
7343            category: FunctionCategory::Scalar,
7344        }),
7345        "timestamp_from_parts" => Some(FunctionSignature {
7346            name: "timestamp_from_parts",
7347            display_name: "TIMESTAMP_FROM_PARTS",
7348            params: PARAMS_TIMESTAMP_FROM_PARTS,
7349            return_type: None,
7350            category: FunctionCategory::Scalar,
7351        }),
7352        "timestamp_ltz_from_parts" => Some(FunctionSignature {
7353            name: "timestamp_ltz_from_parts",
7354            display_name: "TIMESTAMP_LTZ_FROM_PARTS",
7355            params: PARAMS_TIMESTAMP_LTZ_FROM_PARTS,
7356            return_type: None,
7357            category: FunctionCategory::Scalar,
7358        }),
7359        "timestamp_tz_from_parts" => Some(FunctionSignature {
7360            name: "timestamp_tz_from_parts",
7361            display_name: "TIMESTAMP_TZ_FROM_PARTS",
7362            params: PARAMS_TIMESTAMP_TZ_FROM_PARTS,
7363            return_type: None,
7364            category: FunctionCategory::Scalar,
7365        }),
7366        "timestamp_add" => Some(FunctionSignature {
7367            name: "timestamp_add",
7368            display_name: "TIMESTAMP_ADD",
7369            params: PARAMS_TIMESTAMP_ADD,
7370            return_type: None,
7371            category: FunctionCategory::Scalar,
7372        }),
7373        "timestamp_sub" => Some(FunctionSignature {
7374            name: "timestamp_sub",
7375            display_name: "TIMESTAMP_SUB",
7376            params: PARAMS_TIMESTAMP_SUB,
7377            return_type: None,
7378            category: FunctionCategory::Scalar,
7379        }),
7380        "timestamp_trunc" => Some(FunctionSignature {
7381            name: "timestamp_trunc",
7382            display_name: "TIMESTAMP_TRUNC",
7383            params: PARAMS_TIMESTAMP_TRUNC,
7384            return_type: None,
7385            category: FunctionCategory::Scalar,
7386        }),
7387        "time_add" => Some(FunctionSignature {
7388            name: "time_add",
7389            display_name: "TIME_ADD",
7390            params: PARAMS_TIME_ADD,
7391            return_type: None,
7392            category: FunctionCategory::Scalar,
7393        }),
7394        "time_diff" => Some(FunctionSignature {
7395            name: "time_diff",
7396            display_name: "TIME_DIFF",
7397            params: PARAMS_TIME_DIFF,
7398            return_type: None,
7399            category: FunctionCategory::Scalar,
7400        }),
7401        "time_slice" => Some(FunctionSignature {
7402            name: "time_slice",
7403            display_name: "TIME_SLICE",
7404            params: PARAMS_TIME_SLICE,
7405            return_type: None,
7406            category: FunctionCategory::Scalar,
7407        }),
7408        "time_str_to_date" => Some(FunctionSignature {
7409            name: "time_str_to_date",
7410            display_name: "TIME_STR_TO_DATE",
7411            params: PARAMS_TIME_STR_TO_DATE,
7412            return_type: None,
7413            category: FunctionCategory::Scalar,
7414        }),
7415        "time_str_to_time" => Some(FunctionSignature {
7416            name: "time_str_to_time",
7417            display_name: "TIME_STR_TO_TIME",
7418            params: PARAMS_TIME_STR_TO_TIME,
7419            return_type: None,
7420            category: FunctionCategory::Scalar,
7421        }),
7422        "time_str_to_unix" => Some(FunctionSignature {
7423            name: "time_str_to_unix",
7424            display_name: "TIME_STR_TO_UNIX",
7425            params: PARAMS_TIME_STR_TO_UNIX,
7426            return_type: None,
7427            category: FunctionCategory::Scalar,
7428        }),
7429        "time_sub" => Some(FunctionSignature {
7430            name: "time_sub",
7431            display_name: "TIME_SUB",
7432            params: PARAMS_TIME_SUB,
7433            return_type: None,
7434            category: FunctionCategory::Scalar,
7435        }),
7436        "time_to_str" => Some(FunctionSignature {
7437            name: "time_to_str",
7438            display_name: "TIME_TO_STR",
7439            params: PARAMS_TIME_TO_STR,
7440            return_type: None,
7441            category: FunctionCategory::Scalar,
7442        }),
7443        "time_to_time_str" => Some(FunctionSignature {
7444            name: "time_to_time_str",
7445            display_name: "TIME_TO_TIME_STR",
7446            params: PARAMS_TIME_TO_TIME_STR,
7447            return_type: None,
7448            category: FunctionCategory::Scalar,
7449        }),
7450        "time_to_unix" => Some(FunctionSignature {
7451            name: "time_to_unix",
7452            display_name: "TIME_TO_UNIX",
7453            params: PARAMS_TIME_TO_UNIX,
7454            return_type: None,
7455            category: FunctionCategory::Scalar,
7456        }),
7457        "time_trunc" => Some(FunctionSignature {
7458            name: "time_trunc",
7459            display_name: "TIME_TRUNC",
7460            params: PARAMS_TIME_TRUNC,
7461            return_type: None,
7462            category: FunctionCategory::Scalar,
7463        }),
7464        "to_array" => Some(FunctionSignature {
7465            name: "to_array",
7466            display_name: "TO_ARRAY",
7467            params: PARAMS_TO_ARRAY,
7468            return_type: None,
7469            category: FunctionCategory::Scalar,
7470        }),
7471        "to_base32" => Some(FunctionSignature {
7472            name: "to_base32",
7473            display_name: "TO_BASE32",
7474            params: PARAMS_TO_BASE32,
7475            return_type: None,
7476            category: FunctionCategory::Scalar,
7477        }),
7478        "to_base64" => Some(FunctionSignature {
7479            name: "to_base64",
7480            display_name: "TO_BASE64",
7481            params: PARAMS_TO_BASE64,
7482            return_type: None,
7483            category: FunctionCategory::Scalar,
7484        }),
7485        "to_char" => Some(FunctionSignature {
7486            name: "to_char",
7487            display_name: "TO_CHAR",
7488            params: PARAMS_TO_CHAR,
7489            return_type: None,
7490            category: FunctionCategory::Scalar,
7491        }),
7492        "to_code_points" => Some(FunctionSignature {
7493            name: "to_code_points",
7494            display_name: "TO_CODE_POINTS",
7495            params: PARAMS_TO_CODE_POINTS,
7496            return_type: None,
7497            category: FunctionCategory::Scalar,
7498        }),
7499        "to_days" => Some(FunctionSignature {
7500            name: "to_days",
7501            display_name: "TO_DAYS",
7502            params: PARAMS_TO_DAYS,
7503            return_type: None,
7504            category: FunctionCategory::Scalar,
7505        }),
7506        "to_double" => Some(FunctionSignature {
7507            name: "to_double",
7508            display_name: "TO_DOUBLE",
7509            params: PARAMS_TO_DOUBLE,
7510            return_type: None,
7511            category: FunctionCategory::Scalar,
7512        }),
7513        "to_map" => Some(FunctionSignature {
7514            name: "to_map",
7515            display_name: "TO_MAP",
7516            params: PARAMS_TO_MAP,
7517            return_type: None,
7518            category: FunctionCategory::Scalar,
7519        }),
7520        "to_number" => Some(FunctionSignature {
7521            name: "to_number",
7522            display_name: "TO_NUMBER",
7523            params: PARAMS_TO_NUMBER,
7524            return_type: None,
7525            category: FunctionCategory::Scalar,
7526        }),
7527        "transform" => Some(FunctionSignature {
7528            name: "transform",
7529            display_name: "TRANSFORM",
7530            params: PARAMS_TRANSFORM,
7531            return_type: None,
7532            category: FunctionCategory::Scalar,
7533        }),
7534        "translate" => Some(FunctionSignature {
7535            name: "translate",
7536            display_name: "TRANSLATE",
7537            params: PARAMS_TRANSLATE,
7538            return_type: None,
7539            category: FunctionCategory::Scalar,
7540        }),
7541        "trim" => Some(FunctionSignature {
7542            name: "trim",
7543            display_name: "TRIM",
7544            params: PARAMS_TRIM,
7545            return_type: Some(ReturnTypeRule::Text),
7546            category: FunctionCategory::Scalar,
7547        }),
7548        "try" => Some(FunctionSignature {
7549            name: "try",
7550            display_name: "TRY",
7551            params: PARAMS_TRY,
7552            return_type: None,
7553            category: FunctionCategory::Scalar,
7554        }),
7555        "try_base64decode_binary" => Some(FunctionSignature {
7556            name: "try_base64decode_binary",
7557            display_name: "TRY_BASE64DECODE_BINARY",
7558            params: PARAMS_TRY_BASE64DECODE_BINARY,
7559            return_type: None,
7560            category: FunctionCategory::Scalar,
7561        }),
7562        "try_base64decode_string" => Some(FunctionSignature {
7563            name: "try_base64decode_string",
7564            display_name: "TRY_BASE64DECODE_STRING",
7565            params: PARAMS_TRY_BASE64DECODE_STRING,
7566            return_type: None,
7567            category: FunctionCategory::Scalar,
7568        }),
7569        "try_cast" => Some(FunctionSignature {
7570            name: "try_cast",
7571            display_name: "TRY_CAST",
7572            params: PARAMS_TRY_CAST,
7573            return_type: None,
7574            category: FunctionCategory::Scalar,
7575        }),
7576        "try_hex_decode_binary" => Some(FunctionSignature {
7577            name: "try_hex_decode_binary",
7578            display_name: "TRY_HEX_DECODE_BINARY",
7579            params: PARAMS_TRY_HEX_DECODE_BINARY,
7580            return_type: None,
7581            category: FunctionCategory::Scalar,
7582        }),
7583        "try_hex_decode_string" => Some(FunctionSignature {
7584            name: "try_hex_decode_string",
7585            display_name: "TRY_HEX_DECODE_STRING",
7586            params: PARAMS_TRY_HEX_DECODE_STRING,
7587            return_type: None,
7588            category: FunctionCategory::Scalar,
7589        }),
7590        "ts_or_di_to_di" => Some(FunctionSignature {
7591            name: "ts_or_di_to_di",
7592            display_name: "TS_OR_DI_TO_DI",
7593            params: PARAMS_TS_OR_DI_TO_DI,
7594            return_type: None,
7595            category: FunctionCategory::Scalar,
7596        }),
7597        "ts_or_ds_add" => Some(FunctionSignature {
7598            name: "ts_or_ds_add",
7599            display_name: "TS_OR_DS_ADD",
7600            params: PARAMS_TS_OR_DS_ADD,
7601            return_type: None,
7602            category: FunctionCategory::Scalar,
7603        }),
7604        "ts_or_ds_diff" => Some(FunctionSignature {
7605            name: "ts_or_ds_diff",
7606            display_name: "TS_OR_DS_DIFF",
7607            params: PARAMS_TS_OR_DS_DIFF,
7608            return_type: None,
7609            category: FunctionCategory::Scalar,
7610        }),
7611        "ts_or_ds_to_date" => Some(FunctionSignature {
7612            name: "ts_or_ds_to_date",
7613            display_name: "TS_OR_DS_TO_DATE",
7614            params: PARAMS_TS_OR_DS_TO_DATE,
7615            return_type: None,
7616            category: FunctionCategory::Scalar,
7617        }),
7618        "ts_or_ds_to_datetime" => Some(FunctionSignature {
7619            name: "ts_or_ds_to_datetime",
7620            display_name: "TS_OR_DS_TO_DATETIME",
7621            params: PARAMS_TS_OR_DS_TO_DATETIME,
7622            return_type: None,
7623            category: FunctionCategory::Scalar,
7624        }),
7625        "ts_or_ds_to_date_str" => Some(FunctionSignature {
7626            name: "ts_or_ds_to_date_str",
7627            display_name: "TS_OR_DS_TO_DATE_STR",
7628            params: PARAMS_TS_OR_DS_TO_DATE_STR,
7629            return_type: None,
7630            category: FunctionCategory::Scalar,
7631        }),
7632        "ts_or_ds_to_time" => Some(FunctionSignature {
7633            name: "ts_or_ds_to_time",
7634            display_name: "TS_OR_DS_TO_TIME",
7635            params: PARAMS_TS_OR_DS_TO_TIME,
7636            return_type: None,
7637            category: FunctionCategory::Scalar,
7638        }),
7639        "ts_or_ds_to_timestamp" => Some(FunctionSignature {
7640            name: "ts_or_ds_to_timestamp",
7641            display_name: "TS_OR_DS_TO_TIMESTAMP",
7642            params: PARAMS_TS_OR_DS_TO_TIMESTAMP,
7643            return_type: None,
7644            category: FunctionCategory::Scalar,
7645        }),
7646        "typeof" => Some(FunctionSignature {
7647            name: "typeof",
7648            display_name: "TYPEOF",
7649            params: PARAMS_TYPEOF,
7650            return_type: None,
7651            category: FunctionCategory::Scalar,
7652        }),
7653        "upper" => Some(FunctionSignature {
7654            name: "upper",
7655            display_name: "UPPER",
7656            params: PARAMS_UPPER,
7657            return_type: Some(ReturnTypeRule::Text),
7658            category: FunctionCategory::Scalar,
7659        }),
7660        "unhex" => Some(FunctionSignature {
7661            name: "unhex",
7662            display_name: "UNHEX",
7663            params: PARAMS_UNHEX,
7664            return_type: None,
7665            category: FunctionCategory::Scalar,
7666        }),
7667        "unicode" => Some(FunctionSignature {
7668            name: "unicode",
7669            display_name: "UNICODE",
7670            params: PARAMS_UNICODE,
7671            return_type: None,
7672            category: FunctionCategory::Scalar,
7673        }),
7674        "unix_date" => Some(FunctionSignature {
7675            name: "unix_date",
7676            display_name: "UNIX_DATE",
7677            params: PARAMS_UNIX_DATE,
7678            return_type: None,
7679            category: FunctionCategory::Scalar,
7680        }),
7681        "unix_micros" => Some(FunctionSignature {
7682            name: "unix_micros",
7683            display_name: "UNIX_MICROS",
7684            params: PARAMS_UNIX_MICROS,
7685            return_type: None,
7686            category: FunctionCategory::Scalar,
7687        }),
7688        "unix_millis" => Some(FunctionSignature {
7689            name: "unix_millis",
7690            display_name: "UNIX_MILLIS",
7691            params: PARAMS_UNIX_MILLIS,
7692            return_type: None,
7693            category: FunctionCategory::Scalar,
7694        }),
7695        "unix_seconds" => Some(FunctionSignature {
7696            name: "unix_seconds",
7697            display_name: "UNIX_SECONDS",
7698            params: PARAMS_UNIX_SECONDS,
7699            return_type: None,
7700            category: FunctionCategory::Scalar,
7701        }),
7702        "unix_to_str" => Some(FunctionSignature {
7703            name: "unix_to_str",
7704            display_name: "UNIX_TO_STR",
7705            params: PARAMS_UNIX_TO_STR,
7706            return_type: None,
7707            category: FunctionCategory::Scalar,
7708        }),
7709        "unix_to_time" => Some(FunctionSignature {
7710            name: "unix_to_time",
7711            display_name: "UNIX_TO_TIME",
7712            params: PARAMS_UNIX_TO_TIME,
7713            return_type: None,
7714            category: FunctionCategory::Scalar,
7715        }),
7716        "unix_to_time_str" => Some(FunctionSignature {
7717            name: "unix_to_time_str",
7718            display_name: "UNIX_TO_TIME_STR",
7719            params: PARAMS_UNIX_TO_TIME_STR,
7720            return_type: None,
7721            category: FunctionCategory::Scalar,
7722        }),
7723        "unnest" => Some(FunctionSignature {
7724            name: "unnest",
7725            display_name: "UNNEST",
7726            params: PARAMS_UNNEST,
7727            return_type: None,
7728            category: FunctionCategory::Scalar,
7729        }),
7730        "utc_date" => Some(FunctionSignature {
7731            name: "utc_date",
7732            display_name: "UTC_DATE",
7733            params: &[],
7734            return_type: None,
7735            category: FunctionCategory::Scalar,
7736        }),
7737        "utc_time" => Some(FunctionSignature {
7738            name: "utc_time",
7739            display_name: "UTC_TIME",
7740            params: PARAMS_UTC_TIME,
7741            return_type: None,
7742            category: FunctionCategory::Scalar,
7743        }),
7744        "utc_timestamp" => Some(FunctionSignature {
7745            name: "utc_timestamp",
7746            display_name: "UTC_TIMESTAMP",
7747            params: PARAMS_UTC_TIMESTAMP,
7748            return_type: None,
7749            category: FunctionCategory::Scalar,
7750        }),
7751        "variance" => Some(FunctionSignature {
7752            name: "variance",
7753            display_name: "VARIANCE",
7754            params: PARAMS_VARIANCE,
7755            return_type: None,
7756            category: FunctionCategory::Aggregate,
7757        }),
7758        "variance_pop" => Some(FunctionSignature {
7759            name: "variance_pop",
7760            display_name: "VARIANCE_POP",
7761            params: PARAMS_VARIANCE_POP,
7762            return_type: None,
7763            category: FunctionCategory::Aggregate,
7764        }),
7765        "var_map" => Some(FunctionSignature {
7766            name: "var_map",
7767            display_name: "VAR_MAP",
7768            params: PARAMS_VAR_MAP,
7769            return_type: None,
7770            category: FunctionCategory::Scalar,
7771        }),
7772        "vector_search" => Some(FunctionSignature {
7773            name: "vector_search",
7774            display_name: "VECTOR_SEARCH",
7775            params: PARAMS_VECTOR_SEARCH,
7776            return_type: None,
7777            category: FunctionCategory::Scalar,
7778        }),
7779        "week" => Some(FunctionSignature {
7780            name: "week",
7781            display_name: "WEEK",
7782            params: PARAMS_WEEK,
7783            return_type: None,
7784            category: FunctionCategory::Scalar,
7785        }),
7786        "week_of_year" => Some(FunctionSignature {
7787            name: "week_of_year",
7788            display_name: "WEEK_OF_YEAR",
7789            params: PARAMS_WEEK_OF_YEAR,
7790            return_type: None,
7791            category: FunctionCategory::Scalar,
7792        }),
7793        "width_bucket" => Some(FunctionSignature {
7794            name: "width_bucket",
7795            display_name: "WIDTH_BUCKET",
7796            params: PARAMS_WIDTH_BUCKET,
7797            return_type: None,
7798            category: FunctionCategory::Scalar,
7799        }),
7800        "xml_element" => Some(FunctionSignature {
7801            name: "xml_element",
7802            display_name: "XML_ELEMENT",
7803            params: PARAMS_XML_ELEMENT,
7804            return_type: None,
7805            category: FunctionCategory::Scalar,
7806        }),
7807        "xor" => Some(FunctionSignature {
7808            name: "xor",
7809            display_name: "XOR",
7810            params: PARAMS_XOR,
7811            return_type: None,
7812            category: FunctionCategory::Scalar,
7813        }),
7814        "xml_table" => Some(FunctionSignature {
7815            name: "xml_table",
7816            display_name: "XML_TABLE",
7817            params: PARAMS_XML_TABLE,
7818            return_type: None,
7819            category: FunctionCategory::Scalar,
7820        }),
7821        "year" => Some(FunctionSignature {
7822            name: "year",
7823            display_name: "YEAR",
7824            params: PARAMS_YEAR,
7825            return_type: None,
7826            category: FunctionCategory::Scalar,
7827        }),
7828        "year_of_week" => Some(FunctionSignature {
7829            name: "year_of_week",
7830            display_name: "YEAR_OF_WEEK",
7831            params: PARAMS_YEAR_OF_WEEK,
7832            return_type: None,
7833            category: FunctionCategory::Scalar,
7834        }),
7835        "year_of_week_iso" => Some(FunctionSignature {
7836            name: "year_of_week_iso",
7837            display_name: "YEAR_OF_WEEK_ISO",
7838            params: PARAMS_YEAR_OF_WEEK_ISO,
7839            return_type: None,
7840            category: FunctionCategory::Scalar,
7841        }),
7842        _ => None,
7843    }
7844}
7845
7846/// Returns all function signatures for completion.
7847///
7848/// This provides access to all known SQL functions for populating
7849/// completion lists. Functions are returned in a static slice for efficiency.
7850pub fn all_function_signatures() -> impl Iterator<Item = FunctionSignature> {
7851    static NAMES: &[&str] = &[
7852        "abs",
7853        "acos",
7854        "acosh",
7855        "add_months",
7856        "agg_func",
7857        "ai_agg",
7858        "ai_classify",
7859        "ai_summarize_agg",
7860        "and",
7861        "any_value",
7862        "apply",
7863        "approximate_similarity",
7864        "approx_distinct",
7865        "approx_quantile",
7866        "approx_quantiles",
7867        "approx_top_k",
7868        "approx_top_k_accumulate",
7869        "approx_top_k_combine",
7870        "approx_top_sum",
7871        "arg_max",
7872        "arg_min",
7873        "array",
7874        "array_agg",
7875        "array_all",
7876        "array_any",
7877        "array_concat",
7878        "array_concat_agg",
7879        "array_construct_compact",
7880        "array_contains",
7881        "array_contains_all",
7882        "array_filter",
7883        "array_first",
7884        "array_intersect",
7885        "array_to_string",
7886        "array_last",
7887        "array_size",
7888        "array_overlaps",
7889        "array_remove",
7890        "array_reverse",
7891        "array_slice",
7892        "array_sort",
7893        "array_sum",
7894        "array_union_agg",
7895        "array_unique_agg",
7896        "ascii",
7897        "asin",
7898        "asinh",
7899        "atan",
7900        "atan2",
7901        "atanh",
7902        "avg",
7903        "base64decode_binary",
7904        "base64decode_string",
7905        "base64encode",
7906        "bitmap_bit_position",
7907        "bitmap_bucket_number",
7908        "bitmap_construct_agg",
7909        "bitmap_count",
7910        "bitmap_or_agg",
7911        "bitwise_and_agg",
7912        "bitwise_count",
7913        "bitwise_or_agg",
7914        "bitwise_xor_agg",
7915        "bit_length",
7916        "booland",
7917        "logical_and",
7918        "boolnot",
7919        "boolor",
7920        "logical_or",
7921        "boolxor_agg",
7922        "byte_length",
7923        "case",
7924        "cast",
7925        "cast_to_str_type",
7926        "cbrt",
7927        "ceil",
7928        "chr",
7929        "length",
7930        "coalesce",
7931        "code_points_to_bytes",
7932        "code_points_to_string",
7933        "collate",
7934        "collation",
7935        "columns",
7936        "combined_agg_func",
7937        "combined_parameterized_agg",
7938        "compress",
7939        "concat",
7940        "concat_ws",
7941        "connect_by_root",
7942        "contains",
7943        "convert",
7944        "convert_timezone",
7945        "convert_to_charset",
7946        "corr",
7947        "cos",
7948        "cosh",
7949        "cosine_distance",
7950        "cot",
7951        "coth",
7952        "count",
7953        "count_if",
7954        "covar_pop",
7955        "covar_samp",
7956        "csc",
7957        "csch",
7958        "cume_dist",
7959        "current_date",
7960        "current_datetime",
7961        "current_schema",
7962        "current_time",
7963        "current_timestamp",
7964        "current_timestamp_ltz",
7965        "current_user",
7966        "date",
7967        "date_diff",
7968        "date_from_parts",
7969        "datetime",
7970        "datetime_add",
7971        "datetime_diff",
7972        "datetime_sub",
7973        "datetime_trunc",
7974        "date_add",
7975        "date_bin",
7976        "date_from_unix_date",
7977        "date_str_to_date",
7978        "date_sub",
7979        "date_to_date_str",
7980        "date_to_di",
7981        "date_trunc",
7982        "day",
7983        "day_of_month",
7984        "day_of_week",
7985        "day_of_week_iso",
7986        "day_of_year",
7987        "decode",
7988        "decode_case",
7989        "decompress_binary",
7990        "decompress_string",
7991        "degrees",
7992        "dense_rank",
7993        "di_to_date",
7994        "encode",
7995        "ends_with",
7996        "equal_null",
7997        "euclidean_distance",
7998        "exists",
7999        "exp",
8000        "explode",
8001        "explode_outer",
8002        "exploding_generate_series",
8003        "extract",
8004        "factorial",
8005        "farm_fingerprint",
8006        "features_at_time",
8007        "first",
8008        "first_value",
8009        "flatten",
8010        "float64",
8011        "floor",
8012        "format",
8013        "from_base",
8014        "from_base32",
8015        "from_base64",
8016        "from_iso8601timestamp",
8017        "gap_fill",
8018        "generate_date_array",
8019        "generate_embedding",
8020        "generate_series",
8021        "generate_timestamp_array",
8022        "uuid",
8023        "getbit",
8024        "get_extract",
8025        "greatest",
8026        "greatest_ignore_nulls",
8027        "grouping",
8028        "grouping_id",
8029        "group_concat",
8030        "hex",
8031        "hex_decode_string",
8032        "hex_encode",
8033        "hll",
8034        "hour",
8035        "if",
8036        "initcap",
8037        "inline",
8038        "stuff",
8039        "int64",
8040        "is_inf",
8041        "is_nan",
8042        "is_ascii",
8043        "is_null_value",
8044        "jarowinkler_similarity",
8045        "jsonb_contains",
8046        "jsonb_exists",
8047        "jsonb_extract",
8048        "jsonb_extract_scalar",
8049        "json_array_append",
8050        "json_array_contains",
8051        "json_array_insert",
8052        "json_extract",
8053        "json_extract_array",
8054        "json_extract_scalar",
8055        "json_format",
8056        "parse_json",
8057        "json_remove",
8058        "json_set",
8059        "json_strip_nulls",
8060        "json_type",
8061        "justify_days",
8062        "justify_hours",
8063        "justify_interval",
8064        "json_array",
8065        "json_array_agg",
8066        "json_bool",
8067        "jsonb_contains_all_top_keys",
8068        "jsonb_contains_any_top_keys",
8069        "jsonb_delete_at_path",
8070        "jsonb_object_agg",
8071        "json_cast",
8072        "json_exists",
8073        "json_keys_at_depth",
8074        "json_object",
8075        "json_object_agg",
8076        "json_table",
8077        "json_value_array",
8078        "lag",
8079        "last",
8080        "last_day",
8081        "last_value",
8082        "lax_bool",
8083        "lax_float64",
8084        "lax_int64",
8085        "lax_string",
8086        "lower",
8087        "lead",
8088        "least",
8089        "least_ignore_nulls",
8090        "left",
8091        "levenshtein",
8092        "list",
8093        "ln",
8094        "log",
8095        "lower_hex",
8096        "make_interval",
8097        "map",
8098        "map_from_entries",
8099        "match_against",
8100        "max",
8101        "md5",
8102        "md5digest",
8103        "median",
8104        "min",
8105        "minhash",
8106        "minhash_combine",
8107        "minute",
8108        "month",
8109        "monthname",
8110        "months_between",
8111        "md5number_lower64",
8112        "md5number_upper64",
8113        "ml_forecast",
8114        "ml_translate",
8115        "next_day",
8116        "next_value_for",
8117        "normalize",
8118        "now",
8119        "nth_value",
8120        "ntile",
8121        "nullif",
8122        "number_to_str",
8123        "nvl2",
8124        "object_agg",
8125        "object_insert",
8126        "open_json",
8127        "or",
8128        "overlay",
8129        "pad",
8130        "parameterized_agg",
8131        "parse_bignumeric",
8132        "parse_datetime",
8133        "parse_ip",
8134        "parse_numeric",
8135        "parse_time",
8136        "parse_url",
8137        "percentile_cont",
8138        "percentile_disc",
8139        "percent_rank",
8140        "pi",
8141        "posexplode",
8142        "posexplode_outer",
8143        "pow",
8144        "predict",
8145        "previous_day",
8146        "quantile",
8147        "quarter",
8148        "radians",
8149        "rand",
8150        "randn",
8151        "range_bucket",
8152        "range_n",
8153        "rank",
8154        "read_csv",
8155        "read_parquet",
8156        "reduce",
8157        "regexp_count",
8158        "regexp_extract",
8159        "regexp_extract_all",
8160        "regexp_full_match",
8161        "regexp_instr",
8162        "regexp_i_like",
8163        "regexp_like",
8164        "regexp_replace",
8165        "regexp_split",
8166        "regr_avgx",
8167        "regr_avgy",
8168        "regr_valx",
8169        "regr_valy",
8170        "repeat",
8171        "replace",
8172        "reverse",
8173        "right",
8174        "round",
8175        "row_number",
8176        "rtrimmed_length",
8177        "safe_add",
8178        "safe_convert_bytes_to_string",
8179        "safe_divide",
8180        "safe_multiply",
8181        "safe_negate",
8182        "safe_subtract",
8183        "search",
8184        "sec",
8185        "sech",
8186        "second",
8187        "sha",
8188        "sha2",
8189        "sign",
8190        "sin",
8191        "sinh",
8192        "skewness",
8193        "sort_array",
8194        "soundex",
8195        "soundex_p123",
8196        "space",
8197        "split",
8198        "string_to_array",
8199        "split_part",
8200        "sqrt",
8201        "standard_hash",
8202        "starts_with",
8203        "star_map",
8204        "stddev",
8205        "stddev_pop",
8206        "stddev_samp",
8207        "string",
8208        "struct",
8209        "struct_extract",
8210        "str_position",
8211        "str_to_date",
8212        "str_to_map",
8213        "str_to_time",
8214        "str_to_unix",
8215        "st_distance",
8216        "st_point",
8217        "substring",
8218        "substring_index",
8219        "sum",
8220        "sha1digest",
8221        "sha2digest",
8222        "tan",
8223        "tanh",
8224        "time",
8225        "time_from_parts",
8226        "timestamp",
8227        "timestamp_diff",
8228        "timestamp_from_parts",
8229        "timestamp_ltz_from_parts",
8230        "timestamp_tz_from_parts",
8231        "timestamp_add",
8232        "timestamp_sub",
8233        "timestamp_trunc",
8234        "time_add",
8235        "time_diff",
8236        "time_slice",
8237        "time_str_to_date",
8238        "time_str_to_time",
8239        "time_str_to_unix",
8240        "time_sub",
8241        "time_to_str",
8242        "time_to_time_str",
8243        "time_to_unix",
8244        "time_trunc",
8245        "to_array",
8246        "to_base32",
8247        "to_base64",
8248        "to_char",
8249        "to_code_points",
8250        "to_days",
8251        "to_double",
8252        "to_map",
8253        "to_number",
8254        "transform",
8255        "translate",
8256        "trim",
8257        "try",
8258        "try_base64decode_binary",
8259        "try_base64decode_string",
8260        "try_cast",
8261        "try_hex_decode_binary",
8262        "try_hex_decode_string",
8263        "ts_or_di_to_di",
8264        "ts_or_ds_add",
8265        "ts_or_ds_diff",
8266        "ts_or_ds_to_date",
8267        "ts_or_ds_to_datetime",
8268        "ts_or_ds_to_date_str",
8269        "ts_or_ds_to_time",
8270        "ts_or_ds_to_timestamp",
8271        "typeof",
8272        "upper",
8273        "unhex",
8274        "unicode",
8275        "unix_date",
8276        "unix_micros",
8277        "unix_millis",
8278        "unix_seconds",
8279        "unix_to_str",
8280        "unix_to_time",
8281        "unix_to_time_str",
8282        "unnest",
8283        "utc_date",
8284        "utc_time",
8285        "utc_timestamp",
8286        "variance",
8287        "variance_pop",
8288        "var_map",
8289        "vector_search",
8290        "week",
8291        "week_of_year",
8292        "width_bucket",
8293        "xml_element",
8294        "xor",
8295        "xml_table",
8296        "year",
8297        "year_of_week",
8298        "year_of_week_iso",
8299    ];
8300    NAMES.iter().filter_map(|name| get_function_signature(name))
8301}