insert_query_builder progress

2026-04-12 22:07:24 +02:00
parent f03664d60a
commit a0326632ab
25 changed files with 319 additions and 124 deletions
@@ -280,6 +280,8 @@ std::vector<utils::placeholder> placeholders(const Type &obj) {
  return generator.generate(obj);
 }

+std::vector<utils::placeholder> placeholders(size_t num);
+
 template<typename Type>
 std::vector<internal::column_value_pair> column_value_pairs(const Type &obj, const column_value_generator_options options = column_value_generator_options::None) {
  column_value_generator generator(options);
@@ -1,20 +1,65 @@
 #ifndef MATADOR_INSERT_QUERY_BUILDER_HPP
 #define MATADOR_INSERT_QUERY_BUILDER_HPP

+#include <utility>
+
 #include "matador/query/basic_schema.hpp"
 #include "matador/query/intermediates/executable_query.hpp"
 #include "matador/query/query.hpp"
+#include "matador/query/query_contexts.hpp"
 #include "matador/query/query_builder_exception.hpp"

+#include "matador/sql/statement.hpp"
+
 #include "matador/utils/primary_key_accessor.hpp"

+namespace matador::sql {
+class statement_cache;
+}
+
 namespace matador::query {
+template < class ObjectType >
+class has_many_linker {
+public:
+  has_many_linker(const object::object_ptr<ObjectType> &ptr, std::string join_column)
+  : ptr_(ptr), join_column_(std::move(join_column)) {}
+  template < class PrimaryKeyType >
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &, const utils::primary_key_attribute& /*attr*/) {}
+  static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
+  template<typename Type>
+  static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}
+  template<class Pointer>
+  static void on_belongs_to(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
+  void on_belongs_to(const char *id, object::object_ptr<ObjectType> &obj, const utils::foreign_attributes &/*attr*/) {
+    if (id != join_column_) {
+      return;
+    }
+
+    obj = ptr_;
+  }
+  template<class Pointer>
+  static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
+  template<class CollectionType>
+  static void on_has_many(const char * /*id*/, CollectionType &/*con*/, const char *, const utils::foreign_attributes &/*attr*/, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {}
+  template<class Collection>
+  static void on_has_many_to_many(const char * /*id*/, Collection &/*container*/, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes & ) {}
+  template<class Collection>
+  static void on_has_many_to_many(const char * /*id*/, Collection &/*container*/, const utils::foreign_attributes & ) {}
+
+private:
+  object::object_ptr<ObjectType> ptr_;
+  std::string join_column_;
+};
+
+
 class insert_query_builder {
 public:
  using step_query_t = std::variant<executable_query, fetchable_query>;

  struct insert_step {
-    step_query_t query;
+    sql::query_context ctx;
+
+    utils::result<sql::statement, utils::error> acquire_and_bind(sql::statement_cache &cache) const;

    // Session uses these to handle manual/sequence/table pre-insert PKs
    utils::generator_type pk_generator{utils::generator_type::Manual};
@@ -22,10 +67,11 @@ public:

    // Identity post-insert
    std::function<void(const sql::record &)> apply_returning{};
+    std::function<void(sql::statement &)> bind_object{};
  };

 public:
-  explicit insert_query_builder(const basic_schema &schema);
+  explicit insert_query_builder(const basic_schema &schema, const std::unordered_map<std::type_index, query_contexts> &contexts_by_type);

  template<class EntityType>
  utils::result<std::vector<insert_step>, query_build_error> build(const object::object_ptr<EntityType> &ptr) {
@@ -47,10 +93,9 @@ public:
    return utils::ok(steps_);
  }

-  template < class V >
-  static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
+  template < class PrimaryKeyType >
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &, const utils::primary_key_attribute& /*attr*/) {}
  static void on_revision(const char *id, uint64_t &/*rev*/);
-
  template<typename Type>
  static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}

@@ -165,10 +210,16 @@ private:
      step.pk_generator = it->second.pk_generator().type();
    }

+    const auto cit = contexts_by_type_.find(it->second.node().info().type_index());
+    if (cit == contexts_by_type_.end()) {
+      throw query_builder_exception(query_build_error::UnknownType);
+    }
+    step.ctx = cit->second.insert;
+    step.bind_object = [ptr](sql::statement &stmt) { stmt.bind(*ptr); };
    if (info.has_primary_key() && step.pk_generator == utils::generator_type::Identity) {
      const auto pk_name = info.primary_key_attribute()->name();
      const table_column pk_col(&it->second.table(), pk_name);
-      step.query = fetchable_query{insert().into(it->second.table()).values(*ptr).returning(pk_col)};
+      // step.query = fetchable_query{insert().into(it->second.table()).values(*ptr).returning(pk_col)};
      step.apply_returning = [ptr, &step, pk_name = pk_name](const sql::record &rec) {
        const auto& f = rec.at(pk_name);
        utils::identifier id;
@@ -176,7 +227,7 @@ private:
        step.pk_accessor.set(*ptr, id);
      };
    } else {
-      step.query = executable_query{insert().into(it->second.table()).values(*ptr)};
+      // step.query = executable_query{insert().into(it->second.table()).values(*ptr)};
    }
    steps_.push_back(std::move(step));
  }
@@ -197,6 +248,7 @@ private:
  }
 private:
  const basic_schema &schema_;
+  const std::unordered_map<std::type_index, query_contexts> &contexts_by_type_;

  std::vector<insert_step> steps_;
  std::vector<insert_step> relation_steps_;
@@ -7,6 +7,7 @@
 #include "../../utils/result.hpp"

 namespace matador::sql {
+class dialect;
 class executor;
 class statement;
 struct execute_result;
@@ -21,7 +22,7 @@ public:

  [[nodiscard]] utils::result<sql::execute_result, utils::error> execute(const sql::executor &exec) const;
  [[nodiscard]] utils::result<sql::statement, utils::error> prepare(sql::executor &exec) const;
-  [[nodiscard]] sql::query_context compile(const sql::executor &exec) const;
+  [[nodiscard]] sql::query_context compile(const sql::dialect &d) const;
  [[nodiscard]] std::string str(const sql::executor &exec) const;
 };

@@ -0,0 +1,15 @@
+#ifndef MATADOR_QUERY_CONTEXTS_HPP
+#define MATADOR_QUERY_CONTEXTS_HPP
+
+#include "matador/sql/query_context.hpp"
+
+namespace matador::query {
+struct query_contexts {
+  sql::query_context insert;
+  sql::query_context update_one;
+  sql::query_context delete_one;
+  sql::query_context select_one;
+  sql::query_context select_all;
+};
+}
+#endif //MATADOR_QUERY_CONTEXTS_HPP
@@ -256,8 +256,8 @@ public:
  void dump(std::ostream &os) const;

 private:
-  [[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::connection &conn) ;
-  [[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::connection &conn) ;
+  [[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
+  [[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;

  iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type);

@@ -1,6 +1,8 @@
 #ifndef QUERY_TABLE_HPP
 #define QUERY_TABLE_HPP

+#include <optional>
+
 #include "matador/query/table_column.hpp"

 #include <string>
@@ -41,11 +43,12 @@ public:
  [[nodiscard]] bool is_relation_table() const;
  [[nodiscard]] bool has_primary_key() const;

+  [[nodiscard]] std::optional<table_column*> primary_key_column() const;
  [[nodiscard]] const std::string& join_column_name() const;
  [[nodiscard]] const std::string& inverse_join_column_name() const;

 protected:
-  static const table_column& create_column(class table& tab, const std::string& name);
+  // static const table_column& create_column(class table& tab, const std::string& name);

  table(std::string  name, std::string  alias, const std::vector<table_column>& columns);

@@ -58,7 +61,7 @@ private:
  std::string schema_name_;
  std::vector<table_column> columns_;

-  std::string pk_column_name_;
+  std::optional<table_column*> pk_column_{std::nullopt};
  std::string join_column_name_;
  std::string inverse_join_column_name_;
 };
@@ -91,6 +91,11 @@ public:

  [[nodiscard]] bool is_function() const;
  [[nodiscard]] bool is_nullable() const;
+  [[nodiscard]] bool is_primary_key() const;
+  [[nodiscard]] bool is_foreign_key() const;
+  [[nodiscard]] bool is_unique() const;
+  [[nodiscard]] bool is_identity() const;
+
  [[nodiscard]] sql::sql_function_t function() const;
  [[nodiscard]] bool has_alias() const;