@@ -2236,62 +2236,117 @@ pub fn function_call(i: Input) -> IResult<ExprElement> {
22362236 window : Option < WindowDesc > ,
22372237 } ,
22382238 }
2239- let function_call_with_lambda_body = map (
2239+ let function_call_body = map_res (
22402240 rule ! {
2241- "(" ~ #subexpr( 0 ) ~ "," ~ #lambda_params ~ "->" ~ #subexpr( 0 ) ~ ")"
2242- } ,
2243- |( _, arg, _, params, _, expr, _) | FunctionCallSuffix :: Lambda {
2244- arg,
2245- params,
2246- expr : Box :: new ( expr) ,
2247- } ,
2248- ) ;
2249- let function_call_with_within_group_window_body = map (
2250- rule ! {
2251- "(" ~ DISTINCT ? ~ #comma_separated_list0( subexpr( 0 ) ) ? ~ ")"
2241+ "(" ~ DISTINCT ? ~ #subexpr( 0 ) ? ~ "," ? ~ ( #lambda_params ~ "->" ~ #subexpr( 0 ) ) ? ~ #comma_separated_list1( subexpr( 0 ) ) ? ~ ")"
2242+ ~ ( "(" ~ DISTINCT ? ~ #comma_separated_list0( subexpr( 0 ) ) ? ~ ")" ) ?
22522243 ~ #within_group?
22532244 ~ #window_function?
22542245 } ,
2255- |( _, opt_distinct, opt_args, _, order_by, window) | match ( order_by, window) {
2256- ( Some ( order_by) , window) => FunctionCallSuffix :: WithInGroupWindow {
2257- distinct : opt_distinct. is_some ( ) ,
2258- args : opt_args. unwrap_or_default ( ) ,
2246+ |(
2247+ _,
2248+ opt_distinct_0,
2249+ first_param,
2250+ _,
2251+ opt_lambda,
2252+ params_0,
2253+ _,
2254+ params_1,
2255+ order_by,
2256+ window,
2257+ ) | {
2258+ match (
2259+ first_param,
2260+ opt_lambda,
2261+ opt_distinct_0,
2262+ params_0,
2263+ params_1,
22592264 order_by,
22602265 window,
2261- } ,
2262- ( None , Some ( window) ) => FunctionCallSuffix :: Window {
2263- distinct : opt_distinct. is_some ( ) ,
2264- args : opt_args. unwrap_or_default ( ) ,
2265- window,
2266- } ,
2267- ( None , None ) => FunctionCallSuffix :: Simple {
2268- distinct : opt_distinct. is_some ( ) ,
2269- args : opt_args. unwrap_or_default ( ) ,
2270- } ,
2271- } ,
2272- ) ;
2273- let function_call_with_params_window_body = map (
2274- rule ! {
2275- "(" ~ #comma_separated_list1( subexpr( 0 ) ) ~ ")"
2276- ~ "(" ~ DISTINCT ? ~ #comma_separated_list0( subexpr( 0 ) ) ? ~ ")"
2277- ~ #window_function?
2278- } ,
2279- |( _, params, _, _, opt_distinct, opt_args, _, window) | FunctionCallSuffix :: ParamsWindow {
2280- distinct : opt_distinct. is_some ( ) ,
2281- params,
2282- args : opt_args. unwrap_or_default ( ) ,
2283- window,
2266+ ) {
2267+ (
2268+ Some ( first_param) ,
2269+ Some ( ( lambda_params, _, arg_1) ) ,
2270+ None ,
2271+ None ,
2272+ None ,
2273+ None ,
2274+ None ,
2275+ ) => Ok ( FunctionCallSuffix :: Lambda {
2276+ arg : first_param,
2277+ params : lambda_params,
2278+ expr : Box :: new ( arg_1) ,
2279+ } ) ,
2280+ (
2281+ Some ( first_param) ,
2282+ None ,
2283+ None ,
2284+ params_0,
2285+ Some ( ( _, opt_distinct_1, params_1, _) ) ,
2286+ None ,
2287+ window,
2288+ ) => {
2289+ let params = params_0
2290+ . map ( |mut params| {
2291+ params. insert ( 0 , first_param. clone ( ) ) ;
2292+ params
2293+ } )
2294+ . unwrap_or_else ( || vec ! [ first_param] ) ;
2295+
2296+ Ok ( FunctionCallSuffix :: ParamsWindow {
2297+ distinct : opt_distinct_1. is_some ( ) ,
2298+ params,
2299+ args : params_1. unwrap_or_default ( ) ,
2300+ window,
2301+ } )
2302+ }
2303+ ( first_param, None , opt_distinct, params, None , Some ( order_by) , window) => {
2304+ let mut args = params. unwrap_or_default ( ) ;
2305+ if let Some ( first_param) = first_param {
2306+ args. insert ( 0 , first_param)
2307+ }
2308+
2309+ Ok ( FunctionCallSuffix :: WithInGroupWindow {
2310+ distinct : opt_distinct. is_some ( ) ,
2311+ args,
2312+ order_by,
2313+ window,
2314+ } )
2315+ }
2316+ ( first_param, None , opt_distinct, params, None , None , Some ( window) ) => {
2317+ let mut args = params. unwrap_or_default ( ) ;
2318+ if let Some ( first_param) = first_param {
2319+ args. insert ( 0 , first_param)
2320+ }
2321+
2322+ Ok ( FunctionCallSuffix :: Window {
2323+ distinct : opt_distinct. is_some ( ) ,
2324+ args,
2325+ window,
2326+ } )
2327+ }
2328+ ( first_param, None , opt_distinct, params, None , None , None ) => {
2329+ let mut args = params. unwrap_or_default ( ) ;
2330+ if let Some ( first_param) = first_param {
2331+ args. insert ( 0 , first_param)
2332+ }
2333+
2334+ Ok ( FunctionCallSuffix :: Simple {
2335+ distinct : opt_distinct. is_some ( ) ,
2336+ args,
2337+ } )
2338+ }
2339+ _ => Err ( nom:: Err :: Error ( ErrorKind :: Other (
2340+ "Unsupported function format" ,
2341+ ) ) ) ,
2342+ }
22842343 } ,
22852344 ) ;
22862345
22872346 map (
22882347 rule ! (
22892348 #function_name
2290- ~ (
2291- #function_call_with_lambda_body : "`function(..., x -> ...)`"
2292- | #function_call_with_params_window_body : "`function(...)(...) OVER ([ PARTITION BY <expr>, ... ] [ ORDER BY <expr>, ... ] [ <window frame> ])`"
2293- | #function_call_with_within_group_window_body : "`function(...) [ WITHIN GROUP ( ORDER BY <expr>, ... ) ] [ OVER ([ PARTITION BY <expr>, ... ] [ ORDER BY <expr>, ... ] [ <window frame> ]) ]`"
2294- )
2349+ ~ #function_call_body : "`function(... [ , x -> ... ] ) [ (...) ] [ WITHIN GROUP ( ORDER BY <expr>, ... ) ] [ OVER ([ PARTITION BY <expr>, ... ] [ ORDER BY <expr>, ... ] [ <window frame> ]) ]`"
22952350 ) ,
22962351 |( name, suffix) | match suffix {
22972352 FunctionCallSuffix :: Simple { distinct, args } => ExprElement :: FunctionCall {
0 commit comments