added test for date and time, sql read and write functionality

source/orm/query/attribute_string_writer.cpp

@@ -9,104 +9,108 @@
 #include "matador/utils/string.hpp"
 
 namespace matador::query {
-
-attribute_string_writer::attribute_string_writer(const sql::dialect &d, const std::optional<std::reference_wrapper<const sql::connection_impl>> conn)
+attribute_string_writer::attribute_string_writer(const sql::dialect &d,
+                                                 const std::optional<std::reference_wrapper<const
+                                                   sql::connection_impl> > conn)
 : dialect_(d)
-, conn_(conn) {}
-
-const sql::dialect& attribute_string_writer::dialect() const {
-    return dialect_;
+  , conn_(conn) {
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const int8_t& x ) {
-    result_ = std::to_string(x) ;
+const sql::dialect &attribute_string_writer::dialect() const {
+  return dialect_;
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const int16_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const int8_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const int32_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const int16_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const int64_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const int32_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const uint8_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const int64_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const uint16_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const uint8_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const uint32_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const uint16_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const uint64_t& x ) {
-    result_ = std::to_string(x) ;
+void attribute_string_writer::write_value(size_t /*pos*/, const uint32_t &x) {
+  result_ = std::to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const bool& x ) {
-//  result_ = "'" + conn_->dialect().prepare_literal(x ? "true" : "false") + "'";
+void attribute_string_writer::write_value(size_t /*pos*/, const uint64_t &x) {
+  result_ = std::to_string(x);
+}
+
+void attribute_string_writer::write_value(size_t /*pos*/, const bool &x) {
+  //  result_ = "'" + conn_->dialect().prepare_literal(x ? "true" : "false") + "'";
   result_ = dialect_.to_string(x);
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const float& x ) {
+void attribute_string_writer::write_value(size_t /*pos*/, const float &x) {
   if (const auto res = utils::to<std::string>(x); !res.is_error()) {
     result_ = *res;
   }
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const double& x ) {
+void attribute_string_writer::write_value(size_t /*pos*/, const double &x) {
   if (const auto res = utils::to<std::string>(x); !res.is_error()) {
     result_ = *res;
   }
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const utils::date_type_t& /*x*/ ) {
-  //  result_ = "'" + dialect_.prepare_literal(utils::to_string(x)) + "'";
+void attribute_string_writer::write_value(size_t /*pos*/, const utils::date_type_t &x) {
+  result_ = "'" + dialect_.prepare_literal(utils::to_string(x)) + "'";
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const utils::time_type_t& /*x*/ ) {
-//    result_ = "'" + dialect_.prepare_literal(utils::to_string(x, "%F %T.%f")) + "'";
+void attribute_string_writer::write_value(size_t /*pos*/, const utils::time_type_t &x) {
+  result_ = "'" + dialect_.prepare_literal(utils::to_string(x)) + "'";
 }
 
 void attribute_string_writer::write_value(size_t /*pos*/, const utils::timestamp &/*x*/) {
 }
 
-void attribute_string_writer::write_value(size_t pos, const char* x ) {
-  write_value(pos, std::string(x) );
+void attribute_string_writer::write_value(size_t pos, const char *x) {
+  write_value(pos, std::string(x));
 }
 
-void attribute_string_writer::write_value(size_t pos, const char* x, size_t /*size*/) {
-  write_value(pos, std::string(x) );
+void attribute_string_writer::write_value(size_t pos, const char *x, size_t /*size*/) {
+  write_value(pos, std::string(x));
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const std::string& x ) {
+void attribute_string_writer::write_value(size_t /*pos*/, const std::string &x) {
   result_ = "'" + dialect_.prepare_literal(x) + "'";
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const std::string& x, size_t /*size*/) {
+void attribute_string_writer::write_value(size_t /*pos*/, const std::string &x, size_t /*size*/) {
   result_ = "'" + dialect_.prepare_literal(x) + "'";
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const utils::blob& x ) {
+void attribute_string_writer::write_value(size_t /*pos*/, const utils::blob &x) {
   // "This is a binary Data string" as binary data:
   // MySQL:    X'5468697320697320612062616E617279204461746120737472696E67'
   // Postgres: '\\x5468697320697320612062616E617279204461746120737472696E67'
   // MSSQL:    0x5468697320697320612062616E617279204461746120737472696E67
   // Sqlite:   X'5468697320697320612062616E617279204461746120737472696E67'
   if (conn_.has_value()) {
-    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + conn_.value().get().to_escaped_string(x) + dialect_.token_at(sql::dialect_token::EndBinaryData);
+    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + conn_.value().get().to_escaped_string(x) +
+              dialect_.token_at(sql::dialect_token::EndBinaryData);
   } else {
-    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + dialect_.to_escaped_string(x) + dialect_.token_at(sql::dialect_token::EndBinaryData);
+    result_ = dialect_.token_at(sql::dialect_token::BeginBinaryData) + dialect_.to_escaped_string(x) + dialect_.
+              token_at(sql::dialect_token::EndBinaryData);
   }
 }
 
-void attribute_string_writer::write_value(size_t /*pos*/, const utils::value &/*x*/, size_t /*size*/) {}
-
-}
+void attribute_string_writer::write_value(size_t /*pos*/, const utils::value &/*x*/, size_t /*size*/) {
+}
+}

source/orm/query/internal/query_result_impl.cpp

@@ -3,49 +3,47 @@
 #include "matador/sql/interface/query_result_reader.hpp"
 
 namespace matador::sql {
-
 detail::pk_reader::pk_reader(query_result_reader &reader)
-: reader_(reader) {}
+: reader_(reader) {
+}
 
-query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader, std::vector<object::attribute> &&prototype, const size_t column_index)
+query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader,
+                                     std::vector<object::attribute> &&prototype,
+                                     const size_t column_index)
 : column_index_(column_index)
-, prototype_(std::move(prototype))
-, reader_(std::move(reader))
-, pk_reader_(*reader_)
-{}
+  , prototype_(std::move(prototype))
+  , reader_(std::move(reader))
+  , pk_reader_(*reader_) {
+}
 
-query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader, const std::vector<object::attribute> &prototype, const size_t column_index)
+query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader,
+                                     const std::vector<object::attribute> &prototype,
+                                     const size_t column_index)
 : column_index_(column_index)
-, prototype_(prototype)
-, reader_(std::move(reader))
-, pk_reader_(*reader_)
-{}
+  , prototype_(prototype)
+  , reader_(std::move(reader))
+  , pk_reader_(*reader_) {
+}
 
-void query_result_impl::on_revision(const char *id, uint64_t &rev)
-{
+void query_result_impl::on_revision(const char *id, uint64_t &rev) {
   utils::data_type_traits<uint64_t>::read_value(*reader_, id, column_index_++, rev);
   reader_->read_value(id, column_index_++, rev);
 }
 
-void query_result_impl::on_attribute(const char *id, char *value, const utils::field_attributes &attr)
-{
-  utils::data_type_traits<char*>::read_value(*reader_, id, column_index_++, value, attr.size());
+void query_result_impl::on_attribute(const char *id, char *value, const utils::field_attributes &attr) {
+  utils::data_type_traits<char *>::read_value(*reader_, id, column_index_++, value, attr.size());
 }
 
-void query_result_impl::on_attribute(const char *id, std::string &value, const utils::field_attributes &attr)
-{
+void query_result_impl::on_attribute(const char *id, std::string &value, const utils::field_attributes &attr) {
   utils::data_type_traits<std::string>::read_value(*reader_, id, column_index_++, value, attr.size());
 }
 
 void
-query_result_impl::on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr)
-{
+query_result_impl::on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr) {
   reader_->read_value(id, column_index_++, val, attr.size());
 }
 
-const std::vector<object::attribute>& query_result_impl::prototype() const
-{
+const std::vector<object::attribute> &query_result_impl::prototype() const {
   return prototype_;
 }
-
-}
+}

source/orm/query/value_extractor.cpp

@@ -61,15 +61,16 @@ void value_extractor::write_value(size_t /*pos*/, const double &x) {
   values_.emplace_back(x);
 }
 
-void value_extractor::write_value(size_t /*pos*/, const utils::date_type_t &/*x*/) {
-  // values_.emplace_back(x);
+void value_extractor::write_value(size_t /*pos*/, const utils::date_type_t &x) {
+  values_.emplace_back(x);
 }
 
-void value_extractor::write_value(size_t /*pos*/, const utils::time_type_t &/*x*/) {
-  // values_.emplace_back(x);
+void value_extractor::write_value(size_t /*pos*/, const utils::time_type_t &x) {
+  values_.emplace_back(x);
 }
 
-void value_extractor::write_value(size_t /*pos*/, const utils::timestamp &/*x*/) {
+void value_extractor::write_value(size_t /*pos*/, const utils::timestamp &x) {
+  values_.emplace_back(x);
 }
 
 void value_extractor::write_value(size_t /*pos*/, const char *x) {

source/orm/sql/dialect.cpp

@@ -6,8 +6,7 @@
 #include "matador/utils/value.hpp"
 
 namespace matador::sql {
-
-const std::string& dialect::token_at(const dialect_token token) const {
+const std::string &dialect::token_at(const dialect_token token) const {
   return tokens_.at(token);
 }
 
@@ -15,22 +14,21 @@ const std::string &dialect::data_type_at(const utils::basic_type type) const {
   return data_types_.at(type);
 }
 
-const std::string& dialect::sql_function_at(const sql_function_t func) const {
+const std::string &dialect::sql_function_at(const sql_function_t func) const {
   return sql_func_map_.at(func);
 }
 
-std::string dialect::table_name( const std::string& table, const std::string& schema_name ) const {
-    if ( schema_name.empty() && default_schema_name_.empty()) {
-        return prepare_identifier_string( table );
-    }
-    if ( schema_name.empty() ) {
-        return prepare_identifier_string( default_schema_name_ ) + "." + prepare_identifier_string( table );
-    }
-    return prepare_identifier_string( schema_name ) + "." + prepare_identifier_string( table );
+std::string dialect::table_name(const std::string &table, const std::string &schema_name) const {
+  if (schema_name.empty() && default_schema_name_.empty()) {
+    return prepare_identifier_string(table);
+  }
+  if (schema_name.empty()) {
+    return prepare_identifier_string(default_schema_name_) + "." + prepare_identifier_string(table);
+  }
+  return prepare_identifier_string(schema_name) + "." + prepare_identifier_string(table);
 }
 
-const std::string& dialect::to_string(const bool val) const
-{
+const std::string &dialect::to_string(const bool val) const {
   return bool_strings_[static_cast<int>(val)];
 }
 
@@ -45,38 +43,33 @@ std::string dialect::to_sql_string(const utils::value &val) const {
   return val.str();
 }
 
-void dialect::bool_strings(const std::string &true_string, const std::string &false_string)
-{
+void dialect::bool_strings(const std::string &true_string, const std::string &false_string) {
   bool_strings_[0] = false_string;
   bool_strings_[1] = true_string;
 }
 
-std::string dialect::prepare_identifier_string(const std::string &col) const
-{
+std::string dialect::prepare_identifier_string(const std::string &col) const {
   auto parts = utils::split(col, '.');
 
-  for (auto &part : parts) {
+  for (auto &part: parts) {
     escape_quotes_in_identifier(part);
     quote_identifier(part);
   }
   return utils::join(parts, ".");
 }
 
-std::string dialect::prepare_literal(const std::string &str) const
-{
+std::string dialect::prepare_literal(const std::string &str) const {
   std::string result(str);
   escape_quotes_in_literals(result);
   return result;
 }
 
-void dialect::quote_identifier(std::string &str) const
-{
+void dialect::quote_identifier(std::string &str) const {
   str.insert(0, token_at(dialect_token::StartQuote));
   str += token_at(dialect_token::EndQuote);
 }
 
-void dialect::escape_quotes_in_identifier(std::string &str) const
-{
+void dialect::escape_quotes_in_identifier(std::string &str) const {
   const std::string open_char(token_at(dialect_token::StartQuote));
   const std::string close_char(token_at(dialect_token::EndQuote));
   if (identifier_escape_type() == escape_identifier_t::ESCAPE_CLOSING_BRACKET) {
@@ -86,8 +79,7 @@ void dialect::escape_quotes_in_identifier(std::string &str) const
   }
 }
 
-void dialect::escape_quotes_in_literals(std::string &str) const
-{
+void dialect::escape_quotes_in_literals(std::string &str) const {
   const std::string single_quote(token_at(dialect_token::StringQuote));
   const std::string double_quote(token_at(dialect_token::StringQuote) + token_at(dialect_token::StringQuote));
   utils::replace_all(str, single_quote, double_quote);
@@ -101,13 +93,11 @@ void dialect::identifier_escape_type(escape_identifier_t escape_identifier) {
   identifier_escape_type_ = escape_identifier;
 }
 
-std::string dialect::next_placeholder(const std::vector<std::string> &bind_vars) const
-{
+std::string dialect::next_placeholder(const std::vector<std::string> &bind_vars) const {
   return placeholder_func_(bind_vars.size());
 }
 
-std::string dialect::to_escaped_string(const utils::blob &value, const connection_impl *conn) const
-{
+std::string dialect::to_escaped_string(const utils::blob &value, const connection_impl *conn) const {
   if (conn != nullptr) {
     return conn->to_escaped_string(value);
   }
@@ -115,212 +105,211 @@ std::string dialect::to_escaped_string(const utils::blob &value, const connectio
   return to_escaped_string_func_(value);
 }
 
-std::string dialect::default_schema_name() const
-{
+std::string dialect::default_schema_name() const {
   return default_schema_name_;
 }
 
-const std::string& dialect::add_constraint() const {
+const std::string &dialect::add_constraint() const {
   return token_at(dialect_token::AddConstraint);
 }
 
-const std::string& dialect::alter() const {
+const std::string &dialect::alter() const {
   return token_at(dialect_token::Alter);
 }
 
-const std::string& dialect::and_() const {
+const std::string &dialect::and_() const {
   return token_at(dialect_token::And);
 }
 
-const std::string& dialect::as() const {
+const std::string &dialect::as() const {
   return token_at(dialect_token::As);
 }
 
-const std::string& dialect::asc() const {
+const std::string &dialect::asc() const {
   return token_at(dialect_token::Asc);
 }
 
-const std::string& dialect::begin() const {
+const std::string &dialect::begin() const {
   return token_at(dialect_token::Begin);
 }
 
-const std::string& dialect::asterisk() const {
+const std::string &dialect::asterisk() const {
   return token_at(dialect_token::Asterisk);
 }
 
-const std::string& dialect::begin_binary_data() const {
+const std::string &dialect::begin_binary_data() const {
   return token_at(dialect_token::BeginBinaryData);
 }
 
-const std::string& dialect::begin_string_data() const {
+const std::string &dialect::begin_string_data() const {
   return token_at(dialect_token::BeginStringData);
 }
 
-const std::string& dialect::between() const {
+const std::string &dialect::between() const {
   return token_at(dialect_token::Between);
 }
 
-const std::string& dialect::column() const {
+const std::string &dialect::column() const {
   return token_at(dialect_token::Column);
 }
 
-const std::string& dialect::columns() const {
+const std::string &dialect::columns() const {
   return token_at(dialect_token::Columns);
 }
 
-const std::string& dialect::commit() const {
+const std::string &dialect::commit() const {
   return token_at(dialect_token::Commit);
 }
 
-const std::string& dialect::constraint() const {
+const std::string &dialect::constraint() const {
   return token_at(dialect_token::Constraint);
 }
 
-const std::string& dialect::create() const {
+const std::string &dialect::create() const {
   return token_at(dialect_token::Create);
 }
 
-const std::string& dialect::drop() const {
+const std::string &dialect::drop() const {
   return token_at(dialect_token::Drop);
 }
 
-const std::string& dialect::end_binary_data() const {
+const std::string &dialect::end_binary_data() const {
   return token_at(dialect_token::EndBinaryData);
 }
 
-const std::string& dialect::end_string_data() const {
+const std::string &dialect::end_string_data() const {
   return token_at(dialect_token::EndStringData);
 }
 
-const std::string& dialect::from() const {
+const std::string &dialect::from() const {
   return token_at(dialect_token::From);
 }
 
-const std::string& dialect::in() const {
+const std::string &dialect::in() const {
   return token_at(dialect_token::In);
 }
 
-const std::string& dialect::desc() const {
+const std::string &dialect::desc() const {
   return token_at(dialect_token::Desc);
 }
 
-const std::string& dialect::distinct() const {
+const std::string &dialect::distinct() const {
   return token_at(dialect_token::Distinct);
 }
 
-const std::string& dialect::drop_constraint() const {
+const std::string &dialect::drop_constraint() const {
   return token_at(dialect_token::DropConstraint);
 }
 
-const std::string& dialect::end_quote() const {
+const std::string &dialect::end_quote() const {
   return token_at(dialect_token::EndQuote);
 }
 
-const std::string& dialect::foreign_key() const {
+const std::string &dialect::foreign_key() const {
   return token_at(dialect_token::ForeignKey);
 }
 
-const std::string& dialect::group_by() const {
+const std::string &dialect::group_by() const {
   return token_at(dialect_token::GroupBy);
 }
 
-const std::string& dialect::insert() const {
+const std::string &dialect::insert() const {
   return token_at(dialect_token::Insert);
 }
 
-const std::string& dialect::into() const {
+const std::string &dialect::into() const {
   return token_at(dialect_token::Into);
 }
 
-const std::string& dialect::join() const {
+const std::string &dialect::join() const {
   return token_at(dialect_token::Join);
 }
 
-const std::string& dialect::like() const {
+const std::string &dialect::like() const {
   return token_at(dialect_token::Like);
 }
 
-const std::string& dialect::limit() const {
+const std::string &dialect::limit() const {
   return token_at(dialect_token::Limit);
 }
 
-const std::string& dialect::not_() const {
+const std::string &dialect::not_() const {
   return token_at(dialect_token::Not);
 }
 
-const std::string& dialect::not_null() const {
+const std::string &dialect::not_null() const {
   return token_at(dialect_token::NotNull);
 }
 
-const std::string& dialect::offset() const {
+const std::string &dialect::offset() const {
   return token_at(dialect_token::Offset);
 }
 
-const std::string& dialect::on() const {
+const std::string &dialect::on() const {
   return token_at(dialect_token::On);
 }
 
-const std::string& dialect::or_() const {
+const std::string &dialect::or_() const {
   return token_at(dialect_token::Or);
 }
 
-const std::string& dialect::order_by() const {
+const std::string &dialect::order_by() const {
   return token_at(dialect_token::OrderBy);
 }
 
-const std::string& dialect::primary_key() const {
+const std::string &dialect::primary_key() const {
   return token_at(dialect_token::PrimaryKey);
 }
 
-const std::string& dialect::references() const {
+const std::string &dialect::references() const {
   return token_at(dialect_token::References);
 }
 
-const std::string& dialect::remove() const {
+const std::string &dialect::remove() const {
   return token_at(dialect_token::Remove);
 }
 
-const std::string& dialect::rollback() const {
+const std::string &dialect::rollback() const {
   return token_at(dialect_token::Rollback);
 }
 
-const std::string& dialect::schema() const {
+const std::string &dialect::schema() const {
   return token_at(dialect_token::Schema);
 }
 
-const std::string& dialect::select() const {
+const std::string &dialect::select() const {
   return token_at(dialect_token::Select);
 }
 
-const std::string& dialect::set() const {
+const std::string &dialect::set() const {
   return token_at(dialect_token::Set);
 }
 
-const std::string& dialect::start_quote() const {
+const std::string &dialect::start_quote() const {
   return token_at(dialect_token::StartQuote);
 }
 
-const std::string& dialect::string_quote() const {
+const std::string &dialect::string_quote() const {
   return token_at(dialect_token::StringQuote);
 }
 
-const std::string& dialect::table() const {
+const std::string &dialect::table() const {
   return token_at(dialect_token::Table);
 }
 
-const std::string & dialect::unique() const {
+const std::string &dialect::unique() const {
   return token_at(dialect_token::Unique);
 }
 
-const std::string& dialect::update() const {
+const std::string &dialect::update() const {
   return token_at(dialect_token::Update);
 }
 
-const std::string& dialect::values() const {
+const std::string &dialect::values() const {
   return token_at(dialect_token::Values);
 }
 
-const std::string& dialect::where() const {
+const std::string &dialect::where() const {
   return token_at(dialect_token::Where);
 }
 }