ntuple_t.cc File Reference

#include "cetlib/sqlite/ConnectionFactory.h"
#include "cetlib/sqlite/Exception.h"
#include "cetlib/sqlite/Ntuple.h"
#include "cetlib/sqlite/helpers.h"
#include "cetlib/sqlite/select.h"
#include "hep_concurrency/simultaneous_function_spawner.h"
#include "sqlite3.h"
#include <assert.h>
#include <cstring>
#include <functional>
#include <iostream>
#include <vector>

Go to the source code of this file.

Functions
void	test_with_new_database (Connection &c)
void	test_with_matching_table (Connection &c)
template<class... ARGS>
void	test_with_colliding_table (Connection &c, array< string, sizeof...(ARGS)> const &names)
int	count_rows (void *p, int nrows, char **results, char **cnames)
void	test_filling_table (Connection &c)
void	test_parallel_filling_table (Connection &c)
void	test_column_constraint (Connection &c)
void	test_file_create (ConnectionFactory &cf)
int	main ()

Function Documentation

int count_rows	(	void *	p,
		int	nrows,
		char **	results,
		char **	cnames
	)

Definition at line 62 of file ntuple_t.cc.

{
  auto n = static_cast<int*>(p);
  assert(nrows == 1);
  assert(strcmp(cnames[0], "count(*)") == 0);
  *n = stoi(results[0]);
  return 0;
}

int main

(

void

)

Definition at line 151 of file ntuple_t.cc.

           {
  const char* fname{"no_such_file.db"};
  // If there is a database in the directory, delete it.
  remove(fname);

  // Now make a database we are sure is empty.
  ConnectionFactory cf;
  auto c = cf.make_connection(fname);

  test_with_new_database(*c);
  test_with_matching_table(*c);
  test_with_colliding_table<int, double>(*c, {{"y", "txt"}});
  test_with_colliding_table<int, double>(*c, {{"x", "text"}});
  test_with_colliding_table<int, int>(*c, {{"x", "txt"}});
  test_with_colliding_table<int, double, int>(*c, {{"x", "txt", "z"}});
  test_with_colliding_table<int>(*c, {{"x"}});
  test_filling_table(*c);
  test_parallel_filling_table(*c);
  test_column_constraint(*c);
  test_file_create(cf);
}
catch (std::exception const& x) {
  std::cout << x.what() << std::endl;
  return 1;
}
catch (...) {
  std::cout << "Unknown exception caught\n";
  return 2;
}

void test_column_constraint

(

Connection &

c

)

Definition at line 122 of file ntuple_t.cc.

{
  cout << "start test_column_constraint\n";
  assert(c);
  Ntuple<column<int, primary_key>, double> nt{c, "u", {{"i", "x"}}};
  auto const& ref = detail::create_table_ddl(
    "u", column<int, primary_key>{"i"}, column<double>{"x"});
  assert(hasTableWithSchema(c, "u", ref));
  cout << "end test_column_constraint\n";
}

void test_file_create

(

ConnectionFactory &

cf

)

Definition at line 134 of file ntuple_t.cc.

{
  string const filename{"myfile.db"};
  remove(filename.c_str());
  unique_ptr<Connection> c{cf.make_connection(filename)};
  {
    Ntuple<int, double, int> table{*c, "tab1", {{"i", "x", "k"}}, false, 5};
    for (std::size_t i = 0; i < 103; ++i) {
      table.insert(i, 0.5 * i, i * i);
    }
  }
  query_result<int> cnt;
  cnt << select("count(*)").from(*c, "tab1");
  assert(unique_value(cnt) == 103);
}

void test_filling_table

(

Connection &

c

)

Definition at line 72 of file ntuple_t.cc.

{
  cout << "start test_filling_table\n";
  assert(c);
  constexpr int nrows{903};
  {
    Ntuple<int, double> nt{c, "zz", {{"i", "x"}}, false, 100};
    for (int i = 0; i < nrows; ++i) {
      nt.insert(i, 1.5 * i);
    }
  }
  query_result<int> nmatches;
  nmatches << select("count(*)").from(c, "zz");
  // Check that there are 'nrows' rows in the database.
  assert(unique_value(nmatches) == nrows);
  cout << "end test_filling_table\n";
}

void test_parallel_filling_table

(

Connection &

c

)

Definition at line 91 of file ntuple_t.cc.

{
  cout << "start test_parallel_filling_table\n";
  assert(c);
  constexpr int nrows_per_thread{100};
  constexpr unsigned nthreads{10};
  string const tablename{"zz"};
  {
    Ntuple<int, double> nt{c,
                           tablename,
                           {{"i", "x"}},
                           true,
                           60}; // Force flushing after 60 insertions.
    std::vector<std::function<void()>> tasks;
    for (unsigned i{}; i < nthreads; ++i) {
      tasks.emplace_back([i, &nt] {
        for (unsigned j{}; j < nrows_per_thread; ++j) {
          auto const j1 = j + i * 100;
          nt.insert(j1, 1.5 * j1);
        }
      });
    }
    hep::concurrency::simultaneous_function_spawner sfs{tasks};
  }
  query_result<int> nmatches;
  nmatches << select("count(*)").from(c, tablename);
  assert(unique_value(nmatches) == nrows_per_thread * nthreads);
  cout << "end test_parallel_filling_table\n";
}

template<class... ARGS>

void test_with_colliding_table	(	Connection &	c,
		array< string, sizeof...(ARGS)> const &	names
	)

Definition at line 44 of file ntuple_t.cc.

{
  cout << "start test_with_colliding_table\n";
  assert(c);
  try {
    Ntuple<ARGS...> xx{c, "xx", names};
    assert("Failed throw for mismatched table" == nullptr);
  }
  catch (Exception const& x) {
  }
  catch (...) {
    assert("Threw wrong exception for mismatched table" == nullptr);
  }
  cout << "end test_with_colliding_table\n";
}

void test_with_matching_table

(

Connection &

c

)

Definition at line 34 of file ntuple_t.cc.

{
  cout << "start test_with_matching_table\n";
  assert(c);
  Ntuple<double, std::string> xx{c, "xx", {{"x", "txt"}}};
  std::cout << "end test_with_matching_table\n";
}

void test_with_new_database

(

Connection &

c

)

Definition at line 25 of file ntuple_t.cc.

{
  cout << "start test_with_new_database\n";
  assert(c);
  Ntuple<double, std::string> xx{c, "xx", {{"x", "txt"}}};
  std::cout << "end test_with_new_database\n";
}