diff --git a/backends/tests/QueryRecordTest.cpp b/backends/tests/QueryRecordTest.cpp
index 1b3bad0..f38ba35 100644
--- a/backends/tests/QueryRecordTest.cpp
+++ b/backends/tests/QueryRecordTest.cpp
@@ -39,7 +39,7 @@ private:
 
 using namespace matador::sql;
 
-TEST_CASE_METHOD(QueryRecordFixture, " Create and drop table statement", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Create and drop table statement", "[session][record]")
 {
   REQUIRE(!db.exists("person"));
   db.query(schema).create()
@@ -59,7 +59,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Create and drop table statement", "[sessi
   REQUIRE(!db.exists("person"));
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Create and drop table statement with foreign key", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Create and drop table statement with foreign key", "[session][record]")
 {
   db.query(schema).create()
   .table("airplane", {
@@ -94,7 +94,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Create and drop table statement with fore
   REQUIRE(!db.exists("airplane"));
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute insert record statement", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute insert record statement", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -133,7 +133,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute insert record statement", "[sessi
   .execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute insert record statement with foreign key", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute insert record statement with foreign key", "[session][record]")
 {
   db.query(schema).create()
   .table("airplane", {
@@ -173,7 +173,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute insert record statement with fore
   REQUIRE(!db.exists("airplane"));
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute update record statement", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute update record statement", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -219,7 +219,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute update record statement", "[sessi
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute select statement", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -262,7 +262,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement", "[session][rec
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement with order by", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute select statement with order by", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -296,7 +296,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement with order by",
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement with group by and order by", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute select statement with group by and order by", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -335,7 +335,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute select statement with group by an
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Execute delete statement", "[session][record]")
+TEST_CASE_METHOD(QueryRecordFixture, "Execute delete statement", "[session][record]")
 {
   db.query(schema).create()
   .table("person", {
@@ -365,7 +365,7 @@ TEST_CASE_METHOD(QueryRecordFixture, " Execute delete statement", "[session][rec
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryRecordFixture, " Test quoted identifier", "[session][record]") {
+TEST_CASE_METHOD(QueryRecordFixture, "Test quoted identifier", "[session][record]") {
   db.query(schema).create()
   .table("quotes", {
     make_column<std::string>("from", 255),
diff --git a/backends/tests/QueryTest.cpp b/backends/tests/QueryTest.cpp
index 8b95f8d..46c7e39 100644
--- a/backends/tests/QueryTest.cpp
+++ b/backends/tests/QueryTest.cpp
@@ -44,7 +44,7 @@ private:
   }
 };
 
-TEST_CASE_METHOD(QueryFixture, " Create table with foreign key relation", "[session]")
+TEST_CASE_METHOD(QueryFixture, "Create table with foreign key relation", "[session]")
 {
   db.query(schema).create()
   .table<airplane>("airplane")
@@ -65,7 +65,7 @@ TEST_CASE_METHOD(QueryFixture, " Create table with foreign key relation", "[sess
   REQUIRE(!db.exists("airplane"));
 }
 
-TEST_CASE_METHOD(QueryFixture, " Execute select statement with where clause", "[session]")
+TEST_CASE_METHOD(QueryFixture, "Execute select statement with where clause", "[session]")
 {
   db.query(schema).create()
   .table<person>("person")
@@ -115,7 +115,7 @@ TEST_CASE_METHOD(QueryFixture, " Execute select statement with where clause", "[
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]")
+TEST_CASE_METHOD(QueryFixture, "Execute insert statement", "[session]")
 {
   db.query(schema).create()
   .table("person", {
@@ -154,7 +154,7 @@ TEST_CASE_METHOD(QueryFixture, " Execute insert statement", "[session]")
   db.query(schema).drop().table("person").execute();
 }
 
-TEST_CASE_METHOD(QueryFixture, " Select statement with foreign key", "[session]")
+TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[session]")
 {
   db.query(schema).create()
   .table<airplane>("airplane")
@@ -193,7 +193,7 @@ TEST_CASE_METHOD(QueryFixture, " Select statement with foreign key", "[session]"
   db.query(schema).drop().table("airplane").execute();
 }
 
-TEST_CASE_METHOD(QueryFixture, " Select statement with foreign key and join_left", "[session][join_left]")
+TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left", "[session][join_left]")
 {
   db.query(schema).create()
   .table<airplane>("airplane")
diff --git a/backends/tests/StatementCacheTest.cpp b/backends/tests/StatementCacheTest.cpp
index 479e6bb..786b68a 100644
--- a/backends/tests/StatementCacheTest.cpp
+++ b/backends/tests/StatementCacheTest.cpp
@@ -22,7 +22,7 @@ protected:
   matador::sql::session ses;
 };
 
-TEST_CASE_METHOD(StatementCacheFixture, " Acquire prepared statement", "[statement cache]") {
+TEST_CASE_METHOD(StatementCacheFixture, "Acquire prepared statement", "[statement cache]") {
   sql::statement_cache cache;
 
   auto conn = pool.acquire();
diff --git a/backends/tests/StatementTest.cpp b/backends/tests/StatementTest.cpp
index 11580e4..4f85662 100644
--- a/backends/tests/StatementTest.cpp
+++ b/backends/tests/StatementTest.cpp
@@ -46,7 +46,7 @@ private:
 
 };
 
-TEST_CASE_METHOD(StatementTestFixture, " Create prepared statement", "[statement]")
+TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]")
 {
   table ap{"airplane"};
   SECTION("Insert with prepared statement and placeholder") {
diff --git a/include/matador/sql/query.hpp b/include/matador/sql/query.hpp
index e66e6d4..cd1da46 100644
--- a/include/matador/sql/query.hpp
+++ b/include/matador/sql/query.hpp
@@ -21,6 +21,7 @@ public:
   template < class Type >
   query_select_intermediate select(std::initializer_list<column> columns);
   query_select_intermediate select(std::initializer_list<column> columns);
+  query_select_intermediate select(const std::vector<column>& columns);
   query_insert_intermediate insert();
   query_update_intermediate update(const sql::table &table);
   query_delete_intermediate remove();
@@ -33,7 +34,7 @@ private:
 template<class Type>
 query_select_intermediate query::select()
 {
-  return query_select_intermediate{connection_, schema_, column_name_generator::generate<Type>(*schema_)};
+  return select(column_name_generator::generate<Type>(*schema_));
 }
 
 template<class Type>
@@ -41,7 +42,7 @@ query_select_intermediate query::select(std::initializer_list<column> columns)
 {
   auto cols = column_name_generator::generate<Type>(*schema_);
   cols.insert(cols.end(), columns);
-  return query_select_intermediate{connection_, schema_, cols};
+  return select(cols);
 }
 
 }
diff --git a/include/matador/sql/query_data.hpp b/include/matador/sql/query_data.hpp
index ee9d8f2..20cadc8 100644
--- a/include/matador/sql/query_data.hpp
+++ b/include/matador/sql/query_data.hpp
@@ -1,7 +1,7 @@
 #ifndef QUERY_QUERY_DATA_HPP
 #define QUERY_QUERY_DATA_HPP
 
-#include "matador/sql/query_parts.hpp"
+#include "matador/sql/query_part.hpp"
 #include "matador/sql/table.hpp"
 
 #include <memory>
diff --git a/include/matador/sql/query_intermediates.hpp b/include/matador/sql/query_intermediates.hpp
index b927347..79ffefb 100644
--- a/include/matador/sql/query_intermediates.hpp
+++ b/include/matador/sql/query_intermediates.hpp
@@ -143,11 +143,13 @@ public:
   template<class Condition>
   query_where_intermediate where(const Condition &cond)
   {
-    data_.parts.push_back(std::make_unique<query_where_part>(cond));
-    return {connection_, schema_, data_};
+    return where_clause(std::make_unique<Condition>(std::move(cond)));
   }
   query_group_by_intermediate group_by(const column &col);
   query_order_by_intermediate order_by(const column &col);
+
+private:
+  query_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
 class query_join_intermediate : public query_intermediate
@@ -158,9 +160,11 @@ public:
   template<class Condition>
   query_on_intermediate on(const Condition &cond)
   {
-    data_.parts.push_back(std::make_unique<query_on_part>(cond));
-    return {connection_, schema_, data_};
+    return on_clause(std::make_unique<Condition>(std::move(cond)));
   }
+
+private:
+  query_on_intermediate on_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
 class query_from_intermediate : public query_select_finish
@@ -172,11 +176,13 @@ public:
   template<class Condition>
   query_where_intermediate where(const Condition &cond)
   {
-    data_.parts.push_back(std::make_unique<query_where_part>(cond));
-    return {connection_, schema_, data_};
+    return where_clause(std::make_unique<Condition>(std::move(cond)));
   }
   query_group_by_intermediate group_by(const column &col);
   query_order_by_intermediate order_by(const column &col);
+
+private:
+  query_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
 class query_start_intermediate : public basic_query_intermediate
@@ -211,19 +217,17 @@ public:
   using query_intermediate::query_intermediate;
 
   query_execute_finish values(std::initializer_list<any_type> values);
-  query_execute_finish values(const std::vector<any_type>& values);
+  query_execute_finish values(std::vector<any_type> &&values);
   template<class Type>
   query_execute_finish values()
   {
     Type obj;
-    data_.parts.push_back(std::make_unique<query_values_part>(as_placeholder(obj)));
-    return {connection_, schema_, data_};
+    return values(std::move(as_placeholder(obj)));
   }
   template<class Type>
   query_execute_finish values(const Type &obj)
   {
-    data_.parts.push_back(std::make_unique<query_values_part>(value_extractor::extract(obj)));
-    return {connection_, schema_, data_};
+    return values(std::move(value_extractor::extract(obj)));
   }
 };
 
@@ -258,11 +262,11 @@ public:
   explicit query_insert_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
   query_into_intermediate into(const sql::table &table, std::initializer_list<column> column_names);
+  query_into_intermediate into(const sql::table &table, std::vector<column> &&column_names);
   template<class Type>
   query_into_intermediate into(const sql::table &table)
   {
-    data_.parts.push_back(std::make_unique<query_into_part>(table, column_name_generator::generate<Type>(*schema_)));
-    return {connection_, schema_, data_};
+    return into(table, column_name_generator::generate<Type>(*schema_));
   }
 };
 
@@ -282,9 +286,11 @@ public:
   template<class Condition>
   query_execute_where_intermediate where(const Condition &cond)
   {
-    data_.parts.push_back(std::make_unique<query_where_part>(cond));
-    return {connection_, schema_, data_};
+    return where_clause(std::make_unique<Condition>(std::move(cond)));
   }
+
+private:
+  query_execute_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
 class query_update_intermediate : public query_start_intermediate
@@ -293,11 +299,11 @@ public:
   query_update_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, const sql::table& table);
 
   query_set_intermediate set(std::initializer_list<key_value_pair> columns);
+  query_set_intermediate set(std::vector<key_value_pair> &&columns);
   template<class Type>
   query_set_intermediate set(const Type &obj)
   {
-    data_.parts.push_back(std::make_unique<query_set_part>(key_value_generator::generate(obj)));
-    return {connection_, schema_, data_};
+    return set(key_value_generator::generate(obj));
   }
 };
 
@@ -309,9 +315,11 @@ public:
   template<class Condition>
   query_execute_where_intermediate where(const Condition &cond)
   {
-    data_.parts.push_back(std::make_unique<query_where_part>(cond));
-    return {connection_, schema_, data_};
+    return where_clause(std::make_unique<Condition>(std::move(cond)));
   }
+
+private:
+  query_execute_where_intermediate where_clause(std::unique_ptr<basic_condition> &&cond);
 };
 
 class query_delete_intermediate : public query_start_intermediate
diff --git a/include/matador/sql/query_part.hpp b/include/matador/sql/query_part.hpp
new file mode 100644
index 0000000..18147da
--- /dev/null
+++ b/include/matador/sql/query_part.hpp
@@ -0,0 +1,24 @@
+#ifndef QUERY_QUERY_PART_HPP
+#define QUERY_QUERY_PART_HPP
+
+#include "matador/sql/dialect.hpp"
+
+namespace matador::sql {
+
+class query_part_visitor;
+
+class query_part
+{
+protected:
+  explicit query_part(sql::dialect::token_t token);
+
+public:
+  virtual ~query_part() = default;
+  virtual void accept(query_part_visitor &visitor) = 0;
+
+protected:
+  sql::dialect::token_t token_;
+};
+
+}
+#endif //QUERY_QUERY_PART_HPP
diff --git a/include/matador/sql/query_parts.hpp b/include/matador/sql/query_parts.hpp
index 154b926..3f3b1b3 100644
--- a/include/matador/sql/query_parts.hpp
+++ b/include/matador/sql/query_parts.hpp
@@ -5,8 +5,8 @@
 #include "matador/sql/query_part_visitor.hpp"
 #include "matador/sql/column.hpp"
 #include "matador/sql/column_definition.hpp"
-#include "matador/sql/dialect.hpp"
 #include "matador/sql/key_value_pair.hpp"
+#include "matador/sql/query_part.hpp"
 #include "matador/sql/table.hpp"
 
 #include <memory>
@@ -15,19 +15,6 @@ namespace matador::sql {
 
 class basic_condition;
 
-class query_part
-{
-protected:
-  explicit query_part(sql::dialect::token_t token);
-
-public:
-  virtual ~query_part() = default;
-  virtual void accept(query_part_visitor &visitor) = 0;
-
-protected:
-  sql::dialect::token_t token_;
-};
-
 /**
  * Represents the SQL SELECT part
  */
@@ -81,8 +68,9 @@ public:
   explicit query_on_part(const Condition &cond)
     : query_part(dialect::token_t::ON)
     , condition_(new Condition(cond)) {}
+  explicit query_on_part(std::unique_ptr<basic_condition> &&cond);
 
-  const basic_condition& condition() const;
+  [[nodiscard]] const basic_condition& condition() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
@@ -98,6 +86,7 @@ public:
   explicit query_where_part(const Condition &cond)
   : query_part(dialect::token_t::WHERE)
   , condition_(new Condition(cond)) {}
+  explicit query_where_part(std::unique_ptr<basic_condition> &&cond);
 
   [[nodiscard]] const basic_condition& condition() const;
 
@@ -221,7 +210,7 @@ private:
 class query_values_part : public query_part
 {
 public:
-  query_values_part(std::vector<any_type> values);
+  query_values_part(std::vector<any_type> &&values);
 
   [[nodiscard]] const std::vector<any_type>& values() const;
 
diff --git a/include/matador/sql/query_result.hpp b/include/matador/sql/query_result.hpp
index d2ba69f..4c10a8a 100644
--- a/include/matador/sql/query_result.hpp
+++ b/include/matador/sql/query_result.hpp
@@ -1,10 +1,9 @@
 #ifndef QUERY_QUERY_RESULT_HPP
 #define QUERY_QUERY_RESULT_HPP
 
-#include <functional>
-
 #include "matador/sql/query_result_impl.hpp"
 
+#include <functional>
 #include <memory>
 
 namespace matador::sql {
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fce3a70..ea33cb7 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -33,6 +33,7 @@ set(SQL_SOURCES
   sql/query_parts.cpp
   sql/query_compiler.cpp
   sql/noop_connection.cpp
+  sql/query_part.cpp
 )
 
 set(SQL_HEADER
@@ -81,6 +82,7 @@ set(SQL_HEADER
   ../include/matador/sql/query_data.hpp
   ../include/matador/sql/table.hpp
   ../include/matador/sql/noop_connection.hpp
+  ../include/matador/sql/query_part.hpp
 )
 
 set(QUERY_SOURCES
diff --git a/src/sql/query.cpp b/src/sql/query.cpp
index 5170374..cb50d5f 100644
--- a/src/sql/query.cpp
+++ b/src/sql/query.cpp
@@ -19,6 +19,11 @@ query_drop_intermediate query::drop()
 }
 
 query_select_intermediate query::select(std::initializer_list<column> columns)
+{
+  return select(std::vector<column>{columns});
+}
+
+query_select_intermediate query::select(const std::vector<column>& columns)
 {
   return {connection_, schema_, columns};
 }
diff --git a/src/sql/query_compiler.cpp b/src/sql/query_compiler.cpp
index be6b5bc..bae397c 100644
--- a/src/sql/query_compiler.cpp
+++ b/src/sql/query_compiler.cpp
@@ -204,7 +204,7 @@ struct column_context
   std::vector<fk_context> foreign_contexts;
 };
 
-  std::string build_create_column(const column_definition &col, const dialect &d, column_context &context);
+std::string build_create_column(const column_definition &col, const dialect &d, column_context &context);
 
 void query_compiler::visit(query_create_table_part &create_table_part)
 {
diff --git a/src/sql/query_intermediates.cpp b/src/sql/query_intermediates.cpp
index 984642f..9166faf 100644
--- a/src/sql/query_intermediates.cpp
+++ b/src/sql/query_intermediates.cpp
@@ -77,6 +77,12 @@ query_order_direction_intermediate query_order_by_intermediate::desc()
   return {connection_, schema_, data_};
 }
 
+query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
+{
+  data_.parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
+  return {connection_, schema_, data_};
+}
+
 query_group_by_intermediate query_from_intermediate::group_by(const column &col)
 {
   data_.parts.push_back(std::make_unique<query_group_by_part>(col));
@@ -107,6 +113,12 @@ query_join_intermediate query_on_intermediate::join_left(const table &t)
   return {connection_, schema_, data_};
 }
 
+query_where_intermediate query_on_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
+{
+  data_.parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
+  return {connection_, schema_, data_};
+}
+
 query_group_by_intermediate query_on_intermediate::group_by(const column &col)
 {
   data_.parts.push_back(std::make_unique<query_group_by_part>(col));
@@ -119,6 +131,12 @@ query_order_by_intermediate query_on_intermediate::order_by(const column &col)
   return {connection_, schema_, data_};
 }
 
+query_on_intermediate query_join_intermediate::on_clause(std::unique_ptr<basic_condition> &&cond)
+{
+  data_.parts.push_back(std::make_unique<query_on_part>(std::move(cond)));
+  return {connection_, schema_, data_};
+}
+
 query_join_intermediate query_from_intermediate::join_left(const table &t)
 {
   data_.parts.push_back(std::make_unique<query_join_part>(t));
@@ -144,6 +162,11 @@ query_insert_intermediate::query_insert_intermediate(connection &db, const std::
 }
 
 query_into_intermediate query_insert_intermediate::into(const sql::table &table, std::initializer_list<column> column_names)
+{
+  return into(table, std::move(std::vector<column>{column_names}));
+}
+
+query_into_intermediate query_insert_intermediate::into(const table &table, std::vector<column> &&column_names)
 {
   data_.parts.push_back(std::make_unique<query_into_part>(table, column_names));
   return {connection_, schema_, data_};
@@ -172,9 +195,9 @@ query_execute_finish query_into_intermediate::values(std::initializer_list<any_t
   return this->values(std::vector<any_type>(values));
 }
 
-query_execute_finish query_into_intermediate::values(const std::vector<any_type> &values)
+query_execute_finish query_into_intermediate::values(std::vector<any_type> &&values)
 {
-  data_.parts.push_back(std::make_unique<query_values_part>(values));
+  data_.parts.push_back(std::make_unique<query_values_part>(std::move(values)));
   return {connection_, schema_, data_};
 }
 
@@ -212,6 +235,12 @@ query_execute_finish query_execute_where_intermediate::limit(int limit)
 //  return {connection_, builder_.limit(limit)};
 }
 
+query_execute_where_intermediate query_set_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
+{
+  data_.parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
+  return {connection_, schema_, data_};
+}
+
 query_update_intermediate::query_update_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, const sql::table& table)
 : query_start_intermediate(db, schema)
 {
@@ -220,7 +249,19 @@ query_update_intermediate::query_update_intermediate(connection &db, const std::
 
 query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
 {
-  data_.parts.push_back(std::make_unique<query_set_part>(columns));
+  return set(std::vector<key_value_pair>{columns});
+}
+
+query_set_intermediate query_update_intermediate::set(std::vector<key_value_pair> &&columns)
+{
+  data_.parts.push_back(std::make_unique<query_set_part>(std::move(columns)));
+  return {connection_, schema_, data_};
+
+}
+
+query_execute_where_intermediate query_delete_from_intermediate::where_clause(std::unique_ptr<basic_condition> &&cond)
+{
+  data_.parts.push_back(std::make_unique<query_where_part>(std::move(cond)));
   return {connection_, schema_, data_};
 }
 
diff --git a/src/sql/query_part.cpp b/src/sql/query_part.cpp
new file mode 100644
index 0000000..6782690
--- /dev/null
+++ b/src/sql/query_part.cpp
@@ -0,0 +1,9 @@
+#include "matador/sql/query_part.hpp"
+
+namespace matador::sql {
+
+query_part::query_part(sql::dialect::token_t token)
+: token_(token) {}
+
+
+}
\ No newline at end of file
diff --git a/src/sql/query_parts.cpp b/src/sql/query_parts.cpp
index dff05a8..a39f4a1 100644
--- a/src/sql/query_parts.cpp
+++ b/src/sql/query_parts.cpp
@@ -5,9 +5,6 @@
 
 namespace matador::sql {
 
-query_part::query_part(sql::dialect::token_t token)
-  : token_(token) {}
-
 query_select_part::query_select_part(std::vector<column> columns)
   : query_part(sql::dialect::token_t::SELECT)
   , columns_(std::move(columns)) {}
@@ -50,6 +47,10 @@ void query_join_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
+query_on_part::query_on_part(std::unique_ptr<basic_condition> &&cond)
+: query_part(dialect::token_t::ON)
+, condition_(std::move(cond)) {}
+
 const basic_condition &query_on_part::condition() const
 {
   return *condition_;
@@ -60,6 +61,10 @@ void query_on_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
+query_where_part::query_where_part(std::unique_ptr<basic_condition> &&cond)
+: query_part(dialect::token_t::WHERE)
+, condition_(std::move(cond)) {}
+
 void query_where_part::accept(query_part_visitor &visitor)
 {
   visitor.visit(*this);
@@ -178,7 +183,7 @@ void query_into_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_values_part::query_values_part(std::vector<any_type> values)
+query_values_part::query_values_part(std::vector<any_type> &&values)
 : query_part(sql::dialect::token_t::VALUES)
 , values_(std::move(values)) {}
 
diff --git a/test/models/coordinate.hpp b/test/models/coordinate.hpp
index f5d06b6..59dbd07 100644
--- a/test/models/coordinate.hpp
+++ b/test/models/coordinate.hpp
@@ -6,9 +6,9 @@
 namespace matador::test {
 struct coordinate
 {
-  int x;
-  int y;
-  int z;
+  int x{};
+  int y{};
+  int z{};
 };
 
 }
diff --git a/test/models/location.hpp b/test/models/location.hpp
index 3755aaa..e15b431 100644
--- a/test/models/location.hpp
+++ b/test/models/location.hpp
@@ -13,10 +13,10 @@ enum class Color : uint8_t {
 
 struct location
 {
-  unsigned long id;
+  unsigned long id{};
   std::string name;
   coordinate coord;
-  Color color;
+  Color color{Color::Green};
 
   template < class Operator >
   void process(Operator &op)