column_expression progress

source/orm/query/expression/column_expression.cpp

@@ -25,7 +25,7 @@ column_expression::operator std::unique_ptr<abstract_column_expression>() && noe
 }
 
 table_column column_expression::as(const std::string& alias) && {
-    const table_column col{std::move(expression_)};
+    const table_column col{std::shared_ptr<abstract_column_expression>(expression_.release())};
     return col.as(alias);
 }
 }

source/orm/query/internal/column_value_pair.cpp

@@ -4,24 +4,24 @@
 
 namespace matador::query::internal {
 
-column_value_pair::column_value_pair(const std::string& name, utils::database_type value)
-: column_(name)
-, value_(std::move(value)) {
-}
-
-column_value_pair::column_value_pair(table_column col, utils::database_type value)
-: column_(std::move(col))
-, value_(std::move(value)) {
-}
-
-column_value_pair::column_value_pair(const char *name, utils::database_type value)
-: column_(name)
-, value_(std::move(value)) {
-}
-
-column_value_pair::column_value_pair( const char* name, utils::placeholder p )
-: column_(name)
-, value_(p) {}
+// column_value_pair::column_value_pair(const std::string& name, utils::database_type value)
+// : column_(name)
+// , value_(std::move(value)) {
+// }
+//
+// column_value_pair::column_value_pair(table_column col, utils::database_type value)
+// : column_(std::move(col))
+// , value_(std::move(value)) {
+// }
+//
+// column_value_pair::column_value_pair(const char *name, utils::database_type value)
+// : column_(name)
+// , value_(std::move(value)) {
+// }
+//
+// column_value_pair::column_value_pair( const char* name, utils::placeholder p )
+// : column_(name)
+// , value_(p) {}
 
 column_value_pair::column_value_pair(table_column col, column_expression_ptr expression)
 : column_(std::move(col))
@@ -32,12 +32,16 @@ const table_column &column_value_pair::col() const {
   return column_;
 }
 
-const std::variant<utils::placeholder, utils::database_type>& column_value_pair::value() const {
-  return value_;
+// const std::variant<utils::placeholder, utils::database_type>& column_value_pair::value() const {
+  // return value_;
+// }
+
+const abstract_column_expression& column_value_pair::expression() const {
+  return *expression_;
 }
 
 bool operator==( const column_value_pair& lhs, const column_value_pair& rhs ) {
-  return lhs.column_.equals(rhs.column_) && lhs.value_ == rhs.value_;
+  return lhs.column_.equals(rhs.column_) && lhs.expression_ == rhs.expression_;
 }
 
 bool operator!=( const column_value_pair& lhs, const column_value_pair& rhs ) {

source/orm/query/key_value_generator.cpp

@@ -6,8 +6,8 @@ namespace matador::query {
 key_value_generator::key_value_generator(std::vector<internal::column_value_pair> &result)
 : result_(result) {}
 
-void key_value_generator::on_revision(const char *id, uint64_t &x) {
-  result_.emplace_back(id, x);
+void key_value_generator::on_revision(const char *id, uint64_t &x) const {
+  result_.emplace_back(id, std::make_unique<value_expression>(x));
 }
 
 }

source/orm/query/query_builder.cpp

@@ -91,7 +91,11 @@ void query_builder::visit(internal::query_select_part &part) {
 
   query_.prototype.clear();
 
-  build_fetchable_columns(query_, part.columns(), *dialect_);
+  if (part.columns().empty()) {
+    query_.sql += dialect_->asterisk();
+  } else {
+    build_fetchable_columns(query_, part.columns(), *dialect_);
+  }
 }
 
 void query_builder::visit(internal::query_select_nextval_part& part) {
@@ -410,7 +414,7 @@ void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_co
       ctx.sql.append(", ");
     }
     prepare_prototype(ctx.prototype, col);
-    prepare_column(ctx.sql, d, col);
+    prepare_column(ctx, d, col);
     first = false;
   }
 }

source/orm/query/query_utils.cpp

@@ -12,25 +12,15 @@ namespace matador::query {
 void prepare_column(sql::query_context& ctx, const sql::dialect& d, const table_column& col) {
     // Expression-backed select item: (<expr>) [AS alias]
     if (col.is_expression()) {
-        // attribute_string_writer writer(d);
+        attribute_string_writer writer(d, {});
         expression_evaluator v(d, ctx);
         col.expression()->accept(v);
 
         if (col.has_alias()) {
             ctx.sql.append(" ").append(d.as()).append(" ").append(col.alias());
         }
-        return;
-    }
-
-    // Existing behavior: plain column or function
-    if (!col.is_function()) {
-        prepare_identifier_string_append(ctx.sql, col.name(), d);
     } else {
-        if (col.column_name() == d.asterisk()) {
-            ctx.sql += d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
-        } else {
-            ctx.sql += d.sql_function_at(col.function()) + "(" + col.column_name() + ") " + d.as() + " " + col.alias();
-        }
+        prepare_column(ctx.sql, d, col);
     }
 }
 

source/orm/query/table_column.cpp

@@ -53,14 +53,19 @@ table_column::table_column(const class table* tab,
                            std::string alias,
                            const utils::basic_type type,
                            const utils::field_attributes &attributes,
-                           const sql::sql_function_t func)
+                           const sql::sql_function_t func,
+                           const std::shared_ptr<abstract_column_expression>& expression)
 : table_(tab)
 , column_name_(name)
 , canonical_name_(build_canonical_name(table_, name))
 , alias_(std::move(alias))
 , type_(type)
 , attributes_(attributes)
-, function_(func) {}
+, function_(func)
+, expression_(expression) {}
+
+table_column::table_column(const std::shared_ptr<abstract_column_expression>& expression) noexcept
+: table_column(nullptr, "", "", utils::basic_type::Unknown, {}, sql::sql_function_t::None, expression) {}
 
 table_column & table_column::operator=(const table_column &other) {
   if (this == &other) {
@@ -148,7 +153,7 @@ bool table_column::is_expression() const {
   return static_cast<bool>(expression_);
 }
 
-const column_expression_ptr& table_column::expression() const {
+std::shared_ptr<abstract_column_expression> table_column::expression() const {
   return expression_;
 }
 

source/orm/query/table_pk_generator.cpp

@@ -11,7 +11,7 @@ table_pk_generator::table_pk_generator(const std::string& table_name, const std:
   query::update(table_name)
     .set("next_id"_col, "next_id"_col + 1)
     .where("name"_col == sequence_name)
-    .returning(("next_id"_col - 1));
+    .returning(("next_id"_col - 1).as("id"));
   /*
   *UPDATE id_table
   SET next_id = next_id + 1