removed class query and moved their static methods to simple functions

source/orm/orm/session.cpp

@@ -21,7 +21,7 @@ session::session(session_context&& ctx, const query::schema &scm)
 }
 
 utils::result<void, utils::error> session::drop_table(const std::string &table_name) const {
-  auto result = query::query::drop()
+  auto result = query::drop()
       .table(table_name)
       .execute(*this);
   if (result.is_error()) {

source/orm/query/query.cpp

@@ -1,70 +1,72 @@
 #include "matador/query/query.hpp"
 
 namespace matador::query {
-
-table_column count(const std::string &column) {
+table_column count(const std::string& column) {
   return {sql::sql_function_t::Count, column};
 }
 
 table_column count_all() {
   return count("*");
 }
+
 table_column sum(const std::string& column) {
   return {sql::sql_function_t::Sum, column};
 }
+
 table_column avg(const std::string& column) {
   return {sql::sql_function_t::Avg, column};
 }
+
 table_column maximum(const std::string& column) {
   return {sql::sql_function_t::Max, column};
 }
+
 table_column minimum(const std::string& column) {
   return {sql::sql_function_t::Min, column};
 }
 
-query_create_intermediate query::create()
-{
+query_create_intermediate create() {
   return {};
 }
 
-query_drop_intermediate query::drop() {
+query_drop_intermediate drop() {
   return {};
 }
 
-query_select_intermediate query::select() {
+query_select_intermediate select() {
   return query_select_intermediate{{}};
 }
 
-query_select_intermediate query::select( const std::initializer_list<table_column> columns) {
+query_select_intermediate select(const std::initializer_list<table_column> columns) {
   return select(std::vector<table_column>{columns});
 }
 
-query_select_intermediate query::select(const std::vector<table_column>& columns) {
+query_select_intermediate select(const std::vector<table_column>& columns) {
   return query_select_intermediate{columns};
 }
 
-query_select_intermediate query::select(const std::vector<std::string> &column_names) {
+query_select_intermediate select(const std::vector<std::string>& column_names) {
   std::vector<table_column> columns;
   columns.reserve(column_names.size());
-  for (const auto &col_name : column_names) {
+  for (const auto& col_name : column_names) {
     columns.emplace_back(col_name);
   }
   return select(columns);
 }
 
-query_insert_intermediate query::insert() {
+query_insert_intermediate insert() {
   return {};
 }
 
-query_update_intermediate query::update(const table &table) {
+query_update_intermediate update(const table& table) {
   return query_update_intermediate{table};
 }
 
-query_delete_intermediate query::remove() {
+query_delete_intermediate remove() {
   return {};
 }
 
-query_alter_intermediate query::alter() {
-    return {};
+query_alter_intermediate alter() {
+  return {};
+}
 }
-}

source/orm/query/schema.cpp

@@ -21,7 +21,7 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
 
   // create plain tables without constraints
   for (const auto &node: repo_) {
-    auto ctx = query::query::create()
+    auto ctx = query::create()
         .table(node.name())
         .columns(node.info().attributes())
         .compile(conn);
@@ -67,7 +67,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
       if (cons.is_primary_key_constraint()) {
         continue;
       }
-      auto ctx = query::query::alter()
+      auto ctx = alter()
           .table(node.name())
           .drop_constraint(cons)
           .compile(conn);
@@ -84,7 +84,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
       if (!cons.is_primary_key_constraint()) {
         continue;
       }
-      auto ctx = query::query::alter()
+      auto ctx = alter()
           .table(node.name())
           .drop_constraint(cons)
           .compile(conn);
@@ -97,7 +97,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
 
   // drop table
   for (const auto &node: repo_) {
-    auto ctx = query::query::drop()
+    auto ctx = query::drop()
         .table(node.name())
         .compile(conn);
 
@@ -110,7 +110,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
 }
 
 utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) {
-  auto result = query::query::drop()
+  auto result = query::drop()
       .table(table_name)
       .execute(conn);
   if (result.is_error()) {
@@ -137,13 +137,13 @@ sql::query_context schema::build_add_constraint_context(const object::repository
                                                         const object::restriction &cons,
                                                         const sql::connection &conn) {
   if (cons.is_foreign_key_constraint()) {
-    return query::query::alter()
+    return alter()
         .table(node.name())
         .add_constraint(cons)
         .compile(conn);
   }
   if (cons.is_primary_key_constraint()) {
-    return query::query::alter()
+    return alter()
         .table(node.name())
         .add_constraint(cons)
         .compile(conn);
@@ -154,7 +154,7 @@ sql::query_context schema::build_add_constraint_context(const object::repository
 sql::query_context schema::build_drop_constraint_context(const object::repository_node &node,
                                                          const object::restriction &cons,
                                                          const sql::connection &conn) {
-  return query::query::alter()
+  return alter()
       .table(node.name())
       .drop_constraint(cons)
       .compile(conn);