feat: support exists predicate in analyzer.

Author: ashigeru

src/mizugaki/analyzer/details/analyze_scalar_expression.cpp

@@ -31,6 +31,7 @@
 
 #include <yugawara/extension/scalar/aggregate_function_call.h>
 #include <yugawara/extension/scalar/subquery.h>
+#include <yugawara/extension/scalar/exists.h>
 
 #include <mizugaki/ast/scalar/dispatch.h>
 #include <mizugaki/ast/literal/boolean.h>
@@ -712,9 +713,6 @@ class engine {
         return result;
     }
 
-    // FIXME: impl pattern_match_predicate,
-    // FIXME: impl table_predicate,
-
     [[nodiscard]] std::unique_ptr<tscalar::expression> operator()(
             ast::scalar::pattern_match_predicate const& expr,
             value_context const& context) {
@@ -778,6 +776,43 @@ class engine {
         return {};
     }
 
+    [[nodiscard]] std::unique_ptr<tscalar::expression> operator()(
+            ast::scalar::table_predicate const& expr,
+            value_context const& context) {
+        using kind = ast::scalar::table_operator;
+        switch (*expr.operator_kind()) {
+            case kind::exists:
+                return process_exists(expr, context);
+            case kind::unique:
+                break;
+        }
+        context_.report(
+                sql_analyzer_code::unsupported_feature,
+                string_builder {}
+                        << "unsupported table predicate: " << expr.operator_kind()
+                        << string_builder::to_string,
+                expr.operator_kind().region());
+        return {};
+    }
+
+    [[nodiscard]] std::unique_ptr<tscalar::expression> process_exists(
+            ast::scalar::table_predicate const& expr,
+            value_context const&) {
+        ::takatori::relation::graph_type subgraph {};
+        auto query = analyze_query_expression(
+                context_,
+                subgraph,
+                *expr.operand(),
+                scope_,
+                {}); // NOTE: don't propagate value context into subqueries
+        if (!query) {
+            return {};
+        }
+        auto result = context_.create<::yugawara::extension::scalar::exists>(
+                expr.region(),
+                std::move(subgraph));
+        return result;
+    }
 
     // FIXME: impl <type predicate>
 

test/mizugaki/analyzer/details/analyze_scalar_expression_subquery_test.cpp

@@ -9,6 +9,7 @@
 #include <takatori/relation/values.h>
 
 #include <yugawara/extension/scalar/subquery.h>
+#include <yugawara/extension/scalar/exists.h>
 
 #include <yugawara/binding/extract.h>
 
@@ -17,6 +18,7 @@
 
 #include <mizugaki/ast/scalar/value_constructor.h>
 #include <mizugaki/ast/scalar/subquery.h>
+#include <mizugaki/ast/scalar/table_predicate.h>
 #include <mizugaki/ast/query/query.h>
 #include <mizugaki/ast/query/table_reference.h>
 #include <mizugaki/ast/query/table_value_constructor.h>
@@ -151,4 +153,45 @@ TEST_F(analyze_scalar_expression_subquery_test, row_subquery_unsupported) {
     });
 }
 
+TEST_F(analyze_scalar_expression_subquery_test, table_predicate_exists) {
+    auto r = analyze_scalar_expression(
+            context(),
+            ast::scalar::table_predicate {
+                    ast::scalar::table_operator::exists,
+                    ast::query::table_value_constructor {
+                            ast::scalar::value_constructor {
+                                    literal(number("1")),
+                            },
+                    },
+            },
+            scope,
+            {});
+    ASSERT_TRUE(r) << diagnostics();
+
+    auto&& exists = downcast<::yugawara::extension::scalar::exists>(*r);
+    auto&& subgraph = exists.query_graph();
+    ASSERT_EQ(subgraph.size(), 1);
+
+    auto&& subquery_output = exists.find_output_port();
+    ASSERT_TRUE(subquery_output);
+    ASSERT_FALSE(subquery_output->opposite());
+    ASSERT_TRUE(subgraph.contains(subquery_output->owner()));
+
+    // values -
+    auto&& values = downcast<trelation::values>(subquery_output->owner());
+    auto&& values_columns = values.columns();
+    ASSERT_EQ(values_columns.size(), 1);
+}
+
+TEST_F(analyze_scalar_expression_subquery_test, table_predicate_unique_unsupported) {
+    invalid(sql_analyzer_code::unsupported_feature, ast::scalar::table_predicate {
+            ast::scalar::table_operator::unique,
+            ast::query::table_value_constructor {
+                    ast::scalar::value_constructor {
+                            literal(number("1")),
+                    },
+            },
+    });
+}
+
 } // namespace mizugaki::analyzer::details