fixed backend tests

source/orm/query/intermediates/executable_query.cpp

@@ -9,18 +9,21 @@ namespace matador::query {
 utils::result<size_t, utils::error> executable_query::execute(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   return exec.execute(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
 utils::result<sql::statement, utils::error> executable_query::prepare(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Prepared;
   return exec.prepare(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
 std::string executable_query::str(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   return exec.str(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 

source/orm/query/intermediates/fetchable_query.cpp

@@ -8,6 +8,7 @@ namespace matador::query {
 utils::result<sql::query_result<sql::record>, utils::error> fetchable_query::fetch_all(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   return exec.fetch(compiler.compile(*context_, exec.dialect(), std::nullopt))
     .and_then([](auto &&res) {
       return utils::ok(sql::query_result<sql::record>(std::forward<decltype(res)>(res)));
@@ -22,6 +23,7 @@ utils::result<sql::query_result<sql::record>, utils::error> fetchable_query::fet
 utils::result<std::optional<sql::record>, utils::error> fetchable_query::fetch_one(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   auto result = exec.fetch(compiler.compile(*context_, exec.dialect(), std::nullopt));
   if (!result.is_ok()) {
     return utils::failure(result.err());
@@ -39,18 +41,21 @@ utils::result<std::optional<sql::record>, utils::error> fetchable_query::fetch_o
 std::string fetchable_query::str(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   return exec.str(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
 utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetchable_query::fetch(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Direct;
   return exec.fetch(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 
 utils::result<sql::statement, utils::error> fetchable_query::prepare(const sql::executor &exec) const
 {
   query_compiler compiler;
+  context_->mode = query_mode::Prepared;
   return exec.prepare(compiler.compile(*context_, exec.dialect(), std::nullopt));
 }
 

source/orm/query/intermediates/query_into_intermediate.cpp

@@ -15,10 +15,12 @@ executable_query query_into_intermediate::values(std::vector<std::variant<utils:
 }
 
 executable_query query_into_intermediate::values( std::vector<utils::database_type>&& values ) {
-    std::vector<std::variant<utils::placeholder, utils::database_type>> transformed_values;
-    for (auto&& val : values) {
-        transformed_values.emplace_back(val);
-    }
-    return this->values(std::move(transformed_values));
+  std::vector<std::variant<utils::placeholder, utils::database_type>> transformed_values;
+  transformed_values.reserve(values.size());
+  for (auto&& val : values) {
+    transformed_values.emplace_back(val);
+  }
+  return this->values(std::move(transformed_values));
 }
+
 } // namespace matador::query

source/orm/query/query_compiler.cpp

@@ -174,8 +174,16 @@ struct value_visitor {
   internal::basic_type_to_string_visitor value_to_string_visitor;
 };
 
-void query_compiler::visit(internal::query_values_part &values_part)
-{
+std::string query_compiler::determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val) {
+    if (data_->mode == query_mode::Direct) {
+        std::visit(visitor, val);
+        return visitor.value_to_string_visitor.result;
+    }
+
+    query_.bind_vars.emplace_back(std::string("value_") + std::to_string(query_.bind_vars.size() + 1));
+    return dialect_->next_placeholder(query_.bind_vars);
+}
+void query_compiler::visit(internal::query_values_part &values_part) {
   query_.sql += " " + dialect_->token_at(sql::dialect_token::VALUES);
 
   attribute_string_writer writer(*dialect_, connection_);
@@ -184,19 +192,16 @@ void query_compiler::visit(internal::query_values_part &values_part)
   std::string result{"("};
   if (values_part.values().size() < 2) {
     for (const auto& val: values_part.values()) {
-      std::visit(visitor, val);
-      result.append(visitor.value_to_string_visitor.result);
+      result.append(determine_value(visitor, val));
     }
   } else {
     auto it = values_part.values().begin();
     auto val = *it++;
-    std::visit(visitor, val);
-    result.append(visitor.value_to_string_visitor.result);
+      result.append(determine_value(visitor, val));
     for (; it != values_part.values().end(); ++it) {
       result.append(", ");
       val = *it;
-      std::visit(visitor, val);
-      result.append(visitor.value_to_string_visitor.result);
+      result.append(determine_value(visitor, val));
     }
   }
   result += (")");
@@ -267,11 +272,11 @@ void query_compiler::visit(internal::query_create_table_part &create_table_part)
   if (!context.primary_keys.empty()) {
     result.append(", CONSTRAINT PK_" + create_table_part.table().name + " PRIMARY KEY (" + utils::join(context.primary_keys, ", ") + ")");
   }
-  for (const auto &fk: context.foreign_contexts) {
+  for (const auto &[column, reference_column]: context.foreign_contexts) {
     result += ", CONSTRAINT FK_" + create_table_part.table().name;
-    result += "_" + fk.column;
-    result += " FOREIGN KEY (" + fk.column + ")";
-    result += " REFERENCES " + fk.reference_column->table_name() + "(" + fk.reference_column->name() + ")";
+    result += "_" + column;
+    result += " FOREIGN KEY (" + column + ")";
+    result += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";
   }
 
   result += ")";

source/orm/sql/connection.cpp

@@ -73,7 +73,7 @@ utils::result<void, utils::error> connection::open() const
   if (res.is_error()) {
     return utils::failure(res.err());
   }
-  if (*res) {
+  if (!*res) {
     logger_->on_connect();
     return connection_->open();
   }