Added create_index

tests/postgres/test_create_index.cpp

@@ -0,0 +1,44 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_create_index {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  int age;
+};
+
+TEST(postgres, test_create_index) {
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  const auto people = sqlgen::postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(create_table<Person> | if_not_exists)
+                          .and_then(create_index<"test_table_ix", Person>(
+                                        "first_name"_c, "last_name"_c) |
+                                    if_not_exists)
+                          .and_then(sqlgen::read<std::vector<Person>>)
+                          .value();
+
+  const std::string expected = R"([])";
+
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_create_index
+
+#endif

tests/postgres/test_create_index_dry.cpp

@@ -0,0 +1,27 @@
+#include <gtest/gtest.h>
+
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+
+namespace test_create_index_dry {
+
+struct TestTable {
+  std::string field1;
+  int32_t field2;
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::optional<std::string> nullable;
+};
+
+TEST(postgres, test_create_index_dry) {
+  using namespace sqlgen;
+
+  const auto query =
+      create_index<"test_table_ix", TestTable>("field1"_c, "field2"_c) |
+      if_not_exists;
+
+  const auto expected =
+      R"(CREATE INDEX IF NOT EXISTS "test_table_ix" ON "TestTable"("field1", "field2");)";
+
+  EXPECT_EQ(sqlgen::postgres::to_sql(query), expected);
+}
+}  // namespace test_create_index_dry

tests/postgres/test_create_table.cpp

@@ -0,0 +1,41 @@
+#ifndef SQLGEN_BUILD_DRY_TESTS_ONLY
+
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/postgres.hpp>
+#include <vector>
+
+namespace test_create_table {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  int age;
+};
+
+TEST(postgres, test_create_table) {
+  const auto credentials = sqlgen::postgres::Credentials{.user = "postgres",
+                                                         .password = "password",
+                                                         .host = "localhost",
+                                                         .dbname = "postgres"};
+
+  using namespace sqlgen;
+
+  const auto people = sqlgen::postgres::connect(credentials)
+                          .and_then(drop<Person> | if_exists)
+                          .and_then(create_table<Person> | if_not_exists)
+                          .and_then(sqlgen::read<std::vector<Person>>)
+                          .value();
+
+  const std::string expected = R"([])";
+
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_create_table
+
+#endif

tests/postgres/test_create_table_dry.cpp

@@ -13,7 +13,9 @@ struct TestTable {
 };
 
 TEST(postgres, test_create_table_dry) {
-  const auto query = sqlgen::CreateTable<TestTable>{};
+  using namespace sqlgen;
+
+  const auto query = create_table<TestTable> | if_not_exists;
 
   const auto expected =
       R"(CREATE TABLE IF NOT EXISTS "TestTable" ("field1" TEXT NOT NULL, "field2" INTEGER NOT NULL, "id" INTEGER NOT NULL, "nullable" TEXT, PRIMARY KEY ("id"));)";

tests/sqlite/test_create_index.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <sqlgen.hpp>
+#include <sqlgen/sqlite.hpp>
+#include <vector>
+
+namespace test_create_index {
+
+struct Person {
+  sqlgen::PrimaryKey<uint32_t> id;
+  std::string first_name;
+  std::string last_name;
+  int age;
+};
+
+TEST(sqlite, test_create_index) {
+  using namespace sqlgen;
+
+  const auto people = sqlgen::sqlite::connect()
+                          .and_then(create_table<Person> | if_not_exists)
+                          .and_then(create_index<"person_ix", Person>(
+                                        "first_name"_c, "last_name"_c) |
+                                    if_not_exists)
+                          .and_then(sqlgen::read<std::vector<Person>>);
+
+  const std::string expected = R"([])";
+
+  EXPECT_EQ(rfl::json::write(people), expected);
+}
+
+}  // namespace test_create_index