added any type visitor and converter

src/sql/query_intermediates.cpp

@@ -2,145 +2,173 @@
 #include "matador/sql/session.hpp"
 
 namespace matador::sql {
-session &query_intermediate::db()
-{
-  return db_;
-}
-
-query_builder &query_intermediate::query()
-{
-  return query_;
-}
 
 query_result<record> query_select_finish::fetch_all()
 {
-  return db().fetch(query().compile());
+  return session_.fetch(builder_.compile());
 }
 
 record query_select_finish::fetch_one()
 {
-  return *db().fetch(query().compile()).begin().get();
+  return *session_.fetch(builder_.compile()).begin().get();
 }
 
 std::unique_ptr<query_result_impl> query_select_finish::fetch()
 {
-  return db().call_fetch(query().compile());
+  return session_.call_fetch(builder_.compile().sql);
 }
 
 query_intermediate::query_intermediate(session &db, query_builder &query)
-: db_(db), query_(query) {}
+: session_(db), builder_(query) {}
 
 query_offset_intermediate query_order_direction_intermediate::offset(size_t offset)
 {
-  return {db(), query()};
+  return {session_, builder_};
 }
 
 query_limit_intermediate query_offset_intermediate::limit(size_t limit)
 {
-  return {db(), query()};
+  return {session_, builder_};
 }
 
 query_limit_intermediate query_order_direction_intermediate::limit(size_t limit)
 {
-  return {db(), query()};
+  return {session_, builder_};
 }
 
 query_order_by_intermediate query_group_by_intermediate::order_by(const std::string &name)
 {
-  return {db(), query().order_by(name)};
+  return {session_, builder_.order_by(name)};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::asc()
 {
-  return {db(), query().asc()};
+  return {session_, builder_.asc()};
 }
 
 query_order_direction_intermediate query_order_by_intermediate::desc()
 {
-  return {db(), query().desc()};
+  return {session_, builder_.desc()};
 }
 
 query_group_by_intermediate query_from_intermediate::group_by(const std::string &name)
 {
-  return {db(), query().group_by(name)};
+  return {session_, builder_.group_by(name)};
 }
 
 query_order_by_intermediate query_from_intermediate::order_by(const std::string &name)
 {
-  return {db(), query().order_by(name)};
+  return {session_, builder_.order_by(name)};
 }
 
 query_group_by_intermediate query_where_intermediate::group_by(const std::string &name)
 {
-  return {db(), query().group_by(name)};
+  return {session_, builder_.group_by(name)};
 }
 
 query_order_by_intermediate query_where_intermediate::order_by(const std::string &name)
 {
-  return {db(), query().order_by(name)};
+  return {session_, builder_.order_by(name)};
 }
 
 query_where_intermediate query_from_intermediate::where(const basic_condition &cond)
 {
-  return query_where_intermediate{db(), query().where(cond)};
+  return query_where_intermediate{session_, builder_.where(cond)};
+}
+
+query_select_intermediate::query_select_intermediate(session &s, std::vector<std::string> column_names)
+: query_start_intermediate(s)
+{
+  builder_.select(std::move(column_names));
 }
 
 query_from_intermediate query_select_intermediate::from(const std::string &table, const std::string &as)
 {
-  return {db(), query().from(table, as)};
+  return {session_, builder_.from(table, as)};
+}
+
+query_insert_intermediate::query_insert_intermediate(session &s)
+: query_start_intermediate(s)
+{
+  builder_.insert();
 }
 
 query_into_intermediate query_insert_intermediate::into(const std::string &table, std::initializer_list<std::string> column_names)
 {
-  return {db(), query().into(table, column_names)};
+  return {session_, builder_.into(table, column_names)};
 }
 
 std::pair<size_t, std::string> query_execute_finish::execute()
 {
-  return db().execute(query().compile());
+  return session_.execute(builder_.compile().sql);
 }
 
 query_execute_finish query_into_intermediate::values(std::initializer_list<any_type> values)
 {
-  return {db(), query().values(values)};
+  return {session_, builder_.values(values)};
 }
 
-query_create_intermediate::query_create_intermediate(session &db, query_builder &query, table_repository &repo)
-: query_intermediate(db, query)
-, repository_(repo) {}
+query_create_intermediate::query_create_intermediate(session &s, table_repository &repo)
+: query_start_intermediate(s)
+, repository_(repo) {
+  builder_.create();
+}
 
 query_execute_finish query_create_intermediate::table(const std::string &table, std::initializer_list<column> columns)
 {
-  return {db(), query().table(table, columns)};
+  return {session_, builder_.table(table, columns)};
+}
+
+query_drop_intermediate::query_drop_intermediate(session &s)
+: query_start_intermediate(s)
+{
+  builder_.drop();
 }
 
 query_execute_finish query_drop_intermediate::table(const std::string &table)
 {
-  return {db(), query().table(table)};
+  return {session_, builder_.table(table)};
 }
 
 query_execute_finish query_execute_where_intermediate::limit(int limit)
 {
-  return {db(), query().limit(limit)};
+  return {session_, builder_.limit(limit)};
 }
 
 query_execute_where_intermediate query_set_intermediate::where(const basic_condition &cond)
 {
-  return {db(), query().where(cond)};
+  return {session_, builder_.where(cond)};
+}
+
+query_update_intermediate::query_update_intermediate(session &s, std::string table_name)
+: query_start_intermediate(s)
+{
+  builder_.update(std::move(table_name));
 }
 
 query_set_intermediate query_update_intermediate::set(std::initializer_list<key_value_pair> columns)
 {
-  return {db(), query().set(columns)};
+  return {session_, builder_.set(columns)};
 }
 
 query_execute_where_intermediate query_delete_from_intermediate::where(const basic_condition &cond)
 {
-  return {db(), query().where(cond)};
+  return {session_, builder_.where(cond)};
+}
+
+query_delete_intermediate::query_delete_intermediate(session &s)
+: query_start_intermediate(s)
+{
+  builder_.remove();
 }
 
 query_delete_from_intermediate query_delete_intermediate::from(const std::string &table)
 {
-  return {db(), query().from(table)};
+  return {session_, builder_.from(table)};
 }
+
+query_start_intermediate::query_start_intermediate(session &s)
+: session_(s)
+, builder_(s.dialect())
+{}
 }