diff --git a/backends/sqlite/src/sqlite_connection.cpp b/backends/sqlite/src/sqlite_connection.cpp
index 7b02b46..eb5ecc9 100644
--- a/backends/sqlite/src/sqlite_connection.cpp
+++ b/backends/sqlite/src/sqlite_connection.cpp
@@ -173,7 +173,7 @@ sql::record sqlite_connection::describe(const std::string& table)
 bool sqlite_connection::exists(const std::string &table_name)
 {
   const auto result = fetch_internal("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND tbl_name='" + table_name + "' LIMIT 1");
-  sqlite_result_reader reader(std::move(result.rows), result.prototype.size());
+  sqlite_result_reader reader(result.rows, result.prototype.size());
 
   if (!reader.fetch()) {
     // Todo: throw an exception?
diff --git a/include/matador/sql/connection.hpp b/include/matador/sql/connection.hpp
index 7572a73..8fd5a68 100644
--- a/include/matador/sql/connection.hpp
+++ b/include/matador/sql/connection.hpp
@@ -35,7 +35,7 @@ public:
   [[nodiscard]] bool exists(const std::string &table_name) const;
 
   [[nodiscard]] std::unique_ptr<query_result_impl> fetch(const std::string &sql) const;
-  [[nodiscard]] std::pair<size_t, std::string> execute(const std::string &sql) const;
+  [[nodiscard]] size_t execute(const std::string &sql) const;
 
   statement prepare(query_context &&query) const;
 
diff --git a/include/matador/sql/query_intermediates.hpp b/include/matador/sql/query_intermediates.hpp
index 618fcc2..c1efc72 100644
--- a/include/matador/sql/query_intermediates.hpp
+++ b/include/matador/sql/query_intermediates.hpp
@@ -36,7 +36,7 @@ class query_execute_finish : public query_intermediate
 public:
   using query_intermediate::query_intermediate;
 
-  std::pair<size_t, std::string> execute();
+  size_t execute();
   statement prepare();
 };
 
diff --git a/include/matador/sql/session.hpp b/include/matador/sql/session.hpp
index d9b5f6a..8400936 100644
--- a/include/matador/sql/session.hpp
+++ b/include/matador/sql/session.hpp
@@ -31,7 +31,7 @@ public:
 
   [[nodiscard]] query_result<record> fetch(const query_context &q) const;
 //  [[nodiscard]] query_result<record> fetch(const std::string &sql) const;
-  [[nodiscard]] std::pair<size_t, std::string> execute(const std::string &sql) const;
+  [[nodiscard]] size_t execute(const std::string &sql) const;
   statement prepare(query_context q) const;
 
   record describe_table(const std::string &table_name) const;
diff --git a/src/sql/connection.cpp b/src/sql/connection.cpp
index 2246ab8..94c8ec6 100644
--- a/src/sql/connection.cpp
+++ b/src/sql/connection.cpp
@@ -76,10 +76,10 @@ bool connection::exists(const std::string &table_name) const
   return connection_->exists(table_name);
 }
 
-std::pair<size_t, std::string> connection::execute(const std::string &sql) const
+size_t connection::execute(const std::string &sql) const
 {
   logger_.debug(sql);
-  return {connection_->execute(sql), sql};
+  return connection_->execute(sql);
 }
 
 std::unique_ptr<query_result_impl> connection::fetch(const std::string &sql) const
diff --git a/src/sql/query_intermediates.cpp b/src/sql/query_intermediates.cpp
index a964221..cf0bb8c 100644
--- a/src/sql/query_intermediates.cpp
+++ b/src/sql/query_intermediates.cpp
@@ -103,7 +103,7 @@ query_into_intermediate query_insert_intermediate::into(const std::string &table
   return {session_, builder_.into(table, column_names)};
 }
 
-std::pair<size_t, std::string> query_execute_finish::execute()
+size_t query_execute_finish::execute()
 {
   return session_.execute(builder_.compile().sql);
 }
diff --git a/src/sql/session.cpp b/src/sql/session.cpp
index 9a9ff6d..7d299f8 100644
--- a/src/sql/session.cpp
+++ b/src/sql/session.cpp
@@ -65,7 +65,7 @@ query_result<record> session::fetch(const query_context &q) const
 //  return query_result<record>(std::unique_ptr());
 //}
 
-std::pair<size_t, std::string> session::execute(const std::string &sql) const {
+size_t session::execute(const std::string &sql) const {
   auto c = pool_.acquire();
   if (!c.valid()) {
     throw std::logic_error("no database connection available");
diff --git a/test/SessionRecordTest.cpp b/test/SessionRecordTest.cpp
index 137cbe4..5e68760 100644
--- a/test/SessionRecordTest.cpp
+++ b/test/SessionRecordTest.cpp
@@ -8,101 +8,99 @@
 
 using namespace matador::sql;
 
-TEST_CASE("Create and drop table statement", "[session record]") {
-  auto dns = GENERATE(as<std::string>{},
+TEST_CASE("Create and drop table statement", "[session record]")
+{
+  auto dns = GENERATE(as < std::string > {},
                       "sqlite://sqlite.db",
-                      "postgres://test:test123@127.0.0.1:5432/matador_test" );
+                      "postgres://test:test123@127.0.0.1:5432/matador_test");
   connection_pool<connection> pool(dns, 4);
   session s(pool);
 
   REQUIRE(!s.table_exists("person"));
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              })
-              .execute();
-
-  REQUIRE(res.second == R"(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255), "age" INTEGER, CONSTRAINT PK_person PRIMARY KEY (id)))");
+  s.create()
+   .table("person", {
+     make_pk_column<unsigned long>("id"),
+     make_column<std::string>("name", 255),
+     make_column<unsigned short>("age")
+   })
+   .execute();
 
   REQUIRE(s.table_exists("person"));
 
-  res = s.drop()
-         .table("person")
-         .execute();
+  s.drop()
+    .table("person")
+    .execute();
 
-  REQUIRE(res.second == R"(DROP TABLE "person")");
+  REQUIRE(!s.table_exists("person"));
 }
 
-TEST_CASE("Create and drop table statement with foreign key", "[session record]") {
+TEST_CASE("Create and drop table statement with foreign key", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("airplane", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("brand", 255),
-                make_column<std::string>("model", 255),
-              })
-              .execute();
+  s.create()
+   .table("airplane", {
+     make_pk_column<unsigned long>("id"),
+     make_column<std::string>("brand", 255),
+     make_column<std::string>("model", 255),
+   })
+   .execute();
 
-  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
+  REQUIRE(s.table_exists("airplane"));
 
-  res = s.create()
-         .table("flight", {
-           make_pk_column<unsigned long>("id"),
-           make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
-           make_column<std::string>("pilot_name", 255),
-         })
-         .execute();
+  s.create()
+    .table("flight", {
+      make_pk_column<unsigned long>("id"),
+      make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
+      make_column<std::string>("pilot_name", 255),
+    })
+    .execute();
 
-  REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT NOT NULL, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
+  REQUIRE(s.table_exists("flight"));
 
-  res = s.drop()
-         .table("flight")
-         .execute();
+  s.drop()
+    .table("flight")
+    .execute();
 
-  REQUIRE(res.second == R"(DROP TABLE "flight")");
+  REQUIRE(!s.table_exists("flight"));
 
-  res = s.drop()
-         .table("airplane")
-         .execute();
+  s.drop()
+    .table("airplane")
+    .execute();
 
-  REQUIRE(res.second == R"(DROP TABLE "airplane")");
+  REQUIRE(!s.table_exists("airplane"));
 }
 
-TEST_CASE("Execute insert record statement", "[session record]") {
-  auto dns = GENERATE(as<std::string>{},
+TEST_CASE("Execute insert record statement", "[session record]")
+{
+  auto dns = GENERATE(as < std::string > {},
                       "sqlite://sqlite.db",
-                      "postgres://test:test123@127.0.0.1:5432/matador_test" );
+                      "postgres://test:test123@127.0.0.1:5432/matador_test");
 
   connection_pool<connection> pool(dns, 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              })
-              .execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    })
+    .execute();
 
-  REQUIRE(res.first == 0);
+  auto res = s.insert()
+    .into("person", {"id", "name", "age"})
+    .values({7, "george", 45})
+    .execute();
 
-  res = s.insert()
-         .into("person", {"id", "name", "age"})
-         .values({7, "george", 45})
-         .execute();
-
-  REQUIRE(res.first == 1);
-  REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "age") VALUES (7, 'george', 45))");
+  REQUIRE(res == 1);
 
   auto result = s.select({"id", "name", "age"})
-                 .from("person")
-                 .fetch_all();
+    .from("person")
+    .fetch_all();
 
-  for (const auto& i : result) {
+  for (const auto &i: result) {
     REQUIRE(i.size() == 3);
     REQUIRE(i.at(0).name() == "id");
     REQUIRE(i.at(0).type() == data_type_t::type_long_long);
@@ -116,90 +114,87 @@ TEST_CASE("Execute insert record statement", "[session record]") {
   }
 
   s.drop()
-   .table("person")
-   .execute();
+    .table("person")
+    .execute();
 }
 
-TEST_CASE("Execute insert record statement with foreign key", "[session record]") {
+TEST_CASE("Execute insert record statement with foreign key", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("airplane", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("brand", 255),
-                make_column<std::string>("model", 255),
-              })
-              .execute();
+  s.create()
+    .table("airplane", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("brand", 255),
+      make_column<std::string>("model", 255),
+    })
+    .execute();
 
-  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
+  s.create()
+    .table("flight", {
+      make_pk_column<unsigned long>("id"),
+      make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
+      make_column<std::string>("pilot_name", 255),
+    })
+    .execute();
 
-  res = s.create()
-         .table("flight", {
-           make_pk_column<unsigned long>("id"),
-           make_fk_column<unsigned long>("airplane_id", "airplane", "id"),
-           make_column<std::string>("pilot_name", 255),
-         })
-         .execute();
-
-  REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT NOT NULL, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
-
-  res = s.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into("airplane", {"id", "brand", "model"}).values({1, "Airbus", "A380"}).execute();
+  REQUIRE(res == 1);
 
   res = s.insert().into("airplane", {"id", "brand", "model"}).values({2, "Boeing", "707"}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   res = s.insert().into("airplane", {"id", "brand", "model"}).values({3, "Boeing", "747"}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   auto count = s.select({count_all()}).from("airplane").fetch_value<int>();
   REQUIRE(count == 3);
 
   res = s.insert().into("flight", {"id", "airplane_id", "pilot_name"}).values({4, 1, "George"}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
-  res = s.drop().table("flight").execute();
-  REQUIRE(res.second == R"(DROP TABLE "flight")");
-  res = s.drop().table("airplane").execute();
-  REQUIRE(res.second == R"(DROP TABLE "airplane")");
+  s.drop().table("flight").execute();
+  s.drop().table("airplane").execute();
+
+  REQUIRE(!s.table_exists("flight"));
+  REQUIRE(!s.table_exists("airplane"));
 }
 
-TEST_CASE("Execute update record statement", "[session record]") {
+TEST_CASE("Execute update record statement", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              })
-              .execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    })
+    .execute();
 
-  REQUIRE(res.first == 0);
+  auto res = s.insert()
+    .into("person", {"id", "name", "age"})
+    .values({7, "george", 45})
+    .execute();
 
-  res = s.insert()
-         .into("person", {"id", "name", "age"})
-         .values({7, "george", 45})
-         .execute();
-
-  REQUIRE(res.first == 1);
-  REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "age") VALUES (7, 'george', 45))");
+  REQUIRE(res == 1);
 
   res = s.update("person")
-         .set({{"id", 7}, {"name", "jane"}, {"age", 35}})
-         .where("id"_col == 7)
-         .execute();
+    .set({{"id",   7},
+          {"name", "jane"},
+          {"age",  35}})
+    .where("id"_col == 7)
+    .execute();
 
-  REQUIRE(res.first == 1);
-  REQUIRE(res.second == R"(UPDATE "person" SET "id"=7, "name"='jane', "age"=35 WHERE "id" = 7)");
+  REQUIRE(res == 1);
 
   auto result = s.select({"id", "name", "age"})
-                 .from("person")
-                 .fetch_all();
+    .from("person")
+    .fetch_all();
 
-  for (const auto& i : result) {
+  for (const auto &i: result) {
     REQUIRE(i.size() == 3);
     REQUIRE(i.at(0).name() == "id");
     REQUIRE(i.at(0).type() == data_type_t::type_long_long);
@@ -215,83 +210,81 @@ TEST_CASE("Execute update record statement", "[session record]") {
   s.drop().table("person").execute();
 }
 
-TEST_CASE("Execute select statement", "[session record]") {
+TEST_CASE("Execute select statement", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-  .table("person", {
-  make_pk_column<unsigned long>("id"),
-  make_column<std::string>("name", 255),
-  make_column<unsigned short>("age")
-  })
-  .execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    })
+    .execute();
 
-  REQUIRE(res.first == 0);
-
-  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   auto result = s.select({"id", "name", "age"})
-                 .from("person")
-                 .fetch_all();
+    .from("person")
+    .fetch_all();
 
-  std::list<std::string> expected_names {"george", "jane", "michael", "bob"};
-  for (const auto &p : result) {
+  std::list<std::string> expected_names{"george", "jane", "michael", "bob"};
+  for (const auto &p: result) {
     REQUIRE(p.at(1).str() == expected_names.front());
     expected_names.pop_front();
   }
   REQUIRE(expected_names.empty());
 
   auto rec = s.select({"id", "name", "age"})
-              .from("person")
-              .fetch_one();
+    .from("person")
+    .fetch_one();
   REQUIRE(rec.at(1).str() == "george");
 
   auto name = s.select({"name"})
-               .from("person")
-               .fetch_value<std::string>();
+    .from("person")
+    .fetch_value<std::string>();
   REQUIRE(name == "george");
 
   s.drop().table("person").execute();
 }
 
-TEST_CASE("Execute select statement with order by", "[session record]") {
+TEST_CASE("Execute select statement with order by", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              })
-              .execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    })
+    .execute();
 
-  REQUIRE(res.first == 0);
-
-  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   auto result = s.select({"id", "name", "age"})
-                 .from("person")
-                 .order_by("name").asc()
-                 .fetch_all();
+    .from("person")
+    .order_by("name").asc()
+    .fetch_all();
 
-  std::list<std::string> expected_names {"bob", "george", "jane", "michael"};
-  for (const auto &p : result) {
+  std::list<std::string> expected_names{"bob", "george", "jane", "michael"};
+  for (const auto &p: result) {
     REQUIRE(p.at(1).str() == expected_names.front());
     expected_names.pop_front();
   }
@@ -300,37 +293,40 @@ TEST_CASE("Execute select statement with order by", "[session record]") {
   s.drop().table("person").execute();
 }
 
-TEST_CASE("Execute select statement with group by and order by", "[session record]") {
+TEST_CASE("Execute select statement with group by and order by", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              })
-              .execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    })
+    .execute();
 
-  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 13}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({5, "charlie", 67}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   auto result = s.select({alias(count("age"), "age_count"), "age"})
-                 .from("person")
-                 .group_by("age")
-                 .order_by("age_count").desc()
-                 .fetch_all();
+    .from("person")
+    .group_by("age")
+    .order_by("age_count").desc()
+    .fetch_all();
 
-  std::list<std::pair<int, int>> expected_values {{2, 45}, {2, 13}, {1, 67}};
-  for (const auto &r : result) {
+  std::list<std::pair<int, int>> expected_values{{2, 45},
+                                                 {2, 13},
+                                                 {1, 67}};
+  for (const auto &r: result) {
     REQUIRE(r.at(0).as<int>() == expected_values.front().first);
     REQUIRE(r.at(1).as<int>() == expected_values.front().second);
     expected_values.pop_front();
@@ -339,34 +335,32 @@ TEST_CASE("Execute select statement with group by and order by", "[session recor
   s.drop().table("person").execute();
 }
 
-TEST_CASE("Execute delete statement", "[session record]") {
+TEST_CASE("Execute delete statement", "[session record]")
+{
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table("person", {
-                make_pk_column<unsigned long>("id"),
-                make_column<std::string>("name", 255),
-                make_column<unsigned short>("age")
-              }).execute();
+  s.create()
+    .table("person", {
+      make_pk_column<unsigned long>("id"),
+      make_column<std::string>("name", 255),
+      make_column<unsigned short>("age")
+    }).execute();
 
-  REQUIRE(res.first == 0);
-
-  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
+  REQUIRE(res == 1);
   res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   auto count = s.select({count_all()}).from("person").fetch_value<int>();
   REQUIRE(count == 2);
 
   res = s.remove()
-         .from("person")
-         .where("id"_col == 1)
-         .execute();
+    .from("person")
+    .where("id"_col == 1)
+    .execute();
 
-  REQUIRE(res.second == R"(DELETE FROM "main"."person" WHERE "id" = 1)");
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   count = s.select({count_all()}).from("person").fetch_value<int>();
   REQUIRE(count == 1);
diff --git a/test/SessionTest.cpp b/test/SessionTest.cpp
index 4f8179d..c723bd9 100644
--- a/test/SessionTest.cpp
+++ b/test/SessionTest.cpp
@@ -22,38 +22,39 @@ TEST_CASE("Create table with foreign key relation", "[session]") {
   connection_pool<connection> pool(dns, 4);
   session s(pool);
 
-  auto res = s.create()
-              .table<airplane>("airplane")
-              .execute();
-  REQUIRE(res.first == 0);
-  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
+  s.create()
+    .table<airplane>("airplane")
+    .execute();
 
-  res = s.create()
+  REQUIRE(s.table_exists("airplane"));
+
+  s.create()
          .table<flight>("flight")
          .execute();
-  REQUIRE(res.first == 0);
-  REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
+
+  REQUIRE(s.table_exists("flight"));
 
   s.drop().table("flight").execute();
   s.drop().table("airplane").execute();
+
+  REQUIRE(!s.table_exists("flight"));
+  REQUIRE(!s.table_exists("airplane"));
 }
 
 TEST_CASE("Execute select statement with where clause", "[session]") {
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
-              .table<person>("person")
-              .execute();
-
-  REQUIRE(res.first == 0);
+  s.create()
+    .table<person>("person")
+    .execute();
 
   person george{7, "george", 45};
 
-  res = s.insert()
+  auto res = s.insert()
          .into("person", george)
          .execute();
-  REQUIRE(res.first == 1);
+  REQUIRE(res == 1);
 
   // fetch person as record
   auto result_record = s.select<person>()
@@ -93,7 +94,7 @@ TEST_CASE("Execute insert statement", "[session]") {
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
+  s.create()
               .table("person", {
                 make_pk_column<unsigned long>("id"),
                 make_column<std::string>("name", 255),
@@ -101,13 +102,12 @@ TEST_CASE("Execute insert statement", "[session]") {
               })
               .execute();
 
-  res = s.insert()
+  auto res = s.insert()
          .into("person", {"id", "name", "color"})
          .values({7, "george", "green"})
          .execute();
 
-  REQUIRE(res.first == 1);
-  REQUIRE(res.second == R"(INSERT INTO "person" ("id", "name", "color") VALUES (7, 'george', 'green'))");
+  REQUIRE(res == 1);
 
   s.drop().table("person").execute();
 }
@@ -116,27 +116,23 @@ TEST_CASE("Select statement with foreign key", "[session]") {
   connection_pool<connection> pool("sqlite://sqlite.db", 4);
   session s(pool);
 
-  auto res = s.create()
+  s.create()
     .table<airplane>("airplane")
     .execute();
-  REQUIRE(res.first == 0);
-  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
 
-  res = s.create()
+  s.create()
     .table<flight>("flight")
     .execute();
-  REQUIRE(res.first == 0);
-  REQUIRE(res.second == R"(CREATE TABLE "flight" ("id" BIGINT, "airplane_id" BIGINT, "pilot_name" VARCHAR(255), CONSTRAINT PK_flight PRIMARY KEY (id), CONSTRAINT FK_flight_airplane_id FOREIGN KEY (airplane_id) REFERENCES airplane(id)))");
 
   std::vector<entity<airplane>> planes {
-  make_entity<airplane>(1, "Airbus", "A380"),
-  make_entity<airplane>(2, "Boeing", "707"),
-  make_entity<airplane>(3, "Boeing", "747")
+    make_entity<airplane>(1, "Airbus", "A380"),
+    make_entity<airplane>(2, "Boeing", "707"),
+    make_entity<airplane>(3, "Boeing", "747")
   };
 
   for (const auto &plane : planes) {
-    res = s.insert().into<airplane>("airplane").values(*plane).execute();
-    REQUIRE(res.first == 1);
+    auto res = s.insert().into<airplane>("airplane").values(*plane).execute();
+    REQUIRE(res == 1);
   }
 
   auto count = s.select({count_all()}).from("airplane").fetch_value<int>();
@@ -144,8 +140,8 @@ TEST_CASE("Select statement with foreign key", "[session]") {
 
   flight f4711{4, planes.at(1), "hans"};
 
-  res = s.insert().into<flight>("flight").values(f4711).execute();
-  REQUIRE(res.first == 1);
+  auto res = s.insert().into<flight>("flight").values(f4711).execute();
+  REQUIRE(res == 1);
 
   auto f = *s.select<flight>().from("flight").fetch_all<flight>().begin();
   REQUIRE(f.id == 4);
diff --git a/test/StatementTest.cpp b/test/StatementTest.cpp
index 572f05a..2a08275 100644
--- a/test/StatementTest.cpp
+++ b/test/StatementTest.cpp
@@ -21,11 +21,9 @@ public:
   StatementTestFixture()
   : pool_(Type::dns, 4), session_(pool_)
   {
-    auto res = session_.create()
+    session_.create()
     .table<airplane>("airplane")
     .execute();
-    REQUIRE(res.first == 0);
-    REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");
   }
 
   ~StatementTestFixture()
@@ -79,7 +77,7 @@ TEMPLATE_TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[s
   SECTION("Select with prepared statement") {
     for (const auto &plane: planes) {
       auto res = s.insert().template into<airplane>("airplane").values(*plane).execute();
-      REQUIRE(res.first == 1);
+      REQUIRE(res == 1);
     }
 
     auto stmt = s.template select<airplane>().from("airplane").where("brand"_col == _).prepare();
diff --git a/test/TypeTraitsTest.cpp b/test/TypeTraitsTest.cpp
index 009dae5..b90a632 100644
--- a/test/TypeTraitsTest.cpp
+++ b/test/TypeTraitsTest.cpp
@@ -23,11 +23,9 @@ public:
   TypeTraitsTestFixture()
   : pool_(Type::dns, 4), session_(pool_)
   {
-    auto res = session_.create()
+    session_.create()
     .table<location>("location")
     .execute();
-    REQUIRE(res.first == 0);
-    REQUIRE(res.second == R"(CREATE TABLE "location" ("id" BIGINT, "name" VARCHAR(255), "coordinate_x" INTEGER, "coordinate_y" INTEGER, "coordinate_z" INTEGER, "color" TEXT, CONSTRAINT PK_location PRIMARY KEY (id)))");
   }
 
   ~TypeTraitsTestFixture()
@@ -93,7 +91,7 @@ TEMPLATE_TEST_CASE_METHOD(TypeTraitsTestFixture, "Special handling of attributes
     location loc{1, "center", {1, 2, 3}, Color::Black};
 
     auto res = s.insert().template into<location>("location").values(loc).execute();
-    REQUIRE(res.first == 1);
+    REQUIRE(res == 1);
 
     auto result = s.template select<location>().from("location").
     template fetch_all<location>();