query/test/SessionRecordTest.cpp

#include <catch2/catch_test_macros.hpp>
#include <catch2/generators/catch_generators.hpp>

#include <matador/sql/condition.hpp>
#include <matador/sql/session.hpp>

#include <list>

using namespace matador::sql;

TEST_CASE("Create and drop table 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();

  REQUIRE(res.second == R"(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255), "age" INTEGER, CONSTRAINT PK_person PRIMARY KEY (id)))");

  res = s.drop()
         .table("person")
         .execute();

  REQUIRE(res.second == R"(DROP TABLE "person")");
}

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();

  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");

  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.drop()
         .table("flight")
         .execute();

  REQUIRE(res.second == R"(DROP TABLE "flight")");

  res = s.drop()
         .table("airplane")
         .execute();

  REQUIRE(res.second == R"(DROP TABLE "airplane")");
}

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" );

  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();

  REQUIRE(res.first == 0);

  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))");

  auto result = s.select({"id", "name", "age"})
                 .from("person")
                 .fetch_all();

  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);
    REQUIRE(i.at(0).as<long long>() == 7);
    REQUIRE(i.at(1).name() == "name");
    REQUIRE(i.at(1).type() == data_type_t::type_varchar);
    REQUIRE(i.at(1).as<std::string>() == "george");
    REQUIRE(i.at(2).name() == "age");
    REQUIRE(i.at(2).type() == matador::sql::data_type_t::type_int);
    REQUIRE(i.at(2).as<int>() == 45);
  }

  s.drop()
   .table("person")
   .execute();
}

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();

  REQUIRE(res.second == R"(CREATE TABLE "airplane" ("id" BIGINT NOT NULL, "brand" VARCHAR(255), "model" VARCHAR(255), CONSTRAINT PK_airplane PRIMARY KEY (id)))");

  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);

  res = s.insert().into("airplane", {"id", "brand", "model"}).values({2, "Boeing", "707"}).execute();
  REQUIRE(res.first == 1);

  res = s.insert().into("airplane", {"id", "brand", "model"}).values({3, "Boeing", "747"}).execute();
  REQUIRE(res.first == 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);

  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")");
}

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();

  REQUIRE(res.first == 0);

  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))");

  res = s.update("person")
         .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)");

  auto result = s.select({"id", "name", "age"})
                 .from("person")
                 .fetch_all();

  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);
    REQUIRE(i.at(0).as<long long>() == 7);
    REQUIRE(i.at(1).name() == "name");
    REQUIRE(i.at(1).type() == data_type_t::type_varchar);
    REQUIRE(i.at(1).as<std::string>() == "jane");
    REQUIRE(i.at(2).name() == "age");
    REQUIRE(i.at(2).type() == matador::sql::data_type_t::type_int);
    REQUIRE(i.at(2).as<int>() == 35);
  }

  s.drop().table("person").execute();
}

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();

  REQUIRE(res.first == 0);

  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
  REQUIRE(res.first == 1);

  auto result = s.select({"id", "name", "age"})
                 .from("person")
                 .fetch_all();

  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();
  REQUIRE(rec.at(1).str() == "george");

  auto name = s.select({"name"})
               .from("person")
               .fetch_value<std::string>();
  REQUIRE(name == "george");

  s.drop().table("person").execute();
}

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();

  REQUIRE(res.first == 0);

  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 32}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 67}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
  REQUIRE(res.first == 1);

  auto result = s.select({"id", "name", "age"})
                 .from("person")
                 .order_by("name").asc()
                 .fetch_all();

  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();
  }
  REQUIRE(expected_names.empty());

  s.drop().table("person").execute();
}

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();

  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({3, "michael", 13}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({4, "bob", 13}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({5, "charlie", 67}).execute();
  REQUIRE(res.first == 1);

  auto result = s.select({alias(count("age"), "age_count"), "age"})
                 .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) {
    REQUIRE(r.at(0).as<int>() == expected_values.front().first);
    REQUIRE(r.at(1).as<int>() == expected_values.front().second);
    expected_values.pop_front();
  }

  s.drop().table("person").execute();
}

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();

  REQUIRE(res.first == 0);

  res = s.insert().into("person", {"id", "name", "age"}).values({1, "george", 45}).execute();
  REQUIRE(res.first == 1);
  res = s.insert().into("person", {"id", "name", "age"}).values({2, "jane", 45}).execute();
  REQUIRE(res.first == 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();

  REQUIRE(res.second == R"(DELETE FROM "person" WHERE "id" = 1)");
  REQUIRE(res.first == 1);

  count = s.select({count_all()}).from("person").fetch_value<int>();
  REQUIRE(count == 1);

  s.drop().table("person").execute();
}