added date_type_t, time_type_t and timestamp, ensure allocated postgres resources are released, split repository into basic_repository and repository.

2026-01-06 15:43:20 +01:00
parent f07a360da2
commit 0c6b5a0a93
60 changed files with 1132 additions and 1225 deletions
@@ -67,12 +67,15 @@ void attribute_string_writer::write_value(size_t /*pos*/, const double& x ) {
  }
 }

-void attribute_string_writer::write_value(size_t /*pos*/, const time& /*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 date& /*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 ) {
@@ -1,10 +1,10 @@
 #include "matador/query/generator.hpp"

 namespace matador::query::generator {
-column_generator::column_generator(const schema& repo, const std::string& table_name, const column_generator_options options)
+column_generator::column_generator(const schema& repo, const table* tab, const column_generator_options options)
 : repo_(std::cref(repo))
 , options_(options) {
-  table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
+  table_stack_.push(tab);
 }

 void column_generator::on_revision(const char* id, uint64_t&) {
@@ -15,9 +15,9 @@ void column_generator::push( const std::string& column_name ) {
  if (is_column_generator_option_set(options_, column_generator_options::GenerateAlias)) {
      char str[4];
      snprintf(str, 4, "c%02d", ++column_index);
-      result_.emplace_back(table_stack_.top().get(), column_name, str);
+      result_.emplace_back(table_stack_.top(), column_name, str);
  } else {
-      result_.emplace_back(table_stack_.top().get(), column_name);
+      result_.emplace_back(table_stack_.top(), column_name);
  }
 }

@@ -11,10 +11,10 @@ query_insert_intermediate::query_insert_intermediate() {
 }

 query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<table_column> columns) {
-  return into(tab, std::move(std::vector<table_column>{columns}));
+  return into(tab, {columns});
 }

-query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector<table_column> &&columns) {
+query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<table_column> &columns) {
  context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, columns));
  return {context_};
 }
@@ -25,7 +25,7 @@ query_into_intermediate query_insert_intermediate::into(const table &tab, const
  for (const auto &col_name : column_names) {
    columns.emplace_back(col_name);
  }
-  return into(tab, std::move(columns));
+  return into(tab, columns);
 }

 query_into_intermediate query_insert_intermediate::into(const table &tab) {
@@ -9,8 +9,8 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu
 , value_(std::move(value)) {
 }

-column_value_pair::column_value_pair(const table_column &col, utils::database_type value)
-: column_(col)
+column_value_pair::column_value_pair(table_column col, utils::database_type value)
+: column_(std::move(col))
 , value_(std::move(value)) {
 }

@@ -36,6 +36,7 @@ bool operator==( const column_value_pair& lhs, const column_value_pair& rhs ) {
 }

 bool operator!=( const column_value_pair& lhs, const column_value_pair& rhs ) {
+  using namespace matador::utils;
  return !( lhs == rhs );
 }
 }
@@ -70,8 +70,8 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
  // create plain tables without constraints
  for (const auto &node: repo_) {
    auto ctx = query::query::create()
-        .table(node->name())
-        .columns(node->info().attributes())
+        .table(node.name())
+        .columns(node.info().attributes())
        // .constraints(node->info().constraints())
        .compile(conn);

@@ -83,11 +83,11 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co

  // create primary key constraints
  for (const auto &node: repo_) {
-    for (const auto &cons: node->info().constraints()) {
+    for (const auto &cons: node.info().constraints()) {
      if (!cons.is_primary_key_constraint()) {
        continue;
      }
-      auto ctx = build_add_constraint_context(*node, cons, conn);
+      auto ctx = build_add_constraint_context(node, cons, conn);

      std::cout << ctx.sql << std::endl;
      if (auto result = conn.execute(ctx.sql); !result) {
@@ -97,11 +97,11 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
  }
  // create table constraints
  for (const auto &node: repo_) {
-    for (const auto &cons: node->info().constraints()) {
+    for (const auto &cons: node.info().constraints()) {
      if (cons.is_primary_key_constraint()) {
        continue;
      }
-      auto ctx = build_add_constraint_context(*node, cons, conn);
+      auto ctx = build_add_constraint_context(node, cons, conn);

      std::cout << ctx.sql << std::endl;
      if (auto result = conn.execute(ctx.sql); !result) {
@@ -115,12 +115,12 @@ utils::result<void, utils::error> schema::create(const sql::connection &conn) co
 utils::result<void, utils::error> schema::drop(const sql::connection &conn) const {
  // drop table primary key constraints
  for (const auto &node: repo_) {
-    for (const auto &cons: node->info().constraints()) {
+    for (const auto &cons: node.info().constraints()) {
      if (cons.is_primary_key_constraint()) {
        continue;
      }
      auto ctx = query::query::alter()
-          .table(node->name())
+          .table(node.name())
          .drop_constraint(cons)
          .compile(conn);

@@ -133,12 +133,12 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons

  // drop table constraints
  for (const auto &node: repo_) {
-    for (const auto &cons: node->info().constraints()) {
+    for (const auto &cons: node.info().constraints()) {
      if (!cons.is_primary_key_constraint()) {
        continue;
      }
      auto ctx = query::query::alter()
-          .table(node->name())
+          .table(node.name())
          .drop_constraint(cons)
          .compile(conn);

@@ -152,7 +152,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
  // drop table
  for (const auto &node: repo_) {
    auto ctx = query::query::drop()
-        .table(node->name())
+        .table(node.name())
        .compile(conn);

    std::cout << ctx.sql << std::endl;
@@ -164,7 +164,7 @@ utils::result<void, utils::error> schema::drop(const sql::connection &conn) cons
  return utils::ok<void>();
 }

-utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) const {
+utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) {
  auto result = query::query::drop()
      .table(table_name)
      .execute(conn);
@@ -176,17 +176,11 @@ utils::result<void, utils::error> schema::drop_table(const std::string &table_na
 }

 utils::result<std::vector<object::attribute>, utils::error>
-schema::describe_table(const std::string &table_name, const sql::connection &conn) const {
-  // if (!conn.valid()) {
-    // return utils::failure(utils::error(sql::error_code::FAILURE, "Failed to acquire connection."));
-  // }
+schema::describe_table(const std::string &table_name, const sql::connection &conn) {
  return utils::ok(conn.describe(table_name).release());
 }

 utils::result<bool, utils::error> schema::table_exists(const std::string &table_name, const sql::connection &conn) const {
-  // if (!c.valid()) {
-    // return utils::failure(utils::error(sql::error_code::FAILURE, "Failed to acquire connection."));
-  // }
  return conn.exists(repo_.name(), table_name);
 }

@@ -1,119 +1,98 @@
 #include "matador/query/value_extractor.hpp"

 namespace matador::query {
-
 value_extractor::value_extractor(std::vector<utils::database_type> &values)
-: values_(values)
-{}
+: values_(values) {
+}

-void value_extractor::on_revision(const char *, uint64_t &rev)
-{
+void value_extractor::on_revision(const char *, uint64_t &rev) {
  utils::data_type_traits<uint64_t>::bind_value(*this, 0, rev);
 }

-void value_extractor::on_attribute(const char *, char *x, const utils::field_attributes &attr)
-{
-  utils::data_type_traits<char*>::bind_value(*this, 0, x, attr.size());
+void value_extractor::on_attribute(const char *, char *x, const utils::field_attributes &attr) {
+  utils::data_type_traits<char *>::bind_value(*this, 0, x, attr.size());
 }

-void value_extractor::on_attribute(const char *, std::string &x, const utils::field_attributes &attr)
-{
+void value_extractor::on_attribute(const char *, std::string &x, const utils::field_attributes &attr) {
  utils::data_type_traits<std::string>::bind_value(*this, 0, x, attr.size());
 }

-void value_extractor::write_value(size_t /*pos*/, const int8_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const int8_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const int16_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const int16_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const int32_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const int32_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const int64_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const int64_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const uint8_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const uint8_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const uint16_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const uint16_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const uint32_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const uint32_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const uint64_t &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const uint64_t &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const bool &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const bool &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const float &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const float &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const double &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const double &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const time &/*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 date &/*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 char *x)
-{
+void value_extractor::write_value(size_t /*pos*/, const utils::timestamp &/*x*/) {
+}
+
+void value_extractor::write_value(size_t /*pos*/, const char *x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const char *x, size_t /*size*/)
-{
+void value_extractor::write_value(size_t /*pos*/, const char *x, size_t /*size*/) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const std::string &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const std::string &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const std::string &x, size_t /*size*/)
-{
+void value_extractor::write_value(size_t /*pos*/, const std::string &x, size_t /*size*/) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const utils::blob &x)
-{
+void value_extractor::write_value(size_t /*pos*/, const utils::blob &x) {
  values_.emplace_back(x);
 }

-void value_extractor::write_value(size_t /*pos*/, const utils::value &/*x*/, size_t /*size*/)
-{
-//  values_.emplace_back(x);
+void value_extractor::write_value(size_t /*pos*/, const utils::value &/*x*/, size_t /*size*/) {
+  //  values_.emplace_back(x);
+}
 }
-
-}