include/matador/orm/error_code.hpp

@@ -10,7 +10,6 @@ enum class error_code : uint8_t {
   Ok = 0,
   NoConnectionAvailable,
   UnknownType,
-  NoPrimaryKey,
   FailedToBuildQuery,
   FailedToFindObject,
   Failed

include/matador/orm/schema.hpp

@@ -3,10 +3,6 @@
 
 #include "matador/object/repository.hpp"
 
-namespace matador::sql {
-class connection_pool;
-}
-
 namespace matador::orm {
 
 class schema {
@@ -23,9 +19,6 @@ public:
     return repo_.attach<Type, SuperType>(name);
   }
 
-  utils::result<void, utils::error> create(sql::connection_pool &pool) const;
-  utils::result<void, utils::error> drop() const;
-
 private:
   object::repository repo_;
 };

include/matador/orm/session.hpp

@@ -121,7 +121,9 @@ public:
   template<typename Type, typename PrimaryKeyType>
   utils::result<object::object_ptr<Type>, utils::error> find(const PrimaryKeyType &pk);
   template<typename Type>
-  utils::result<sql::query_result<Type>, utils::error> find(query::criteria_ptr clause = {});
+  utils::result<sql::query_result<Type>, utils::error> find();
+  // template<typename Type, typename Condition>
+  // utils::result<sql::query_result<Type>, utils::error> find(const Condition &cond);
 
   template<typename Type>
   utils::result<void, utils::error> drop_table();
@@ -294,18 +296,11 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
     if (!info) {
         return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
     }
-    if (!info.value().get().definition().has_primary_key()) {
-        return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key."));
-    }
-
-    const auto& type_info = info.value().get();
 
     session_query_builder eqb(*schema_, *this);
-    const sql::column col(sql::table{type_info.reference_column()->table_name()}, type_info.reference_column()->name());
+    auto data = eqb.build<Type>(pk);
-    using namespace matador::query;
-    auto data = eqb.build<Type>(col == utils::_);
     if (!data.is_ok()) {
-        return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + type_info.name() + "."));
+        return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
     }
 
     auto res = build_select_query(data.release()).prepare(*this);
@@ -315,20 +310,20 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
     }
     auto stmt_result = res->bind(0, const_cast<PrimaryKeyType&>(pk)).template fetch_one<Type>();
     if (stmt_result && !stmt_result.value()) {
-        return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + type_info.name() + " with primary key " + std::to_string(pk) + "."));
+        return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + info->get().name() + " with primary key " + std::to_string(pk) + "."));
     }
     return utils::ok(object::object_ptr<Type>{ stmt_result->release() });
 }
 
 template<typename Type>
-utils::result<sql::query_result<Type>, utils::error> session::find(query::criteria_ptr clause) {
+utils::result<sql::query_result<Type>, utils::error> session::find() {
     auto info = schema_->info<Type>();
     if (!info) {
         return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
     }
 
     session_query_builder eqb(*schema_, *this);
-    auto data = eqb.build<Type>(std::move(clause));
+    auto data = eqb.build<Type>();
     if (!data.is_ok()) {
         return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
     }
@@ -341,6 +336,27 @@ utils::result<sql::query_result<Type>, utils::error> session::find(query::criter
     return result->template fetch<Type>();
 }
 
+// template<typename Type, typename Condition>
+// utils::result<sql::query_result<Type>, utils::error> session::find(const Condition &cond) {
+//     auto info = schema_->info<Type>();
+//     if (!info) {
+//         return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
+//     }
+//
+//     session_query_builder eqb(*schema_, *this);
+//     auto data = eqb.build<Type>();
+//     if (!data.is_ok()) {
+//         return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info->get().name() + "."));
+//     }
+//
+//     auto result = build_select_query(data.release()).prepare(*this);
+//     if (!result.is_ok()) {
+//         return utils::failure(result.err());
+//     }
+//
+//     return result->template fetch<Type>();
+// }
+//
 template<typename Type>
 utils::result<void, utils::error> session::drop_table() {
   auto info = schema_->info<Type>();

include/matador/orm/session_query_builder.hpp

@@ -11,7 +11,6 @@
 
 #include "matador/object/join_columns_collector.hpp"
 #include "matador/object/repository.hpp"
-#include "matador/query/criteria/criteria_visitor.hpp"
 
 #include "matador/utils/primary_key_attribute.hpp"
 #include "matador/utils/result.hpp"
@@ -31,49 +30,46 @@ struct entity_query_data {
   query::criteria_ptr where_clause;
 };
 
-class criteria_transformer final : public query::criteria_visitor {
-public:
-    criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name);
-    void visit( const query::between_criteria& node ) override;
-    void visit( const query::binary_criteria& node ) override;
-    void visit( const query::binary_column_criteria& node ) override;
-    void visit( const query::collection_criteria& node ) override;
-    void visit( const query::collection_query_criteria& node ) override;
-    void visit( const query::like_criteria& node ) override;
-    void visit( const query::logical_criteria& node ) override;
-    void visit( const query::not_criteria& node ) override;
-
-private:
-    void update_criteria_column(const query::abstract_column_criteria& node) const;
-
-private:
-    const object::repository &repo_;
-    const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name_;
-};
-
 class session_query_builder final {
 public:
   session_query_builder(const object::repository &scm, sql::executor &exec)
   : schema_(scm)
   , executor_(exec){}
 
-  template<class EntityType>
+  template<class EntityType, typename PrimaryKeyType>
-  utils::result<entity_query_data, query_build_error> build(query::criteria_ptr clause = {}) {
+  utils::result<entity_query_data, query_build_error> build(const PrimaryKeyType &pk) {
-    const auto info = schema_.info<EntityType>();
+    auto info = schema_.info<EntityType>();
     if (!info) {
       return utils::failure(query_build_error::UnknownType);
     }
+    pk_ = pk;
     table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
     entity_query_data_ = { table_info_stack_.top().table };
     processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
     try {
       access::process(*this, info->get().prototype());
 
-      if (clause) {
+      return {utils::ok(std::move(entity_query_data_))};
-        criteria_transformer transformer{schema_, processed_tables_};
+    } catch (const query_builder_exception &ex) {
-        clause->accept(transformer);
+      return {utils::failure(ex.error_type())};
-        entity_query_data_.where_clause = std::move(clause);
+    } catch (...) {
+      return {utils::failure(query_build_error::UnexpectedError)};
     }
+  }
+
+  template<class EntityType>
+  utils::result<entity_query_data, query_build_error> build() {
+    const auto info = schema_.info<EntityType>();
+    if (!info) {
+      return utils::failure(query_build_error::UnknownType);
+    }
+    pk_ = nullptr;
+    table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
+    entity_query_data_ = { table_info_stack_.top().table };
+    processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
+    try {
+      access::process(*this, info->get().prototype());
+
       return {utils::ok(std::move(entity_query_data_))};
     } catch (const query_builder_exception &ex) {
       return {utils::failure(ex.error_type())};
@@ -83,12 +79,19 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes)
+  {
     push(id);
     if (!is_root_entity()) {
       return;
     }
     entity_query_data_.pk_column_name = id;
+    if (!pk_.is_null()) {
+      const auto c = sql::column{table_info_stack_.top().table, id, ""};
+      using namespace matador::query;
+      auto co = c == utils::_;
+      entity_query_data_.where_clause = std::move(co);
+    }
   }
 
   void on_revision(const char *id, uint64_t &/*rev*/);
@@ -232,6 +235,7 @@ private:
   void append_join(const sql::column &left, const sql::column &right);
 
 private:
+  utils::value pk_;
   struct table_info {
     std::reference_wrapper<const object::basic_object_info> info;
     std::shared_ptr<sql::table> table;

include/matador/query/criteria/abstract_column_criteria.hpp

@@ -1,22 +0,0 @@
-#ifndef MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP
-#define MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP
-
-#include "matador/query/criteria/abstract_criteria.hpp"
-
-#include "matador/sql/column.hpp"
-
-namespace matador::query {
-
-class abstract_column_criteria : public abstract_criteria {
-public:
-    abstract_column_criteria() = delete;
-    explicit abstract_column_criteria(sql::column column);
-
-    [[nodiscard]] const sql::column& column() const;
-
-protected:
-    sql::column column_;
-};
-
-}
-#endif //MATADOR_ABSTRACT_COLUMN_CRITERIA_HPP

include/matador/query/criteria/between_criteria.hpp

@@ -1,14 +1,16 @@
 #ifndef CRITERIA_BETWEEN_CRITERIA_NODE_HPP
 #define CRITERIA_BETWEEN_CRITERIA_NODE_HPP
 
-#include "matador/query/criteria/abstract_column_criteria.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 #include "matador/query/criteria/criteria_utils.hpp"
 
+#include "matador/sql/column.hpp"
+
 #include "matador/utils/value.hpp"
 
 namespace matador::query {
 
-class between_criteria final : public abstract_column_criteria {
+class between_criteria final : public abstract_criteria {
 public:
     between_criteria() = delete;
     between_criteria(sql::column column, int64_t min, int64_t max);
@@ -16,10 +18,12 @@ public:
 
     void accept(criteria_visitor& visitor) const override;
 
+    [[nodiscard]] const sql::column& column() const;
     [[nodiscard]] const criteria_value &minimum() const;
     [[nodiscard]] const criteria_value &maximum() const;
 
 private:
+    sql::column column_;
     criteria_value min_;
     criteria_value max_;
 };

include/matador/query/criteria/binary_criteria.hpp

@@ -1,7 +1,7 @@
 #ifndef CRITERIA_BINARY_CRITERIA_NODE_HPP
 #define CRITERIA_BINARY_CRITERIA_NODE_HPP
 
-#include "matador/query/criteria/abstract_column_criteria.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 #include "matador/query/criteria/criteria_utils.hpp"
 
 #include "matador/sql/column.hpp"
@@ -16,17 +16,19 @@ enum class binary_operator {
     LESS_THAN_OR_EQUAL,
 };
 
-class binary_criteria final : public abstract_column_criteria {
+class binary_criteria final : public abstract_criteria {
 public:
     binary_criteria() = delete;
     binary_criteria(sql::column column, binary_operator operand, criteria_value value);
 
     void accept( criteria_visitor& visitor ) const override;
 
+    [[nodiscard]] const sql::column& column() const;
     [[nodiscard]] binary_operator operand() const;
     [[nodiscard]] const criteria_value& value() const;
 
 private:
+    sql::column column_;
     binary_operator operator_{};
     criteria_value value_;
 };

include/matador/query/criteria/collection_criteria.hpp

@@ -1,7 +1,7 @@
 #ifndef CRITERIA_COLLECTION_CRITERIA_NODE_HPP
 #define CRITERIA_COLLECTION_CRITERIA_NODE_HPP
 
-#include "matador/query/criteria/abstract_column_criteria.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 #include "matador/query/criteria/criteria_utils.hpp"
 
 #include "matador/sql/column.hpp"
@@ -23,7 +23,7 @@ enum class collection_operator {
  * WHERE age IN (29,34,56)
  * @endcode
  */
-class collection_criteria final : public abstract_column_criteria {
+class collection_criteria final : public abstract_criteria {
 public:
     collection_criteria() = delete;
     /**
@@ -41,25 +41,29 @@ public:
 
     void accept(criteria_visitor& visitor) const override;
 
+    [[nodiscard]] const sql::column& column() const;
     [[nodiscard]] collection_operator operand() const;
     [[nodiscard]] const std::vector<criteria_value>& values() const;
 
 private:
+    sql::column column_;
     collection_operator operand_;
     std::vector<criteria_value> values_;
 };
 
-class collection_query_criteria final : public abstract_column_criteria {
+class collection_query_criteria final : public abstract_criteria {
 public:
     collection_query_criteria() = delete;
     collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx);
 
     void accept(criteria_visitor& visitor) const override;
 
+    [[nodiscard]] const sql::column& column() const;
     [[nodiscard]] collection_operator operand() const;
     [[nodiscard]] const sql::query_context& context() const;
 
 private:
+    sql::column column_;
     collection_operator operand_;
     sql::query_context query_context_;
 };

include/matador/query/criteria/criteria_operators.hpp

@@ -19,6 +19,8 @@ criteria_ptr operator==(const sql::column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
 }
 
+criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
+
 template<class Type>
 criteria_ptr operator!=(const sql::column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
@@ -44,13 +46,6 @@ criteria_ptr operator<=(const sql::column &col, Type val) {
     return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
 }
 
-criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator!=(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator>(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator>=(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator<(const sql::column &col_left, const sql::column &col_right);
-criteria_ptr operator<=(const sql::column &col_left, const sql::column &col_right);
-
 criteria_ptr operator==(const sql::column &col, utils::placeholder p);
 criteria_ptr operator!=(const sql::column &col, utils::placeholder p);
 criteria_ptr operator>(const sql::column &col, utils::placeholder p);

include/matador/query/criteria/like_criteria.hpp

@@ -1,21 +1,23 @@
 #ifndef CRITERIA_LIKE_CRITERIA_NODE_HPP
 #define CRITERIA_LIKE_CRITERIA_NODE_HPP
 
-#include "matador/query/criteria/abstract_column_criteria.hpp"
+#include "matador/query/criteria/abstract_criteria.hpp"
 
 #include "matador/sql/column.hpp"
 
 namespace matador::query {
-class like_criteria final : public abstract_column_criteria {
+class like_criteria final : public abstract_criteria {
 public:
   like_criteria() = delete;
   like_criteria(sql::column column, std::string pattern);
 
   void accept(criteria_visitor &visitor) const override;
 
+  [[nodiscard]] const sql::column& column() const;
   [[nodiscard]] const std::string& pattern() const;
 
 private:
+  sql::column column_;
   std::string pattern_;
 };
 }

include/matador/query/criteria/logical_criteria.hpp

@@ -21,9 +21,9 @@ public:
     [[nodiscard]] const criteria_ptr& right_clause() const;
 
 private:
-    criteria_ptr left_criteria_;
+    std::unique_ptr<abstract_criteria> left_criteria_;
     logical_operator operand_;
-    criteria_ptr right_criteria_;
+    std::unique_ptr<abstract_criteria> right_criteria_;
 };
 }
 #endif //CRITERIA_LOGICAL_CRITERIA_NODE_HPP

include/matador/sql/column.hpp

@@ -31,12 +31,11 @@ struct column {
 
   [[nodiscard]] const std::string& column_name() const;
   [[nodiscard]] std::string full_name() const;
-  [[nodiscard]] const std::string& alias_name() const;
   [[nodiscard]] bool is_function() const;
   [[nodiscard]] bool has_alias() const;
-  [[nodiscard]] std::shared_ptr<sql::table> table() const;
 
-  std::shared_ptr<sql::table> table_;
+  std::shared_ptr<table> table_;
+  using table_ref = std::reference_wrapper<const table>;
   std::string name;
   std::string alias;
   sql_function_t function_{sql_function_t::NONE};

source/orm/CMakeLists.txt

@@ -150,8 +150,6 @@ add_library(matador-orm STATIC
   ../../include/matador/query/criteria_evaluator.hpp
   query/criteria_evaluator.cpp
   ../../include/matador/query/criteria/criteria_utils.hpp
-  ../../include/matador/query/criteria/abstract_column_criteria.hpp
-  query/criteria/abstract_column_criteria.cpp
 )
 
 target_include_directories(matador-orm

source/orm/orm/error_code.cpp

@@ -14,8 +14,6 @@ std::string orm_category_impl::message(const int ev) const {
       return "No connection available";
     case error_code::UnknownType:
       return "Unknown type";
-    case error_code::NoPrimaryKey:
-      return "No primary key";
     case error_code::FailedToBuildQuery:
       return "Failed to build query";
     case error_code::FailedToFindObject:

source/orm/orm/schema.cpp

@@ -1,70 +1,6 @@
 #include "matador/orm/schema.hpp"
 
-#include "matador/query/query.hpp"
-
-#include "matador/sql/connection_pool.hpp"
-
 namespace matador::orm {
 schema::schema( const std::string& name )
 : repo_(name){}
 }
-
-matador::utils::result<void, matador::utils::error> matador::orm::schema::create(sql::connection_pool &pool) const {
-    // Step 1: Build dependency graph
-    // std::unordered_map<std::string, std::vector<std::string> > dependency_graph;
-    // std::unordered_map<std::string, std::pair<int,object::repository::node_ptr>> in_degree;
-    //
-    // for (const auto &node: repo_) {
-    //     for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
-    //         dependency_graph[node->name()].push_back(it->second->node().name());
-    //
-    //         if (const auto dit = in_degree.find(it->second->node().name()); dit == in_degree.end()) {
-    //             in_degree[it->second->node().name()] = std::make_pair(1, it->second->node_ptr());
-    //         } else {
-    //             in_degree[it->second->node().name()].first++;
-    //         }
-    //     }
-    //
-    //     // Ensure the current node exists in the graph representation
-    //     if (in_degree.find(node->name()) == in_degree.end()) {
-    //         in_degree[node->name()] = std::make_pair(0, node);
-    //     }
-    // }
-    //
-    // for (const auto &it : dependency_graph) {
-    //     std::cout << "Dependency graph " << it.first << std::endl;
-    //     for (const auto &neighbor: it.second) {
-    //         std::cout << "  " << neighbor << std::endl;
-    //     }
-    //     std::cout << std::endl;
-    // }
-
-    std::vector<std::string> fk_sql_commands;
-    auto c = pool.acquire();
-    for (const auto &node: repo_) {
-        auto ctx = query::query::create()
-          .table(node->name(), node->info().definition().columns())
-          .compile(*c);
-
-        for ( const auto& [sql, command] : ctx.additional_commands ) {
-            fk_sql_commands.push_back( sql );
-        }
-        std::cout << ctx.sql << std::endl;
-        if (auto result = c->execute(ctx.sql); !result) {
-            return utils::failure(result.err());
-        }
-    }
-
-    // execute additional commands (e.g. ALTER TABLE ADD FK)
-    for (const auto &sql: fk_sql_commands) {
-        std::cout << sql << std::endl;
-        if (auto result = c->execute(sql); !result) {
-            return utils::failure(result.err());
-        }
-    }
-    return utils::ok<void>();
-}
-
-matador::utils::result<void, matador::utils::error> matador::orm::schema::drop() const {
-  return utils::ok<void>();
-}

source/orm/orm/session_query_builder.cpp

@@ -3,50 +3,6 @@
 #include <iostream>
 
 namespace matador::orm {
-criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name)
-: repo_(repo)
-, tables_by_name_(tables_by_name) {}
-
-void criteria_transformer::visit( const query::between_criteria& node ) {
-  update_criteria_column(node);
-}
-
-void criteria_transformer::visit( const query::binary_criteria& node ) {
-  update_criteria_column(node);
-}
-
-void criteria_transformer::visit( const query::binary_column_criteria& node ) {}
-
-void criteria_transformer::visit( const query::collection_criteria& node ) {
-  update_criteria_column(node);
-}
-
-void criteria_transformer::visit( const query::collection_query_criteria& node ) {
-  update_criteria_column(node);
-}
-
-void criteria_transformer::visit( const query::like_criteria& node ) {
-  update_criteria_column(node);
-}
-
-void criteria_transformer::visit( const query::logical_criteria& node ) {
-  node.left_clause()->accept(*this);
-  node.right_clause()->accept(*this);
-}
-
-void criteria_transformer::visit( const query::not_criteria& node ) {
-  node.clause()->accept(*this);
-}
-
-void criteria_transformer::update_criteria_column(const query::abstract_column_criteria& node) const {
-    const auto it = tables_by_name_.find(node.column().table()->name);
-    if (it == tables_by_name_.end()) {
-        return;
-    }
-
-    const_cast<sql::column&>(node.column()).table_ = it->second;
-}
-
 void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) {
   push(id);
 }

source/orm/query/criteria/abstract_column_criteria.cpp

@@ -1,10 +0,0 @@
-#include "matador/query/criteria/abstract_column_criteria.hpp"
-
-namespace matador::query {
-abstract_column_criteria::abstract_column_criteria(sql::column column)
-: column_(std::move(column)) {}
-
-const sql::column& abstract_column_criteria::column() const {
-  return column_;
-}
-}

source/orm/query/criteria/between_criteria.cpp

@@ -4,13 +4,13 @@
 
 namespace matador::query{
 between_criteria::between_criteria(sql::column column, const int64_t min, const int64_t max)
-: abstract_column_criteria(std::move(column))
+: column_(std::move(column))
 , min_(utils::value{min})
 , max_(utils::value{max})
 {}
 
 between_criteria::between_criteria(sql::column column, utils::placeholder min, utils::placeholder max)
-: abstract_column_criteria(std::move(column))
+: column_(std::move(column))
 , min_(min)
 , max_(max)
 {}
@@ -19,6 +19,10 @@ void between_criteria::accept( criteria_visitor& visitor ) const {
   visitor.visit(*this);
 }
 
+const sql::column & between_criteria::column() const {
+  return column_;
+}
+
 const criteria_value &between_criteria::minimum() const {
   return min_;
 }

source/orm/query/criteria/binary_criteria.cpp

@@ -4,7 +4,7 @@
 
 namespace matador::query {
 binary_criteria::binary_criteria(sql::column column, const binary_operator operand, criteria_value value)
-: abstract_column_criteria(std::move(column))
+: column_(std::move(column))
 , operator_(operand)
 , value_(std::move(value))
 {}
@@ -13,6 +13,10 @@ void binary_criteria::accept( criteria_visitor& visitor ) const {
   visitor.visit(*this);
 }
 
+const sql::column & binary_criteria::column() const {
+  return column_;
+}
+
 binary_operator binary_criteria::operand() const {
   return operator_;
 }

source/orm/query/criteria/collection_criteria.cpp

@@ -4,13 +4,13 @@
 
 namespace matador::query {
 collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, std::vector<criteria_value> values )
-: abstract_column_criteria(std::move(col))
+: column_(std::move(col))
 , operand_(operand_)
 , values_(std::move(values))
 {}
 
 collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
-: abstract_column_criteria(std::move(col))
+: column_(std::move(col))
 , operand_(operand_)
 , values_(values)
 {}
@@ -19,6 +19,10 @@ void collection_criteria::accept(criteria_visitor& visitor) const {
   visitor.visit(*this);
 }
 
+const sql::column & collection_criteria::column() const {
+  return column_;
+}
+
 collection_operator collection_criteria::operand() const {
   return operand_;
 }
@@ -28,7 +32,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
 }
 
 collection_query_criteria::collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx)
-: abstract_column_criteria(std::move(col))
+: column_(std::move(col))
 , operand_(operand_)
 , query_context_(std::move(ctx)){
 }
@@ -37,6 +41,10 @@ void collection_query_criteria::accept(criteria_visitor &visitor) const {
   visitor.visit(*this);
 }
 
+const sql::column & collection_query_criteria::column() const {
+  return column_;
+}
+
 collection_operator collection_query_criteria::operand() const {
   return operand_;
 }

source/orm/query/criteria/criteria_operators.cpp

@@ -6,6 +6,10 @@
 #include "matador/query/criteria/not_criteria.hpp"
 
 namespace matador::query {
+criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
+  return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
+}
+
 criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
 }
@@ -20,6 +24,7 @@ criteria_ptr operator>(const sql::column &col, utils::placeholder p) {
 
 criteria_ptr operator>=(const sql::column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, p);
+
 }
 
 criteria_ptr operator<(const sql::column &col, utils::placeholder p) {
@@ -30,30 +35,6 @@ criteria_ptr operator<=(const sql::column &col, utils::placeholder p) {
   return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, p);
 }
 
-criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
-}
-
-criteria_ptr operator!=( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::NOT_EQUALS, col_right);
-}
-
-criteria_ptr operator>( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN, col_right);
-}
-
-criteria_ptr operator>=( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right);
-}
-
-criteria_ptr operator<( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN, col_right);
-}
-
-criteria_ptr operator<=( const sql::column& col_left, const sql::column& col_right ) {
-    return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN_OR_EQUAL, col_right);
-}
-
 criteria_ptr operator&&(criteria_ptr left, criteria_ptr right) {
   return std::make_unique<logical_criteria>(std::move(left), logical_operator::AND, std::move(right));
 }

source/orm/query/criteria/like_criteria.cpp

@@ -4,13 +4,17 @@
 
 namespace matador::query {
 like_criteria::like_criteria(sql::column column, std::string pattern)
-: abstract_column_criteria(std::move(column))
+: column_(std::move(column))
 , pattern_(std::move(pattern)){}
 
 void like_criteria::accept(criteria_visitor &visitor) const {
   visitor.visit(*this);
 }
 
+const sql::column & like_criteria::column() const {
+  return column_;
+}
+
 const std::string & like_criteria::pattern() const {
   return pattern_;
 }

source/orm/sql/column.cpp

@@ -36,27 +36,29 @@ column::column(const sql_function_t func, std::string name)
 , name(std::move(name))
 , function_(func) {}
 
-column::column(const sql::table& tab, std::string name, std::string as)
+column::column(const table& tab, std::string name, std::string as)
-: table_(std::make_shared<sql::table>(tab))
+: table_(std::make_shared<table>(tab))
 , name(std::move(name))
 , alias(std::move(as)) {
     table_->columns.push_back(*this);
 }
 
-column::column(const std::shared_ptr<sql::table>& t, std::string name, std::string as)
+column::column(const std::shared_ptr<table>& t, std::string name, std::string as)
 : table_(t)
 , name(std::move(name))
 , alias(std::move(as)) {
 }
 
-bool column::equals(const column &x) const {
+bool column::equals(const column &x) const
+{
   return *table_ == *x.table_ &&
          name == x.name &&
          alias == x.alias &&
          function_ == x.function_;
 }
 
-column &column::as(std::string a) {
+column &column::as(std::string a)
+{
   alias = std::move(a);
   return *this;
 }
@@ -72,11 +74,8 @@ std::string column::full_name() const {
   return name;
 }
 
-const std::string& column::alias_name() const {
+bool column::is_function() const
-  return alias;
+{
-}
-
-bool column::is_function() const {
   return function_ != sql_function_t::NONE;
 }
 
@@ -84,7 +83,4 @@ bool column::has_alias() const {
     return !alias.empty();
 }
 
-std::shared_ptr<table> column::table() const {
-  return table_;
-}
 }

test/orm/orm/SessionQueryBuilderTest.cpp

@@ -26,7 +26,6 @@
 using namespace matador::object;
 using namespace matador::orm;
 using namespace matador::query;
-using namespace matador::utils;
 using namespace matador::sql;
 using namespace matador::test;
 
@@ -41,7 +40,7 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
 
   session_query_builder eqb(scm, db);
 
-  auto data = eqb.build<flight>("flights.id"_col == _);
+  auto data = eqb.build<flight>(17U);
 
   REQUIRE(data.is_ok());
   REQUIRE(data->root_table->name == "flights");
@@ -87,7 +86,7 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
 
   session_query_builder eqb(scm, db);
 
-  auto data = eqb.build<book>("books.id"_col == _);
+  auto data = eqb.build<book>(17);
 
   REQUIRE(data.is_ok());
   REQUIRE(data->root_table->name == "books");
@@ -115,9 +114,9 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
   query_context qc;
   size_t index{0};
   criteria_evaluator evaluator(db.dialect(), qc);
-  for (const auto & [join_table, clause] : data->joins) {
+  for (const auto &jd : data->joins) {
-    REQUIRE(join_table->name == expected_join_data[index].first);
+    REQUIRE(jd.join_table->name == expected_join_data[index].first);
-    REQUIRE(evaluator.evaluate(*clause) == expected_join_data[index].second);
+    REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
     ++index;
   }
 
@@ -151,7 +150,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
 
   session_query_builder eqb(scm, db);
 
-  auto data = eqb.build<order>("orders.order_id"_col == _);
+  auto data = eqb.build<order>(17);
 
   REQUIRE(data.is_ok());
   REQUIRE(data->root_table->name == "orders");
@@ -207,7 +206,7 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
 
   session_query_builder eqb(scm, db);
 
-  auto data = eqb.build<ingredient>("ingredients.id"_col == _);
+  auto data = eqb.build<ingredient>(17);
 
   REQUIRE(data.is_ok());
   REQUIRE(data->root_table->name == "ingredients");
@@ -253,7 +252,7 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
 
   session_query_builder eqb(scm, db);
 
-  auto data = eqb.build<course>("courses.id"_col == _);
+  auto data = eqb.build<course>(17);
 
   REQUIRE(data.is_ok());
   REQUIRE(data->root_table->name == "courses");

test/orm/sql/StatementCacheTest.cpp

@@ -222,76 +222,76 @@ TEST_CASE("Test statement reuse avoids reprepare", "[statement][cache][prepare]"
   auto stmt2 = result.value();
 }
 
-// TEST_CASE("Multithreaded stress test", "[statement][cache][stress]") {
+TEST_CASE("Multithreaded stress test", "[statement][cache][stress]") {
-//   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
+  backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
-//
+
-//   constexpr int thread_count = 16;
+  constexpr int thread_count = 16;
-//   constexpr int iterations = 1000;
+  constexpr int iterations = 1000;
-//   constexpr int sql_pool_size = 10;
+  constexpr int sql_pool_size = 10;
-//
+
-//   std::vector<std::string> sqls;
+  std::vector<std::string> sqls;
-//   for (int i = 0; i < sql_pool_size; ++i) {
+  for (int i = 0; i < sql_pool_size; ++i) {
-//     sqls.push_back("SELECT " + std::to_string(i));
+    sqls.push_back("SELECT " + std::to_string(i));
-//   }
+  }
-//
+
-//   connection_pool pool("noop://noop.db", 4);
+  connection_pool pool("noop://noop.db", 4);
-//   message_bus bus;
+  message_bus bus;
-//   statement_cache cache(bus, pool, 5);
+  statement_cache cache(bus, pool, 5);
-//   RecordingObserver observer(bus);
+  RecordingObserver observer(bus);
-//   MetricsObserver metrics(bus);
+  MetricsObserver metrics(bus);
-//
+
-//   auto start_time = std::chrono::steady_clock::now();
+  auto start_time = std::chrono::steady_clock::now();
-//
+
-//   std::atomic_int lock_failed_count{0};
+  std::atomic_int lock_failed_count{0};
-//   std::atomic_int exec_failed_count{0};
+  std::atomic_int exec_failed_count{0};
-//
+
-//   auto worker = [&](const int tid) {
+  auto worker = [&](const int tid) {
-//     std::mt19937 rng(tid);
+    std::mt19937 rng(tid);
-//     std::uniform_int_distribution dist(0, sql_pool_size - 1);
+    std::uniform_int_distribution dist(0, sql_pool_size - 1);
-//
+
-//     for (int i = 0; i < iterations; ++i) {
+    for (int i = 0; i < iterations; ++i) {
-//       const auto& sql = sqls[dist(rng)];
+      const auto& sql = sqls[dist(rng)];
-//       if (const auto result = cache.acquire({sql}); !result) {
+      if (const auto result = cache.acquire({sql}); !result) {
-//         FAIL("Failed to acquire statement");
+        FAIL("Failed to acquire statement");
-//       } else {
+      } else {
-//         if (const auto exec_result = result->execute(); !exec_result) {
+        if (const auto exec_result = result->execute(); !exec_result) {
-//           if (exec_result.err().ec() == error_code::STATEMENT_LOCKED) {
+          if (exec_result.err().ec() == error_code::STATEMENT_LOCKED) {
-//             ++lock_failed_count;
+            ++lock_failed_count;
-//           } else {
+          } else {
-//             ++exec_failed_count;
+            ++exec_failed_count;
-//           }
+          }
-//         }
+        }
-//       }
+      }
-//     }
+    }
-//   };
+  };
-//
+
-//   std::vector<std::thread> threads;
+  std::vector<std::thread> threads;
-//   for (int i = 0; i < thread_count; ++i) {
+  for (int i = 0; i < thread_count; ++i) {
-//     threads.emplace_back(worker, i);
+    threads.emplace_back(worker, i);
-//   }
+  }
-//
+
-//   for (auto& t : threads) {
+  for (auto& t : threads) {
-//     t.join();
+    t.join();
-//   }
+  }
-//
+
-//   auto end_time = std::chrono::steady_clock::now();
+  auto end_time = std::chrono::steady_clock::now();
-//   auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
+  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
-//
+
-//   std::cout << "[Performance] Executed " << (thread_count * iterations) << " statements in " << duration.count() << " ms (lock failed: " << lock_failed_count << ", execute failed: " << exec_failed_count << ")\n";
+  std::cout << "[Performance] Executed " << (thread_count * iterations) << " statements in " << duration.count() << " ms (lock failed: " << lock_failed_count << ", execute failed: " << exec_failed_count << ")\n";
-//
+
-//   std::cout << "Average lock wait time: " << metrics.get_average_lock_wait_time().count() << "ms\n";
+  std::cout << "Average lock wait time: " << metrics.get_average_lock_wait_time().count() << "ms\n";
-//   std::cout << "Total lock wait time: " << metrics.get_total_lock_wait_time().count() << "ms\n";
+  std::cout << "Total lock wait time: " << metrics.get_total_lock_wait_time().count() << "ms\n";
-//   std::cout << "Average execution time: " << metrics.get_average_execution_time().count() << "ms\n";
+  std::cout << "Average execution time: " << metrics.get_average_execution_time().count() << "ms\n";
-//   std::cout << "Total execution time: " << metrics.get_total_execution_time().count() << "ms\n";
+  std::cout << "Total execution time: " << metrics.get_total_execution_time().count() << "ms\n";
-//   std::cout << "Number of lock failures: " << metrics.get_lock_failure_count() << "\n";
+  std::cout << "Number of lock failures: " << metrics.get_lock_failure_count() << "\n";
-//
+
-//   // Some events should be generated
+  // Some events should be generated
-//   int accessed = 0;
+  int accessed = 0;
-//   while (auto e = observer.poll()) {
+  while (auto e = observer.poll()) {
-//     if (e->is<statement_accessed_event>()) accessed++;
+    if (e->is<statement_accessed_event>()) accessed++;
-//   }
+  }
-//   REQUIRE(accessed > 0);
+  REQUIRE(accessed > 0);
-// }
+}
 
 TEST_CASE("Race condition simulation with mixed access", "[statement_cache][race]") {
   backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());