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.params
268            .iter()
269            .map(|p| {
270                if p.required {
271                    p.name.to_string()
272                } else {
273                    format!("[{}]", p.name)
274                }
275            })
276            .collect::<Vec<_>>()
277            .join(", ");
278
279        let return_str = self.return_type
280            .map(|rt| format!(" → {}", match rt {
281                ReturnTypeRule::Integer => "INTEGER",
282                ReturnTypeRule::Numeric => "NUMERIC",
283                ReturnTypeRule::Text => "TEXT",
284                ReturnTypeRule::Timestamp => "TIMESTAMP",
285                ReturnTypeRule::Boolean => "BOOLEAN",
286                ReturnTypeRule::Date => "DATE",
287                ReturnTypeRule::MatchFirstArg => "T",
288            }))
289            .unwrap_or_default();
290
291        format!("{}({}){}", self.display_name, params_str, return_str)
292    }
293}
294
295/// Static function parameter definitions.
296static PARAMS_ABS: &[FunctionParam] = &[
297    FunctionParam { name: "this", required: true },
298];
299static PARAMS_ACOS: &[FunctionParam] = &[
300    FunctionParam { name: "this", required: true },
301];
302static PARAMS_ACOSH: &[FunctionParam] = &[
303    FunctionParam { name: "this", required: true },
304];
305static PARAMS_ADD_MONTHS: &[FunctionParam] = &[
306    FunctionParam { name: "this", required: true },
307    FunctionParam { name: "expression", required: true },
308];
309static PARAMS_AGG_FUNC: &[FunctionParam] = &[
310    FunctionParam { name: "this", required: true },
311];
312static PARAMS_AI_AGG: &[FunctionParam] = &[
313    FunctionParam { name: "this", required: true },
314    FunctionParam { name: "expression", required: true },
315];
316static PARAMS_AI_CLASSIFY: &[FunctionParam] = &[
317    FunctionParam { name: "this", required: true },
318    FunctionParam { name: "categories", required: true },
319    FunctionParam { name: "config", required: false },
320];
321static PARAMS_AI_SUMMARIZE_AGG: &[FunctionParam] = &[
322    FunctionParam { name: "this", required: true },
323];
324static PARAMS_AND: &[FunctionParam] = &[
325    FunctionParam { name: "this", required: true },
326    FunctionParam { name: "expression", required: true },
327];
328static PARAMS_ANY_VALUE: &[FunctionParam] = &[
329    FunctionParam { name: "this", required: true },
330];
331static PARAMS_APPLY: &[FunctionParam] = &[
332    FunctionParam { name: "this", required: true },
333    FunctionParam { name: "expression", required: true },
334];
335static PARAMS_APPROXIMATE_SIMILARITY: &[FunctionParam] = &[
336    FunctionParam { name: "this", required: true },
337];
338static PARAMS_APPROX_DISTINCT: &[FunctionParam] = &[
339    FunctionParam { name: "this", required: true },
340    FunctionParam { name: "accuracy", required: false },
341];
342static PARAMS_APPROX_QUANTILE: &[FunctionParam] = &[
343    FunctionParam { name: "this", required: true },
344    FunctionParam { name: "quantile", required: true },
345    FunctionParam { name: "accuracy", required: false },
346    FunctionParam { name: "weight", required: false },
347    FunctionParam { name: "error_tolerance", required: false },
348];
349static PARAMS_APPROX_QUANTILES: &[FunctionParam] = &[
350    FunctionParam { name: "this", required: true },
351    FunctionParam { name: "expression", required: false },
352];
353static PARAMS_APPROX_TOP_K: &[FunctionParam] = &[
354    FunctionParam { name: "this", required: true },
355    FunctionParam { name: "expression", required: false },
356    FunctionParam { name: "counters", required: false },
357];
358static PARAMS_APPROX_TOP_K_ACCUMULATE: &[FunctionParam] = &[
359    FunctionParam { name: "this", required: true },
360    FunctionParam { name: "expression", required: false },
361];
362static PARAMS_APPROX_TOP_K_COMBINE: &[FunctionParam] = &[
363    FunctionParam { name: "this", required: true },
364    FunctionParam { name: "expression", required: false },
365];
366static PARAMS_APPROX_TOP_SUM: &[FunctionParam] = &[
367    FunctionParam { name: "this", required: true },
368    FunctionParam { name: "expression", required: true },
369    FunctionParam { name: "count", required: true },
370];
371static PARAMS_ARG_MAX: &[FunctionParam] = &[
372    FunctionParam { name: "this", required: true },
373    FunctionParam { name: "expression", required: true },
374    FunctionParam { name: "count", required: false },
375];
376static PARAMS_ARG_MIN: &[FunctionParam] = &[
377    FunctionParam { name: "this", required: true },
378    FunctionParam { name: "expression", required: true },
379    FunctionParam { name: "count", required: false },
380];
381static PARAMS_ARRAY: &[FunctionParam] = &[
382    FunctionParam { name: "expressions", required: false },
383];
384static PARAMS_ARRAY_AGG: &[FunctionParam] = &[
385    FunctionParam { name: "this", required: true },
386];
387static PARAMS_ARRAY_ALL: &[FunctionParam] = &[
388    FunctionParam { name: "this", required: true },
389    FunctionParam { name: "expression", required: true },
390];
391static PARAMS_ARRAY_ANY: &[FunctionParam] = &[
392    FunctionParam { name: "this", required: true },
393    FunctionParam { name: "expression", required: true },
394];
395static PARAMS_ARRAY_CONCAT: &[FunctionParam] = &[
396    FunctionParam { name: "this", required: true },
397    FunctionParam { name: "expressions", required: false },
398];
399static PARAMS_ARRAY_CONCAT_AGG: &[FunctionParam] = &[
400    FunctionParam { name: "this", required: true },
401];
402static PARAMS_ARRAY_CONSTRUCT_COMPACT: &[FunctionParam] = &[
403    FunctionParam { name: "expressions", required: true },
404];
405static PARAMS_ARRAY_CONTAINS: &[FunctionParam] = &[
406    FunctionParam { name: "this", required: true },
407    FunctionParam { name: "expression", required: true },
408];
409static PARAMS_ARRAY_CONTAINS_ALL: &[FunctionParam] = &[
410    FunctionParam { name: "this", required: true },
411    FunctionParam { name: "expression", required: true },
412];
413static PARAMS_ARRAY_FILTER: &[FunctionParam] = &[
414    FunctionParam { name: "this", required: true },
415    FunctionParam { name: "expression", required: true },
416];
417static PARAMS_ARRAY_FIRST: &[FunctionParam] = &[
418    FunctionParam { name: "this", required: true },
419];
420static PARAMS_ARRAY_INTERSECT: &[FunctionParam] = &[
421    FunctionParam { name: "expressions", required: true },
422];
423static PARAMS_ARRAY_TO_STRING: &[FunctionParam] = &[
424    FunctionParam { name: "this", required: true },
425    FunctionParam { name: "expression", required: true },
426    FunctionParam { name: "null", required: false },
427];
428static PARAMS_ARRAY_LAST: &[FunctionParam] = &[
429    FunctionParam { name: "this", required: true },
430];
431static PARAMS_ARRAY_SIZE: &[FunctionParam] = &[
432    FunctionParam { name: "this", required: true },
433    FunctionParam { name: "expression", required: false },
434];
435static PARAMS_ARRAY_OVERLAPS: &[FunctionParam] = &[
436    FunctionParam { name: "this", required: true },
437    FunctionParam { name: "expression", required: true },
438];
439static PARAMS_ARRAY_REMOVE: &[FunctionParam] = &[
440    FunctionParam { name: "this", required: true },
441    FunctionParam { name: "expression", required: true },
442];
443static PARAMS_ARRAY_REVERSE: &[FunctionParam] = &[
444    FunctionParam { name: "this", required: true },
445];
446static PARAMS_ARRAY_SLICE: &[FunctionParam] = &[
447    FunctionParam { name: "this", required: true },
448    FunctionParam { name: "start", required: true },
449    FunctionParam { name: "end", required: false },
450    FunctionParam { name: "step", required: false },
451];
452static PARAMS_ARRAY_SORT: &[FunctionParam] = &[
453    FunctionParam { name: "this", required: true },
454    FunctionParam { name: "expression", required: false },
455];
456static PARAMS_ARRAY_SUM: &[FunctionParam] = &[
457    FunctionParam { name: "this", required: true },
458    FunctionParam { name: "expression", required: false },
459];
460static PARAMS_ARRAY_UNION_AGG: &[FunctionParam] = &[
461    FunctionParam { name: "this", required: true },
462];
463static PARAMS_ARRAY_UNIQUE_AGG: &[FunctionParam] = &[
464    FunctionParam { name: "this", required: true },
465];
466static PARAMS_ASCII: &[FunctionParam] = &[
467    FunctionParam { name: "this", required: true },
468];
469static PARAMS_ASIN: &[FunctionParam] = &[
470    FunctionParam { name: "this", required: true },
471];
472static PARAMS_ASINH: &[FunctionParam] = &[
473    FunctionParam { name: "this", required: true },
474];
475static PARAMS_ATAN: &[FunctionParam] = &[
476    FunctionParam { name: "this", required: true },
477    FunctionParam { name: "expression", required: false },
478];
479static PARAMS_ATAN2: &[FunctionParam] = &[
480    FunctionParam { name: "this", required: true },
481    FunctionParam { name: "expression", required: true },
482];
483static PARAMS_ATANH: &[FunctionParam] = &[
484    FunctionParam { name: "this", required: true },
485];
486static PARAMS_AVG: &[FunctionParam] = &[
487    FunctionParam { name: "this", required: true },
488];
489static PARAMS_BASE64DECODE_BINARY: &[FunctionParam] = &[
490    FunctionParam { name: "this", required: true },
491    FunctionParam { name: "alphabet", required: false },
492];
493static PARAMS_BASE64DECODE_STRING: &[FunctionParam] = &[
494    FunctionParam { name: "this", required: true },
495    FunctionParam { name: "alphabet", required: false },
496];
497static PARAMS_BASE64ENCODE: &[FunctionParam] = &[
498    FunctionParam { name: "this", required: true },
499    FunctionParam { name: "max_line_length", required: false },
500    FunctionParam { name: "alphabet", required: false },
501];
502static PARAMS_BITMAP_BIT_POSITION: &[FunctionParam] = &[
503    FunctionParam { name: "this", required: true },
504];
505static PARAMS_BITMAP_BUCKET_NUMBER: &[FunctionParam] = &[
506    FunctionParam { name: "this", required: true },
507];
508static PARAMS_BITMAP_CONSTRUCT_AGG: &[FunctionParam] = &[
509    FunctionParam { name: "this", required: true },
510];
511static PARAMS_BITMAP_COUNT: &[FunctionParam] = &[
512    FunctionParam { name: "this", required: true },
513];
514static PARAMS_BITMAP_OR_AGG: &[FunctionParam] = &[
515    FunctionParam { name: "this", required: true },
516];
517static PARAMS_BITWISE_AND_AGG: &[FunctionParam] = &[
518    FunctionParam { name: "this", required: true },
519];
520static PARAMS_BITWISE_COUNT: &[FunctionParam] = &[
521    FunctionParam { name: "this", required: true },
522];
523static PARAMS_BITWISE_OR_AGG: &[FunctionParam] = &[
524    FunctionParam { name: "this", required: true },
525];
526static PARAMS_BITWISE_XOR_AGG: &[FunctionParam] = &[
527    FunctionParam { name: "this", required: true },
528];
529static PARAMS_BIT_LENGTH: &[FunctionParam] = &[
530    FunctionParam { name: "this", required: true },
531];
532static PARAMS_BOOLAND: &[FunctionParam] = &[
533    FunctionParam { name: "this", required: true },
534    FunctionParam { name: "expression", required: true },
535];
536static PARAMS_LOGICAL_AND: &[FunctionParam] = &[
537    FunctionParam { name: "this", required: true },
538];
539static PARAMS_BOOLNOT: &[FunctionParam] = &[
540    FunctionParam { name: "this", required: true },
541];
542static PARAMS_BOOLOR: &[FunctionParam] = &[
543    FunctionParam { name: "this", required: true },
544    FunctionParam { name: "expression", required: true },
545];
546static PARAMS_LOGICAL_OR: &[FunctionParam] = &[
547    FunctionParam { name: "this", required: true },
548];
549static PARAMS_BOOLXOR_AGG: &[FunctionParam] = &[
550    FunctionParam { name: "this", required: true },
551];
552static PARAMS_BYTE_LENGTH: &[FunctionParam] = &[
553    FunctionParam { name: "this", required: true },
554];
555static PARAMS_CASE: &[FunctionParam] = &[
556    FunctionParam { name: "this", required: false },
557    FunctionParam { name: "ifs", required: true },
558    FunctionParam { name: "default", required: false },
559];
560static PARAMS_CAST: &[FunctionParam] = &[
561    FunctionParam { name: "this", required: true },
562    FunctionParam { name: "to", required: true },
563    FunctionParam { name: "format", required: false },
564    FunctionParam { name: "safe", required: false },
565    FunctionParam { name: "action", required: false },
566    FunctionParam { name: "default", required: false },
567];
568static PARAMS_CAST_TO_STR_TYPE: &[FunctionParam] = &[
569    FunctionParam { name: "this", required: true },
570    FunctionParam { name: "to", required: true },
571];
572static PARAMS_CBRT: &[FunctionParam] = &[
573    FunctionParam { name: "this", required: true },
574];
575static PARAMS_CEIL: &[FunctionParam] = &[
576    FunctionParam { name: "this", required: true },
577    FunctionParam { name: "decimals", required: false },
578    FunctionParam { name: "to", required: false },
579];
580static PARAMS_CHR: &[FunctionParam] = &[
581    FunctionParam { name: "expressions", required: true },
582    FunctionParam { name: "charset", required: false },
583];
584static PARAMS_LENGTH: &[FunctionParam] = &[
585    FunctionParam { name: "this", required: true },
586    FunctionParam { name: "binary", required: false },
587    FunctionParam { name: "encoding", required: false },
588];
589static PARAMS_COALESCE: &[FunctionParam] = &[
590    FunctionParam { name: "this", required: true },
591    FunctionParam { name: "expressions", required: false },
592    FunctionParam { name: "is_nvl", required: false },
593    FunctionParam { name: "is_null", required: false },
594];
595static PARAMS_CODE_POINTS_TO_BYTES: &[FunctionParam] = &[
596    FunctionParam { name: "this", required: true },
597];
598static PARAMS_CODE_POINTS_TO_STRING: &[FunctionParam] = &[
599    FunctionParam { name: "this", required: true },
600];
601static PARAMS_COLLATE: &[FunctionParam] = &[
602    FunctionParam { name: "this", required: true },
603    FunctionParam { name: "expression", required: true },
604];
605static PARAMS_COLLATION: &[FunctionParam] = &[
606    FunctionParam { name: "this", required: true },
607];
608static PARAMS_COLUMNS: &[FunctionParam] = &[
609    FunctionParam { name: "this", required: true },
610    FunctionParam { name: "unpack", required: false },
611];
612static PARAMS_COMBINED_AGG_FUNC: &[FunctionParam] = &[
613    FunctionParam { name: "this", required: true },
614    FunctionParam { name: "expressions", required: false },
615];
616static PARAMS_COMBINED_PARAMETERIZED_AGG: &[FunctionParam] = &[
617    FunctionParam { name: "this", required: true },
618    FunctionParam { name: "expressions", required: true },
619    FunctionParam { name: "params", required: true },
620];
621static PARAMS_COMPRESS: &[FunctionParam] = &[
622    FunctionParam { name: "this", required: true },
623    FunctionParam { name: "method", required: false },
624];
625static PARAMS_CONCAT: &[FunctionParam] = &[
626    FunctionParam { name: "expressions", required: true },
627    FunctionParam { name: "safe", required: false },
628    FunctionParam { name: "coalesce", required: false },
629];
630static PARAMS_CONCAT_WS: &[FunctionParam] = &[
631    FunctionParam { name: "expressions", required: true },
632    FunctionParam { name: "safe", required: false },
633    FunctionParam { name: "coalesce", required: false },
634];
635static PARAMS_CONNECT_BY_ROOT: &[FunctionParam] = &[
636    FunctionParam { name: "this", required: true },
637];
638static PARAMS_CONTAINS: &[FunctionParam] = &[
639    FunctionParam { name: "this", required: true },
640    FunctionParam { name: "expression", required: true },
641    FunctionParam { name: "json_scope", required: false },
642];
643static PARAMS_CONVERT: &[FunctionParam] = &[
644    FunctionParam { name: "this", required: true },
645    FunctionParam { name: "expression", required: true },
646    FunctionParam { name: "style", required: false },
647    FunctionParam { name: "safe", required: false },
648];
649static PARAMS_CONVERT_TIMEZONE: &[FunctionParam] = &[
650    FunctionParam { name: "source_tz", required: false },
651    FunctionParam { name: "target_tz", required: true },
652    FunctionParam { name: "timestamp", required: true },
653    FunctionParam { name: "options", required: false },
654];
655static PARAMS_CONVERT_TO_CHARSET: &[FunctionParam] = &[
656    FunctionParam { name: "this", required: true },
657    FunctionParam { name: "dest", required: true },
658    FunctionParam { name: "source", required: false },
659];
660static PARAMS_CORR: &[FunctionParam] = &[
661    FunctionParam { name: "this", required: true },
662    FunctionParam { name: "expression", required: true },
663];
664static PARAMS_COS: &[FunctionParam] = &[
665    FunctionParam { name: "this", required: true },
666];
667static PARAMS_COSH: &[FunctionParam] = &[
668    FunctionParam { name: "this", required: true },
669];
670static PARAMS_COSINE_DISTANCE: &[FunctionParam] = &[
671    FunctionParam { name: "this", required: true },
672    FunctionParam { name: "expression", required: true },
673];
674static PARAMS_COT: &[FunctionParam] = &[
675    FunctionParam { name: "this", required: true },
676];
677static PARAMS_COTH: &[FunctionParam] = &[
678    FunctionParam { name: "this", required: true },
679];
680static PARAMS_COUNT: &[FunctionParam] = &[
681    FunctionParam { name: "this", required: false },
682    FunctionParam { name: "expressions", required: false },
683    FunctionParam { name: "big_int", required: false },
684];
685static PARAMS_COUNT_IF: &[FunctionParam] = &[
686    FunctionParam { name: "this", required: true },
687];
688static PARAMS_COVAR_POP: &[FunctionParam] = &[
689    FunctionParam { name: "this", required: true },
690    FunctionParam { name: "expression", required: true },
691];
692static PARAMS_COVAR_SAMP: &[FunctionParam] = &[
693    FunctionParam { name: "this", required: true },
694    FunctionParam { name: "expression", required: true },
695];
696static PARAMS_CSC: &[FunctionParam] = &[
697    FunctionParam { name: "this", required: true },
698];
699static PARAMS_CSCH: &[FunctionParam] = &[
700    FunctionParam { name: "this", required: true },
701];
702static PARAMS_CUME_DIST: &[FunctionParam] = &[
703    FunctionParam { name: "expressions", required: false },
704];
705static PARAMS_CURRENT_DATE: &[FunctionParam] = &[
706    FunctionParam { name: "this", required: false },
707];
708static PARAMS_CURRENT_DATETIME: &[FunctionParam] = &[
709    FunctionParam { name: "this", required: false },
710];
711static PARAMS_CURRENT_SCHEMA: &[FunctionParam] = &[
712    FunctionParam { name: "this", required: false },
713];
714static PARAMS_CURRENT_TIME: &[FunctionParam] = &[
715    FunctionParam { name: "this", required: false },
716];
717static PARAMS_CURRENT_TIMESTAMP: &[FunctionParam] = &[
718    FunctionParam { name: "this", required: false },
719    FunctionParam { name: "sysdate", required: false },
720];
721static PARAMS_CURRENT_USER: &[FunctionParam] = &[
722    FunctionParam { name: "this", required: false },
723];
724static PARAMS_DATE: &[FunctionParam] = &[
725    FunctionParam { name: "this", required: false },
726    FunctionParam { name: "zone", required: false },
727    FunctionParam { name: "expressions", required: false },
728];
729static PARAMS_DATE_DIFF: &[FunctionParam] = &[
730    FunctionParam { name: "this", required: true },
731    FunctionParam { name: "expression", required: true },
732    FunctionParam { name: "unit", required: false },
733    FunctionParam { name: "zone", required: false },
734    FunctionParam { name: "big_int", required: false },
735];
736static PARAMS_DATE_FROM_PARTS: &[FunctionParam] = &[
737    FunctionParam { name: "year", required: true },
738    FunctionParam { name: "month", required: false },
739    FunctionParam { name: "day", required: false },
740];
741static PARAMS_DATETIME: &[FunctionParam] = &[
742    FunctionParam { name: "this", required: true },
743    FunctionParam { name: "expression", required: false },
744];
745static PARAMS_DATETIME_ADD: &[FunctionParam] = &[
746    FunctionParam { name: "this", required: true },
747    FunctionParam { name: "expression", required: true },
748    FunctionParam { name: "unit", required: false },
749];
750static PARAMS_DATETIME_DIFF: &[FunctionParam] = &[
751    FunctionParam { name: "this", required: true },
752    FunctionParam { name: "expression", required: true },
753    FunctionParam { name: "unit", required: false },
754];
755static PARAMS_DATETIME_SUB: &[FunctionParam] = &[
756    FunctionParam { name: "this", required: true },
757    FunctionParam { name: "expression", required: true },
758    FunctionParam { name: "unit", required: false },
759];
760static PARAMS_DATETIME_TRUNC: &[FunctionParam] = &[
761    FunctionParam { name: "this", required: true },
762    FunctionParam { name: "unit", required: true },
763    FunctionParam { name: "zone", required: false },
764];
765static PARAMS_DATE_ADD: &[FunctionParam] = &[
766    FunctionParam { name: "this", required: true },
767    FunctionParam { name: "expression", required: true },
768    FunctionParam { name: "unit", required: false },
769];
770static PARAMS_DATE_BIN: &[FunctionParam] = &[
771    FunctionParam { name: "this", required: true },
772    FunctionParam { name: "expression", required: true },
773    FunctionParam { name: "unit", required: false },
774    FunctionParam { name: "zone", required: false },
775    FunctionParam { name: "origin", required: false },
776];
777static PARAMS_DATE_FROM_UNIX_DATE: &[FunctionParam] = &[
778    FunctionParam { name: "this", required: true },
779];
780static PARAMS_DATE_STR_TO_DATE: &[FunctionParam] = &[
781    FunctionParam { name: "this", required: true },
782];
783static PARAMS_DATE_SUB: &[FunctionParam] = &[
784    FunctionParam { name: "this", required: true },
785    FunctionParam { name: "expression", required: true },
786    FunctionParam { name: "unit", required: false },
787];
788static PARAMS_DATE_TO_DATE_STR: &[FunctionParam] = &[
789    FunctionParam { name: "this", required: true },
790];
791static PARAMS_DATE_TO_DI: &[FunctionParam] = &[
792    FunctionParam { name: "this", required: true },
793];
794static PARAMS_DATE_TRUNC: &[FunctionParam] = &[
795    FunctionParam { name: "unit", required: true },
796    FunctionParam { name: "this", required: true },
797    FunctionParam { name: "zone", required: false },
798];
799static PARAMS_DAY: &[FunctionParam] = &[
800    FunctionParam { name: "this", required: true },
801];
802static PARAMS_DAY_OF_MONTH: &[FunctionParam] = &[
803    FunctionParam { name: "this", required: true },
804];
805static PARAMS_DAY_OF_WEEK: &[FunctionParam] = &[
806    FunctionParam { name: "this", required: true },
807];
808static PARAMS_DAY_OF_WEEK_ISO: &[FunctionParam] = &[
809    FunctionParam { name: "this", required: true },
810];
811static PARAMS_DAY_OF_YEAR: &[FunctionParam] = &[
812    FunctionParam { name: "this", required: true },
813];
814static PARAMS_DECODE: &[FunctionParam] = &[
815    FunctionParam { name: "this", required: true },
816    FunctionParam { name: "charset", required: true },
817    FunctionParam { name: "replace", required: false },
818];
819static PARAMS_DECODE_CASE: &[FunctionParam] = &[
820    FunctionParam { name: "expressions", required: true },
821];
822static PARAMS_DECOMPRESS_BINARY: &[FunctionParam] = &[
823    FunctionParam { name: "this", required: true },
824    FunctionParam { name: "method", required: true },
825];
826static PARAMS_DECOMPRESS_STRING: &[FunctionParam] = &[
827    FunctionParam { name: "this", required: true },
828    FunctionParam { name: "method", required: true },
829];
830static PARAMS_DEGREES: &[FunctionParam] = &[
831    FunctionParam { name: "this", required: true },
832];
833static PARAMS_DENSE_RANK: &[FunctionParam] = &[
834    FunctionParam { name: "expressions", required: false },
835];
836static PARAMS_DI_TO_DATE: &[FunctionParam] = &[
837    FunctionParam { name: "this", required: true },
838];
839static PARAMS_ENCODE: &[FunctionParam] = &[
840    FunctionParam { name: "this", required: true },
841    FunctionParam { name: "charset", required: true },
842];
843static PARAMS_ENDS_WITH: &[FunctionParam] = &[
844    FunctionParam { name: "this", required: true },
845    FunctionParam { name: "expression", required: true },
846];
847static PARAMS_EQUAL_NULL: &[FunctionParam] = &[
848    FunctionParam { name: "this", required: true },
849    FunctionParam { name: "expression", required: true },
850];
851static PARAMS_EUCLIDEAN_DISTANCE: &[FunctionParam] = &[
852    FunctionParam { name: "this", required: true },
853    FunctionParam { name: "expression", required: true },
854];
855static PARAMS_EXISTS: &[FunctionParam] = &[
856    FunctionParam { name: "this", required: true },
857    FunctionParam { name: "expression", required: false },
858];
859static PARAMS_EXP: &[FunctionParam] = &[
860    FunctionParam { name: "this", required: true },
861];
862static PARAMS_EXPLODE: &[FunctionParam] = &[
863    FunctionParam { name: "this", required: true },
864    FunctionParam { name: "expressions", required: false },
865];
866static PARAMS_EXPLODE_OUTER: &[FunctionParam] = &[
867    FunctionParam { name: "this", required: true },
868    FunctionParam { name: "expressions", required: false },
869];
870static PARAMS_EXPLODING_GENERATE_SERIES: &[FunctionParam] = &[
871    FunctionParam { name: "start", required: true },
872    FunctionParam { name: "end", required: true },
873    FunctionParam { name: "step", required: false },
874    FunctionParam { name: "is_end_exclusive", required: false },
875];
876static PARAMS_EXTRACT: &[FunctionParam] = &[
877    FunctionParam { name: "this", required: true },
878    FunctionParam { name: "expression", required: true },
879];
880static PARAMS_FACTORIAL: &[FunctionParam] = &[
881    FunctionParam { name: "this", required: true },
882];
883static PARAMS_FARM_FINGERPRINT: &[FunctionParam] = &[
884    FunctionParam { name: "expressions", required: true },
885];
886static PARAMS_FEATURES_AT_TIME: &[FunctionParam] = &[
887    FunctionParam { name: "this", required: true },
888    FunctionParam { name: "time", required: false },
889    FunctionParam { name: "num_rows", required: false },
890    FunctionParam { name: "ignore_feature_nulls", required: false },
891];
892static PARAMS_FIRST: &[FunctionParam] = &[
893    FunctionParam { name: "this", required: true },
894    FunctionParam { name: "expression", required: false },
895];
896static PARAMS_FIRST_VALUE: &[FunctionParam] = &[
897    FunctionParam { name: "this", required: true },
898];
899static PARAMS_FLATTEN: &[FunctionParam] = &[
900    FunctionParam { name: "this", required: true },
901];
902static PARAMS_FLOAT64: &[FunctionParam] = &[
903    FunctionParam { name: "this", required: true },
904    FunctionParam { name: "expression", required: false },
905];
906static PARAMS_FLOOR: &[FunctionParam] = &[
907    FunctionParam { name: "this", required: true },
908    FunctionParam { name: "decimals", required: false },
909    FunctionParam { name: "to", required: false },
910];
911static PARAMS_FORMAT: &[FunctionParam] = &[
912    FunctionParam { name: "this", required: true },
913    FunctionParam { name: "expressions", required: false },
914];
915static PARAMS_FROM_BASE: &[FunctionParam] = &[
916    FunctionParam { name: "this", required: true },
917    FunctionParam { name: "expression", required: true },
918];
919static PARAMS_FROM_BASE32: &[FunctionParam] = &[
920    FunctionParam { name: "this", required: true },
921];
922static PARAMS_FROM_BASE64: &[FunctionParam] = &[
923    FunctionParam { name: "this", required: true },
924];
925static PARAMS_FROM_ISO8601TIMESTAMP: &[FunctionParam] = &[
926    FunctionParam { name: "this", required: true },
927];
928static PARAMS_GAP_FILL: &[FunctionParam] = &[
929    FunctionParam { name: "this", required: true },
930    FunctionParam { name: "ts_column", required: true },
931    FunctionParam { name: "bucket_width", required: true },
932    FunctionParam { name: "partitioning_columns", required: false },
933    FunctionParam { name: "value_columns", required: false },
934    FunctionParam { name: "origin", required: false },
935    FunctionParam { name: "ignore_nulls", required: false },
936];
937static PARAMS_GENERATE_DATE_ARRAY: &[FunctionParam] = &[
938    FunctionParam { name: "start", required: true },
939    FunctionParam { name: "end", required: true },
940    FunctionParam { name: "step", required: false },
941];
942static PARAMS_GENERATE_EMBEDDING: &[FunctionParam] = &[
943    FunctionParam { name: "this", required: true },
944    FunctionParam { name: "expression", required: true },
945    FunctionParam { name: "params_struct", required: false },
946    FunctionParam { name: "is_text", required: false },
947];
948static PARAMS_GENERATE_SERIES: &[FunctionParam] = &[
949    FunctionParam { name: "start", required: true },
950    FunctionParam { name: "end", required: true },
951    FunctionParam { name: "step", required: false },
952    FunctionParam { name: "is_end_exclusive", required: false },
953];
954static PARAMS_GENERATE_TIMESTAMP_ARRAY: &[FunctionParam] = &[
955    FunctionParam { name: "start", required: true },
956    FunctionParam { name: "end", required: true },
957    FunctionParam { name: "step", required: true },
958];
959static PARAMS_UUID: &[FunctionParam] = &[
960    FunctionParam { name: "this", required: false },
961    FunctionParam { name: "name", required: false },
962    FunctionParam { name: "is_string", required: false },
963];
964static PARAMS_GETBIT: &[FunctionParam] = &[
965    FunctionParam { name: "this", required: true },
966    FunctionParam { name: "expression", required: true },
967];
968static PARAMS_GET_EXTRACT: &[FunctionParam] = &[
969    FunctionParam { name: "this", required: true },
970    FunctionParam { name: "expression", required: true },
971];
972static PARAMS_GREATEST: &[FunctionParam] = &[
973    FunctionParam { name: "this", required: true },
974    FunctionParam { name: "expressions", required: false },
975    FunctionParam { name: "null_if_any_null", required: false },
976];
977static PARAMS_GREATEST_IGNORE_NULLS: &[FunctionParam] = &[
978    FunctionParam { name: "expressions", required: true },
979];
980static PARAMS_GROUPING: &[FunctionParam] = &[
981    FunctionParam { name: "expressions", required: true },
982];
983static PARAMS_GROUPING_ID: &[FunctionParam] = &[
984    FunctionParam { name: "expressions", required: true },
985];
986static PARAMS_GROUP_CONCAT: &[FunctionParam] = &[
987    FunctionParam { name: "this", required: true },
988    FunctionParam { name: "separator", required: false },
989    FunctionParam { name: "on_overflow", required: false },
990];
991static PARAMS_HEX: &[FunctionParam] = &[
992    FunctionParam { name: "this", required: true },
993];
994static PARAMS_HEX_DECODE_STRING: &[FunctionParam] = &[
995    FunctionParam { name: "this", required: true },
996];
997static PARAMS_HEX_ENCODE: &[FunctionParam] = &[
998    FunctionParam { name: "this", required: true },
999    FunctionParam { name: "case", required: false },
1000];
1001static PARAMS_HLL: &[FunctionParam] = &[
1002    FunctionParam { name: "this", required: true },
1003    FunctionParam { name: "expressions", required: false },
1004];
1005static PARAMS_HOUR: &[FunctionParam] = &[
1006    FunctionParam { name: "this", required: true },
1007];
1008static PARAMS_IF: &[FunctionParam] = &[
1009    FunctionParam { name: "this", required: true },
1010    FunctionParam { name: "true", required: true },
1011    FunctionParam { name: "false", required: false },
1012];
1013static PARAMS_INITCAP: &[FunctionParam] = &[
1014    FunctionParam { name: "this", required: true },
1015    FunctionParam { name: "expression", required: false },
1016];
1017static PARAMS_INLINE: &[FunctionParam] = &[
1018    FunctionParam { name: "this", required: true },
1019];
1020static PARAMS_STUFF: &[FunctionParam] = &[
1021    FunctionParam { name: "this", required: true },
1022    FunctionParam { name: "start", required: true },
1023    FunctionParam { name: "length", required: true },
1024    FunctionParam { name: "expression", required: true },
1025];
1026static PARAMS_INT64: &[FunctionParam] = &[
1027    FunctionParam { name: "this", required: true },
1028];
1029static PARAMS_IS_INF: &[FunctionParam] = &[
1030    FunctionParam { name: "this", required: true },
1031];
1032static PARAMS_IS_NAN: &[FunctionParam] = &[
1033    FunctionParam { name: "this", required: true },
1034];
1035static PARAMS_IS_ASCII: &[FunctionParam] = &[
1036    FunctionParam { name: "this", required: true },
1037];
1038static PARAMS_IS_NULL_VALUE: &[FunctionParam] = &[
1039    FunctionParam { name: "this", required: true },
1040];
1041static PARAMS_JAROWINKLER_SIMILARITY: &[FunctionParam] = &[
1042    FunctionParam { name: "this", required: true },
1043    FunctionParam { name: "expression", required: true },
1044];
1045static PARAMS_JSONB_CONTAINS: &[FunctionParam] = &[
1046    FunctionParam { name: "this", required: true },
1047    FunctionParam { name: "expression", required: true },
1048];
1049static PARAMS_JSONB_EXISTS: &[FunctionParam] = &[
1050    FunctionParam { name: "this", required: true },
1051    FunctionParam { name: "path", required: true },
1052];
1053static PARAMS_JSONB_EXTRACT: &[FunctionParam] = &[
1054    FunctionParam { name: "this", required: true },
1055    FunctionParam { name: "expression", required: true },
1056];
1057static PARAMS_JSONB_EXTRACT_SCALAR: &[FunctionParam] = &[
1058    FunctionParam { name: "this", required: true },
1059    FunctionParam { name: "expression", required: true },
1060    FunctionParam { name: "json_type", required: false },
1061];
1062static PARAMS_JSON_ARRAY_APPEND: &[FunctionParam] = &[
1063    FunctionParam { name: "this", required: true },
1064    FunctionParam { name: "expressions", required: true },
1065];
1066static PARAMS_JSON_ARRAY_CONTAINS: &[FunctionParam] = &[
1067    FunctionParam { name: "this", required: true },
1068    FunctionParam { name: "expression", required: true },
1069    FunctionParam { name: "json_type", required: false },
1070];
1071static PARAMS_JSON_ARRAY_INSERT: &[FunctionParam] = &[
1072    FunctionParam { name: "this", required: true },
1073    FunctionParam { name: "expressions", required: true },
1074];
1075static PARAMS_JSON_EXTRACT: &[FunctionParam] = &[
1076    FunctionParam { name: "this", required: true },
1077    FunctionParam { name: "expression", required: true },
1078    FunctionParam { name: "only_json_types", required: false },
1079    FunctionParam { name: "expressions", required: false },
1080    FunctionParam { name: "variant_extract", required: false },
1081    FunctionParam { name: "json_query", required: false },
1082    FunctionParam { name: "option", required: false },
1083    FunctionParam { name: "quote", required: false },
1084    FunctionParam { name: "on_condition", required: false },
1085    FunctionParam { name: "requires_json", required: false },
1086];
1087static PARAMS_JSON_EXTRACT_ARRAY: &[FunctionParam] = &[
1088    FunctionParam { name: "this", required: true },
1089    FunctionParam { name: "expression", required: false },
1090];
1091static PARAMS_JSON_EXTRACT_SCALAR: &[FunctionParam] = &[
1092    FunctionParam { name: "this", required: true },
1093    FunctionParam { name: "expression", required: true },
1094    FunctionParam { name: "only_json_types", required: false },
1095    FunctionParam { name: "expressions", required: false },
1096    FunctionParam { name: "json_type", required: false },
1097    FunctionParam { name: "scalar_only", required: false },
1098];
1099static PARAMS_JSON_FORMAT: &[FunctionParam] = &[
1100    FunctionParam { name: "this", required: false },
1101    FunctionParam { name: "options", required: false },
1102    FunctionParam { name: "is_json", required: false },
1103    FunctionParam { name: "to_json", required: false },
1104];
1105static PARAMS_PARSE_JSON: &[FunctionParam] = &[
1106    FunctionParam { name: "this", required: true },
1107    FunctionParam { name: "expression", required: false },
1108    FunctionParam { name: "safe", required: false },
1109];
1110static PARAMS_JSON_REMOVE: &[FunctionParam] = &[
1111    FunctionParam { name: "this", required: true },
1112    FunctionParam { name: "expressions", required: true },
1113];
1114static PARAMS_JSON_SET: &[FunctionParam] = &[
1115    FunctionParam { name: "this", required: true },
1116    FunctionParam { name: "expressions", required: true },
1117];
1118static PARAMS_JSON_STRIP_NULLS: &[FunctionParam] = &[
1119    FunctionParam { name: "this", required: true },
1120    FunctionParam { name: "expression", required: false },
1121    FunctionParam { name: "include_arrays", required: false },
1122    FunctionParam { name: "remove_empty", required: false },
1123];
1124static PARAMS_JSON_TYPE: &[FunctionParam] = &[
1125    FunctionParam { name: "this", required: true },
1126    FunctionParam { name: "expression", required: false },
1127];
1128static PARAMS_JUSTIFY_DAYS: &[FunctionParam] = &[
1129    FunctionParam { name: "this", required: true },
1130];
1131static PARAMS_JUSTIFY_HOURS: &[FunctionParam] = &[
1132    FunctionParam { name: "this", required: true },
1133];
1134static PARAMS_JUSTIFY_INTERVAL: &[FunctionParam] = &[
1135    FunctionParam { name: "this", required: true },
1136];
1137static PARAMS_JSON_ARRAY: &[FunctionParam] = &[
1138    FunctionParam { name: "expressions", required: false },
1139    FunctionParam { name: "null_handling", required: false },
1140    FunctionParam { name: "return_type", required: false },
1141    FunctionParam { name: "strict", required: false },
1142];
1143static PARAMS_JSON_ARRAY_AGG: &[FunctionParam] = &[
1144    FunctionParam { name: "this", required: true },
1145    FunctionParam { name: "order", required: false },
1146    FunctionParam { name: "null_handling", required: false },
1147    FunctionParam { name: "return_type", required: false },
1148    FunctionParam { name: "strict", required: false },
1149];
1150static PARAMS_JSON_BOOL: &[FunctionParam] = &[
1151    FunctionParam { name: "this", required: true },
1152];
1153static PARAMS_JSONB_CONTAINS_ALL_TOP_KEYS: &[FunctionParam] = &[
1154    FunctionParam { name: "this", required: true },
1155    FunctionParam { name: "expression", required: true },
1156];
1157static PARAMS_JSONB_CONTAINS_ANY_TOP_KEYS: &[FunctionParam] = &[
1158    FunctionParam { name: "this", required: true },
1159    FunctionParam { name: "expression", required: true },
1160];
1161static PARAMS_JSONB_DELETE_AT_PATH: &[FunctionParam] = &[
1162    FunctionParam { name: "this", required: true },
1163    FunctionParam { name: "expression", required: true },
1164];
1165static PARAMS_JSONB_OBJECT_AGG: &[FunctionParam] = &[
1166    FunctionParam { name: "this", required: true },
1167    FunctionParam { name: "expression", required: true },
1168];
1169static PARAMS_JSON_CAST: &[FunctionParam] = &[
1170    FunctionParam { name: "this", required: true },
1171    FunctionParam { name: "to", required: true },
1172    FunctionParam { name: "format", required: false },
1173    FunctionParam { name: "safe", required: false },
1174    FunctionParam { name: "action", required: false },
1175    FunctionParam { name: "default", required: false },
1176];
1177static PARAMS_JSON_EXISTS: &[FunctionParam] = &[
1178    FunctionParam { name: "this", required: true },
1179    FunctionParam { name: "path", required: true },
1180    FunctionParam { name: "passing", required: false },
1181    FunctionParam { name: "on_condition", required: false },
1182];
1183static PARAMS_JSON_KEYS_AT_DEPTH: &[FunctionParam] = &[
1184    FunctionParam { name: "this", required: true },
1185    FunctionParam { name: "expression", required: false },
1186    FunctionParam { name: "mode", required: false },
1187];
1188static PARAMS_JSON_OBJECT: &[FunctionParam] = &[
1189    FunctionParam { name: "expressions", required: false },
1190    FunctionParam { name: "null_handling", required: false },
1191    FunctionParam { name: "unique_keys", required: false },
1192    FunctionParam { name: "return_type", required: false },
1193    FunctionParam { name: "encoding", required: false },
1194];
1195static PARAMS_JSON_OBJECT_AGG: &[FunctionParam] = &[
1196    FunctionParam { name: "expressions", required: false },
1197    FunctionParam { name: "null_handling", required: false },
1198    FunctionParam { name: "unique_keys", required: false },
1199    FunctionParam { name: "return_type", required: false },
1200    FunctionParam { name: "encoding", required: false },
1201];
1202static PARAMS_JSON_TABLE: &[FunctionParam] = &[
1203    FunctionParam { name: "this", required: true },
1204    FunctionParam { name: "schema", required: true },
1205    FunctionParam { name: "path", required: false },
1206    FunctionParam { name: "error_handling", required: false },
1207    FunctionParam { name: "empty_handling", required: false },
1208];
1209static PARAMS_JSON_VALUE_ARRAY: &[FunctionParam] = &[
1210    FunctionParam { name: "this", required: true },
1211    FunctionParam { name: "expression", required: false },
1212];
1213static PARAMS_LAG: &[FunctionParam] = &[
1214    FunctionParam { name: "this", required: true },
1215    FunctionParam { name: "offset", required: false },
1216    FunctionParam { name: "default", required: false },
1217];
1218static PARAMS_LAST: &[FunctionParam] = &[
1219    FunctionParam { name: "this", required: true },
1220    FunctionParam { name: "expression", required: false },
1221];
1222static PARAMS_LAST_DAY: &[FunctionParam] = &[
1223    FunctionParam { name: "this", required: true },
1224    FunctionParam { name: "unit", required: false },
1225];
1226static PARAMS_LAST_VALUE: &[FunctionParam] = &[
1227    FunctionParam { name: "this", required: true },
1228];
1229static PARAMS_LAX_BOOL: &[FunctionParam] = &[
1230    FunctionParam { name: "this", required: true },
1231];
1232static PARAMS_LAX_FLOAT64: &[FunctionParam] = &[
1233    FunctionParam { name: "this", required: true },
1234];
1235static PARAMS_LAX_INT64: &[FunctionParam] = &[
1236    FunctionParam { name: "this", required: true },
1237];
1238static PARAMS_LAX_STRING: &[FunctionParam] = &[
1239    FunctionParam { name: "this", required: true },
1240];
1241static PARAMS_LOWER: &[FunctionParam] = &[
1242    FunctionParam { name: "this", required: true },
1243];
1244static PARAMS_LEAD: &[FunctionParam] = &[
1245    FunctionParam { name: "this", required: true },
1246    FunctionParam { name: "offset", required: false },
1247    FunctionParam { name: "default", required: false },
1248];
1249static PARAMS_LEAST: &[FunctionParam] = &[
1250    FunctionParam { name: "this", required: true },
1251    FunctionParam { name: "expressions", required: false },
1252    FunctionParam { name: "null_if_any_null", required: false },
1253];
1254static PARAMS_LEAST_IGNORE_NULLS: &[FunctionParam] = &[
1255    FunctionParam { name: "expressions", required: true },
1256];
1257static PARAMS_LEFT: &[FunctionParam] = &[
1258    FunctionParam { name: "this", required: true },
1259    FunctionParam { name: "expression", required: true },
1260];
1261static PARAMS_LEVENSHTEIN: &[FunctionParam] = &[
1262    FunctionParam { name: "this", required: true },
1263    FunctionParam { name: "expression", required: false },
1264    FunctionParam { name: "ins_cost", required: false },
1265    FunctionParam { name: "del_cost", required: false },
1266    FunctionParam { name: "sub_cost", required: false },
1267    FunctionParam { name: "max_dist", required: false },
1268];
1269static PARAMS_LIST: &[FunctionParam] = &[
1270    FunctionParam { name: "expressions", required: false },
1271];
1272static PARAMS_LN: &[FunctionParam] = &[
1273    FunctionParam { name: "this", required: true },
1274];
1275static PARAMS_LOG: &[FunctionParam] = &[
1276    FunctionParam { name: "this", required: true },
1277    FunctionParam { name: "expression", required: false },
1278];
1279static PARAMS_LOWER_HEX: &[FunctionParam] = &[
1280    FunctionParam { name: "this", required: true },
1281];
1282static PARAMS_MAKE_INTERVAL: &[FunctionParam] = &[
1283    FunctionParam { name: "year", required: false },
1284    FunctionParam { name: "month", required: false },
1285    FunctionParam { name: "day", required: false },
1286    FunctionParam { name: "hour", required: false },
1287    FunctionParam { name: "minute", required: false },
1288    FunctionParam { name: "second", required: false },
1289];
1290static PARAMS_MAP: &[FunctionParam] = &[
1291    FunctionParam { name: "keys", required: false },
1292    FunctionParam { name: "values", required: false },
1293];
1294static PARAMS_MAP_FROM_ENTRIES: &[FunctionParam] = &[
1295    FunctionParam { name: "this", required: true },
1296];
1297static PARAMS_MATCH_AGAINST: &[FunctionParam] = &[
1298    FunctionParam { name: "this", required: true },
1299    FunctionParam { name: "expressions", required: true },
1300    FunctionParam { name: "modifier", required: false },
1301];
1302static PARAMS_MAX: &[FunctionParam] = &[
1303    FunctionParam { name: "this", required: true },
1304    FunctionParam { name: "expressions", required: false },
1305];
1306static PARAMS_MD5: &[FunctionParam] = &[
1307    FunctionParam { name: "this", required: true },
1308];
1309static PARAMS_MD5DIGEST: &[FunctionParam] = &[
1310    FunctionParam { name: "this", required: true },
1311];
1312static PARAMS_MEDIAN: &[FunctionParam] = &[
1313    FunctionParam { name: "this", required: true },
1314];
1315static PARAMS_MIN: &[FunctionParam] = &[
1316    FunctionParam { name: "this", required: true },
1317    FunctionParam { name: "expressions", required: false },
1318];
1319static PARAMS_MINHASH: &[FunctionParam] = &[
1320    FunctionParam { name: "this", required: true },
1321    FunctionParam { name: "expressions", required: true },
1322];
1323static PARAMS_MINHASH_COMBINE: &[FunctionParam] = &[
1324    FunctionParam { name: "this", required: true },
1325];
1326static PARAMS_MINUTE: &[FunctionParam] = &[
1327    FunctionParam { name: "this", required: true },
1328];
1329static PARAMS_MONTH: &[FunctionParam] = &[
1330    FunctionParam { name: "this", required: true },
1331];
1332static PARAMS_MONTHNAME: &[FunctionParam] = &[
1333    FunctionParam { name: "this", required: true },
1334];
1335static PARAMS_MONTHS_BETWEEN: &[FunctionParam] = &[
1336    FunctionParam { name: "this", required: true },
1337    FunctionParam { name: "expression", required: true },
1338    FunctionParam { name: "roundoff", required: false },
1339];
1340static PARAMS_MD5NUMBER_LOWER64: &[FunctionParam] = &[
1341    FunctionParam { name: "this", required: true },
1342];
1343static PARAMS_MD5NUMBER_UPPER64: &[FunctionParam] = &[
1344    FunctionParam { name: "this", required: true },
1345];
1346static PARAMS_ML_FORECAST: &[FunctionParam] = &[
1347    FunctionParam { name: "this", required: true },
1348    FunctionParam { name: "expression", required: false },
1349    FunctionParam { name: "params_struct", required: false },
1350];
1351static PARAMS_ML_TRANSLATE: &[FunctionParam] = &[
1352    FunctionParam { name: "this", required: true },
1353    FunctionParam { name: "expression", required: true },
1354    FunctionParam { name: "params_struct", required: true },
1355];
1356static PARAMS_NEXT_DAY: &[FunctionParam] = &[
1357    FunctionParam { name: "this", required: true },
1358    FunctionParam { name: "expression", required: true },
1359];
1360static PARAMS_NEXT_VALUE_FOR: &[FunctionParam] = &[
1361    FunctionParam { name: "this", required: true },
1362    FunctionParam { name: "order", required: false },
1363];
1364static PARAMS_NORMALIZE: &[FunctionParam] = &[
1365    FunctionParam { name: "this", required: true },
1366    FunctionParam { name: "form", required: false },
1367    FunctionParam { name: "is_casefold", required: false },
1368];
1369static PARAMS_NTH_VALUE: &[FunctionParam] = &[
1370    FunctionParam { name: "this", required: true },
1371    FunctionParam { name: "offset", required: true },
1372];
1373static PARAMS_NTILE: &[FunctionParam] = &[
1374    FunctionParam { name: "this", required: false },
1375];
1376static PARAMS_NULLIF: &[FunctionParam] = &[
1377    FunctionParam { name: "this", required: true },
1378    FunctionParam { name: "expression", required: true },
1379];
1380static PARAMS_NUMBER_TO_STR: &[FunctionParam] = &[
1381    FunctionParam { name: "this", required: true },
1382    FunctionParam { name: "format", required: true },
1383    FunctionParam { name: "culture", required: false },
1384];
1385static PARAMS_NVL2: &[FunctionParam] = &[
1386    FunctionParam { name: "this", required: true },
1387    FunctionParam { name: "true", required: true },
1388    FunctionParam { name: "false", required: false },
1389];
1390static PARAMS_OBJECT_AGG: &[FunctionParam] = &[
1391    FunctionParam { name: "this", required: true },
1392    FunctionParam { name: "expression", required: true },
1393];
1394static PARAMS_OBJECT_INSERT: &[FunctionParam] = &[
1395    FunctionParam { name: "this", required: true },
1396    FunctionParam { name: "key", required: true },
1397    FunctionParam { name: "value", required: true },
1398    FunctionParam { name: "update_flag", required: false },
1399];
1400static PARAMS_OPEN_JSON: &[FunctionParam] = &[
1401    FunctionParam { name: "this", required: true },
1402    FunctionParam { name: "path", required: false },
1403    FunctionParam { name: "expressions", required: false },
1404];
1405static PARAMS_OR: &[FunctionParam] = &[
1406    FunctionParam { name: "this", required: true },
1407    FunctionParam { name: "expression", required: true },
1408];
1409static PARAMS_OVERLAY: &[FunctionParam] = &[
1410    FunctionParam { name: "this", required: true },
1411    FunctionParam { name: "expression", required: true },
1412    FunctionParam { name: "from_", required: true },
1413    FunctionParam { name: "for_", required: false },
1414];
1415static PARAMS_PAD: &[FunctionParam] = &[
1416    FunctionParam { name: "this", required: true },
1417    FunctionParam { name: "expression", required: true },
1418    FunctionParam { name: "fill_pattern", required: false },
1419    FunctionParam { name: "is_left", required: true },
1420];
1421static PARAMS_PARAMETERIZED_AGG: &[FunctionParam] = &[
1422    FunctionParam { name: "this", required: true },
1423    FunctionParam { name: "expressions", required: true },
1424    FunctionParam { name: "params", required: true },
1425];
1426static PARAMS_PARSE_BIGNUMERIC: &[FunctionParam] = &[
1427    FunctionParam { name: "this", required: true },
1428];
1429static PARAMS_PARSE_DATETIME: &[FunctionParam] = &[
1430    FunctionParam { name: "this", required: true },
1431    FunctionParam { name: "format", required: false },
1432    FunctionParam { name: "zone", required: false },
1433];
1434static PARAMS_PARSE_IP: &[FunctionParam] = &[
1435    FunctionParam { name: "this", required: true },
1436    FunctionParam { name: "type", required: true },
1437    FunctionParam { name: "permissive", required: false },
1438];
1439static PARAMS_PARSE_NUMERIC: &[FunctionParam] = &[
1440    FunctionParam { name: "this", required: true },
1441];
1442static PARAMS_PARSE_TIME: &[FunctionParam] = &[
1443    FunctionParam { name: "this", required: true },
1444    FunctionParam { name: "format", required: true },
1445];
1446static PARAMS_PARSE_URL: &[FunctionParam] = &[
1447    FunctionParam { name: "this", required: true },
1448    FunctionParam { name: "part_to_extract", required: false },
1449    FunctionParam { name: "key", required: false },
1450    FunctionParam { name: "permissive", required: false },
1451];
1452static PARAMS_PERCENTILE_CONT: &[FunctionParam] = &[
1453    FunctionParam { name: "this", required: true },
1454    FunctionParam { name: "expression", required: false },
1455];
1456static PARAMS_PERCENTILE_DISC: &[FunctionParam] = &[
1457    FunctionParam { name: "this", required: true },
1458    FunctionParam { name: "expression", required: false },
1459];
1460static PARAMS_PERCENT_RANK: &[FunctionParam] = &[
1461    FunctionParam { name: "expressions", required: false },
1462];
1463static PARAMS_POSEXPLODE: &[FunctionParam] = &[
1464    FunctionParam { name: "this", required: true },
1465    FunctionParam { name: "expressions", required: false },
1466];
1467static PARAMS_POSEXPLODE_OUTER: &[FunctionParam] = &[
1468    FunctionParam { name: "this", required: true },
1469    FunctionParam { name: "expressions", required: false },
1470];
1471static PARAMS_POW: &[FunctionParam] = &[
1472    FunctionParam { name: "this", required: true },
1473    FunctionParam { name: "expression", required: true },
1474];
1475static PARAMS_PREDICT: &[FunctionParam] = &[
1476    FunctionParam { name: "this", required: true },
1477    FunctionParam { name: "expression", required: true },
1478    FunctionParam { name: "params_struct", required: false },
1479];
1480static PARAMS_PREVIOUS_DAY: &[FunctionParam] = &[
1481    FunctionParam { name: "this", required: true },
1482    FunctionParam { name: "expression", required: true },
1483];
1484static PARAMS_QUANTILE: &[FunctionParam] = &[
1485    FunctionParam { name: "this", required: true },
1486    FunctionParam { name: "quantile", required: true },
1487];
1488static PARAMS_QUARTER: &[FunctionParam] = &[
1489    FunctionParam { name: "this", required: true },
1490];
1491static PARAMS_RADIANS: &[FunctionParam] = &[
1492    FunctionParam { name: "this", required: true },
1493];
1494static PARAMS_RAND: &[FunctionParam] = &[
1495    FunctionParam { name: "this", required: false },
1496    FunctionParam { name: "lower", required: false },
1497    FunctionParam { name: "upper", required: false },
1498];
1499static PARAMS_RANDN: &[FunctionParam] = &[
1500    FunctionParam { name: "this", required: false },
1501];
1502static PARAMS_RANGE_BUCKET: &[FunctionParam] = &[
1503    FunctionParam { name: "this", required: true },
1504    FunctionParam { name: "expression", required: true },
1505];
1506static PARAMS_RANGE_N: &[FunctionParam] = &[
1507    FunctionParam { name: "this", required: true },
1508    FunctionParam { name: "expressions", required: true },
1509    FunctionParam { name: "each", required: false },
1510];
1511static PARAMS_RANK: &[FunctionParam] = &[
1512    FunctionParam { name: "expressions", required: false },
1513];
1514static PARAMS_READ_CSV: &[FunctionParam] = &[
1515    FunctionParam { name: "this", required: true },
1516    FunctionParam { name: "expressions", required: false },
1517];
1518static PARAMS_READ_PARQUET: &[FunctionParam] = &[
1519    FunctionParam { name: "expressions", required: true },
1520];
1521static PARAMS_REDUCE: &[FunctionParam] = &[
1522    FunctionParam { name: "this", required: true },
1523    FunctionParam { name: "initial", required: true },
1524    FunctionParam { name: "merge", required: true },
1525    FunctionParam { name: "finish", required: false },
1526];
1527static PARAMS_REGEXP_COUNT: &[FunctionParam] = &[
1528    FunctionParam { name: "this", required: true },
1529    FunctionParam { name: "expression", required: true },
1530    FunctionParam { name: "position", required: false },
1531    FunctionParam { name: "parameters", required: false },
1532];
1533static PARAMS_REGEXP_EXTRACT: &[FunctionParam] = &[
1534    FunctionParam { name: "this", required: true },
1535    FunctionParam { name: "expression", required: true },
1536    FunctionParam { name: "position", required: false },
1537    FunctionParam { name: "occurrence", required: false },
1538    FunctionParam { name: "parameters", required: false },
1539    FunctionParam { name: "group", required: false },
1540];
1541static PARAMS_REGEXP_EXTRACT_ALL: &[FunctionParam] = &[
1542    FunctionParam { name: "this", required: true },
1543    FunctionParam { name: "expression", required: true },
1544    FunctionParam { name: "group", required: false },
1545    FunctionParam { name: "parameters", required: false },
1546    FunctionParam { name: "position", required: false },
1547    FunctionParam { name: "occurrence", required: false },
1548];
1549static PARAMS_REGEXP_FULL_MATCH: &[FunctionParam] = &[
1550    FunctionParam { name: "this", required: true },
1551    FunctionParam { name: "expression", required: true },
1552    FunctionParam { name: "options", required: false },
1553];
1554static PARAMS_REGEXP_INSTR: &[FunctionParam] = &[
1555    FunctionParam { name: "this", required: true },
1556    FunctionParam { name: "expression", required: true },
1557    FunctionParam { name: "position", required: false },
1558    FunctionParam { name: "occurrence", required: false },
1559    FunctionParam { name: "option", required: false },
1560    FunctionParam { name: "parameters", required: false },
1561    FunctionParam { name: "group", required: false },
1562];
1563static PARAMS_REGEXP_I_LIKE: &[FunctionParam] = &[
1564    FunctionParam { name: "this", required: true },
1565    FunctionParam { name: "expression", required: true },
1566    FunctionParam { name: "flag", required: false },
1567];
1568static PARAMS_REGEXP_LIKE: &[FunctionParam] = &[
1569    FunctionParam { name: "this", required: true },
1570    FunctionParam { name: "expression", required: true },
1571    FunctionParam { name: "flag", required: false },
1572];
1573static PARAMS_REGEXP_REPLACE: &[FunctionParam] = &[
1574    FunctionParam { name: "this", required: true },
1575    FunctionParam { name: "expression", required: true },
1576    FunctionParam { name: "replacement", required: false },
1577    FunctionParam { name: "position", required: false },
1578    FunctionParam { name: "occurrence", required: false },
1579    FunctionParam { name: "modifiers", required: false },
1580    FunctionParam { name: "single_replace", required: false },
1581];
1582static PARAMS_REGEXP_SPLIT: &[FunctionParam] = &[
1583    FunctionParam { name: "this", required: true },
1584    FunctionParam { name: "expression", required: true },
1585    FunctionParam { name: "limit", required: false },
1586];
1587static PARAMS_REGR_AVGX: &[FunctionParam] = &[
1588    FunctionParam { name: "this", required: true },
1589    FunctionParam { name: "expression", required: true },
1590];
1591static PARAMS_REGR_AVGY: &[FunctionParam] = &[
1592    FunctionParam { name: "this", required: true },
1593    FunctionParam { name: "expression", required: true },
1594];
1595static PARAMS_REGR_VALX: &[FunctionParam] = &[
1596    FunctionParam { name: "this", required: true },
1597    FunctionParam { name: "expression", required: true },
1598];
1599static PARAMS_REGR_VALY: &[FunctionParam] = &[
1600    FunctionParam { name: "this", required: true },
1601    FunctionParam { name: "expression", required: true },
1602];
1603static PARAMS_REPEAT: &[FunctionParam] = &[
1604    FunctionParam { name: "this", required: true },
1605    FunctionParam { name: "times", required: true },
1606];
1607static PARAMS_REPLACE: &[FunctionParam] = &[
1608    FunctionParam { name: "this", required: true },
1609    FunctionParam { name: "expression", required: true },
1610    FunctionParam { name: "replacement", required: false },
1611];
1612static PARAMS_REVERSE: &[FunctionParam] = &[
1613    FunctionParam { name: "this", required: true },
1614];
1615static PARAMS_RIGHT: &[FunctionParam] = &[
1616    FunctionParam { name: "this", required: true },
1617    FunctionParam { name: "expression", required: true },
1618];
1619static PARAMS_ROUND: &[FunctionParam] = &[
1620    FunctionParam { name: "this", required: true },
1621    FunctionParam { name: "decimals", required: false },
1622    FunctionParam { name: "truncate", required: false },
1623];
1624static PARAMS_ROW_NUMBER: &[FunctionParam] = &[
1625    FunctionParam { name: "this", required: false },
1626];
1627static PARAMS_RTRIMMED_LENGTH: &[FunctionParam] = &[
1628    FunctionParam { name: "this", required: true },
1629];
1630static PARAMS_SAFE_ADD: &[FunctionParam] = &[
1631    FunctionParam { name: "this", required: true },
1632    FunctionParam { name: "expression", required: true },
1633];
1634static PARAMS_SAFE_CONVERT_BYTES_TO_STRING: &[FunctionParam] = &[
1635    FunctionParam { name: "this", required: true },
1636];
1637static PARAMS_SAFE_DIVIDE: &[FunctionParam] = &[
1638    FunctionParam { name: "this", required: true },
1639    FunctionParam { name: "expression", required: true },
1640];
1641static PARAMS_SAFE_MULTIPLY: &[FunctionParam] = &[
1642    FunctionParam { name: "this", required: true },
1643    FunctionParam { name: "expression", required: true },
1644];
1645static PARAMS_SAFE_NEGATE: &[FunctionParam] = &[
1646    FunctionParam { name: "this", required: true },
1647];
1648static PARAMS_SAFE_SUBTRACT: &[FunctionParam] = &[
1649    FunctionParam { name: "this", required: true },
1650    FunctionParam { name: "expression", required: true },
1651];
1652static PARAMS_SEARCH: &[FunctionParam] = &[
1653    FunctionParam { name: "this", required: true },
1654    FunctionParam { name: "expression", required: true },
1655    FunctionParam { name: "json_scope", required: false },
1656    FunctionParam { name: "analyzer", required: false },
1657    FunctionParam { name: "analyzer_options", required: false },
1658    FunctionParam { name: "search_mode", required: false },
1659];
1660static PARAMS_SEC: &[FunctionParam] = &[
1661    FunctionParam { name: "this", required: true },
1662];
1663static PARAMS_SECH: &[FunctionParam] = &[
1664    FunctionParam { name: "this", required: true },
1665];
1666static PARAMS_SECOND: &[FunctionParam] = &[
1667    FunctionParam { name: "this", required: true },
1668];
1669static PARAMS_SHA: &[FunctionParam] = &[
1670    FunctionParam { name: "this", required: true },
1671];
1672static PARAMS_SHA2: &[FunctionParam] = &[
1673    FunctionParam { name: "this", required: true },
1674    FunctionParam { name: "length", required: false },
1675];
1676static PARAMS_SIGN: &[FunctionParam] = &[
1677    FunctionParam { name: "this", required: true },
1678];
1679static PARAMS_SIN: &[FunctionParam] = &[
1680    FunctionParam { name: "this", required: true },
1681];
1682static PARAMS_SINH: &[FunctionParam] = &[
1683    FunctionParam { name: "this", required: true },
1684];
1685static PARAMS_SKEWNESS: &[FunctionParam] = &[
1686    FunctionParam { name: "this", required: true },
1687];
1688static PARAMS_SORT_ARRAY: &[FunctionParam] = &[
1689    FunctionParam { name: "this", required: true },
1690    FunctionParam { name: "asc", required: false },
1691    FunctionParam { name: "nulls_first", required: false },
1692];
1693static PARAMS_SOUNDEX: &[FunctionParam] = &[
1694    FunctionParam { name: "this", required: true },
1695];
1696static PARAMS_SOUNDEX_P123: &[FunctionParam] = &[
1697    FunctionParam { name: "this", required: true },
1698];
1699static PARAMS_SPACE: &[FunctionParam] = &[
1700    FunctionParam { name: "this", required: true },
1701];
1702static PARAMS_SPLIT: &[FunctionParam] = &[
1703    FunctionParam { name: "this", required: true },
1704    FunctionParam { name: "expression", required: true },
1705    FunctionParam { name: "limit", required: false },
1706];
1707static PARAMS_STRING_TO_ARRAY: &[FunctionParam] = &[
1708    FunctionParam { name: "this", required: true },
1709    FunctionParam { name: "expression", required: false },
1710    FunctionParam { name: "null", required: false },
1711];
1712static PARAMS_SPLIT_PART: &[FunctionParam] = &[
1713    FunctionParam { name: "this", required: true },
1714    FunctionParam { name: "delimiter", required: false },
1715    FunctionParam { name: "part_index", required: false },
1716];
1717static PARAMS_SQRT: &[FunctionParam] = &[
1718    FunctionParam { name: "this", required: true },
1719];
1720static PARAMS_STANDARD_HASH: &[FunctionParam] = &[
1721    FunctionParam { name: "this", required: true },
1722    FunctionParam { name: "expression", required: false },
1723];
1724static PARAMS_STARTS_WITH: &[FunctionParam] = &[
1725    FunctionParam { name: "this", required: true },
1726    FunctionParam { name: "expression", required: true },
1727];
1728static PARAMS_STAR_MAP: &[FunctionParam] = &[
1729    FunctionParam { name: "this", required: true },
1730];
1731static PARAMS_STDDEV: &[FunctionParam] = &[
1732    FunctionParam { name: "this", required: true },
1733];
1734static PARAMS_STDDEV_POP: &[FunctionParam] = &[
1735    FunctionParam { name: "this", required: true },
1736];
1737static PARAMS_STDDEV_SAMP: &[FunctionParam] = &[
1738    FunctionParam { name: "this", required: true },
1739];
1740static PARAMS_STRING: &[FunctionParam] = &[
1741    FunctionParam { name: "this", required: true },
1742    FunctionParam { name: "zone", required: false },
1743];
1744static PARAMS_STRUCT: &[FunctionParam] = &[
1745    FunctionParam { name: "expressions", required: false },
1746];
1747static PARAMS_STRUCT_EXTRACT: &[FunctionParam] = &[
1748    FunctionParam { name: "this", required: true },
1749    FunctionParam { name: "expression", required: true },
1750];
1751static PARAMS_STR_POSITION: &[FunctionParam] = &[
1752    FunctionParam { name: "this", required: true },
1753    FunctionParam { name: "substr", required: true },
1754    FunctionParam { name: "position", required: false },
1755    FunctionParam { name: "occurrence", required: false },
1756];
1757static PARAMS_STR_TO_DATE: &[FunctionParam] = &[
1758    FunctionParam { name: "this", required: true },
1759    FunctionParam { name: "format", required: false },
1760    FunctionParam { name: "safe", required: false },
1761];
1762static PARAMS_STR_TO_MAP: &[FunctionParam] = &[
1763    FunctionParam { name: "this", required: true },
1764    FunctionParam { name: "pair_delim", required: false },
1765    FunctionParam { name: "key_value_delim", required: false },
1766    FunctionParam { name: "duplicate_resolution_callback", required: false },
1767];
1768static PARAMS_STR_TO_TIME: &[FunctionParam] = &[
1769    FunctionParam { name: "this", required: true },
1770    FunctionParam { name: "format", required: true },
1771    FunctionParam { name: "zone", required: false },
1772    FunctionParam { name: "safe", required: false },
1773];
1774static PARAMS_STR_TO_UNIX: &[FunctionParam] = &[
1775    FunctionParam { name: "this", required: false },
1776    FunctionParam { name: "format", required: false },
1777];
1778static PARAMS_ST_DISTANCE: &[FunctionParam] = &[
1779    FunctionParam { name: "this", required: true },
1780    FunctionParam { name: "expression", required: true },
1781    FunctionParam { name: "use_spheroid", required: false },
1782];
1783static PARAMS_ST_POINT: &[FunctionParam] = &[
1784    FunctionParam { name: "this", required: true },
1785    FunctionParam { name: "expression", required: true },
1786    FunctionParam { name: "null", required: false },
1787];
1788static PARAMS_SUBSTRING: &[FunctionParam] = &[
1789    FunctionParam { name: "this", required: true },
1790    FunctionParam { name: "start", required: false },
1791    FunctionParam { name: "length", required: false },
1792];
1793static PARAMS_SUBSTRING_INDEX: &[FunctionParam] = &[
1794    FunctionParam { name: "this", required: true },
1795    FunctionParam { name: "delimiter", required: true },
1796    FunctionParam { name: "count", required: true },
1797];
1798static PARAMS_SUM: &[FunctionParam] = &[
1799    FunctionParam { name: "this", required: true },
1800];
1801static PARAMS_SHA1DIGEST: &[FunctionParam] = &[
1802    FunctionParam { name: "this", required: true },
1803];
1804static PARAMS_SHA2DIGEST: &[FunctionParam] = &[
1805    FunctionParam { name: "this", required: true },
1806    FunctionParam { name: "length", required: false },
1807];
1808static PARAMS_TAN: &[FunctionParam] = &[
1809    FunctionParam { name: "this", required: true },
1810];
1811static PARAMS_TANH: &[FunctionParam] = &[
1812    FunctionParam { name: "this", required: true },
1813];
1814static PARAMS_TIME: &[FunctionParam] = &[
1815    FunctionParam { name: "this", required: false },
1816    FunctionParam { name: "zone", required: false },
1817];
1818static PARAMS_TIME_FROM_PARTS: &[FunctionParam] = &[
1819    FunctionParam { name: "hour", required: true },
1820    FunctionParam { name: "min", required: true },
1821    FunctionParam { name: "sec", required: true },
1822    FunctionParam { name: "nano", required: false },
1823    FunctionParam { name: "fractions", required: false },
1824    FunctionParam { name: "precision", required: false },
1825];
1826static PARAMS_TIMESTAMP: &[FunctionParam] = &[
1827    FunctionParam { name: "this", required: false },
1828    FunctionParam { name: "zone", required: false },
1829    FunctionParam { name: "with_tz", required: false },
1830];
1831static PARAMS_TIMESTAMP_DIFF: &[FunctionParam] = &[
1832    FunctionParam { name: "this", required: true },
1833    FunctionParam { name: "expression", required: true },
1834    FunctionParam { name: "unit", required: false },
1835];
1836static PARAMS_TIMESTAMP_FROM_PARTS: &[FunctionParam] = &[
1837    FunctionParam { name: "year", required: false },
1838    FunctionParam { name: "month", required: false },
1839    FunctionParam { name: "day", required: false },
1840    FunctionParam { name: "hour", required: false },
1841    FunctionParam { name: "min", required: false },
1842    FunctionParam { name: "sec", required: false },
1843    FunctionParam { name: "nano", required: false },
1844    FunctionParam { name: "zone", required: false },
1845    FunctionParam { name: "milli", required: false },
1846    FunctionParam { name: "this", required: false },
1847    FunctionParam { name: "expression", required: false },
1848];
1849static PARAMS_TIMESTAMP_LTZ_FROM_PARTS: &[FunctionParam] = &[
1850    FunctionParam { name: "year", required: false },
1851    FunctionParam { name: "month", required: false },
1852    FunctionParam { name: "day", required: false },
1853    FunctionParam { name: "hour", required: false },
1854    FunctionParam { name: "min", required: false },
1855    FunctionParam { name: "sec", required: false },
1856    FunctionParam { name: "nano", required: false },
1857];
1858static PARAMS_TIMESTAMP_TZ_FROM_PARTS: &[FunctionParam] = &[
1859    FunctionParam { name: "year", required: false },
1860    FunctionParam { name: "month", required: false },
1861    FunctionParam { name: "day", required: false },
1862    FunctionParam { name: "hour", required: false },
1863    FunctionParam { name: "min", required: false },
1864    FunctionParam { name: "sec", required: false },
1865    FunctionParam { name: "nano", required: false },
1866    FunctionParam { name: "zone", required: false },
1867];
1868static PARAMS_TIMESTAMP_ADD: &[FunctionParam] = &[
1869    FunctionParam { name: "this", required: true },
1870    FunctionParam { name: "expression", required: true },
1871    FunctionParam { name: "unit", required: false },
1872];
1873static PARAMS_TIMESTAMP_SUB: &[FunctionParam] = &[
1874    FunctionParam { name: "this", required: true },
1875    FunctionParam { name: "expression", required: true },
1876    FunctionParam { name: "unit", required: false },
1877];
1878static PARAMS_TIMESTAMP_TRUNC: &[FunctionParam] = &[
1879    FunctionParam { name: "this", required: true },
1880    FunctionParam { name: "unit", required: true },
1881    FunctionParam { name: "zone", required: false },
1882];
1883static PARAMS_TIME_ADD: &[FunctionParam] = &[
1884    FunctionParam { name: "this", required: true },
1885    FunctionParam { name: "expression", required: true },
1886    FunctionParam { name: "unit", required: false },
1887];
1888static PARAMS_TIME_DIFF: &[FunctionParam] = &[
1889    FunctionParam { name: "this", required: true },
1890    FunctionParam { name: "expression", required: true },
1891    FunctionParam { name: "unit", required: false },
1892];
1893static PARAMS_TIME_SLICE: &[FunctionParam] = &[
1894    FunctionParam { name: "this", required: true },
1895    FunctionParam { name: "expression", required: true },
1896    FunctionParam { name: "unit", required: true },
1897    FunctionParam { name: "kind", required: false },
1898];
1899static PARAMS_TIME_STR_TO_DATE: &[FunctionParam] = &[
1900    FunctionParam { name: "this", required: true },
1901];
1902static PARAMS_TIME_STR_TO_TIME: &[FunctionParam] = &[
1903    FunctionParam { name: "this", required: true },
1904    FunctionParam { name: "zone", required: false },
1905];
1906static PARAMS_TIME_STR_TO_UNIX: &[FunctionParam] = &[
1907    FunctionParam { name: "this", required: true },
1908];
1909static PARAMS_TIME_SUB: &[FunctionParam] = &[
1910    FunctionParam { name: "this", required: true },
1911    FunctionParam { name: "expression", required: true },
1912    FunctionParam { name: "unit", required: false },
1913];
1914static PARAMS_TIME_TO_STR: &[FunctionParam] = &[
1915    FunctionParam { name: "this", required: true },
1916    FunctionParam { name: "format", required: true },
1917    FunctionParam { name: "culture", required: false },
1918    FunctionParam { name: "zone", required: false },
1919];
1920static PARAMS_TIME_TO_TIME_STR: &[FunctionParam] = &[
1921    FunctionParam { name: "this", required: true },
1922];
1923static PARAMS_TIME_TO_UNIX: &[FunctionParam] = &[
1924    FunctionParam { name: "this", required: true },
1925];
1926static PARAMS_TIME_TRUNC: &[FunctionParam] = &[
1927    FunctionParam { name: "this", required: true },
1928    FunctionParam { name: "unit", required: true },
1929    FunctionParam { name: "zone", required: false },
1930];
1931static PARAMS_TO_ARRAY: &[FunctionParam] = &[
1932    FunctionParam { name: "this", required: true },
1933];
1934static PARAMS_TO_BASE32: &[FunctionParam] = &[
1935    FunctionParam { name: "this", required: true },
1936];
1937static PARAMS_TO_BASE64: &[FunctionParam] = &[
1938    FunctionParam { name: "this", required: true },
1939];
1940static PARAMS_TO_CHAR: &[FunctionParam] = &[
1941    FunctionParam { name: "this", required: true },
1942    FunctionParam { name: "format", required: false },
1943    FunctionParam { name: "nlsparam", required: false },
1944    FunctionParam { name: "is_numeric", required: false },
1945];
1946static PARAMS_TO_CODE_POINTS: &[FunctionParam] = &[
1947    FunctionParam { name: "this", required: true },
1948];
1949static PARAMS_TO_DAYS: &[FunctionParam] = &[
1950    FunctionParam { name: "this", required: true },
1951];
1952static PARAMS_TO_DOUBLE: &[FunctionParam] = &[
1953    FunctionParam { name: "this", required: true },
1954    FunctionParam { name: "format", required: false },
1955];
1956static PARAMS_TO_MAP: &[FunctionParam] = &[
1957    FunctionParam { name: "this", required: true },
1958];
1959static PARAMS_TO_NUMBER: &[FunctionParam] = &[
1960    FunctionParam { name: "this", required: true },
1961    FunctionParam { name: "format", required: false },
1962    FunctionParam { name: "nlsparam", required: false },
1963    FunctionParam { name: "precision", required: false },
1964    FunctionParam { name: "scale", required: false },
1965];
1966static PARAMS_TRANSFORM: &[FunctionParam] = &[
1967    FunctionParam { name: "this", required: true },
1968    FunctionParam { name: "expression", required: true },
1969];
1970static PARAMS_TRANSLATE: &[FunctionParam] = &[
1971    FunctionParam { name: "this", required: true },
1972    FunctionParam { name: "from_", required: true },
1973    FunctionParam { name: "to", required: true },
1974];
1975static PARAMS_TRIM: &[FunctionParam] = &[
1976    FunctionParam { name: "this", required: true },
1977    FunctionParam { name: "expression", required: false },
1978    FunctionParam { name: "position", required: false },
1979    FunctionParam { name: "collation", required: false },
1980];
1981static PARAMS_TRY: &[FunctionParam] = &[
1982    FunctionParam { name: "this", required: true },
1983];
1984static PARAMS_TRY_BASE64DECODE_BINARY: &[FunctionParam] = &[
1985    FunctionParam { name: "this", required: true },
1986    FunctionParam { name: "alphabet", required: false },
1987];
1988static PARAMS_TRY_BASE64DECODE_STRING: &[FunctionParam] = &[
1989    FunctionParam { name: "this", required: true },
1990    FunctionParam { name: "alphabet", required: false },
1991];
1992static PARAMS_TRY_CAST: &[FunctionParam] = &[
1993    FunctionParam { name: "this", required: true },
1994    FunctionParam { name: "to", required: true },
1995    FunctionParam { name: "format", required: false },
1996    FunctionParam { name: "safe", required: false },
1997    FunctionParam { name: "action", required: false },
1998    FunctionParam { name: "default", required: false },
1999    FunctionParam { name: "requires_string", required: false },
2000];
2001static PARAMS_TRY_HEX_DECODE_BINARY: &[FunctionParam] = &[
2002    FunctionParam { name: "this", required: true },
2003];
2004static PARAMS_TRY_HEX_DECODE_STRING: &[FunctionParam] = &[
2005    FunctionParam { name: "this", required: true },
2006];
2007static PARAMS_TS_OR_DI_TO_DI: &[FunctionParam] = &[
2008    FunctionParam { name: "this", required: true },
2009];
2010static PARAMS_TS_OR_DS_ADD: &[FunctionParam] = &[
2011    FunctionParam { name: "this", required: true },
2012    FunctionParam { name: "expression", required: true },
2013    FunctionParam { name: "unit", required: false },
2014    FunctionParam { name: "return_type", required: false },
2015];
2016static PARAMS_TS_OR_DS_DIFF: &[FunctionParam] = &[
2017    FunctionParam { name: "this", required: true },
2018    FunctionParam { name: "expression", required: true },
2019    FunctionParam { name: "unit", required: false },
2020];
2021static PARAMS_TS_OR_DS_TO_DATE: &[FunctionParam] = &[
2022    FunctionParam { name: "this", required: true },
2023    FunctionParam { name: "format", required: false },
2024    FunctionParam { name: "safe", required: false },
2025];
2026static PARAMS_TS_OR_DS_TO_DATETIME: &[FunctionParam] = &[
2027    FunctionParam { name: "this", required: true },
2028];
2029static PARAMS_TS_OR_DS_TO_DATE_STR: &[FunctionParam] = &[
2030    FunctionParam { name: "this", required: true },
2031];
2032static PARAMS_TS_OR_DS_TO_TIME: &[FunctionParam] = &[
2033    FunctionParam { name: "this", required: true },
2034    FunctionParam { name: "format", required: false },
2035    FunctionParam { name: "safe", required: false },
2036];
2037static PARAMS_TS_OR_DS_TO_TIMESTAMP: &[FunctionParam] = &[
2038    FunctionParam { name: "this", required: true },
2039];
2040static PARAMS_TYPEOF: &[FunctionParam] = &[
2041    FunctionParam { name: "this", required: true },
2042];
2043static PARAMS_UPPER: &[FunctionParam] = &[
2044    FunctionParam { name: "this", required: true },
2045];
2046static PARAMS_UNHEX: &[FunctionParam] = &[
2047    FunctionParam { name: "this", required: true },
2048    FunctionParam { name: "expression", required: false },
2049];
2050static PARAMS_UNICODE: &[FunctionParam] = &[
2051    FunctionParam { name: "this", required: true },
2052];
2053static PARAMS_UNIX_DATE: &[FunctionParam] = &[
2054    FunctionParam { name: "this", required: true },
2055];
2056static PARAMS_UNIX_MICROS: &[FunctionParam] = &[
2057    FunctionParam { name: "this", required: true },
2058];
2059static PARAMS_UNIX_MILLIS: &[FunctionParam] = &[
2060    FunctionParam { name: "this", required: true },
2061];
2062static PARAMS_UNIX_SECONDS: &[FunctionParam] = &[
2063    FunctionParam { name: "this", required: true },
2064];
2065static PARAMS_UNIX_TO_STR: &[FunctionParam] = &[
2066    FunctionParam { name: "this", required: true },
2067    FunctionParam { name: "format", required: false },
2068];
2069static PARAMS_UNIX_TO_TIME: &[FunctionParam] = &[
2070    FunctionParam { name: "this", required: true },
2071    FunctionParam { name: "scale", required: false },
2072    FunctionParam { name: "zone", required: false },
2073    FunctionParam { name: "hours", required: false },
2074    FunctionParam { name: "minutes", required: false },
2075    FunctionParam { name: "format", required: false },
2076];
2077static PARAMS_UNIX_TO_TIME_STR: &[FunctionParam] = &[
2078    FunctionParam { name: "this", required: true },
2079];
2080static PARAMS_UNNEST: &[FunctionParam] = &[
2081    FunctionParam { name: "expressions", required: true },
2082    FunctionParam { name: "alias", required: false },
2083    FunctionParam { name: "offset", required: false },
2084    FunctionParam { name: "explode_array", required: false },
2085];
2086static PARAMS_UTC_TIME: &[FunctionParam] = &[
2087    FunctionParam { name: "this", required: false },
2088];
2089static PARAMS_UTC_TIMESTAMP: &[FunctionParam] = &[
2090    FunctionParam { name: "this", required: false },
2091];
2092static PARAMS_VARIANCE: &[FunctionParam] = &[
2093    FunctionParam { name: "this", required: true },
2094];
2095static PARAMS_VARIANCE_POP: &[FunctionParam] = &[
2096    FunctionParam { name: "this", required: true },
2097];
2098static PARAMS_VAR_MAP: &[FunctionParam] = &[
2099    FunctionParam { name: "keys", required: true },
2100    FunctionParam { name: "values", required: true },
2101];
2102static PARAMS_VECTOR_SEARCH: &[FunctionParam] = &[
2103    FunctionParam { name: "this", required: true },
2104    FunctionParam { name: "column_to_search", required: true },
2105    FunctionParam { name: "query_table", required: true },
2106    FunctionParam { name: "query_column_to_search", required: false },
2107    FunctionParam { name: "top_k", required: false },
2108    FunctionParam { name: "distance_type", required: false },
2109    FunctionParam { name: "options", required: false },
2110];
2111static PARAMS_WEEK: &[FunctionParam] = &[
2112    FunctionParam { name: "this", required: true },
2113    FunctionParam { name: "mode", required: false },
2114];
2115static PARAMS_WEEK_OF_YEAR: &[FunctionParam] = &[
2116    FunctionParam { name: "this", required: true },
2117];
2118static PARAMS_WIDTH_BUCKET: &[FunctionParam] = &[
2119    FunctionParam { name: "this", required: true },
2120    FunctionParam { name: "min_value", required: true },
2121    FunctionParam { name: "max_value", required: true },
2122    FunctionParam { name: "num_buckets", required: true },
2123];
2124static PARAMS_XML_ELEMENT: &[FunctionParam] = &[
2125    FunctionParam { name: "this", required: true },
2126    FunctionParam { name: "expressions", required: false },
2127];
2128static PARAMS_XOR: &[FunctionParam] = &[
2129    FunctionParam { name: "this", required: false },
2130    FunctionParam { name: "expression", required: false },
2131    FunctionParam { name: "expressions", required: false },
2132];
2133static PARAMS_XML_TABLE: &[FunctionParam] = &[
2134    FunctionParam { name: "this", required: true },
2135    FunctionParam { name: "namespaces", required: false },
2136    FunctionParam { name: "passing", required: false },
2137    FunctionParam { name: "columns", required: false },
2138    FunctionParam { name: "by_ref", required: false },
2139];
2140static PARAMS_YEAR: &[FunctionParam] = &[
2141    FunctionParam { name: "this", required: true },
2142];
2143static PARAMS_YEAR_OF_WEEK: &[FunctionParam] = &[
2144    FunctionParam { name: "this", required: true },
2145];
2146static PARAMS_YEAR_OF_WEEK_ISO: &[FunctionParam] = &[
2147    FunctionParam { name: "this", required: true },
2148];
2149
2150/// Looks up a function signature by name.
2151///
2152/// Returns the complete function signature including parameters, return type,
2153/// and category. The lookup is case-insensitive.
2154///
2155/// # Arguments
2156///
2157/// * `name` - The function name (case-insensitive)
2158///
2159/// # Returns
2160///
2161/// `Some(FunctionSignature)` if the function is known, `None` otherwise.
2162pub fn get_function_signature(name: &str) -> Option<FunctionSignature> {
2163    let lower = name.to_ascii_lowercase();
2164    match lower.as_str() {
2165        "abs" => Some(FunctionSignature {
2166            name: "abs",
2167            display_name: "ABS",
2168            params: PARAMS_ABS,
2169            return_type: None,
2170            category: FunctionCategory::Scalar,
2171        }),
2172        "acos" => Some(FunctionSignature {
2173            name: "acos",
2174            display_name: "ACOS",
2175            params: PARAMS_ACOS,
2176            return_type: None,
2177            category: FunctionCategory::Scalar,
2178        }),
2179        "acosh" => Some(FunctionSignature {
2180            name: "acosh",
2181            display_name: "ACOSH",
2182            params: PARAMS_ACOSH,
2183            return_type: None,
2184            category: FunctionCategory::Scalar,
2185        }),
2186        "add_months" => Some(FunctionSignature {
2187            name: "add_months",
2188            display_name: "ADD_MONTHS",
2189            params: PARAMS_ADD_MONTHS,
2190            return_type: None,
2191            category: FunctionCategory::Scalar,
2192        }),
2193        "agg_func" => Some(FunctionSignature {
2194            name: "agg_func",
2195            display_name: "AGG_FUNC",
2196            params: PARAMS_AGG_FUNC,
2197            return_type: None,
2198            category: FunctionCategory::Aggregate,
2199        }),
2200        "ai_agg" => Some(FunctionSignature {
2201            name: "ai_agg",
2202            display_name: "AI_AGG",
2203            params: PARAMS_AI_AGG,
2204            return_type: None,
2205            category: FunctionCategory::Aggregate,
2206        }),
2207        "ai_classify" => Some(FunctionSignature {
2208            name: "ai_classify",
2209            display_name: "AI_CLASSIFY",
2210            params: PARAMS_AI_CLASSIFY,
2211            return_type: None,
2212            category: FunctionCategory::Scalar,
2213        }),
2214        "ai_summarize_agg" => Some(FunctionSignature {
2215            name: "ai_summarize_agg",
2216            display_name: "AI_SUMMARIZE_AGG",
2217            params: PARAMS_AI_SUMMARIZE_AGG,
2218            return_type: None,
2219            category: FunctionCategory::Aggregate,
2220        }),
2221        "and" => Some(FunctionSignature {
2222            name: "and",
2223            display_name: "AND",
2224            params: PARAMS_AND,
2225            return_type: Some(ReturnTypeRule::Boolean),
2226            category: FunctionCategory::Scalar,
2227        }),
2228        "any_value" => Some(FunctionSignature {
2229            name: "any_value",
2230            display_name: "ANY_VALUE",
2231            params: PARAMS_ANY_VALUE,
2232            return_type: Some(ReturnTypeRule::MatchFirstArg),
2233            category: FunctionCategory::Aggregate,
2234        }),
2235        "apply" => Some(FunctionSignature {
2236            name: "apply",
2237            display_name: "APPLY",
2238            params: PARAMS_APPLY,
2239            return_type: None,
2240            category: FunctionCategory::Scalar,
2241        }),
2242        "approximate_similarity" => Some(FunctionSignature {
2243            name: "approximate_similarity",
2244            display_name: "APPROXIMATE_SIMILARITY",
2245            params: PARAMS_APPROXIMATE_SIMILARITY,
2246            return_type: None,
2247            category: FunctionCategory::Aggregate,
2248        }),
2249        "approx_distinct" => Some(FunctionSignature {
2250            name: "approx_distinct",
2251            display_name: "APPROX_DISTINCT",
2252            params: PARAMS_APPROX_DISTINCT,
2253            return_type: None,
2254            category: FunctionCategory::Aggregate,
2255        }),
2256        "approx_quantile" => Some(FunctionSignature {
2257            name: "approx_quantile",
2258            display_name: "APPROX_QUANTILE",
2259            params: PARAMS_APPROX_QUANTILE,
2260            return_type: None,
2261            category: FunctionCategory::Aggregate,
2262        }),
2263        "approx_quantiles" => Some(FunctionSignature {
2264            name: "approx_quantiles",
2265            display_name: "APPROX_QUANTILES",
2266            params: PARAMS_APPROX_QUANTILES,
2267            return_type: None,
2268            category: FunctionCategory::Aggregate,
2269        }),
2270        "approx_top_k" => Some(FunctionSignature {
2271            name: "approx_top_k",
2272            display_name: "APPROX_TOP_K",
2273            params: PARAMS_APPROX_TOP_K,
2274            return_type: None,
2275            category: FunctionCategory::Aggregate,
2276        }),
2277        "approx_top_k_accumulate" => Some(FunctionSignature {
2278            name: "approx_top_k_accumulate",
2279            display_name: "APPROX_TOP_K_ACCUMULATE",
2280            params: PARAMS_APPROX_TOP_K_ACCUMULATE,
2281            return_type: None,
2282            category: FunctionCategory::Aggregate,
2283        }),
2284        "approx_top_k_combine" => Some(FunctionSignature {
2285            name: "approx_top_k_combine",
2286            display_name: "APPROX_TOP_K_COMBINE",
2287            params: PARAMS_APPROX_TOP_K_COMBINE,
2288            return_type: None,
2289            category: FunctionCategory::Aggregate,
2290        }),
2291        "approx_top_sum" => Some(FunctionSignature {
2292            name: "approx_top_sum",
2293            display_name: "APPROX_TOP_SUM",
2294            params: PARAMS_APPROX_TOP_SUM,
2295            return_type: None,
2296            category: FunctionCategory::Aggregate,
2297        }),
2298        "arg_max" => Some(FunctionSignature {
2299            name: "arg_max",
2300            display_name: "ARG_MAX",
2301            params: PARAMS_ARG_MAX,
2302            return_type: None,
2303            category: FunctionCategory::Aggregate,
2304        }),
2305        "arg_min" => Some(FunctionSignature {
2306            name: "arg_min",
2307            display_name: "ARG_MIN",
2308            params: PARAMS_ARG_MIN,
2309            return_type: None,
2310            category: FunctionCategory::Aggregate,
2311        }),
2312        "array" => Some(FunctionSignature {
2313            name: "array",
2314            display_name: "ARRAY",
2315            params: PARAMS_ARRAY,
2316            return_type: None,
2317            category: FunctionCategory::Scalar,
2318        }),
2319        "array_agg" => Some(FunctionSignature {
2320            name: "array_agg",
2321            display_name: "ARRAY_AGG",
2322            params: PARAMS_ARRAY_AGG,
2323            return_type: None,
2324            category: FunctionCategory::Aggregate,
2325        }),
2326        "array_all" => Some(FunctionSignature {
2327            name: "array_all",
2328            display_name: "ARRAY_ALL",
2329            params: PARAMS_ARRAY_ALL,
2330            return_type: None,
2331            category: FunctionCategory::Scalar,
2332        }),
2333        "array_any" => Some(FunctionSignature {
2334            name: "array_any",
2335            display_name: "ARRAY_ANY",
2336            params: PARAMS_ARRAY_ANY,
2337            return_type: None,
2338            category: FunctionCategory::Scalar,
2339        }),
2340        "array_concat" => Some(FunctionSignature {
2341            name: "array_concat",
2342            display_name: "ARRAY_CONCAT",
2343            params: PARAMS_ARRAY_CONCAT,
2344            return_type: None,
2345            category: FunctionCategory::Scalar,
2346        }),
2347        "array_concat_agg" => Some(FunctionSignature {
2348            name: "array_concat_agg",
2349            display_name: "ARRAY_CONCAT_AGG",
2350            params: PARAMS_ARRAY_CONCAT_AGG,
2351            return_type: None,
2352            category: FunctionCategory::Aggregate,
2353        }),
2354        "array_construct_compact" => Some(FunctionSignature {
2355            name: "array_construct_compact",
2356            display_name: "ARRAY_CONSTRUCT_COMPACT",
2357            params: PARAMS_ARRAY_CONSTRUCT_COMPACT,
2358            return_type: None,
2359            category: FunctionCategory::Scalar,
2360        }),
2361        "array_contains" => Some(FunctionSignature {
2362            name: "array_contains",
2363            display_name: "ARRAY_CONTAINS",
2364            params: PARAMS_ARRAY_CONTAINS,
2365            return_type: None,
2366            category: FunctionCategory::Scalar,
2367        }),
2368        "array_contains_all" => Some(FunctionSignature {
2369            name: "array_contains_all",
2370            display_name: "ARRAY_CONTAINS_ALL",
2371            params: PARAMS_ARRAY_CONTAINS_ALL,
2372            return_type: None,
2373            category: FunctionCategory::Scalar,
2374        }),
2375        "array_filter" => Some(FunctionSignature {
2376            name: "array_filter",
2377            display_name: "ARRAY_FILTER",
2378            params: PARAMS_ARRAY_FILTER,
2379            return_type: None,
2380            category: FunctionCategory::Scalar,
2381        }),
2382        "array_first" => Some(FunctionSignature {
2383            name: "array_first",
2384            display_name: "ARRAY_FIRST",
2385            params: PARAMS_ARRAY_FIRST,
2386            return_type: None,
2387            category: FunctionCategory::Scalar,
2388        }),
2389        "array_intersect" => Some(FunctionSignature {
2390            name: "array_intersect",
2391            display_name: "ARRAY_INTERSECT",
2392            params: PARAMS_ARRAY_INTERSECT,
2393            return_type: None,
2394            category: FunctionCategory::Scalar,
2395        }),
2396        "array_to_string" => Some(FunctionSignature {
2397            name: "array_to_string",
2398            display_name: "ARRAY_TO_STRING",
2399            params: PARAMS_ARRAY_TO_STRING,
2400            return_type: None,
2401            category: FunctionCategory::Scalar,
2402        }),
2403        "array_last" => Some(FunctionSignature {
2404            name: "array_last",
2405            display_name: "ARRAY_LAST",
2406            params: PARAMS_ARRAY_LAST,
2407            return_type: None,
2408            category: FunctionCategory::Scalar,
2409        }),
2410        "array_size" => Some(FunctionSignature {
2411            name: "array_size",
2412            display_name: "ARRAY_SIZE",
2413            params: PARAMS_ARRAY_SIZE,
2414            return_type: None,
2415            category: FunctionCategory::Scalar,
2416        }),
2417        "array_overlaps" => Some(FunctionSignature {
2418            name: "array_overlaps",
2419            display_name: "ARRAY_OVERLAPS",
2420            params: PARAMS_ARRAY_OVERLAPS,
2421            return_type: None,
2422            category: FunctionCategory::Scalar,
2423        }),
2424        "array_remove" => Some(FunctionSignature {
2425            name: "array_remove",
2426            display_name: "ARRAY_REMOVE",
2427            params: PARAMS_ARRAY_REMOVE,
2428            return_type: None,
2429            category: FunctionCategory::Scalar,
2430        }),
2431        "array_reverse" => Some(FunctionSignature {
2432            name: "array_reverse",
2433            display_name: "ARRAY_REVERSE",
2434            params: PARAMS_ARRAY_REVERSE,
2435            return_type: None,
2436            category: FunctionCategory::Scalar,
2437        }),
2438        "array_slice" => Some(FunctionSignature {
2439            name: "array_slice",
2440            display_name: "ARRAY_SLICE",
2441            params: PARAMS_ARRAY_SLICE,
2442            return_type: None,
2443            category: FunctionCategory::Scalar,
2444        }),
2445        "array_sort" => Some(FunctionSignature {
2446            name: "array_sort",
2447            display_name: "ARRAY_SORT",
2448            params: PARAMS_ARRAY_SORT,
2449            return_type: None,
2450            category: FunctionCategory::Scalar,
2451        }),
2452        "array_sum" => Some(FunctionSignature {
2453            name: "array_sum",
2454            display_name: "ARRAY_SUM",
2455            params: PARAMS_ARRAY_SUM,
2456            return_type: None,
2457            category: FunctionCategory::Scalar,
2458        }),
2459        "array_union_agg" => Some(FunctionSignature {
2460            name: "array_union_agg",
2461            display_name: "ARRAY_UNION_AGG",
2462            params: PARAMS_ARRAY_UNION_AGG,
2463            return_type: None,
2464            category: FunctionCategory::Aggregate,
2465        }),
2466        "array_unique_agg" => Some(FunctionSignature {
2467            name: "array_unique_agg",
2468            display_name: "ARRAY_UNIQUE_AGG",
2469            params: PARAMS_ARRAY_UNIQUE_AGG,
2470            return_type: None,
2471            category: FunctionCategory::Aggregate,
2472        }),
2473        "ascii" => Some(FunctionSignature {
2474            name: "ascii",
2475            display_name: "ASCII",
2476            params: PARAMS_ASCII,
2477            return_type: None,
2478            category: FunctionCategory::Scalar,
2479        }),
2480        "asin" => Some(FunctionSignature {
2481            name: "asin",
2482            display_name: "ASIN",
2483            params: PARAMS_ASIN,
2484            return_type: None,
2485            category: FunctionCategory::Scalar,
2486        }),
2487        "asinh" => Some(FunctionSignature {
2488            name: "asinh",
2489            display_name: "ASINH",
2490            params: PARAMS_ASINH,
2491            return_type: None,
2492            category: FunctionCategory::Scalar,
2493        }),
2494        "atan" => Some(FunctionSignature {
2495            name: "atan",
2496            display_name: "ATAN",
2497            params: PARAMS_ATAN,
2498            return_type: None,
2499            category: FunctionCategory::Scalar,
2500        }),
2501        "atan2" => Some(FunctionSignature {
2502            name: "atan2",
2503            display_name: "ATAN2",
2504            params: PARAMS_ATAN2,
2505            return_type: None,
2506            category: FunctionCategory::Scalar,
2507        }),
2508        "atanh" => Some(FunctionSignature {
2509            name: "atanh",
2510            display_name: "ATANH",
2511            params: PARAMS_ATANH,
2512            return_type: None,
2513            category: FunctionCategory::Scalar,
2514        }),
2515        "avg" => Some(FunctionSignature {
2516            name: "avg",
2517            display_name: "AVG",
2518            params: PARAMS_AVG,
2519            return_type: Some(ReturnTypeRule::Numeric),
2520            category: FunctionCategory::Aggregate,
2521        }),
2522        "base64decode_binary" => Some(FunctionSignature {
2523            name: "base64decode_binary",
2524            display_name: "BASE64DECODE_BINARY",
2525            params: PARAMS_BASE64DECODE_BINARY,
2526            return_type: None,
2527            category: FunctionCategory::Scalar,
2528        }),
2529        "base64decode_string" => Some(FunctionSignature {
2530            name: "base64decode_string",
2531            display_name: "BASE64DECODE_STRING",
2532            params: PARAMS_BASE64DECODE_STRING,
2533            return_type: None,
2534            category: FunctionCategory::Scalar,
2535        }),
2536        "base64encode" => Some(FunctionSignature {
2537            name: "base64encode",
2538            display_name: "BASE64ENCODE",
2539            params: PARAMS_BASE64ENCODE,
2540            return_type: None,
2541            category: FunctionCategory::Scalar,
2542        }),
2543        "bitmap_bit_position" => Some(FunctionSignature {
2544            name: "bitmap_bit_position",
2545            display_name: "BITMAP_BIT_POSITION",
2546            params: PARAMS_BITMAP_BIT_POSITION,
2547            return_type: None,
2548            category: FunctionCategory::Scalar,
2549        }),
2550        "bitmap_bucket_number" => Some(FunctionSignature {
2551            name: "bitmap_bucket_number",
2552            display_name: "BITMAP_BUCKET_NUMBER",
2553            params: PARAMS_BITMAP_BUCKET_NUMBER,
2554            return_type: None,
2555            category: FunctionCategory::Scalar,
2556        }),
2557        "bitmap_construct_agg" => Some(FunctionSignature {
2558            name: "bitmap_construct_agg",
2559            display_name: "BITMAP_CONSTRUCT_AGG",
2560            params: PARAMS_BITMAP_CONSTRUCT_AGG,
2561            return_type: None,
2562            category: FunctionCategory::Aggregate,
2563        }),
2564        "bitmap_count" => Some(FunctionSignature {
2565            name: "bitmap_count",
2566            display_name: "BITMAP_COUNT",
2567            params: PARAMS_BITMAP_COUNT,
2568            return_type: None,
2569            category: FunctionCategory::Scalar,
2570        }),
2571        "bitmap_or_agg" => Some(FunctionSignature {
2572            name: "bitmap_or_agg",
2573            display_name: "BITMAP_OR_AGG",
2574            params: PARAMS_BITMAP_OR_AGG,
2575            return_type: None,
2576            category: FunctionCategory::Aggregate,
2577        }),
2578        "bitwise_and_agg" => Some(FunctionSignature {
2579            name: "bitwise_and_agg",
2580            display_name: "BITWISE_AND_AGG",
2581            params: PARAMS_BITWISE_AND_AGG,
2582            return_type: None,
2583            category: FunctionCategory::Aggregate,
2584        }),
2585        "bitwise_count" => Some(FunctionSignature {
2586            name: "bitwise_count",
2587            display_name: "BITWISE_COUNT",
2588            params: PARAMS_BITWISE_COUNT,
2589            return_type: None,
2590            category: FunctionCategory::Scalar,
2591        }),
2592        "bitwise_or_agg" => Some(FunctionSignature {
2593            name: "bitwise_or_agg",
2594            display_name: "BITWISE_OR_AGG",
2595            params: PARAMS_BITWISE_OR_AGG,
2596            return_type: None,
2597            category: FunctionCategory::Aggregate,
2598        }),
2599        "bitwise_xor_agg" => Some(FunctionSignature {
2600            name: "bitwise_xor_agg",
2601            display_name: "BITWISE_XOR_AGG",
2602            params: PARAMS_BITWISE_XOR_AGG,
2603            return_type: None,
2604            category: FunctionCategory::Aggregate,
2605        }),
2606        "bit_length" => Some(FunctionSignature {
2607            name: "bit_length",
2608            display_name: "BIT_LENGTH",
2609            params: PARAMS_BIT_LENGTH,
2610            return_type: None,
2611            category: FunctionCategory::Scalar,
2612        }),
2613        "booland" => Some(FunctionSignature {
2614            name: "booland",
2615            display_name: "BOOLAND",
2616            params: PARAMS_BOOLAND,
2617            return_type: None,
2618            category: FunctionCategory::Scalar,
2619        }),
2620        "logical_and" => Some(FunctionSignature {
2621            name: "logical_and",
2622            display_name: "LOGICAL_AND",
2623            params: PARAMS_LOGICAL_AND,
2624            return_type: None,
2625            category: FunctionCategory::Aggregate,
2626        }),
2627        "boolnot" => Some(FunctionSignature {
2628            name: "boolnot",
2629            display_name: "BOOLNOT",
2630            params: PARAMS_BOOLNOT,
2631            return_type: None,
2632            category: FunctionCategory::Scalar,
2633        }),
2634        "boolor" => Some(FunctionSignature {
2635            name: "boolor",
2636            display_name: "BOOLOR",
2637            params: PARAMS_BOOLOR,
2638            return_type: None,
2639            category: FunctionCategory::Scalar,
2640        }),
2641        "logical_or" => Some(FunctionSignature {
2642            name: "logical_or",
2643            display_name: "LOGICAL_OR",
2644            params: PARAMS_LOGICAL_OR,
2645            return_type: None,
2646            category: FunctionCategory::Aggregate,
2647        }),
2648        "boolxor_agg" => Some(FunctionSignature {
2649            name: "boolxor_agg",
2650            display_name: "BOOLXOR_AGG",
2651            params: PARAMS_BOOLXOR_AGG,
2652            return_type: None,
2653            category: FunctionCategory::Aggregate,
2654        }),
2655        "byte_length" => Some(FunctionSignature {
2656            name: "byte_length",
2657            display_name: "BYTE_LENGTH",
2658            params: PARAMS_BYTE_LENGTH,
2659            return_type: None,
2660            category: FunctionCategory::Scalar,
2661        }),
2662        "case" => Some(FunctionSignature {
2663            name: "case",
2664            display_name: "CASE",
2665            params: PARAMS_CASE,
2666            return_type: None,
2667            category: FunctionCategory::Scalar,
2668        }),
2669        "cast" => Some(FunctionSignature {
2670            name: "cast",
2671            display_name: "CAST",
2672            params: PARAMS_CAST,
2673            return_type: None,
2674            category: FunctionCategory::Scalar,
2675        }),
2676        "cast_to_str_type" => Some(FunctionSignature {
2677            name: "cast_to_str_type",
2678            display_name: "CAST_TO_STR_TYPE",
2679            params: PARAMS_CAST_TO_STR_TYPE,
2680            return_type: None,
2681            category: FunctionCategory::Scalar,
2682        }),
2683        "cbrt" => Some(FunctionSignature {
2684            name: "cbrt",
2685            display_name: "CBRT",
2686            params: PARAMS_CBRT,
2687            return_type: None,
2688            category: FunctionCategory::Scalar,
2689        }),
2690        "ceil" => Some(FunctionSignature {
2691            name: "ceil",
2692            display_name: "CEIL",
2693            params: PARAMS_CEIL,
2694            return_type: None,
2695            category: FunctionCategory::Scalar,
2696        }),
2697        "chr" => Some(FunctionSignature {
2698            name: "chr",
2699            display_name: "CHR",
2700            params: PARAMS_CHR,
2701            return_type: None,
2702            category: FunctionCategory::Scalar,
2703        }),
2704        "length" => Some(FunctionSignature {
2705            name: "length",
2706            display_name: "LENGTH",
2707            params: PARAMS_LENGTH,
2708            return_type: None,
2709            category: FunctionCategory::Scalar,
2710        }),
2711        "coalesce" => Some(FunctionSignature {
2712            name: "coalesce",
2713            display_name: "COALESCE",
2714            params: PARAMS_COALESCE,
2715            return_type: Some(ReturnTypeRule::MatchFirstArg),
2716            category: FunctionCategory::Scalar,
2717        }),
2718        "code_points_to_bytes" => Some(FunctionSignature {
2719            name: "code_points_to_bytes",
2720            display_name: "CODE_POINTS_TO_BYTES",
2721            params: PARAMS_CODE_POINTS_TO_BYTES,
2722            return_type: None,
2723            category: FunctionCategory::Scalar,
2724        }),
2725        "code_points_to_string" => Some(FunctionSignature {
2726            name: "code_points_to_string",
2727            display_name: "CODE_POINTS_TO_STRING",
2728            params: PARAMS_CODE_POINTS_TO_STRING,
2729            return_type: None,
2730            category: FunctionCategory::Scalar,
2731        }),
2732        "collate" => Some(FunctionSignature {
2733            name: "collate",
2734            display_name: "COLLATE",
2735            params: PARAMS_COLLATE,
2736            return_type: None,
2737            category: FunctionCategory::Scalar,
2738        }),
2739        "collation" => Some(FunctionSignature {
2740            name: "collation",
2741            display_name: "COLLATION",
2742            params: PARAMS_COLLATION,
2743            return_type: None,
2744            category: FunctionCategory::Scalar,
2745        }),
2746        "columns" => Some(FunctionSignature {
2747            name: "columns",
2748            display_name: "COLUMNS",
2749            params: PARAMS_COLUMNS,
2750            return_type: None,
2751            category: FunctionCategory::Scalar,
2752        }),
2753        "combined_agg_func" => Some(FunctionSignature {
2754            name: "combined_agg_func",
2755            display_name: "COMBINED_AGG_FUNC",
2756            params: PARAMS_COMBINED_AGG_FUNC,
2757            return_type: None,
2758            category: FunctionCategory::Aggregate,
2759        }),
2760        "combined_parameterized_agg" => Some(FunctionSignature {
2761            name: "combined_parameterized_agg",
2762            display_name: "COMBINED_PARAMETERIZED_AGG",
2763            params: PARAMS_COMBINED_PARAMETERIZED_AGG,
2764            return_type: None,
2765            category: FunctionCategory::Aggregate,
2766        }),
2767        "compress" => Some(FunctionSignature {
2768            name: "compress",
2769            display_name: "COMPRESS",
2770            params: PARAMS_COMPRESS,
2771            return_type: None,
2772            category: FunctionCategory::Scalar,
2773        }),
2774        "concat" => Some(FunctionSignature {
2775            name: "concat",
2776            display_name: "CONCAT",
2777            params: PARAMS_CONCAT,
2778            return_type: Some(ReturnTypeRule::Text),
2779            category: FunctionCategory::Scalar,
2780        }),
2781        "concat_ws" => Some(FunctionSignature {
2782            name: "concat_ws",
2783            display_name: "CONCAT_WS",
2784            params: PARAMS_CONCAT_WS,
2785            return_type: Some(ReturnTypeRule::Text),
2786            category: FunctionCategory::Scalar,
2787        }),
2788        "connect_by_root" => Some(FunctionSignature {
2789            name: "connect_by_root",
2790            display_name: "CONNECT_BY_ROOT",
2791            params: PARAMS_CONNECT_BY_ROOT,
2792            return_type: None,
2793            category: FunctionCategory::Scalar,
2794        }),
2795        "contains" => Some(FunctionSignature {
2796            name: "contains",
2797            display_name: "CONTAINS",
2798            params: PARAMS_CONTAINS,
2799            return_type: None,
2800            category: FunctionCategory::Scalar,
2801        }),
2802        "convert" => Some(FunctionSignature {
2803            name: "convert",
2804            display_name: "CONVERT",
2805            params: PARAMS_CONVERT,
2806            return_type: None,
2807            category: FunctionCategory::Scalar,
2808        }),
2809        "convert_timezone" => Some(FunctionSignature {
2810            name: "convert_timezone",
2811            display_name: "CONVERT_TIMEZONE",
2812            params: PARAMS_CONVERT_TIMEZONE,
2813            return_type: None,
2814            category: FunctionCategory::Scalar,
2815        }),
2816        "convert_to_charset" => Some(FunctionSignature {
2817            name: "convert_to_charset",
2818            display_name: "CONVERT_TO_CHARSET",
2819            params: PARAMS_CONVERT_TO_CHARSET,
2820            return_type: None,
2821            category: FunctionCategory::Scalar,
2822        }),
2823        "corr" => Some(FunctionSignature {
2824            name: "corr",
2825            display_name: "CORR",
2826            params: PARAMS_CORR,
2827            return_type: None,
2828            category: FunctionCategory::Aggregate,
2829        }),
2830        "cos" => Some(FunctionSignature {
2831            name: "cos",
2832            display_name: "COS",
2833            params: PARAMS_COS,
2834            return_type: None,
2835            category: FunctionCategory::Scalar,
2836        }),
2837        "cosh" => Some(FunctionSignature {
2838            name: "cosh",
2839            display_name: "COSH",
2840            params: PARAMS_COSH,
2841            return_type: None,
2842            category: FunctionCategory::Scalar,
2843        }),
2844        "cosine_distance" => Some(FunctionSignature {
2845            name: "cosine_distance",
2846            display_name: "COSINE_DISTANCE",
2847            params: PARAMS_COSINE_DISTANCE,
2848            return_type: None,
2849            category: FunctionCategory::Scalar,
2850        }),
2851        "cot" => Some(FunctionSignature {
2852            name: "cot",
2853            display_name: "COT",
2854            params: PARAMS_COT,
2855            return_type: None,
2856            category: FunctionCategory::Scalar,
2857        }),
2858        "coth" => Some(FunctionSignature {
2859            name: "coth",
2860            display_name: "COTH",
2861            params: PARAMS_COTH,
2862            return_type: None,
2863            category: FunctionCategory::Scalar,
2864        }),
2865        "count" => Some(FunctionSignature {
2866            name: "count",
2867            display_name: "COUNT",
2868            params: PARAMS_COUNT,
2869            return_type: Some(ReturnTypeRule::Integer),
2870            category: FunctionCategory::Aggregate,
2871        }),
2872        "count_if" => Some(FunctionSignature {
2873            name: "count_if",
2874            display_name: "COUNT_IF",
2875            params: PARAMS_COUNT_IF,
2876            return_type: None,
2877            category: FunctionCategory::Aggregate,
2878        }),
2879        "covar_pop" => Some(FunctionSignature {
2880            name: "covar_pop",
2881            display_name: "COVAR_POP",
2882            params: PARAMS_COVAR_POP,
2883            return_type: None,
2884            category: FunctionCategory::Aggregate,
2885        }),
2886        "covar_samp" => Some(FunctionSignature {
2887            name: "covar_samp",
2888            display_name: "COVAR_SAMP",
2889            params: PARAMS_COVAR_SAMP,
2890            return_type: None,
2891            category: FunctionCategory::Aggregate,
2892        }),
2893        "csc" => Some(FunctionSignature {
2894            name: "csc",
2895            display_name: "CSC",
2896            params: PARAMS_CSC,
2897            return_type: None,
2898            category: FunctionCategory::Scalar,
2899        }),
2900        "csch" => Some(FunctionSignature {
2901            name: "csch",
2902            display_name: "CSCH",
2903            params: PARAMS_CSCH,
2904            return_type: None,
2905            category: FunctionCategory::Scalar,
2906        }),
2907        "cume_dist" => Some(FunctionSignature {
2908            name: "cume_dist",
2909            display_name: "CUME_DIST",
2910            params: PARAMS_CUME_DIST,
2911            return_type: None,
2912            category: FunctionCategory::Window,
2913        }),
2914        "current_date" => Some(FunctionSignature {
2915            name: "current_date",
2916            display_name: "CURRENT_DATE",
2917            params: PARAMS_CURRENT_DATE,
2918            return_type: Some(ReturnTypeRule::Date),
2919            category: FunctionCategory::Scalar,
2920        }),
2921        "current_datetime" => Some(FunctionSignature {
2922            name: "current_datetime",
2923            display_name: "CURRENT_DATETIME",
2924            params: PARAMS_CURRENT_DATETIME,
2925            return_type: None,
2926            category: FunctionCategory::Scalar,
2927        }),
2928        "current_schema" => Some(FunctionSignature {
2929            name: "current_schema",
2930            display_name: "CURRENT_SCHEMA",
2931            params: PARAMS_CURRENT_SCHEMA,
2932            return_type: None,
2933            category: FunctionCategory::Scalar,
2934        }),
2935        "current_time" => Some(FunctionSignature {
2936            name: "current_time",
2937            display_name: "CURRENT_TIME",
2938            params: PARAMS_CURRENT_TIME,
2939            return_type: None,
2940            category: FunctionCategory::Scalar,
2941        }),
2942        "current_timestamp" => Some(FunctionSignature {
2943            name: "current_timestamp",
2944            display_name: "CURRENT_TIMESTAMP",
2945            params: PARAMS_CURRENT_TIMESTAMP,
2946            return_type: Some(ReturnTypeRule::Timestamp),
2947            category: FunctionCategory::Scalar,
2948        }),
2949        "current_timestamp_ltz" => Some(FunctionSignature {
2950            name: "current_timestamp_ltz",
2951            display_name: "CURRENT_TIMESTAMP_LTZ",
2952            params: &[],
2953            return_type: None,
2954            category: FunctionCategory::Scalar,
2955        }),
2956        "current_user" => Some(FunctionSignature {
2957            name: "current_user",
2958            display_name: "CURRENT_USER",
2959            params: PARAMS_CURRENT_USER,
2960            return_type: None,
2961            category: FunctionCategory::Scalar,
2962        }),
2963        "date" => Some(FunctionSignature {
2964            name: "date",
2965            display_name: "DATE",
2966            params: PARAMS_DATE,
2967            return_type: None,
2968            category: FunctionCategory::Scalar,
2969        }),
2970        "date_diff" => Some(FunctionSignature {
2971            name: "date_diff",
2972            display_name: "DATE_DIFF",
2973            params: PARAMS_DATE_DIFF,
2974            return_type: None,
2975            category: FunctionCategory::Scalar,
2976        }),
2977        "date_from_parts" => Some(FunctionSignature {
2978            name: "date_from_parts",
2979            display_name: "DATE_FROM_PARTS",
2980            params: PARAMS_DATE_FROM_PARTS,
2981            return_type: None,
2982            category: FunctionCategory::Scalar,
2983        }),
2984        "datetime" => Some(FunctionSignature {
2985            name: "datetime",
2986            display_name: "DATETIME",
2987            params: PARAMS_DATETIME,
2988            return_type: None,
2989            category: FunctionCategory::Scalar,
2990        }),
2991        "datetime_add" => Some(FunctionSignature {
2992            name: "datetime_add",
2993            display_name: "DATETIME_ADD",
2994            params: PARAMS_DATETIME_ADD,
2995            return_type: None,
2996            category: FunctionCategory::Scalar,
2997        }),
2998        "datetime_diff" => Some(FunctionSignature {
2999            name: "datetime_diff",
3000            display_name: "DATETIME_DIFF",
3001            params: PARAMS_DATETIME_DIFF,
3002            return_type: None,
3003            category: FunctionCategory::Scalar,
3004        }),
3005        "datetime_sub" => Some(FunctionSignature {
3006            name: "datetime_sub",
3007            display_name: "DATETIME_SUB",
3008            params: PARAMS_DATETIME_SUB,
3009            return_type: None,
3010            category: FunctionCategory::Scalar,
3011        }),
3012        "datetime_trunc" => Some(FunctionSignature {
3013            name: "datetime_trunc",
3014            display_name: "DATETIME_TRUNC",
3015            params: PARAMS_DATETIME_TRUNC,
3016            return_type: None,
3017            category: FunctionCategory::Scalar,
3018        }),
3019        "date_add" => Some(FunctionSignature {
3020            name: "date_add",
3021            display_name: "DATE_ADD",
3022            params: PARAMS_DATE_ADD,
3023            return_type: None,
3024            category: FunctionCategory::Scalar,
3025        }),
3026        "date_bin" => Some(FunctionSignature {
3027            name: "date_bin",
3028            display_name: "DATE_BIN",
3029            params: PARAMS_DATE_BIN,
3030            return_type: None,
3031            category: FunctionCategory::Scalar,
3032        }),
3033        "date_from_unix_date" => Some(FunctionSignature {
3034            name: "date_from_unix_date",
3035            display_name: "DATE_FROM_UNIX_DATE",
3036            params: PARAMS_DATE_FROM_UNIX_DATE,
3037            return_type: None,
3038            category: FunctionCategory::Scalar,
3039        }),
3040        "date_str_to_date" => Some(FunctionSignature {
3041            name: "date_str_to_date",
3042            display_name: "DATE_STR_TO_DATE",
3043            params: PARAMS_DATE_STR_TO_DATE,
3044            return_type: None,
3045            category: FunctionCategory::Scalar,
3046        }),
3047        "date_sub" => Some(FunctionSignature {
3048            name: "date_sub",
3049            display_name: "DATE_SUB",
3050            params: PARAMS_DATE_SUB,
3051            return_type: None,
3052            category: FunctionCategory::Scalar,
3053        }),
3054        "date_to_date_str" => Some(FunctionSignature {
3055            name: "date_to_date_str",
3056            display_name: "DATE_TO_DATE_STR",
3057            params: PARAMS_DATE_TO_DATE_STR,
3058            return_type: None,
3059            category: FunctionCategory::Scalar,
3060        }),
3061        "date_to_di" => Some(FunctionSignature {
3062            name: "date_to_di",
3063            display_name: "DATE_TO_DI",
3064            params: PARAMS_DATE_TO_DI,
3065            return_type: None,
3066            category: FunctionCategory::Scalar,
3067        }),
3068        "date_trunc" => Some(FunctionSignature {
3069            name: "date_trunc",
3070            display_name: "DATE_TRUNC",
3071            params: PARAMS_DATE_TRUNC,
3072            return_type: Some(ReturnTypeRule::MatchFirstArg),
3073            category: FunctionCategory::Scalar,
3074        }),
3075        "day" => Some(FunctionSignature {
3076            name: "day",
3077            display_name: "DAY",
3078            params: PARAMS_DAY,
3079            return_type: None,
3080            category: FunctionCategory::Scalar,
3081        }),
3082        "day_of_month" => Some(FunctionSignature {
3083            name: "day_of_month",
3084            display_name: "DAY_OF_MONTH",
3085            params: PARAMS_DAY_OF_MONTH,
3086            return_type: None,
3087            category: FunctionCategory::Scalar,
3088        }),
3089        "day_of_week" => Some(FunctionSignature {
3090            name: "day_of_week",
3091            display_name: "DAY_OF_WEEK",
3092            params: PARAMS_DAY_OF_WEEK,
3093            return_type: None,
3094            category: FunctionCategory::Scalar,
3095        }),
3096        "day_of_week_iso" => Some(FunctionSignature {
3097            name: "day_of_week_iso",
3098            display_name: "DAY_OF_WEEK_ISO",
3099            params: PARAMS_DAY_OF_WEEK_ISO,
3100            return_type: None,
3101            category: FunctionCategory::Scalar,
3102        }),
3103        "day_of_year" => Some(FunctionSignature {
3104            name: "day_of_year",
3105            display_name: "DAY_OF_YEAR",
3106            params: PARAMS_DAY_OF_YEAR,
3107            return_type: None,
3108            category: FunctionCategory::Scalar,
3109        }),
3110        "decode" => Some(FunctionSignature {
3111            name: "decode",
3112            display_name: "DECODE",
3113            params: PARAMS_DECODE,
3114            return_type: None,
3115            category: FunctionCategory::Scalar,
3116        }),
3117        "decode_case" => Some(FunctionSignature {
3118            name: "decode_case",
3119            display_name: "DECODE_CASE",
3120            params: PARAMS_DECODE_CASE,
3121            return_type: None,
3122            category: FunctionCategory::Scalar,
3123        }),
3124        "decompress_binary" => Some(FunctionSignature {
3125            name: "decompress_binary",
3126            display_name: "DECOMPRESS_BINARY",
3127            params: PARAMS_DECOMPRESS_BINARY,
3128            return_type: None,
3129            category: FunctionCategory::Scalar,
3130        }),
3131        "decompress_string" => Some(FunctionSignature {
3132            name: "decompress_string",
3133            display_name: "DECOMPRESS_STRING",
3134            params: PARAMS_DECOMPRESS_STRING,
3135            return_type: None,
3136            category: FunctionCategory::Scalar,
3137        }),
3138        "degrees" => Some(FunctionSignature {
3139            name: "degrees",
3140            display_name: "DEGREES",
3141            params: PARAMS_DEGREES,
3142            return_type: None,
3143            category: FunctionCategory::Scalar,
3144        }),
3145        "dense_rank" => Some(FunctionSignature {
3146            name: "dense_rank",
3147            display_name: "DENSE_RANK",
3148            params: PARAMS_DENSE_RANK,
3149            return_type: Some(ReturnTypeRule::Integer),
3150            category: FunctionCategory::Window,
3151        }),
3152        "di_to_date" => Some(FunctionSignature {
3153            name: "di_to_date",
3154            display_name: "DI_TO_DATE",
3155            params: PARAMS_DI_TO_DATE,
3156            return_type: None,
3157            category: FunctionCategory::Scalar,
3158        }),
3159        "encode" => Some(FunctionSignature {
3160            name: "encode",
3161            display_name: "ENCODE",
3162            params: PARAMS_ENCODE,
3163            return_type: None,
3164            category: FunctionCategory::Scalar,
3165        }),
3166        "ends_with" => Some(FunctionSignature {
3167            name: "ends_with",
3168            display_name: "ENDS_WITH",
3169            params: PARAMS_ENDS_WITH,
3170            return_type: None,
3171            category: FunctionCategory::Scalar,
3172        }),
3173        "equal_null" => Some(FunctionSignature {
3174            name: "equal_null",
3175            display_name: "EQUAL_NULL",
3176            params: PARAMS_EQUAL_NULL,
3177            return_type: None,
3178            category: FunctionCategory::Scalar,
3179        }),
3180        "euclidean_distance" => Some(FunctionSignature {
3181            name: "euclidean_distance",
3182            display_name: "EUCLIDEAN_DISTANCE",
3183            params: PARAMS_EUCLIDEAN_DISTANCE,
3184            return_type: None,
3185            category: FunctionCategory::Scalar,
3186        }),
3187        "exists" => Some(FunctionSignature {
3188            name: "exists",
3189            display_name: "EXISTS",
3190            params: PARAMS_EXISTS,
3191            return_type: None,
3192            category: FunctionCategory::Scalar,
3193        }),
3194        "exp" => Some(FunctionSignature {
3195            name: "exp",
3196            display_name: "EXP",
3197            params: PARAMS_EXP,
3198            return_type: None,
3199            category: FunctionCategory::Scalar,
3200        }),
3201        "explode" => Some(FunctionSignature {
3202            name: "explode",
3203            display_name: "EXPLODE",
3204            params: PARAMS_EXPLODE,
3205            return_type: None,
3206            category: FunctionCategory::Scalar,
3207        }),
3208        "explode_outer" => Some(FunctionSignature {
3209            name: "explode_outer",
3210            display_name: "EXPLODE_OUTER",
3211            params: PARAMS_EXPLODE_OUTER,
3212            return_type: None,
3213            category: FunctionCategory::Scalar,
3214        }),
3215        "exploding_generate_series" => Some(FunctionSignature {
3216            name: "exploding_generate_series",
3217            display_name: "EXPLODING_GENERATE_SERIES",
3218            params: PARAMS_EXPLODING_GENERATE_SERIES,
3219            return_type: None,
3220            category: FunctionCategory::Scalar,
3221        }),
3222        "extract" => Some(FunctionSignature {
3223            name: "extract",
3224            display_name: "EXTRACT",
3225            params: PARAMS_EXTRACT,
3226            return_type: None,
3227            category: FunctionCategory::Scalar,
3228        }),
3229        "factorial" => Some(FunctionSignature {
3230            name: "factorial",
3231            display_name: "FACTORIAL",
3232            params: PARAMS_FACTORIAL,
3233            return_type: None,
3234            category: FunctionCategory::Scalar,
3235        }),
3236        "farm_fingerprint" => Some(FunctionSignature {
3237            name: "farm_fingerprint",
3238            display_name: "FARM_FINGERPRINT",
3239            params: PARAMS_FARM_FINGERPRINT,
3240            return_type: None,
3241            category: FunctionCategory::Scalar,
3242        }),
3243        "features_at_time" => Some(FunctionSignature {
3244            name: "features_at_time",
3245            display_name: "FEATURES_AT_TIME",
3246            params: PARAMS_FEATURES_AT_TIME,
3247            return_type: None,
3248            category: FunctionCategory::Scalar,
3249        }),
3250        "first" => Some(FunctionSignature {
3251            name: "first",
3252            display_name: "FIRST",
3253            params: PARAMS_FIRST,
3254            return_type: None,
3255            category: FunctionCategory::Aggregate,
3256        }),
3257        "first_value" => Some(FunctionSignature {
3258            name: "first_value",
3259            display_name: "FIRST_VALUE",
3260            params: PARAMS_FIRST_VALUE,
3261            return_type: Some(ReturnTypeRule::MatchFirstArg),
3262            category: FunctionCategory::Window,
3263        }),
3264        "flatten" => Some(FunctionSignature {
3265            name: "flatten",
3266            display_name: "FLATTEN",
3267            params: PARAMS_FLATTEN,
3268            return_type: None,
3269            category: FunctionCategory::Scalar,
3270        }),
3271        "float64" => Some(FunctionSignature {
3272            name: "float64",
3273            display_name: "FLOAT64",
3274            params: PARAMS_FLOAT64,
3275            return_type: None,
3276            category: FunctionCategory::Scalar,
3277        }),
3278        "floor" => Some(FunctionSignature {
3279            name: "floor",
3280            display_name: "FLOOR",
3281            params: PARAMS_FLOOR,
3282            return_type: None,
3283            category: FunctionCategory::Scalar,
3284        }),
3285        "format" => Some(FunctionSignature {
3286            name: "format",
3287            display_name: "FORMAT",
3288            params: PARAMS_FORMAT,
3289            return_type: None,
3290            category: FunctionCategory::Scalar,
3291        }),
3292        "from_base" => Some(FunctionSignature {
3293            name: "from_base",
3294            display_name: "FROM_BASE",
3295            params: PARAMS_FROM_BASE,
3296            return_type: None,
3297            category: FunctionCategory::Scalar,
3298        }),
3299        "from_base32" => Some(FunctionSignature {
3300            name: "from_base32",
3301            display_name: "FROM_BASE32",
3302            params: PARAMS_FROM_BASE32,
3303            return_type: None,
3304            category: FunctionCategory::Scalar,
3305        }),
3306        "from_base64" => Some(FunctionSignature {
3307            name: "from_base64",
3308            display_name: "FROM_BASE64",
3309            params: PARAMS_FROM_BASE64,
3310            return_type: None,
3311            category: FunctionCategory::Scalar,
3312        }),
3313        "from_iso8601timestamp" => Some(FunctionSignature {
3314            name: "from_iso8601timestamp",
3315            display_name: "FROM_ISO8601TIMESTAMP",
3316            params: PARAMS_FROM_ISO8601TIMESTAMP,
3317            return_type: None,
3318            category: FunctionCategory::Scalar,
3319        }),
3320        "gap_fill" => Some(FunctionSignature {
3321            name: "gap_fill",
3322            display_name: "GAP_FILL",
3323            params: PARAMS_GAP_FILL,
3324            return_type: None,
3325            category: FunctionCategory::Scalar,
3326        }),
3327        "generate_date_array" => Some(FunctionSignature {
3328            name: "generate_date_array",
3329            display_name: "GENERATE_DATE_ARRAY",
3330            params: PARAMS_GENERATE_DATE_ARRAY,
3331            return_type: None,
3332            category: FunctionCategory::Scalar,
3333        }),
3334        "generate_embedding" => Some(FunctionSignature {
3335            name: "generate_embedding",
3336            display_name: "GENERATE_EMBEDDING",
3337            params: PARAMS_GENERATE_EMBEDDING,
3338            return_type: None,
3339            category: FunctionCategory::Scalar,
3340        }),
3341        "generate_series" => Some(FunctionSignature {
3342            name: "generate_series",
3343            display_name: "GENERATE_SERIES",
3344            params: PARAMS_GENERATE_SERIES,
3345            return_type: None,
3346            category: FunctionCategory::Scalar,
3347        }),
3348        "generate_timestamp_array" => Some(FunctionSignature {
3349            name: "generate_timestamp_array",
3350            display_name: "GENERATE_TIMESTAMP_ARRAY",
3351            params: PARAMS_GENERATE_TIMESTAMP_ARRAY,
3352            return_type: None,
3353            category: FunctionCategory::Scalar,
3354        }),
3355        "uuid" => Some(FunctionSignature {
3356            name: "uuid",
3357            display_name: "UUID",
3358            params: PARAMS_UUID,
3359            return_type: None,
3360            category: FunctionCategory::Scalar,
3361        }),
3362        "getbit" => Some(FunctionSignature {
3363            name: "getbit",
3364            display_name: "GETBIT",
3365            params: PARAMS_GETBIT,
3366            return_type: None,
3367            category: FunctionCategory::Scalar,
3368        }),
3369        "get_extract" => Some(FunctionSignature {
3370            name: "get_extract",
3371            display_name: "GET_EXTRACT",
3372            params: PARAMS_GET_EXTRACT,
3373            return_type: None,
3374            category: FunctionCategory::Scalar,
3375        }),
3376        "greatest" => Some(FunctionSignature {
3377            name: "greatest",
3378            display_name: "GREATEST",
3379            params: PARAMS_GREATEST,
3380            return_type: None,
3381            category: FunctionCategory::Scalar,
3382        }),
3383        "greatest_ignore_nulls" => Some(FunctionSignature {
3384            name: "greatest_ignore_nulls",
3385            display_name: "GREATEST_IGNORE_NULLS",
3386            params: PARAMS_GREATEST_IGNORE_NULLS,
3387            return_type: None,
3388            category: FunctionCategory::Scalar,
3389        }),
3390        "grouping" => Some(FunctionSignature {
3391            name: "grouping",
3392            display_name: "GROUPING",
3393            params: PARAMS_GROUPING,
3394            return_type: None,
3395            category: FunctionCategory::Aggregate,
3396        }),
3397        "grouping_id" => Some(FunctionSignature {
3398            name: "grouping_id",
3399            display_name: "GROUPING_ID",
3400            params: PARAMS_GROUPING_ID,
3401            return_type: None,
3402            category: FunctionCategory::Aggregate,
3403        }),
3404        "group_concat" => Some(FunctionSignature {
3405            name: "group_concat",
3406            display_name: "GROUP_CONCAT",
3407            params: PARAMS_GROUP_CONCAT,
3408            return_type: None,
3409            category: FunctionCategory::Aggregate,
3410        }),
3411        "hex" => Some(FunctionSignature {
3412            name: "hex",
3413            display_name: "HEX",
3414            params: PARAMS_HEX,
3415            return_type: None,
3416            category: FunctionCategory::Scalar,
3417        }),
3418        "hex_decode_string" => Some(FunctionSignature {
3419            name: "hex_decode_string",
3420            display_name: "HEX_DECODE_STRING",
3421            params: PARAMS_HEX_DECODE_STRING,
3422            return_type: None,
3423            category: FunctionCategory::Scalar,
3424        }),
3425        "hex_encode" => Some(FunctionSignature {
3426            name: "hex_encode",
3427            display_name: "HEX_ENCODE",
3428            params: PARAMS_HEX_ENCODE,
3429            return_type: None,
3430            category: FunctionCategory::Scalar,
3431        }),
3432        "hll" => Some(FunctionSignature {
3433            name: "hll",
3434            display_name: "HLL",
3435            params: PARAMS_HLL,
3436            return_type: None,
3437            category: FunctionCategory::Aggregate,
3438        }),
3439        "hour" => Some(FunctionSignature {
3440            name: "hour",
3441            display_name: "HOUR",
3442            params: PARAMS_HOUR,
3443            return_type: None,
3444            category: FunctionCategory::Scalar,
3445        }),
3446        "if" => Some(FunctionSignature {
3447            name: "if",
3448            display_name: "IF",
3449            params: PARAMS_IF,
3450            return_type: None,
3451            category: FunctionCategory::Scalar,
3452        }),
3453        "initcap" => Some(FunctionSignature {
3454            name: "initcap",
3455            display_name: "INITCAP",
3456            params: PARAMS_INITCAP,
3457            return_type: None,
3458            category: FunctionCategory::Scalar,
3459        }),
3460        "inline" => Some(FunctionSignature {
3461            name: "inline",
3462            display_name: "INLINE",
3463            params: PARAMS_INLINE,
3464            return_type: None,
3465            category: FunctionCategory::Scalar,
3466        }),
3467        "stuff" => Some(FunctionSignature {
3468            name: "stuff",
3469            display_name: "STUFF",
3470            params: PARAMS_STUFF,
3471            return_type: None,
3472            category: FunctionCategory::Scalar,
3473        }),
3474        "int64" => Some(FunctionSignature {
3475            name: "int64",
3476            display_name: "INT64",
3477            params: PARAMS_INT64,
3478            return_type: None,
3479            category: FunctionCategory::Scalar,
3480        }),
3481        "is_inf" => Some(FunctionSignature {
3482            name: "is_inf",
3483            display_name: "IS_INF",
3484            params: PARAMS_IS_INF,
3485            return_type: None,
3486            category: FunctionCategory::Scalar,
3487        }),
3488        "is_nan" => Some(FunctionSignature {
3489            name: "is_nan",
3490            display_name: "IS_NAN",
3491            params: PARAMS_IS_NAN,
3492            return_type: None,
3493            category: FunctionCategory::Scalar,
3494        }),
3495        "is_ascii" => Some(FunctionSignature {
3496            name: "is_ascii",
3497            display_name: "IS_ASCII",
3498            params: PARAMS_IS_ASCII,
3499            return_type: None,
3500            category: FunctionCategory::Scalar,
3501        }),
3502        "is_null_value" => Some(FunctionSignature {
3503            name: "is_null_value",
3504            display_name: "IS_NULL_VALUE",
3505            params: PARAMS_IS_NULL_VALUE,
3506            return_type: None,
3507            category: FunctionCategory::Scalar,
3508        }),
3509        "jarowinkler_similarity" => Some(FunctionSignature {
3510            name: "jarowinkler_similarity",
3511            display_name: "JAROWINKLER_SIMILARITY",
3512            params: PARAMS_JAROWINKLER_SIMILARITY,
3513            return_type: None,
3514            category: FunctionCategory::Scalar,
3515        }),
3516        "jsonb_contains" => Some(FunctionSignature {
3517            name: "jsonb_contains",
3518            display_name: "JSONB_CONTAINS",
3519            params: PARAMS_JSONB_CONTAINS,
3520            return_type: None,
3521            category: FunctionCategory::Scalar,
3522        }),
3523        "jsonb_exists" => Some(FunctionSignature {
3524            name: "jsonb_exists",
3525            display_name: "JSONB_EXISTS",
3526            params: PARAMS_JSONB_EXISTS,
3527            return_type: None,
3528            category: FunctionCategory::Scalar,
3529        }),
3530        "jsonb_extract" => Some(FunctionSignature {
3531            name: "jsonb_extract",
3532            display_name: "JSONB_EXTRACT",
3533            params: PARAMS_JSONB_EXTRACT,
3534            return_type: None,
3535            category: FunctionCategory::Scalar,
3536        }),
3537        "jsonb_extract_scalar" => Some(FunctionSignature {
3538            name: "jsonb_extract_scalar",
3539            display_name: "JSONB_EXTRACT_SCALAR",
3540            params: PARAMS_JSONB_EXTRACT_SCALAR,
3541            return_type: None,
3542            category: FunctionCategory::Scalar,
3543        }),
3544        "json_array_append" => Some(FunctionSignature {
3545            name: "json_array_append",
3546            display_name: "JSON_ARRAY_APPEND",
3547            params: PARAMS_JSON_ARRAY_APPEND,
3548            return_type: None,
3549            category: FunctionCategory::Scalar,
3550        }),
3551        "json_array_contains" => Some(FunctionSignature {
3552            name: "json_array_contains",
3553            display_name: "JSON_ARRAY_CONTAINS",
3554            params: PARAMS_JSON_ARRAY_CONTAINS,
3555            return_type: None,
3556            category: FunctionCategory::Scalar,
3557        }),
3558        "json_array_insert" => Some(FunctionSignature {
3559            name: "json_array_insert",
3560            display_name: "JSON_ARRAY_INSERT",
3561            params: PARAMS_JSON_ARRAY_INSERT,
3562            return_type: None,
3563            category: FunctionCategory::Scalar,
3564        }),
3565        "json_extract" => Some(FunctionSignature {
3566            name: "json_extract",
3567            display_name: "JSON_EXTRACT",
3568            params: PARAMS_JSON_EXTRACT,
3569            return_type: None,
3570            category: FunctionCategory::Scalar,
3571        }),
3572        "json_extract_array" => Some(FunctionSignature {
3573            name: "json_extract_array",
3574            display_name: "JSON_EXTRACT_ARRAY",
3575            params: PARAMS_JSON_EXTRACT_ARRAY,
3576            return_type: None,
3577            category: FunctionCategory::Scalar,
3578        }),
3579        "json_extract_scalar" => Some(FunctionSignature {
3580            name: "json_extract_scalar",
3581            display_name: "JSON_EXTRACT_SCALAR",
3582            params: PARAMS_JSON_EXTRACT_SCALAR,
3583            return_type: None,
3584            category: FunctionCategory::Scalar,
3585        }),
3586        "json_format" => Some(FunctionSignature {
3587            name: "json_format",
3588            display_name: "JSON_FORMAT",
3589            params: PARAMS_JSON_FORMAT,
3590            return_type: None,
3591            category: FunctionCategory::Scalar,
3592        }),
3593        "parse_json" => Some(FunctionSignature {
3594            name: "parse_json",
3595            display_name: "PARSE_JSON",
3596            params: PARAMS_PARSE_JSON,
3597            return_type: None,
3598            category: FunctionCategory::Scalar,
3599        }),
3600        "json_remove" => Some(FunctionSignature {
3601            name: "json_remove",
3602            display_name: "JSON_REMOVE",
3603            params: PARAMS_JSON_REMOVE,
3604            return_type: None,
3605            category: FunctionCategory::Scalar,
3606        }),
3607        "json_set" => Some(FunctionSignature {
3608            name: "json_set",
3609            display_name: "JSON_SET",
3610            params: PARAMS_JSON_SET,
3611            return_type: None,
3612            category: FunctionCategory::Scalar,
3613        }),
3614        "json_strip_nulls" => Some(FunctionSignature {
3615            name: "json_strip_nulls",
3616            display_name: "JSON_STRIP_NULLS",
3617            params: PARAMS_JSON_STRIP_NULLS,
3618            return_type: None,
3619            category: FunctionCategory::Scalar,
3620        }),
3621        "json_type" => Some(FunctionSignature {
3622            name: "json_type",
3623            display_name: "JSON_TYPE",
3624            params: PARAMS_JSON_TYPE,
3625            return_type: None,
3626            category: FunctionCategory::Scalar,
3627        }),
3628        "justify_days" => Some(FunctionSignature {
3629            name: "justify_days",
3630            display_name: "JUSTIFY_DAYS",
3631            params: PARAMS_JUSTIFY_DAYS,
3632            return_type: None,
3633            category: FunctionCategory::Scalar,
3634        }),
3635        "justify_hours" => Some(FunctionSignature {
3636            name: "justify_hours",
3637            display_name: "JUSTIFY_HOURS",
3638            params: PARAMS_JUSTIFY_HOURS,
3639            return_type: None,
3640            category: FunctionCategory::Scalar,
3641        }),
3642        "justify_interval" => Some(FunctionSignature {
3643            name: "justify_interval",
3644            display_name: "JUSTIFY_INTERVAL",
3645            params: PARAMS_JUSTIFY_INTERVAL,
3646            return_type: None,
3647            category: FunctionCategory::Scalar,
3648        }),
3649        "json_array" => Some(FunctionSignature {
3650            name: "json_array",
3651            display_name: "JSON_ARRAY",
3652            params: PARAMS_JSON_ARRAY,
3653            return_type: None,
3654            category: FunctionCategory::Scalar,
3655        }),
3656        "json_array_agg" => Some(FunctionSignature {
3657            name: "json_array_agg",
3658            display_name: "JSON_ARRAY_AGG",
3659            params: PARAMS_JSON_ARRAY_AGG,
3660            return_type: None,
3661            category: FunctionCategory::Scalar,
3662        }),
3663        "json_bool" => Some(FunctionSignature {
3664            name: "json_bool",
3665            display_name: "JSON_BOOL",
3666            params: PARAMS_JSON_BOOL,
3667            return_type: None,
3668            category: FunctionCategory::Scalar,
3669        }),
3670        "jsonb_contains_all_top_keys" => Some(FunctionSignature {
3671            name: "jsonb_contains_all_top_keys",
3672            display_name: "JSONB_CONTAINS_ALL_TOP_KEYS",
3673            params: PARAMS_JSONB_CONTAINS_ALL_TOP_KEYS,
3674            return_type: None,
3675            category: FunctionCategory::Scalar,
3676        }),
3677        "jsonb_contains_any_top_keys" => Some(FunctionSignature {
3678            name: "jsonb_contains_any_top_keys",
3679            display_name: "JSONB_CONTAINS_ANY_TOP_KEYS",
3680            params: PARAMS_JSONB_CONTAINS_ANY_TOP_KEYS,
3681            return_type: None,
3682            category: FunctionCategory::Scalar,
3683        }),
3684        "jsonb_delete_at_path" => Some(FunctionSignature {
3685            name: "jsonb_delete_at_path",
3686            display_name: "JSONB_DELETE_AT_PATH",
3687            params: PARAMS_JSONB_DELETE_AT_PATH,
3688            return_type: None,
3689            category: FunctionCategory::Scalar,
3690        }),
3691        "jsonb_object_agg" => Some(FunctionSignature {
3692            name: "jsonb_object_agg",
3693            display_name: "JSONB_OBJECT_AGG",
3694            params: PARAMS_JSONB_OBJECT_AGG,
3695            return_type: None,
3696            category: FunctionCategory::Aggregate,
3697        }),
3698        "json_cast" => Some(FunctionSignature {
3699            name: "json_cast",
3700            display_name: "JSON_CAST",
3701            params: PARAMS_JSON_CAST,
3702            return_type: None,
3703            category: FunctionCategory::Scalar,
3704        }),
3705        "json_exists" => Some(FunctionSignature {
3706            name: "json_exists",
3707            display_name: "JSON_EXISTS",
3708            params: PARAMS_JSON_EXISTS,
3709            return_type: None,
3710            category: FunctionCategory::Scalar,
3711        }),
3712        "json_keys_at_depth" => Some(FunctionSignature {
3713            name: "json_keys_at_depth",
3714            display_name: "JSON_KEYS_AT_DEPTH",
3715            params: PARAMS_JSON_KEYS_AT_DEPTH,
3716            return_type: None,
3717            category: FunctionCategory::Scalar,
3718        }),
3719        "json_object" => Some(FunctionSignature {
3720            name: "json_object",
3721            display_name: "JSON_OBJECT",
3722            params: PARAMS_JSON_OBJECT,
3723            return_type: None,
3724            category: FunctionCategory::Scalar,
3725        }),
3726        "json_object_agg" => Some(FunctionSignature {
3727            name: "json_object_agg",
3728            display_name: "JSON_OBJECT_AGG",
3729            params: PARAMS_JSON_OBJECT_AGG,
3730            return_type: None,
3731            category: FunctionCategory::Aggregate,
3732        }),
3733        "json_table" => Some(FunctionSignature {
3734            name: "json_table",
3735            display_name: "JSON_TABLE",
3736            params: PARAMS_JSON_TABLE,
3737            return_type: None,
3738            category: FunctionCategory::Scalar,
3739        }),
3740        "json_value_array" => Some(FunctionSignature {
3741            name: "json_value_array",
3742            display_name: "JSON_VALUE_ARRAY",
3743            params: PARAMS_JSON_VALUE_ARRAY,
3744            return_type: None,
3745            category: FunctionCategory::Scalar,
3746        }),
3747        "lag" => Some(FunctionSignature {
3748            name: "lag",
3749            display_name: "LAG",
3750            params: PARAMS_LAG,
3751            return_type: Some(ReturnTypeRule::MatchFirstArg),
3752            category: FunctionCategory::Window,
3753        }),
3754        "last" => Some(FunctionSignature {
3755            name: "last",
3756            display_name: "LAST",
3757            params: PARAMS_LAST,
3758            return_type: None,
3759            category: FunctionCategory::Aggregate,
3760        }),
3761        "last_day" => Some(FunctionSignature {
3762            name: "last_day",
3763            display_name: "LAST_DAY",
3764            params: PARAMS_LAST_DAY,
3765            return_type: None,
3766            category: FunctionCategory::Scalar,
3767        }),
3768        "last_value" => Some(FunctionSignature {
3769            name: "last_value",
3770            display_name: "LAST_VALUE",
3771            params: PARAMS_LAST_VALUE,
3772            return_type: Some(ReturnTypeRule::MatchFirstArg),
3773            category: FunctionCategory::Window,
3774        }),
3775        "lax_bool" => Some(FunctionSignature {
3776            name: "lax_bool",
3777            display_name: "LAX_BOOL",
3778            params: PARAMS_LAX_BOOL,
3779            return_type: None,
3780            category: FunctionCategory::Scalar,
3781        }),
3782        "lax_float64" => Some(FunctionSignature {
3783            name: "lax_float64",
3784            display_name: "LAX_FLOAT64",
3785            params: PARAMS_LAX_FLOAT64,
3786            return_type: None,
3787            category: FunctionCategory::Scalar,
3788        }),
3789        "lax_int64" => Some(FunctionSignature {
3790            name: "lax_int64",
3791            display_name: "LAX_INT64",
3792            params: PARAMS_LAX_INT64,
3793            return_type: None,
3794            category: FunctionCategory::Scalar,
3795        }),
3796        "lax_string" => Some(FunctionSignature {
3797            name: "lax_string",
3798            display_name: "LAX_STRING",
3799            params: PARAMS_LAX_STRING,
3800            return_type: None,
3801            category: FunctionCategory::Scalar,
3802        }),
3803        "lower" => Some(FunctionSignature {
3804            name: "lower",
3805            display_name: "LOWER",
3806            params: PARAMS_LOWER,
3807            return_type: Some(ReturnTypeRule::Text),
3808            category: FunctionCategory::Scalar,
3809        }),
3810        "lead" => Some(FunctionSignature {
3811            name: "lead",
3812            display_name: "LEAD",
3813            params: PARAMS_LEAD,
3814            return_type: Some(ReturnTypeRule::MatchFirstArg),
3815            category: FunctionCategory::Window,
3816        }),
3817        "least" => Some(FunctionSignature {
3818            name: "least",
3819            display_name: "LEAST",
3820            params: PARAMS_LEAST,
3821            return_type: None,
3822            category: FunctionCategory::Scalar,
3823        }),
3824        "least_ignore_nulls" => Some(FunctionSignature {
3825            name: "least_ignore_nulls",
3826            display_name: "LEAST_IGNORE_NULLS",
3827            params: PARAMS_LEAST_IGNORE_NULLS,
3828            return_type: None,
3829            category: FunctionCategory::Scalar,
3830        }),
3831        "left" => Some(FunctionSignature {
3832            name: "left",
3833            display_name: "LEFT",
3834            params: PARAMS_LEFT,
3835            return_type: None,
3836            category: FunctionCategory::Scalar,
3837        }),
3838        "levenshtein" => Some(FunctionSignature {
3839            name: "levenshtein",
3840            display_name: "LEVENSHTEIN",
3841            params: PARAMS_LEVENSHTEIN,
3842            return_type: None,
3843            category: FunctionCategory::Scalar,
3844        }),
3845        "list" => Some(FunctionSignature {
3846            name: "list",
3847            display_name: "LIST",
3848            params: PARAMS_LIST,
3849            return_type: None,
3850            category: FunctionCategory::Scalar,
3851        }),
3852        "ln" => Some(FunctionSignature {
3853            name: "ln",
3854            display_name: "LN",
3855            params: PARAMS_LN,
3856            return_type: None,
3857            category: FunctionCategory::Scalar,
3858        }),
3859        "log" => Some(FunctionSignature {
3860            name: "log",
3861            display_name: "LOG",
3862            params: PARAMS_LOG,
3863            return_type: None,
3864            category: FunctionCategory::Scalar,
3865        }),
3866        "lower_hex" => Some(FunctionSignature {
3867            name: "lower_hex",
3868            display_name: "LOWER_HEX",
3869            params: PARAMS_LOWER_HEX,
3870            return_type: None,
3871            category: FunctionCategory::Scalar,
3872        }),
3873        "make_interval" => Some(FunctionSignature {
3874            name: "make_interval",
3875            display_name: "MAKE_INTERVAL",
3876            params: PARAMS_MAKE_INTERVAL,
3877            return_type: None,
3878            category: FunctionCategory::Scalar,
3879        }),
3880        "map" => Some(FunctionSignature {
3881            name: "map",
3882            display_name: "MAP",
3883            params: PARAMS_MAP,
3884            return_type: None,
3885            category: FunctionCategory::Scalar,
3886        }),
3887        "map_from_entries" => Some(FunctionSignature {
3888            name: "map_from_entries",
3889            display_name: "MAP_FROM_ENTRIES",
3890            params: PARAMS_MAP_FROM_ENTRIES,
3891            return_type: None,
3892            category: FunctionCategory::Scalar,
3893        }),
3894        "match_against" => Some(FunctionSignature {
3895            name: "match_against",
3896            display_name: "MATCH_AGAINST",
3897            params: PARAMS_MATCH_AGAINST,
3898            return_type: None,
3899            category: FunctionCategory::Scalar,
3900        }),
3901        "max" => Some(FunctionSignature {
3902            name: "max",
3903            display_name: "MAX",
3904            params: PARAMS_MAX,
3905            return_type: Some(ReturnTypeRule::MatchFirstArg),
3906            category: FunctionCategory::Aggregate,
3907        }),
3908        "md5" => Some(FunctionSignature {
3909            name: "md5",
3910            display_name: "MD5",
3911            params: PARAMS_MD5,
3912            return_type: None,
3913            category: FunctionCategory::Scalar,
3914        }),
3915        "md5digest" => Some(FunctionSignature {
3916            name: "md5digest",
3917            display_name: "MD5DIGEST",
3918            params: PARAMS_MD5DIGEST,
3919            return_type: None,
3920            category: FunctionCategory::Scalar,
3921        }),
3922        "median" => Some(FunctionSignature {
3923            name: "median",
3924            display_name: "MEDIAN",
3925            params: PARAMS_MEDIAN,
3926            return_type: None,
3927            category: FunctionCategory::Aggregate,
3928        }),
3929        "min" => Some(FunctionSignature {
3930            name: "min",
3931            display_name: "MIN",
3932            params: PARAMS_MIN,
3933            return_type: Some(ReturnTypeRule::MatchFirstArg),
3934            category: FunctionCategory::Aggregate,
3935        }),
3936        "minhash" => Some(FunctionSignature {
3937            name: "minhash",
3938            display_name: "MINHASH",
3939            params: PARAMS_MINHASH,
3940            return_type: None,
3941            category: FunctionCategory::Aggregate,
3942        }),
3943        "minhash_combine" => Some(FunctionSignature {
3944            name: "minhash_combine",
3945            display_name: "MINHASH_COMBINE",
3946            params: PARAMS_MINHASH_COMBINE,
3947            return_type: None,
3948            category: FunctionCategory::Aggregate,
3949        }),
3950        "minute" => Some(FunctionSignature {
3951            name: "minute",
3952            display_name: "MINUTE",
3953            params: PARAMS_MINUTE,
3954            return_type: None,
3955            category: FunctionCategory::Scalar,
3956        }),
3957        "month" => Some(FunctionSignature {
3958            name: "month",
3959            display_name: "MONTH",
3960            params: PARAMS_MONTH,
3961            return_type: None,
3962            category: FunctionCategory::Scalar,
3963        }),
3964        "monthname" => Some(FunctionSignature {
3965            name: "monthname",
3966            display_name: "MONTHNAME",
3967            params: PARAMS_MONTHNAME,
3968            return_type: None,
3969            category: FunctionCategory::Scalar,
3970        }),
3971        "months_between" => Some(FunctionSignature {
3972            name: "months_between",
3973            display_name: "MONTHS_BETWEEN",
3974            params: PARAMS_MONTHS_BETWEEN,
3975            return_type: None,
3976            category: FunctionCategory::Scalar,
3977        }),
3978        "md5number_lower64" => Some(FunctionSignature {
3979            name: "md5number_lower64",
3980            display_name: "MD5NUMBER_LOWER64",
3981            params: PARAMS_MD5NUMBER_LOWER64,
3982            return_type: None,
3983            category: FunctionCategory::Scalar,
3984        }),
3985        "md5number_upper64" => Some(FunctionSignature {
3986            name: "md5number_upper64",
3987            display_name: "MD5NUMBER_UPPER64",
3988            params: PARAMS_MD5NUMBER_UPPER64,
3989            return_type: None,
3990            category: FunctionCategory::Scalar,
3991        }),
3992        "ml_forecast" => Some(FunctionSignature {
3993            name: "ml_forecast",
3994            display_name: "ML_FORECAST",
3995            params: PARAMS_ML_FORECAST,
3996            return_type: None,
3997            category: FunctionCategory::Scalar,
3998        }),
3999        "ml_translate" => Some(FunctionSignature {
4000            name: "ml_translate",
4001            display_name: "ML_TRANSLATE",
4002            params: PARAMS_ML_TRANSLATE,
4003            return_type: None,
4004            category: FunctionCategory::Scalar,
4005        }),
4006        "next_day" => Some(FunctionSignature {
4007            name: "next_day",
4008            display_name: "NEXT_DAY",
4009            params: PARAMS_NEXT_DAY,
4010            return_type: None,
4011            category: FunctionCategory::Scalar,
4012        }),
4013        "next_value_for" => Some(FunctionSignature {
4014            name: "next_value_for",
4015            display_name: "NEXT_VALUE_FOR",
4016            params: PARAMS_NEXT_VALUE_FOR,
4017            return_type: None,
4018            category: FunctionCategory::Scalar,
4019        }),
4020        "normalize" => Some(FunctionSignature {
4021            name: "normalize",
4022            display_name: "NORMALIZE",
4023            params: PARAMS_NORMALIZE,
4024            return_type: None,
4025            category: FunctionCategory::Scalar,
4026        }),
4027        "now" => Some(FunctionSignature {
4028            name: "now",
4029            display_name: "NOW",
4030            params: &[],
4031            return_type: Some(ReturnTypeRule::Timestamp),
4032            category: FunctionCategory::Scalar,
4033        }),
4034        "nth_value" => Some(FunctionSignature {
4035            name: "nth_value",
4036            display_name: "NTH_VALUE",
4037            params: PARAMS_NTH_VALUE,
4038            return_type: None,
4039            category: FunctionCategory::Window,
4040        }),
4041        "ntile" => Some(FunctionSignature {
4042            name: "ntile",
4043            display_name: "NTILE",
4044            params: PARAMS_NTILE,
4045            return_type: Some(ReturnTypeRule::Integer),
4046            category: FunctionCategory::Window,
4047        }),
4048        "nullif" => Some(FunctionSignature {
4049            name: "nullif",
4050            display_name: "NULLIF",
4051            params: PARAMS_NULLIF,
4052            return_type: None,
4053            category: FunctionCategory::Scalar,
4054        }),
4055        "number_to_str" => Some(FunctionSignature {
4056            name: "number_to_str",
4057            display_name: "NUMBER_TO_STR",
4058            params: PARAMS_NUMBER_TO_STR,
4059            return_type: None,
4060            category: FunctionCategory::Scalar,
4061        }),
4062        "nvl2" => Some(FunctionSignature {
4063            name: "nvl2",
4064            display_name: "NVL2",
4065            params: PARAMS_NVL2,
4066            return_type: None,
4067            category: FunctionCategory::Scalar,
4068        }),
4069        "object_agg" => Some(FunctionSignature {
4070            name: "object_agg",
4071            display_name: "OBJECT_AGG",
4072            params: PARAMS_OBJECT_AGG,
4073            return_type: None,
4074            category: FunctionCategory::Aggregate,
4075        }),
4076        "object_insert" => Some(FunctionSignature {
4077            name: "object_insert",
4078            display_name: "OBJECT_INSERT",
4079            params: PARAMS_OBJECT_INSERT,
4080            return_type: None,
4081            category: FunctionCategory::Scalar,
4082        }),
4083        "open_json" => Some(FunctionSignature {
4084            name: "open_json",
4085            display_name: "OPEN_JSON",
4086            params: PARAMS_OPEN_JSON,
4087            return_type: None,
4088            category: FunctionCategory::Scalar,
4089        }),
4090        "or" => Some(FunctionSignature {
4091            name: "or",
4092            display_name: "OR",
4093            params: PARAMS_OR,
4094            return_type: Some(ReturnTypeRule::Boolean),
4095            category: FunctionCategory::Scalar,
4096        }),
4097        "overlay" => Some(FunctionSignature {
4098            name: "overlay",
4099            display_name: "OVERLAY",
4100            params: PARAMS_OVERLAY,
4101            return_type: None,
4102            category: FunctionCategory::Scalar,
4103        }),
4104        "pad" => Some(FunctionSignature {
4105            name: "pad",
4106            display_name: "PAD",
4107            params: PARAMS_PAD,
4108            return_type: None,
4109            category: FunctionCategory::Scalar,
4110        }),
4111        "parameterized_agg" => Some(FunctionSignature {
4112            name: "parameterized_agg",
4113            display_name: "PARAMETERIZED_AGG",
4114            params: PARAMS_PARAMETERIZED_AGG,
4115            return_type: None,
4116            category: FunctionCategory::Aggregate,
4117        }),
4118        "parse_bignumeric" => Some(FunctionSignature {
4119            name: "parse_bignumeric",
4120            display_name: "PARSE_BIGNUMERIC",
4121            params: PARAMS_PARSE_BIGNUMERIC,
4122            return_type: None,
4123            category: FunctionCategory::Scalar,
4124        }),
4125        "parse_datetime" => Some(FunctionSignature {
4126            name: "parse_datetime",
4127            display_name: "PARSE_DATETIME",
4128            params: PARAMS_PARSE_DATETIME,
4129            return_type: None,
4130            category: FunctionCategory::Scalar,
4131        }),
4132        "parse_ip" => Some(FunctionSignature {
4133            name: "parse_ip",
4134            display_name: "PARSE_IP",
4135            params: PARAMS_PARSE_IP,
4136            return_type: None,
4137            category: FunctionCategory::Scalar,
4138        }),
4139        "parse_numeric" => Some(FunctionSignature {
4140            name: "parse_numeric",
4141            display_name: "PARSE_NUMERIC",
4142            params: PARAMS_PARSE_NUMERIC,
4143            return_type: None,
4144            category: FunctionCategory::Scalar,
4145        }),
4146        "parse_time" => Some(FunctionSignature {
4147            name: "parse_time",
4148            display_name: "PARSE_TIME",
4149            params: PARAMS_PARSE_TIME,
4150            return_type: None,
4151            category: FunctionCategory::Scalar,
4152        }),
4153        "parse_url" => Some(FunctionSignature {
4154            name: "parse_url",
4155            display_name: "PARSE_URL",
4156            params: PARAMS_PARSE_URL,
4157            return_type: None,
4158            category: FunctionCategory::Scalar,
4159        }),
4160        "percentile_cont" => Some(FunctionSignature {
4161            name: "percentile_cont",
4162            display_name: "PERCENTILE_CONT",
4163            params: PARAMS_PERCENTILE_CONT,
4164            return_type: None,
4165            category: FunctionCategory::Window,
4166        }),
4167        "percentile_disc" => Some(FunctionSignature {
4168            name: "percentile_disc",
4169            display_name: "PERCENTILE_DISC",
4170            params: PARAMS_PERCENTILE_DISC,
4171            return_type: None,
4172            category: FunctionCategory::Window,
4173        }),
4174        "percent_rank" => Some(FunctionSignature {
4175            name: "percent_rank",
4176            display_name: "PERCENT_RANK",
4177            params: PARAMS_PERCENT_RANK,
4178            return_type: None,
4179            category: FunctionCategory::Window,
4180        }),
4181        "pi" => Some(FunctionSignature {
4182            name: "pi",
4183            display_name: "PI",
4184            params: &[],
4185            return_type: None,
4186            category: FunctionCategory::Scalar,
4187        }),
4188        "posexplode" => Some(FunctionSignature {
4189            name: "posexplode",
4190            display_name: "POSEXPLODE",
4191            params: PARAMS_POSEXPLODE,
4192            return_type: None,
4193            category: FunctionCategory::Scalar,
4194        }),
4195        "posexplode_outer" => Some(FunctionSignature {
4196            name: "posexplode_outer",
4197            display_name: "POSEXPLODE_OUTER",
4198            params: PARAMS_POSEXPLODE_OUTER,
4199            return_type: None,
4200            category: FunctionCategory::Scalar,
4201        }),
4202        "pow" => Some(FunctionSignature {
4203            name: "pow",
4204            display_name: "POW",
4205            params: PARAMS_POW,
4206            return_type: None,
4207            category: FunctionCategory::Scalar,
4208        }),
4209        "predict" => Some(FunctionSignature {
4210            name: "predict",
4211            display_name: "PREDICT",
4212            params: PARAMS_PREDICT,
4213            return_type: None,
4214            category: FunctionCategory::Scalar,
4215        }),
4216        "previous_day" => Some(FunctionSignature {
4217            name: "previous_day",
4218            display_name: "PREVIOUS_DAY",
4219            params: PARAMS_PREVIOUS_DAY,
4220            return_type: None,
4221            category: FunctionCategory::Scalar,
4222        }),
4223        "quantile" => Some(FunctionSignature {
4224            name: "quantile",
4225            display_name: "QUANTILE",
4226            params: PARAMS_QUANTILE,
4227            return_type: None,
4228            category: FunctionCategory::Aggregate,
4229        }),
4230        "quarter" => Some(FunctionSignature {
4231            name: "quarter",
4232            display_name: "QUARTER",
4233            params: PARAMS_QUARTER,
4234            return_type: None,
4235            category: FunctionCategory::Scalar,
4236        }),
4237        "radians" => Some(FunctionSignature {
4238            name: "radians",
4239            display_name: "RADIANS",
4240            params: PARAMS_RADIANS,
4241            return_type: None,
4242            category: FunctionCategory::Scalar,
4243        }),
4244        "rand" => Some(FunctionSignature {
4245            name: "rand",
4246            display_name: "RAND",
4247            params: PARAMS_RAND,
4248            return_type: None,
4249            category: FunctionCategory::Scalar,
4250        }),
4251        "randn" => Some(FunctionSignature {
4252            name: "randn",
4253            display_name: "RANDN",
4254            params: PARAMS_RANDN,
4255            return_type: None,
4256            category: FunctionCategory::Scalar,
4257        }),
4258        "range_bucket" => Some(FunctionSignature {
4259            name: "range_bucket",
4260            display_name: "RANGE_BUCKET",
4261            params: PARAMS_RANGE_BUCKET,
4262            return_type: None,
4263            category: FunctionCategory::Scalar,
4264        }),
4265        "range_n" => Some(FunctionSignature {
4266            name: "range_n",
4267            display_name: "RANGE_N",
4268            params: PARAMS_RANGE_N,
4269            return_type: None,
4270            category: FunctionCategory::Scalar,
4271        }),
4272        "rank" => Some(FunctionSignature {
4273            name: "rank",
4274            display_name: "RANK",
4275            params: PARAMS_RANK,
4276            return_type: Some(ReturnTypeRule::Integer),
4277            category: FunctionCategory::Window,
4278        }),
4279        "read_csv" => Some(FunctionSignature {
4280            name: "read_csv",
4281            display_name: "READ_CSV",
4282            params: PARAMS_READ_CSV,
4283            return_type: None,
4284            category: FunctionCategory::Scalar,
4285        }),
4286        "read_parquet" => Some(FunctionSignature {
4287            name: "read_parquet",
4288            display_name: "READ_PARQUET",
4289            params: PARAMS_READ_PARQUET,
4290            return_type: None,
4291            category: FunctionCategory::Scalar,
4292        }),
4293        "reduce" => Some(FunctionSignature {
4294            name: "reduce",
4295            display_name: "REDUCE",
4296            params: PARAMS_REDUCE,
4297            return_type: None,
4298            category: FunctionCategory::Scalar,
4299        }),
4300        "regexp_count" => Some(FunctionSignature {
4301            name: "regexp_count",
4302            display_name: "REGEXP_COUNT",
4303            params: PARAMS_REGEXP_COUNT,
4304            return_type: None,
4305            category: FunctionCategory::Scalar,
4306        }),
4307        "regexp_extract" => Some(FunctionSignature {
4308            name: "regexp_extract",
4309            display_name: "REGEXP_EXTRACT",
4310            params: PARAMS_REGEXP_EXTRACT,
4311            return_type: None,
4312            category: FunctionCategory::Scalar,
4313        }),
4314        "regexp_extract_all" => Some(FunctionSignature {
4315            name: "regexp_extract_all",
4316            display_name: "REGEXP_EXTRACT_ALL",
4317            params: PARAMS_REGEXP_EXTRACT_ALL,
4318            return_type: None,
4319            category: FunctionCategory::Scalar,
4320        }),
4321        "regexp_full_match" => Some(FunctionSignature {
4322            name: "regexp_full_match",
4323            display_name: "REGEXP_FULL_MATCH",
4324            params: PARAMS_REGEXP_FULL_MATCH,
4325            return_type: None,
4326            category: FunctionCategory::Scalar,
4327        }),
4328        "regexp_instr" => Some(FunctionSignature {
4329            name: "regexp_instr",
4330            display_name: "REGEXP_INSTR",
4331            params: PARAMS_REGEXP_INSTR,
4332            return_type: None,
4333            category: FunctionCategory::Scalar,
4334        }),
4335        "regexp_i_like" => Some(FunctionSignature {
4336            name: "regexp_i_like",
4337            display_name: "REGEXP_I_LIKE",
4338            params: PARAMS_REGEXP_I_LIKE,
4339            return_type: None,
4340            category: FunctionCategory::Scalar,
4341        }),
4342        "regexp_like" => Some(FunctionSignature {
4343            name: "regexp_like",
4344            display_name: "REGEXP_LIKE",
4345            params: PARAMS_REGEXP_LIKE,
4346            return_type: None,
4347            category: FunctionCategory::Scalar,
4348        }),
4349        "regexp_replace" => Some(FunctionSignature {
4350            name: "regexp_replace",
4351            display_name: "REGEXP_REPLACE",
4352            params: PARAMS_REGEXP_REPLACE,
4353            return_type: None,
4354            category: FunctionCategory::Scalar,
4355        }),
4356        "regexp_split" => Some(FunctionSignature {
4357            name: "regexp_split",
4358            display_name: "REGEXP_SPLIT",
4359            params: PARAMS_REGEXP_SPLIT,
4360            return_type: None,
4361            category: FunctionCategory::Scalar,
4362        }),
4363        "regr_avgx" => Some(FunctionSignature {
4364            name: "regr_avgx",
4365            display_name: "REGR_AVGX",
4366            params: PARAMS_REGR_AVGX,
4367            return_type: None,
4368            category: FunctionCategory::Scalar,
4369        }),
4370        "regr_avgy" => Some(FunctionSignature {
4371            name: "regr_avgy",
4372            display_name: "REGR_AVGY",
4373            params: PARAMS_REGR_AVGY,
4374            return_type: None,
4375            category: FunctionCategory::Scalar,
4376        }),
4377        "regr_valx" => Some(FunctionSignature {
4378            name: "regr_valx",
4379            display_name: "REGR_VALX",
4380            params: PARAMS_REGR_VALX,
4381            return_type: None,
4382            category: FunctionCategory::Scalar,
4383        }),
4384        "regr_valy" => Some(FunctionSignature {
4385            name: "regr_valy",
4386            display_name: "REGR_VALY",
4387            params: PARAMS_REGR_VALY,
4388            return_type: None,
4389            category: FunctionCategory::Scalar,
4390        }),
4391        "repeat" => Some(FunctionSignature {
4392            name: "repeat",
4393            display_name: "REPEAT",
4394            params: PARAMS_REPEAT,
4395            return_type: None,
4396            category: FunctionCategory::Scalar,
4397        }),
4398        "replace" => Some(FunctionSignature {
4399            name: "replace",
4400            display_name: "REPLACE",
4401            params: PARAMS_REPLACE,
4402            return_type: Some(ReturnTypeRule::Text),
4403            category: FunctionCategory::Scalar,
4404        }),
4405        "reverse" => Some(FunctionSignature {
4406            name: "reverse",
4407            display_name: "REVERSE",
4408            params: PARAMS_REVERSE,
4409            return_type: None,
4410            category: FunctionCategory::Scalar,
4411        }),
4412        "right" => Some(FunctionSignature {
4413            name: "right",
4414            display_name: "RIGHT",
4415            params: PARAMS_RIGHT,
4416            return_type: None,
4417            category: FunctionCategory::Scalar,
4418        }),
4419        "round" => Some(FunctionSignature {
4420            name: "round",
4421            display_name: "ROUND",
4422            params: PARAMS_ROUND,
4423            return_type: None,
4424            category: FunctionCategory::Scalar,
4425        }),
4426        "row_number" => Some(FunctionSignature {
4427            name: "row_number",
4428            display_name: "ROW_NUMBER",
4429            params: PARAMS_ROW_NUMBER,
4430            return_type: Some(ReturnTypeRule::Integer),
4431            category: FunctionCategory::Window,
4432        }),
4433        "rtrimmed_length" => Some(FunctionSignature {
4434            name: "rtrimmed_length",
4435            display_name: "RTRIMMED_LENGTH",
4436            params: PARAMS_RTRIMMED_LENGTH,
4437            return_type: None,
4438            category: FunctionCategory::Scalar,
4439        }),
4440        "safe_add" => Some(FunctionSignature {
4441            name: "safe_add",
4442            display_name: "SAFE_ADD",
4443            params: PARAMS_SAFE_ADD,
4444            return_type: None,
4445            category: FunctionCategory::Scalar,
4446        }),
4447        "safe_convert_bytes_to_string" => Some(FunctionSignature {
4448            name: "safe_convert_bytes_to_string",
4449            display_name: "SAFE_CONVERT_BYTES_TO_STRING",
4450            params: PARAMS_SAFE_CONVERT_BYTES_TO_STRING,
4451            return_type: None,
4452            category: FunctionCategory::Scalar,
4453        }),
4454        "safe_divide" => Some(FunctionSignature {
4455            name: "safe_divide",
4456            display_name: "SAFE_DIVIDE",
4457            params: PARAMS_SAFE_DIVIDE,
4458            return_type: None,
4459            category: FunctionCategory::Scalar,
4460        }),
4461        "safe_multiply" => Some(FunctionSignature {
4462            name: "safe_multiply",
4463            display_name: "SAFE_MULTIPLY",
4464            params: PARAMS_SAFE_MULTIPLY,
4465            return_type: None,
4466            category: FunctionCategory::Scalar,
4467        }),
4468        "safe_negate" => Some(FunctionSignature {
4469            name: "safe_negate",
4470            display_name: "SAFE_NEGATE",
4471            params: PARAMS_SAFE_NEGATE,
4472            return_type: None,
4473            category: FunctionCategory::Scalar,
4474        }),
4475        "safe_subtract" => Some(FunctionSignature {
4476            name: "safe_subtract",
4477            display_name: "SAFE_SUBTRACT",
4478            params: PARAMS_SAFE_SUBTRACT,
4479            return_type: None,
4480            category: FunctionCategory::Scalar,
4481        }),
4482        "search" => Some(FunctionSignature {
4483            name: "search",
4484            display_name: "SEARCH",
4485            params: PARAMS_SEARCH,
4486            return_type: None,
4487            category: FunctionCategory::Scalar,
4488        }),
4489        "sec" => Some(FunctionSignature {
4490            name: "sec",
4491            display_name: "SEC",
4492            params: PARAMS_SEC,
4493            return_type: None,
4494            category: FunctionCategory::Scalar,
4495        }),
4496        "sech" => Some(FunctionSignature {
4497            name: "sech",
4498            display_name: "SECH",
4499            params: PARAMS_SECH,
4500            return_type: None,
4501            category: FunctionCategory::Scalar,
4502        }),
4503        "second" => Some(FunctionSignature {
4504            name: "second",
4505            display_name: "SECOND",
4506            params: PARAMS_SECOND,
4507            return_type: None,
4508            category: FunctionCategory::Scalar,
4509        }),
4510        "sha" => Some(FunctionSignature {
4511            name: "sha",
4512            display_name: "SHA",
4513            params: PARAMS_SHA,
4514            return_type: None,
4515            category: FunctionCategory::Scalar,
4516        }),
4517        "sha2" => Some(FunctionSignature {
4518            name: "sha2",
4519            display_name: "SHA2",
4520            params: PARAMS_SHA2,
4521            return_type: None,
4522            category: FunctionCategory::Scalar,
4523        }),
4524        "sign" => Some(FunctionSignature {
4525            name: "sign",
4526            display_name: "SIGN",
4527            params: PARAMS_SIGN,
4528            return_type: None,
4529            category: FunctionCategory::Scalar,
4530        }),
4531        "sin" => Some(FunctionSignature {
4532            name: "sin",
4533            display_name: "SIN",
4534            params: PARAMS_SIN,
4535            return_type: None,
4536            category: FunctionCategory::Scalar,
4537        }),
4538        "sinh" => Some(FunctionSignature {
4539            name: "sinh",
4540            display_name: "SINH",
4541            params: PARAMS_SINH,
4542            return_type: None,
4543            category: FunctionCategory::Scalar,
4544        }),
4545        "skewness" => Some(FunctionSignature {
4546            name: "skewness",
4547            display_name: "SKEWNESS",
4548            params: PARAMS_SKEWNESS,
4549            return_type: None,
4550            category: FunctionCategory::Aggregate,
4551        }),
4552        "sort_array" => Some(FunctionSignature {
4553            name: "sort_array",
4554            display_name: "SORT_ARRAY",
4555            params: PARAMS_SORT_ARRAY,
4556            return_type: None,
4557            category: FunctionCategory::Scalar,
4558        }),
4559        "soundex" => Some(FunctionSignature {
4560            name: "soundex",
4561            display_name: "SOUNDEX",
4562            params: PARAMS_SOUNDEX,
4563            return_type: None,
4564            category: FunctionCategory::Scalar,
4565        }),
4566        "soundex_p123" => Some(FunctionSignature {
4567            name: "soundex_p123",
4568            display_name: "SOUNDEX_P123",
4569            params: PARAMS_SOUNDEX_P123,
4570            return_type: None,
4571            category: FunctionCategory::Scalar,
4572        }),
4573        "space" => Some(FunctionSignature {
4574            name: "space",
4575            display_name: "SPACE",
4576            params: PARAMS_SPACE,
4577            return_type: None,
4578            category: FunctionCategory::Scalar,
4579        }),
4580        "split" => Some(FunctionSignature {
4581            name: "split",
4582            display_name: "SPLIT",
4583            params: PARAMS_SPLIT,
4584            return_type: None,
4585            category: FunctionCategory::Scalar,
4586        }),
4587        "string_to_array" => Some(FunctionSignature {
4588            name: "string_to_array",
4589            display_name: "STRING_TO_ARRAY",
4590            params: PARAMS_STRING_TO_ARRAY,
4591            return_type: None,
4592            category: FunctionCategory::Scalar,
4593        }),
4594        "split_part" => Some(FunctionSignature {
4595            name: "split_part",
4596            display_name: "SPLIT_PART",
4597            params: PARAMS_SPLIT_PART,
4598            return_type: None,
4599            category: FunctionCategory::Scalar,
4600        }),
4601        "sqrt" => Some(FunctionSignature {
4602            name: "sqrt",
4603            display_name: "SQRT",
4604            params: PARAMS_SQRT,
4605            return_type: None,
4606            category: FunctionCategory::Scalar,
4607        }),
4608        "standard_hash" => Some(FunctionSignature {
4609            name: "standard_hash",
4610            display_name: "STANDARD_HASH",
4611            params: PARAMS_STANDARD_HASH,
4612            return_type: None,
4613            category: FunctionCategory::Scalar,
4614        }),
4615        "starts_with" => Some(FunctionSignature {
4616            name: "starts_with",
4617            display_name: "STARTS_WITH",
4618            params: PARAMS_STARTS_WITH,
4619            return_type: None,
4620            category: FunctionCategory::Scalar,
4621        }),
4622        "star_map" => Some(FunctionSignature {
4623            name: "star_map",
4624            display_name: "STAR_MAP",
4625            params: PARAMS_STAR_MAP,
4626            return_type: None,
4627            category: FunctionCategory::Scalar,
4628        }),
4629        "stddev" => Some(FunctionSignature {
4630            name: "stddev",
4631            display_name: "STDDEV",
4632            params: PARAMS_STDDEV,
4633            return_type: None,
4634            category: FunctionCategory::Aggregate,
4635        }),
4636        "stddev_pop" => Some(FunctionSignature {
4637            name: "stddev_pop",
4638            display_name: "STDDEV_POP",
4639            params: PARAMS_STDDEV_POP,
4640            return_type: None,
4641            category: FunctionCategory::Aggregate,
4642        }),
4643        "stddev_samp" => Some(FunctionSignature {
4644            name: "stddev_samp",
4645            display_name: "STDDEV_SAMP",
4646            params: PARAMS_STDDEV_SAMP,
4647            return_type: None,
4648            category: FunctionCategory::Aggregate,
4649        }),
4650        "string" => Some(FunctionSignature {
4651            name: "string",
4652            display_name: "STRING",
4653            params: PARAMS_STRING,
4654            return_type: None,
4655            category: FunctionCategory::Scalar,
4656        }),
4657        "struct" => Some(FunctionSignature {
4658            name: "struct",
4659            display_name: "STRUCT",
4660            params: PARAMS_STRUCT,
4661            return_type: None,
4662            category: FunctionCategory::Scalar,
4663        }),
4664        "struct_extract" => Some(FunctionSignature {
4665            name: "struct_extract",
4666            display_name: "STRUCT_EXTRACT",
4667            params: PARAMS_STRUCT_EXTRACT,
4668            return_type: None,
4669            category: FunctionCategory::Scalar,
4670        }),
4671        "str_position" => Some(FunctionSignature {
4672            name: "str_position",
4673            display_name: "STR_POSITION",
4674            params: PARAMS_STR_POSITION,
4675            return_type: None,
4676            category: FunctionCategory::Scalar,
4677        }),
4678        "str_to_date" => Some(FunctionSignature {
4679            name: "str_to_date",
4680            display_name: "STR_TO_DATE",
4681            params: PARAMS_STR_TO_DATE,
4682            return_type: None,
4683            category: FunctionCategory::Scalar,
4684        }),
4685        "str_to_map" => Some(FunctionSignature {
4686            name: "str_to_map",
4687            display_name: "STR_TO_MAP",
4688            params: PARAMS_STR_TO_MAP,
4689            return_type: None,
4690            category: FunctionCategory::Scalar,
4691        }),
4692        "str_to_time" => Some(FunctionSignature {
4693            name: "str_to_time",
4694            display_name: "STR_TO_TIME",
4695            params: PARAMS_STR_TO_TIME,
4696            return_type: None,
4697            category: FunctionCategory::Scalar,
4698        }),
4699        "str_to_unix" => Some(FunctionSignature {
4700            name: "str_to_unix",
4701            display_name: "STR_TO_UNIX",
4702            params: PARAMS_STR_TO_UNIX,
4703            return_type: None,
4704            category: FunctionCategory::Scalar,
4705        }),
4706        "st_distance" => Some(FunctionSignature {
4707            name: "st_distance",
4708            display_name: "ST_DISTANCE",
4709            params: PARAMS_ST_DISTANCE,
4710            return_type: None,
4711            category: FunctionCategory::Scalar,
4712        }),
4713        "st_point" => Some(FunctionSignature {
4714            name: "st_point",
4715            display_name: "ST_POINT",
4716            params: PARAMS_ST_POINT,
4717            return_type: None,
4718            category: FunctionCategory::Scalar,
4719        }),
4720        "substring" => Some(FunctionSignature {
4721            name: "substring",
4722            display_name: "SUBSTRING",
4723            params: PARAMS_SUBSTRING,
4724            return_type: Some(ReturnTypeRule::Text),
4725            category: FunctionCategory::Scalar,
4726        }),
4727        "substring_index" => Some(FunctionSignature {
4728            name: "substring_index",
4729            display_name: "SUBSTRING_INDEX",
4730            params: PARAMS_SUBSTRING_INDEX,
4731            return_type: None,
4732            category: FunctionCategory::Scalar,
4733        }),
4734        "sum" => Some(FunctionSignature {
4735            name: "sum",
4736            display_name: "SUM",
4737            params: PARAMS_SUM,
4738            return_type: Some(ReturnTypeRule::Numeric),
4739            category: FunctionCategory::Aggregate,
4740        }),
4741        "sha1digest" => Some(FunctionSignature {
4742            name: "sha1digest",
4743            display_name: "SHA1DIGEST",
4744            params: PARAMS_SHA1DIGEST,
4745            return_type: None,
4746            category: FunctionCategory::Scalar,
4747        }),
4748        "sha2digest" => Some(FunctionSignature {
4749            name: "sha2digest",
4750            display_name: "SHA2DIGEST",
4751            params: PARAMS_SHA2DIGEST,
4752            return_type: None,
4753            category: FunctionCategory::Scalar,
4754        }),
4755        "tan" => Some(FunctionSignature {
4756            name: "tan",
4757            display_name: "TAN",
4758            params: PARAMS_TAN,
4759            return_type: None,
4760            category: FunctionCategory::Scalar,
4761        }),
4762        "tanh" => Some(FunctionSignature {
4763            name: "tanh",
4764            display_name: "TANH",
4765            params: PARAMS_TANH,
4766            return_type: None,
4767            category: FunctionCategory::Scalar,
4768        }),
4769        "time" => Some(FunctionSignature {
4770            name: "time",
4771            display_name: "TIME",
4772            params: PARAMS_TIME,
4773            return_type: None,
4774            category: FunctionCategory::Scalar,
4775        }),
4776        "time_from_parts" => Some(FunctionSignature {
4777            name: "time_from_parts",
4778            display_name: "TIME_FROM_PARTS",
4779            params: PARAMS_TIME_FROM_PARTS,
4780            return_type: None,
4781            category: FunctionCategory::Scalar,
4782        }),
4783        "timestamp" => Some(FunctionSignature {
4784            name: "timestamp",
4785            display_name: "TIMESTAMP",
4786            params: PARAMS_TIMESTAMP,
4787            return_type: None,
4788            category: FunctionCategory::Scalar,
4789        }),
4790        "timestamp_diff" => Some(FunctionSignature {
4791            name: "timestamp_diff",
4792            display_name: "TIMESTAMP_DIFF",
4793            params: PARAMS_TIMESTAMP_DIFF,
4794            return_type: None,
4795            category: FunctionCategory::Scalar,
4796        }),
4797        "timestamp_from_parts" => Some(FunctionSignature {
4798            name: "timestamp_from_parts",
4799            display_name: "TIMESTAMP_FROM_PARTS",
4800            params: PARAMS_TIMESTAMP_FROM_PARTS,
4801            return_type: None,
4802            category: FunctionCategory::Scalar,
4803        }),
4804        "timestamp_ltz_from_parts" => Some(FunctionSignature {
4805            name: "timestamp_ltz_from_parts",
4806            display_name: "TIMESTAMP_LTZ_FROM_PARTS",
4807            params: PARAMS_TIMESTAMP_LTZ_FROM_PARTS,
4808            return_type: None,
4809            category: FunctionCategory::Scalar,
4810        }),
4811        "timestamp_tz_from_parts" => Some(FunctionSignature {
4812            name: "timestamp_tz_from_parts",
4813            display_name: "TIMESTAMP_TZ_FROM_PARTS",
4814            params: PARAMS_TIMESTAMP_TZ_FROM_PARTS,
4815            return_type: None,
4816            category: FunctionCategory::Scalar,
4817        }),
4818        "timestamp_add" => Some(FunctionSignature {
4819            name: "timestamp_add",
4820            display_name: "TIMESTAMP_ADD",
4821            params: PARAMS_TIMESTAMP_ADD,
4822            return_type: None,
4823            category: FunctionCategory::Scalar,
4824        }),
4825        "timestamp_sub" => Some(FunctionSignature {
4826            name: "timestamp_sub",
4827            display_name: "TIMESTAMP_SUB",
4828            params: PARAMS_TIMESTAMP_SUB,
4829            return_type: None,
4830            category: FunctionCategory::Scalar,
4831        }),
4832        "timestamp_trunc" => Some(FunctionSignature {
4833            name: "timestamp_trunc",
4834            display_name: "TIMESTAMP_TRUNC",
4835            params: PARAMS_TIMESTAMP_TRUNC,
4836            return_type: None,
4837            category: FunctionCategory::Scalar,
4838        }),
4839        "time_add" => Some(FunctionSignature {
4840            name: "time_add",
4841            display_name: "TIME_ADD",
4842            params: PARAMS_TIME_ADD,
4843            return_type: None,
4844            category: FunctionCategory::Scalar,
4845        }),
4846        "time_diff" => Some(FunctionSignature {
4847            name: "time_diff",
4848            display_name: "TIME_DIFF",
4849            params: PARAMS_TIME_DIFF,
4850            return_type: None,
4851            category: FunctionCategory::Scalar,
4852        }),
4853        "time_slice" => Some(FunctionSignature {
4854            name: "time_slice",
4855            display_name: "TIME_SLICE",
4856            params: PARAMS_TIME_SLICE,
4857            return_type: None,
4858            category: FunctionCategory::Scalar,
4859        }),
4860        "time_str_to_date" => Some(FunctionSignature {
4861            name: "time_str_to_date",
4862            display_name: "TIME_STR_TO_DATE",
4863            params: PARAMS_TIME_STR_TO_DATE,
4864            return_type: None,
4865            category: FunctionCategory::Scalar,
4866        }),
4867        "time_str_to_time" => Some(FunctionSignature {
4868            name: "time_str_to_time",
4869            display_name: "TIME_STR_TO_TIME",
4870            params: PARAMS_TIME_STR_TO_TIME,
4871            return_type: None,
4872            category: FunctionCategory::Scalar,
4873        }),
4874        "time_str_to_unix" => Some(FunctionSignature {
4875            name: "time_str_to_unix",
4876            display_name: "TIME_STR_TO_UNIX",
4877            params: PARAMS_TIME_STR_TO_UNIX,
4878            return_type: None,
4879            category: FunctionCategory::Scalar,
4880        }),
4881        "time_sub" => Some(FunctionSignature {
4882            name: "time_sub",
4883            display_name: "TIME_SUB",
4884            params: PARAMS_TIME_SUB,
4885            return_type: None,
4886            category: FunctionCategory::Scalar,
4887        }),
4888        "time_to_str" => Some(FunctionSignature {
4889            name: "time_to_str",
4890            display_name: "TIME_TO_STR",
4891            params: PARAMS_TIME_TO_STR,
4892            return_type: None,
4893            category: FunctionCategory::Scalar,
4894        }),
4895        "time_to_time_str" => Some(FunctionSignature {
4896            name: "time_to_time_str",
4897            display_name: "TIME_TO_TIME_STR",
4898            params: PARAMS_TIME_TO_TIME_STR,
4899            return_type: None,
4900            category: FunctionCategory::Scalar,
4901        }),
4902        "time_to_unix" => Some(FunctionSignature {
4903            name: "time_to_unix",
4904            display_name: "TIME_TO_UNIX",
4905            params: PARAMS_TIME_TO_UNIX,
4906            return_type: None,
4907            category: FunctionCategory::Scalar,
4908        }),
4909        "time_trunc" => Some(FunctionSignature {
4910            name: "time_trunc",
4911            display_name: "TIME_TRUNC",
4912            params: PARAMS_TIME_TRUNC,
4913            return_type: None,
4914            category: FunctionCategory::Scalar,
4915        }),
4916        "to_array" => Some(FunctionSignature {
4917            name: "to_array",
4918            display_name: "TO_ARRAY",
4919            params: PARAMS_TO_ARRAY,
4920            return_type: None,
4921            category: FunctionCategory::Scalar,
4922        }),
4923        "to_base32" => Some(FunctionSignature {
4924            name: "to_base32",
4925            display_name: "TO_BASE32",
4926            params: PARAMS_TO_BASE32,
4927            return_type: None,
4928            category: FunctionCategory::Scalar,
4929        }),
4930        "to_base64" => Some(FunctionSignature {
4931            name: "to_base64",
4932            display_name: "TO_BASE64",
4933            params: PARAMS_TO_BASE64,
4934            return_type: None,
4935            category: FunctionCategory::Scalar,
4936        }),
4937        "to_char" => Some(FunctionSignature {
4938            name: "to_char",
4939            display_name: "TO_CHAR",
4940            params: PARAMS_TO_CHAR,
4941            return_type: None,
4942            category: FunctionCategory::Scalar,
4943        }),
4944        "to_code_points" => Some(FunctionSignature {
4945            name: "to_code_points",
4946            display_name: "TO_CODE_POINTS",
4947            params: PARAMS_TO_CODE_POINTS,
4948            return_type: None,
4949            category: FunctionCategory::Scalar,
4950        }),
4951        "to_days" => Some(FunctionSignature {
4952            name: "to_days",
4953            display_name: "TO_DAYS",
4954            params: PARAMS_TO_DAYS,
4955            return_type: None,
4956            category: FunctionCategory::Scalar,
4957        }),
4958        "to_double" => Some(FunctionSignature {
4959            name: "to_double",
4960            display_name: "TO_DOUBLE",
4961            params: PARAMS_TO_DOUBLE,
4962            return_type: None,
4963            category: FunctionCategory::Scalar,
4964        }),
4965        "to_map" => Some(FunctionSignature {
4966            name: "to_map",
4967            display_name: "TO_MAP",
4968            params: PARAMS_TO_MAP,
4969            return_type: None,
4970            category: FunctionCategory::Scalar,
4971        }),
4972        "to_number" => Some(FunctionSignature {
4973            name: "to_number",
4974            display_name: "TO_NUMBER",
4975            params: PARAMS_TO_NUMBER,
4976            return_type: None,
4977            category: FunctionCategory::Scalar,
4978        }),
4979        "transform" => Some(FunctionSignature {
4980            name: "transform",
4981            display_name: "TRANSFORM",
4982            params: PARAMS_TRANSFORM,
4983            return_type: None,
4984            category: FunctionCategory::Scalar,
4985        }),
4986        "translate" => Some(FunctionSignature {
4987            name: "translate",
4988            display_name: "TRANSLATE",
4989            params: PARAMS_TRANSLATE,
4990            return_type: None,
4991            category: FunctionCategory::Scalar,
4992        }),
4993        "trim" => Some(FunctionSignature {
4994            name: "trim",
4995            display_name: "TRIM",
4996            params: PARAMS_TRIM,
4997            return_type: Some(ReturnTypeRule::Text),
4998            category: FunctionCategory::Scalar,
4999        }),
5000        "try" => Some(FunctionSignature {
5001            name: "try",
5002            display_name: "TRY",
5003            params: PARAMS_TRY,
5004            return_type: None,
5005            category: FunctionCategory::Scalar,
5006        }),
5007        "try_base64decode_binary" => Some(FunctionSignature {
5008            name: "try_base64decode_binary",
5009            display_name: "TRY_BASE64DECODE_BINARY",
5010            params: PARAMS_TRY_BASE64DECODE_BINARY,
5011            return_type: None,
5012            category: FunctionCategory::Scalar,
5013        }),
5014        "try_base64decode_string" => Some(FunctionSignature {
5015            name: "try_base64decode_string",
5016            display_name: "TRY_BASE64DECODE_STRING",
5017            params: PARAMS_TRY_BASE64DECODE_STRING,
5018            return_type: None,
5019            category: FunctionCategory::Scalar,
5020        }),
5021        "try_cast" => Some(FunctionSignature {
5022            name: "try_cast",
5023            display_name: "TRY_CAST",
5024            params: PARAMS_TRY_CAST,
5025            return_type: None,
5026            category: FunctionCategory::Scalar,
5027        }),
5028        "try_hex_decode_binary" => Some(FunctionSignature {
5029            name: "try_hex_decode_binary",
5030            display_name: "TRY_HEX_DECODE_BINARY",
5031            params: PARAMS_TRY_HEX_DECODE_BINARY,
5032            return_type: None,
5033            category: FunctionCategory::Scalar,
5034        }),
5035        "try_hex_decode_string" => Some(FunctionSignature {
5036            name: "try_hex_decode_string",
5037            display_name: "TRY_HEX_DECODE_STRING",
5038            params: PARAMS_TRY_HEX_DECODE_STRING,
5039            return_type: None,
5040            category: FunctionCategory::Scalar,
5041        }),
5042        "ts_or_di_to_di" => Some(FunctionSignature {
5043            name: "ts_or_di_to_di",
5044            display_name: "TS_OR_DI_TO_DI",
5045            params: PARAMS_TS_OR_DI_TO_DI,
5046            return_type: None,
5047            category: FunctionCategory::Scalar,
5048        }),
5049        "ts_or_ds_add" => Some(FunctionSignature {
5050            name: "ts_or_ds_add",
5051            display_name: "TS_OR_DS_ADD",
5052            params: PARAMS_TS_OR_DS_ADD,
5053            return_type: None,
5054            category: FunctionCategory::Scalar,
5055        }),
5056        "ts_or_ds_diff" => Some(FunctionSignature {
5057            name: "ts_or_ds_diff",
5058            display_name: "TS_OR_DS_DIFF",
5059            params: PARAMS_TS_OR_DS_DIFF,
5060            return_type: None,
5061            category: FunctionCategory::Scalar,
5062        }),
5063        "ts_or_ds_to_date" => Some(FunctionSignature {
5064            name: "ts_or_ds_to_date",
5065            display_name: "TS_OR_DS_TO_DATE",
5066            params: PARAMS_TS_OR_DS_TO_DATE,
5067            return_type: None,
5068            category: FunctionCategory::Scalar,
5069        }),
5070        "ts_or_ds_to_datetime" => Some(FunctionSignature {
5071            name: "ts_or_ds_to_datetime",
5072            display_name: "TS_OR_DS_TO_DATETIME",
5073            params: PARAMS_TS_OR_DS_TO_DATETIME,
5074            return_type: None,
5075            category: FunctionCategory::Scalar,
5076        }),
5077        "ts_or_ds_to_date_str" => Some(FunctionSignature {
5078            name: "ts_or_ds_to_date_str",
5079            display_name: "TS_OR_DS_TO_DATE_STR",
5080            params: PARAMS_TS_OR_DS_TO_DATE_STR,
5081            return_type: None,
5082            category: FunctionCategory::Scalar,
5083        }),
5084        "ts_or_ds_to_time" => Some(FunctionSignature {
5085            name: "ts_or_ds_to_time",
5086            display_name: "TS_OR_DS_TO_TIME",
5087            params: PARAMS_TS_OR_DS_TO_TIME,
5088            return_type: None,
5089            category: FunctionCategory::Scalar,
5090        }),
5091        "ts_or_ds_to_timestamp" => Some(FunctionSignature {
5092            name: "ts_or_ds_to_timestamp",
5093            display_name: "TS_OR_DS_TO_TIMESTAMP",
5094            params: PARAMS_TS_OR_DS_TO_TIMESTAMP,
5095            return_type: None,
5096            category: FunctionCategory::Scalar,
5097        }),
5098        "typeof" => Some(FunctionSignature {
5099            name: "typeof",
5100            display_name: "TYPEOF",
5101            params: PARAMS_TYPEOF,
5102            return_type: None,
5103            category: FunctionCategory::Scalar,
5104        }),
5105        "upper" => Some(FunctionSignature {
5106            name: "upper",
5107            display_name: "UPPER",
5108            params: PARAMS_UPPER,
5109            return_type: Some(ReturnTypeRule::Text),
5110            category: FunctionCategory::Scalar,
5111        }),
5112        "unhex" => Some(FunctionSignature {
5113            name: "unhex",
5114            display_name: "UNHEX",
5115            params: PARAMS_UNHEX,
5116            return_type: None,
5117            category: FunctionCategory::Scalar,
5118        }),
5119        "unicode" => Some(FunctionSignature {
5120            name: "unicode",
5121            display_name: "UNICODE",
5122            params: PARAMS_UNICODE,
5123            return_type: None,
5124            category: FunctionCategory::Scalar,
5125        }),
5126        "unix_date" => Some(FunctionSignature {
5127            name: "unix_date",
5128            display_name: "UNIX_DATE",
5129            params: PARAMS_UNIX_DATE,
5130            return_type: None,
5131            category: FunctionCategory::Scalar,
5132        }),
5133        "unix_micros" => Some(FunctionSignature {
5134            name: "unix_micros",
5135            display_name: "UNIX_MICROS",
5136            params: PARAMS_UNIX_MICROS,
5137            return_type: None,
5138            category: FunctionCategory::Scalar,
5139        }),
5140        "unix_millis" => Some(FunctionSignature {
5141            name: "unix_millis",
5142            display_name: "UNIX_MILLIS",
5143            params: PARAMS_UNIX_MILLIS,
5144            return_type: None,
5145            category: FunctionCategory::Scalar,
5146        }),
5147        "unix_seconds" => Some(FunctionSignature {
5148            name: "unix_seconds",
5149            display_name: "UNIX_SECONDS",
5150            params: PARAMS_UNIX_SECONDS,
5151            return_type: None,
5152            category: FunctionCategory::Scalar,
5153        }),
5154        "unix_to_str" => Some(FunctionSignature {
5155            name: "unix_to_str",
5156            display_name: "UNIX_TO_STR",
5157            params: PARAMS_UNIX_TO_STR,
5158            return_type: None,
5159            category: FunctionCategory::Scalar,
5160        }),
5161        "unix_to_time" => Some(FunctionSignature {
5162            name: "unix_to_time",
5163            display_name: "UNIX_TO_TIME",
5164            params: PARAMS_UNIX_TO_TIME,
5165            return_type: None,
5166            category: FunctionCategory::Scalar,
5167        }),
5168        "unix_to_time_str" => Some(FunctionSignature {
5169            name: "unix_to_time_str",
5170            display_name: "UNIX_TO_TIME_STR",
5171            params: PARAMS_UNIX_TO_TIME_STR,
5172            return_type: None,
5173            category: FunctionCategory::Scalar,
5174        }),
5175        "unnest" => Some(FunctionSignature {
5176            name: "unnest",
5177            display_name: "UNNEST",
5178            params: PARAMS_UNNEST,
5179            return_type: None,
5180            category: FunctionCategory::Scalar,
5181        }),
5182        "utc_date" => Some(FunctionSignature {
5183            name: "utc_date",
5184            display_name: "UTC_DATE",
5185            params: &[],
5186            return_type: None,
5187            category: FunctionCategory::Scalar,
5188        }),
5189        "utc_time" => Some(FunctionSignature {
5190            name: "utc_time",
5191            display_name: "UTC_TIME",
5192            params: PARAMS_UTC_TIME,
5193            return_type: None,
5194            category: FunctionCategory::Scalar,
5195        }),
5196        "utc_timestamp" => Some(FunctionSignature {
5197            name: "utc_timestamp",
5198            display_name: "UTC_TIMESTAMP",
5199            params: PARAMS_UTC_TIMESTAMP,
5200            return_type: None,
5201            category: FunctionCategory::Scalar,
5202        }),
5203        "variance" => Some(FunctionSignature {
5204            name: "variance",
5205            display_name: "VARIANCE",
5206            params: PARAMS_VARIANCE,
5207            return_type: None,
5208            category: FunctionCategory::Aggregate,
5209        }),
5210        "variance_pop" => Some(FunctionSignature {
5211            name: "variance_pop",
5212            display_name: "VARIANCE_POP",
5213            params: PARAMS_VARIANCE_POP,
5214            return_type: None,
5215            category: FunctionCategory::Aggregate,
5216        }),
5217        "var_map" => Some(FunctionSignature {
5218            name: "var_map",
5219            display_name: "VAR_MAP",
5220            params: PARAMS_VAR_MAP,
5221            return_type: None,
5222            category: FunctionCategory::Scalar,
5223        }),
5224        "vector_search" => Some(FunctionSignature {
5225            name: "vector_search",
5226            display_name: "VECTOR_SEARCH",
5227            params: PARAMS_VECTOR_SEARCH,
5228            return_type: None,
5229            category: FunctionCategory::Scalar,
5230        }),
5231        "week" => Some(FunctionSignature {
5232            name: "week",
5233            display_name: "WEEK",
5234            params: PARAMS_WEEK,
5235            return_type: None,
5236            category: FunctionCategory::Scalar,
5237        }),
5238        "week_of_year" => Some(FunctionSignature {
5239            name: "week_of_year",
5240            display_name: "WEEK_OF_YEAR",
5241            params: PARAMS_WEEK_OF_YEAR,
5242            return_type: None,
5243            category: FunctionCategory::Scalar,
5244        }),
5245        "width_bucket" => Some(FunctionSignature {
5246            name: "width_bucket",
5247            display_name: "WIDTH_BUCKET",
5248            params: PARAMS_WIDTH_BUCKET,
5249            return_type: None,
5250            category: FunctionCategory::Scalar,
5251        }),
5252        "xml_element" => Some(FunctionSignature {
5253            name: "xml_element",
5254            display_name: "XML_ELEMENT",
5255            params: PARAMS_XML_ELEMENT,
5256            return_type: None,
5257            category: FunctionCategory::Scalar,
5258        }),
5259        "xor" => Some(FunctionSignature {
5260            name: "xor",
5261            display_name: "XOR",
5262            params: PARAMS_XOR,
5263            return_type: None,
5264            category: FunctionCategory::Scalar,
5265        }),
5266        "xml_table" => Some(FunctionSignature {
5267            name: "xml_table",
5268            display_name: "XML_TABLE",
5269            params: PARAMS_XML_TABLE,
5270            return_type: None,
5271            category: FunctionCategory::Scalar,
5272        }),
5273        "year" => Some(FunctionSignature {
5274            name: "year",
5275            display_name: "YEAR",
5276            params: PARAMS_YEAR,
5277            return_type: None,
5278            category: FunctionCategory::Scalar,
5279        }),
5280        "year_of_week" => Some(FunctionSignature {
5281            name: "year_of_week",
5282            display_name: "YEAR_OF_WEEK",
5283            params: PARAMS_YEAR_OF_WEEK,
5284            return_type: None,
5285            category: FunctionCategory::Scalar,
5286        }),
5287        "year_of_week_iso" => Some(FunctionSignature {
5288            name: "year_of_week_iso",
5289            display_name: "YEAR_OF_WEEK_ISO",
5290            params: PARAMS_YEAR_OF_WEEK_ISO,
5291            return_type: None,
5292            category: FunctionCategory::Scalar,
5293        }),
5294        _ => None,
5295    }
5296}
5297
5298/// Returns all function signatures for completion.
5299///
5300/// This provides access to all known SQL functions for populating
5301/// completion lists. Functions are returned in a static slice for efficiency.
5302pub fn all_function_signatures() -> impl Iterator<Item = FunctionSignature> {
5303    static NAMES: &[&str] = &[
5304        "abs",
5305        "acos",
5306        "acosh",
5307        "add_months",
5308        "agg_func",
5309        "ai_agg",
5310        "ai_classify",
5311        "ai_summarize_agg",
5312        "and",
5313        "any_value",
5314        "apply",
5315        "approximate_similarity",
5316        "approx_distinct",
5317        "approx_quantile",
5318        "approx_quantiles",
5319        "approx_top_k",
5320        "approx_top_k_accumulate",
5321        "approx_top_k_combine",
5322        "approx_top_sum",
5323        "arg_max",
5324        "arg_min",
5325        "array",
5326        "array_agg",
5327        "array_all",
5328        "array_any",
5329        "array_concat",
5330        "array_concat_agg",
5331        "array_construct_compact",
5332        "array_contains",
5333        "array_contains_all",
5334        "array_filter",
5335        "array_first",
5336        "array_intersect",
5337        "array_to_string",
5338        "array_last",
5339        "array_size",
5340        "array_overlaps",
5341        "array_remove",
5342        "array_reverse",
5343        "array_slice",
5344        "array_sort",
5345        "array_sum",
5346        "array_union_agg",
5347        "array_unique_agg",
5348        "ascii",
5349        "asin",
5350        "asinh",
5351        "atan",
5352        "atan2",
5353        "atanh",
5354        "avg",
5355        "base64decode_binary",
5356        "base64decode_string",
5357        "base64encode",
5358        "bitmap_bit_position",
5359        "bitmap_bucket_number",
5360        "bitmap_construct_agg",
5361        "bitmap_count",
5362        "bitmap_or_agg",
5363        "bitwise_and_agg",
5364        "bitwise_count",
5365        "bitwise_or_agg",
5366        "bitwise_xor_agg",
5367        "bit_length",
5368        "booland",
5369        "logical_and",
5370        "boolnot",
5371        "boolor",
5372        "logical_or",
5373        "boolxor_agg",
5374        "byte_length",
5375        "case",
5376        "cast",
5377        "cast_to_str_type",
5378        "cbrt",
5379        "ceil",
5380        "chr",
5381        "length",
5382        "coalesce",
5383        "code_points_to_bytes",
5384        "code_points_to_string",
5385        "collate",
5386        "collation",
5387        "columns",
5388        "combined_agg_func",
5389        "combined_parameterized_agg",
5390        "compress",
5391        "concat",
5392        "concat_ws",
5393        "connect_by_root",
5394        "contains",
5395        "convert",
5396        "convert_timezone",
5397        "convert_to_charset",
5398        "corr",
5399        "cos",
5400        "cosh",
5401        "cosine_distance",
5402        "cot",
5403        "coth",
5404        "count",
5405        "count_if",
5406        "covar_pop",
5407        "covar_samp",
5408        "csc",
5409        "csch",
5410        "cume_dist",
5411        "current_date",
5412        "current_datetime",
5413        "current_schema",
5414        "current_time",
5415        "current_timestamp",
5416        "current_timestamp_ltz",
5417        "current_user",
5418        "date",
5419        "date_diff",
5420        "date_from_parts",
5421        "datetime",
5422        "datetime_add",
5423        "datetime_diff",
5424        "datetime_sub",
5425        "datetime_trunc",
5426        "date_add",
5427        "date_bin",
5428        "date_from_unix_date",
5429        "date_str_to_date",
5430        "date_sub",
5431        "date_to_date_str",
5432        "date_to_di",
5433        "date_trunc",
5434        "day",
5435        "day_of_month",
5436        "day_of_week",
5437        "day_of_week_iso",
5438        "day_of_year",
5439        "decode",
5440        "decode_case",
5441        "decompress_binary",
5442        "decompress_string",
5443        "degrees",
5444        "dense_rank",
5445        "di_to_date",
5446        "encode",
5447        "ends_with",
5448        "equal_null",
5449        "euclidean_distance",
5450        "exists",
5451        "exp",
5452        "explode",
5453        "explode_outer",
5454        "exploding_generate_series",
5455        "extract",
5456        "factorial",
5457        "farm_fingerprint",
5458        "features_at_time",
5459        "first",
5460        "first_value",
5461        "flatten",
5462        "float64",
5463        "floor",
5464        "format",
5465        "from_base",
5466        "from_base32",
5467        "from_base64",
5468        "from_iso8601timestamp",
5469        "gap_fill",
5470        "generate_date_array",
5471        "generate_embedding",
5472        "generate_series",
5473        "generate_timestamp_array",
5474        "uuid",
5475        "getbit",
5476        "get_extract",
5477        "greatest",
5478        "greatest_ignore_nulls",
5479        "grouping",
5480        "grouping_id",
5481        "group_concat",
5482        "hex",
5483        "hex_decode_string",
5484        "hex_encode",
5485        "hll",
5486        "hour",
5487        "if",
5488        "initcap",
5489        "inline",
5490        "stuff",
5491        "int64",
5492        "is_inf",
5493        "is_nan",
5494        "is_ascii",
5495        "is_null_value",
5496        "jarowinkler_similarity",
5497        "jsonb_contains",
5498        "jsonb_exists",
5499        "jsonb_extract",
5500        "jsonb_extract_scalar",
5501        "json_array_append",
5502        "json_array_contains",
5503        "json_array_insert",
5504        "json_extract",
5505        "json_extract_array",
5506        "json_extract_scalar",
5507        "json_format",
5508        "parse_json",
5509        "json_remove",
5510        "json_set",
5511        "json_strip_nulls",
5512        "json_type",
5513        "justify_days",
5514        "justify_hours",
5515        "justify_interval",
5516        "json_array",
5517        "json_array_agg",
5518        "json_bool",
5519        "jsonb_contains_all_top_keys",
5520        "jsonb_contains_any_top_keys",
5521        "jsonb_delete_at_path",
5522        "jsonb_object_agg",
5523        "json_cast",
5524        "json_exists",
5525        "json_keys_at_depth",
5526        "json_object",
5527        "json_object_agg",
5528        "json_table",
5529        "json_value_array",
5530        "lag",
5531        "last",
5532        "last_day",
5533        "last_value",
5534        "lax_bool",
5535        "lax_float64",
5536        "lax_int64",
5537        "lax_string",
5538        "lower",
5539        "lead",
5540        "least",
5541        "least_ignore_nulls",
5542        "left",
5543        "levenshtein",
5544        "list",
5545        "ln",
5546        "log",
5547        "lower_hex",
5548        "make_interval",
5549        "map",
5550        "map_from_entries",
5551        "match_against",
5552        "max",
5553        "md5",
5554        "md5digest",
5555        "median",
5556        "min",
5557        "minhash",
5558        "minhash_combine",
5559        "minute",
5560        "month",
5561        "monthname",
5562        "months_between",
5563        "md5number_lower64",
5564        "md5number_upper64",
5565        "ml_forecast",
5566        "ml_translate",
5567        "next_day",
5568        "next_value_for",
5569        "normalize",
5570        "now",
5571        "nth_value",
5572        "ntile",
5573        "nullif",
5574        "number_to_str",
5575        "nvl2",
5576        "object_agg",
5577        "object_insert",
5578        "open_json",
5579        "or",
5580        "overlay",
5581        "pad",
5582        "parameterized_agg",
5583        "parse_bignumeric",
5584        "parse_datetime",
5585        "parse_ip",
5586        "parse_numeric",
5587        "parse_time",
5588        "parse_url",
5589        "percentile_cont",
5590        "percentile_disc",
5591        "percent_rank",
5592        "pi",
5593        "posexplode",
5594        "posexplode_outer",
5595        "pow",
5596        "predict",
5597        "previous_day",
5598        "quantile",
5599        "quarter",
5600        "radians",
5601        "rand",
5602        "randn",
5603        "range_bucket",
5604        "range_n",
5605        "rank",
5606        "read_csv",
5607        "read_parquet",
5608        "reduce",
5609        "regexp_count",
5610        "regexp_extract",
5611        "regexp_extract_all",
5612        "regexp_full_match",
5613        "regexp_instr",
5614        "regexp_i_like",
5615        "regexp_like",
5616        "regexp_replace",
5617        "regexp_split",
5618        "regr_avgx",
5619        "regr_avgy",
5620        "regr_valx",
5621        "regr_valy",
5622        "repeat",
5623        "replace",
5624        "reverse",
5625        "right",
5626        "round",
5627        "row_number",
5628        "rtrimmed_length",
5629        "safe_add",
5630        "safe_convert_bytes_to_string",
5631        "safe_divide",
5632        "safe_multiply",
5633        "safe_negate",
5634        "safe_subtract",
5635        "search",
5636        "sec",
5637        "sech",
5638        "second",
5639        "sha",
5640        "sha2",
5641        "sign",
5642        "sin",
5643        "sinh",
5644        "skewness",
5645        "sort_array",
5646        "soundex",
5647        "soundex_p123",
5648        "space",
5649        "split",
5650        "string_to_array",
5651        "split_part",
5652        "sqrt",
5653        "standard_hash",
5654        "starts_with",
5655        "star_map",
5656        "stddev",
5657        "stddev_pop",
5658        "stddev_samp",
5659        "string",
5660        "struct",
5661        "struct_extract",
5662        "str_position",
5663        "str_to_date",
5664        "str_to_map",
5665        "str_to_time",
5666        "str_to_unix",
5667        "st_distance",
5668        "st_point",
5669        "substring",
5670        "substring_index",
5671        "sum",
5672        "sha1digest",
5673        "sha2digest",
5674        "tan",
5675        "tanh",
5676        "time",
5677        "time_from_parts",
5678        "timestamp",
5679        "timestamp_diff",
5680        "timestamp_from_parts",
5681        "timestamp_ltz_from_parts",
5682        "timestamp_tz_from_parts",
5683        "timestamp_add",
5684        "timestamp_sub",
5685        "timestamp_trunc",
5686        "time_add",
5687        "time_diff",
5688        "time_slice",
5689        "time_str_to_date",
5690        "time_str_to_time",
5691        "time_str_to_unix",
5692        "time_sub",
5693        "time_to_str",
5694        "time_to_time_str",
5695        "time_to_unix",
5696        "time_trunc",
5697        "to_array",
5698        "to_base32",
5699        "to_base64",
5700        "to_char",
5701        "to_code_points",
5702        "to_days",
5703        "to_double",
5704        "to_map",
5705        "to_number",
5706        "transform",
5707        "translate",
5708        "trim",
5709        "try",
5710        "try_base64decode_binary",
5711        "try_base64decode_string",
5712        "try_cast",
5713        "try_hex_decode_binary",
5714        "try_hex_decode_string",
5715        "ts_or_di_to_di",
5716        "ts_or_ds_add",
5717        "ts_or_ds_diff",
5718        "ts_or_ds_to_date",
5719        "ts_or_ds_to_datetime",
5720        "ts_or_ds_to_date_str",
5721        "ts_or_ds_to_time",
5722        "ts_or_ds_to_timestamp",
5723        "typeof",
5724        "upper",
5725        "unhex",
5726        "unicode",
5727        "unix_date",
5728        "unix_micros",
5729        "unix_millis",
5730        "unix_seconds",
5731        "unix_to_str",
5732        "unix_to_time",
5733        "unix_to_time_str",
5734        "unnest",
5735        "utc_date",
5736        "utc_time",
5737        "utc_timestamp",
5738        "variance",
5739        "variance_pop",
5740        "var_map",
5741        "vector_search",
5742        "week",
5743        "week_of_year",
5744        "width_bucket",
5745        "xml_element",
5746        "xor",
5747        "xml_table",
5748        "year",
5749        "year_of_week",
5750        "year_of_week_iso",
5751    ];
5752    NAMES.iter().filter_map(|name| get_function_signature(name))
5753}
flowscope_core/generated/functions.rs

flowscope_core/generated/
functions.rs
