added mysql backend

src/CMakeLists.txt

@@ -23,9 +23,10 @@ set(SQL_SOURCES
   sql/statement_cache.cpp
   sql/statement_impl.cpp
   sql/dialect_builder.cpp
-  sql/object_binder.cpp
+  sql/object_parameter_binder.cpp
   sql/placeholder_generator.cpp
   sql/types.cpp
+  sql/result_parameter_binder.cpp
 )
 
 set(SQL_HEADER
@@ -64,8 +65,9 @@ set(SQL_HEADER
   sql/statement.cpp
   ../include/matador/sql/parameter_binder.hpp
   ../include/matador/sql/dialect_builder.hpp
-  ../include/matador/sql/object_binder.hpp
+  ../include/matador/sql/object_parameter_binder.hpp
   ../include/matador/sql/placeholder_generator.hpp
+  ../include/matador/sql/result_parameter_binder.hpp
 )
 
 set(UTILS_HEADER

src/sql/connection.cpp

@@ -71,9 +71,9 @@ record connection::describe(const std::string &table_name) const
   return std::move(connection_->describe(table_name));
 }
 
-bool connection::exists(const std::string &table_name) const
+bool connection::exists(const std::string &schema_name, const std::string &table_name) const
 {
-  return connection_->exists(table_name);
+  return connection_->exists(schema_name, table_name);
 }
 
 size_t connection::execute(const std::string &sql) const

src/sql/object_parameter_binder.cpp

@@ -1,4 +1,4 @@
-#include "matador/sql/object_binder.hpp"
+#include "matador/sql/object_parameter_binder.hpp"
 #include "matador/sql/parameter_binder.hpp"
 
 namespace matador::sql {
@@ -15,21 +15,21 @@ void fk_binder::on_primary_key(const char *id, std::string &value, size_t size)
 
 }
 
-object_binder::object_binder(parameter_binder &binder)
+object_parameter_binder::object_parameter_binder(parameter_binder &binder)
 : binder_(binder)
 , fk_binder_(binder) {}
 
-void object_binder::reset()
+void object_parameter_binder::reset()
 {
   index_ = 0;
 }
 
-void object_binder::on_primary_key(const char *id, std::string &val, size_t size)
+void object_parameter_binder::on_primary_key(const char *id, std::string &val, size_t size)
 {
   data_type_traits<std::string>::bind_value(binder_, index_++, val, size);
 }
 
-void object_binder::on_revision(const char *id, unsigned long long int &rev)
+void object_parameter_binder::on_revision(const char *id, unsigned long long int &rev)
 {
   data_type_traits<unsigned long long>::bind_value(binder_, index_++, rev);
 }

src/sql/query_builder.cpp

@@ -125,15 +125,18 @@ query_builder &query_builder::select(const std::vector<column> &columns)
   if (columns.size() < 2) {
     for (const auto &col: columns) {
       result.append(dialect_.prepare_identifier(col));
+      query_.result_vars.emplace_back(col.name());
       query_.prototype.append(col);
     }
   } else {
     auto it = columns.begin();
     result.append(dialect_.prepare_identifier(*it));
+    query_.result_vars.emplace_back(it->name());
     query_.prototype.append(column{*it++});
     for (; it != columns.end(); ++it) {
       result.append(", ");
       result.append(dialect_.prepare_identifier(*it));
+      query_.result_vars.emplace_back(it->name());
       query_.prototype.append(column{*it});
     }
   }
@@ -284,20 +287,20 @@ query_builder &query_builder::values(const std::vector<any_type> &values)
   std::string result{"("};
   if (values.size() < 2) {
     for (auto val: values) {
-      query_.host_vars.push_back(val);
+//      query_.result_vars.push_back(val);
       std::visit(value_to_string_, val);
       result.append(value_to_string_.result);
     }
   } else {
     auto it = values.begin();
     auto val = *it++;
-    query_.host_vars.push_back(val);
+//    query_.result_vars.push_back(val);
     std::visit(value_to_string_, val);
     result.append(value_to_string_.result);
     for (; it != values.end(); ++it) {
       result.append(", ");
       val = *it;
-      query_.host_vars.push_back(val);
+//      query_.result_vars.push_back(val);
       std::visit(value_to_string_, val);
       result.append(value_to_string_.result);
     }

src/sql/result_parameter_binder.cpp

@@ -0,0 +1,42 @@
+#include "matador/sql/result_parameter_binder.hpp"
+
+namespace matador::sql {
+
+namespace detail {
+fk_result_binder::fk_result_binder(result_parameter_binder &result_binder)
+: result_binder_(result_binder)
+{}
+
+void fk_result_binder::on_primary_key(const char * /*id*/, std::string &value, size_t size)
+{
+  data_type_traits<std::string>::bind_result_value(result_binder_, column_index_++, value, size);
+}
+
+}
+
+void result_parameter_binder::on_primary_key(const char * /*id*/, std::string &value, size_t size)
+{
+  data_type_traits<std::string>::bind_result_value(*this, column_index_++, value, size);
+}
+
+void result_parameter_binder::on_revision(const char * /*id*/, unsigned long long &rev)
+{
+  data_type_traits<unsigned long long>::bind_result_value(*this, column_index_++, rev);
+}
+
+void result_parameter_binder::on_attribute(const char * /*id*/, char *value, const utils::field_attributes &attr)
+{
+  data_type_traits<char*>::bind_result_value(*this, column_index_++, value, attr.size());
+}
+
+void result_parameter_binder::on_attribute(const char * /*id*/, std::string &value, const utils::field_attributes &attr)
+{
+  data_type_traits<std::string>::bind_result_value(*this, column_index_++, value, attr.size());
+}
+
+void result_parameter_binder::on_attribute(const char * /*id*/, any_type &value, data_type_t type, const utils::field_attributes &attr)
+{
+
+}
+
+}

src/sql/session.cpp

@@ -97,7 +97,7 @@ bool session::table_exists(const std::string &table_name) const
   if (!c.valid()) {
     throw std::logic_error("no database connection available");
   }
-  return c->exists(table_name);
+  return c->exists(dialect_.default_schema_name(), table_name);
 }
 
 const table_repository& session::tables() const

src/sql/types.cpp

@@ -2,6 +2,7 @@
 
 #include "matador/sql/parameter_binder.hpp"
 #include "matador/sql/query_result_reader.hpp"
+#include "matador/sql/result_parameter_binder.hpp"
 
 namespace matador::sql {
 
@@ -15,6 +16,11 @@ void data_type_traits<char>::bind_value(parameter_binder &binder, size_t index,
   binder.bind(index, value);
 }
 
+void data_type_traits<char>::bind_result_value(result_parameter_binder &binder, size_t index, char &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<short>::read_value(query_result_reader &reader, const char *id, size_t index, short &value)
 {
   reader.read_value(id, index, value);
@@ -25,6 +31,11 @@ void data_type_traits<short>::bind_value(parameter_binder &binder, size_t index,
   binder.bind(index, value);
 }
 
+void data_type_traits<short>::bind_result_value(result_parameter_binder &binder, size_t index, short &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<int>::read_value(query_result_reader &reader, const char *id, size_t index, int &value)
 {
   reader.read_value(id, index, value);
@@ -35,6 +46,11 @@ void data_type_traits<int>::bind_value(parameter_binder &binder, size_t index, i
   binder.bind(index, value);
 }
 
+void data_type_traits<int>::bind_result_value(result_parameter_binder &binder, size_t index, int &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<long>::read_value(query_result_reader &reader, const char *id, size_t index, long &value)
 {
   reader.read_value(id, index, value);
@@ -45,6 +61,11 @@ void data_type_traits<long>::bind_value(parameter_binder &binder, size_t index,
   binder.bind(index, value);
 }
 
+void data_type_traits<long>::bind_result_value(result_parameter_binder &binder, size_t index, long &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<long long>::read_value(query_result_reader &reader, const char *id, size_t index, long long &value)
 {
   reader.read_value(id, index, value);
@@ -55,6 +76,11 @@ void data_type_traits<long long int>::bind_value(parameter_binder &binder, size_
   binder.bind(index, value);
 }
 
+void data_type_traits<long long int>::bind_result_value(result_parameter_binder &binder, size_t index, long long int &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<unsigned char>::read_value(query_result_reader &reader, const char *id, size_t index, unsigned char &value)
 {
   reader.read_value(id, index, value);
@@ -65,6 +91,11 @@ void data_type_traits<unsigned char>::bind_value(parameter_binder &binder, size_
   binder.bind(index, value);
 }
 
+void data_type_traits<unsigned char>::bind_result_value(result_parameter_binder &binder, size_t index, unsigned char &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<unsigned short>::read_value(query_result_reader &reader, const char *id, size_t index, unsigned short &value)
 {
   reader.read_value(id, index, value);
@@ -75,6 +106,11 @@ void data_type_traits<unsigned short>::bind_value(parameter_binder &binder, size
   binder.bind(index, value);
 }
 
+void data_type_traits<unsigned short>::bind_result_value(result_parameter_binder &binder, size_t index, unsigned short &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<unsigned int>::read_value(query_result_reader &reader, const char *id, size_t index, unsigned int &value)
 {
   reader.read_value(id, index, value);
@@ -85,6 +121,11 @@ void data_type_traits<unsigned int>::bind_value(parameter_binder &binder, size_t
   binder.bind(index, value);
 }
 
+void data_type_traits<unsigned int>::bind_result_value(result_parameter_binder &binder, size_t index, unsigned int &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<unsigned long>::read_value(query_result_reader &reader, const char *id, size_t index, unsigned long &value)
 {
   reader.read_value(id, index, value);
@@ -95,16 +136,26 @@ void data_type_traits<unsigned long>::bind_value(parameter_binder &binder, size_
   binder.bind(index, value);
 }
 
+void data_type_traits<unsigned long>::bind_result_value(result_parameter_binder &binder, size_t index, unsigned long &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<unsigned long long>::read_value(query_result_reader &reader, const char *id, size_t index, unsigned long long &value)
 {
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<unsigned long long int>::bind_value(parameter_binder &binder, size_t index, unsigned long long int &value)
+void data_type_traits<unsigned long long>::bind_value(parameter_binder &binder, size_t index, unsigned long long &value)
 {
   binder.bind(index, value);
 }
 
+void data_type_traits<unsigned long long>::bind_result_value(result_parameter_binder &binder, size_t index, unsigned long long &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<bool>::read_value(query_result_reader &reader, const char *id, size_t index, bool &value)
 {
   reader.read_value(id, index, value);
@@ -115,6 +166,11 @@ void data_type_traits<bool>::bind_value(parameter_binder &binder, size_t index,
   binder.bind(index, value);
 }
 
+void data_type_traits<bool>::bind_result_value(result_parameter_binder &binder, size_t index, bool &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<float>::read_value(query_result_reader &reader, const char *id, size_t index, float &value)
 {
   reader.read_value(id, index, value);
@@ -125,6 +181,11 @@ void data_type_traits<float>::bind_value(parameter_binder &binder, size_t index,
   binder.bind(index, value);
 }
 
+void data_type_traits<float>::bind_result_value(result_parameter_binder &binder, size_t index, float &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<double>::read_value(query_result_reader &reader, const char *id, size_t index, double &value)
 {
   reader.read_value(id, index, value);
@@ -135,6 +196,11 @@ void data_type_traits<double>::bind_value(parameter_binder &binder, size_t index
   binder.bind(index, value);
 }
 
+void data_type_traits<double>::bind_result_value(result_parameter_binder &binder, size_t index, double &value)
+{
+  binder.bind_result_value(index, value);
+}
+
 void data_type_traits<const char*>::read_value(query_result_reader &reader, const char *id, size_t index, const char* value, size_t size)
 {
   reader.read_value(id, index, const_cast<char*>(value), size);
@@ -145,6 +211,11 @@ void data_type_traits<const char *>::bind_value(parameter_binder &binder, size_t
   binder.bind(index, value, size);
 }
 
+void data_type_traits<const char *>::bind_result_value(result_parameter_binder &binder, size_t index, const char *value, size_t size)
+{
+  binder.bind_result_value(index, const_cast<char*>(value), size);
+}
+
 void data_type_traits<char*>::read_value(query_result_reader &reader, const char *id, size_t index, char* value, size_t size)
 {
   reader.read_value(id, index, value, size);
@@ -155,6 +226,11 @@ void data_type_traits<char *>::bind_value(parameter_binder &binder, size_t index
   binder.bind(index, value, size);
 }
 
+void data_type_traits<char *, void>::bind_result_value(result_parameter_binder &binder, size_t index, char *value, size_t size)
+{
+  binder.bind_result_value(index, value, size);
+}
+
 void data_type_traits<std::string>::read_value(query_result_reader &reader, const char *id, size_t index, std::string &value, size_t size)
 {
   reader.read_value(id, index, value, size);
@@ -165,4 +241,8 @@ void data_type_traits<std::string>::bind_value(parameter_binder &binder, size_t
   binder.bind(index, value, size);
 }
 
+void data_type_traits<std::string, void>::bind_result_value(result_parameter_binder &binder, size_t index, std::string &value, size_t size)
+{
+  binder.bind_result_value(index, value, size);
+}
 }