removed class query and moved their static methods to simple functions

include/matador/orm/session.hpp

@@ -123,7 +123,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(object::ob
           // For now, we derive from the schema type used for the root insert: simplistic but works if table name == entity name.
           const std::string seq_name = it->second.name() + "_seq";
 
-          auto id_res = query::query::select().nextval(seq_name).fetch_value<std::uint64_t>(*this);
+          auto id_res = query::select().nextval(seq_name).fetch_value<std::uint64_t>(*this);
           if (!id_res.is_ok() || !id_res.value().has_value()) {
             return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to obtain next sequence value."));
           }
@@ -227,7 +227,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::update(const obje
   using namespace matador::query;
 
   const auto col = table_column(it->second.node().info().primary_key_attribute()->name());
-  auto res = matador::query::query::update(it->second.name())
+  auto res = query::update(it->second.name())
     .set<Type>()
     .where(col == _)
     .prepare(*this);
@@ -253,7 +253,7 @@ utils::result<void, utils::error> session::remove(const object::object_ptr<Type>
   using namespace matador::query;
 
   const auto col = table_column(it->second.node().info().primary_key_attribute()->name());
-  auto res = matador::query::query::remove()
+  auto res = query::remove()
     .from(it->second.name())
     .where(col == _)
     .prepare(*this);

include/matador/query/insert_query_builder.hpp

@@ -178,7 +178,7 @@ public:
       // Build INSERT into relation table with the 2 FK columns
       insert_step rel_step{};
       rel_step.query = executable_query{
-        query::query::insert()
+        insert()
           .into(relation_table, {table_column{&relation_table, join_column}, table_column{&relation_table, inverse_join_column}})
           .values({utils::database_type{current_entity_pk_}, utils::database_type{fk.value}})
       };
@@ -244,7 +244,7 @@ private:
 
     if (info.has_primary_key() && step.pk_generator == utils::generator_type::Identity) {
       const table_column pk_col(&it->second.table(), step.pk_name);
-      step.query = fetchable_query{query::query::insert().into(it->second.table()).values(*ptr).returning(pk_col)};
+      step.query = fetchable_query{insert().into(it->second.table()).values(*ptr).returning(pk_col)};
       step.apply_returning = [ptr, pk_name = step.pk_name](const sql::record &rec) {
         if (auto v = rec.at<std::uint64_t>(pk_name); v.has_value()) {
           pk_setter setter{pk_name, *v};
@@ -252,7 +252,7 @@ private:
         }
       };
     } else {
-      step.query = executable_query{query::query::insert().into(it->second.table()).values(*ptr)};
+      step.query = executable_query{insert().into(it->second.table()).values(*ptr)};
     }
     steps_.push_back(std::move(step));
   }

include/matador/query/query.hpp

@@ -17,25 +17,20 @@ table_column avg(const std::string &column);
 table_column maximum(const std::string &column);
 table_column minimum(const std::string &column);
 
-class query
-{
-public:
-  [[nodiscard]] static query_create_intermediate create();
-  [[nodiscard]] static query_drop_intermediate drop();
-  [[nodiscard]] static query_select_intermediate select();
-  [[nodiscard]] static query_select_intermediate select(std::initializer_list<table_column> columns);
-  [[nodiscard]] static query_select_intermediate select(const std::vector<table_column>& columns);
-  [[nodiscard]] static query_select_intermediate select(const std::vector<std::string> &column_names);
-  template<class Type>
-  [[nodiscard]] static query_select_intermediate select(const schema &scm) {
-    return select(generator::columns<Type>(scm));
-  }
-  [[nodiscard]] static query_insert_intermediate insert();
-  [[nodiscard]] static query_update_intermediate update(const table &table);
-  [[nodiscard]] static query_delete_intermediate remove();
-
-  [[nodiscard]] static query_alter_intermediate alter();
-};
+[[nodiscard]] query_create_intermediate create();
+[[nodiscard]] query_drop_intermediate drop();
+[[nodiscard]] query_select_intermediate select();
+[[nodiscard]] query_select_intermediate select(std::initializer_list<table_column> columns);
+[[nodiscard]] query_select_intermediate select(const std::vector<table_column>& columns);
+[[nodiscard]] query_select_intermediate select(const std::vector<std::string> &column_names);
+template<class Type>
+[[nodiscard]] query_select_intermediate select(const schema &scm) {
+  return select(generator::columns<Type>(scm));
+}
+[[nodiscard]] query_insert_intermediate insert();
+[[nodiscard]] query_update_intermediate update(const table &table);
+[[nodiscard]] query_delete_intermediate remove();
 
+[[nodiscard]] query_alter_intermediate alter();
 }
 #endif //QUERY_QUERY_HPP

include/matador/query/select_query_builder.hpp

@@ -74,7 +74,7 @@ public:
         entity_query_data_.where_clause = std::move(clause);
       }
 
-      fetchable_query q = query::query::select(entity_query_data_.columns)
+      fetchable_query q = select(entity_query_data_.columns)
         .from(*entity_query_data_.root_table)
         .join_left(entity_query_data_.joins)
         .where(std::move(entity_query_data_.where_clause))