column_expression progress

2026-03-06 15:39:53 +01:00
parent 9b4738a5ff
commit 2aff0cabbb
20 changed files with 104 additions and 53 deletions
@@ -228,7 +228,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::update(const obje

  const auto col = table_column(it->second.node().info().primary_key_attribute()->name());
  auto res = matador::query::query::update(it->second.name())
-    .set(generator::column_value_pairs<Type>())
+    .set<Type>()
    .where(col == _)
    .prepare(*this);
  if (!res) {
@@ -15,7 +15,7 @@ public:
    [[nodiscard]] const table_column& col() const;

 protected:
-    const table_column& column_;
+    table_column column_;
 };

 }
@@ -34,7 +34,7 @@ private:
 class binary_column_criteria final : public abstract_criteria {
 public:
    binary_column_criteria() = delete;
-    binary_column_criteria(const table_column& left_column, binary_operator operand, const table_column& right_column);
+    binary_column_criteria(table_column  left_column, binary_operator operand, table_column  right_column);

    void accept(criteria_visitor& visitor) const override;

@@ -43,9 +43,9 @@ public:
    [[nodiscard]] const table_column& right_column() const;

 private:
-    const table_column& left_column_;
+    table_column left_column_;
    binary_operator operator_{};
-    const table_column& right_column_;
+    table_column right_column_;
 };
 }
 #endif //CRITERIA_BINARY_CRITERIA_NODE_HPP
@@ -17,8 +17,8 @@ public:
    template<typename Type, typename = std::enable_if_t<std::is_convertible_v<Type, utils::database_type>>>
    column_expression(Type&& value)
    : column_expression(std::make_unique<value_expression>(std::forward<Type>(value))){
-
    }
+    column_expression(utils::placeholder p);
    column_expression(const column_expression&) = delete;
    column_expression& operator=(const column_expression&) = delete;
    column_expression(column_expression&&) noexcept = default;
@@ -8,14 +8,14 @@ namespace matador::query {
 class table_column_expression : public abstract_column_expression {
 public:
  table_column_expression() = delete;
-  explicit table_column_expression(const table_column& col);
+  explicit table_column_expression(table_column col);

  void accept(expression_visitor& visitor) const override;

  [[nodiscard]] const table_column& col() const;

 private:
-  const table_column& column_;
+  table_column column_;
 };
 }
 #endif //MATADOR_TABLE_COLUMN_EXPRESSION_HPP
@@ -19,6 +19,8 @@ public:
    void visit(const value_expression& node) override;
    void visit(const placeholder_expression& node) override;

+    const std::string& result() const;
+
 private:
    const sql::dialect &dialect_;
    sql::query_context &query_;
@@ -224,7 +224,7 @@ public:
      result_.clear();
      access::process(*this, obj);

-      return result_;
+      return std::move(result_);
  }

  template < class V >
@@ -5,30 +5,35 @@
 #include "matador/query/intermediates/query_set_intermediate.hpp"

 #include "matador/query/expression/column_expression.hpp"
-#include "matador/query/key_value_generator.hpp"
+#include "matador/query/generator.hpp"

 #include "matador/query/internal/column_value_pair.hpp"

 namespace matador::query {
-
+namespace internal {
+class query_set_part;
+}
 class query_update_intermediate : public executable_query {
 public:
  explicit query_update_intermediate(const table& tab);

-  // query_set_intermediate set(std::initializer_list<internal::column_value_pair> columns);
-  // query_set_intermediate set(std::vector<internal::column_value_pair> &&columns);
  query_update_intermediate& set(const table_column& col, column_expression&& expression);
  template<class Type>
  query_set_intermediate set(const Type &obj) {
-    return set(key_value_generator::generate(obj));
+    return set(generator::column_value_pairs(obj));
+  }
+  template<class Type>
+  query_set_intermediate set() {
+    return set(generator::column_value_pairs<Type>());
  }
  query_execute_where_intermediate where(std::unique_ptr<abstract_criteria> cond);

 private:
  query_execute_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);
+  query_set_intermediate set(std::vector<internal::column_value_pair> &&key_value_pairs);

 private:
-  std::vector<internal::column_value_pair> key_value_pairs_;
+  internal::query_set_part* query_set_part_{nullptr};
 };

 }
@@ -11,10 +11,13 @@ namespace matador::query::internal {

 class column_value_pair {
 public:
+  column_value_pair() = default;
  // column_value_pair(table_column col, utils::database_type value);
  // column_value_pair(const std::string& name, utils::database_type value);
  // column_value_pair(const char *name, utils::database_type value);
  // column_value_pair(const char *name, utils::placeholder p);
+  column_value_pair(column_value_pair&& x) = default;
+  column_value_pair& operator=(column_value_pair&& x) = default;
  column_value_pair(table_column col, column_expression_ptr expression);

  friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs);
@@ -83,8 +83,10 @@ protected:

  static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
  static std::string build_table_name(const sql::dialect &d, const table& t);
+  static std::string determine_value(const sql::dialect &d, sql::query_context& ctx, const abstract_column_expression &exp);
  static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);

+
  [[nodiscard]] std::string build_add_constraint_string(const table_constraint& c) const;
  [[nodiscard]] std::string build_drop_constraint_string(const table_constraint& c) const;
  static std::string build_constraint_name(const table_constraint& c);
@@ -17,6 +17,7 @@ class table;
 // ReSharper disable CppNonExplicitConvertingConstructor
 class table_column {
 public:
+  table_column() = default;
  table_column(const char *name); // NOLINT(*-explicit-constructor)
  table_column(const std::string& name); // NOLINT(*-explicit-constructor)
  table_column(const std::string& name, const std::string& alias);