query/demo/main.cpp

#include "matador/sql/column.hpp"
#include "matador/sql/condition.hpp"
#include "matador/sql/schema.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/entity.hpp"

#include "matador/utils/access.hpp"

#include "query_helper.hpp"

#include <iostream>
#include <string>

struct author
{
  unsigned long id{};
  std::string first_name;
  std::string last_name;
  std::string date_of_birth;
  unsigned short year_of_birth{};
  bool distinguished{false};

  template < typename Operator >
  void process(Operator &op) {
    namespace field = matador::utils::access;
    field::primary_key(op, "id", id);
    field::attribute(op, "first_name", first_name, 63);
    field::attribute(op, "last_name", last_name, 63);
    field::attribute(op, "date_of_birth", date_of_birth, 31);
    field::attribute(op, "year_of_birth", year_of_birth);
    field::attribute(op, "distinguished", distinguished);
  }
};

struct book
{
  unsigned long id{};
  matador::sql::entity<author> book_author;
  std::string title;
  unsigned short published_in{};

  template < typename Operator >
  void process(Operator &op) {
    namespace field = matador::utils::access;
    field::primary_key(op, "id", id);
    field::attribute(op, "title", title, 511);
    field::has_one(op, "author_id", book_author, matador::utils::default_foreign_attributes);
    field::attribute(op, "published_in", published_in);
  }
};

QUERY_HELPER(authors, id, first_name, last_name, date_of_birth, year_of_birth, distinguished)
QUERY_HELPER(books, id, author_id, title, published_in)

int main()
{
  using namespace matador::sql;
  using namespace matador;

  const std::string env_var{"MATADOR_BACKENDS_PATH"};

  std::string dns{"sqlite://demo.db"};
//  std::string dns{"memory://test"};
  auto s = std::make_shared<schema>("main");
  s->attach<author>("authors");
  s->attach<book>("books");

  connection c(dns);
  c.open();

  auto create_authors_sql = c.query(s)
    .create()
    .table<author>(qh::authors)
//    .str();
    .execute();

  c.query(s).create().table<book>(qh::books).execute();

  std::cout << "SQL: " << create_authors_sql << "\n";

  auto mc = make_entity<author>();
  mc->id = 1;
  mc->first_name = "Michael";
  mc->last_name = "Crichton";
  mc->date_of_birth = "19.8.1954";
  mc->year_of_birth = 1954;
  mc->distinguished = true;
  auto insert_authors_sql = c.query(s)
    .insert()
    .into<author>(qh::authors)
    .values(*mc)
    .execute();
//    .str();

  std::cout << "SQL: " << insert_authors_sql << "\n";

  auto result = c.query(s)
    .select<author>()
    .from(qh::authors)
    .fetch_all();

  for (const auto &row : result) {
    std::cout << "Author " << row.at(qh::authors.first_name) << "\n";
  }

  auto update_authors_sql = c.query(s)
    .update(qh::authors)
    .set({{qh::authors.first_name, "Stephen"}, {qh::authors.last_name, "King"}})
    .where(qh::authors.last_name == "Crichton")
    .execute();
//    .str();

  std::cout << "SQL: " << update_authors_sql << "\n";

  auto authors = c.query(s)
    .select<author>()
    .from(qh::authors)
    .fetch_all<author>();

  for (const auto &a : authors) {
    std::cout << "Author " << a.first_name << "\n";
  }

  c.query(s)
    .insert()
    .into<book>(qh::books)
    .values({2, "It", mc->id, 1980})
    .execute();

  c.query(s)
    .insert()
    .into<book>(qh::books)
    .values({3, "Misery", mc->id, 1984})
    .execute();

  auto select_books_sql = c.query(s)
    .select<book>({qh::authors.last_name})
    .from(qh::books)
    .join_left(qh::authors)
    .on(qh::books.author_id == qh::authors.id)
    .where(qh::books.published_in < 2008 && qh::authors.last_name == "King")
    .group_by(qh::books.published_in)
    .order_by(qh::books.title).asc()
//    .offset(2)
//    .limit(5)
//    .str();
    .fetch_all();
//    .fetch_all<book>();

//  std::cout << "SQL: " << select_books_sql << "\n";

  for (const auto &r : select_books_sql) {
    std::cout << "R: " << r.at(qh::books.title) << ", " << r.at(qh::authors.last_name) << "\n";
  }
  // SELECT book.title, book.id, book.author_id, book.published_in, author.name
  // FROM book
  // INNER JOIN author ON book.author_id = author.id
  // WHERE book.published_in < 2008 AND author.name = "Michael Crichton"
  // ORDER BY "book.title" ASC
  // OFFSET 2 LIMIT 5

//  char var[1024];
//  size_t len{};
//  const auto error = getenv_s(&len, var, 1024, env_var.c_str());
//  if (error > 0) {
//    std::cout << "error: unknown env var " << env_var << "\n";
//  } else {
//    std::cout << "env var: " << var << "\n";
//  }

  c.query(s).drop().table(qh::books).execute();

  auto drop_authors_sql = c.query(s)
    .drop()
    .table(qh::authors)
//    .str();
    .execute();

  std::cout << "SQL: " << drop_authors_sql << "\n";

  return 0;
}