python lit function to support bool and byte vec

[jimexist]

Which issue does this PR close?

Closes #

Rationale for this change

python lit function to support bool and byte vec

What changes are included in this PR?

Are there any user-facing changes?

[houqp]

LGTM other than the error message that @xudong963 mentioned 👍

[pjmore]

An alternative to manually trying to extract values is to create an enum with the allowed rust types and derive FromPyObject for it. I added in implementation for Literal for & [u8] for checking this locally.

#[derive(FromPyObject)]
enum PythonLiteral<'a>{
    UInt(u64),
    Int(i64),
    Float(f64),
    Str(&'a str),
    Boolean(bool),
    Binary(&'a [u8])
}

impl<'a> Literal for PythonLiteral<'a>{
    fn lit(&self) -> logical_plan::Expr {
        match self{
            PythonLiteral::Int(val) => val.lit(),
            PythonLiteral::UInt(val) => val.lit(),
            PythonLiteral::Float(val) => val.lit(),
            PythonLiteral::Str(val) => (*val).lit(),
            PythonLiteral::Boolean(val) => val.lit(),
            PythonLiteral::Binary(val) => (*val).lit(), 
        }
    }
}

/// Expression representing a constant value
#[pyfunction]
#[pyo3(text_signature = "(value)")]
fn lit(value: &PyAny) -> PyResult<expression::Expression> {
        let py_lit = value.extract::<PythonLiteral>()?;
        let expr = py_lit.lit();
        Ok(expression::Expression { expr })
}

This outputs error messages like

TypeError: failed to extract enum PythonLiteral ('Union[Int, UInt, Float, String, Boolean, Binary]')
       - variant Int (Int): 'list' object cannot be interpreted as an integer
       - variant UInt (UInt): 'list' object cannot be interpreted as an integer
       - variant Float (Float): must be real number, not list
       - variant String (String): 'list' object cannot be converted to 'PyString'
       - variant Boolean (Boolean): 'list' object cannot be converted to 'PyBool'
       - variant Binary (Binary): 'list' object cannot be converted to 'PyBytes'

[jimexist]

An alternative to manually trying to extract values is to create an enum with the allowed rust types and derive FromPyObject for it. I added in implementation for Literal for & [u8] for checking this locally.

#[derive(FromPyObject)]
enum PythonLiteral<'a>{
    UInt(u64),
    Int(i64),
    Float(f64),
    Str(&'a str),
    Boolean(bool),
    Binary(&'a [u8])
}

impl<'a> Literal for PythonLiteral<'a>{
    fn lit(&self) -> logical_plan::Expr {
        match self{
            PythonLiteral::Int(val) => val.lit(),
            PythonLiteral::UInt(val) => val.lit(),
            PythonLiteral::Float(val) => val.lit(),
            PythonLiteral::Str(val) => (*val).lit(),
            PythonLiteral::Boolean(val) => val.lit(),
            PythonLiteral::Binary(val) => (*val).lit(), 
        }
    }
}

/// Expression representing a constant value
#[pyfunction]
#[pyo3(text_signature = "(value)")]
fn lit(value: &PyAny) -> PyResult<expression::Expression> {
        let py_lit = value.extract::<PythonLiteral>()?;
        let expr = py_lit.lit();
        Ok(expression::Expression { expr })
}

This outputs error messages like

TypeError: failed to extract enum PythonLiteral ('Union[Int, UInt, Float, String, Boolean, Binary]')
       - variant Int (Int): 'list' object cannot be interpreted as an integer
       - variant UInt (UInt): 'list' object cannot be interpreted as an integer
       - variant Float (Float): must be real number, not list
       - variant String (String): 'list' object cannot be converted to 'PyString'
       - variant Boolean (Boolean): 'list' object cannot be converted to 'PyBool'
       - variant Binary (Binary): 'list' object cannot be converted to 'PyBytes'

thanks - it's a better solution so let me adapt it

[houqp]

nice tip @pjmore , definitely looks much cleaner :)