[BUG] Inconsistency in cudfAST Evaluation for Complex Expressions

[aocsa]

Describe the bug

cudfAST, as documented in Issue #12319, has known limitations in evaluating AST expressions involving mixed data types such as i32 + i64. This limitation stems from the lack of automatic type casting support in cudfAST. The source code reference here further explains this behavior. It appears that cudfAST deems an expression valid when operands share the same data type.

Observed Behavior

cudfAST successfully evaluates expressions where binary operands have consistent data types, and the AST tree's height is less than three. An example is (i64 < i64) == (f64 < f64). However, in attempts to evaluate more complex expressions with additional levels in the AST Tree, such as (i64 < i64) == (i64 < (i64 + i64)), cudfAST returns an error stating, "An AST expression was provided non-matching operand types."

Example of valid cudfAST expression

                (==)
               /    \
            (<)      (<)
           /  \     /   \
        i64  i64  str   str

Clarification Needed

It remains unclear whether this behavior is an intentional design choice or a limitation that warrants attention. The inability to process expressions with an AST tree height greater than two significantly restricts cudfAST's flexibility and usability.

Here is an example of a 'complex' expression.

                (==)
               /    \
            (<)      (<)
           /  \     /   \
        i64  i64  i64   (+)
                        /  \
                      i64  i64

Expected Behavior

Ideally, cudfAST should either support evaluation of complex expression or provide a clear error message explaining the limitation.

Steps to Reproduce

Execute a simple cudfAST expression like (i64 < i64) == (i64 < i64), which works as expected.
Attempt a more complex expression such as (i64 < i64) == (i64 < (i64 + i64)), which results in the mentioned error.

Steps/Code to Reproduce Bug

import cudf
import pandas as pd 

df = cudf.DataFrame({'b8': [True,True,False], 'i64': [4, 5, 6], 'f64': [4.0, 5.0, 6.0], 'str': ["A", "B", "C"]})
df.eval("(b8 < b8) == (str < str)") # OK
df.eval("(i64 < i64) == (str == str)") # OK 

df.eval("(i64 < i64) == (i64 < (i64 + i64))")
# Error received:
# CUDF failure at:/opt/conda/conda-bld/work/cpp/src/ast/expression_parser.cpp:149:
# An AST expression was provided non-matching operand types.

Environment overview

Environment location: conda
Method of cuDF install: conda
branch-23.10, origin/branch-23.10

[vyasr]

Thank you for the report! This definitely looks like a bug to me. I'm not immediately sure why this would be happening, but it looks like the output type of the more deeply nested part of the expression tree is being determined incorrectly. This should be supported.

It definitely looks like the issue is with imbalanced trees because this expression works:

 df.eval("(i64 > (i64 + i64)) == (i64 < (i64 + i64))")

[GregoryKimball]

@revans2 Have you seen any issues with inbalanced AST trees in Spark-RAPIDS?

[revans2]

@revans2 Have you seen any issues with inbalanced AST trees in Spark-RAPIDS?

@GregoryKimball we have not stress tested that part much, but obviously should do more of it. We have not seen this in practice, but most of the join conditions we see end up being split up and optimized by Spark anyways. So it might take a fair amount of work to make an imbalanced condition like this.

[jlowe]

I was able to reproduce the issue on Spark with the RAPIDS Accelerator by enabling AST projections and using a complex expression similar to the one proposed (the original expression Spark will simplify into one that works):

scala> spark.conf.set("spark.rapids.sql.projectAstEnabled", "true")
scala> spark.range(10).withColumn("x", col("id")).repartition(1).selectExpr("(id < x) == (id < (id + x))").collect
23/11/15 21:30:31 ERROR Executor: Exception in task 0.0 in stage 5.0 (TID 3)
ai.rapids.cudf.CudfException: CUDF failure at:/home/jenkins/agent/workspace/jenkins-spark-rapids-jni_nightly-pre_release-203-cuda11/thirdparty/cudf/cpp/src/ast/expression_parser.cpp:149: An AST expression was provided non-matching operand types.
	at ai.rapids.cudf.ast.CompiledExpression.computeColumn(Native Method)
	at ai.rapids.cudf.ast.CompiledExpression.computeColumn(CompiledExpression.java:88)
	at com.nvidia.spark.rapids.GpuProjectAstExec$$anon$1.$anonfun$next$15(basicPhysicalOperators.scala:452)
[...]

[vyasr]

I believe I have a fix for this in #14445.