clp-s: Add boilerplate for new sql parser

components/core/CMakeLists.txt

@@ -519,6 +519,7 @@ set(SOURCE_FILES_unitTest
         tests/test-Stopwatch.cpp
         tests/test-StreamingCompression.cpp
         tests/test-string_utils.cpp
+        tests/test-sql.cpp
         tests/test-TimestampPattern.cpp
         tests/test-utf8_utils.cpp
         tests/test-Utils.cpp
@@ -539,6 +540,7 @@ target_link_libraries(unitTest
         LibArchive::LibArchive
         MariaDBClient::MariaDBClient
         spdlog::spdlog
+        sql
         OpenSSL::Crypto
         ${sqlite_LIBRARY_DEPENDENCIES}
         ${STD_FS_LIBS}

components/core/src/clp_s/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_subdirectory(search/kql)
+add_subdirectory(search/sql)
 
 set(
         CLP_SOURCES

components/core/src/clp_s/search/antlr_common/ErrorListener.hpp

@@ -0,0 +1,36 @@
+#ifndef CLP_S_SEARCH_ANTLRCOMMON_ERRORLISTENER_HPP
+#define CLP_S_SEARCH_ANTLRCOMMON_ERRORLISTENER_HPP
+
+#include <cstddef>
+#include <exception>
+#include <string>
+#include <string_view>
+
+#include <antlr4-runtime.h>
+
+namespace clp_s::search::antlr_common {
+class ErrorListener : public antlr4::BaseErrorListener {
+public:
+    auto syntaxError(
+            [[maybe_unused]] antlr4::Recognizer* recognizer,
+            [[maybe_unused]] antlr4::Token* offending_symbol,
+            [[maybe_unused]] size_t line,
+            [[maybe_unused]] size_t char_position_in_line,
+            std::string const& msg,
+            [[maybe_unused]] std::exception_ptr e
+    ) -> void override {
+        m_error = true;
+        m_error_message = msg;
+    }
+
+    [[nodiscard]] auto error() const -> bool { return m_error; }
+
+    [[nodiscard]] auto message() const -> std::string_view { return m_error_message; }
+
+private:
+    bool m_error{false};
+    std::string m_error_message;
+};
+}  // namespace clp_s::search::antlr_common
+
+#endif  // CLP_S_SEARCH_ANTLRCOMMON_ERRORLISTENER_HPP

components/core/src/clp_s/search/kql/CMakeLists.txt

@@ -8,6 +8,7 @@ ANTLR_TARGET(
 add_library(
         kql
         ../../Utils.hpp
+        ../antlr_common/ErrorListener.hpp
         ../AndExpr.hpp
         ../BooleanLiteral.hpp
         ../ColumnDescriptor.hpp
@@ -25,4 +26,4 @@ add_library(
 )
 target_compile_features(kql PRIVATE cxx_std_20)
 target_include_directories(kql PRIVATE ${ANTLR_KqlParser_OUTPUT_DIR})
-target_link_libraries(kql PRIVATE antlr4_static Boost::filesystem)
+target_link_libraries(kql PRIVATE antlr4_static spdlog::spdlog)

components/core/src/clp_s/search/kql/kql.cpp

@@ -5,14 +5,9 @@
 #include <antlr4-runtime.h>
 #include <spdlog/spdlog.h>
 
-#include "KqlBaseVisitor.h"
-#include "KqlLexer.h"
-#include "KqlParser.h"
-// If redlining may want to add ${workspaceFolder}/build/**
-// to include path for vscode C/C++ utils
-
 #include "../../Utils.hpp"
 #include "../AndExpr.hpp"
+#include "../antlr_common/ErrorListener.hpp"
 #include "../BooleanLiteral.hpp"
 #include "../ColumnDescriptor.hpp"
 #include "../DateLiteral.hpp"
@@ -22,34 +17,16 @@
 #include "../NullLiteral.hpp"
 #include "../OrExpr.hpp"
 #include "../StringLiteral.hpp"
+#include "KqlBaseVisitor.h"
+#include "KqlLexer.h"
+#include "KqlParser.h"
 
 using namespace antlr4;
 using namespace kql;
+using clp_s::search::antlr_common::ErrorListener;
 
 namespace clp_s::search::kql {
-class ErrorListener : public BaseErrorListener {
-public:
-    void syntaxError(
-            Recognizer* recognizer,
-            Token* offending_symbol,
-            size_t line,
-            size_t char_position_in_line,
-            std::string const& msg,
-            std::exception_ptr e
-    ) override {
-        m_error = true;
-        m_error_message = msg;
-    }
-
-    bool error() const { return m_error; }
-
-    std::string const& message() const { return m_error_message; }
-
-private:
-    bool m_error{false};
-    std::string m_error_message;
-};
-
+namespace {
 class ParseTreeVisitor : public KqlBaseVisitor {
 private:
     static void
@@ -224,6 +201,7 @@ class ParseTreeVisitor : public KqlBaseVisitor {
         return base;
     }
 };
+}  // namespace
 
 std::shared_ptr<Expression> parse_kql_expression(std::istream& in) {
     ErrorListener lexer_error_listener;

components/core/src/clp_s/search/sql/CMakeLists.txt

@@ -0,0 +1,29 @@
+ANTLR_TARGET(
+        SqlParser
+        Sql.g4
+        LEXER PARSER VISITOR
+        PACKAGE sql
+)
+
+add_library(
+        sql
+        ../../Utils.hpp
+        ../antlr_common/ErrorListener.hpp
+        ../AndExpr.hpp
+        ../BooleanLiteral.hpp
+        ../ColumnDescriptor.hpp
+        ../DateLiteral.hpp
+        ../EmptyExpr.hpp
+        ../Expression.hpp
+        ../FilterExpr.hpp
+        ../Integral.hpp
+        ../NullLiteral.hpp
+        ../OrExpr.hpp
+        ../StringLiteral.hpp
+        ${ANTLR_SqlParser_CXX_OUTPUTS}
+        sql.cpp
+        sql.hpp
+)
+target_compile_features(sql PRIVATE cxx_std_20)
+target_include_directories(sql PRIVATE ${ANTLR_SqlParser_OUTPUT_DIR})
+target_link_libraries(sql PRIVATE antlr4_static spdlog::spdlog)

components/core/src/clp_s/search/sql/Sql.g4

@@ -0,0 +1,5 @@
+grammar Sql;
+
+start: EOF ;
+
+SPACE:  [ \t\r\n] -> skip ;

components/core/src/clp_s/search/sql/sql.cpp

@@ -0,0 +1,59 @@
+#include <any>
+#include <iostream>
+#include <memory>
+
+#include <antlr4-runtime.h>
+#include <spdlog/spdlog.h>
+
+#include "../antlr_common/ErrorListener.hpp"
+#include "../EmptyExpr.hpp"
+#include "../Expression.hpp"
+#include "SqlBaseVisitor.h"
+#include "SqlLexer.h"
+#include "SqlParser.h"
+
+using antlr4::ANTLRInputStream;
+using antlr4::CommonTokenStream;
+using clp_s::search::antlr_common::ErrorListener;
+using sql::SqlBaseVisitor;
+using sql::SqlLexer;
+using sql::SqlParser;
+
+namespace clp_s::search::sql {
+namespace {
+class ParseTreeVisitor : public SqlBaseVisitor {
+public:
+    [[nodiscard]] auto visitStart([[maybe_unused]] SqlParser::StartContext* ctx
+    ) -> std::any override {
+        return EmptyExpr::create();
+    }
+};
+}  // namespace
+
+auto parse_sql_expression(std::istream& in) -> std::shared_ptr<Expression> {
+    ErrorListener lexer_error_listener;
+    ErrorListener parser_error_listener;
+
+    ANTLRInputStream input{in};
+    SqlLexer lexer(&input);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(&lexer_error_listener);
+    CommonTokenStream tokens(&lexer);
+    SqlParser parser(&tokens);
+    parser.removeErrorListeners();
+    parser.addErrorListener(&parser_error_listener);
+    SqlParser::StartContext* tree = parser.start();
+
+    if (lexer_error_listener.error()) {
+        SPDLOG_ERROR("Lexer error: {}", lexer_error_listener.message());
+        return nullptr;
+    }
+    if (parser_error_listener.error()) {
+        SPDLOG_ERROR("Parser error: {}", parser_error_listener.message());
+        return {};
+    }
+
+    ParseTreeVisitor visitor;
+    return std::any_cast<std::shared_ptr<Expression>>(visitor.visitStart(tree));
+}
+}  // namespace clp_s::search::sql

components/core/src/clp_s/search/sql/sql.hpp

@@ -0,0 +1,18 @@
+#ifndef CLP_S_SEARCH_SQL_SQL_HPP
+#define CLP_S_SEARCH_SQL_SQL_HPP
+
+#include <istream>
+#include <memory>
+
+#include "../Expression.hpp"
+
+namespace clp_s::search::sql {
+/**
+ * Parses an SQL expression from the given stream to generate a search AST.
+ * @param in Input stream containing an SQL expression followed by EOF
+ * @return a search AST on success, nullptr otherwise
+ */
+[[nodiscard]] auto parse_sql_expression(std::istream& in) -> std::shared_ptr<Expression>;
+}  // namespace clp_s::search::sql
+
+#endif  // CLP_S_SEARCH_SQL_SQL_HPP

components/core/tests/test-sql.cpp

@@ -0,0 +1,24 @@
+#include <memory>
+#include <sstream>
+
+#include <Catch2/single_include/catch2/catch.hpp>
+#include <spdlog/spdlog.h>
+
+#include "../src/clp_s/search/EmptyExpr.hpp"
+#include "../src/clp_s/search/sql/sql.hpp"
+#include "LogSuppressor.hpp"
+
+using clp_s::search::EmptyExpr;
+using clp_s::search::sql::parse_sql_expression;
+using std::stringstream;
+
+TEST_CASE("Test parsing SQL", "[SQL]") {
+    // Suppress logging
+    LogSuppressor suppressor{};
+
+    SECTION("Stub accepts empty string") {
+        stringstream empty_string{""};
+        auto filter = std::dynamic_pointer_cast<EmptyExpr>(parse_sql_expression(empty_string));
+        REQUIRE(nullptr != filter);
+    }
+}