Temp test

Author: infvg

backends-velox/src-iceberg/test/scala/org/apache/gluten/execution/enhanced/VeloxIcebergSuite.scala

@@ -16,6 +16,7 @@
  */
 package org.apache.gluten.execution.enhanced
 
+import org.apache.gluten.config.VeloxConfig
 import org.apache.gluten.execution._
 import org.apache.gluten.tags.EnhancedFeaturesTest
 
@@ -383,4 +384,109 @@ class VeloxIcebergSuite extends IcebergSuite {
       }
     }
   }
+
+  test("iceberg max aggregate") {
+    withSQLConf(VeloxConfig.ENABLE_ENHANCED_FEATURES.key -> "true") {
+      withTable("store_sales_test") {
+        // Create a simple test table with decimal prices
+        spark.sql("""
+                    |create table store_sales_test (
+                    |  ss_item_sk int,
+                    |  ss_sales_price decimal(7,2)
+                    |) using iceberg
+                    |""".stripMargin)
+
+        // Insert test data matching the issue description
+        spark.sql("""
+                    |insert into store_sales_test values
+                    |(1, 200.00),
+                    |(2, 200.00),
+                    |(3, 200.00),
+                    |(4, 199.98),
+                    |(5, 199.96),
+                    |(6, 199.96),
+                    |(7, 199.92),
+                    |(8, 199.92),
+                    |(9, 199.92),
+                    |(10, 199.90)
+                    |""".stripMargin)
+
+        // Test 1: Verify ORDER BY DESC LIMIT works correctly
+        val orderByResult = spark
+          .sql(
+            "select ss_sales_price from store_sales_test order by ss_sales_price desc limit 10"
+          )
+          .collect()
+
+        assert(orderByResult.length == 10, "Should return 10 rows")
+        assert(
+          orderByResult(0).getDecimal(0).doubleValue() == 200.00,
+          "First value should be 200.00")
+
+        // Test 2: MAX aggregate without WHERE clause - THIS IS THE BUG
+        // With enhancedFeatures=true, this returns NULL incorrectly
+        val maxResult = spark
+          .sql(
+            "select max(ss_sales_price) from store_sales_test"
+          )
+          .collect()
+
+        assert(maxResult.length == 1, "Should return 1 row")
+        assert(maxResult(0).get(0) != null, "MAX should not return NULL")
+        assert(
+          maxResult(0).getDecimal(0).doubleValue() == 200.00,
+          s"MAX should return 200.00, but got ${maxResult(0).get(0)}"
+        )
+
+        // Test 3: MAX aggregate with WHERE clause - this works correctly
+        val maxWithWhereResult = spark
+          .sql(
+            "select max(ss_sales_price) from store_sales_test where ss_sales_price is not null"
+          )
+          .collect()
+
+        assert(maxWithWhereResult.length == 1, "Should return 1 row")
+        assert(maxWithWhereResult(0).get(0) != null, "MAX with WHERE should not return NULL")
+        assert(
+          maxWithWhereResult(0).getDecimal(0).doubleValue() == 200.00,
+          s"MAX with WHERE should return 200.00, but got ${maxWithWhereResult(0).get(0)}"
+        )
+      }
+    }
+    withSQLConf(VeloxConfig.ENABLE_ENHANCED_FEATURES.key -> "false") {
+      withTable("store_sales_test_disabled") {
+        // Create a simple test table with decimal prices
+        spark.sql("""
+                    |create table store_sales_test_disabled (
+                    |  ss_item_sk int,
+                    |  ss_sales_price decimal(7,2)
+                    |) using iceberg
+                    |""".stripMargin)
+
+        // Insert test data
+        spark.sql("""
+                    |insert into store_sales_test_disabled values
+                    |(1, 200.00),
+                    |(2, 199.98),
+                    |(3, 199.96)
+                    |""".stripMargin)
+
+        // With enhancedFeatures=false, MAX should work correctly
+        val maxResult = spark
+          .sql(
+            "select max(ss_sales_price) from store_sales_test_disabled"
+          )
+          .collect()
+
+        assert(maxResult.length == 1, "Should return 1 row")
+        assert(
+          maxResult(0).get(0) != null,
+          "MAX should not return NULL with enhancedFeatures=false")
+        assert(
+          maxResult(0).getDecimal(0).doubleValue() == 200.00,
+          s"MAX should return 200.00, but got ${maxResult(0).get(0)}"
+        )
+      }
+    }
+  }
 }