initial matador ng commit

test/orm/backend/test_backend_service.cpp

@@ -0,0 +1,31 @@
+#include "test_backend_service.hpp"
+#include "test_connection.hpp"
+
+#include "matador/sql/dialect_builder.hpp"
+
+#include <algorithm>
+
+namespace matador::test::orm {
+
+sql::connection_impl *test_backend_service::create(const sql::connection_info &info)
+{
+  return noop_connections_.insert(std::make_unique<test_connection>(info)).first->get();
+}
+
+void test_backend_service::destroy(sql::connection_impl *impl)
+{
+  auto it = std::find_if(noop_connections_.begin(), noop_connections_.end(), [impl](const auto &item) {
+    return impl == item.get();
+  });
+  if (it != noop_connections_.end()) {
+    noop_connections_.erase(it);
+  }
+}
+
+const sql::dialect *test_backend_service::dialect() const
+{
+  static sql::dialect dialect_ = sql::dialect_builder::builder().create().build();
+  return &dialect_;
+}
+
+}

test/orm/backend/test_backend_service.hpp

@@ -0,0 +1,22 @@
+#ifndef NOOP_BACKEND_SERVICE_HPP
+#define NOOP_BACKEND_SERVICE_HPP
+
+#include "matador/sql/backend_provider.hpp"
+
+#include <unordered_set>
+
+namespace matador::test::orm {
+
+class test_backend_service final : public sql::backend_provider::basic_backend_service {
+public:
+  sql::connection_impl *create(const sql::connection_info &info) override;
+  void destroy(sql::connection_impl *impl) override;
+  [[nodiscard]] const sql::dialect *dialect() const override;
+
+private:
+  std::unordered_set<std::unique_ptr<sql::connection_impl>> noop_connections_;
+};
+
+}
+
+#endif //NOOP_BACKEND_SERVICE_HPP

test/orm/backend/test_connection.cpp

@@ -0,0 +1,80 @@
+#include "test_connection.hpp"
+#include "test_result_reader.hpp"
+
+#include "matador/sql/query_context.hpp"
+#include "matador/sql/record.hpp"
+
+#include "matador/sql/internal/query_result_impl.hpp"
+
+#include "matador/sql/interface/statement_impl.hpp"
+
+#include "matador/utils/string.hpp"
+
+#include <string>
+#include <memory>
+
+namespace matador::test::orm {
+test_connection::test_connection(const sql::connection_info &info)
+: connection_impl(info) {}
+
+utils::result<void, utils::error> test_connection::open()
+{
+  is_open_ = true;
+  return utils::ok<void>();
+}
+
+utils::result<void, utils::error> test_connection::close()
+{
+  is_open_ = false;
+  return utils::ok<void>();
+}
+
+utils::result<bool, utils::error> test_connection::is_open() const
+{
+  return utils::ok(is_open_);
+}
+
+utils::result<bool, utils::error> test_connection::is_valid() const
+{
+  return is_open();
+}
+
+utils::result<utils::version, utils::error> test_connection::client_version() const {
+  return utils::ok(utils::version{1, 2, 3});
+}
+
+utils::result<utils::version, utils::error> test_connection::server_version() const {
+  return utils::ok(utils::version{3, 2, 1});
+}
+
+utils::result<size_t, utils::error> test_connection::execute(const std::string &/*stmt*/)
+{
+  return utils::ok(static_cast<size_t>(4));
+}
+
+utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> test_connection::fetch(const sql::query_context &context)
+{
+  return utils::ok(std::make_unique<sql::query_result_impl>(std::make_unique<test_result_reader>(), context.prototype, context.prototype.size()));
+}
+
+utils::result<std::unique_ptr<sql::statement_impl>, utils::error> test_connection::prepare(const sql::query_context &/*context*/)
+{
+  return utils::ok(std::unique_ptr<sql::statement_impl>{});
+}
+
+utils::result<std::vector<sql::column_definition>, utils::error> test_connection::describe(const std::string &/*table*/)
+{
+  return utils::ok(std::vector<sql::column_definition>{});
+}
+
+utils::result<bool, utils::error> test_connection::exists(const std::string &/*schema_name*/, const std::string &/*table_name*/)
+{
+  return utils::ok(false);
+}
+
+std::string test_connection::to_escaped_string(const utils::blob& value) const
+{
+  return utils::to_string(value);
+}
+
+}

test/orm/backend/test_connection.hpp

@@ -0,0 +1,32 @@
+#ifndef QUERY_NOOP_CONNECTION_HPP
+#define QUERY_NOOP_CONNECTION_HPP
+
+#include "matador/sql/interface/connection_impl.hpp"
+
+namespace matador::test::orm {
+
+class test_connection final : public sql::connection_impl
+{
+public:
+  explicit test_connection(const sql::connection_info &info);
+
+  utils::result<void, utils::error> open() override;
+  utils::result<void, utils::error> close() override;
+  [[nodiscard]] utils::result<bool, utils::error> is_open() const override;
+  [[nodiscard]] utils::result<bool, utils::error> is_valid() const override;
+  [[nodiscard]] utils::result<utils::version, utils::error> client_version() const override;
+  [[nodiscard]] utils::result<utils::version, utils::error> server_version() const override;
+  utils::result<size_t, utils::error> execute(const std::string &stmt) override;
+  utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::query_context &context) override;
+  utils::result<std::unique_ptr<sql::statement_impl>, utils::error> prepare(const sql::query_context &context) override;
+  utils::result<std::vector<sql::column_definition>, utils::error> describe(const std::string &table) override;
+  utils::result<bool, utils::error> exists(const std::string &schema_name, const std::string &table_name) override;
+
+  [[nodiscard]] std::string to_escaped_string( const utils::blob& value ) const override;
+
+private:
+  bool is_open_{false};
+};
+
+}
+#endif //QUERY_NOOP_CONNECTION_HPP

test/orm/backend/test_parameter_binder.cpp

@@ -0,0 +1,23 @@
+#include "test_parameter_binder.hpp"
+
+namespace matador::test::orm {
+void test_parameter_binder::write_value(size_t pos, const int8_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const int16_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const int32_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const int64_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const uint8_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const uint16_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const uint32_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const uint64_t &x) {}
+void test_parameter_binder::write_value(size_t pos, const bool &x) {}
+void test_parameter_binder::write_value(size_t pos, const float &x) {}
+void test_parameter_binder::write_value(size_t pos, const double &x) {}
+void test_parameter_binder::write_value(size_t pos, const time &x) {}
+void test_parameter_binder::write_value(size_t pos, const date &x) {}
+void test_parameter_binder::write_value(size_t pos, const char *x) {}
+void test_parameter_binder::write_value(size_t pos, const char *x, size_t size) {}
+void test_parameter_binder::write_value(size_t pos, const std::string &x) {}
+void test_parameter_binder::write_value(size_t pos, const std::string &x, size_t size) {}
+void test_parameter_binder::write_value(size_t pos, const utils::blob &x) {}
+void test_parameter_binder::write_value(size_t pos, const utils::value &x, size_t size) {}
+}

test/orm/backend/test_parameter_binder.hpp

@@ -0,0 +1,33 @@
+#ifndef TEST_PARAMETER_BINDER_HPP
+#define TEST_PARAMETER_BINDER_HPP
+
+#include "matador/utils/attribute_writer.hpp"
+
+namespace matador::test::orm {
+
+class test_parameter_binder final : public utils::attribute_writer {
+public:
+  void write_value(size_t pos, const int8_t &x) override;
+  void write_value(size_t pos, const int16_t &x) override;
+  void write_value(size_t pos, const int32_t &x) override;
+  void write_value(size_t pos, const int64_t &x) override;
+  void write_value(size_t pos, const uint8_t &x) override;
+  void write_value(size_t pos, const uint16_t &x) override;
+  void write_value(size_t pos, const uint32_t &x) override;
+  void write_value(size_t pos, const uint64_t &x) override;
+  void write_value(size_t pos, const bool &x) override;
+  void write_value(size_t pos, const float &x) override;
+  void write_value(size_t pos, const double &x) override;
+  void write_value(size_t pos, const time &x) override;
+  void write_value(size_t pos, const date &x) override;
+  void write_value(size_t pos, const char *x) override;
+  void write_value(size_t pos, const char *x, size_t size) override;
+  void write_value(size_t pos, const std::string &x) override;
+  void write_value(size_t pos, const std::string &x, size_t size) override;
+  void write_value(size_t pos, const utils::blob &x) override;
+  void write_value(size_t pos, const utils::value &x, size_t size) override;
+};
+
+}
+
+#endif //TEST_PARAMETER_BINDER_HPP

test/orm/backend/test_result_reader.cpp

@@ -0,0 +1,92 @@
+#include "test_result_reader.hpp"
+
+#include "matador/utils/value.hpp"
+
+namespace matador::test::orm {
+
+size_t test_result_reader::column_count() const {
+  return 10;
+}
+
+const char *test_result_reader::column(size_t index) const {
+  return "";
+}
+
+utils::result<bool, utils::error> test_result_reader::fetch() { return utils::ok(rows_-- > 0); }
+
+size_t test_result_reader::start_column_index() const {
+  return 0;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, int8_t &value) {
+  value = -8;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, int16_t &value) {
+  value = -16;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, int32_t &value) {
+  value = -32;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, int64_t &value) {
+  value = -64;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, uint8_t &value) {
+  value = 8;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, uint16_t &value) {
+  value = 16;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, uint32_t &value) {
+  value = 32;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, uint64_t &value) {
+  value = 64;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, bool &value) {
+  value = true;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, float &value) {
+  value = 3.141572f;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, double &value) {
+  value = 2.14159265358979323846;
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, matador::time &value) {
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, matador::date &value) {
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, char *value, const size_t size) {
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, std::string &value) {
+  value = "Lorem ipsum";
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, std::string &value, const size_t size) {
+  value = "Hello world";
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, utils::blob &value) {
+  value = {'b', 'l', 'o', 'b'};
+}
+
+void test_result_reader::read_value(const char *id, const size_t index, utils::value &val, const size_t size) {
+  val = "value";
+}
+utils::attribute_reader &test_result_reader::result_binder() {
+  return query_result_reader::result_binder();
+}
+} // namespace matador::test::orm

test/orm/backend/test_result_reader.hpp

@@ -0,0 +1,43 @@
+#ifndef TEST_RESULT_READER_HPP
+#define TEST_RESULT_READER_HPP
+
+#include "matador/sql/interface/query_result_reader.hpp"
+
+namespace matador::test::orm {
+
+class test_result_reader final : public sql::query_result_reader {
+public:
+  [[nodiscard]] size_t column_count() const override;
+  [[nodiscard]] const char *column(size_t index) const override;
+  [[nodiscard]] utils::result<bool, utils::error> fetch() override;
+  [[nodiscard]] size_t start_column_index() const override;
+
+  void read_value(const char *id, size_t index, int8_t &value) override;
+  void read_value(const char *id, size_t index, int16_t &value) override;
+  void read_value(const char *id, size_t index, int32_t &value) override;
+  void read_value(const char *id, size_t index, int64_t &value) override;
+  void read_value(const char *id, size_t index, uint8_t &value) override;
+  void read_value(const char *id, size_t index, uint16_t &value) override;
+  void read_value(const char *id, size_t index, uint32_t &value) override;
+  void read_value(const char *id, size_t index, uint64_t &value) override;
+  void read_value(const char *id, size_t index, bool &value) override;
+  void read_value(const char *id, size_t index, float &value) override;
+  void read_value(const char *id, size_t index, double &value) override;
+  void read_value(const char *id, size_t index, matador::time &value) override;
+  void read_value(const char *id, size_t index, matador::date &value) override;
+  void read_value(const char *id, size_t index, char *value, size_t size) override;
+  void read_value(const char *id, size_t index, std::string &value) override;
+  void read_value(const char *id, size_t index, std::string &value, size_t size) override;
+  void read_value(const char *id, size_t index, utils::blob &value) override;
+  void read_value(const char *id, size_t index, utils::value &val, size_t size) override;
+
+protected:
+  attribute_reader &result_binder() override;
+
+private:
+  uint8_t rows_{5};
+};
+
+}
+
+#endif //TEST_RESULT_READER_HPP

test/orm/backend/test_statement.cpp

@@ -0,0 +1,22 @@
+#include "test_statement.hpp"
+#include "test_result_reader.hpp"
+
+namespace matador::test::orm {
+test_statement::test_statement(const sql::query_context &query)
+: statement_impl(query) {}
+
+utils::result<size_t, utils::error> test_statement::execute() {
+  return utils::ok(static_cast<size_t>(8));
+}
+
+utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> test_statement::fetch() {
+  return utils::ok(std::make_unique<sql::query_result_impl>(std::make_unique<test_result_reader>(), query_.prototype, query_.prototype.size()));
+}
+
+void test_statement::reset() {}
+
+utils::attribute_writer &test_statement::binder() {
+  return binder_;
+}
+
+} // namespace matador::test::orm

test/orm/backend/test_statement.hpp

@@ -0,0 +1,26 @@
+#ifndef TEST_STATEMENT_HPP
+#define TEST_STATEMENT_HPP
+
+#include "test_parameter_binder.hpp"
+
+#include "matador/sql/interface/statement_impl.hpp"
+
+namespace matador::test::orm {
+
+class test_statement final : public sql::statement_impl {
+public:
+  explicit test_statement(const sql::query_context &query);
+  utils::result<size_t, utils::error> execute() override;
+  utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch() override;
+  void reset() override;
+
+protected:
+  utils::attribute_writer &binder() override;
+
+private:
+  test_parameter_binder binder_;
+};
+
+}
+
+#endif //TEST_STATEMENT_HPP