identity generator progress

test/backends/SchemaTest.cpp

@@ -17,10 +17,8 @@ TEST_CASE_METHOD(SchemaFixture, "Test schema one-two-many", "[schema][one-to-man
   using namespace matador::test;
   query::schema repo;
 
-  // auto result = repo.attach<department>("departments")
-  //   .and_then([&repo] { return repo.attach<employee>("employees"); });
-  auto result = repo.attach<employee>("employees")
-    .and_then([&repo] { return repo.attach<department>("departments"); });
+  auto result = repo.attach<department>("departments")
+    .and_then([&repo] { return repo.attach<employee>("employees"); });
   REQUIRE(result);
 
   auto conn = pool.acquire();

test/orm/backend/test_connection.cpp

@@ -44,8 +44,8 @@ utils::result<utils::version, utils::error> test_connection::server_version() co
   return utils::ok(utils::version{3, 2, 1});
 }
 
-utils::result<size_t, utils::error> test_connection::execute(const std::string &/*stmt*/) {
-  return utils::ok(static_cast<size_t>(4));
+utils::result<sql::execute_result, utils::error> test_connection::execute(const sql::query_context &/*context*/) {
+  return utils::ok(sql::execute_result{4});
 }
 
 utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> test_connection::fetch(const sql::query_context &context) {

test/orm/backend/test_connection.hpp

@@ -2,6 +2,7 @@
 #define QUERY_NOOP_CONNECTION_HPP
 
 #include "matador/sql/interface/connection_impl.hpp"
+#include "matador/sql/execute_result.hpp"
 
 namespace matador::test::orm {
 
@@ -16,7 +17,7 @@ public:
   [[nodiscard]] utils::result<bool, utils::error> is_valid() const override;
   [[nodiscard]] utils::result<utils::version, utils::error> client_version() const override;
   [[nodiscard]] utils::result<utils::version, utils::error> server_version() const override;
-  utils::result<size_t, utils::error> execute(const std::string &stmt) override;
+  utils::result<sql::execute_result, utils::error> execute(const sql::query_context &context) override;
   utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::query_context &context) override;
   utils::result<std::unique_ptr<sql::statement_impl>, utils::error> prepare(const sql::query_context &context) override;
   utils::result<std::vector<object::attribute>, utils::error> describe(const std::string &table) override;

test/orm/backend/test_statement.cpp

@@ -10,12 +10,12 @@ namespace matador::test::orm {
 test_statement::test_statement(const sql::query_context &query)
 : statement_impl(query, 0) {}
 
-utils::result<size_t, utils::error> test_statement::execute(const sql::parameter_binder &/*bindings*/) {
+utils::result<sql::execute_result, utils::error> test_statement::execute(const sql::parameter_binder &/*bindings*/) {
   using namespace std::chrono_literals;
   std::mt19937 rng(query_.sql.size());
   std::uniform_int_distribution dist(10, 50);
   std::this_thread::sleep_for(std::chrono::milliseconds(dist(rng)));
-  return utils::ok(static_cast<size_t>(8));
+  return utils::ok(sql::execute_result{8});
 }
 
 utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> test_statement::fetch(const sql::parameter_binder &/*bindings*/) {

test/orm/backend/test_statement.hpp

@@ -2,13 +2,14 @@
 #define TEST_STATEMENT_HPP
 
 #include "matador/sql/interface/statement_impl.hpp"
+#include "matador/sql/execute_result.hpp"
 
 namespace matador::test::orm {
 
 class test_statement final : public sql::statement_impl {
 public:
   explicit test_statement(const sql::query_context &query);
-  utils::result<size_t, utils::error> execute(const sql::parameter_binder &bindings) override;
+  utils::result<sql::execute_result, utils::error> execute(const sql::parameter_binder &bindings) override;
   utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::parameter_binder &bindings) override;
   void reset() override;
 

test/orm/query/QueryBuilderTest.cpp

@@ -50,6 +50,17 @@ TEST_CASE_METHOD(QueryFixture, "Test create table sql statement string", "[query
 
   REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
 
+  result = query::create()
+    .table({"person"})
+    .columns({
+        column("id", basic_type::UInt32).primary_key().identity(),
+        column("name", basic_type::Varchar, 255),
+        column("age", basic_type::UInt16)
+    })
+    .str(*db);
+
+  REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL AUTO INCREMENT PRIMARY KEY, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL))##");
+
   auto ctx = query::create()
     .table("person")
     .columns({

test/utils/record_printer.cpp

@@ -58,15 +58,15 @@ int record_printer::width(const sql::field &f) {
   // If it's a varchar/string and has a defined size, use it if it's reasonable, 
   // otherwise fall back to type defaults.
   if ((f.is_varchar() || f.is_string()) && f.size() > 0 && f.size() < 100) {
-    return std::max(f.name().length(), f.size());
+    return static_cast<int>(std::max(f.name().length(), f.size()));
   }
 
   // Find the default width for type
-  // Note: field class doesn't expose basic_type directly but we can use value().type() 
-  // if we had access. For now we use name length as minimum.
+  // Note: field class doesn't expose basic_type directly, but we can use value().type()
+  // if we had access. For now we use name length as a minimum.
   constexpr size_t w = 15;
   // In a real implementation we would probe the field's underlying type.
 
-  return std::max(f.name().length(), w);
+  return static_cast<int>(std::max(f.name().length(), w));
 }
 }