query/test/QueryBuilderTest.cpp

#include <catch2/catch_test_macros.hpp>

#include <matador/sql/column_definition.hpp>
#include <matador/sql/condition.hpp>
#include <matador/sql/connection.hpp>
#include <matador/sql/dialect_builder.hpp>
#include <matador/sql/query_builder.hpp>
#include <matador/sql/query.hpp>

using namespace matador::sql;
using namespace matador::utils;

TEST_CASE("Create table sql statement string", "[query]") {
  connection noop("noop://noop.db");
  auto scm = std::make_shared<schema>("noop");
  query qu(noop, scm);
  auto s = qu.create().table({"person"}, {
    make_pk_column<unsigned long>("id"),
    make_column<std::string>("name", 255),
    make_column<unsigned short>("age")
  }).str();

  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  auto q = query.create().table("person", {
      make_pk_column<unsigned long>("id"),
      make_column<std::string>("name", 255),
      make_column<unsigned short>("age")
  }).compile();

  REQUIRE(s == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
//  REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
  REQUIRE(q.table_name == "person");

  q = query.create().table("person", {
    make_pk_column<unsigned long>("id"),
    make_column<std::string>("name", { 255, constraints::UNIQUE }, null_option::NOT_NULL),
    make_column<unsigned short>("age"),
    make_fk_column<unsigned long>("address", "address", "id")
  }).compile();

  REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address(id)))##");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Drop table sql statement string", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.drop().table("person").compile();

  REQUIRE(q.sql == R"(DROP TABLE "person")");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Select sql statement string", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.select({"id", "name", "age"}).from("person").compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person")");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Insert sql statement string", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.insert().into("person", {
    "id", "name", "age"
  }).values({7UL, "george", 65U}).compile();

  REQUIRE(q.sql == R"(INSERT INTO "person" ("id", "name", "age") VALUES (7, 'george', 65))");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Update sql statement string", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.update("person").set({
    {"id", 7UL},
    {"name", "george"},
    {"age", 65U}
  }).compile();

  REQUIRE(q.sql == R"(UPDATE "person" SET "id"=7, "name"='george', "age"=65)");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Delete sql statement string", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.remove().from("person").compile();

  REQUIRE(q.sql == R"(DELETE FROM "person")");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Select sql statement string with where clause", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  auto q = query.select({"id", "name", "age"})
                .from("person")
                .where("id"_col == 8 && "age"_col > 50)
                .compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person" WHERE ("id" = 8 AND "age" > 50))");
  REQUIRE(q.table_name == "person");

  q = query.select({"id", "name", "age"})
           .from("person")
           .where("id"_col == _ && "age"_col > 50)
           .compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person" WHERE ("id" = ? AND "age" > 50))");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Insert sql statement with placeholder", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.insert().into("person", {
  "id", "name", "age"
  }).values({_, _, _}).compile();

  REQUIRE(q.sql == R"(INSERT INTO "person" ("id", "name", "age") VALUES (?, ?, ?))");
  REQUIRE(q.table_name == "person");
  REQUIRE(q.bind_vars.size() == 3);
}

TEST_CASE("Select sql statement string with order by", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.select({"id", "name", "age"})
          .from("person")
          .order_by("name").asc()
          .compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person" ORDER BY "name" ASC)");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Select sql statement string with group by", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.select({"id", "name", "age"})
          .from("person")
          .group_by("age")
          .compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person" GROUP BY "age")");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Select sql statement string with offset and limit", "[query]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  const auto q = query.select({"id", "name", "age"})
                        .from("person")
                        .offset(10)
                        .limit(20)
                        .compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "age" FROM "person" OFFSET 10 LIMIT 20)");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Create, insert and select a blob column", "[query][blob]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);
  auto q = query.create().table("person", {
    make_pk_column<unsigned long>("id"),
    make_column<std::string>("name", 255),
    make_column<blob>("data")
  }).compile();

  REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "data" BLOB NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
  REQUIRE(q.table_name == "person");

  q = query.insert().into("person", {
    { "id", "name", "data" }
  }).values({7UL, "george", blob{1, 'A', 3, 4}}).compile();

  REQUIRE(q.sql == R"(INSERT INTO "person" ("id", "name", "data") VALUES (7, 'george', X'01410304'))");
  REQUIRE(q.table_name == "person");

  q = query.select({"id", "name", "data"}).from("person").compile();

  REQUIRE(q.sql == R"(SELECT "id", "name", "data" FROM "person")");
  REQUIRE(q.table_name == "person");
}

TEST_CASE("Select statement with join_left", "[query][join_left]") {
  dialect d = dialect_builder::builder().create().build();
  query_builder query(d);

  auto q = query.select({"f.id", "ap.brand", "f.pilot_name"}).from("flight", "f").join("airplane", join_type_t::INNER, "ap").on("f.airplane_id", "ap.id").compile();

  REQUIRE(q.sql == R"(SELECT "f.id", "ap.brand", "f.pilot_name" FROM "flight" AS "f" INNER JOIN "airplane" AS "ap" ON "f.airplane_id"="ap.id")");
  REQUIRE(q.table_name == "flight");
}