query parts progress

include/matador/sql/column_definition.hpp

@@ -96,6 +96,8 @@ public:
     return visitor.result;
   }
 
+  friend std::ostream& operator<<(std::ostream &out, const column_definition &col);
+
 private:
   template<class Operator>
   void process(Operator &op)

include/matador/sql/condition.hpp

@@ -57,7 +57,7 @@ public:
   std::string evaluate(dialect &d, query_context &query) const override
   {
     query.bind_vars.emplace_back(field_.name);
-    return d.prepare_identifier(field_.name) + " " + operand + " " + std::to_string(value);
+    return d.prepare_identifier(field_) + " " + operand + " " + std::to_string(value);
   }
 };
 
@@ -77,7 +77,7 @@ public:
   std::string evaluate(dialect &d, query_context &query) const override
   {
     query.bind_vars.emplace_back(field_.name);
-    return d.prepare_identifier(field_.name) + " " + operand + " '" + value + "'";
+    return d.prepare_identifier(field_) + " " + operand + " '" + value + "'";
   }
 };
 
@@ -97,7 +97,7 @@ public:
 
   std::string evaluate(dialect &d, query_context &query) const override
   {
-    return std::to_string(value) + " " + operand + " " + d.prepare_identifier(field_.name);
+    return std::to_string(value) + " " + operand + " " + d.prepare_identifier(field_);
   }
 };
 
@@ -116,7 +116,7 @@ public:
 
   std::string evaluate(dialect &d, query_context &query) const override
   {
-    return "'" + std::to_string(value) + "' " + operand + " " + d.prepare_identifier(field_.name);
+    return "'" + std::to_string(value) + "' " + operand + " " + d.prepare_identifier(field_);
   }
 };
 
@@ -162,7 +162,7 @@ public:
       query.bind_vars.emplace_back(field_.name);
     }
 
-    std::string result = d.prepare_identifier(field_.name) + " IN (";
+    std::string result = d.prepare_identifier(field_) + " IN (";
     if (args_.size() < 2) {
       for (const auto &val : args_) {
         result.append(std::to_string(val));
@@ -264,7 +264,7 @@ public:
   std::string evaluate(dialect &d, query_context &query) const override {
     query.bind_vars.emplace_back(field_.name);
     query.bind_vars.emplace_back(field_.name);
-    return d.prepare_identifier(field_.name) + " BETWEEN " + std::to_string(range_.first) + " AND " + std::to_string(range_.second);
+    return d.prepare_identifier(field_) + " BETWEEN " + std::to_string(range_.first) + " AND " + std::to_string(range_.second);
   }
 
 private:
@@ -371,7 +371,7 @@ public:
    */
   std::string evaluate(dialect &d, query_context &query) const override
   {
-    return d.prepare_identifier(field_.name) + " " + operand + " " + d.prepare_identifier(other_column_.name);
+    return d.prepare_identifier(field_) + " " + operand + " " + d.prepare_identifier(other_column_);
   }
 
 private:

include/matador/sql/connection.hpp

@@ -20,8 +20,8 @@ namespace matador::sql {
 class connection
 {
 public:
-  explicit connection(connection_info info, const std::shared_ptr<schema> &repo = std::make_shared<sql::schema>());
-  explicit connection(const std::string& dns, const std::shared_ptr<schema> &repo = std::make_shared<sql::schema>());
+  explicit connection(connection_info info);
+  explicit connection(const std::string& dns);
   connection(const connection &x);
   connection& operator=(const connection &x);
   connection(connection &&x) noexcept = default;
@@ -36,7 +36,7 @@ public:
   [[nodiscard]] bool exists(const std::string &schema_name, const std::string &table_name) const;
   [[nodiscard]] bool exists(const std::string &table_name) const;
 
-  sql::query query() const;
+  sql::query query(const std::shared_ptr<sql::schema> &schema) const;
 
   query_result<record> fetch(const query_context &q) const;
   [[nodiscard]] std::unique_ptr<query_result_impl> fetch(const std::string &sql) const;
@@ -45,14 +45,12 @@ public:
   statement prepare(query_context &&query) const;
 
   const class dialect& dialect() const;
-  std::shared_ptr<sql::schema> schema() const;
 
 private:
   connection_info connection_info_;
   std::unique_ptr<connection_impl> connection_;
   utils::logger logger_;
   const class dialect &dialect_;
-  std::shared_ptr<sql::schema> schema_;
 };
 
 }

include/matador/sql/key_value_pair.hpp

@@ -2,13 +2,15 @@
 #define QUERY_KEY_VALUE_PAIR_HPP
 
 #include "matador/sql/any_type.hpp"
+#include "matador/sql/column.hpp"
 
 namespace matador::sql {
 
 class key_value_pair
 {
 public:
-  key_value_pair(const std::string &name, any_type value);
+  key_value_pair(const sql::column &col, any_type value);
+  key_value_pair(std::string name, any_type value);
   key_value_pair(const char *name, any_type value);
 
   [[nodiscard]] const std::string& name() const;

include/matador/sql/query.hpp

@@ -10,7 +10,7 @@ class connection;
 class query
 {
 public:
-  explicit query(connection &c);
+  explicit query(connection &db, const std::shared_ptr<sql::schema> &schema);
   query(const query &) = delete;
   query& operator=(const query &) = delete;
 
@@ -22,28 +22,26 @@ public:
   query_select_intermediate select(std::initializer_list<column> columns);
   query_select_intermediate select(std::initializer_list<column> columns);
   query_insert_intermediate insert();
-  query_update_intermediate update(const std::string &table);
+  query_update_intermediate update(const sql::table &table);
   query_delete_intermediate remove();
 
-private:
-  [[nodiscard]] const sql::schema& schema() const;
-
 private:
   connection &connection_;
+  std::shared_ptr<sql::schema> schema_;
 };
 
 template<class Type>
 query_select_intermediate query::select()
 {
-  return query_select_intermediate{connection_, column_name_generator::generate<Type>(this->schema())};
+  return query_select_intermediate{connection_, schema_, column_name_generator::generate<Type>(*schema_)};
 }
 
 template<class Type>
 query_select_intermediate query::select(std::initializer_list<column> columns)
 {
-  auto cols = column_name_generator::generate<Type>(this->schema());
+  auto cols = column_name_generator::generate<Type>(*schema_);
   cols.insert(cols.end(), columns);
-  return query_select_intermediate{connection_, cols};
+  return query_select_intermediate{connection_, schema_, cols};
 }
 
 }

include/matador/sql/query_compiler.hpp

@@ -31,17 +31,22 @@ private:
   void visit(query_order_by_part &order_by_part) override;
   void visit(query_order_by_asc_part &order_by_asc_part) override;
   void visit(query_order_by_desc_part &order_by_desc_part) override;
-
+  void visit(query_offset_part &offset_part) override;
+  void visit(query_limit_part &limit_part) override;
   void visit(query_insert_part &insert_part) override;
+  void visit(query_into_part &into_part) override;
   void visit(query_values_part &values_part) override;
 
   void visit(query_update_part &update_part) override;
+  void visit(query_set_part &set_part) override;
 
   void visit(query_delete_part &delete_part) override;
 
   void visit(query_create_part &create_part) override;
+  void visit(query_create_table_part &create_table_part) override;
 
   void visit(query_drop_part &drop_part) override;
+  void visit(query_drop_table_part &drop_table_part) override;
 
 private:
   const sql::dialect &dialect_;

include/matador/sql/query_intermediates.hpp

@@ -24,19 +24,17 @@ class connection;
 class basic_query_intermediate
 {
 public:
-  explicit basic_query_intermediate(connection &db);
-
-protected:
-  [[nodiscard]] std::shared_ptr<schema> tables() const;
+  explicit basic_query_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
 protected:
   connection &connection_;
+  std::shared_ptr<sql::schema> schema_;
 };
 
 class query_intermediate : public basic_query_intermediate
 {
 public:
-  query_intermediate(connection &db, query_data &data);
+  query_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, query_data &data);
 
 protected:
   query_data &data_;
@@ -49,6 +47,7 @@ public:
 
   size_t execute();
   statement prepare();
+  [[nodiscard]] std::string str() const;
 };
 
 class query_select_finish : public query_intermediate
@@ -109,7 +108,7 @@ class query_group_by_intermediate : public query_select_finish
 public:
   using query_select_finish::query_select_finish;
 
-  query_order_by_intermediate order_by(const std::string &name);
+  query_order_by_intermediate order_by(const column &col);
 };
 
 class query_order_by_intermediate : public query_intermediate
@@ -126,7 +125,7 @@ class query_where_intermediate : public query_select_finish
 public:
   using query_select_finish::query_select_finish;
 
-  query_group_by_intermediate group_by(const std::string &name);
+  query_group_by_intermediate group_by(const column &col);
   query_order_by_intermediate order_by(const column &col);
 };
 
@@ -137,14 +136,14 @@ class query_on_intermediate : public query_select_finish
 public:
   using query_select_finish::query_select_finish;
 
-  query_join_intermediate join(const std::string &join_table_name, const std::string &as);
+  query_join_intermediate join_left(const table &t);
   template<class Condition>
   query_where_intermediate where(const Condition &cond)
   {
     data_.parts.push_back(std::make_unique<query_where_part>(cond));
-    return {connection_, data_};
+    return {connection_, schema_, data_};
   }
-  query_group_by_intermediate group_by(const std::string &name);
+  query_group_by_intermediate group_by(const column &col);
   query_order_by_intermediate order_by(const column &col);
 };
 
@@ -157,7 +156,7 @@ public:
   query_on_intermediate on(const Condition &cond)
   {
     data_.parts.push_back(std::make_unique<query_on_part>(cond));
-    return {connection_, data_};
+    return {connection_, schema_, data_};
   }
 };
 
@@ -167,15 +166,20 @@ public:
   using query_select_finish::query_select_finish;
 
   query_join_intermediate join_left(const table &t);
-  query_where_intermediate where(const basic_condition &cond);
-  query_group_by_intermediate group_by(const std::string &name);
-  query_order_by_intermediate order_by(const std::string &name);
+  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_};
+  }
+  query_group_by_intermediate group_by(const column &col);
+  query_order_by_intermediate order_by(const column &col);
 };
 
 class query_start_intermediate : public basic_query_intermediate
 {
 public:
-  explicit query_start_intermediate(connection &db);
+  explicit query_start_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
 protected:
   query_data data_;
@@ -184,7 +188,7 @@ protected:
 class query_select_intermediate : public query_start_intermediate
 {
 public:
-  query_select_intermediate(connection &s, const std::vector<column>& columns);
+  query_select_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema, const std::vector<column>& columns);
 
   query_from_intermediate from(const table& t);
 };
@@ -209,61 +213,54 @@ public:
   query_execute_finish values()
   {
     Type obj;
-    return {connection_, data_};
-//    return {connection_, builder_.values(as_placeholder(obj))};
+    data_.parts.push_back(std::make_unique<query_values_part>(as_placeholder(obj)));
+    return {connection_, schema_, data_};
   }
   template<class Type>
   query_execute_finish values(const Type &obj)
   {
-    return {connection_, data_};
-//    return {connection_, builder_.values(value_extractor::extract(obj))};
+    data_.parts.push_back(std::make_unique<query_values_part>(value_extractor::extract(obj)));
+    return {connection_, schema_, data_};
   }
 };
 
 class query_create_intermediate : public query_start_intermediate
 {
 public:
-  explicit query_create_intermediate(connection &db);
+  explicit query_create_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
-  query_execute_finish table(const std::string &table_name, std::initializer_list<column_definition> columns);
-  query_execute_finish table(const std::string &table_name, const std::vector<column_definition> &columns);
+  query_execute_finish table(const sql::table &table, std::initializer_list<column_definition> columns);
+  query_execute_finish table(const sql::table &table, const std::vector<column_definition> &columns);
   template<class Type>
-  query_execute_finish table(const std::string &table_name)
+  query_execute_finish table(const sql::table &table)
   {
-    if (!tables()->exists<Type>()) {
-      tables()->attach<Type>(table_name);
+    if (!schema_->exists<Type>()) {
+      schema_->attach<Type>(table.name);
     }
-    return {connection_, data_};
-//    return {connection_, builder_.table(table_name, column_generator::generate<Type>(*tables()))};
+    data_.parts.push_back(std::make_unique<query_create_table_part>(table, column_generator::generate<Type>(*schema_)));
+    return {connection_, schema_, data_};
   }
 };
 
 class query_drop_intermediate : query_start_intermediate
 {
 public:
-  explicit query_drop_intermediate(connection &s);
+  explicit query_drop_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
-  query_execute_finish table(const std::string &table);
+  query_execute_finish table(const sql::table &table);
 };
 
 class query_insert_intermediate : public query_start_intermediate
 {
 public:
-  explicit query_insert_intermediate(connection &s);
+  explicit query_insert_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
-  query_into_intermediate into(const std::string &table, std::initializer_list<column> column_names);
+  query_into_intermediate into(const sql::table &table, std::initializer_list<column> column_names);
   template<class Type>
-  query_into_intermediate into(const std::string &table)
-  {
-    return {connection_, data_};
-//    return {connection_, builder_.into(table, column_name_generator::generate<Type>(*tables()))};
-  }
-  template<class Type>
-  query_execute_finish into(const std::string &table, const Type &obj)
-  {
-    return {connection_, data_};
-//    return {connection_, builder_.into(table, column_name_generator::generate<Type>(*tables()))
-//                         .values(value_extractor::extract(obj))};
+  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_};
   }
 };
 
@@ -280,20 +277,25 @@ class query_set_intermediate : public query_execute_finish
 public:
   using query_execute_finish::query_execute_finish;
 
-  query_execute_where_intermediate where(const basic_condition &cond);
+  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_};
+  }
 };
 
 class query_update_intermediate : public query_start_intermediate
 {
 public:
-  query_update_intermediate(connection &s, const std::string& table_name);
+  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);
   template<class Type>
   query_set_intermediate set(const Type &obj)
   {
-    return {connection_, data_};
-//    return {connection_, builder_.set(key_value_generator::generate(obj))};
+    data_.parts.push_back(std::make_unique<query_set_part>(key_value_generator::generate(obj)));
+    return {connection_, schema_, data_};
   }
 };
 
@@ -302,15 +304,20 @@ class query_delete_from_intermediate : public query_execute_finish
 public:
   using query_execute_finish::query_execute_finish;
 
-  query_execute_where_intermediate where(const basic_condition &cond);
+  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_};
+  }
 };
 
 class query_delete_intermediate : public query_start_intermediate
 {
 public:
-  explicit query_delete_intermediate(connection &s);
+  explicit query_delete_intermediate(connection &db, const std::shared_ptr<sql::schema> &schema);
 
-  query_delete_from_intermediate from(const std::string &table);
+  query_delete_from_intermediate from(const sql::table &table);
 };
 
 }

include/matador/sql/query_part_visitor.hpp

@@ -12,12 +12,18 @@ class query_group_by_part;
 class query_order_by_part;
 class query_order_by_asc_part;
 class query_order_by_desc_part;
+class query_offset_part;
+class query_limit_part;
 class query_insert_part;
+class query_into_part;
 class query_values_part;
 class query_update_part;
+class query_set_part;
 class query_delete_part;
 class query_create_part;
+class query_create_table_part;
 class query_drop_part;
+class query_drop_table_part;
 
 class query_part_visitor
 {
@@ -33,16 +39,23 @@ public:
   virtual void visit(query_order_by_part &order_by_part) = 0;
   virtual void visit(query_order_by_asc_part &order_by_asc_part) = 0;
   virtual void visit(query_order_by_desc_part &order_by_desc_part) = 0;
+  virtual void visit(query_offset_part &offset_part) = 0;
+  virtual void visit(query_limit_part &limit_part) = 0;
 
   virtual void visit(query_insert_part &insert_part) = 0;
+  virtual void visit(query_into_part &into_part) = 0;
   virtual void visit(query_values_part &values_part) = 0;
 
   virtual void visit(query_update_part &update_part) = 0;
+  virtual void visit(query_set_part &set_part) = 0;
 
   virtual void visit(query_delete_part &delete_part) = 0;
 
   virtual void visit(query_create_part &create_part) = 0;
+  virtual void visit(query_create_table_part &create_table_part) = 0;
+
   virtual void visit(query_drop_part &drop_part) = 0;
+  virtual void visit(query_drop_table_part &drop_table_part) = 0;
 };
 
 }

include/matador/sql/query_parts.hpp

@@ -6,6 +6,7 @@
 #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/table.hpp"
 
 #include <memory>
@@ -98,7 +99,7 @@ public:
   : query_part(dialect::token_t::WHERE)
   , condition_(new Condition(cond)) {}
 
-  const basic_condition& condition() const;
+  [[nodiscard]] const basic_condition& condition() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
@@ -116,13 +117,18 @@ protected:
   std::string table_name_;
 };
 
-class query_group_by_part : public query_table_name_part
+class query_group_by_part : public query_part
 {
 public:
-  explicit query_group_by_part(const std::string &table_name);
+  explicit query_group_by_part(sql::column  col);
+
+  [[nodiscard]] const sql::column& column() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
+
+private:
+  sql::column column_;
 };
 
 class query_order_by_part : public query_part
@@ -130,7 +136,7 @@ class query_order_by_part : public query_part
 public:
   explicit query_order_by_part(sql::column  col);
 
-  const sql::column& column() const;
+  [[nodiscard]] const sql::column& column() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
@@ -157,6 +163,34 @@ private:
   void accept(query_part_visitor &visitor) override;
 };
 
+class query_offset_part : public query_part
+{
+public:
+  explicit query_offset_part(size_t offset);
+
+  size_t offset() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  size_t offset_;
+};
+
+class query_limit_part : public query_part
+{
+public:
+  explicit query_limit_part(size_t limit);
+
+  size_t limit() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  size_t limit_;
+};
+
 class query_insert_part : public query_part
 {
 public:
@@ -166,13 +200,30 @@ private:
   void accept(query_part_visitor &visitor) override;
 };
 
+class query_into_part : public query_part
+{
+public:
+  query_into_part(sql::table t, std::vector<sql::column> columns);
+
+  [[nodiscard]] const sql::table& table() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  sql::table table_;
+  std::vector<column> columns_;
+};
 /**
  * Represents the SQL VALUES part
  */
 class query_values_part : public query_part
 {
 public:
-  query_values_part(std::initializer_list<any_type> values);
+  query_values_part(std::vector<any_type> values);
+
+  [[nodiscard]] const std::vector<any_type>& values() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
@@ -181,13 +232,32 @@ private:
   std::vector<any_type> values_;
 };
 
-class query_update_part : public query_table_name_part
+class query_update_part : public query_part
 {
 public:
-  explicit query_update_part(const std::string &table_name);
+  explicit query_update_part(sql::table table);
+
+  [[nodiscard]] const sql::table& table() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
+
+private:
+  sql::table table_;
+};
+
+class query_set_part : public query_part
+{
+public:
+  explicit query_set_part(const std::vector<sql::key_value_pair>& key_value_pairs);
+
+  [[nodiscard]] const std::vector<sql::key_value_pair>& key_values() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  std::vector<sql::key_value_pair> key_value_pairs_;
 };
 
 class query_delete_part : public query_part
@@ -208,6 +278,22 @@ private:
   void accept(query_part_visitor &visitor) override;
 };
 
+class query_create_table_part : public query_part
+{
+public:
+  query_create_table_part(sql::table table, std::vector<sql::column_definition> columns);
+
+  [[nodiscard]] const sql::table& table() const;
+  const std::vector<sql::column_definition>& columns() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  sql::table table_;
+  std::vector<sql::column_definition> columns_;
+};
+
 class query_drop_part : public query_part
 {
 public:
@@ -217,5 +303,19 @@ private:
   void accept(query_part_visitor &visitor) override;
 };
 
+class query_drop_table_part : public query_part
+{
+public:
+  explicit query_drop_table_part(sql::table table);
+
+  [[nodiscard]] const sql::table& table() const;
+
+private:
+  void accept(query_part_visitor &visitor) override;
+
+private:
+  sql::table table_;
+};
+
 }
 #endif //QUERY_QUERY_PARTS_HPP

include/matador/sql/record.hpp

@@ -10,6 +10,8 @@
 
 namespace matador::sql {
 
+struct column;
+
 class record
 {
 private:
@@ -50,7 +52,8 @@ public:
 
   [[nodiscard]] const std::vector<column_definition>& columns() const;
 
-  [[nodiscard]] const column_definition& at(const std::string &name) const;
+  [[nodiscard]] const column_definition& at(const column &col) const;
+//  [[nodiscard]] const column_definition& at(const std::string &name) const;
   [[nodiscard]] const column_definition& at(size_t index) const;
 
   iterator find(const std::string &column_name);

include/matador/sql/schema.hpp

@@ -28,6 +28,8 @@ public:
   using iterator = repository::iterator;
   using const_iterator = repository::const_iterator;
 
+  explicit schema(std::string name);
+
   [[nodiscard]] std::string name() const;
 
   template<typename Type>

include/matador/sql/session.hpp

@@ -56,25 +56,25 @@ private:
   connection_pool<connection> &pool_;
   const class dialect &dialect_;
 
-  schema schema_;
+  std::shared_ptr<schema> schema_;
   mutable std::unordered_map<std::string, record> prototypes_;
 };
 
 template<typename Type>
 void session::attach(const std::string &table_name)
 {
-  schema_.attach<Type>(table_name);
+  schema_->attach<Type>(table_name);
 }
 
 template<typename Type>
 entity<Type> session::insert(Type *obj)
 {
   auto c = pool_.acquire();
-  auto info = schema_.info<Type>();
+  auto info = schema_->info<Type>();
   if (!info) {
     return {};
   }
-  c->query().insert().into<Type>(info->name).values(*obj).execute();
+  c->query(schema_).insert().into<Type>(info->name).values(*obj).execute();
 
   return entity{obj};
 }
@@ -82,7 +82,7 @@ entity<Type> session::insert(Type *obj)
 template<typename Type>
 void session::drop_table()
 {
-  auto info = schema_.info<Type>();
+  auto info = schema_->info<Type>();
   if (info) {
     return drop_table(info.name);
   }