@@ -21,7 +21,7 @@ use datafusion::logical_expr::Expr;
2121use std:: sync:: Arc ;
2222use substrait:: proto:: expression:: FieldReference ;
2323use substrait:: proto:: expression:: field_reference:: ReferenceType :: DirectReference ;
24- use substrait:: proto:: expression:: field_reference:: RootType ;
24+ use substrait:: proto:: expression:: field_reference:: { LambdaParameterReference , RootType } ;
2525use substrait:: proto:: expression:: reference_segment:: ReferenceType :: StructField ;
2626
2727pub async fn from_field_reference (
@@ -56,9 +56,9 @@ pub(crate) fn from_substrait_field_reference(
5656 Some ( RootType :: Expression ( _) ) => not_impl_err ! (
5757 "Expression root type in field reference is not supported"
5858 ) ,
59- Some ( RootType :: LambdaParameterReference ( _ ) ) => not_impl_err ! (
60- "Lambda parameter reference in field reference is not yet supported"
61- ) ,
59+ Some ( RootType :: LambdaParameterReference (
60+ LambdaParameterReference { steps_out } ,
61+ ) ) => consumer . lambda_variable ( * steps_out as usize , field_idx ) ,
6262 }
6363 }
6464 _ => not_impl_err ! (
@@ -85,3 +85,83 @@ fn resolve_outer_reference(
8585 let col = Column :: from ( ( qualifier, field) ) ;
8686 Ok ( Expr :: OuterReferenceColumn ( Arc :: clone ( field) , col) )
8787}
88+
89+ #[ cfg( test) ]
90+ mod tests {
91+ use datafusion:: {
92+ common:: { DFSchema , assert_contains} ,
93+ prelude:: SessionContext ,
94+ } ;
95+ use substrait:: proto:: {
96+ Type ,
97+ expression:: {
98+ FieldReference , ReferenceSegment ,
99+ field_reference:: { self , LambdaParameterReference , RootType } ,
100+ reference_segment:: { ReferenceType , StructField } ,
101+ } ,
102+ r#type:: { I64 , Kind } ,
103+ } ;
104+
105+ use crate :: {
106+ extensions:: Extensions ,
107+ logical_plan:: consumer:: {
108+ DefaultSubstraitConsumer , SubstraitConsumer , from_field_reference,
109+ } ,
110+ } ;
111+
112+ #[ tokio:: test]
113+ async fn test_lambda_variable_invalid_steps_out ( ) {
114+ let lambda_field_ref = lambda_field_ref ( 0 , 99 ) ;
115+
116+ let extensions = Extensions :: default ( ) ;
117+ let session_state = SessionContext :: new ( ) . state ( ) ;
118+ let consumer = DefaultSubstraitConsumer :: new ( & extensions, & session_state) ;
119+
120+ let err = from_field_reference ( & consumer, & lambda_field_ref, & DFSchema :: empty ( ) )
121+ . await
122+ . unwrap_err ( ) ;
123+
124+ assert_contains ! ( err. to_string( ) , "No lambda at 99 steps out, got only 0" ) ;
125+ }
126+
127+ #[ tokio:: test]
128+ async fn test_lambda_variable_invalid_field_idx ( ) {
129+ let lambda_field_ref = lambda_field_ref ( 1 , 0 ) ;
130+
131+ let extensions = Extensions :: default ( ) ;
132+ let session_state = SessionContext :: new ( ) . state ( ) ;
133+ let consumer = DefaultSubstraitConsumer :: new ( & extensions, & session_state) ;
134+ let _names = consumer
135+ . push_lambda_parameters (
136+ & [ Type {
137+ kind : Some ( Kind :: I64 ( I64 :: default ( ) ) ) ,
138+ } ] ,
139+ & DFSchema :: empty ( ) ,
140+ )
141+ . unwrap ( ) ;
142+
143+ let err = from_field_reference ( & consumer, & lambda_field_ref, & DFSchema :: empty ( ) )
144+ . await
145+ . unwrap_err ( ) ;
146+
147+ assert_contains ! (
148+ err. to_string( ) ,
149+ "At lambda 0 steps out, no field at index 1, got only 1"
150+ ) ;
151+ }
152+
153+ fn lambda_field_ref ( field : i32 , steps_out : u32 ) -> FieldReference {
154+ FieldReference {
155+ reference_type : Some ( field_reference:: ReferenceType :: DirectReference (
156+ ReferenceSegment {
157+ reference_type : Some ( ReferenceType :: StructField ( Box :: new (
158+ StructField { field, child : None } ,
159+ ) ) ) ,
160+ } ,
161+ ) ) ,
162+ root_type : Some ( RootType :: LambdaParameterReference (
163+ LambdaParameterReference { steps_out } ,
164+ ) ) ,
165+ }
166+ }
167+ }
0 commit comments