readyset-server: Allow function predicates

Handle non-aggregate function calls in WHERE predicates by lowering them
to filter expressions instead of raising an internal error.

I believe the previous error message was inaccurate and misleading,
perhaps copy and pasted from the aggregates case, since I can't find
functions being "handled earlier in projection" or anything, and we see
this error consistently whenever a function is the top-level expression
in a predicate. 

Fixes: REA-5941
Release-Note-Core: Allow function as top-level predicates in WHERE, e.g.
  `WHERE COALESCE(col, TRUE)` or `WHERE JSON_OVERLAPS(col, '[42]')`.
AI-Use: level:3
Change-Id: Iee455de1c509999f76d391ddcf4e4a7e6a6a6964
Reviewed-on: https://gerrit.readyset.name/c/readyset/+/11232
Tested-by: Buildkite CI
Reviewed-by: Vassili Zarouba <vassili@readyset.io>

Author: mvzink

logictests/mysql/function_predicate.test

@@ -0,0 +1,81 @@
+statement ok
+CREATE TABLE json_overlaps_test (id INT PRIMARY KEY, payload JSON);
+
+statement ok
+INSERT INTO json_overlaps_test VALUES
+  (1, '[1,2,3]'),
+  (2, '[3,4]'),
+  (3, '[4,5]'),
+  (4, '[1,2,3,4]'),
+  (5, '[]');
+
+query I
+SELECT json_overlaps(payload, '[1,2,3]') FROM json_overlaps_test ORDER BY id;
+----
+1
+1
+0
+1
+0
+
+query I
+SELECT id FROM json_overlaps_test
+WHERE json_overlaps(payload, '[1,2,3]')
+ORDER BY id;
+----
+1
+2
+4
+
+query I
+SELECT id FROM json_overlaps_test
+WHERE id > ? AND json_overlaps(payload, '[1,2,3]')
+ORDER BY id;
+? = 1
+----
+2
+4
+
+# Test COALESCE and IFNULL as predicates
+statement ok
+CREATE TABLE bool_nulls (id INT PRIMARY KEY, b BOOLEAN);
+
+statement ok
+INSERT INTO bool_nulls VALUES
+  (1, TRUE),
+  (2, FALSE),
+  (3, NULL),
+  (4, TRUE),
+  (5, NULL);
+
+# Test COALESCE with boolean, defaulting NULL to TRUE
+query I
+SELECT id FROM bool_nulls WHERE COALESCE(b, TRUE) ORDER BY id;
+----
+1
+3
+4
+5
+
+# Test COALESCE with boolean, defaulting NULL to FALSE
+query I
+SELECT id FROM bool_nulls WHERE COALESCE(b, FALSE) ORDER BY id;
+----
+1
+4
+
+# Test IFNULL with boolean, defaulting NULL to TRUE
+query I
+SELECT id FROM bool_nulls WHERE IFNULL(b, TRUE) ORDER BY id;
+----
+1
+3
+4
+5
+
+# Test IFNULL with boolean, defaulting NULL to FALSE
+query I
+SELECT id FROM bool_nulls WHERE IFNULL(b, FALSE) ORDER BY id;
+----
+1
+4

logictests/psql/function_predicate.test

@@ -0,0 +1,37 @@
+# Test function calls as WHERE predicates in PostgreSQL
+
+statement ok
+CREATE TABLE bool_nulls (id INT PRIMARY KEY, b BOOLEAN);
+
+statement ok
+INSERT INTO bool_nulls VALUES
+  (1, TRUE),
+  (2, FALSE),
+  (3, NULL),
+  (4, TRUE),
+  (5, NULL);
+
+# Test COALESCE with boolean, defaulting NULL to TRUE
+query I
+SELECT id FROM bool_nulls WHERE COALESCE(b, TRUE) ORDER BY id;
+----
+1
+3
+4
+5
+
+# Test COALESCE with boolean, defaulting NULL to FALSE
+query I
+SELECT id FROM bool_nulls WHERE COALESCE(b, FALSE) ORDER BY id;
+----
+1
+4
+
+# Test COALESCE with three arguments
+query I
+SELECT id FROM bool_nulls WHERE COALESCE(NULL, b, TRUE) ORDER BY id;
+----
+1
+3
+4
+5

readyset-server/src/controller/sql/mir/mod.rs

@@ -1947,9 +1947,6 @@ impl SqlToMirConverter {
 
                 self.handle_exists(ce, query_name, &name, parent, subquery)?
             }
-            Expr::Call(_) => {
-                internal!("Function calls should have been handled by projection earlier")
-            }
             Expr::In {
                 lhs,
                 rhs: InValue::Subquery(subquery),
@@ -3255,4 +3252,164 @@ mod tests {
         // post-lookups not enabled
         expect_success: false
     }
+
+    #[test]
+    fn function_call_predicate_is_supported() {
+        let query = parse_select(
+            readyset_sql::Dialect::MySQL,
+            "SELECT a FROM test_table WHERE json_overlaps(test_table.c, '[1,2,3]')",
+        )
+        .unwrap();
+
+        let qg = to_query_graph(query, Dialect::DEFAULT_MYSQL).unwrap();
+        let columns = &[
+            ColumnSpecification {
+                column: Column::from("test_table.a"),
+                sql_type: SqlType::Int(None),
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+            ColumnSpecification {
+                column: Column::from("test_table.c"),
+                sql_type: SqlType::Json,
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+        ];
+
+        let mut converter = SqlToMirConverter::new(Dialect::DEFAULT_MYSQL);
+        let result = converter
+            .make_base_node(&"test_table".into(), columns, None)
+            .and_then(|_| {
+                converter.named_query_to_mir(&"q1".into(), &qg, &HashMap::new(), LeafBehavior::Leaf)
+            });
+
+        assert!(
+            result.is_ok(),
+            "Expected MIR lowering to succeed, but it failed: {:?}",
+            result.err()
+        );
+    }
+
+    #[test]
+    fn coalesce_predicate_mysql() {
+        let query = parse_select(
+            readyset_sql::Dialect::MySQL,
+            "SELECT a FROM test_table WHERE COALESCE(test_table.b, TRUE)",
+        )
+        .unwrap();
+
+        let qg = to_query_graph(query, Dialect::DEFAULT_MYSQL).unwrap();
+        let columns = &[
+            ColumnSpecification {
+                column: Column::from("test_table.a"),
+                sql_type: SqlType::Int(None),
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+            ColumnSpecification {
+                column: Column::from("test_table.b"),
+                sql_type: SqlType::Bool,
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+        ];
+
+        let mut converter = SqlToMirConverter::new(Dialect::DEFAULT_MYSQL);
+        let result = converter
+            .make_base_node(&"test_table".into(), columns, None)
+            .and_then(|_| {
+                converter.named_query_to_mir(&"q1".into(), &qg, &HashMap::new(), LeafBehavior::Leaf)
+            });
+
+        assert!(
+            result.is_ok(),
+            "Expected MIR lowering to succeed for COALESCE predicate (MySQL), but it failed: {:?}",
+            result.err()
+        );
+    }
+
+    #[test]
+    fn ifnull_predicate_mysql() {
+        let query = parse_select(
+            readyset_sql::Dialect::MySQL,
+            "SELECT a FROM test_table WHERE IFNULL(test_table.b, FALSE)",
+        )
+        .unwrap();
+
+        let qg = to_query_graph(query, Dialect::DEFAULT_MYSQL).unwrap();
+        let columns = &[
+            ColumnSpecification {
+                column: Column::from("test_table.a"),
+                sql_type: SqlType::Int(None),
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+            ColumnSpecification {
+                column: Column::from("test_table.b"),
+                sql_type: SqlType::Bool,
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+        ];
+
+        let mut converter = SqlToMirConverter::new(Dialect::DEFAULT_MYSQL);
+        let result = converter
+            .make_base_node(&"test_table".into(), columns, None)
+            .and_then(|_| {
+                converter.named_query_to_mir(&"q1".into(), &qg, &HashMap::new(), LeafBehavior::Leaf)
+            });
+
+        assert!(
+            result.is_ok(),
+            "Expected MIR lowering to succeed for IFNULL predicate (MySQL), but it failed: {:?}",
+            result.err()
+        );
+    }
+
+    #[test]
+    fn coalesce_predicate_postgresql() {
+        let query = parse_select(
+            readyset_sql::Dialect::PostgreSQL,
+            "SELECT a FROM test_table WHERE COALESCE(test_table.b, TRUE)",
+        )
+        .unwrap();
+
+        let qg = to_query_graph(query, Dialect::DEFAULT_POSTGRESQL).unwrap();
+        let columns = &[
+            ColumnSpecification {
+                column: Column::from("test_table.a"),
+                sql_type: SqlType::Int(None),
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+            ColumnSpecification {
+                column: Column::from("test_table.b"),
+                sql_type: SqlType::Bool,
+                generated: None,
+                constraints: vec![],
+                comment: None,
+            },
+        ];
+
+        let mut converter = SqlToMirConverter::new(Dialect::DEFAULT_POSTGRESQL);
+        let result = converter
+            .make_base_node(&"test_table".into(), columns, None)
+            .and_then(|_| {
+                converter.named_query_to_mir(&"q1".into(), &qg, &HashMap::new(), LeafBehavior::Leaf)
+            });
+
+        assert!(
+            result.is_ok(),
+            "Expected MIR lowering to succeed for COALESCE predicate (PostgreSQL), but it failed: {:?}",
+            result.err()
+        );
+    }
 }