add draft of WHERE cluse in query class

CMakeLists.txt

@@ -39,6 +39,7 @@ set(SOURCES
         src/database/defaults/DefaultInsertCommand.cpp
         src/database/defaults/DefaultSelectCommand.cpp
         src/database/CommandGenerator.cpp
+        src/query/Condition.cpp
 )
 
 add_library(${LIBRARY_NAME} ${SOURCES})
@@ -91,6 +92,7 @@ if (BUILD_ORM_CXX_TESTS)
             src/database/defaults/DefaultDropTableCommandTest.cpp
             src/database/defaults/DefaultInsertCommandTest.cpp
             src/database/defaults/DefaultSelectCommandTest.cpp
+            src/query/ConditionTest.cpp
     )
 
     set(GTEST_INCLUDE_DIR

include/orm-cxx/query.hpp

@@ -25,6 +25,17 @@ class Query
      */
     Query() : data{.modelInfo = Model<T>().getModelInfo()} {}
 
+    /**
+     * @brief Where clause
+     * @param condition
+     */
+    auto where(const query::Condition& condition) -> Query<T>&
+    {
+        data.condition = condition;
+
+        return *this;
+    }
+
     /**
      * @brief Sets the OFFSET clause for the select query.
      * @param offset The number of rows to skip.

include/orm-cxx/query/Condition.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+
+namespace orm::query
+{
+class Condition
+{
+    enum class Operator
+    {
+        EQUAL,
+        NOT_EQUAL,
+        GREATER,
+        GREATER_OR_EQUAL,
+        LESS,
+        LESS_OR_EQUAL,
+        LIKE,
+        NOT_LIKE,
+        IS_NULL,
+        IS_NOT_NULL
+    };
+
+public:
+    Condition(std::string columnName);
+
+    //    auto operator==(const std::string& value) -> Condition&;
+    //
+    //    auto operator!=(const std::string& value) -> Condition&;
+    //
+    //    auto operator>(const std::string& value) -> Condition&;
+    //
+    //    auto operator>=(const std::string& value) -> Condition&;
+    //
+    //    auto operator<(const std::string& value) -> Condition&;
+    //
+    //    auto operator<=(const std::string& value) -> Condition&;
+
+    auto like(const std::string& value) -> Condition&;
+
+    auto notLike(const std::string& value) -> Condition&;
+
+    auto isNull() -> Condition&;
+
+    auto isNotNull() -> Condition&;
+
+private:
+    std::string columnName;
+
+    Operator operatorType;
+
+    std::string comparisonValue;
+};
+} // namespace orm::query

include/orm-cxx/query/QueryData.hpp

@@ -3,15 +3,17 @@
 #include <optional>
 #include <string>
 
+#include "Condition.hpp"
 #include "orm-cxx/model/ModelInfo.hpp"
 
 namespace orm::query
 {
 struct QueryData
 {
-    const model::ModelInfo& modelInfo;                /**< The model info for the query. */
-    std::optional<std::size_t> offset = std::nullopt; /**< The optional OFFSET value for the query. */
-    std::optional<std::size_t> limit = std::nullopt;  /**< The optional LIMIT value for the query. */
-    bool shouldJoin = true;                           /**< The flag that indicates if the query should join. */
+    const model::ModelInfo& modelInfo;                 /**< The model info for the query. */
+    std::optional<std::size_t> offset = std::nullopt;  /**< The optional OFFSET value for the query. */
+    std::optional<std::size_t> limit = std::nullopt;   /**< The optional LIMIT value for the query. */
+    std::optional<Condition> condition = std::nullopt; /**< The optional WHERE condition(s) */
+    bool shouldJoin = true;                            /**< The flag that indicates if the query should join. */
 };
 }

src/query/Condition.cpp

@@ -0,0 +1,32 @@
+#include "orm-cxx/query/Condition.hpp"
+
+namespace orm::query
+{
+Condition::Condition(std::string columnName) : columnName{std::move(columnName)} {}
+
+auto Condition::like(const std::string& value) -> Condition&
+{
+    operatorType = Operator::LIKE;
+    comparisonValue = value;
+    return *this;
+}
+
+auto Condition::notLike(const std::string& value) -> Condition&
+{
+    operatorType = Operator::NOT_LIKE;
+    comparisonValue = value;
+    return *this;
+}
+
+auto Condition::isNull() -> Condition&
+{
+    operatorType = Operator::IS_NULL;
+    return *this;
+}
+
+auto Condition::isNotNull() -> Condition&
+{
+    operatorType = Operator::IS_NOT_NULL;
+    return *this;
+}
+} // namespace orm::query

src/query/ConditionTest.cpp

@@ -0,0 +1,41 @@
+#include "orm-cxx/query/Condition.hpp"
+
+#include <gtest/gtest.h>
+
+namespace
+{
+
+}
+
+class ConditionTest : public ::testing::Test
+{
+};
+
+TEST_F(ConditionTest, shouldCreateCondition)
+{
+    orm::query::Condition condition{"test"};
+}
+
+TEST_F(ConditionTest, shouldSetLikeCondition)
+{
+    orm::query::Condition condition{"test"};
+    condition.like("value");
+}
+
+TEST_F(ConditionTest, shouldSetNotLikeCondition)
+{
+    orm::query::Condition condition{"test"};
+    condition.notLike("value");
+}
+
+TEST_F(ConditionTest, shouldSetIsNullCondition)
+{
+    orm::query::Condition condition{"test"};
+    condition.isNull();
+}
+
+TEST_F(ConditionTest, shouldSetIsNotNullCondition)
+{
+    orm::query::Condition condition{"test"};
+    condition.isNotNull();
+}